subagent-cli 0.1.0 → 0.2.1

package/src/utils/swarm/inProcessRunner.ts

@@ -0,0 +1,1552 @@
+/**
+ * In-process teammate runner
+ *
+ * Wraps runAgent() for in-process teammates, providing:
+ * - AsyncLocalStorage-based context isolation via runWithTeammateContext()
+ * - Progress tracking and AppState updates
+ * - Idle notification to leader when complete
+ * - Plan mode approval flow support
+ * - Cleanup on completion or abort
+ */
+
+import { feature } from 'src/_stubs/bun-bundle.js'
+import type { ContentBlockParam } from '@anthropic-ai/sdk/resources/messages.mjs'
+import { getSystemPrompt } from '../../constants/prompts.js'
+import { TEAMMATE_MESSAGE_TAG } from '../../constants/xml.js'
+import type { CanUseToolFn } from '../../hooks/useCanUseTool.js'
+import {
+  processMailboxPermissionResponse,
+  registerPermissionCallback,
+  unregisterPermissionCallback,
+} from '../../hooks/useSwarmPermissionPoller.js'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../../services/analytics/index.js'
+import { getAutoCompactThreshold } from '../../services/compact/autoCompact.js'
+import {
+  buildPostCompactMessages,
+  compactConversation,
+  ERROR_MESSAGE_USER_ABORT,
+} from '../../services/compact/compact.js'
+import { resetMicrocompactState } from '../../services/compact/microCompact.js'
+import type { AppState } from '../../state/AppState.js'
+import type { Tool, ToolUseContext } from '../../Tool.js'
+import { appendTeammateMessage } from '../../tasks/InProcessTeammateTask/InProcessTeammateTask.js'
+import type {
+  InProcessTeammateTaskState,
+  TeammateIdentity,
+} from '../../tasks/InProcessTeammateTask/types.js'
+import { appendCappedMessage } from '../../tasks/InProcessTeammateTask/types.js'
+import {
+  createActivityDescriptionResolver,
+  createProgressTracker,
+  getProgressUpdate,
+  updateProgressFromMessage,
+} from '../../tasks/LocalAgentTask/LocalAgentTask.js'
+import type { CustomAgentDefinition } from '../../tools/AgentTool/loadAgentsDir.js'
+import { runAgent } from '../../tools/AgentTool/runAgent.js'
+import { awaitClassifierAutoApproval } from '../../tools/BashTool/bashPermissions.js'
+import { BASH_TOOL_NAME } from '../../tools/BashTool/toolName.js'
+import { SEND_MESSAGE_TOOL_NAME } from '../../tools/SendMessageTool/constants.js'
+import { TASK_CREATE_TOOL_NAME } from '../../tools/TaskCreateTool/constants.js'
+import { TASK_GET_TOOL_NAME } from '../../tools/TaskGetTool/constants.js'
+import { TASK_LIST_TOOL_NAME } from '../../tools/TaskListTool/constants.js'
+import { TASK_UPDATE_TOOL_NAME } from '../../tools/TaskUpdateTool/constants.js'
+import { TEAM_CREATE_TOOL_NAME } from '../../tools/TeamCreateTool/constants.js'
+import { TEAM_DELETE_TOOL_NAME } from '../../tools/TeamDeleteTool/constants.js'
+import type { Message } from '../../types/message.js'
+import type { PermissionDecision } from '../../types/permissions.js'
+import {
+  createAssistantAPIErrorMessage,
+  createUserMessage,
+} from '../../utils/messages.js'
+import { evictTaskOutput } from '../../utils/task/diskOutput.js'
+import { evictTerminalTask } from '../../utils/task/framework.js'
+import { tokenCountWithEstimation } from '../../utils/tokens.js'
+import { createAbortController } from '../abortController.js'
+import { type AgentContext, runWithAgentContext } from '../agentContext.js'
+import { count } from '../array.js'
+import { logForDebugging } from '../debug.js'
+import { cloneFileStateCache } from '../fileStateCache.js'
+import {
+  SUBAGENT_REJECT_MESSAGE,
+  SUBAGENT_REJECT_MESSAGE_WITH_REASON_PREFIX,
+} from '../messages.js'
+import type { ModelAlias } from '../model/aliases.js'
+import {
+  applyPermissionUpdates,
+  persistPermissionUpdates,
+} from '../permissions/PermissionUpdate.js'
+import type { PermissionUpdate } from '../permissions/PermissionUpdateSchema.js'
+import { hasPermissionsToUseTool } from '../permissions/permissions.js'
+import { emitTaskTerminatedSdk } from '../sdkEventQueue.js'
+import { sleep } from '../sleep.js'
+import { jsonStringify } from '../slowOperations.js'
+import { asSystemPrompt } from '../systemPromptType.js'
+import { claimTask, listTasks, type Task, updateTask } from '../tasks.js'
+import type { TeammateContext } from '../teammateContext.js'
+import { runWithTeammateContext } from '../teammateContext.js'
+import {
+  createIdleNotification,
+  getLastPeerDmSummary,
+  isPermissionResponse,
+  isShutdownRequest,
+  markMessageAsReadByIndex,
+  readMailbox,
+  writeToMailbox,
+} from '../teammateMailbox.js'
+import { unregisterAgent as unregisterPerfettoAgent } from '../telemetry/perfettoTracing.js'
+import { createContentReplacementState } from '../toolResultStorage.js'
+import { TEAM_LEAD_NAME } from './constants.js'
+import {
+  getLeaderSetToolPermissionContext,
+  getLeaderToolUseConfirmQueue,
+} from './leaderPermissionBridge.js'
+import {
+  createPermissionRequest,
+  sendPermissionRequestViaMailbox,
+} from './permissionSync.js'
+import { TEAMMATE_SYSTEM_PROMPT_ADDENDUM } from './teammatePromptAddendum.js'
+
+type SetAppStateFn = (updater: (prev: AppState) => AppState) => void
+
+const PERMISSION_POLL_INTERVAL_MS = 500
+
+/**
+ * Creates a canUseTool function for in-process teammates that properly resolves
+ * 'ask' permissions via the UI rather than treating them as denials.
+ *
+ * Always uses the leader's ToolUseConfirm dialog with a worker badge when
+ * the bridge is available, giving teammates the same tool-specific UI
+ * (BashPermissionRequest, FileEditToolDiff, etc.) as the leader's own tools.
+ *
+ * Falls back to the mailbox system when the bridge is unavailable:
+ * sends a permission request to the leader's inbox, waits for the response
+ * in the teammate's own mailbox.
+ */
+function createInProcessCanUseTool(
+  identity: TeammateIdentity,
+  abortController: AbortController,
+  onPermissionWaitMs?: (waitMs: number) => void,
+): CanUseToolFn {
+  return async (
+    tool,
+    input,
+    toolUseContext,
+    assistantMessage,
+    toolUseID,
+    forceDecision,
+  ) => {
+    const result =
+      forceDecision ??
+      (await hasPermissionsToUseTool(
+        tool,
+        input,
+        toolUseContext,
+        assistantMessage,
+        toolUseID,
+      ))
+
+    // Pass through allow/deny decisions directly
+    if (result.behavior !== 'ask') {
+      return result
+    }
+
+    // For bash commands, try classifier auto-approval before showing leader dialog.
+    // Agents await the classifier result (rather than racing it against user
+    // interaction like the main agent).
+    if (
+      feature('BASH_CLASSIFIER') &&
+      tool.name === BASH_TOOL_NAME &&
+      result.pendingClassifierCheck
+    ) {
+      const classifierDecision = await awaitClassifierAutoApproval(
+        result.pendingClassifierCheck,
+        abortController.signal,
+        toolUseContext.options.isNonInteractiveSession,
+      )
+      if (classifierDecision) {
+        return {
+          behavior: 'allow',
+          updatedInput: input as Record<string, unknown>,
+          decisionReason: classifierDecision,
+        }
+      }
+    }
+
+    // Check if aborted before showing UI
+    if (abortController.signal.aborted) {
+      return { behavior: 'ask', message: SUBAGENT_REJECT_MESSAGE }
+    }
+
+    const appState = toolUseContext.getAppState()
+
+    const description = await (tool as Tool).description(input as never, {
+      isNonInteractiveSession: toolUseContext.options.isNonInteractiveSession,
+      toolPermissionContext: appState.toolPermissionContext,
+      tools: toolUseContext.options.tools,
+    })
+
+    if (abortController.signal.aborted) {
+      return { behavior: 'ask', message: SUBAGENT_REJECT_MESSAGE }
+    }
+
+    const setToolUseConfirmQueue = getLeaderToolUseConfirmQueue()
+
+    // Standard path: use ToolUseConfirm dialog with worker badge
+    if (setToolUseConfirmQueue) {
+      return new Promise<PermissionDecision>(resolve => {
+        let decisionMade = false
+        const permissionStartMs = Date.now()
+
+        // Report permission wait time to the caller so it can be
+        // subtracted from the displayed elapsed time.
+        const reportPermissionWait = () => {
+          onPermissionWaitMs?.(Date.now() - permissionStartMs)
+        }
+
+        const onAbortListener = () => {
+          if (decisionMade) return
+          decisionMade = true
+          reportPermissionWait()
+          resolve({ behavior: 'ask', message: SUBAGENT_REJECT_MESSAGE })
+          setToolUseConfirmQueue(queue =>
+            queue.filter(item => item.toolUseID !== toolUseID),
+          )
+        }
+
+        abortController.signal.addEventListener('abort', onAbortListener, {
+          once: true,
+        })
+
+        setToolUseConfirmQueue(queue => [
+          ...queue,
+          {
+            assistantMessage,
+            tool: tool as Tool,
+            description,
+            input,
+            toolUseContext,
+            toolUseID,
+            permissionResult: result,
+            permissionPromptStartTimeMs: permissionStartMs,
+            workerBadge: identity.color
+              ? { name: identity.agentName, color: identity.color }
+              : undefined,
+            onUserInteraction() {
+              // No-op for teammates (no classifier auto-approval)
+            },
+            onAbort() {
+              if (decisionMade) return
+              decisionMade = true
+              abortController.signal.removeEventListener(
+                'abort',
+                onAbortListener,
+              )
+              reportPermissionWait()
+              resolve({ behavior: 'ask', message: SUBAGENT_REJECT_MESSAGE })
+            },
+            async onAllow(
+              updatedInput: Record<string, unknown>,
+              permissionUpdates: PermissionUpdate[],
+              feedback?: string,
+              contentBlocks?: ContentBlockParam[],
+            ) {
+              if (decisionMade) return
+              decisionMade = true
+              abortController.signal.removeEventListener(
+                'abort',
+                onAbortListener,
+              )
+              reportPermissionWait()
+              persistPermissionUpdates(permissionUpdates)
+              // Write back permission updates to the leader's shared context
+              if (permissionUpdates.length > 0) {
+                const setToolPermissionContext =
+                  getLeaderSetToolPermissionContext()
+                if (setToolPermissionContext) {
+                  const currentAppState = toolUseContext.getAppState()
+                  const updatedContext = applyPermissionUpdates(
+                    currentAppState.toolPermissionContext,
+                    permissionUpdates,
+                  )
+                  // Preserve the leader's mode to prevent workers'
+                  // transformed 'acceptEdits' context from leaking back
+                  // to the coordinator
+                  setToolPermissionContext(updatedContext, {
+                    preserveMode: true,
+                  })
+                }
+              }
+              const trimmedFeedback = feedback?.trim()
+              resolve({
+                behavior: 'allow',
+                updatedInput,
+                userModified: false,
+                acceptFeedback: trimmedFeedback || undefined,
+                ...(contentBlocks &&
+                  contentBlocks.length > 0 && { contentBlocks }),
+              })
+            },
+            onReject(feedback?: string, contentBlocks?: ContentBlockParam[]) {
+              if (decisionMade) return
+              decisionMade = true
+              abortController.signal.removeEventListener(
+                'abort',
+                onAbortListener,
+              )
+              reportPermissionWait()
+              const message = feedback
+                ? `${SUBAGENT_REJECT_MESSAGE_WITH_REASON_PREFIX}${feedback}`
+                : SUBAGENT_REJECT_MESSAGE
+              resolve({ behavior: 'ask', message, contentBlocks })
+            },
+            async recheckPermission() {
+              if (decisionMade) return
+              const freshResult = await hasPermissionsToUseTool(
+                tool,
+                input,
+                toolUseContext,
+                assistantMessage,
+                toolUseID,
+              )
+              if (freshResult.behavior === 'allow') {
+                decisionMade = true
+                abortController.signal.removeEventListener(
+                  'abort',
+                  onAbortListener,
+                )
+                reportPermissionWait()
+                setToolUseConfirmQueue(queue =>
+                  queue.filter(item => item.toolUseID !== toolUseID),
+                )
+                resolve({
+                  ...freshResult,
+                  updatedInput: input,
+                  userModified: false,
+                })
+              }
+            },
+          },
+        ])
+      })
+    }
+
+    // Fallback: use mailbox system when leader UI queue is unavailable
+    return new Promise<PermissionDecision>(resolve => {
+      const request = createPermissionRequest({
+        toolName: (tool as Tool).name,
+        toolUseId: toolUseID,
+        input,
+        description,
+        permissionSuggestions: result.suggestions,
+        workerId: identity.agentId,
+        workerName: identity.agentName,
+        workerColor: identity.color,
+        teamName: identity.teamName,
+      })
+
+      // Register callback to be invoked when the leader responds
+      registerPermissionCallback({
+        requestId: request.id,
+        toolUseId: toolUseID,
+        onAllow(
+          updatedInput: Record<string, unknown> | undefined,
+          permissionUpdates: PermissionUpdate[],
+          _feedback?: string,
+          contentBlocks?: ContentBlockParam[],
+        ) {
+          cleanup()
+          persistPermissionUpdates(permissionUpdates)
+          const finalInput =
+            updatedInput && Object.keys(updatedInput).length > 0
+              ? updatedInput
+              : input
+          resolve({
+            behavior: 'allow',
+            updatedInput: finalInput,
+            userModified: false,
+            ...(contentBlocks && contentBlocks.length > 0 && { contentBlocks }),
+          })
+        },
+        onReject(feedback?: string, contentBlocks?: ContentBlockParam[]) {
+          cleanup()
+          const message = feedback
+            ? `${SUBAGENT_REJECT_MESSAGE_WITH_REASON_PREFIX}${feedback}`
+            : SUBAGENT_REJECT_MESSAGE
+          resolve({ behavior: 'ask', message, contentBlocks })
+        },
+      })
+
+      // Send request to leader's mailbox
+      void sendPermissionRequestViaMailbox(request)
+
+      // Poll teammate's mailbox for the response
+      const pollInterval = setInterval(
+        async (abortController, cleanup, resolve, identity, request) => {
+          if (abortController.signal.aborted) {
+            cleanup()
+            resolve({ behavior: 'ask', message: SUBAGENT_REJECT_MESSAGE })
+            return
+          }
+
+          const allMessages = await readMailbox(
+            identity.agentName,
+            identity.teamName,
+          )
+          for (let i = 0; i < allMessages.length; i++) {
+            const msg = allMessages[i]
+            if (msg && !msg.read) {
+              const parsed = isPermissionResponse(msg.text)
+              if (parsed && parsed.request_id === request.id) {
+                await markMessageAsReadByIndex(
+                  identity.agentName,
+                  identity.teamName,
+                  i,
+                )
+                if (parsed.subtype === 'success') {
+                  processMailboxPermissionResponse({
+                    requestId: parsed.request_id,
+                    decision: 'approved',
+                    updatedInput: parsed.response?.updated_input,
+                    permissionUpdates: parsed.response?.permission_updates,
+                  })
+                } else {
+                  processMailboxPermissionResponse({
+                    requestId: parsed.request_id,
+                    decision: 'rejected',
+                    feedback: parsed.error,
+                  })
+                }
+                return // Callback already resolves the promise
+              }
+            }
+          }
+        },
+        PERMISSION_POLL_INTERVAL_MS,
+        abortController,
+        cleanup,
+        resolve,
+        identity,
+        request,
+      )
+
+      const onAbortListener = () => {
+        cleanup()
+        resolve({ behavior: 'ask', message: SUBAGENT_REJECT_MESSAGE })
+      }
+
+      abortController.signal.addEventListener('abort', onAbortListener, {
+        once: true,
+      })
+
+      function cleanup() {
+        clearInterval(pollInterval)
+        unregisterPermissionCallback(request.id)
+        abortController.signal.removeEventListener('abort', onAbortListener)
+      }
+    })
+  }
+}
+
+/**
+ * Formats a message as <teammate-message> XML for injection into the conversation.
+ * This ensures the model sees messages in the same format as tmux teammates.
+ */
+function formatAsTeammateMessage(
+  from: string,
+  content: string,
+  color?: string,
+  summary?: string,
+): string {
+  const colorAttr = color ? ` color="${color}"` : ''
+  const summaryAttr = summary ? ` summary="${summary}"` : ''
+  return `<${TEAMMATE_MESSAGE_TAG} teammate_id="${from}"${colorAttr}${summaryAttr}>\n${content}\n</${TEAMMATE_MESSAGE_TAG}>`
+}
+
+/**
+ * Configuration for running an in-process teammate.
+ */
+export type InProcessRunnerConfig = {
+  /** Teammate identity for context */
+  identity: TeammateIdentity
+  /** Task ID in AppState */
+  taskId: string
+  /** Initial prompt for the teammate */
+  prompt: string
+  /** Optional agent definition (for specialized agents) */
+  agentDefinition?: CustomAgentDefinition
+  /** Teammate context for AsyncLocalStorage */
+  teammateContext: TeammateContext
+  /** Parent's tool use context */
+  toolUseContext: ToolUseContext
+  /** Abort controller linked to parent */
+  abortController: AbortController
+  /** Optional model override for this teammate */
+  model?: string
+  /** Optional system prompt override for this teammate */
+  systemPrompt?: string
+  /** How to apply the system prompt: 'replace' or 'append' to default */
+  systemPromptMode?: 'default' | 'replace' | 'append'
+  /** Tool permissions to auto-allow for this teammate */
+  allowedTools?: string[]
+  /** Whether this teammate can show permission prompts for unlisted tools.
+   * When false (default), unlisted tools are auto-denied. */
+  allowPermissionPrompts?: boolean
+  /** Short description of the task (used as summary for the initial prompt header) */
+  description?: string
+  /** request_id of the API call that spawned this teammate, for lineage
+   *  tracing on tengu_api_* events. */
+  invokingRequestId?: string
+}
+
+/**
+ * Result from running an in-process teammate.
+ */
+export type InProcessRunnerResult = {
+  /** Whether the run completed successfully */
+  success: boolean
+  /** Error message if failed */
+  error?: string
+  /** Messages produced by the agent */
+  messages: Message[]
+}
+
+/**
+ * Updates task state in AppState.
+ */
+function updateTaskState(
+  taskId: string,
+  updater: (task: InProcessTeammateTaskState) => InProcessTeammateTaskState,
+  setAppState: SetAppStateFn,
+): void {
+  setAppState(prev => {
+    const task = prev.tasks[taskId]
+    if (!task || task.type !== 'in_process_teammate') {
+      return prev
+    }
+    const updated = updater(task)
+    if (updated === task) {
+      return prev
+    }
+    return {
+      ...prev,
+      tasks: {
+        ...prev.tasks,
+        [taskId]: updated,
+      },
+    }
+  })
+}
+
+/**
+ * Sends a message to the leader's file-based mailbox.
+ * Uses the same mailbox system as tmux teammates for consistency.
+ */
+async function sendMessageToLeader(
+  from: string,
+  text: string,
+  color: string | undefined,
+  teamName: string,
+): Promise<void> {
+  await writeToMailbox(
+    TEAM_LEAD_NAME,
+    {
+      from,
+      text,
+      timestamp: new Date().toISOString(),
+      color,
+    },
+    teamName,
+  )
+}
+
+/**
+ * Sends idle notification to the leader via file-based mailbox.
+ * Uses agentName (not agentId) for consistency with process-based teammates.
+ */
+async function sendIdleNotification(
+  agentName: string,
+  agentColor: string | undefined,
+  teamName: string,
+  options?: {
+    idleReason?: 'available' | 'interrupted' | 'failed'
+    summary?: string
+    completedTaskId?: string
+    completedStatus?: 'resolved' | 'blocked' | 'failed'
+    failureReason?: string
+  },
+): Promise<void> {
+  const notification = createIdleNotification(agentName, options)
+
+  await sendMessageToLeader(
+    agentName,
+    jsonStringify(notification),
+    agentColor,
+    teamName,
+  )
+}
+
+/**
+ * Find an available task from the team's task list.
+ * A task is available if it's pending, has no owner, and is not blocked.
+ */
+function findAvailableTask(tasks: Task[]): Task | undefined {
+  const unresolvedTaskIds = new Set(
+    tasks.filter(t => t.status !== 'completed').map(t => t.id),
+  )
+
+  return tasks.find(task => {
+    if (task.status !== 'pending') return false
+    if (task.owner) return false
+    return task.blockedBy.every(id => !unresolvedTaskIds.has(id))
+  })
+}
+
+/**
+ * Format a task as a prompt for the teammate to work on.
+ */
+function formatTaskAsPrompt(task: Task): string {
+  let prompt = `Complete all open tasks. Start with task #${task.id}: \n\n ${task.subject}`
+
+  if (task.description) {
+    prompt += `\n\n${task.description}`
+  }
+
+  return prompt
+}
+
+/**
+ * Try to claim an available task from the team's task list.
+ * Returns the formatted prompt if a task was claimed, or undefined if none available.
+ */
+async function tryClaimNextTask(
+  taskListId: string,
+  agentName: string,
+): Promise<string | undefined> {
+  try {
+    const tasks = await listTasks(taskListId)
+    const availableTask = findAvailableTask(tasks)
+
+    if (!availableTask) {
+      return undefined
+    }
+
+    const result = await claimTask(taskListId, availableTask.id, agentName)
+
+    if (!result.success) {
+      logForDebugging(
+        `[inProcessRunner] Failed to claim task #${availableTask.id}: ${result.reason}`,
+      )
+      return undefined
+    }
+
+    // Also set status to in_progress so the UI reflects it immediately
+    await updateTask(taskListId, availableTask.id, { status: 'in_progress' })
+
+    logForDebugging(
+      `[inProcessRunner] Claimed task #${availableTask.id}: ${availableTask.subject}`,
+    )
+
+    return formatTaskAsPrompt(availableTask)
+  } catch (err) {
+    logForDebugging(`[inProcessRunner] Error checking task list: ${err}`)
+    return undefined
+  }
+}
+
+/**
+ * Result of waiting for messages.
+ */
+type WaitResult =
+  | {
+      type: 'shutdown_request'
+      request: ReturnType<typeof isShutdownRequest>
+      originalMessage: string
+    }
+  | {
+      type: 'new_message'
+      message: string
+      from: string
+      color?: string
+      summary?: string
+    }
+  | {
+      type: 'aborted'
+    }
+
+/**
+ * Waits for new prompts or shutdown request.
+ * Polls the teammate's mailbox every 500ms, checking for:
+ * - Shutdown request from leader (returned to caller for model decision)
+ * - New messages/prompts from leader
+ * - Abort signal
+ *
+ * This keeps the teammate alive in 'idle' state instead of terminating.
+ * Does NOT auto-approve shutdown - the model should make that decision.
+ */
+async function waitForNextPromptOrShutdown(
+  identity: TeammateIdentity,
+  abortController: AbortController,
+  taskId: string,
+  getAppState: () => AppState,
+  setAppState: SetAppStateFn,
+  taskListId: string,
+): Promise<WaitResult> {
+  const POLL_INTERVAL_MS = 500
+
+  logForDebugging(
+    `[inProcessRunner] ${identity.agentName} starting poll loop (abort=${abortController.signal.aborted})`,
+  )
+
+  let pollCount = 0
+  while (!abortController.signal.aborted) {
+    // Check for in-memory pending messages on every iteration (from transcript viewing)
+    const appState = getAppState()
+    const task = appState.tasks[taskId]
+    if (
+      task &&
+      task.type === 'in_process_teammate' &&
+      task.pendingUserMessages.length > 0
+    ) {
+      const message = task.pendingUserMessages[0]! // Safe: checked length > 0
+      // Pop the message from the queue
+      setAppState(prev => {
+        const prevTask = prev.tasks[taskId]
+        if (!prevTask || prevTask.type !== 'in_process_teammate') {
+          return prev
+        }
+        return {
+          ...prev,
+          tasks: {
+            ...prev.tasks,
+            [taskId]: {
+              ...prevTask,
+              pendingUserMessages: prevTask.pendingUserMessages.slice(1),
+            },
+          },
+        }
+      })
+      logForDebugging(
+        `[inProcessRunner] ${identity.agentName} found pending user message (poll #${pollCount})`,
+      )
+      return {
+        type: 'new_message',
+        message,
+        from: 'user',
+      }
+    }
+
+    // Wait before next poll (skip on first iteration to check immediately)
+    if (pollCount > 0) {
+      await sleep(POLL_INTERVAL_MS)
+    }
+    pollCount++
+
+    // Check for abort
+    if (abortController.signal.aborted) {
+      logForDebugging(
+        `[inProcessRunner] ${identity.agentName} aborted while waiting (poll #${pollCount})`,
+      )
+      return { type: 'aborted' }
+    }
+
+    // Check for messages in mailbox
+    logForDebugging(
+      `[inProcessRunner] ${identity.agentName} poll #${pollCount}: checking mailbox`,
+    )
+    try {
+      // Read all messages and scan unread for shutdown requests first.
+      // Shutdown requests are prioritized over regular messages to prevent
+      // starvation when peer-to-peer messages flood the queue.
+      const allMessages = await readMailbox(
+        identity.agentName,
+        identity.teamName,
+      )
+
+      // Scan all unread messages for shutdown requests (highest priority).
+      // readMailbox() already reads all messages from disk, so this scan
+      // adds only ~1-2ms of JSON parsing overhead.
+      let shutdownIndex = -1
+      let shutdownParsed: ReturnType<typeof isShutdownRequest> = null
+      for (let i = 0; i < allMessages.length; i++) {
+        const m = allMessages[i]
+        if (m && !m.read) {
+          const parsed = isShutdownRequest(m.text)
+          if (parsed) {
+            shutdownIndex = i
+            shutdownParsed = parsed
+            break
+          }
+        }
+      }
+
+      if (shutdownIndex !== -1) {
+        const msg = allMessages[shutdownIndex]!
+        const skippedUnread = count(
+          allMessages.slice(0, shutdownIndex),
+          m => !m.read,
+        )
+        logForDebugging(
+          `[inProcessRunner] ${identity.agentName} received shutdown request from ${shutdownParsed?.from} (prioritized over ${skippedUnread} unread messages)`,
+        )
+        await markMessageAsReadByIndex(
+          identity.agentName,
+          identity.teamName,
+          shutdownIndex,
+        )
+        return {
+          type: 'shutdown_request',
+          request: shutdownParsed,
+          originalMessage: msg.text,
+        }
+      }
+
+      // No shutdown request found. Prioritize team-lead messages over peer
+      // messages — the leader represents user intent and coordination, so
+      // their messages should not be starved behind peer-to-peer chatter.
+      // Fall back to FIFO for peer messages.
+      let selectedIndex = -1
+
+      // Check for unread team-lead messages first
+      for (let i = 0; i < allMessages.length; i++) {
+        const m = allMessages[i]
+        if (m && !m.read && m.from === TEAM_LEAD_NAME) {
+          selectedIndex = i
+          break
+        }
+      }
+
+      // Fall back to first unread message (any sender)
+      if (selectedIndex === -1) {
+        selectedIndex = allMessages.findIndex(m => !m.read)
+      }
+
+      if (selectedIndex !== -1) {
+        const msg = allMessages[selectedIndex]
+        if (msg) {
+          logForDebugging(
+            `[inProcessRunner] ${identity.agentName} received new message from ${msg.from} (index ${selectedIndex})`,
+          )
+          await markMessageAsReadByIndex(
+            identity.agentName,
+            identity.teamName,
+            selectedIndex,
+          )
+          return {
+            type: 'new_message',
+            message: msg.text,
+            from: msg.from,
+            color: msg.color,
+            summary: msg.summary,
+          }
+        }
+      }
+    } catch (err) {
+      logForDebugging(
+        `[inProcessRunner] ${identity.agentName} poll error: ${err}`,
+      )
+      // Continue polling even if one read fails
+    }
+
+    // Check the team's task list for unclaimed tasks
+    const taskPrompt = await tryClaimNextTask(taskListId, identity.agentName)
+    if (taskPrompt) {
+      return {
+        type: 'new_message',
+        message: taskPrompt,
+        from: 'task-list',
+      }
+    }
+  }
+
+  logForDebugging(
+    `[inProcessRunner] ${identity.agentName} exiting poll loop (abort=${abortController.signal.aborted}, polls=${pollCount})`,
+  )
+  return { type: 'aborted' }
+}
+
+/**
+ * Runs an in-process teammate with a continuous prompt loop.
+ *
+ * Executes runAgent() within the teammate's AsyncLocalStorage context,
+ * tracks progress, updates task state, sends idle notification on completion,
+ * then waits for new prompts or shutdown requests.
+ *
+ * Unlike background tasks, teammates stay alive and can receive multiple prompts.
+ * The loop only exits on abort or after shutdown is approved by the model.
+ *
+ * @param config - Runner configuration
+ * @returns Result with messages and success status
+ */
+export async function runInProcessTeammate(
+  config: InProcessRunnerConfig,
+): Promise<InProcessRunnerResult> {
+  const {
+    identity,
+    taskId,
+    prompt,
+    description,
+    agentDefinition,
+    teammateContext,
+    toolUseContext,
+    abortController,
+    model,
+    systemPrompt,
+    systemPromptMode,
+    allowedTools,
+    allowPermissionPrompts,
+    invokingRequestId,
+  } = config
+  const { setAppState } = toolUseContext
+
+  logForDebugging(
+    `[inProcessRunner] Starting agent loop for ${identity.agentId}`,
+  )
+
+  // Create AgentContext for analytics attribution
+  const agentContext: AgentContext = {
+    agentId: identity.agentId,
+    parentSessionId: identity.parentSessionId,
+    agentName: identity.agentName,
+    teamName: identity.teamName,
+    agentColor: identity.color,
+    planModeRequired: identity.planModeRequired,
+    isTeamLead: false,
+    agentType: 'teammate',
+    invokingRequestId,
+    invocationKind: 'spawn',
+    invocationEmitted: false,
+  }
+
+  // Build system prompt based on systemPromptMode
+  let teammateSystemPrompt: string
+  if (systemPromptMode === 'replace' && systemPrompt) {
+    teammateSystemPrompt = systemPrompt
+  } else {
+    const fullSystemPromptParts = await getSystemPrompt(
+      toolUseContext.options.tools,
+      toolUseContext.options.mainLoopModel,
+      undefined,
+      toolUseContext.options.mcpClients,
+    )
+
+    const systemPromptParts = [
+      ...fullSystemPromptParts,
+      TEAMMATE_SYSTEM_PROMPT_ADDENDUM,
+    ]
+
+    // If custom agent definition provided, append its prompt
+    if (agentDefinition) {
+      const customPrompt = agentDefinition.getSystemPrompt()
+      if (customPrompt) {
+        systemPromptParts.push(`\n# Custom Agent Instructions\n${customPrompt}`)
+      }
+
+      // Log agent memory loaded event for in-process teammates
+      if (agentDefinition.memory) {
+        logEvent('tengu_agent_memory_loaded', {
+          ...(process.env.USER_TYPE === 'ant'
+            ? {
+                agent_type:
+                  agentDefinition.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+              }
+            : {}),
+          scope:
+            agentDefinition.memory as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          source:
+            'in-process-teammate' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        })
+      }
+    }
+
+    // Append mode: add provided system prompt after default
+    if (systemPromptMode === 'append' && systemPrompt) {
+      systemPromptParts.push(systemPrompt)
+    }
+
+    teammateSystemPrompt = systemPromptParts.join('\n')
+  }
+
+  // Resolve agent definition - use full system prompt with teammate addendum
+  // IMPORTANT: Set permissionMode to 'default' so teammates always get full tool
+  // access regardless of the leader's permission mode.
+  const resolvedAgentDefinition: CustomAgentDefinition = {
+    agentType: identity.agentName,
+    whenToUse: `In-process teammate: ${identity.agentName}`,
+    getSystemPrompt: () => teammateSystemPrompt,
+    // Inject team-essential tools so teammates can always respond to
+    // shutdown requests, send messages, and coordinate via the task list,
+    // even with explicit tool lists
+    tools: agentDefinition?.tools
+      ? [
+          ...new Set([
+            ...agentDefinition.tools,
+            SEND_MESSAGE_TOOL_NAME,
+            TEAM_CREATE_TOOL_NAME,
+            TEAM_DELETE_TOOL_NAME,
+            TASK_CREATE_TOOL_NAME,
+            TASK_GET_TOOL_NAME,
+            TASK_LIST_TOOL_NAME,
+            TASK_UPDATE_TOOL_NAME,
+          ]),
+        ]
+      : ['*'],
+    source: 'projectSettings',
+    permissionMode: 'default',
+    // Propagate model from custom agent definition so getAgentModel()
+    // can use it as a fallback when no tool-level model is specified
+    ...(agentDefinition?.model ? { model: agentDefinition.model } : {}),
+  }
+
+  // All messages across all prompts
+  const allMessages: Message[] = []
+  // Wrap initial prompt with XML for proper styling in transcript view
+  const wrappedInitialPrompt = formatAsTeammateMessage(
+    'team-lead',
+    prompt,
+    undefined,
+    description,
+  )
+  let currentPrompt = wrappedInitialPrompt
+  let shouldExit = false
+
+  // Try to claim an available task immediately so the UI can show activity
+  // from the very start. The idle loop handles claiming for subsequent tasks.
+  // Use parentSessionId as the task list ID since the leader creates tasks
+  // under its session ID, not the team name.
+  await tryClaimNextTask(identity.parentSessionId, identity.agentName)
+
+  try {
+    // Add initial prompt to task.messages for display (wrapped with XML)
+    updateTaskState(
+      taskId,
+      task => ({
+        ...task,
+        messages: appendCappedMessage(
+          task.messages,
+          createUserMessage({ content: wrappedInitialPrompt }),
+        ),
+      }),
+      setAppState,
+    )
+
+    // Per-teammate content replacement state. The while-loop below calls
+    // runAgent repeatedly over an accumulating `allMessages` buffer (which
+    // carries FULL original tool result content, not previews — query() yields
+    // originals, enforcement is non-mutating). Without persisting state across
+    // iterations, each call gets a fresh empty state from createSubagentContext
+    // and makes holistic replace-globally-largest decisions, diverging from
+    // earlier iterations' incremental frozen-first decisions → wire prefix
+    // differs → cache miss. Gated on parent to inherit feature-flag-off.
+    let teammateReplacementState = toolUseContext.contentReplacementState
+      ? createContentReplacementState()
+      : undefined
+
+    // Main teammate loop - runs until abort or shutdown approved
+    while (!abortController.signal.aborted && !shouldExit) {
+      logForDebugging(
+        `[inProcessRunner] ${identity.agentId} processing prompt: ${currentPrompt.substring(0, 50)}...`,
+      )
+
+      // Create a per-turn abort controller for this iteration.
+      // This allows Escape to stop current work without killing the whole teammate.
+      // The lifecycle abortController still kills the whole teammate if needed.
+      const currentWorkAbortController = createAbortController()
+
+      // Store the work controller in task state so UI can abort it
+      updateTaskState(
+        taskId,
+        task => ({ ...task, currentWorkAbortController }),
+        setAppState,
+      )
+
+      // Prepare prompt messages for this iteration
+      // For the first iteration, start fresh
+      // For subsequent iterations, pass accumulated messages as context
+      const userMessage = createUserMessage({ content: currentPrompt })
+      const promptMessages: Message[] = [userMessage]
+
+      // Check if compaction is needed before building context
+      let contextMessages = allMessages
+      const tokenCount = tokenCountWithEstimation(allMessages)
+      if (
+        tokenCount >
+        getAutoCompactThreshold(toolUseContext.options.mainLoopModel)
+      ) {
+        logForDebugging(
+          `[inProcessRunner] ${identity.agentId} compacting history (${tokenCount} tokens)`,
+        )
+        // Create an isolated copy of toolUseContext so that compaction
+        // does not clear the main session's readFileState cache or
+        // trigger the main session's UI callbacks.
+        const isolatedContext: ToolUseContext = {
+          ...toolUseContext,
+          readFileState: cloneFileStateCache(toolUseContext.readFileState),
+          onCompactProgress: undefined,
+          setStreamMode: undefined,
+        }
+        const compactedSummary = await compactConversation(
+          allMessages,
+          isolatedContext,
+          {
+            systemPrompt: asSystemPrompt([]),
+            userContext: {},
+            systemContext: {},
+            toolUseContext: isolatedContext,
+            forkContextMessages: [],
+          },
+          true, // suppressFollowUpQuestions
+          undefined, // customInstructions
+          true, // isAutoCompact
+        )
+        contextMessages = buildPostCompactMessages(compactedSummary)
+        // Reset microcompact state since full compact replaces all
+        // messages — old tool IDs are no longer relevant
+        resetMicrocompactState()
+        // Reset content replacement state — compact replaces all messages
+        // so old tool_use_ids are gone. Stale Map entries are harmless
+        // (UUID keys never match) but accumulate memory over long runs.
+        if (teammateReplacementState) {
+          teammateReplacementState = createContentReplacementState()
+        }
+        // Update allMessages in place with compacted version
+        allMessages.length = 0
+        allMessages.push(...contextMessages)
+
+        // Mirror compaction into task.messages — otherwise the AppState
+        // mirror grows unbounded (500 turns = 500+ messages, 10-50MB).
+        // Replace with the compacted messages, matching allMessages.
+        updateTaskState(
+          taskId,
+          task => ({ ...task, messages: [...contextMessages, userMessage] }),
+          setAppState,
+        )
+      }
+
+      // Pass previous messages as context to preserve conversation history
+      // allMessages accumulates all previous messages (user + assistant) from prior iterations
+      const forkContextMessages =
+        contextMessages.length > 0 ? [...contextMessages] : undefined
+
+      // Add the user message to allMessages so it's included in future context
+      // This ensures the full conversation (user + assistant turns) is preserved
+      allMessages.push(userMessage)
+
+      // Create fresh progress tracker for this prompt
+      const tracker = createProgressTracker()
+      const resolveActivity = createActivityDescriptionResolver(
+        toolUseContext.options.tools,
+      )
+      const iterationMessages: Message[] = []
+
+      // Read current permission mode from task state (may have been cycled by leader via Shift+Tab)
+      const currentAppState = toolUseContext.getAppState()
+      const currentTask = currentAppState.tasks[taskId]
+      const currentPermissionMode =
+        currentTask && currentTask.type === 'in_process_teammate'
+          ? currentTask.permissionMode
+          : 'default'
+      const iterationAgentDefinition = {
+        ...resolvedAgentDefinition,
+        permissionMode: currentPermissionMode,
+      }
+
+      // Track if this iteration was interrupted by work abort (not lifecycle abort)
+      let workWasAborted = false
+
+      // Run agent within contexts
+      await runWithTeammateContext(teammateContext, async () => {
+        return runWithAgentContext(agentContext, async () => {
+          // Mark task as running (not idle)
+          updateTaskState(
+            taskId,
+            task => ({ ...task, status: 'running', isIdle: false }),
+            setAppState,
+          )
+
+          // Run the normal agent loop - same runAgent() used by AgentTool/subagents.
+          // This calls query() internally, so we share the core API infrastructure.
+          // Pass forkContextMessages to preserve conversation history across prompts.
+          // In-process teammates are async but run in the same process as the leader,
+          // so they CAN show permission prompts (unlike true background agents).
+          // Use currentWorkAbortController so Escape stops this turn only, not the teammate.
+          for await (const message of runAgent({
+            agentDefinition: iterationAgentDefinition,
+            promptMessages,
+            toolUseContext,
+            canUseTool: createInProcessCanUseTool(
+              identity,
+              currentWorkAbortController,
+              (waitMs: number) => {
+                updateTaskState(
+                  taskId,
+                  task => ({
+                    ...task,
+                    totalPausedMs: (task.totalPausedMs ?? 0) + waitMs,
+                  }),
+                  setAppState,
+                )
+              },
+            ),
+            isAsync: true,
+            canShowPermissionPrompts: allowPermissionPrompts ?? true,
+            forkContextMessages,
+            querySource: 'agent:custom',
+            override: { abortController: currentWorkAbortController },
+            model: model as ModelAlias | undefined,
+            preserveToolUseResults: true,
+            availableTools: toolUseContext.options.tools,
+            allowedTools,
+            contentReplacementState: teammateReplacementState,
+          })) {
+            // Check lifecycle abort first (kills whole teammate)
+            if (abortController.signal.aborted) {
+              logForDebugging(
+                `[inProcessRunner] ${identity.agentId} lifecycle aborted`,
+              )
+              break
+            }
+
+            // Check work abort (stops current turn only)
+            if (currentWorkAbortController.signal.aborted) {
+              logForDebugging(
+                `[inProcessRunner] ${identity.agentId} current work aborted (Escape pressed)`,
+              )
+              workWasAborted = true
+              break
+            }
+
+            iterationMessages.push(message)
+            allMessages.push(message)
+
+            updateProgressFromMessage(
+              tracker,
+              message,
+              resolveActivity,
+              toolUseContext.options.tools,
+            )
+            const progress = getProgressUpdate(tracker)
+
+            updateTaskState(
+              taskId,
+              task => {
+                // Track in-progress tool use IDs for animation in transcript view
+                let inProgressToolUseIDs = task.inProgressToolUseIDs
+                if (message.type === 'assistant') {
+                  for (const block of message.message.content) {
+                    if (block.type === 'tool_use') {
+                      inProgressToolUseIDs = new Set([
+                        ...(inProgressToolUseIDs ?? []),
+                        block.id,
+                      ])
+                    }
+                  }
+                } else if (message.type === 'user') {
+                  const content = message.message.content
+                  if (Array.isArray(content)) {
+                    for (const block of content) {
+                      if (
+                        typeof block === 'object' &&
+                        'type' in block &&
+                        block.type === 'tool_result'
+                      ) {
+                        if (inProgressToolUseIDs) {
+                          inProgressToolUseIDs = new Set(inProgressToolUseIDs)
+                          inProgressToolUseIDs.delete(block.tool_use_id)
+                        }
+                      }
+                    }
+                  }
+                }
+
+                return {
+                  ...task,
+                  progress,
+                  messages: appendCappedMessage(task.messages, message),
+                  inProgressToolUseIDs,
+                }
+              },
+              setAppState,
+            )
+          }
+
+          return { success: true, messages: iterationMessages }
+        })
+      })
+
+      // Clear the work controller from state (it's no longer valid)
+      updateTaskState(
+        taskId,
+        task => ({ ...task, currentWorkAbortController: undefined }),
+        setAppState,
+      )
+
+      // Check if lifecycle aborted during agent run (kills whole teammate)
+      if (abortController.signal.aborted) {
+        break
+      }
+
+      // If work was aborted (Escape), log it and add interrupt message, then continue to idle state
+      if (workWasAborted) {
+        logForDebugging(
+          `[inProcessRunner] ${identity.agentId} work interrupted, returning to idle`,
+        )
+
+        // Add interrupt message to teammate's messages so it appears in their scrollback
+        const interruptMessage = createAssistantAPIErrorMessage({
+          content: ERROR_MESSAGE_USER_ABORT,
+        })
+        updateTaskState(
+          taskId,
+          task => ({
+            ...task,
+            messages: appendCappedMessage(task.messages, interruptMessage),
+          }),
+          setAppState,
+        )
+      }
+
+      // Check if already idle before updating (to skip duplicate notification)
+      const prevAppState = toolUseContext.getAppState()
+      const prevTask = prevAppState.tasks[taskId]
+      const wasAlreadyIdle =
+        prevTask?.type === 'in_process_teammate' && prevTask.isIdle
+
+      // Mark task as idle (NOT completed) and notify any waiters
+      updateTaskState(
+        taskId,
+        task => {
+          // Call any registered idle callbacks
+          task.onIdleCallbacks?.forEach(cb => cb())
+          return { ...task, isIdle: true, onIdleCallbacks: [] }
+        },
+        setAppState,
+      )
+
+      // Note: We do NOT automatically send the teammate's response to the leader.
+      // Teammates should use the Teammate tool to communicate with the leader.
+      // This matches process-based teammates where output is not visible to the leader.
+
+      // Only send idle notification on transition to idle (not if already idle)
+      if (!wasAlreadyIdle) {
+        await sendIdleNotification(
+          identity.agentName,
+          identity.color,
+          identity.teamName,
+          {
+            idleReason: workWasAborted ? 'interrupted' : 'available',
+            summary: getLastPeerDmSummary(allMessages),
+          },
+        )
+      } else {
+        logForDebugging(
+          `[inProcessRunner] Skipping duplicate idle notification for ${identity.agentName}`,
+        )
+      }
+
+      logForDebugging(
+        `[inProcessRunner] ${identity.agentId} finished prompt, waiting for next`,
+      )
+
+      // Wait for next message or shutdown
+      const waitResult = await waitForNextPromptOrShutdown(
+        identity,
+        abortController,
+        taskId,
+        toolUseContext.getAppState,
+        setAppState,
+        identity.parentSessionId,
+      )
+
+      switch (waitResult.type) {
+        case 'shutdown_request':
+          // Pass shutdown request to model for decision
+          // Format as teammate-message for consistency with how tmux teammates receive it
+          // The model will use approveShutdown or rejectShutdown tool
+          logForDebugging(
+            `[inProcessRunner] ${identity.agentId} received shutdown request - passing to model`,
+          )
+          currentPrompt = formatAsTeammateMessage(
+            waitResult.request?.from || 'team-lead',
+            waitResult.originalMessage,
+          )
+          // Add shutdown request to task.messages for transcript display
+          appendTeammateMessage(
+            taskId,
+            createUserMessage({ content: currentPrompt }),
+            setAppState,
+          )
+          break
+
+        case 'new_message':
+          // New prompt from leader or teammate
+          logForDebugging(
+            `[inProcessRunner] ${identity.agentId} received new message from ${waitResult.from}`,
+          )
+          // Messages from the user should be plain text (not wrapped in XML)
+          // Messages from other teammates get XML wrapper for identification
+          if (waitResult.from === 'user') {
+            currentPrompt = waitResult.message
+          } else {
+            currentPrompt = formatAsTeammateMessage(
+              waitResult.from,
+              waitResult.message,
+              waitResult.color,
+              waitResult.summary,
+            )
+            // Add to task.messages for transcript display (only for non-user messages)
+            // Messages from 'user' come from pendingUserMessages which are already
+            // added by injectUserMessageToTeammate
+            appendTeammateMessage(
+              taskId,
+              createUserMessage({ content: currentPrompt }),
+              setAppState,
+            )
+          }
+          break
+
+        case 'aborted':
+          logForDebugging(
+            `[inProcessRunner] ${identity.agentId} aborted while waiting`,
+          )
+          shouldExit = true
+          break
+      }
+    }
+
+    // Mark as completed when exiting the loop
+    let alreadyTerminal = false
+    let toolUseId: string | undefined
+    updateTaskState(
+      taskId,
+      task => {
+        // killInProcessTeammate may have already set status:killed +
+        // notified:true + cleared fields. Don't overwrite (would flip
+        // killed → completed and double-emit the SDK bookend).
+        if (task.status !== 'running') {
+          alreadyTerminal = true
+          return task
+        }
+        toolUseId = task.toolUseId
+        task.onIdleCallbacks?.forEach(cb => cb())
+        task.unregisterCleanup?.()
+        return {
+          ...task,
+          status: 'completed' as const,
+          notified: true,
+          endTime: Date.now(),
+          messages: task.messages?.length ? [task.messages.at(-1)!] : undefined,
+          pendingUserMessages: [],
+          inProgressToolUseIDs: undefined,
+          abortController: undefined,
+          unregisterCleanup: undefined,
+          currentWorkAbortController: undefined,
+          onIdleCallbacks: [],
+        }
+      },
+      setAppState,
+    )
+    void evictTaskOutput(taskId)
+    // Eagerly evict task from AppState since it's been consumed
+    evictTerminalTask(taskId, setAppState)
+    // notified:true pre-set → no XML notification → print.ts won't emit
+    // the SDK task_notification. Close the task_started bookend directly.
+    if (!alreadyTerminal) {
+      emitTaskTerminatedSdk(taskId, 'completed', {
+        toolUseId,
+        summary: identity.agentId,
+      })
+    }
+
+    unregisterPerfettoAgent(identity.agentId)
+    return { success: true, messages: allMessages }
+  } catch (error) {
+    const errorMessage =
+      error instanceof Error ? error.message : 'Unknown error'
+
+    logForDebugging(
+      `[inProcessRunner] Agent ${identity.agentId} failed: ${errorMessage}`,
+    )
+
+    // Mark task as failed and notify any waiters
+    let alreadyTerminal = false
+    let toolUseId: string | undefined
+    updateTaskState(
+      taskId,
+      task => {
+        if (task.status !== 'running') {
+          alreadyTerminal = true
+          return task
+        }
+        toolUseId = task.toolUseId
+        task.onIdleCallbacks?.forEach(cb => cb())
+        task.unregisterCleanup?.()
+        return {
+          ...task,
+          status: 'failed' as const,
+          notified: true,
+          error: errorMessage,
+          isIdle: true,
+          endTime: Date.now(),
+          onIdleCallbacks: [],
+          messages: task.messages?.length ? [task.messages.at(-1)!] : undefined,
+          pendingUserMessages: [],
+          inProgressToolUseIDs: undefined,
+          abortController: undefined,
+          unregisterCleanup: undefined,
+          currentWorkAbortController: undefined,
+        }
+      },
+      setAppState,
+    )
+    void evictTaskOutput(taskId)
+    // Eagerly evict task from AppState since it's been consumed
+    evictTerminalTask(taskId, setAppState)
+    // notified:true pre-set → no XML notification → close SDK bookend directly.
+    if (!alreadyTerminal) {
+      emitTaskTerminatedSdk(taskId, 'failed', {
+        toolUseId,
+        summary: identity.agentId,
+      })
+    }
+
+    // Send idle notification with failure via file-based mailbox
+    await sendIdleNotification(
+      identity.agentName,
+      identity.color,
+      identity.teamName,
+      {
+        idleReason: 'failed',
+        completedStatus: 'failed',
+        failureReason: errorMessage,
+      },
+    )
+
+    unregisterPerfettoAgent(identity.agentId)
+    return {
+      success: false,
+      error: errorMessage,
+      messages: allMessages,
+    }
+  }
+}
+
+/**
+ * Starts an in-process teammate in the background.
+ *
+ * This is the main entry point called after spawn. It starts the agent
+ * execution loop in a fire-and-forget manner.
+ *
+ * @param config - Runner configuration
+ */
+export function startInProcessTeammate(config: InProcessRunnerConfig): void {
+  // Extract agentId before the closure so the catch handler doesn't retain
+  // the full config object (including toolUseContext) while the promise is
+  // pending - which can be hours for a long-running teammate.
+  const agentId = config.identity.agentId
+  void runInProcessTeammate(config).catch(error => {
+    logForDebugging(`[inProcessRunner] Unhandled error in ${agentId}: ${error}`)
+  })
+}