fix(sync): refresh vscode copilot workspace metadata

VS Code Copilot was provider-aware for workspace.json freshness, but this stack still runs legacy sync writes. Without mirroring that freshness in the legacy process path, metadata-only workspace renames could be classified but then skipped against the unchanged chat transcript.

Move the Copilot IDE providers into shadow compare on their migration branch, preserve .jsonl priority during provider changed-path classification, and store composite workspace freshness for VS Code Copilot sessions while both shapes run.

Validation: go test -tags "fts5" ./internal/sync -run 'TestSyncPathsVSCodeCopilot(JSONLPriority|WorkspaceMetadataRefreshesProject)' -count=1; go test -tags "fts5" ./internal/parser -run 'Test(VSCodeCopilotProvider|VisualStudioCopilotProvider|ProviderMigrationModes)' -count=1; go test -tags "fts5" ./internal/sync -count=1; go test -tags "fts5" ./internal/parser -count=1; go vet ./...; git diff --check

Author: mariusvniekerk

internal/parser/provider_migration.go

@@ -30,8 +30,8 @@ var providerMigrationModes = map[AgentType]ProviderMigrationMode{
 	AgentIflow:          ProviderMigrationShadowCompare,
 	AgentAmp:            ProviderMigrationShadowCompare,
 	AgentZencoder:       ProviderMigrationShadowCompare,
-	AgentVSCodeCopilot:  ProviderMigrationLegacyOnly,
-	AgentVSCopilot:      ProviderMigrationLegacyOnly,
+	AgentVSCodeCopilot:  ProviderMigrationShadowCompare,
+	AgentVSCopilot:      ProviderMigrationShadowCompare,
 	AgentPi:             ProviderMigrationShadowCompare,
 	AgentQwen:           ProviderMigrationShadowCompare,
 	AgentCommandCode:    ProviderMigrationShadowCompare,

internal/parser/vscode_copilot_provider.go

@@ -181,7 +181,7 @@ func (s vscodeCopilotSourceSet) SourcesForChangedPath(
 		if len(sources) > 0 {
 			return sources, nil
 		}
-		source, ok := s.sourceRefForChangedPath(root, req.Path)
+		source, ok := s.sourceRefForChangedPath(root, req)
 		if ok {
 			return []SourceRef{source}, nil
 		}
@@ -322,8 +322,13 @@ func (s vscodeCopilotSourceSet) sourceRef(root, path string) (SourceRef, bool) {
 }
 
 func (s vscodeCopilotSourceSet) sourceRefForChangedPath(
-	root, path string,
+	root string,
+	req ChangedPathRequest,
 ) (SourceRef, bool) {
+	path := req.Path
+	if req.EventKind != "remove" && vscodeCopilotJSONLPreferredOver(path) {
+		return SourceRef{}, false
+	}
 	if source, ok := s.sourceRef(root, path); ok {
 		return source, true
 	}
@@ -471,6 +476,14 @@ func vscodeCopilotPreferredExistingPath(path string) string {
 	return ""
 }
 
+func vscodeCopilotJSONLPreferredOver(path string) bool {
+	base, ok := strings.CutSuffix(path, ".json")
+	if !ok {
+		return false
+	}
+	return IsRegularFile(base + ".jsonl")
+}
+
 func vscodeCopilotSourceHash(path, workspacePath string) (string, error) {
 	hash, err := hashJSONLSourceFile(path)
 	if err != nil {

internal/sync/engine.go

@@ -4350,6 +4350,11 @@ func (e *Engine) processFile(
 		// of staying skipped on the unchanged transcript mtime.
 		mtime = vibeEffectiveInfo(file.Path, info).ModTime().UnixNano()
 	}
+	if file.Agent == parser.AgentVSCodeCopilot {
+		mtime = e.vscodeCopilotEffectiveInfo(file.Path, info).
+			ModTime().
+			UnixNano()
+	}
 	cacheSkip := e.shouldCacheSkip(file)
 
 	// Skip files cached from a previous sync (parse errors
@@ -5865,7 +5870,8 @@ func (e *Engine) processZencoder(
 func (e *Engine) processVSCodeCopilot(
 	file parser.DiscoveredFile, info os.FileInfo,
 ) processResult {
-	if e.shouldSkipByPath(file.Path, info) {
+	effectiveInfo := e.vscodeCopilotEffectiveInfo(file.Path, info)
+	if !file.ForceParse && e.shouldSkipByPath(file.Path, effectiveInfo) {
 		return processResult{skip: true}
 	}
 
@@ -5878,8 +5884,10 @@ func (e *Engine) processVSCodeCopilot(
 	if sess == nil {
 		return processResult{}
 	}
+	sess.File.Size = effectiveInfo.Size()
+	sess.File.Mtime = effectiveInfo.ModTime().UnixNano()
 
-	hash, err := ComputeFileHash(file.Path)
+	hash, err := e.vscodeCopilotCompositeHash(file.Path)
 	if err == nil {
 		sess.File.Hash = hash
 	}
@@ -5895,6 +5903,70 @@ func (e *Engine) processVSCodeCopilot(
 	}
 }
 
+func (e *Engine) vscodeCopilotEffectiveInfo(
+	path string, info os.FileInfo,
+) os.FileInfo {
+	workspacePath := e.vscodeCopilotWorkspaceManifestPath(path)
+	if workspacePath == "" {
+		return info
+	}
+	workspaceInfo, err := os.Stat(workspacePath)
+	if err != nil || workspaceInfo.IsDir() {
+		return info
+	}
+	size := info.Size() + workspaceInfo.Size()
+	mtime := info.ModTime().UnixNano()
+	if workspaceMtime := workspaceInfo.ModTime().UnixNano(); workspaceMtime > mtime {
+		mtime = workspaceMtime
+	}
+	return fakeSnapshotInfo{fSize: size, fMtime: mtime}
+}
+
+func (e *Engine) vscodeCopilotCompositeHash(path string) (string, error) {
+	chatHash, err := ComputeFileHash(path)
+	if err != nil {
+		return "", err
+	}
+	workspacePath := e.vscodeCopilotWorkspaceManifestPath(path)
+	if workspacePath == "" {
+		return chatHash, nil
+	}
+	if info, err := os.Stat(workspacePath); err != nil || info.IsDir() {
+		return chatHash, nil
+	}
+	workspaceHash, err := ComputeFileHash(workspacePath)
+	if err != nil {
+		return "", err
+	}
+	return ComputeHash(strings.NewReader(
+		"chat\x00" + chatHash + "\x00workspace\x00" + workspaceHash,
+	))
+}
+
+func (e *Engine) vscodeCopilotWorkspaceManifestPath(path string) string {
+	path = filepath.Clean(path)
+	for _, root := range e.agentDirs[parser.AgentVSCodeCopilot] {
+		if root == "" {
+			continue
+		}
+		root = filepath.Clean(root)
+		rel, ok := isUnder(root, path)
+		if !ok {
+			continue
+		}
+		parts := strings.Split(filepath.ToSlash(rel), "/")
+		if len(parts) != 4 ||
+			parts[0] != "workspaceStorage" ||
+			parts[2] != "chatSessions" ||
+			(!strings.HasSuffix(parts[3], ".json") &&
+				!strings.HasSuffix(parts[3], ".jsonl")) {
+			continue
+		}
+		return filepath.Join(root, "workspaceStorage", parts[1], "workspace.json")
+	}
+	return ""
+}
+
 func (e *Engine) processOpenClaw(
 	file parser.DiscoveredFile, info os.FileInfo,
 ) processResult {

internal/sync/engine_integration_test.go

@@ -6799,6 +6799,85 @@ func TestSyncPathsVSCodeCopilotJSONLPriority(t *testing.T) {
 	assert.Equal(t, 0, len(page.Sessions), "expected 0 sessions (.json skipped), got %d", len(page.Sessions))
 }
 
+func TestSyncPathsVSCodeCopilotWorkspaceMetadataRefreshesProject(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping integration test")
+	}
+
+	dir := t.TempDir()
+	vscDir := filepath.Join(dir, "vscode")
+	hashDir := filepath.Join(vscDir, "workspaceStorage", "abc123")
+	chatDir := filepath.Join(hashDir, "chatSessions")
+	workspacePath := filepath.Join(hashDir, "workspace.json")
+
+	database := dbtest.OpenTestDB(t)
+	engine := sync.NewEngine(database, sync.EngineConfig{
+		AgentDirs: map[parser.AgentType][]string{
+			parser.AgentVSCodeCopilot: {vscDir},
+		},
+		Machine: "local",
+	})
+
+	writeWorkspace := func(name string) {
+		t.Helper()
+		dbtest.WriteTestFile(t, workspacePath, fmt.Appendf(nil,
+			`{"folder":"file:///Users/alice/code/%s"}`,
+			name,
+		))
+	}
+
+	uuid := "bbbbbbbb-cccc-dddd-eeee-ffffffffffff"
+	session := fmt.Sprintf(
+		`{"version":1,"sessionId":"%s",`+
+			`"creationDate":1704103200000,`+
+			`"lastMessageDate":1704103260000,`+
+			`"requests":[{"requestId":"r1",`+
+			`"message":{"text":"hello"},`+
+			`"response":[{"value":"hi"}],`+
+			`"timestamp":1704103200000}]}`,
+		uuid,
+	)
+	jsonlPath := filepath.Join(chatDir, uuid+".jsonl")
+
+	writeWorkspace("one")
+	dbtest.WriteTestFile(
+		t, jsonlPath,
+		[]byte(`{"kind":0,"v":`+session+`}`),
+	)
+
+	engine.SyncPaths([]string{jsonlPath})
+	assertSessionState(
+		t, database, "vscode-copilot:"+uuid,
+		func(sess *db.Session) {
+			assert.Equal(t, "one", sess.Project)
+		},
+	)
+
+	info, err := os.Stat(jsonlPath)
+	require.NoError(t, err, "stat vscode copilot session")
+	engine.InjectSkipCache(map[string]int64{
+		jsonlPath: info.ModTime().UnixNano(),
+	})
+
+	writeWorkspace("two")
+	engine.SyncPaths([]string{workspacePath})
+	assertSessionState(
+		t, database, "vscode-copilot:"+uuid,
+		func(sess *db.Session) {
+			assert.Equal(t, "two", sess.Project)
+		},
+	)
+
+	writeWorkspace("three")
+	engine.SyncPaths([]string{jsonlPath, workspacePath})
+	assertSessionState(
+		t, database, "vscode-copilot:"+uuid,
+		func(sess *db.Session) {
+			assert.Equal(t, "three", sess.Project)
+		},
+	)
+}
+
 func TestPiSessionIntegration(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping integration test")