fix subagent lane fallback issue

Author: icecrasher321

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

@@ -133,6 +133,49 @@ describe('modelToContentBlocks', () => {
     expect(snap2[0].content).toBe('one')
   })
 
+  it('attributes subagent content that streams before its subagent_start (parallel-burst inversion)', () => {
+    const sub: Scope = {
+      lane: 'subagent',
+      spanId: 'R1',
+      parentSpanId: 'main',
+      parentToolCallId: 'tc-r1',
+      agentId: 'research',
+    }
+    const m = createTurnModel()
+    reduceEvent(m, env(1, 'text', { channel: 'assistant', text: 'Spawning research.' }))
+    // Under an 8-way burst the subagent's thinking + text can be reduced before
+    // its subagent_start lands. The content already carries the lane identity.
+    reduceEvent(m, env(2, 'text', { channel: 'thinking', text: 'Considering odds.' }, sub))
+    reduceEvent(m, env(3, 'text', { channel: 'assistant', text: 'Team analysis.' }, sub))
+
+    // Snapshot mid-burst (before the start): the research content must already be
+    // its own lane, never leaked into the main ("Sim") lane with its thinking dropped.
+    const mid = modelToContentBlocks(m)
+    const midSub = mid.find((b) => b.type === 'subagent')
+    expect(midSub?.content).toBe('research')
+    expect(midSub?.spanId).toBe('R1')
+    expect(mid.find((b) => b.type === 'subagent_thinking')?.spanId).toBe('R1')
+    expect(mid.filter((b) => b.type === 'text' && b.spanId === 'R1')).toHaveLength(1)
+    // The main lane holds only the pre-spawn text — nothing leaked in.
+    const mainText = mid.filter((b) => b.type === 'text' && !b.spanId)
+    expect(mainText).toHaveLength(1)
+    expect(mainText[0].content).toBe('Spawning research.')
+
+    // The real subagent_start lands afterward and no-ops: still one research lane.
+    reduceEvent(
+      m,
+      env(
+        4,
+        'span',
+        { kind: 'subagent', event: 'start', agent: 'research', data: { tool_call_id: 'tc-r1' } },
+        sub
+      )
+    )
+    const after = modelToContentBlocks(m)
+    expect(after.filter((b) => b.type === 'subagent')).toHaveLength(1)
+    expect(after.find((b) => b.type === 'subagent')?.content).toBe('research')
+  })
+
   it('places subagent_end at its end seq (after the lane work), never reordering siblings', () => {
     const sub: Scope = {
       lane: 'subagent',

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

@@ -344,6 +344,42 @@ function applyToolResult(
   model.bufferedResults.set(id, { success, output, status, ...(error ? { error } : {}) })
 }
 
+/**
+ * Materializes a subagent lane on first reference. Subagent-scoped content
+ * (text/thinking/tool) can be reduced before its `subagent_start` under heavy
+ * parallel bursts (many subagents streaming into one ordered channel); without
+ * the owning `AgentNode` the serializer can't attribute the content, so it leaks
+ * into the main lane and the subagent's thinking is dropped until the start
+ * lands. The wire scope already carries the lane identity (Go tags every
+ * forwarded subagent event with its agent id/span), so the lane is rebuilt
+ * deterministically from the content event itself — the symmetric counterpart to
+ * buffering a result before its call. The later `subagent_start` finds this node
+ * and no-ops.
+ */
+function ensureSubagentLane(
+  model: TurnModel,
+  spanId: string,
+  scope: { agentId?: string; parentSpanId?: string; parentToolCallId?: string } | undefined,
+  seq: number,
+  atMs?: number
+): void {
+  if (spanId === MAIN_SPAN || model.agentBySpanId.has(spanId)) return
+  const node: AgentNode = {
+    kind: 'agent',
+    id: spanId,
+    spanId,
+    parentSpanId: scope?.parentSpanId ?? MAIN_SPAN,
+    agentId: scope?.agentId ?? '',
+    status: 'running',
+    seq,
+    ...(atMs !== undefined ? { startedAtMs: atMs } : {}),
+    ...(scope?.parentToolCallId ? { triggerToolCallId: scope.parentToolCallId } : {}),
+  }
+  model.nodes.set(node.id, node)
+  model.order.push(node.id)
+  model.agentBySpanId.set(spanId, node.id)
+}
+
 /**
  * Folds one wire envelope into the model. Pure accumulator: it mutates and
  * returns the same `model` (the streaming hot path keeps one model per turn).
@@ -364,6 +400,7 @@ export function reduceEvent(model: TurnModel, envelope: PersistedStreamEventEnve
   switch (envelope.type) {
     case MothershipStreamV1EventType.text: {
       const payload = envelope.payload
+      ensureSubagentLane(model, spanId, scope, seq, tsMs)
       appendText(model, spanId, payload.channel as TextChannel, payload.text, seq, tsMs)
       break
     }
@@ -374,6 +411,7 @@ export function reduceEvent(model: TurnModel, envelope: PersistedStreamEventEnve
       const rawToolCallId = asString(payload.toolCallId)
       if (!rawToolCallId) break
       const toolName = asString(payload.toolName) ?? ''
+      ensureSubagentLane(model, spanId, scope, seq, tsMs)
       const phase = payload.phase
       if (phase === MothershipStreamV1ToolPhase.call) {
         // edit_content folds into its span's workspace_file row (the write