fix(sync): apply hermes archive fingerprints consistently

Hermes archive refresh paths need to compare and persist the same aggregate fingerprint for state.db plus sibling transcripts. Otherwise cached parse skips and single-session refreshes can fall back to raw state.db metadata and miss transcript-only archive changes.

Use the aggregate archive file info before generic skip-cache checks and share the archive parse-and-stamp helper between full archive processing and single-session refreshes. The regression coverage now persists the metadata, checks unchanged archive skips, and covers transcript discovery/removal behavior.

Validation: go test -tags "fts5" ./internal/sync -run 'TestHermesArchive|TestProcessFileHermes|TestProcessHermesArchive|TestSyncSingleHermesArchive' -count=1; go test -tags "fts5" ./internal/parser ./internal/sync; go vet ./...; make nilaway

Author: mariusvniekerk

internal/sync/engine.go

@@ -4316,6 +4316,9 @@ func (e *Engine) processFile(
 			err: fmt.Errorf("stat %s: %w", file.Path, err),
 		}
 	}
+	if file.Agent == parser.AgentHermes {
+		info = hermesArchiveEffectiveInfo(file.Path, info)
+	}
 
 	// Capture mtime once from the initial stat so all
 	// downstream cache operations use a consistent value.
@@ -6385,25 +6388,16 @@ func (e *Engine) processCortex(
 func (e *Engine) processHermes(
 	file parser.DiscoveredFile, info os.FileInfo,
 ) processResult {
-	if filepath.Base(file.Path) == "state.db" {
-		info = hermesArchiveEffectiveInfo(file.Path, info)
-	}
+	info = hermesArchiveEffectiveInfo(file.Path, info)
 	if e.shouldSkipByPath(file.Path, info) {
 		return processResult{skip: true}
 	}
 
 	if filepath.Base(file.Path) == "state.db" {
-		results, err := parser.ParseHermesArchive(
-			file.Path, file.Project, e.machine,
-		)
+		results, err := e.parseHermesArchive(file.Path, file.Project, info)
 		if err != nil {
 			return processResult{err: err}
 		}
-		for i := range results {
-			results[i].Session.File.Path = file.Path
-			results[i].Session.File.Size = info.Size()
-			results[i].Session.File.Mtime = info.ModTime().UnixNano()
-		}
 		return processResult{results: results, forceReplace: true}
 	}
 
@@ -6429,7 +6423,37 @@ func (e *Engine) processHermes(
 	}
 }
 
+func (e *Engine) parseHermesArchive(
+	stateDB, project string, info os.FileInfo,
+) ([]parser.ParseResult, error) {
+	info = hermesArchiveEffectiveInfo(stateDB, info)
+	results, err := parser.ParseHermesArchive(
+		stateDB, project, e.machine,
+	)
+	if err != nil {
+		return nil, err
+	}
+	stampHermesArchiveResults(stateDB, info, results)
+	return results, nil
+}
+
+func stampHermesArchiveResults(
+	stateDB string, info os.FileInfo, results []parser.ParseResult,
+) {
+	for i := range results {
+		results[i].Session.File.Path = stateDB
+		results[i].Session.File.Size = info.Size()
+		results[i].Session.File.Mtime = info.ModTime().UnixNano()
+	}
+}
+
 func hermesArchiveEffectiveInfo(path string, info os.FileInfo) os.FileInfo {
+	if info == nil {
+		return info
+	}
+	if _, ok := info.(fakeSnapshotInfo); ok {
+		return info
+	}
 	_, sessionsDir, ok := hermesArchiveSourcePaths(path)
 	if !ok {
 		return info
@@ -9269,9 +9293,11 @@ func (e *Engine) syncSingleHermesArchive(
 		return false, nil
 	}
 
-	results, err := parser.ParseHermesArchive(
-		stateDB, project, e.machine,
-	)
+	info, err := os.Stat(stateDB)
+	if err != nil {
+		return true, fmt.Errorf("stat %s: %w", stateDB, err)
+	}
+	results, err := e.parseHermesArchive(stateDB, project, info)
 	if err != nil {
 		return true, err
 	}

internal/sync/hermes_archive_test.go

@@ -1,6 +1,7 @@
 package sync
 
 import (
+	"context"
 	"database/sql"
 	"os"
 	"path/filepath"
@@ -35,6 +36,76 @@ func TestHermesArchiveEffectiveInfoIncludesDirectTranscripts(t *testing.T) {
 	assert.Equal(t, transcriptTime.UnixNano(), got.ModTime().UnixNano())
 }
 
+func TestHermesArchiveTranscriptFilesUsesDirectSessionFiles(t *testing.T) {
+	sessionsDir := t.TempDir()
+	writeFile := func(name string) {
+		t.Helper()
+		path := filepath.Join(sessionsDir, name)
+		require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
+		require.NoError(t, os.WriteFile(path, []byte("{}\n"), 0o644))
+	}
+	writeFile("extra.jsonl")
+	writeFile("session_child.json")
+	writeFile("child.json")
+	writeFile("session_child.txt")
+	writeFile(filepath.Join("nested", "session_nested.json"))
+
+	got := hermesArchiveTranscriptFiles(sessionsDir)
+
+	assert.Equal(t, []string{
+		filepath.Join(sessionsDir, "extra.jsonl"),
+		filepath.Join(sessionsDir, "session_child.json"),
+	}, got)
+}
+
+func TestHermesArchiveEffectiveInfoChangesWhenTranscriptRemoved(t *testing.T) {
+	root := t.TempDir()
+	stateDB := writeHermesArchiveStateDB(t, root)
+	transcriptPath := filepath.Join(root, "sessions", "extra.jsonl")
+	require.NoError(t, os.MkdirAll(filepath.Dir(transcriptPath), 0o755))
+	require.NoError(t, os.WriteFile(transcriptPath, []byte("{}\n{}\n"), 0o644))
+
+	stateInfo, err := os.Stat(stateDB)
+	require.NoError(t, err)
+	before := hermesArchiveEffectiveInfo(stateDB, stateInfo)
+
+	require.NoError(t, os.Remove(transcriptPath))
+	after := hermesArchiveEffectiveInfo(stateDB, stateInfo)
+
+	assert.NotEqual(t, before.Size(), after.Size())
+	assert.Equal(t, stateInfo.Size(), after.Size())
+}
+
+func TestProcessFileHermesArchiveSkipCacheUsesAggregateMtime(t *testing.T) {
+	root := t.TempDir()
+	stateDB := writeHermesArchiveStateDB(t, root)
+	transcriptPath := filepath.Join(root, "sessions", "extra.jsonl")
+	require.NoError(t, os.MkdirAll(filepath.Dir(transcriptPath), 0o755))
+	require.NoError(t, os.WriteFile(transcriptPath, []byte("{}\n"), 0o644))
+	transcriptTime := time.Now().Add(2 * time.Second).Truncate(time.Second)
+	require.NoError(t, os.Chtimes(transcriptPath, transcriptTime, transcriptTime))
+
+	engine := NewEngine(dbtest.OpenTestDB(t), EngineConfig{
+		AgentDirs: map[parser.AgentType][]string{
+			parser.AgentHermes: {filepath.Join(root, "sessions")},
+		},
+		Machine: "local",
+	})
+	engine.InjectSkipCache(map[string]int64{
+		stateDB: transcriptTime.UnixNano(),
+	})
+
+	res := engine.processFile(context.Background(), parser.DiscoveredFile{
+		Path:  stateDB,
+		Agent: parser.AgentHermes,
+	})
+
+	require.NoError(t, res.err)
+	assert.True(t, res.skip)
+	assert.True(t, res.cacheSkip)
+	assert.Equal(t, transcriptTime.UnixNano(), res.mtime)
+}
+
 func TestProcessHermesArchivePersistsAggregateFingerprint(t *testing.T) {
 	root := t.TempDir()
 	stateDB := writeHermesArchiveStateDB(t, root)
@@ -52,7 +123,8 @@ func TestProcessHermesArchivePersistsAggregateFingerprint(t *testing.T) {
 	stateInfo, err := os.Stat(stateDB)
 	require.NoError(t, err)
 	effectiveInfo := hermesArchiveEffectiveInfo(stateDB, stateInfo)
-	engine := NewEngine(dbtest.OpenTestDB(t), EngineConfig{
+	database := dbtest.OpenTestDB(t)
+	engine := NewEngine(database, EngineConfig{
 		AgentDirs: map[parser.AgentType][]string{
 			parser.AgentHermes: {filepath.Join(root, "sessions")},
 		},
@@ -71,6 +143,65 @@ func TestProcessHermesArchivePersistsAggregateFingerprint(t *testing.T) {
 		assert.Equal(t, effectiveInfo.Size(), result.Session.File.Size)
 		assert.Equal(t, effectiveInfo.ModTime().UnixNano(), result.Session.File.Mtime)
 	}
+
+	pending := make([]pendingWrite, 0, len(res.results))
+	for _, result := range res.results {
+		pending = append(pending, pendingWrite{
+			sess:        result.Session,
+			msgs:        result.Messages,
+			usageEvents: result.UsageEvents,
+		})
+	}
+	written, _, failed := engine.writeBatch(pending, syncWriteDefault, true)
+	require.Equal(t, 0, failed)
+	require.NotZero(t, written)
+
+	storedSize, storedMtime, ok := database.GetFileInfoByPath(stateDB)
+	require.True(t, ok)
+	assert.Equal(t, effectiveInfo.Size(), storedSize)
+	assert.Equal(t, effectiveInfo.ModTime().UnixNano(), storedMtime)
+
+	second := engine.processHermes(parser.DiscoveredFile{
+		Path:  stateDB,
+		Agent: parser.AgentHermes,
+	}, stateInfo)
+	require.NoError(t, second.err)
+	assert.True(t, second.skip)
+}
+
+func TestSyncSingleHermesArchivePersistsAggregateFingerprint(t *testing.T) {
+	root := t.TempDir()
+	stateDB := writeHermesArchiveStateDB(t, root)
+	transcriptPath := filepath.Join(root, "sessions", "extra.jsonl")
+	require.NoError(t, os.MkdirAll(filepath.Dir(transcriptPath), 0o755))
+	require.NoError(t, os.WriteFile(
+		transcriptPath,
+		[]byte(
+			`{"role":"session_meta","platform":"cli","timestamp":"2026-05-14T10:00:00.000000"}`+"\n"+
+				`{"role":"user","content":"new transcript","timestamp":"2026-05-14T10:01:00.000000"}`+"\n",
+		),
+		0o644,
+	))
+
+	stateInfo, err := os.Stat(stateDB)
+	require.NoError(t, err)
+	effectiveInfo := hermesArchiveEffectiveInfo(stateDB, stateInfo)
+	database := dbtest.OpenTestDB(t)
+	engine := NewEngine(database, EngineConfig{
+		AgentDirs: map[parser.AgentType][]string{
+			parser.AgentHermes: {filepath.Join(root, "sessions")},
+		},
+		Machine: "local",
+	})
+
+	ok, err := engine.syncSingleHermesArchive("hermes:child", transcriptPath, "")
+	require.NoError(t, err)
+	require.True(t, ok)
+
+	storedSize, storedMtime, found := database.GetFileInfoByPath(stateDB)
+	require.True(t, found)
+	assert.Equal(t, effectiveInfo.Size(), storedSize)
+	assert.Equal(t, effectiveInfo.ModTime().UnixNano(), storedMtime)
 }
 
 func writeHermesArchiveStateDB(t *testing.T, root string) string {