Resolve subagent parent only from an unambiguous edge (review fix)

roborev flagged that the bare LIMIT 1 subquery could re-parent a correctly
parented subagent arbitrarily when a child is referenced by spawn edges from
more than one distinct session (reachable via copied/forked history). This
became reachable for already-'subagent' rows once the prior commit added the
"OR parent differs" branch.

Resolve the parent only from an unambiguous edge: GROUP BY subagent_session_id
HAVING COUNT(DISTINCT tc.session_id) = 1, wrapped in
COALESCE(..., parent_session_id) so conflicting edges preserve the current
parent instead of picking one arbitrarily. This also removes the LIMIT 1
nondeterminism between the SET and WHERE evaluations. Add
TestLinkSubagentSessionsPreservesParentOnConflictingEdges (mutation-verified:
fails if the exactly-one-distinct-spawner guard is relaxed).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Nick

internal/db/link_subagent_nested_test.go

@@ -182,3 +182,60 @@ func TestLinkSubagentSessionsLinksNullParentSubagent(t *testing.T) {
 			"orphan.parent_session_id")
 	}
 }
+
+// TestLinkSubagentSessionsPreservesParentOnConflictingEdges guards against
+// arbitrary re-parenting when a child is referenced by spawn edges from more
+// than one distinct session (reachable via copied/forked history). The parent
+// must be resolved only from an unambiguous edge; with conflicting edges the
+// current parent is preserved rather than picked arbitrarily by a bare LIMIT 1.
+func TestLinkSubagentSessionsPreservesParentOnConflictingEdges(t *testing.T) {
+	d := testDB(t)
+
+	insertSession(t, d, "p1", "p", func(s *Session) {
+		s.MessageCount = 1
+	})
+	insertSession(t, d, "p2", "p", func(s *Session) {
+		s.MessageCount = 1
+	})
+	// "kid" is already a correctly parented subagent under p2.
+	insertSession(t, d, "kid", "p", func(s *Session) {
+		s.MessageCount = 1
+		parent := "p2"
+		s.ParentSessionID = &parent
+		s.RelationshipType = "subagent"
+	})
+
+	// Two DISTINCT sessions both carry a spawn edge to "kid". p1's edge is
+	// inserted first (lower rowid), so a bare `LIMIT 1` would pick p1 and
+	// wrongly re-parent kid away from its current p2. The unambiguous-edge
+	// resolution must instead preserve p2.
+	insertMessages(t, d,
+		Message{
+			SessionID: "p1", Ordinal: 0, Role: "assistant",
+			Content: "spawn kid (copy A)", HasToolUse: true,
+			ToolCalls: []ToolCall{{
+				ToolName: "Agent", Category: "Task",
+				SubagentSessionID: "kid",
+			}},
+		},
+		Message{
+			SessionID: "p2", Ordinal: 0, Role: "assistant",
+			Content: "spawn kid (copy B)", HasToolUse: true,
+			ToolCalls: []ToolCall{{
+				ToolName: "Agent", Category: "Task",
+				SubagentSessionID: "kid",
+			}},
+		},
+	)
+
+	require.NoError(t, d.LinkSubagentSessions(), "LinkSubagentSessions")
+
+	kid, err := d.GetSession(context.Background(), "kid")
+	requireNoError(t, err, "GetSession kid")
+	assert.Equal(t, "subagent", kid.RelationshipType, "kid relationship_type")
+	if assert.NotNil(t, kid.ParentSessionID, "kid parent") {
+		assert.Equal(t, "p2", *kid.ParentSessionID,
+			"conflicting edges must preserve the current parent, "+
+				"not pick one arbitrarily")
+	}
+}

internal/db/sessions.go

@@ -1566,37 +1566,49 @@ func (db *DB) LinkSubagentSessions() error {
 	// same pattern).
 	_, err := db.getWriter().Exec(`
 		UPDATE sessions
-		SET parent_session_id = (
-			SELECT tc.session_id
-			FROM tool_calls tc
-			WHERE tc.subagent_session_id = sessions.id
-			LIMIT 1
+		SET parent_session_id = COALESCE(
+			(
+				SELECT tc.session_id
+				FROM tool_calls tc
+				WHERE tc.subagent_session_id = sessions.id
+				GROUP BY tc.subagent_session_id
+				HAVING COUNT(DISTINCT tc.session_id) = 1
+			),
+			parent_session_id
 		),
 		relationship_type = 'subagent',
 		local_modified_at = strftime('%Y-%m-%dT%H:%M:%fZ','now')
-		-- The tool_calls edge (from toolUseResult.agentId) is the record of
-		-- the actual spawn, so it is authoritative over the path-derived
-		-- parent set at parse time. Nested subagents (depth >= 2) all live in
-		-- the same flat <main>/subagents/ dir, so path derivation pins them to
-		-- the main session AND tags them 'subagent'; the previous
-		-- relationship_type != subagent guard then skipped them, leaving
-		-- the hierarchy flat. Update the row when EITHER it is not yet tagged
-		-- 'subagent' (upgrades a continuation/fork/empty classification even
-		-- when its parent already matches the spawner) OR the authoritative
-		-- parent differs (the nested depth>=2 re-parent). Null-safe IS NOT.
-		-- Already-correct subagents match neither branch and are left as-is to
-		-- avoid needless local_modified_at churn.
+		-- The tool_calls edge (from toolUseResult.agentId) records the actual
+		-- spawn, authoritative over the path-derived parent set at parse time.
+		-- Nested subagents (depth >= 2) live flat in <main>/subagents/, so path
+		-- derivation pins them to the main session AND tags them 'subagent';
+		-- the old relationship_type != 'subagent' guard skipped them, leaving
+		-- the hierarchy flat.
+		--
+		-- Resolve the parent only from an UNAMBIGUOUS edge: the grouped
+		-- subquery yields a spawner only when exactly one distinct session
+		-- spawned this child (HAVING COUNT(DISTINCT tc.session_id) = 1). With
+		-- conflicting edges from copied/forked history it yields NULL and
+		-- COALESCE keeps the current parent, so a correctly parented subagent
+		-- is never re-parented arbitrarily. Update when EITHER the row is not
+		-- yet 'subagent' (upgrade continuation/fork/empty; parent preserved if
+		-- ambiguous) OR the unambiguous parent differs (null-safe IS NOT).
+		-- Already-correct subagents match neither branch (no churn).
 		WHERE EXISTS (
 			SELECT 1 FROM tool_calls tc
 			WHERE tc.subagent_session_id = sessions.id
 		)
 		AND (
 			relationship_type != 'subagent'
-			OR parent_session_id IS NOT (
-				SELECT tc.session_id
-				FROM tool_calls tc
-				WHERE tc.subagent_session_id = sessions.id
-				LIMIT 1
+			OR parent_session_id IS NOT COALESCE(
+				(
+					SELECT tc.session_id
+					FROM tool_calls tc
+					WHERE tc.subagent_session_id = sessions.id
+					GROUP BY tc.subagent_session_id
+					HAVING COUNT(DISTINCT tc.session_id) = 1
+				),
+				parent_session_id
 			)
 		)`)
 	if err != nil {