fix(sync): queue attempted hierarchy repairs

A full session write persists parser-derived parent provenance before its later stages complete. If one of those stages fails, outgoing-edge discovery cannot find the attempted session through an incoming spawn edge, so its effective parent can remain stale.

Durably seed repair with each session before starting its write so deferred reconciliation covers both the session itself and any children its committed messages introduce.

Author: wesm

internal/sync/engine.go

@@ -13480,6 +13480,18 @@ func (e *Engine) SyncSingleSessionContext(
 			needsRetry:   res.needsRetryForSession(pr.Session.ID),
 			forceReplace: res.forceReplace,
 		}
+		// The session upsert commits parser-derived parent provenance before
+		// the later content, usage, and completion stages. Queue the attempted
+		// session itself first so a failure after that upsert still re-resolves
+		// its incoming spawn edges in the deferred repair pass.
+		if err := e.db.QueueSubagentParentRepairs(
+			[]string{resultIDs[i]},
+		); err != nil {
+			return fmt.Errorf(
+				"queue attempted session parent repair: %w", err,
+			)
+		}
+		repairQueued = true
 		writeErr := e.writeSessionFull(write)
 		// Full-write stages commit independently. Message content (and a new
 		// spawn edge) can persist even when a later usage, data-version, or

internal/sync/provider_process_test.go

@@ -537,6 +537,73 @@ func TestSyncSingleSessionPartialFullWritesQueueNewChild(t *testing.T) {
 	}
 }
 
+func TestSyncSingleSessionPartialFullWriteRepairsAttemptedSession(t *testing.T) {
+	root := t.TempDir()
+	sourcePath, fingerprint := writeProcessProviderSource(
+		t, root, "partial-parent-write.jsonl",
+	)
+	child := processFixtureResult(
+		"cowork:child", parser.AgentCowork, "fixture-project",
+		sourcePath, fingerprint,
+	)
+	child.Session.ParentSessionID = "cowork:path-parent"
+	child.Session.RelationshipType = parser.RelSubagent
+	provider := newProcessFixtureProvider(
+		processFixtureSource(sourcePath), fingerprint,
+		parser.ParseOutcome{
+			Results: []parser.ParseResultOutcome{{
+				Result: child, DataVersion: parser.DataVersionCurrent,
+			}},
+			ResultSetComplete: true,
+			ForceReplace:      true,
+		},
+	)
+	engine := newProcessFixtureEngine(t, root, provider)
+	database := engine.db
+	actualParent := "cowork:spawner"
+	started := "2026-01-01T00:00:00Z"
+	require.NoError(t, database.UpsertSession(db.Session{
+		ID: actualParent, Agent: string(parser.AgentCowork),
+		Project: "fixture-project", Machine: "devbox", StartedAt: &started,
+		MessageCount: 1,
+	}))
+	require.NoError(t, database.UpsertSession(db.Session{
+		ID: "cowork:child", Agent: string(parser.AgentCowork),
+		Project: "fixture-project", Machine: "devbox",
+		ParentSessionID: &actualParent, RelationshipType: string(parser.RelSubagent),
+	}))
+	require.NoError(t, database.InsertMessages([]db.Message{{
+		SessionID: actualParent, Ordinal: 0, Role: string(parser.RoleAssistant),
+		Content: "spawn child", HasToolUse: true,
+		ToolCalls: []db.ToolCall{{
+			ToolUseID: "spawn-child", ToolName: "Agent",
+			SubagentSessionID: "cowork:child",
+		}},
+	}}))
+
+	raw, err := sql.Open("sqlite3", database.Path())
+	require.NoError(t, err)
+	t.Cleanup(func() { require.NoError(t, raw.Close()) })
+	_, err = raw.Exec(fmt.Sprintf(`
+		CREATE TRIGGER fail_child_write_completion
+		BEFORE UPDATE OF data_version ON sessions
+		WHEN NEW.id = 'cowork:child' AND NEW.data_version = %d
+		BEGIN
+			SELECT RAISE(FAIL, 'injected child completion failure');
+		END`, db.CurrentDataVersion()))
+	require.NoError(t, err)
+
+	syncErr := engine.SyncSingleSession("cowork:child")
+
+	require.ErrorContains(t, syncErr, "injected child completion failure")
+	stored, err := database.GetSession(t.Context(), "cowork:child")
+	require.NoError(t, err)
+	require.NotNil(t, stored)
+	require.NotNil(t, stored.ParentSessionID)
+	assert.Equal(t, actualParent, *stored.ParentSessionID,
+		"deferred repair must reconcile the partially written session itself")
+}
+
 func TestProcessFileProviderAuthoritativeSuppressesUncleanSkipCache(t *testing.T) {
 
 	root := t.TempDir()