fix(sync): respect sidecar relevance and preserve metadata wakeups

Author: rodboev

internal/parser/opencode_change_feed.go

@@ -601,14 +601,13 @@ func DrainOpenCodeJournal(
 			}
 
 		case "session.updated.1", "session.created.1":
-			// Recognized lifecycle events: note session existence, no state change.
+			// Session metadata is durable source state, so apply it at the end
+			// of this drain even when no settlement-bearing message exists.
 			if len(status) >= OpenCodeCoverageMaxIDs && !hasID(status, m.AggregateID) {
 				auditRequired = true
 				break
 			}
-			if _, exists := status[m.AggregateID]; !exists {
-				status[m.AggregateID] = openCodeStatusPending
-			}
+			status[m.AggregateID] = openCodeStatusReady
 
 		default:
 			// Unrecognized event type or version: latch audit.
@@ -752,9 +751,7 @@ func ReduceOpenCodeJournalEvents(
 			if len(status) >= OpenCodeCoverageMaxIDs && !hasID(status, e.AggregateID) {
 				return next, true
 			}
-			if _, exists := status[e.AggregateID]; !exists {
-				status[e.AggregateID] = openCodeStatusPending
-			}
+			status[e.AggregateID] = openCodeStatusReady
 
 		default:
 			return next, true

internal/parser/opencode_change_feed_test.go

@@ -303,6 +303,20 @@ func TestOpenCodeSettlementField(t *testing.T) {
 		"assistant without completed must be pending")
 }
 
+func TestOpenCodeSessionMetadataEventIsReady(t *testing.T) {
+	cp, audit := ReduceOpenCodeJournalEvents(
+		OpenCodeCoverageCheckpoint{},
+		[]OpenCodeJournalEventInput{{
+			RowID: 1, EventID: "session-update", AggregateID: "ses-metadata",
+			Type: "session.updated.1",
+		}},
+	)
+	assert.False(t, audit)
+	assert.Contains(t, cp.ReadyIDs, "ses-metadata",
+		"durable session metadata must reach the archive even without a settlement event")
+	assert.NotContains(t, cp.PendingIDs, "ses-metadata")
+}
+
 // TestOpenCodeTrailingEventsDoNotDowngrade verifies proof matrix row 4:
 // trailing events do not downgrade. A reference-model sequence of settlement
 // followed by a message.updated.1 and then session.updated.1 leaves the

internal/sync/opencode_coverage_coordinator.go

@@ -50,9 +50,21 @@ func (e *Engine) wakeOpenCodePaths(
 		}
 		keys = uniqueCoverageKeys(keys)
 		if len(keys) > 0 {
+			missing := false
 			for _, key := range keys {
+				if !e.opencodeCoverage.pathRelevant(ctx, key, path) {
+					continue
+				}
+				if _, err := os.Stat(key.DBPath); errors.Is(err, os.ErrNotExist) {
+					e.opencodeCoverage.retire(key)
+					missing = true
+					continue
+				}
 				e.opencodeCoverage.wake(key, reasonNative)
 			}
+			if missing {
+				remaining = append(remaining, path)
+			}
 			continue
 		}
 		remaining = append(remaining, path)
@@ -178,6 +190,31 @@ func (c *openCodeCoverageCoordinator) provider(agent parser.AgentType) parser.Pr
 	return provider
 }
 
+func (c *openCodeCoverageCoordinator) pathRelevant(
+	ctx context.Context, key openCodeCoverageKey, path string,
+) bool {
+	c.mu.RLock()
+	provider := c.providers[key.Agent]
+	c.mu.RUnlock()
+	if provider == nil {
+		if c.engine == nil {
+			return true
+		}
+		provider = c.provider(key.Agent)
+	}
+	if provider == nil {
+		return true
+	}
+	physical := path
+	if idx := strings.LastIndex(path, "#"); idx > 0 {
+		physical = path[:idx]
+	}
+	relevance, err := parser.ResolveChangedPathRelevance(
+		ctx, provider, parser.ChangedPathRequest{Path: physical},
+	)
+	return err != nil || relevance != parser.ChangedPathNonData
+}
+
 // Initialize registers and baselines every schema-admitted OpenCode-family
 // SQLite unit. It must run before startup reconciliation so the baseline keeps
 // events committed during startup visible to the first wake.

internal/sync/opencode_coverage_coordinator_test.go

@@ -5,6 +5,7 @@ import (
 	"database/sql"
 	"os"
 	"path/filepath"
+	"strings"
 	"sync/atomic"
 	"testing"
 	"time"
@@ -54,7 +55,7 @@ func TestOpenCodeLateContainerAdmissionUsesJournalEvidence(t *testing.T) {
 	require.Len(t, keys, 1)
 	assert.True(t, engine.opencodeCoverage.worker.unit(keys[0]).committedCheckpoint().Initialized,
 		"runtime admission must use the row-zero origin, not the baseline sentinel")
-	require.True(t, engine.wakeOpenCodePath(t.Context(), dbPath+"-wal"))
+	require.True(t, engine.wakeOpenCodePath(t.Context(), dbPath))
 	key, admitted := engine.opencodeCoverage.keyForPath(dbPath)
 	require.True(t, admitted)
 	assert.Equal(t, parser.AgentOpenCode, key.Agent)
@@ -66,6 +67,7 @@ func TestOpenCodeLateContainerAdmissionUsesJournalEvidence(t *testing.T) {
 
 func TestOpenCodeWakePathWakesEveryOverlappingUnit(t *testing.T) {
 	dbPath := filepath.Join(t.TempDir(), "opencode.db")
+	require.NoError(t, os.WriteFile(dbPath, nil, 0o644))
 	first := openCodeCoverageKey{Agent: parser.AgentOpenCode, DBPath: dbPath}
 	second := openCodeCoverageKey{Agent: parser.AgentKilo, DBPath: dbPath}
 	var wakes atomic.Int32
@@ -90,6 +92,80 @@ func TestOpenCodeWakePathWakesEveryOverlappingUnit(t *testing.T) {
 	c.stop()
 }
 
+type coverageRelevanceProvider struct {
+	parser.ProviderBase
+}
+
+func (p *coverageRelevanceProvider) Parse(
+	context.Context, parser.ParseRequest,
+) (parser.ParseOutcome, error) {
+	return parser.ParseOutcome{}, nil
+}
+
+func (p *coverageRelevanceProvider) ChangedPathRelevance(
+	_ context.Context, req parser.ChangedPathRequest,
+) (parser.ChangedPathRelevance, error) {
+	if strings.HasSuffix(req.Path, "-shm") {
+		return parser.ChangedPathNonData, nil
+	}
+	if strings.HasSuffix(req.Path, "-wal") {
+		return parser.ChangedPathNonData, nil
+	}
+	return parser.ChangedPathDataBearing, nil
+}
+
+func TestOpenCodeWakePathHonorsSidecarRelevance(t *testing.T) {
+	dbPath := filepath.Join(t.TempDir(), "opencode.db")
+	require.NoError(t, os.WriteFile(dbPath, nil, 0o644))
+	key := openCodeCoverageKey{Agent: parser.AgentOpenCode, DBPath: dbPath}
+	var wakes atomic.Int32
+	c := &openCodeCoverageCoordinator{
+		units: map[openCodeCoverageKey]struct{}{key: {}},
+		providers: map[parser.AgentType]parser.Provider{
+			parser.AgentOpenCode: &coverageRelevanceProvider{
+				ProviderBase: parser.ProviderBase{Caps: parser.Capabilities{
+					Source: parser.SourceCapabilities{
+						ChangedPathRelevance: parser.CapabilitySupported,
+					},
+				}},
+			},
+		},
+	}
+	c.worker = newOpenCodeCoverageWorker(t.Context(), nil, nil)
+	c.worker.drain = func(
+		context.Context, string, parser.OpenCodeCoverageCheckpoint,
+	) (parser.OpenCodeFeedResult, error) {
+		wakes.Add(1)
+		return parser.OpenCodeFeedResult{
+			Next: parser.OpenCodeCoverageCheckpoint{Initialized: true},
+		}, nil
+	}
+	c.worker.Register(key)
+	e := &Engine{opencodeCoverage: c}
+
+	assert.Empty(t, e.wakeOpenCodePaths(t.Context(), []string{dbPath + "-shm"}))
+	assert.Empty(t, e.wakeOpenCodePaths(t.Context(), []string{dbPath + "-wal"}))
+	assert.Zero(t, wakes.Load(), "non-data sidecars must not wake coverage")
+	assert.Empty(t, e.wakeOpenCodePaths(t.Context(), []string{dbPath}))
+	assert.Eventually(t, func() bool { return wakes.Load() == 1 }, time.Second, time.Millisecond)
+	c.stop()
+}
+
+func TestOpenCodeWatcherDeletedUnitReturnsPathToNormalSync(t *testing.T) {
+	dbPath := filepath.Join(t.TempDir(), "opencode.db")
+	key := openCodeCoverageKey{Agent: parser.AgentOpenCode, DBPath: dbPath}
+	c := &openCodeCoverageCoordinator{
+		units:  map[openCodeCoverageKey]struct{}{key: {}},
+		worker: newOpenCodeCoverageWorker(t.Context(), nil, nil),
+	}
+	c.worker.Register(key)
+	e := &Engine{opencodeCoverage: c}
+
+	assert.Equal(t, []string{dbPath}, e.wakeOpenCodePaths(t.Context(), []string{dbPath}))
+	assert.Empty(t, c.keysForPath(dbPath), "deleted units must be retired before normal processing")
+	c.stop()
+}
+
 func TestOpenCodeDeletedUnitLeavesRootForAuthoritativeReconciliation(t *testing.T) {
 	root := t.TempDir()
 	key := openCodeCoverageKey{
@@ -110,6 +186,7 @@ func TestOpenCodeDeletedUnitLeavesRootForAuthoritativeReconciliation(t *testing.
 
 func TestSyncPathsDivertsAdmittedContainerToWake(t *testing.T) {
 	dbPath := filepath.Join(t.TempDir(), "opencode.db")
+	require.NoError(t, os.WriteFile(dbPath, nil, 0o644))
 	key := openCodeCoverageKey{Agent: parser.AgentOpenCode, DBPath: dbPath}
 	var wakes atomic.Int32
 	c := &openCodeCoverageCoordinator{