fix(scope): scope subagent tools

Author: Sg312

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model.test.ts

@@ -522,3 +522,33 @@ describe('turn-terminal propagation', () => {
     expect(tool(m, 'tc-1').status).toBe('error')
   })
 })
+
+describe('reduceEvent — span-start owner reconciliation', () => {
+  it('corrects a nonempty mismatched provisional lane owner from the authoritative start', () => {
+    const model = createTurnModel()
+    // A content event races ahead of the span start; its scope names the
+    // FORWARDING caller (superagent), not the lane's real owner.
+    reduceEvent(
+      model,
+      envelope(
+        1,
+        'text',
+        { channel: 'assistant', text: 'early chunk' },
+        { lane: 'subagent', spanId: 'S1', agentId: 'superagent', parentToolCallId: 'd1' }
+      )
+    )
+    reduceEvent(
+      model,
+      envelope(
+        2,
+        'span',
+        { kind: 'subagent', event: 'start', agent: 'workflow', data: { tool_call_id: 'd1' } },
+        { lane: 'subagent', spanId: 'S1', parentToolCallId: 'd1' }
+      )
+    )
+    const laneId = model.agentBySpanId.get('S1')
+    const lane = laneId ? model.nodes.get(laneId) : undefined
+    if (!lane || lane.kind !== 'agent') throw new Error('expected agent lane for S1')
+    expect((lane as AgentNode).agentId).toBe('workflow')
+  })
+})

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model.ts

@@ -521,8 +521,11 @@ export function reduceEvent(model: TurnModel, envelope: PersistedStreamEventEnve
           // that raced ahead of this start. That event's scope may omit agentId
           // (contract-optional) while only this start carries payload.agent —
           // an empty agentId makes the downstream parsers drop the whole lane.
-          // Reconcile instead of ignoring the start.
-          if (!existing.agentId && agentId) existing.agentId = agentId
+          // Reconcile instead of ignoring the start — and overwrite a NONEMPTY
+          // mismatched provisional owner too: a racing content event's
+          // scope.agentId can name the forwarding caller (e.g. superagent),
+          // while this start's payload.agent is the authoritative lane owner.
+          if (agentId && existing.agentId !== agentId) existing.agentId = agentId
           if (!existing.triggerToolCallId && triggerToolCallId) {
             existing.triggerToolCallId = triggerToolCallId
           }

apps/sim/lib/copilot/chat/effective-transcript.test.ts

@@ -384,3 +384,96 @@ describe('isLiveAssistantMessageId', () => {
     expect(isLiveAssistantMessageId('')).toBe(false)
   })
 })
+
+describe('tool ownership is call-frame authoritative', () => {
+  const toolEvent = (
+    seq: number,
+    phase: 'call' | 'result',
+    toolCallId: string,
+    scope?: Record<string, unknown>
+  ): StreamBatchEvent =>
+    toBatchEvent(seq, {
+      v: 1,
+      seq,
+      ts: '2026-04-15T12:00:01.000Z',
+      type: MothershipStreamV1EventType.tool,
+      stream: { streamId: 'stream-1' },
+      payload:
+        phase === 'call'
+          ? { phase: 'call', toolCallId, toolName: 'read', arguments: { path: 'a.md' } }
+          : { phase: 'result', toolCallId, toolName: 'read', success: true, output: 'ok' },
+      ...(scope ? { scope } : {}),
+      // double-cast-allowed: synthetic test envelope; the reducer reads only the fields set here
+    } as unknown as StreamBatchEvent['event'])
+
+  const superagentScope = {
+    lane: 'subagent',
+    agentId: 'superagent',
+    parentToolCallId: 'dispatch-1',
+    spanId: 'S1',
+  }
+
+  const ownership = (result: ReturnType<typeof buildEffectiveChatTranscript>) => {
+    const blocks = (result[1].contentBlocks ?? []) as Array<Record<string, unknown>>
+    const tool = blocks.find((b) => b.type === MothershipStreamV1EventType.tool)
+    const tc = tool?.toolCall as Record<string, unknown> | undefined
+    return { calledBy: tc?.calledBy, parentToolCallId: tool?.parentToolCallId, spanId: tool?.spanId }
+  }
+
+  it('an unscoped main call clears provisional subagent attribution', () => {
+    // The observed dev bug: a mis-scoped replayed result seeded the main
+    // read under Superagent, and nothing could ever move it back.
+    const result = buildEffectiveChatTranscript({
+      messages: [buildUserMessage('stream-1', 'Hello')],
+      activeStreamId: 'stream-1',
+      streamSnapshot: {
+        events: [
+          toolEvent(1, 'result', 'fc_1', superagentScope),
+          toolEvent(2, 'call', 'fc_1'),
+        ],
+        previewSessions: [],
+        status: 'active',
+      },
+    })
+    const own = ownership(result)
+    expect(own.calledBy).toBeUndefined()
+    expect(own.parentToolCallId).toBeUndefined()
+    expect(own.spanId).toBeUndefined()
+  })
+
+  it('a later mis-scoped result cannot re-parent a settled main tool', () => {
+    const result = buildEffectiveChatTranscript({
+      messages: [buildUserMessage('stream-1', 'Hello')],
+      activeStreamId: 'stream-1',
+      streamSnapshot: {
+        events: [
+          toolEvent(1, 'call', 'fc_1'),
+          toolEvent(2, 'result', 'fc_1', superagentScope),
+        ],
+        previewSessions: [],
+        status: 'active',
+      },
+    })
+    const own = ownership(result)
+    expect(own.calledBy).toBeUndefined()
+    expect(own.parentToolCallId).toBeUndefined()
+  })
+
+  it('a genuinely scoped subagent call keeps its ownership', () => {
+    const result = buildEffectiveChatTranscript({
+      messages: [buildUserMessage('stream-1', 'Hello')],
+      activeStreamId: 'stream-1',
+      streamSnapshot: {
+        events: [
+          toolEvent(1, 'call', 'fc_2', superagentScope),
+          toolEvent(2, 'result', 'fc_2'),
+        ],
+        previewSessions: [],
+        status: 'active',
+      },
+    })
+    const own = ownership(result)
+    expect(own.calledBy).toBe('superagent')
+    expect(own.parentToolCallId).toBe('dispatch-1')
+  })
+})

apps/sim/lib/copilot/chat/effective-transcript.ts

@@ -149,6 +149,17 @@ function buildLiveAssistantMessage(params: {
     return scopedParent
   }
 
+  // Tool ownership (calledBy / parent / span identity) is CALL-FRAME
+  // authoritative: once a call frame for a tool id has been reduced, later
+  // scoped results or replayed duplicates must not re-parent the tool. Before
+  // a call frame arrives, ownership stays provisional (result-first replay
+  // arrival is legal) and the call frame settles it — including CLEARING
+  // stale subagent attribution when the call is main-lane (unscoped). Without
+  // the clear, one mis-scoped replayed event pinned main tools under a
+  // subagent (observed: Sim's reads rendered under Superagent) with no later
+  // event able to correct it.
+  const toolOwnershipSettled = new Set<string>()
+
   const ensureToolBlock = (input: {
     toolCallId: string
     toolName: string
@@ -160,7 +171,10 @@ function buildLiveAssistantMessage(params: {
     params?: Record<string, unknown>
     result?: { success: boolean; output?: unknown; error?: string }
     state?: string
+    isCallFrame?: boolean
   }): RawPersistedBlock => {
+    const ownershipWritable = input.isCallFrame === true || !toolOwnershipSettled.has(input.toolCallId)
+    if (input.isCallFrame) toolOwnershipSettled.add(input.toolCallId)
     const existingIndex = toolIndexById.get(input.toolCallId)
     if (existingIndex !== undefined) {
       const existing = blocks[existingIndex]
@@ -172,7 +186,7 @@ function buildLiveAssistantMessage(params: {
         state:
           input.state ??
           (typeof existingToolCall?.state === 'string' ? existingToolCall.state : 'executing'),
-        ...(input.calledBy ? { calledBy: input.calledBy } : {}),
+        ...(ownershipWritable && input.calledBy ? { calledBy: input.calledBy } : {}),
         ...(input.params ? { params: input.params } : {}),
         ...(input.result ? { result: input.result } : {}),
         ...(input.displayTitle
@@ -185,9 +199,21 @@ function buildLiveAssistantMessage(params: {
             ? { display: existingToolCall.display }
             : {}),
       }
-      if (input.parentToolCallId) existing.parentToolCallId = input.parentToolCallId
-      if (input.spanId) existing.spanId = input.spanId
-      if (input.parentSpanId) existing.parentSpanId = input.parentSpanId
+      if (ownershipWritable) {
+        if (input.parentToolCallId) existing.parentToolCallId = input.parentToolCallId
+        if (input.spanId) existing.spanId = input.spanId
+        if (input.parentSpanId) existing.parentSpanId = input.parentSpanId
+        if (input.isCallFrame && !input.calledBy) {
+          // Authoritative main-lane call: clear any provisionally-seeded
+          // subagent attribution so the tool renders under Sim, not the
+          // forwarding caller.
+          const tc = asPayloadRecord(existing.toolCall)
+          if (tc) delete tc.calledBy
+          delete existing.parentToolCallId
+          delete existing.spanId
+          delete existing.parentSpanId
+        }
+      }
       return existing
     }
 
@@ -332,6 +358,7 @@ function buildLiveAssistantMessage(params: {
           ),
           params: isRecordLike(payload.arguments) ? payload.arguments : undefined,
           state: typeof payload.status === 'string' ? payload.status : 'executing',
+          isCallFrame: payload.phase === MothershipStreamV1ToolPhase.call,
         })
         continue
       }