@agentclientprotocol/claude-agent-acp 0.100.1-preview.1 → 0.100.1-preview.2

package/dist/background-work.js

@@ -29,173 +29,351 @@
 import { RequestError } from "@agentclientprotocol/sdk/unstable";
 import { V2_CANCELLED, V2_PAUSED } from "./tool-calls/renderer.js";
 import { BackgroundOutputTail } from "./background-output.js";
+/** The most returned tool calls that {@link SessionBackgroundWork} remembers. */
+const MAX_RETURNED_CALLS = 1024;
 /** The tools whose structured result names the task that the call started. */
 const TASK_TOOLS = new Set(["Monitor", "Workflow"]);
 /**
- * Registers each tool call of a tool result message whose task goes on in
- * the background: a `Monitor` or `Workflow` call, whose structured result
- * names its task, or a call that a live task names as its tool use, such as
- * a backgrounded MCP call. The task must be in the level: one that ended
- * already, or that Claude Code marks `ambient`, leaves its call as it is.
- * Returns the ids of the calls, whose result then reports `in_progress` (see
- * `withRunningToolCall`).
+ * The background work of one root session, and of its subagent sessions: the
+ * terminals and tool calls of the tasks that run in the background, and what
+ * the client is told of them.
+ *
+ * Terminals are kept for every client that renders them, as before the
+ * background lists. The rest is kept only when `reported`.
  */
-export function registerBackgroundToolCalls(session, content, toolUseResult, toolUses, parentToolUseId) {
-    const registered = new Set();
-    if (!session.reportsBackground || !Array.isArray(content))
-        return registered;
-    const results = content.filter((block) => typeof block === "object" &&
-        block !== null &&
-        block.type === "tool_result" &&
-        typeof block.tool_use_id === "string" &&
-        block.is_error !== true);
-    const structuredTaskId = results.length === 1 &&
-        typeof toolUseResult === "object" &&
-        toolUseResult !== null &&
-        typeof toolUseResult.taskId === "string"
-        ? toolUseResult.taskId
-        : undefined;
-    for (const { tool_use_id: toolCallId } of results) {
-        const toolUse = toolUses[toolCallId];
-        if (!toolUse)
-            continue;
-        const taskId = (TASK_TOOLS.has(toolUse.name) ? structuredTaskId : undefined) ??
-            [...(session.liveBackgroundTasks ?? [])].find(([, task]) => task.parentToolUseId === toolCallId && !task.isSubagent)?.[0];
-        const task = taskId === undefined ? undefined : session.backgroundLevel?.get(taskId);
-        if (!task ||
-            task.ambient ||
-            task.taskType === "local_bash" ||
-            task.taskType === "local_agent") {
-            continue;
+export class SessionBackgroundWork {
+    sessionId;
+    reported;
+    /** Claude Code's live background task set, from its last `background_tasks_changed`. */
+    level = new Map();
+    /** The terminals of the commands that went to the background, by task id. */
+    terminals = new Map();
+    /** The tool calls whose tasks went on in the background, by task id. */
+    toolCalls = new Map();
+    /**
+     * The tool calls that returned, oldest first. A task that a call started
+     * is part of that call until it returns, and the foreground work waits on
+     * it. The task's `task_started` can come after the call returned. Bounded
+     * by {@link MAX_RETURNED_CALLS}: a task joins the level around the time its
+     * call returns.
+     */
+    returned = new Set();
+    /**
+     * `reported`: whether the client gets the lists. Only when Claude Code's
+     * interrupt spares background tasks, as `perTaskStopAffordance` makes it.
+     */
+    constructor(sessionId, reported) {
+        this.sessionId = sessionId;
+        this.reported = reported;
+    }
+    /**
+     * Keeps the display terminal of the command `taskId` running after its Bash
+     * result, until its task ends (see `withRunningTerminal`).
+     */
+    terminalStarted(taskId, terminal) {
+        this.terminals.set(taskId, terminal);
+    }
+    /**
+     * Reads what a tool result message tells of the background tasks:
+     *
+     * - The returned calls no longer hold the tasks that they started.
+     * - Each call whose task goes on in the background is registered: a
+     *   `Monitor` or `Workflow` call, whose structured result names its task,
+     *   or a call that a live task names as its tool use, such as a
+     *   backgrounded MCP call. The task must be in the level: one that ended
+     *   already, or that Claude Code marks `ambient`, leaves its call as it is.
+     *
+     * Returns the ids of the registered calls, whose result then reports
+     * `in_progress` (see `withRunningToolCall`).
+     */
+    toolResults(owner, content, toolUseResult, toolUses, parentToolUseId) {
+        const registered = new Set();
+        if (!this.reported || !Array.isArray(content))
+            return registered;
+        const results = content.filter((block) => typeof block === "object" &&
+            block !== null &&
+            block.type === "tool_result" &&
+            typeof block.tool_use_id === "string");
+        for (const { tool_use_id: toolCallId } of results) {
+            this.returned.add(toolCallId);
+            if (this.returned.size > MAX_RETURNED_CALLS) {
+                this.returned.delete(this.returned.values().next().value);
+            }
         }
-        (session.backgroundToolCalls ??= new Map()).set(taskId, {
-            toolCallId,
-            toolUse,
-            ...(parentToolUseId ? { parentToolUseId } : {}),
-        });
-        registered.add(toolCallId);
+        const succeeded = results.filter((block) => block.is_error !== true);
+        const structuredTaskId = succeeded.length === 1 &&
+            typeof toolUseResult === "object" &&
+            toolUseResult !== null &&
+            typeof toolUseResult.taskId === "string"
+            ? toolUseResult.taskId
+            : undefined;
+        for (const { tool_use_id: toolCallId } of succeeded) {
+            const toolUse = toolUses[toolCallId];
+            if (!toolUse)
+                continue;
+            const taskId = (TASK_TOOLS.has(toolUse.name) ? structuredTaskId : undefined) ??
+                [...owner.liveBackgroundTasks].find(([, task]) => task.parentToolUseId === toolCallId && !task.isSubagent)?.[0];
+            const task = taskId === undefined ? undefined : this.level.get(taskId);
+            if (!task ||
+                task.ambient ||
+                task.taskType === "local_bash" ||
+                task.taskType === "local_agent") {
+                continue;
+            }
+            this.toolCalls.set(taskId, {
+                toolCallId,
+                toolUse,
+                ...(parentToolUseId ? { parentToolUseId } : {}),
+            });
+            registered.add(toolCallId);
+        }
+        return registered;
     }
-    return registered;
-}
-/** The level of a `background_tasks_changed` payload. */
-export function backgroundLevel(tasks) {
-    return new Map(tasks.map((task) => [
-        task.task_id,
-        {
-            ambient: task.ambient === true,
-            taskType: task.task_type,
-            description: task.description,
-            ...(task.parent_task_id !== undefined ? { parentTaskId: task.parent_task_id } : {}),
-        },
-    ]));
-}
-/**
- * The `background` list of the root session `rootSessionId` and of each of
- * its announced subagent sessions, by session id, deeper sessions first and
- * the root last. Each list is empty while
- * the level has not been reported: Claude Code sends none before the first
- * background task starts.
- */
-export function backgroundLists(session, rootSessionId) {
-    const children = [...(session.nativeSubagentsByTaskId ?? [])].filter(([, child]) => child.announced);
-    const childByTask = new Map(children);
-    const childByToolUse = new Map(children.flatMap(([, child]) => child.parentToolUseId ? [[child.parentToolUseId, child]] : []));
-    const lists = new Map([
-        [rootSessionId, []],
-        ...children.map(([, child]) => [child.sessionId, []]),
-    ]);
-    const level = session.backgroundLevel ?? new Map();
-    for (const [taskId, task] of level) {
-        if (task.ambient)
-            continue;
-        // A subagent's command or tool call runs on the child's stream.
-        const ownerOf = (parentToolUseId) => parentToolUseId ? childByToolUse.get(parentToolUseId)?.sessionId : rootSessionId;
-        const terminal = session.backgroundTerminals?.get(taskId);
+    /**
+     * Starts reading the output of the background command `taskId` into its
+     * terminal, when the client gets the lists and the Bash result named the
+     * command's output file. `send` sends an update of the terminal's tool
+     * call, routed as the call's other updates. Called once the Bash result's
+     * own updates are sent: the first output replaces the placeholder that they
+     * gave the terminal.
+     */
+    followOutput(taskId, send) {
+        const terminal = this.terminals.get(taskId);
+        if (!this.reported || !terminal?.outputFilePath || terminal.output)
+            return;
+        terminal.output = new BackgroundOutputTail(terminal.outputFilePath, (output) => send(terminalOutputUpdate(this.sessionId, terminal, output)));
+    }
+    /**
+     * The task `taskId` ended. Reads the rest of its command's output, then
+     * exits its terminal, and gives a tool call whose task it was its final
+     * status: `cancelled` for a task that Claude Code stopped, and `completed`
+     * for one that ended without saying how, such as one that the level
+     * dropped: it no longer runs, and reported no failure. Claude Code reports
+     * no exit code for a command, and `completed` does not mean 0: Claude Code
+     * accepts some non-zero codes as a success, such as grep's 1.
+     */
+    async taskEnded(taskId, end, send) {
+        const terminal = this.terminals.get(taskId);
         if (terminal) {
-            const owner = ownerOf(terminal.parentToolUseId);
-            if (owner)
-                lists.get(owner).push({ type: "terminal", terminalId: terminal.toolCallId });
-            continue;
+            await terminal.output?.finish();
+            this.terminals.delete(taskId);
+            await send(terminalExit(this.sessionId, terminal));
         }
-        const toolCall = session.backgroundToolCalls?.get(taskId);
+        const toolCall = this.toolCalls.get(taskId);
         if (toolCall) {
-            const owner = ownerOf(toolCall.parentToolUseId);
-            if (owner)
-                lists.get(owner).push({ type: "tool_call", toolCallId: toolCall.toolCallId });
-            continue;
+            this.toolCalls.delete(taskId);
+            await send(toolCallStatusUpdate(this.sessionId, toolCall, end === "stopped" ? V2_CANCELLED : end === "failed" ? "failed" : "completed"));
         }
-        // A command without a terminal yet is one that foreground work waits on.
-        // A subagent is listed below, as its session.
-        if (task.taskType === "local_bash" || task.taskType === "local_agent")
-            continue;
-        // A task joins the level before its `task_started`, and before the tool
-        // call that starts it returns. Until both, the task is unknown or part of
-        // that tool call, which the foreground work waits on. Claude Code drops a
-        // tool use from its cache at the tool's result.
-        const live = session.liveBackgroundTasks?.get(taskId);
-        if (!live || (live.parentToolUseId && session.toolUseCache?.[live.parentToolUseId])) {
-            continue;
+    }
+    /**
+     * The update that reports the background tool call of the task `taskId` as
+     * `paused`, or as `in_progress` again, when `paused` changes it. Claude Code
+     * pauses a workflow this way.
+     */
+    taskPaused(taskId, paused) {
+        const toolCall = this.toolCalls.get(taskId);
+        if (!toolCall || (toolCall.paused ?? false) === paused)
+            return undefined;
+        toolCall.paused = paused;
+        return toolCallStatusUpdate(this.sessionId, toolCall, paused ? V2_PAUSED : "in_progress");
+    }
+    /**
+     * Takes Claude Code's new live background task set. The terminals and tool
+     * calls whose tasks it no longer holds end first, before a list drops them,
+     * as v2 requires. A terminal or tool call is registered at its tool result,
+     * after its task joined the level, so a later level without the task means
+     * that it ended. Claude Code usually sends a task's end before that level,
+     * which ends them first, but the SDK does not promise that order.
+     */
+    async levelChanged(tasks, send) {
+        if (!this.reported)
+            return;
+        const level = new Map(tasks.map((task) => [
+            task.task_id,
+            {
+                ambient: task.ambient === true,
+                taskType: task.task_type,
+                description: task.description,
+                ...(task.parent_task_id !== undefined ? { parentTaskId: task.parent_task_id } : {}),
+            },
+        ]));
+        for (const taskId of [...this.terminals.keys(), ...this.toolCalls.keys()]) {
+            if (!level.has(taskId))
+                await this.taskEnded(taskId, undefined, send);
         }
-        const parent = task.parentTaskId ? childByTask.get(task.parentTaskId) : undefined;
-        lists
-            .get(parent?.sessionId ?? rootSessionId)
-            .push({ type: "_claude/task", taskId, description: task.description });
+        this.level = level;
     }
-    // A child is listed in its parent's list while it works in the background,
-    // and while it is idle with background work of its own. Deeper children
-    // first, so a child's list is whole before its parent's reads it.
-    const sessions = new Map(children.map(([, child]) => [child.sessionId, child]));
-    const depth = (child) => {
-        const parent = sessions.get(child.parentSessionId);
-        return parent ? depth(parent) + 1 : 0;
-    };
-    for (const [taskId, child] of children.sort(([, a], [, b]) => depth(b) - depth(a))) {
-        const task = level.get(taskId);
-        const working = child.workState !== undefined &&
-            child.workState !== "idle" &&
-            task !== undefined &&
-            !task.ambient;
-        if (working || lists.get(child.sessionId).length > 0) {
-            lists.get(child.parentSessionId)?.push({ type: "subagent", sessionId: child.sessionId });
+    /**
+     * The query closed: Claude Code's background tasks end with its process.
+     * Stops reading output, and returns the updates that exit the root
+     * session's terminals and cancel its tool calls. The level empties, so the
+     * next lists are empty. A subagent's command or tool call is left as it
+     * was: it is on the child's stream, which the closed query's routing owned.
+     */
+    queryClosed() {
+        for (const terminal of this.terminals.values())
+            terminal.output?.stop();
+        if (!this.reported)
+            return [];
+        const updates = [];
+        for (const [taskId, terminal] of this.terminals) {
+            if (terminal.parentToolUseId)
+                continue;
+            this.terminals.delete(taskId);
+            updates.push(terminalExit(this.sessionId, terminal));
+        }
+        for (const [taskId, toolCall] of this.toolCalls) {
+            if (toolCall.parentToolUseId)
+                continue;
+            this.toolCalls.delete(taskId);
+            updates.push(toolCallStatusUpdate(this.sessionId, toolCall, V2_CANCELLED));
         }
+        this.level = new Map();
+        this.returned.clear();
+        return updates;
+    }
+    /**
+     * The `background` list of the root session and of each of its announced
+     * subagent sessions, with what their repeated states need, deeper sessions
+     * first and the root last: a child's own list goes out before its parent's
+     * list drops it. Each list is empty while the level has not been reported:
+     * Claude Code sends none before the first background task starts.
+     */
+    reports(owner, rootState) {
+        const children = [...(owner.nativeSubagentsByTaskId ?? [])].filter(([, child]) => child.announced);
+        const childByTask = new Map(children);
+        const childByToolUse = new Map(children.flatMap(([, child]) => child.parentToolUseId ? [[child.parentToolUseId, child]] : []));
+        const lists = new Map([
+            [this.sessionId, []],
+            ...children.map(([, child]) => [child.sessionId, []]),
+        ]);
+        // A subagent's command or tool call runs on the child's stream.
+        const ownerOf = (parentToolUseId) => parentToolUseId ? childByToolUse.get(parentToolUseId)?.sessionId : this.sessionId;
+        for (const [taskId, task] of this.level) {
+            if (task.ambient)
+                continue;
+            const terminal = this.terminals.get(taskId);
+            if (terminal) {
+                const session = ownerOf(terminal.parentToolUseId);
+                if (session)
+                    lists.get(session).push({ type: "terminal", terminalId: terminal.toolCallId });
+                continue;
+            }
+            const toolCall = this.toolCalls.get(taskId);
+            if (toolCall) {
+                const session = ownerOf(toolCall.parentToolUseId);
+                if (session)
+                    lists.get(session).push({ type: "tool_call", toolCallId: toolCall.toolCallId });
+                continue;
+            }
+            // A command without a terminal yet is one that foreground work waits on.
+            // A subagent is listed below, as its session.
+            if (task.taskType === "local_bash" || task.taskType === "local_agent")
+                continue;
+            // A task joins the level before its `task_started`, and before the tool
+            // call that starts it returns. Until both, the task is unknown or part
+            // of that tool call.
+            const live = owner.liveBackgroundTasks.get(taskId);
+            if (!live || (live.parentToolUseId && !this.returned.has(live.parentToolUseId)))
+                continue;
+            const parent = task.parentTaskId ? childByTask.get(task.parentTaskId) : undefined;
+            lists
+                .get(parent?.sessionId ?? this.sessionId)
+                .push({ type: "_claude/task", taskId, description: task.description });
+        }
+        // A child is listed in its parent's list while it works in the background,
+        // and while it is idle with background work of its own. Deeper children
+        // first, so a child's list is whole before its parent's reads it.
+        const sessions = new Map(children.map(([, child]) => [child.sessionId, child]));
+        const depth = (child) => {
+            const parent = sessions.get(child.parentSessionId);
+            return parent ? depth(parent) + 1 : 0;
+        };
+        const ordered = children.sort(([, a], [, b]) => depth(b) - depth(a));
+        for (const [taskId, child] of ordered) {
+            const task = this.level.get(taskId);
+            const working = child.workState !== undefined &&
+                child.workState !== "idle" &&
+                task !== undefined &&
+                !task.ambient;
+            if (working || lists.get(child.sessionId).length > 0) {
+                lists.get(child.parentSessionId)?.push({ type: "subagent", sessionId: child.sessionId });
+            }
+        }
+        return [
+            ...ordered.map(([, child]) => ({
+                sessionId: child.sessionId,
+                items: lists.get(child.sessionId),
+                state: workStateName(child.workState),
+                parentSessionId: child.parentSessionId,
+            })),
+            { sessionId: this.sessionId, items: lists.get(this.sessionId), state: rootState },
+        ];
+    }
+    /**
+     * The current state of each background tool call in `toolCallIds`: the
+     * call as `renderer` shows its tool use, with its status now (see
+     * `ClaudeAcpAgent.publishBackgroundToolCalls`).
+     */
+    toolCallStates(toolCallIds, renderer, cwd) {
+        return [...this.toolCalls.values()]
+            .filter((toolCall) => toolCallIds.includes(toolCall.toolCallId))
+            .map((toolCall) => {
+            const update = renderer.toolCall({ id: toolCall.toolCallId, ...toolCall.toolUse }, { cwd });
+            const status = toolCall.paused ? V2_PAUSED : "in_progress";
+            return {
+                sessionId: this.sessionId,
+                update: { ...update, status },
+            };
+        });
+    }
+    /**
+     * The task of the terminal or tool call `target` that the session
+     * `sessionId` lists, or undefined when it lists no such item.
+     */
+    listedTask(owner, sessionId, target) {
+        if (!this.reported)
+            return undefined;
+        const listed = this.reports(owner, "idle")
+            .find((report) => report.sessionId === sessionId)
+            ?.items.some((item) => "terminalId" in target
+            ? item.type === "terminal" && item.terminalId === target.terminalId
+            : item.type === "tool_call" && item.toolCallId === target.toolCallId);
+        if (!listed)
+            return undefined;
+        const id = "terminalId" in target ? target.terminalId : target.toolCallId;
+        const entries = "terminalId" in target ? this.terminals : this.toolCalls;
+        return [...entries].find(([, entry]) => entry.toolCallId === id)?.[0];
     }
-    // In the same order, the root last: a child's own list goes out before its
-    // parent's list drops it.
-    return new Map([
-        ...children.map(([, child]) => [
-            child.sessionId,
-            lists.get(child.sessionId),
-        ]),
-        [rootSessionId, lists.get(rootSessionId)],
-    ]);
-}
-/**
- * The tasks of the terminals and tool calls that `level` does not hold:
- * Claude Code no longer runs them, so they end before a list drops them, as
- * v2 requires. A terminal or tool call is registered at its tool result,
- * after its task joined the level, so a later level without the task means
- * that it ended. Claude Code usually sends a task's end before that level,
- * which ends them first, but the SDK does not promise that order.
- */
-export function droppedTasks(session, level) {
-    return [
-        ...(session.backgroundTerminals?.keys() ?? []),
-        ...(session.backgroundToolCalls?.keys() ?? []),
-    ].filter((taskId) => !level.has(taskId));
 }
 /**
- * Starts reading the output of the background command `taskId` into its
- * terminal, when the session reports its background work and the Bash result
- * named the command's output file. `send` sends an update of the terminal's
- * tool call, routed as the call's other updates. Called once the Bash
- * result's own updates are sent: the first output replaces the placeholder
- * that they gave the terminal.
+ * Stops the task of a terminal or tool call that the session `sessionId`
+ * lists (v2 `terminal/cancel` and `tool_call/cancel`). `sessions` are the
+ * root sessions: a subagent session's list is built with its root's. The
+ * terminal exits, or the tool call gets its final status, when Claude Code
+ * reports the task stopped.
  */
-export function followBackgroundTerminalOutput(session, sessionId, taskId, send) {
-    const terminal = session.backgroundTerminals?.get(taskId);
-    if (!session.reportsBackground || !terminal?.outputFilePath || terminal.output)
+export async function cancelBackgroundWork(sessions, sessionId, target) {
+    const notCancellable = () => "terminalId" in target
+        ? RequestError.invalidParams({ sessionId, terminalId: target.terminalId }, `Terminal ${target.terminalId} is not a command running in the background, so it cannot be cancelled.`)
+        : RequestError.invalidParams({ sessionId, toolCallId: target.toolCallId }, `Tool call ${target.toolCallId} is not running in the background, so it cannot be cancelled.`);
+    for (const session of sessions) {
+        const taskId = session.background?.listedTask(session, sessionId, target);
+        if (taskId === undefined)
+            continue;
+        try {
+            await session.query.stopTask(taskId);
+        }
+        catch (error) {
+            // The task ended meanwhile: it has ended on the client too, or is about to.
+            if (session.background?.listedTask(session, sessionId, target) === undefined) {
+                throw notCancellable();
+            }
+            throw error;
+        }
         return;
-    terminal.output = new BackgroundOutputTail(terminal.outputFilePath, (output) => send(terminalOutputUpdate(sessionId, terminal, output)));
+    }
+    throw notCancellable();
 }
 /** The update that gives the terminal of `terminal` the text `output`. */
 function terminalOutputUpdate(sessionId, terminal, output) {
@@ -214,27 +392,8 @@ function terminalOutputUpdate(sessionId, terminal, output) {
         },
     };
 }
-/**
- * Reads the rest of the output of the background command `taskId` into its
- * terminal: the command ended, and its output goes before its exit, as v2
- * asks.
- */
-export async function finishBackgroundTerminalOutput(session, taskId) {
-    await session.backgroundTerminals?.get(taskId)?.output?.finish();
-}
-/**
- * Removes the terminal of the background command `taskId` of the session
- * `sessionId`, and returns the update that exits it, or undefined when the
- * command has no terminal. Claude Code reports no exit code for it, and
- * `completed` does not mean 0: Claude Code accepts some non-zero codes as a
- * success, such as grep's 1.
- */
-export function takeBackgroundTerminalExit(session, sessionId, taskId) {
-    const terminal = session.backgroundTerminals?.get(taskId);
-    if (!terminal)
-        return undefined;
-    terminal.output?.stop();
-    session.backgroundTerminals.delete(taskId);
+/** The update that exits the terminal of `terminal`, with no exit code. */
+function terminalExit(sessionId, terminal) {
     return {
         sessionId,
         update: {
@@ -249,46 +408,6 @@ export function takeBackgroundTerminalExit(session, sessionId, taskId) {
         },
     };
 }
-/**
- * Removes the background tool call of the task `taskId` of the session
- * `sessionId`, and returns the update that gives it its final status, or
- * undefined when the task has no such call. A task that Claude Code stopped
- * is `cancelled`. One that ended without saying how, such as one that the
- * level dropped, is `completed`: it no longer runs, and reported no failure.
- */
-export function takeBackgroundToolCallEnd(session, sessionId, taskId, end) {
-    const toolCall = session.backgroundToolCalls?.get(taskId);
-    if (!toolCall)
-        return undefined;
-    session.backgroundToolCalls.delete(taskId);
-    return toolCallStatusUpdate(sessionId, toolCall, end === "stopped" ? V2_CANCELLED : end === "failed" ? "failed" : "completed");
-}
-/**
- * The update that reports the background tool call of the task `taskId` as
- * `paused`, or as `in_progress` again, when `paused` changes it. Claude Code
- * pauses a workflow this way.
- */
-export function backgroundToolCallPause(session, sessionId, taskId, paused) {
-    const toolCall = session.backgroundToolCalls?.get(taskId);
-    if (!toolCall || (toolCall.paused ?? false) === paused)
-        return undefined;
-    toolCall.paused = paused;
-    return toolCallStatusUpdate(sessionId, toolCall, paused ? V2_PAUSED : "in_progress");
-}
-/**
- * The current state of each background tool call in `toolCallIds` of the
- * root session `sessionId`: the call as `renderer` shows its tool use, with
- * its status now (see `ClaudeAcpAgent.publishBackgroundToolCalls`).
- */
-export function backgroundToolCallStates(session, sessionId, toolCallIds, renderer) {
-    return [...(session.backgroundToolCalls?.values() ?? [])]
-        .filter((toolCall) => toolCallIds.includes(toolCall.toolCallId))
-        .map((toolCall) => {
-        const update = renderer.toolCall({ id: toolCall.toolCallId, ...toolCall.toolUse }, { cwd: session.cwd });
-        const status = toolCall.paused ? V2_PAUSED : "in_progress";
-        return { sessionId, update: { ...update, status } };
-    });
-}
 function toolCallStatusUpdate(sessionId, toolCall, status) {
     return {
         sessionId,
@@ -302,69 +421,6 @@ function toolCallStatusUpdate(sessionId, toolCall, status) {
         },
     };
 }
-/**
- * Ends the background work of a session whose query closed: Claude Code's
- * background tasks end with its process. Returns the updates that exit the
- * root session's terminals and cancel its tool calls, and empties the level,
- * so the next lists are empty. A subagent's command or tool call is left as
- * it was: it is on the child's stream, which the closed query's routing
- * owned.
- */
-export function endBackgroundWork(session, sessionId) {
-    if (!session.reportsBackground)
-        return [];
-    // No command writes output any more.
-    for (const terminal of session.backgroundTerminals?.values() ?? [])
-        terminal.output?.stop();
-    const exits = [...(session.backgroundTerminals ?? [])].flatMap(([taskId, terminal]) => {
-        const exit = terminal.parentToolUseId
-            ? undefined
-            : takeBackgroundTerminalExit(session, sessionId, taskId);
-        return exit ? [exit] : [];
-    });
-    const ends = [...(session.backgroundToolCalls ?? [])].flatMap(([taskId, toolCall]) => {
-        const end = toolCall.parentToolUseId
-            ? undefined
-            : takeBackgroundToolCallEnd(session, sessionId, taskId, "stopped");
-        return end ? [end] : [];
-    });
-    session.backgroundLevel = undefined;
-    return [...exits, ...ends];
-}
-/**
- * Stops the task of a terminal or tool call that the session `sessionId`
- * lists (v2 `terminal/cancel` and `tool_call/cancel`). `sessions` are the
- * root sessions, by id: a subagent session's list is built with its root's.
- * The terminal exits, or the tool call gets its final status, when Claude
- * Code reports the task stopped.
- */
-export async function cancelBackgroundWork(sessions, sessionId, target) {
-    const notCancellable = () => "terminalId" in target
-        ? RequestError.invalidParams({ sessionId, terminalId: target.terminalId }, `Terminal ${target.terminalId} is not a command running in the background, so it cannot be cancelled.`)
-        : RequestError.invalidParams({ sessionId, toolCallId: target.toolCallId }, `Tool call ${target.toolCallId} is not running in the background, so it cannot be cancelled.`);
-    const isTarget = (item) => "terminalId" in target
-        ? item.type === "terminal" && item.terminalId === target.terminalId
-        : item.type === "tool_call" && item.toolCallId === target.toolCallId;
-    const listed = (root, session) => session.reportsBackground === true &&
-        (backgroundLists(session, root).get(sessionId)?.some(isTarget) ?? false);
-    const owner = Object.entries(sessions).find(([root, session]) => listed(root, session));
-    if (!owner)
-        throw notCancellable();
-    const [root, session] = owner;
-    const id = "terminalId" in target ? target.terminalId : target.toolCallId;
-    const taskId = [
-        ...(("terminalId" in target ? session.backgroundTerminals : session.backgroundToolCalls) ?? []),
-    ].find(([, entry]) => entry.toolCallId === id)[0];
-    try {
-        await session.query.stopTask(taskId);
-    }
-    catch (error) {
-        // The task ended meanwhile: it has ended on the client too, or is about to.
-        if (!listed(root, session))
-            throw notCancellable();
-        throw error;
-    }
-}
 /**
  * Publishes the lists of each session that reports them, each time one
  * changes. The sink sends them to the client synchronously, so a list follows
@@ -387,24 +443,14 @@ export class BackgroundWorkReporter {
      * `rootState` is the root session's state now.
      */
     sync(rootSessionId, session, rootState) {
-        if (!this.sink || !session.reportsBackground)
+        if (!this.sink || !session.background?.reported)
             return;
-        const children = new Map([...(session.nativeSubagentsByTaskId?.values() ?? [])].map((child) => [
-            child.sessionId,
-            child,
-        ]));
-        for (const [sessionId, items] of backgroundLists(session, rootSessionId)) {
-            const json = JSON.stringify(items);
-            if (this.published.get(sessionId)?.json === json)
+        for (const report of session.background.reports(session, rootState)) {
+            const json = JSON.stringify(report.items);
+            if (this.published.get(report.sessionId)?.json === json)
                 continue;
-            this.published.set(sessionId, { json, root: rootSessionId });
-            const child = children.get(sessionId);
-            this.sink.changed({
-                sessionId,
-                items,
-                state: child ? workStateName(child.workState) : rootState,
-                ...(child ? { parentSessionId: child.parentSessionId } : {}),
-            });
+            this.published.set(report.sessionId, { json, root: rootSessionId });
+            this.sink.changed(report);
         }
     }
     /** The root session `rootSessionId` ended, and its subagent sessions with it. */