1
export async function recordTranscript(
2
  messages: Message[],
3
  teamInfo?: TeamInfo,
4
  startingParentUuidHint?: UUID,
5
  allMessages?: readonly Message[],
6
): Promise<UUID | null> {
7
  const cleanedMessages = cleanMessagesForLogging(messages, allMessages)
8
  const sessionId = getSessionId() as UUID
9
  const messageSet = await getSessionMessages(sessionId)
10
  const newMessages: typeof cleanedMessages = []
11
  let startingParentUuid: UUID | undefined = startingParentUuidHint
12
  let seenNewMessage = false
13
  for (const m of cleanedMessages) {
14
    if (messageSet.has(m.uuid as UUID)) {
15
      // Only track skipped messages that form a prefix. After compaction,
16
      // messagesToKeep appear AFTER new CB/summary, so this skips them.
17
      if (!seenNewMessage && isChainParticipant(m)) {
18
        startingParentUuid = m.uuid as UUID
19
      }
20
    } else {
21
      newMessages.push(m)
22
      seenNewMessage = true
23
    }
24
  }
25
  if (newMessages.length > 0) {
26
    await getProject().insertMessageChain(
27
      newMessages,
28
      false,
29
      undefined,
30
      startingParentUuid,
31
      teamInfo,
32
    )
33
  }
34
  // Return the last ACTUALLY recorded chain-participant's UUID, OR the
35
  // prefix-tracked UUID if no new chain participants were recorded. This lets
36
  // callers (useLogMessages) maintain the correct parent chain even when the
37
  // slice is all-recorded (rewind, /resume scenarios where every message is
38
  // already in messageSet). Progress is skipped — it's written to the JSONL
39
  // but nothing chains TO it (see isChainParticipant).
40
  const lastRecorded = newMessages.findLast(isChainParticipant)
41
  return (lastRecorded?.uuid as UUID | undefined) ?? startingParentUuid ?? null
42
}

1
export async function loadTranscriptFile(
2
  filePath: string,
3
  opts?: { keepAllLeaves?: boolean },
4
): Promise<{
5
  messages: Map<UUID, TranscriptMessage>
6
  summaries: Map<UUID, string>
7
  customTitles: Map<UUID, string>
8
  tags: Map<UUID, string>
9
  agentNames: Map<UUID, string>
10
  agentColors: Map<UUID, string>
11
  agentSettings: Map<UUID, string>
12
  prNumbers: Map<UUID, number>
13
  prUrls: Map<UUID, string>
14
  prRepositories: Map<UUID, string>
15
  modes: Map<UUID, string>
16
  worktreeStates: Map<UUID, PersistedWorktreeSession | null>
17
  fileHistorySnapshots: Map<UUID, FileHistorySnapshotMessage>
18
  attributionSnapshots: Map<UUID, AttributionSnapshotMessage>
19
  contentReplacements: Map<UUID, ContentReplacementRecord[]>
20
  agentContentReplacements: Map<AgentId, ContentReplacementRecord[]>
21
  contextCollapseCommits: ContextCollapseCommitEntry[]
22
  contextCollapseSnapshot: ContextCollapseSnapshotEntry | undefined
23
  leafUuids: Set<UUID>
24
}> {
25
  const messages = new Map<UUID, TranscriptMessage>()
26
  const summaries = new Map<UUID, string>()
27
  const customTitles = new Map<UUID, string>()
28
  const tags = new Map<UUID, string>()
29
  const agentNames = new Map<UUID, string>()
30
  const agentColors = new Map<UUID, string>()
31
  const agentSettings = new Map<UUID, string>()
32
  const prNumbers = new Map<UUID, number>()
33
  const prUrls = new Map<UUID, string>()
34
  const prRepositories = new Map<UUID, string>()
35
  const modes = new Map<UUID, string>()
36
  const worktreeStates = new Map<UUID, PersistedWorktreeSession | null>()
37
  const fileHistorySnapshots = new Map<UUID, FileHistorySnapshotMessage>()
38
  const attributionSnapshots = new Map<UUID, AttributionSnapshotMessage>()
39
  const contentReplacements = new Map<UUID, ContentReplacementRecord[]>()
40
  const agentContentReplacements = new Map<
41
    AgentId,
42
    ContentReplacementRecord[]
43
  >()
44
  // Array, not Map — commit order matters (nested collapses).
45
  const contextCollapseCommits: ContextCollapseCommitEntry[] = []
46
  // Last-wins — later entries supersede.
47
  let contextCollapseSnapshot: ContextCollapseSnapshotEntry | undefined
48

49
  try {
50
    // For large transcripts, avoid materializing megabytes of stale content.
51
    // Single forward chunked read: attribution-snapshot lines are skipped at
52
    // the fd level (never buffered), compact boundaries truncate the
53
    // accumulator in-stream. Peak allocation is the OUTPUT size, not the
54
    // file size — a 151 MB session that is 84% stale attr-snaps allocates
55
    // ~32 MB instead of 159+64 MB. This matters because mimalloc does not
56
    // return those pages to the OS even after JS-level GC frees the backing
57
    // buffers (measured: arrayBuffers=0 after Bun.gc(true) but RSS stuck at
58
    // ~316 MB on the old scan+strip path vs ~155 MB here).
59
    //
60
    // Pre-boundary metadata (agent-setting, mode, pr-link, etc.) is recovered
61
    // via a cheap byte-level forward scan of [0, boundary).
62
    let buf: Buffer | null = null
63
    let metadataLines: string[] | null = null
64
    let hasPreservedSegment = false
65
    if (!isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_PRECOMPACT_SKIP)) {
66
      const { size } = await stat(filePath)
67
      if (size > SKIP_PRECOMPACT_THRESHOLD) {
68
        const scan = await readTranscriptForLoad(filePath, size)
69
        buf = scan.postBoundaryBuf
70
        hasPreservedSegment = scan.hasPreservedSegment
71
        // >0 means we truncated pre-boundary bytes and must recover
72
        // session-scoped metadata from that range. A preservedSegment
73
        // boundary does not truncate (preserved messages are physically
74
        // pre-boundary), so offset stays 0 unless an EARLIER non-preserved
75
        // boundary already truncated — in which case the preserved messages
76
        // for the later boundary are post-that-earlier-boundary and were
77
        // kept, and we still want the metadata scan.
78
        if (scan.boundaryStartOffset > 0) {
79
          metadataLines = await scanPreBoundaryMetadata(
80
            filePath,
81
            scan.boundaryStartOffset,
82
          )
83
        }
84
      }
85
    }
86
    buf ??= await readFile(filePath)
87
    // For large buffers (which here means readTranscriptForLoad output with
88
    // attr-snaps already stripped at the fd level — the <5MB readFile path
89
    // falls through the size gate below), the dominant cost is parsing dead
90
    // fork branches that buildConversationChain would discard anyway. Skip
91
    // when the caller needs all
92
    // leaves (loadAllLogsFromSessionFile for /insights picks the branch with
93
    // most user messages, not the latest), when the boundary has a
94
    // preservedSegment (those messages keep their pre-compact parentUuid on
95
    // disk -- applyPreservedSegmentRelinks splices them in-memory AFTER
96
    // parse, so a pre-parse chain walk would drop them as orphans), and when
97
    // CLAUDE_CODE_DISABLE_PRECOMPACT_SKIP is set (that kill switch means
98
    // "load everything, skip nothing"; this is another skip-before-parse
99
    // optimization and the scan it depends on for hasPreservedSegment did
100
    // not run).
101
    if (
102
      !opts?.keepAllLeaves &&
103
      !hasPreservedSegment &&
104
      !isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_PRECOMPACT_SKIP) &&
105
      buf.length > SKIP_PRECOMPACT_THRESHOLD
106
    ) {
107
      buf = walkChainBeforeParse(buf)
108
    }
109

110
    // First pass: process metadata-only lines collected during the boundary scan.
111
    // These populate the session-scoped maps (agentSettings, modes, prNumbers,
112
    // etc.) for entries written before the compact boundary. Any overlap with
113
    // the post-boundary buffer is harmless — later values overwrite earlier ones.
114
    if (metadataLines && metadataLines.length > 0) {
115
      const metaEntries = parseJSONL<Entry>(
116
        Buffer.from(metadataLines.join('\n')),
117
      )
118
      for (const entry of metaEntries) {
119
        if (entry.type === 'summary' && entry.leafUuid) {
120
          summaries.set(entry.leafUuid, entry.summary)
121
        } else if (entry.type === 'custom-title' && entry.sessionId) {
122
          customTitles.set(entry.sessionId, entry.customTitle)
123
        } else if (entry.type === 'tag' && entry.sessionId) {
124
          tags.set(entry.sessionId, entry.tag)
125
        } else if (entry.type === 'agent-name' && entry.sessionId) {
126
          agentNames.set(entry.sessionId, entry.agentName)
127
        } else if (entry.type === 'agent-color' && entry.sessionId) {
128
          agentColors.set(entry.sessionId, entry.agentColor)
129
        } else if (entry.type === 'agent-setting' && entry.sessionId) {
130
          agentSettings.set(entry.sessionId, entry.agentSetting)
131
        } else if (entry.type === 'mode' && entry.sessionId) {
132
          modes.set(entry.sessionId, entry.mode)
133
        } else if (entry.type === 'worktree-state' && entry.sessionId) {
134
          worktreeStates.set(entry.sessionId, entry.worktreeSession)
135
        } else if (entry.type === 'pr-link' && entry.sessionId) {
136
          prNumbers.set(entry.sessionId, entry.prNumber)
137
          prUrls.set(entry.sessionId, entry.prUrl)
138
          prRepositories.set(entry.sessionId, entry.prRepository)
139
        }
140
      }
141
    }
142

143
    const entries = parseJSONL<Entry>(buf)
144

145
    // Bridge map for legacy progress entries: progress_uuid → progress_parent_uuid.
146
    // PR #24099 removed progress from isTranscriptMessage, so old transcripts with
147
    // progress in the parentUuid chain would truncate at buildConversationChain
148
    // when messages.get(progressUuid) returns undefined. Since transcripts are
149
    // append-only (parents before children), we record each progress→parent link
150
    // as we see it, chain-resolving through consecutive progress entries, then
151
    // rewrite any subsequent message whose parentUuid lands in the bridge.
152
    const progressBridge = new Map<UUID, UUID | null>()
153

154
    for (const entry of entries) {
155
      // Legacy progress check runs before the Entry-typed else-if chain —
156
      // progress is not in the Entry union, so checking it after TypeScript
157
      // has narrowed `entry` intersects to `never`.
158
      if (isLegacyProgressEntry(entry)) {
159
        // Chain-resolve through consecutive progress entries so a later
160
        // message pointing at the tail of a progress run bridges to the
161
        // nearest non-progress ancestor in one lookup.
162
        const parent = entry.parentUuid
163
        progressBridge.set(
164
          entry.uuid,
165
          parent && progressBridge.has(parent)
166
            ? (progressBridge.get(parent) ?? null)
167
            : parent,
168
        )
169
        continue
170
      }
171
      if (isTranscriptMessage(entry)) {
172
        if (entry.parentUuid && progressBridge.has(entry.parentUuid)) {
173
          entry.parentUuid = progressBridge.get(entry.parentUuid) ?? null
174
        }
175
        messages.set(entry.uuid, entry)
176
        // Compact boundary: prior marble-origami-commit entries reference
177
        // messages that won't be in the post-boundary chain. The >5MB
178
        // backward-scan path discards them naturally by never reading the
179
        // pre-boundary bytes; the <5MB path reads everything, so discard
180
        // here. Without this, getStats().collapsedSpans in /context
181
        // overcounts (projectView silently skips the stale commits but
182
        // they're still in the log).
183
        if (isCompactBoundaryMessage(entry)) {
184
          contextCollapseCommits.length = 0
185
          contextCollapseSnapshot = undefined
186
        }
187
      } else if (entry.type === 'summary' && entry.leafUuid) {
188
        summaries.set(entry.leafUuid, entry.summary)
189
      } else if (entry.type === 'custom-title' && entry.sessionId) {
190
        customTitles.set(entry.sessionId, entry.customTitle)
191
      } else if (entry.type === 'tag' && entry.sessionId) {
192
        tags.set(entry.sessionId, entry.tag)
193
      } else if (entry.type === 'agent-name' && entry.sessionId) {
194
        agentNames.set(entry.sessionId, entry.agentName)
195
      } else if (entry.type === 'agent-color' && entry.sessionId) {
196
        agentColors.set(entry.sessionId, entry.agentColor)
197
      } else if (entry.type === 'agent-setting' && entry.sessionId) {
198
        agentSettings.set(entry.sessionId, entry.agentSetting)
199
      } else if (entry.type === 'mode' && entry.sessionId) {
200
        modes.set(entry.sessionId, entry.mode)
201
      } else if (entry.type === 'worktree-state' && entry.sessionId) {
202
        worktreeStates.set(entry.sessionId, entry.worktreeSession)
203
      } else if (entry.type === 'pr-link' && entry.sessionId) {
204
        prNumbers.set(entry.sessionId, entry.prNumber)
205
        prUrls.set(entry.sessionId, entry.prUrl)
206
        prRepositories.set(entry.sessionId, entry.prRepository)
207
      } else if (entry.type === 'file-history-snapshot') {
208
        fileHistorySnapshots.set(entry.messageId, entry)
209
      } else if (entry.type === 'attribution-snapshot') {
210
        attributionSnapshots.set(entry.messageId, entry)
211
      } else if (entry.type === 'content-replacement') {
212
        // Subagent decisions key by agentId (sidechain resume); main-thread
213
        // decisions key by sessionId (/resume).
214
        if (entry.agentId) {
215
          const existing = agentContentReplacements.get(entry.agentId) ?? []
216
          agentContentReplacements.set(entry.agentId, existing)
217
          existing.push(...entry.replacements)
218
        } else {
219
          const existing = contentReplacements.get(entry.sessionId) ?? []
220
          contentReplacements.set(entry.sessionId, existing)
221
          existing.push(...entry.replacements)
222
        }
223
      } else if (entry.type === 'marble-origami-commit') {
224
        contextCollapseCommits.push(entry)
225
      } else if (entry.type === 'marble-origami-snapshot') {
226
        contextCollapseSnapshot = entry
227
      }
228
    }
229
  } catch {
230
    // File doesn't exist or can't be read
231
  }
232

233
  applyPreservedSegmentRelinks(messages)
234
  applySnipRemovals(messages)
235

236
  // Compute leaf UUIDs once at load time
237
  // Only user/assistant messages should be considered as leaves for anchoring resume.
238
  // Other message types (system, attachment) are metadata or auxiliary and shouldn't
239
  // anchor a conversation chain.
240
  //
241
  // We use standard parent relationship for main chain detection, but also need to
242
  // handle cases where the last message is a system/metadata message.
243
  // For each conversation chain (identified by following parent links), the leaf
244
  // is the most recent user/assistant message.
245
  const allMessages = [...messages.values()]
246

247
  // Standard leaf computation using parent relationships
248
  const parentUuids = new Set(
249
    allMessages
250
      .map(msg => msg.parentUuid)
251
      .filter((uuid): uuid is UUID => uuid !== null),
252
  )
253

254
  // Find all terminal messages (messages with no children)
255
  const terminalMessages = allMessages.filter(msg => !parentUuids.has(msg.uuid))
256

257
  const leafUuids = new Set<UUID>()
258
  let hasCycle = false
259

260
  if (getFeatureValue_CACHED_MAY_BE_STALE('tengu_pebble_leaf_prune', false)) {
261
    // Build a set of UUIDs that have user/assistant children
262
    // (these are mid-conversation nodes, not dead ends)
263
    const hasUserAssistantChild = new Set<UUID>()
264
    for (const msg of allMessages) {
265
      if (msg.parentUuid && (msg.type === 'user' || msg.type === 'assistant')) {
266
        hasUserAssistantChild.add(msg.parentUuid)
267
      }
268
    }
269

270
    // For each terminal message, walk back to find the nearest user/assistant ancestor.
271
    // Skip ancestors that already have user/assistant children - those are mid-conversation
272
    // nodes where the conversation continued (e.g., an assistant tool_use message whose
273
    // progress child is terminal, but whose tool_result child continues the conversation).
274
    for (const terminal of terminalMessages) {
275
      const seen = new Set<UUID>()
276
      let current: TranscriptMessage | undefined = terminal
277
      while (current) {
278
        if (seen.has(current.uuid)) {
279
          hasCycle = true
280
          break
281
        }
282
        seen.add(current.uuid)
283
        if (current.type === 'user' || current.type === 'assistant') {
284
          if (!hasUserAssistantChild.has(current.uuid)) {
285
            leafUuids.add(current.uuid)
286
          }
287
          break
288
        }
289
        current = current.parentUuid
290
          ? messages.get(current.parentUuid)
291
          : undefined
292
      }
293
    }
294
  } else {
295
    // Original leaf computation: walk back from terminal messages to find
296
    // the nearest user/assistant ancestor unconditionally
297
    for (const terminal of terminalMessages) {
298
      const seen = new Set<UUID>()
299
      let current: TranscriptMessage | undefined = terminal
300
      while (current) {
301
        if (seen.has(current.uuid)) {
302
          hasCycle = true
303
          break
304
        }
305
        seen.add(current.uuid)
306
        if (current.type === 'user' || current.type === 'assistant') {
307
          leafUuids.add(current.uuid)
308
          break
309
        }
310
        current = current.parentUuid
311
          ? messages.get(current.parentUuid)
312
          : undefined
313
      }
314
    }
315
  }
316

317
  if (hasCycle) {
318
    logEvent('tengu_transcript_parent_cycle', {})
319
  }
320

321
  return {
322
    messages,
323
    summaries,
324
    customTitles,
325
    tags,
326
    agentNames,
327
    agentColors,
328
    agentSettings,
329
    prNumbers,
330
    prUrls,
331
    prRepositories,
332
    modes,
333
    worktreeStates,
334
    fileHistorySnapshots,
335
    attributionSnapshots,
336
    contentReplacements,
337
    agentContentReplacements,
338
    contextCollapseCommits,
339
    contextCollapseSnapshot,
340
    leafUuids,
341
  }
342
}

1
export async function runForkedAgent({
2
  promptMessages,
3
  cacheSafeParams,
4
  canUseTool,
5
  querySource,
6
  forkLabel,
7
  overrides,
8
  maxOutputTokens,
9
  maxTurns,
10
  onMessage,
11
  skipTranscript,
12
  skipCacheWrite,
13
}: ForkedAgentParams): Promise<ForkedAgentResult> {
14
  const startTime = Date.now()
15
  const outputMessages: Message[] = []
16
  let totalUsage: NonNullableUsage = { ...EMPTY_USAGE }
17

18
  const {
19
    systemPrompt,
20
    userContext,
21
    systemContext,
22
    toolUseContext,
23
    forkContextMessages,
24
  } = cacheSafeParams
25

26
  // Create isolated context to prevent mutation of parent state
27
  const isolatedToolUseContext = createSubagentContext(
28
    toolUseContext,
29
    overrides,
30
  )
31

32
  // Do NOT filterIncompleteToolCalls here — it drops the whole assistant on
33
  // partial tool batches, orphaning the paired results (API 400). Dangling
34
  // tool_uses are repaired downstream by ensureToolResultPairing in claude.ts,
35
  // same as the main thread — identical post-repair prefix keeps the cache hit.
36
  const initialMessages: Message[] = [...forkContextMessages, ...promptMessages]
37

38
  // Generate agent ID and record initial messages for transcript
39
  // When skipTranscript is set, skip agent ID creation and all transcript I/O
40
  const agentId = skipTranscript ? undefined : createAgentId(forkLabel)
41
  let lastRecordedUuid: UUID | null = null
42
  if (agentId) {
43
    await recordSidechainTranscript(initialMessages, agentId).catch(err =>
44
      logForDebugging(
45
        `Forked agent [${forkLabel}] failed to record initial transcript: ${err}`,
46
      ),
47
    )
48
    // Track the last recorded message UUID for parent chain continuity
49
    lastRecordedUuid =
50
      initialMessages.length > 0
51
        ? initialMessages[initialMessages.length - 1]!.uuid
52
        : null
53
  }
54

55
  // Run the query loop with isolated context (cache-safe params preserved)
56
  try {
57
    for await (const message of query({
58
      messages: initialMessages,
59
      systemPrompt,
60
      userContext,
61
      systemContext,
62
      canUseTool,
63
      toolUseContext: isolatedToolUseContext,
64
      querySource,
65
      maxOutputTokensOverride: maxOutputTokens,
66
      maxTurns,
67
      skipCacheWrite,
68
    })) {
69
      // Extract real usage from message_delta stream events (final usage per API call)
70
      if (message.type === 'stream_event') {
71
        if (
72
          'event' in message &&
73
          message.event?.type === 'message_delta' &&
74
          message.event.usage
75
        ) {
76
          const turnUsage = updateUsage({ ...EMPTY_USAGE }, message.event.usage)
77
          totalUsage = accumulateUsage(totalUsage, turnUsage)
78
        }
79
        continue
80
      }
81
      if (message.type === 'stream_request_start') {
82
        continue
83
      }
84

85
      logForDebugging(
86
        `Forked agent [${forkLabel}] received message: type=${message.type}`,
87
      )
88

89
      outputMessages.push(message as Message)
90
      onMessage?.(message as Message)
91

92
      // Record transcript for recordable message types (same pattern as runAgent.ts)
93
      const msg = message as Message
94
      if (
95
        agentId &&
96
        (msg.type === 'assistant' ||
97
          msg.type === 'user' ||
98
          msg.type === 'progress')
99
      ) {
100
        await recordSidechainTranscript([msg], agentId, lastRecordedUuid).catch(
101
          err =>
102
            logForDebugging(
103
              `Forked agent [${forkLabel}] failed to record transcript: ${err}`,
104
            ),
105
        )
106
        if (msg.type !== 'progress') {
107
          lastRecordedUuid = msg.uuid
108
        }
109
      }
110
    }
111
  } finally {
112
    // Release cloned file state cache memory (same pattern as runAgent.ts)
113
    isolatedToolUseContext.readFileState.clear()
114
    // Release the cloned fork context messages
115
    initialMessages.length = 0
116
  }
117

118
  logForDebugging(
119
    `Forked agent [${forkLabel}] finished: ${outputMessages.length} messages, types=[${outputMessages.map(m => m.type).join(', ')}], totalUsage: input=${totalUsage.input_tokens} output=${totalUsage.output_tokens} cacheRead=${totalUsage.cache_read_input_tokens} cacheCreate=${totalUsage.cache_creation_input_tokens}`,
120
  )
121

122
  const durationMs = Date.now() - startTime
123

124
  // Log the fork query metrics with full NonNullableUsage
125
  logForkAgentQueryEvent({
126
    forkLabel,
127
    querySource,
128
    durationMs,
129
    messageCount: outputMessages.length,
130
    totalUsage,
131
    queryTracking: toolUseContext.queryTracking,
132
  })
133

134
  return {
135
    messages: outputMessages,
136
    totalUsage,
137
  }
138
}

1
export function buildForkedMessages(
2
  directive: string,
3
  assistantMessage: AssistantMessage,
4
): MessageType[] {
5
  // Clone the assistant message to avoid mutating the original, keeping all
6
  // content blocks (thinking, text, and every tool_use)
7
  const fullAssistantMessage: AssistantMessage = {
8
    ...assistantMessage,
9
    uuid: randomUUID(),
10
    message: {
11
      ...assistantMessage.message,
12
      content: [...assistantMessage.message.content],
13
    },
14
  }
15

16
  // Collect all tool_use blocks from the assistant message
17
  const toolUseBlocks = assistantMessage.message.content.filter(
18
    (block): block is BetaToolUseBlock => block.type === 'tool_use',
19
  )
20

21
  if (toolUseBlocks.length === 0) {
22
    logForDebugging(
23
      `No tool_use blocks found in assistant message for fork directive: ${directive.slice(0, 50)}...`,
24
      { level: 'error' },
25
    )
26
    return [
27
      createUserMessage({
28
        content: [
29
          { type: 'text' as const, text: buildChildMessage(directive) },
30
        ],
31
      }),
32
    ]
33
  }
34

35
  // Build tool_result blocks for every tool_use, all with identical placeholder text
36
  const toolResultBlocks = toolUseBlocks.map(block => ({
37
    type: 'tool_result' as const,
38
    tool_use_id: block.id,
39
    content: [
40
      {
41
        type: 'text' as const,
42
        text: FORK_PLACEHOLDER_RESULT,
43
      },
44
    ],
45
  }))
46

47
  // Build a single user message: all placeholder tool_results + the per-child directive
48
  // TODO(smoosh): this text sibling creates a [tool_result, text] pattern on the wire
49
  // (renders as </function_results>\n\nHuman:<text>). One-off per-child construction,
50
  // not a repeated teacher, so low-priority. If we ever care, use smooshIntoToolResult
51
  // from src/utils/messages.ts to fold the directive into the last tool_result.content.
52
  const toolResultMessage = createUserMessage({
53
    content: [
54
      ...toolResultBlocks,
55
      {
56
        type: 'text' as const,
57
        text: buildChildMessage(directive),
58
      },
59
    ],
60
  })
61

62
  return [fullAssistantMessage, toolResultMessage]
63
}