fix(snapshot): debounce LastAccessedAt touch + finalize-time stamp on Create

- lookupRecord: read first via store.With, only escalate to store.Update when
  prior touch is older than accessTouchDebounce (1 minute). Hot paths (clone
  DataDir, Export which calls DataDir twice in the gzip/tar path) used to take
  the exclusive flock + rewrite the entire index JSON every call.
- Create: stamp LastAccessedAt at finalize via a fresh time.Now() instead of
  the now captured before tar extraction so freshly-finished snapshots don't
  look minutes old to --snapshot-age right after Create returns.

Author: CMGS

snapshot/localfile/localfile.go

@@ -21,7 +21,10 @@ import (
 	"github.com/cocoonstack/cocoon/utils"
 )
 
-const typ = "localfile"
+const (
+	typ                 = "localfile"
+	accessTouchDebounce = time.Minute
+)
 
 // compile-time interface checks.
 var (
@@ -124,14 +127,15 @@ func (lf *LocalFile) Create(ctx context.Context, cfg *types.SnapshotConfig, stre
 	if sizeErr != nil {
 		return "", fmt.Errorf("compute data dir size: %w", sizeErr)
 	}
+	finalizedAt := time.Now()
 	if err = lf.store.Update(ctx, func(idx *snapshot.SnapshotIndex) error {
 		rec := idx.Snapshots[id]
 		if rec == nil {
 			return fmt.Errorf("snapshot %q disappeared from index", id)
 		}
 		rec.Pending = false
 		rec.SizeBytes = size
-		rec.LastAccessedAt = now
+		rec.LastAccessedAt = finalizedAt
 		return nil
 	}); err != nil {
 		return "", fmt.Errorf("finalize snapshot: %w", err)
@@ -224,10 +228,11 @@ func (lf *LocalFile) rollbackCreate(ctx context.Context, id, name string) {
 	}
 }
 
-// lookupRecord resolves ref to a non-pending record; touch=true also bumps LastAccessedAt under the same write lock.
+// lookupRecord resolves ref to a non-pending record; touch=true bumps LastAccessedAt only when the prior touch is older than accessTouchDebounce so hot paths (clone DataDir, Export) don't serialize on the index write lock.
 func (lf *LocalFile) lookupRecord(ctx context.Context, ref string, touch bool) (snapshot.SnapshotRecord, error) {
 	var rec snapshot.SnapshotRecord
-	apply := func(idx *snapshot.SnapshotIndex) error {
+	var resolvedID string
+	if err := lf.store.With(ctx, func(idx *snapshot.SnapshotIndex) error {
 		id, err := idx.Resolve(ref)
 		if err != nil {
 			return err
@@ -236,16 +241,27 @@ func (lf *LocalFile) lookupRecord(ctx context.Context, ref string, touch bool) (
 		if r == nil || r.Pending {
 			return snapshot.ErrNotFound
 		}
-		if touch {
-			r.LastAccessedAt = time.Now()
-		}
+		resolvedID = id
 		rec = *r
 		return nil
+	}); err != nil {
+		return rec, err
+	}
+	if !touch || time.Since(rec.LastAccessedAt) < accessTouchDebounce {
+		return rec, nil
 	}
-	if touch {
-		return rec, lf.store.Update(ctx, apply)
+	if err := lf.store.Update(ctx, func(idx *snapshot.SnapshotIndex) error {
+		r := idx.Snapshots[resolvedID]
+		if r == nil || r.Pending {
+			return nil
+		}
+		r.LastAccessedAt = time.Now()
+		rec.LastAccessedAt = r.LastAccessedAt
+		return nil
+	}); err != nil {
+		log.WithFunc("localfile.lookupRecord").Warnf(ctx, "touch LastAccessedAt for %s: %v", resolvedID, err)
 	}
-	return rec, lf.store.With(ctx, apply)
+	return rec, nil
 }
 
 // snapshotRecordToConfig builds a detached SnapshotConfig from a record,