Function run

src/workflow/backends/claudeCodeBackend.ts:207–408

(
    params: AgentRunParams,
    ctx: AgentAdapterContext,
  )

  capabilities: { structuredOutput: true, tools: true },

  async run(
    params: AgentRunParams,
    ctx: AgentAdapterContext,
  ): Promise<AgentRunResult> {
    const { toolUseContext, canUseTool } = readHostBundle(ctx.host)
    const appState = toolUseContext.getAppState()
    const agentDef = resolveAgentDefinition(params.agentType, toolUseContext)
    const model = mapWorkflowModel(params.model)
    // coreAgentId: the tracking ID for the core-layer subagent (a string, used inside runAgent).
    // Different from ctx.agentId (the engine's number seq, used for panel / killAgent routing) - two distinct concepts, must not be mixed up.
    const coreAgentId = createAgentId()

    // isolation:'worktree' - run the agent inside an independent git worktree, so concurrent writes do not conflict.
    let worktreeInfo: WorkflowWorktreeInfo | null = null
    if (params.isolation === 'worktree') {
      try {
        worktreeInfo = await createAgentWorktree(
          makeWorkflowWorktreeSlug(ctx.runId, coreAgentId),
        )
      } catch (e) {
        // fail-closed: when isolation fails, do not silently fall back to a shared cwd (otherwise concurrent writes race on data)
        const detail = (e as Error).message
        logForDebugging(
          `workflow worktree creation failed (${agentDef.agentType}): ${detail}`,
        )
        return { kind: 'dead', reason: 'worktree-failed', detail }
      }
    }
    // runWithCwdOverride makes tools such as Bash/Read inside the agent see the worktree path
    // (AsyncLocalStorage is preserved across awaits); the worktreePath parameter of runAgent only writes metadata.
    const runInCwd = worktreeInfo
      ? <T>(fn: () => T): T =>
          runWithCwdOverride(worktreeInfo!.worktreePath, fn)
      : <T>(fn: () => T): T => fn()

    // Bridge ctx.signal -> runAgent.override.abortController. Otherwise, when the workflow is killed
    // runAgent is unaware (root cause of 'x' being ineffective): the abort signal cannot reach the internal fetch, and the agent runs to completion.
    // Single-agent kill goes through service.kill(runId, agentId) -> ports.taskRegistrar.killAgent ->
    // agentAbortControllers.get(agentId).abort(); the same controller takes over both paths.
    const agentAbort = new AbortController()
    const onParentAbort = (): void => agentAbort.abort()
    if (ctx.signal.aborted) {
      agentAbort.abort()
    } else {
      ctx.signal.addEventListener('abort', onParentAbort, { once: true })
    }
    if (typeof ctx.registerAgentAbort === 'function') {
      ctx.registerAgentAbort(ctx.agentId, agentAbort)
    }

    const workerPermissionContext = {
      ...appState.toolPermissionContext,
      mode: agentDef.permissionMode ?? 'acceptEdits',
    }
    const workerTools = assembleToolPool(
      workerPermissionContext,
      appState.mcp.tools,
    )