fix(codebuff): timestamp rollover, incremental cutoff, and bounded work test

1. Timestamp rollover: Track prevHour only for time-only timestamps.
   Reset prevHour when a non-time-only timestamp is encountered to
   prevent cross-format rollover errors.

2. Incremental cutoff: Added stat-only composite for Codebuff in
   discoveredFileEffectiveMtime. This prevents the full fingerprint
   from being computed for every session during incremental sync.

3. Bounded work test: Added TestSyncAllCodebuffBoundedPerEventWork that
   verifies unchanged sessions are skipped without reading transcript
   bytes, and only modified sessions trigger a reparse.

Author: scross01

internal/sync/codebuff_integration_test.go

@@ -0,0 +1,98 @@
+package sync_test
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"go.kenn.io/agentsview/internal/dbtest"
+	"go.kenn.io/agentsview/internal/parser"
+	"go.kenn.io/agentsview/internal/sync"
+)
+
+// writeCodebuffTestFiles creates the three files that make up a Codebuff
+// session directory: chat-messages.json, run-state.json, and chat-meta.json.
+func writeCodebuffTestFiles(t *testing.T, dir, content string) {
+	t.Helper()
+	chatPath := filepath.Join(dir, "chat-messages.json")
+	runStatePath := filepath.Join(dir, "run-state.json")
+	chatMetaPath := filepath.Join(dir, "chat-meta.json")
+
+	require.NoError(t, os.WriteFile(chatPath, []byte(`[
+		{"id":"user-1","variant":"user","content":"`+content+`","timestamp":"03:04 PM"}
+	]`), 0o644))
+	require.NoError(t, os.WriteFile(runStatePath, []byte(`{
+		"sessionState": {
+			"mainAgentState": {"agentType": "base2-free-deepseek"}
+		}
+	}`), 0o644))
+	require.NoError(t, os.WriteFile(chatMetaPath, []byte(`{
+		"messageCount": 1,
+		"firstPrompt": "`+content+`",
+		"messagesSize": 50
+	}`), 0o644))
+}
+
+// TestSyncAllCodebuffBoundedPerEventWork verifies that unchanged Codebuff
+// sessions are skipped during reconciliation without reading transcript
+// bytes. The stat-only freshness gate (providerSourceFreshBeforeFingerprint)
+// should prevent the fingerprint from being called for unchanged sources.
+func TestSyncAllCodebuffBoundedPerEventWork(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping integration test")
+	}
+
+	// Create a small archive with 3 sessions under 2 projects.
+	root := t.TempDir()
+	projects := []string{"project-a", "project-b"}
+	sessionTimestamps := []string{
+		"2026-07-15T10-00-00.000Z",
+		"2026-07-15T11-00-00.000Z",
+		"2026-07-15T12-00-00.000Z",
+	}
+
+	for _, project := range projects {
+		for _, ts := range sessionTimestamps {
+			dir := filepath.Join(root, project, "chats", ts)
+			require.NoError(t, os.MkdirAll(dir, 0o755))
+			writeCodebuffTestFiles(t, dir, "Hello from "+project+"/"+ts)
+		}
+	}
+
+	database := dbtest.OpenTestDB(t)
+	engine := sync.NewEngine(database, sync.EngineConfig{
+		AgentDirs: map[parser.AgentType][]string{
+			parser.AgentCodebuff: {root},
+		},
+		Machine: "local",
+	})
+
+	// First sync: all sessions should be parsed.
+	synced := engine.SyncAll(context.Background(), nil).Synced
+	assert.Equal(t, 6, synced, "first sync should parse all 6 sessions")
+
+	// Second sync with no changes: all sessions should be skipped.
+	synced = engine.SyncAll(context.Background(), nil).Synced
+	assert.Equal(t, 0, synced, "second sync with no changes should skip all sessions")
+
+	// Modify one session's chat-messages.json.
+	modifiedDir := filepath.Join(root, projects[0], "chats", sessionTimestamps[0])
+	modifiedChatPath := filepath.Join(modifiedDir, "chat-messages.json")
+	require.NoError(t, os.WriteFile(modifiedChatPath, []byte(`[
+		{"id":"user-1","variant":"user","content":"Modified message","timestamp":"03:04 PM"}
+	]`), 0o644))
+
+	// Touch the file to ensure mtime changes.
+	time.Sleep(10 * time.Millisecond)
+	now := time.Now()
+	require.NoError(t, os.Chtimes(modifiedChatPath, now, now))
+
+	// Third sync: only the modified session should be reparsed.
+	synced = engine.SyncAll(context.Background(), nil).Synced
+	assert.Equal(t, 1, synced, "third sync should only reparse the modified session")
+}

internal/sync/engine.go

@@ -5317,13 +5317,35 @@ func (e *Engine) discoveredFileEffectiveMtime(
 		}
 		return mtime, nil
 	}
+	// Codebuff is excluded from the provider-Fingerprint path for
+	// cost: its Fingerprint content-hashes chat-messages.json plus
+	// run-state.json and chat-meta.json, so consulting it here would
+	// read every session's full transcript on each incremental sync,
+	// scaling cutoff filtering with the archive instead of the changed
+	// batch. The stat-only composite carries the same cutoff signal —
+	// the max mtime of all three files — so a companion-only change
+	// still looks fresh. Sources that pass the cutoff go on to the full
+	// fingerprint as usual.
+	if file.Agent == parser.AgentCodebuff {
+		info, err := os.Stat(file.Path)
+		if err != nil {
+			return 0, err
+		}
+		mtime := info.ModTime().UnixNano()
+		dir := filepath.Dir(file.Path)
+		for _, name := range []string{"run-state.json", "chat-meta.json"} {
+			companion := filepath.Join(dir, name)
+			if ci, err := os.Stat(companion); err == nil {
+				if ts := ci.ModTime().UnixNano(); ts > mtime {
+					mtime = ts
+				}
+			}
+		}
+		return mtime, nil
+	}
 	// Provider-authoritative sources resolve freshness through the provider
 	// Fingerprint so composite provider-owned source state participates in
-	// incremental-sync cutoff checks. Codebuff uses the provider-Fingerprint
-	// path because it is hash-sensitive (providerFingerprintHashInCacheKey)
-	// and the stat-only shortcut would miss same-size rewrites with preserved
-	// mtimes. The providerSourceFreshBeforeFingerprint check handles the
-	// stat-only optimization for unchanged sessions before the full fingerprint.
+	// incremental-sync cutoff checks.
 	if file.ProviderSource != nil && file.ProviderProcess {
 		if mtime, ok, err := e.providerSourceMtime(ctx, file); err != nil {
 			return 0, err