@cloudcli-ai/cloudcli 1.37.2 → 1.37.4

package/dist-server/server/modules/providers/list/claude/claude-runtime.provider.js

@@ -17,11 +17,16 @@ import os from 'os';
 import path from 'path';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { appendFilesInputTag, buildClaudeUserContent, normalizeImageDescriptors } from '../../../../shared/image-attachments.js';
-import { CLAUDE_PREDEFINED_MODELS } from '../../../../modules/providers/list/claude/claude-models.provider.js';
+import { CLAUDE_PREDEFINED_MODELS, CLAUDE_ULTRACODE_EFFORT } from '../../../../modules/providers/list/claude/claude-models.provider.js';
 import { resolveClaudeCodeExecutablePath } from '../../../../shared/claude-cli-path.js';
 import { createNotificationEvent, notifyBackgroundWorkCompleted, notifyRunFailed, notifyRunStopped, notifyUserIfEnabled } from '../../../../modules/notifications/index.js';
+import { sessionHistoryCache } from '../../../../modules/providers/services/session-history-cache.service.js';
 import { createCompleteMessage, createNormalizedMessage } from '../../../../shared/utils.js';
 const activeSessions = new Map();
+// Outstanding background tasks per live session, keyed like activeSessions. An
+// entry lives exactly as long as the map entry it shadows: cleared when the
+// session is removed, and reset when a newer run takes the key over.
+const backgroundWork = createBackgroundWorkTracker();
 const pendingToolApprovals = new Map();
 // Sessions cancelled via abort-session. The abort handler already sent the
 // terminal `complete` (aborted: true) to the client, so the run loop must not
@@ -51,6 +56,11 @@ const TOOL_APPROVAL_TIMEOUT_MS = parseInt(process.env.CLAUDE_TOOL_APPROVAL_TIMEO
 // forever. The timer resets on every message, so it measures silence, not total time.
 const BG_WAIT_CEILING_MS = 30 * 60 * 1000;
 const TOOLS_REQUIRING_INTERACTION = new Set(['AskUserQuestion', 'ExitPlanMode']);
+// Ultracode is a session-scoped setting rather than an SDK effort level: it pairs xhigh
+// effort with standing dynamic-workflow orchestration, and the CLI only honours it when
+// Workflows are enabled. The catalog offers it as an effort choice for the picker, so the
+// selection is translated back into the two options the SDK actually understands here.
+const ULTRACODE_SDK_EFFORT = 'xhigh';
 function resolveClaudeEffort(model, effort, modelsDefinition = CLAUDE_PREDEFINED_MODELS) {
     const selectedModel = modelsDefinition?.OPTIONS?.find((option) => option.value === model) || null;
     const allowedEfforts = selectedModel?.effort?.values
@@ -59,6 +69,27 @@ function resolveClaudeEffort(model, effort, modelsDefinition = CLAUDE_PREDEFINED
         ? effort
         : undefined;
 }
+/**
+ * Writes the resolved effort choice onto the SDK options, expanding `ultracode` into the
+ * xhigh effort level plus the session-scoped settings it requires.
+ * @param {Object} sdkOptions - SDK options being built
+ * @param {string|undefined} resolvedEffort - Catalog-validated effort selection
+ */
+function applyClaudeEffort(sdkOptions, resolvedEffort) {
+    if (!resolvedEffort) {
+        return;
+    }
+    if (resolvedEffort !== CLAUDE_ULTRACODE_EFFORT) {
+        sdkOptions.effort = resolvedEffort;
+        return;
+    }
+    sdkOptions.effort = ULTRACODE_SDK_EFFORT;
+    sdkOptions.settings = {
+        ...(sdkOptions.settings || {}),
+        ultracode: true,
+        enableWorkflows: true
+    };
+}
 function createRequestId() {
     if (typeof crypto.randomUUID === 'function') {
         return crypto.randomUUID();
@@ -149,14 +180,19 @@ function matchesToolPermission(entry, toolName, input) {
     return false;
 }
 function mapCliOptionsToSDK(options = {}) {
-    const { providerSessionId, cwd, toolsSettings, permissionMode, effort } = options;
+    const { providerSessionId, cwd, toolsSettings, permissionMode, effort, resumeAnchorId, resumeFromScratch } = options;
     const sdkOptions = {};
     // Forward all host env vars (e.g. ANTHROPIC_BASE_URL) to the subprocess.
     // Since SDK 0.2.113, options.env replaces process.env instead of overlaying it.
     sdkOptions.env = { ...process.env, CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS: String(BG_WAIT_CEILING_MS) };
     // Resolve the executable eagerly on Windows because the SDK uses raw child_process.spawn,
     // which does not reliably follow npm's shell wrappers like cross-spawn does.
-    sdkOptions.pathToClaudeCodeExecutable = resolveClaudeCodeExecutablePath(process.env.CLAUDE_CLI_PATH);
+    // When nothing resolves the option stays unset on purpose: the SDK then falls back to the
+    // binary it ships, which beats handing it a bare `claude` that raw spawn can never launch.
+    const claudeExecutablePath = resolveClaudeCodeExecutablePath(process.env.CLAUDE_CLI_PATH);
+    if (claudeExecutablePath) {
+        sdkOptions.pathToClaudeCodeExecutable = claudeExecutablePath;
+    }
     if (cwd) {
         sdkOptions.cwd = cwd;
     }
@@ -187,18 +223,25 @@ function mapCliOptionsToSDK(options = {}) {
     sdkOptions.tools = { type: 'preset', preset: 'claude_code' };
     sdkOptions.disallowedTools = settings.disallowedTools || [];
     sdkOptions.model = options.model || CLAUDE_PREDEFINED_MODELS.DEFAULT;
-    const resolvedEffort = resolveClaudeEffort(sdkOptions.model, effort, options.effortModels || CLAUDE_PREDEFINED_MODELS);
-    if (resolvedEffort) {
-        sdkOptions.effort = resolvedEffort;
-    }
+    applyClaudeEffort(sdkOptions, resolveClaudeEffort(sdkOptions.model, effort, options.effortModels || CLAUDE_PREDEFINED_MODELS));
     sdkOptions.systemPrompt = {
         type: 'preset',
         preset: 'claude_code'
     };
     sdkOptions.settingSources = ['project', 'user', 'local'];
     // The SDK resumes with the provider-native session id, never the app id.
-    if (providerSessionId) {
+    // `resumeFromScratch` is set when the very first prompt of a conversation was
+    // edited: there is nothing before it to resume through, so the turn has to
+    // start the conversation over instead.
+    if (providerSessionId && !resumeFromScratch) {
         sdkOptions.resume = providerSessionId;
+        // Editing an already-sent message re-runs the conversation truncated just
+        // before it. `resumeSessionAt` is inclusive of the uuid it names, so the
+        // caller resolves the last row to KEEP and passes that — never the edited
+        // turn itself, which would leave the original prompt in context.
+        if (resumeAnchorId) {
+            sdkOptions.resumeSessionAt = resumeAnchorId;
+        }
     }
     return sdkOptions;
 }
@@ -227,6 +270,9 @@ function addSession(sessionId, queryInstance, writer = null, releaseInput = null
             console.error(`Error interrupting superseded run for session ${sessionId}:`, error?.message || error);
         });
         existing.releaseInput?.();
+        // Whatever the superseded process had outstanding dies with it and will
+        // never report, so the new run starts from an empty task set.
+        backgroundWork.clear(sessionId);
     }
     const carried = superseding ? null : existing;
     activeSessions.set(sessionId, {
@@ -237,6 +283,44 @@ function addSession(sessionId, queryInstance, writer = null, releaseInput = null
         // Re-registered mid-run once the provider session id lands; keep the closer.
         releaseInput: releaseInput || carried?.releaseInput || null
     });
+    // The history reader reports a background agent as running or stopped by
+    // whether this entry exists, and the cached history does not see this map.
+    sessionHistoryCache.invalidate(sessionId);
+}
+/**
+ * Lets go of the process an earlier run left holding a session open, so the
+ * next turn can take the session over.
+ *
+ * Closing stdin is not enough on its own: the CLI's wind-down waits for the
+ * background agents the process still has going — for up to the ceiling it
+ * was started with (BG_WAIT_CEILING_MS) — so an abandoned process with an
+ * agent outstanding would run next to the process that replaced it for as
+ * long as the agent does, both appending to the same session file. Stop the
+ * tasks first, while stdin is still open: the SDK drops control requests
+ * written after stdin has ended, which is also why the interrupt a later
+ * supersede sends to this process cannot do the job.
+ *
+ * The stops are not awaited — each request is written to the CLI before this
+ * returns, and a reply is only missing when the process has already gone.
+ * @param {string} sessionId - Session identifier
+ */
+function releaseHeldSession(sessionId) {
+    const held = getSession(sessionId);
+    if (!held) {
+        return;
+    }
+    for (const task of backgroundWork.outstanding(sessionId)) {
+        // A stop that cannot be delivered changes nothing about what happens
+        // next: the process is on its way out either way. Guard the synchronous
+        // call too, so a failing stop can never skip the release below.
+        try {
+            Promise.resolve(held.instance?.stopTask?.(task.taskId)).catch(() => { });
+        }
+        catch {
+            // Same as a rejected stop.
+        }
+    }
+    held.releaseInput?.();
 }
 /**
  * Removes a session from the active sessions map
@@ -244,6 +328,11 @@ function addSession(sessionId, queryInstance, writer = null, releaseInput = null
  */
 function removeSession(sessionId) {
     activeSessions.delete(sessionId);
+    // No process, no background work: anything still tracked was killed with it.
+    backgroundWork.clear(sessionId);
+    // See addSession: a page cached while the process was up still says
+    // `running` for any agent that never reported back.
+    sessionHistoryCache.invalidate(sessionId);
 }
 /**
  * Gets a session from the active sessions map
@@ -275,44 +364,118 @@ function transformMessage(sdkMessage) {
     }
     return sdkMessage;
 }
+/**
+ * True for the user bubble the SDK echoes for a subagent's own prompt.
+ *
+ * Subagent traffic carries `parent_tool_use_id`, so this echo lands in the main
+ * thread and stacks a second copy of the prompt right below the Agent tool card
+ * that already displays it. It also disappears on reload, because the transcript
+ * keeps that turn in the subagent's sidechain rather than the session file.
+ * @param {Object} message - Normalized message about to be sent to the client
+ * @returns {boolean}
+ */
+export function isSubagentPromptEcho(message) {
+    return Boolean(message?.parentToolUseId) && message.role === 'user' && message.kind === 'text';
+}
 function readNumber(value) {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : 0;
 }
 /**
- * Extracts token usage from SDK messages.
- * Prefers per-step `message.usage` (Claude message payload), then falls back
- * to result-level usage/modelUsage for compatibility across SDK versions.
+ * @typedef {Object} TokenBudget
+ * @property {number} used
+ * @property {number} total
+ * @property {number} inputTokens
+ * @property {number} outputTokens
+ * @property {number} [cacheReadTokens]
+ * @property {number} [cacheCreationTokens]
+ * @property {number} [cacheTokens]
+ * @property {{ input: number, output: number }} breakdown
+ */
+/**
+ * Builds a context-window budget from an Anthropic-shaped usage payload.
+ *
+ * `input_tokens + cache_read + cache_creation` is one request's whole prompt,
+ * which is exactly what the context window holds at that moment.
+ * @param {Object} messageUsage - Anthropic usage payload
+ * @returns {TokenBudget} Token budget object
+ */
+function buildTokenBudget(messageUsage) {
+    const directInputTokens = readNumber(messageUsage.input_tokens ?? messageUsage.inputTokens);
+    const cacheCreationTokens = readNumber(messageUsage.cache_creation_input_tokens ?? messageUsage.cacheCreationInputTokens ?? messageUsage.cacheCreationTokens);
+    const cacheReadTokens = readNumber(messageUsage.cache_read_input_tokens ?? messageUsage.cacheReadInputTokens ?? messageUsage.cacheReadTokens);
+    const cacheTokens = cacheCreationTokens + cacheReadTokens;
+    const inputTokens = directInputTokens + cacheTokens;
+    const outputTokens = readNumber(messageUsage.output_tokens ?? messageUsage.outputTokens);
+    const contextWindow = parseInt(process.env.CONTEXT_WINDOW, 10) || 160000;
+    return {
+        used: inputTokens + outputTokens,
+        total: contextWindow,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheCreationTokens,
+        cacheTokens,
+        breakdown: {
+            input: inputTokens,
+            output: outputTokens,
+        },
+    };
+}
+/**
+ * Extracts the session's context-window usage from an SDK stream message.
+ *
+ * Only assistant messages describe the context window: each one reports the
+ * prompt its own request carried. The turn-ending `result` is deliberately not
+ * a source here — see `extractCumulativeTokenBudget`.
  * @param {Object} sdkMessage - SDK stream message
- * @returns {Object|null} Token budget object or null
+ * @returns {TokenBudget|null} Token budget object or null
  */
 function extractTokenBudget(sdkMessage) {
     if (!sdkMessage || typeof sdkMessage !== 'object') {
         return null;
     }
-    const messageUsage = sdkMessage.message?.usage || sdkMessage.usage;
-    if (messageUsage && typeof messageUsage === 'object') {
-        const directInputTokens = readNumber(messageUsage.input_tokens ?? messageUsage.inputTokens);
-        const cacheCreationTokens = readNumber(messageUsage.cache_creation_input_tokens ?? messageUsage.cacheCreationInputTokens ?? messageUsage.cacheCreationTokens);
-        const cacheReadTokens = readNumber(messageUsage.cache_read_input_tokens ?? messageUsage.cacheReadInputTokens ?? messageUsage.cacheReadTokens);
-        const cacheTokens = cacheCreationTokens + cacheReadTokens;
-        const inputTokens = directInputTokens + cacheTokens;
-        const outputTokens = readNumber(messageUsage.output_tokens ?? messageUsage.outputTokens);
-        const totalUsed = inputTokens + outputTokens;
-        const contextWindow = parseInt(process.env.CONTEXT_WINDOW, 10) || 160000;
-        return {
-            used: totalUsed,
-            total: contextWindow,
-            inputTokens,
-            outputTokens,
-            cacheReadTokens,
-            cacheCreationTokens,
-            cacheTokens,
-            breakdown: {
-                input: inputTokens,
-                output: outputTokens,
-            },
-        };
+    // Subagent traffic (parent_tool_use_id set) reports the subagent's own
+    // context window, not this session's — surfacing it makes the counter drop
+    // to the subagent's number and bounce back on the next main-thread event.
+    if (sdkMessage.parent_tool_use_id) {
+        return null;
+    }
+    // Only assistant messages carry Anthropic-shaped usage. System
+    // task_progress/task_notification events have a top-level `usage` too, but
+    // shaped {total_tokens, tool_uses, duration_ms} — reading Anthropic keys
+    // off it yields an all-zero budget that flashes "0" in the composer.
+    if (sdkMessage.type !== 'assistant') {
+        return null;
+    }
+    const messageUsage = sdkMessage.message?.usage;
+    if (!messageUsage || typeof messageUsage !== 'object') {
+        return null;
+    }
+    return buildTokenBudget(messageUsage);
+}
+/**
+ * Last-resort budget read from a turn's `result` message.
+ *
+ * `result.usage` and `result.modelUsage` are the turn's *bill*: every request
+ * the turn made, summed, including each subagent's. A turn that made four
+ * requests therefore reports roughly four times the context the conversation
+ * actually holds, so publishing it made the counter leap at the end of a turn
+ * and fall back on the next assistant message — worst with subagents running,
+ * whose requests inflate the sum without ever entering this session's context.
+ *
+ * It is still the only usage an SDK build that reports none per assistant
+ * message ever emits, so it stays available for the caller to use when a turn
+ * produced no assistant budget at all.
+ * @param {Object} sdkMessage - SDK stream message
+ * @returns {TokenBudget|null} Token budget object or null
+ */
+function extractCumulativeTokenBudget(sdkMessage) {
+    if (!sdkMessage || typeof sdkMessage !== 'object' || sdkMessage.type !== 'result') {
+        return null;
+    }
+    if (sdkMessage.usage && typeof sdkMessage.usage === 'object') {
+        return buildTokenBudget(sdkMessage.usage);
     }
     if (!sdkMessage.modelUsage || typeof sdkMessage.modelUsage !== 'object') {
         return null;
@@ -338,19 +501,26 @@ function extractTokenBudget(sdkMessage) {
         },
     };
 }
-// Tool calls that leave work running past the end of a turn. Bash only counts
-// when it is explicitly backgrounded; the rest defer or watch work by nature.
-const DEFERRED_WORK_TOOLS = new Set(['Monitor', 'ScheduleWakeup', 'CronCreate', 'TaskCreate']);
+// Tool calls that leave work running past the end of a turn. Bash and Agent only
+// count when they are backgrounded; the rest defer or watch work by nature.
+// Workflow belongs here rather than in a branch of its own: its input schema has
+// no foreground option at all, so every call returns a task id immediately and
+// reports back in a later turn.
+const DEFERRED_WORK_TOOLS = new Set(['Monitor', 'ScheduleWakeup', 'CronCreate', 'TaskCreate', 'Workflow']);
 /**
  * Detects tool calls that keep working after the turn's `result` arrives.
  *
  * Only turns that start background work need their CLI process held open; every
  * other turn can let it exit immediately, as it did before the hold existed.
  *
+ * Used by the providers module's tests, which pin the tool matching directly:
+ * the alternative is driving a whole SDK run to observe whether stdin was held,
+ * and the cost of getting this wrong is silently killed background work.
+ *
  * @param {Object} sdkMessage - SDK stream message
  * @returns {boolean} True when the message launches work that outlives the turn
  */
-function startsBackgroundWork(sdkMessage) {
+export function startsBackgroundWork(sdkMessage) {
     const content = sdkMessage?.message?.content;
     if (!Array.isArray(content)) {
         return false;
@@ -362,9 +532,152 @@ function startsBackgroundWork(sdkMessage) {
         if (block.name === 'Bash') {
             return block.input?.run_in_background === true;
         }
+        // A backgrounded subagent outlives the turn exactly like a backgrounded
+        // Bash does, so the process has to be held open for it to report back.
+        // Agents background by default — `run_in_background` is optional and only
+        // an explicit `false` opts out — hence `!== false` rather than `=== true`.
+        // A foreground agent must stay out of DEFERRED_WORK_TOOLS: it never pushes
+        // a follow-up turn, so it would pin the process for the full ceiling.
+        if (block.name === 'Agent') {
+            return block.input?.run_in_background !== false;
+        }
         return DEFERRED_WORK_TOOLS.has(block.name);
     });
 }
+// `task_updated` patch statuses after which a task is gone for good. `pending`,
+// `running` and `paused` are still outstanding; `killed` is what the CLI
+// writes when it stops a task itself (the task notification spells it
+// `stopped`).
+const TERMINAL_TASK_STATUSES = new Set(['completed', 'failed', 'killed']);
+/**
+ * Tracks the background tasks each live session still has outstanding, folded
+ * from the `system` task events the SDK stream already carries.
+ *
+ * `startsBackgroundWork` above only knows that a turn *launched* something
+ * lasting; this knows what is still running and which task ids it answers to,
+ * which is what the running-sessions list and a stop request need once the
+ * turn's `result` has gone out and nothing else remembers the session is busy.
+ *
+ * Verified against a real query (SDK 0.3.165): `task_started` carries
+ * `task_id`, `tool_use_id`, `task_type` and `description` for every agent,
+ * workflow and backgrounded command (a foreground Bash emits nothing);
+ * `task_notification` settles a task with any status; `task_updated` carries
+ * only `task_id` and a patch, and is terminal when the patch's `status` is.
+ * Housekeeping tasks the CLI starts on its own have no `tool_use_id` and are
+ * not tracked — nothing in the transcript could show them.
+ *
+ * Exported so the folding can be driven with the four event shapes directly;
+ * the runtime keeps one instance keyed like `activeSessions`.
+ *
+ * @returns {{
+ *   apply: (sessionKey: string, message: Object) => void,
+ *   hasOutstanding: (sessionKey: string) => boolean,
+ *   has: (sessionKey: string, taskId: string) => boolean,
+ *   outstanding: (sessionKey: string) => Array<import('../../../../shared/types.js').BackgroundTaskSummary>,
+ *   clear: (sessionKey: string) => void,
+ *   list: () => Array<{ sessionId: string, tasks: Array<import('../../../../shared/types.js').BackgroundTaskSummary> }>
+ * }}
+ */
+export function createBackgroundWorkTracker() {
+    /** @type {Map<string, Map<string, import('../../../../shared/types.js').BackgroundTaskSummary>>} */
+    const sessions = new Map();
+    /**
+     * Tool-use ids the session's own turns issued. A task started for a call an
+     * agent made inside its own transcript — a workflow agent's backgrounded
+     * command, say — reaches this stream too, and nothing in the parent
+     * transcript could show it; it is kept for stopping but flagged `nested`.
+     * @type {Map<string, Set<string>>}
+     */
+    const ownToolUseIds = new Map();
+    const remove = (sessionKey, taskId) => {
+        const tasks = sessions.get(sessionKey);
+        if (!tasks) {
+            return;
+        }
+        tasks.delete(taskId);
+        if (tasks.size === 0) {
+            sessions.delete(sessionKey);
+        }
+    };
+    return {
+        apply(sessionKey, message) {
+            if (message?.type === 'assistant' && !message.parent_tool_use_id) {
+                const content = message.message?.content;
+                if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (block?.type === 'tool_use' && typeof block.id === 'string') {
+                            let ids = ownToolUseIds.get(sessionKey);
+                            if (!ids) {
+                                ids = new Set();
+                                ownToolUseIds.set(sessionKey, ids);
+                            }
+                            ids.add(block.id);
+                        }
+                    }
+                }
+                return;
+            }
+            if (message?.type !== 'system' || typeof message.task_id !== 'string') {
+                return;
+            }
+            switch (message.subtype) {
+                case 'task_started': {
+                    if (typeof message.tool_use_id !== 'string') {
+                        return;
+                    }
+                    const task = {
+                        taskId: message.task_id,
+                        toolUseId: message.tool_use_id,
+                        taskType: message.task_type,
+                        description: message.description,
+                        startedAt: Date.now()
+                    };
+                    if (typeof message.workflow_name === 'string') {
+                        task.workflowName = message.workflow_name;
+                    }
+                    if (!ownToolUseIds.get(sessionKey)?.has(message.tool_use_id)) {
+                        task.nested = true;
+                    }
+                    let tasks = sessions.get(sessionKey);
+                    if (!tasks) {
+                        tasks = new Map();
+                        sessions.set(sessionKey, tasks);
+                    }
+                    tasks.set(task.taskId, task);
+                    return;
+                }
+                case 'task_notification':
+                    remove(sessionKey, message.task_id);
+                    return;
+                case 'task_updated':
+                    if (TERMINAL_TASK_STATUSES.has(message.patch?.status)) {
+                        remove(sessionKey, message.task_id);
+                    }
+                    return;
+                default:
+            }
+        },
+        hasOutstanding(sessionKey) {
+            return sessions.has(sessionKey);
+        },
+        has(sessionKey, taskId) {
+            return Boolean(sessions.get(sessionKey)?.has(taskId));
+        },
+        outstanding(sessionKey) {
+            return Array.from(sessions.get(sessionKey)?.values() ?? []);
+        },
+        clear(sessionKey) {
+            sessions.delete(sessionKey);
+            ownToolUseIds.delete(sessionKey);
+        },
+        list() {
+            return Array.from(sessions, ([sessionId, tasks]) => ({
+                sessionId,
+                tasks: Array.from(tasks.values())
+            }));
+        }
+    };
+}
 /**
  * Builds the SDK user messages for one turn.
  *
@@ -509,13 +822,22 @@ async function queryClaudeSDK(command, options = {}, ws, context) {
     // Set when a turn starts background work, cleared when the next `result`
     // arrives — only turns with work still outstanding hold their process open.
     let backgroundWorkPending = false;
+    // Set when the stream reports a task starting during this turn. Task events
+    // are the exact word on what is still running, so when the turn produced
+    // any, the tracker decides the hold; `startsBackgroundWork` is the fallback
+    // for tools that emit none (Monitor, ScheduleWakeup, CronCreate, TaskCreate)
+    // and for an SDK that does not report tasks at all.
+    let sawTaskEventThisTurn = false;
     // True while the process is being held open for background work, so a later
     // `result` can be recognised as that work reporting back.
     let heldForBackgroundWork = false;
+    // Set once a turn publishes a budget read from an assistant message, so the
+    // turn-ending `result` is only mined for usage when nothing better arrived.
+    let assistantBudgetSent = false;
     // A new turn supersedes any earlier one still holding this session's process
     // open, so held runs cannot stack up across a conversation.
     if (sessionKey()) {
-        getSession(sessionKey())?.releaseInput?.();
+        releaseHeldSession(sessionKey());
     }
     // Arms (or re-arms) the idle countdown that eventually closes stdin.
     const scheduleRelease = () => {
@@ -630,6 +952,12 @@ async function queryClaudeSDK(command, options = {}, ws, context) {
             if (decision.cancelled) {
                 return { behavior: 'deny', message: 'Permission request cancelled' };
             }
+            // A client answered. Announce it on the run stream so the replay buffer
+            // and every other attached tab drop the prompt — resolving happens over
+            // the inbound socket only, so without this a mid-run page refresh
+            // replays the `permission_request` with nothing to retract it and the
+            // already-answered prompt resurrects.
+            ws.send(createNormalizedMessage({ kind: 'permission_resolved', requestId, sessionId: capturedSessionId || sessionId || null, provider: 'claude' }));
             if (decision.allow) {
                 if (decision.rememberEntry && typeof decision.rememberEntry === 'string') {
                     if (!sdkOptions.allowedTools.includes(decision.rememberEntry)) {
@@ -643,10 +971,13 @@ async function queryClaudeSDK(command, options = {}, ws, context) {
             }
             return { behavior: 'deny', message: decision.message ?? 'User denied tool use' };
         };
+        // The SDK's own `query`, unless the caller supplies one (tests script the
+        // stream to drive the hold logic below without a CLI process).
+        const createQuery = context.createQuery ?? query;
         let heldPrompt = createHeldPromptStream(promptMessages);
         releasePromptStream = heldPrompt.release;
         try {
-            queryInstance = query({
+            queryInstance = createQuery({
                 prompt: heldPrompt.stream,
                 options: sdkOptions
             });
@@ -660,7 +991,7 @@ async function queryClaudeSDK(command, options = {}, ws, context) {
             heldPrompt.release();
             heldPrompt = createHeldPromptStream(promptMessages);
             releasePromptStream = heldPrompt.release;
-            queryInstance = query({
+            queryInstance = createQuery({
                 prompt: heldPrompt.stream,
                 options: sdkOptions
             });
@@ -699,19 +1030,47 @@ async function queryClaudeSDK(command, options = {}, ws, context) {
                 if (transformedMessage.parentToolUseId && !msg.parentToolUseId) {
                     msg.parentToolUseId = transformedMessage.parentToolUseId;
                 }
+                if (isSubagentPromptEcho(msg)) {
+                    continue;
+                }
                 ws.send(msg);
             }
-            // Extract and send token budget updates from assistant/result usage payloads
-            const tokenBudgetData = extractTokenBudget(message);
+            // Extract and send token budget updates from assistant usage payloads,
+            // falling back to the turn's cumulative bill only for SDK builds that
+            // report no per-assistant usage at all.
+            const tokenBudgetData = extractTokenBudget(message)
+                || (assistantBudgetSent ? null : extractCumulativeTokenBudget(message));
             if (tokenBudgetData) {
+                if (message.type === 'assistant') {
+                    assistantBudgetSent = true;
+                }
                 ws.send(createNormalizedMessage({ kind: 'status', text: 'token_budget', tokenBudget: tokenBudgetData, sessionId: capturedSessionId || sessionId || null, provider: 'claude' }));
             }
             if (startsBackgroundWork(message)) {
                 backgroundWorkPending = true;
             }
+            if (message.type === 'system' && message.subtype === 'task_started') {
+                sawTaskEventThisTurn = true;
+            }
+            backgroundWork.apply(sessionKey(), message);
+            // A task the user stopped gets no follow-up turn from the CLI — only its
+            // `stopped` notification — so when that was the last outstanding task
+            // nothing will ever push the `result` the release below waits for, and
+            // the process would sit until the idle ceiling. Release it here. A
+            // completed task is different: the CLI relays its result in a turn of
+            // its own, which closing stdin now would cut short.
+            if (heldForBackgroundWork
+                && message.type === 'system'
+                && message.subtype === 'task_notification'
+                && message.status === 'stopped'
+                && !backgroundWork.hasOutstanding(sessionKey())) {
+                heldForBackgroundWork = false;
+                releasePromptStream();
+            }
             if (message.type === 'result') {
                 // The turn is done as far as the client is concerned.
                 const abortPending = sessionKey() ? abortedSessionIds.has(sessionKey()) : false;
+                const stillOutstanding = backgroundWork.hasOutstanding(sessionKey());
                 if (!turnCompleteSent && !abortPending) {
                     turnCompleteSent = true;
                     ws.send(createCompleteMessage({ provider: 'claude', sessionId: capturedSessionId || sessionId || null, exitCode: 0 }));
@@ -723,9 +1082,10 @@ async function queryClaudeSDK(command, options = {}, ws, context) {
                         stopReason: 'completed'
                     });
                 }
-                else if (heldForBackgroundWork && !abortPending) {
+                else if (heldForBackgroundWork && !abortPending && !stillOutstanding) {
                     // A result after the turn already reported complete means the work we
-                    // held the process open for has finished and pushed a follow-up turn.
+                    // held the process open for has finished and pushed a follow-up turn
+                    // — the last of it, when nothing else is still running.
                     notifyBackgroundWorkCompleted({
                         userId: ws?.userId || null,
                         provider: 'claude',
@@ -733,11 +1093,26 @@ async function queryClaudeSDK(command, options = {}, ws, context) {
                         sessionName: sessionSummary
                     });
                 }
-                if (backgroundWorkPending) {
-                    // Work started during this turn is still running. Hold the process
-                    // open so it can finish and report back in a follow-up turn; the
-                    // ceiling is only a backstop for work that never reports.
-                    backgroundWorkPending = false;
+                // Work started during this turn, or work from an earlier turn that
+                // has not settled yet (a follow-up turn reports one task in while
+                // another is still going), is still running. Hold the process open
+                // so it can finish and report back in a follow-up turn; the ceiling
+                // is only a backstop for work that never reports.
+                //
+                // The release when the last task settles is this same branch on the
+                // follow-up turn the CLI pushes for it, not the settling event
+                // itself: closing stdin at that moment would cut the turn that
+                // relays the task's result.
+                //
+                // When the turn reported its tasks, the tracker is the whole truth: an
+                // Agent call without `run_in_background` is scored as background by
+                // `startsBackgroundWork`, but the CLI runs it in the foreground and
+                // it has settled before this `result` — holding for it kept a process
+                // alive for the full ceiling with nothing outstanding.
+                const holdForTurn = sawTaskEventThisTurn ? stillOutstanding : backgroundWorkPending || stillOutstanding;
+                backgroundWorkPending = false;
+                sawTaskEventThisTurn = false;
+                if (holdForTurn) {
                     heldForBackgroundWork = true;
                     scheduleRelease();
                 }
@@ -863,6 +1238,34 @@ async function abortClaudeSDKSession(sessionId) {
         return false;
     }
 }
+/**
+ * Sessions whose background tasks are still outstanding, with the tasks.
+ *
+ * A session stays here after its turn's `result` for as long as the process
+ * is held open for the work — which is exactly the window in which nothing
+ * else (the chat run registry marks the run completed at `result`) knows the
+ * session is still busy.
+ * @returns {Array<{ sessionId: string, tasks: Array<import('../../../../shared/types.js').BackgroundTaskSummary> }>}
+ */
+function listClaudeSDKBackgroundWork() {
+    return backgroundWork.list();
+}
+/**
+ * Stops one outstanding background task through the SDK, which then emits a
+ * `task_notification` with status `stopped` — the same event that drops the
+ * task from the tracker and settles its card.
+ * @param {string} sessionId - Session identifier
+ * @param {string} taskId - The task's `task_id` as reported on `task_started`
+ * @returns {Promise<boolean>} False when no live process is tracking the task
+ */
+async function stopClaudeSDKTask(sessionId, taskId) {
+    const session = getSession(sessionId);
+    if (!session || !backgroundWork.has(sessionId, taskId)) {
+        return false;
+    }
+    await session.instance.stopTask(taskId);
+    return true;
+}
 /**
  * Checks if an SDK session is currently active
  * @param {string} sessionId - Session identifier
@@ -870,7 +1273,21 @@ async function abortClaudeSDKSession(sessionId) {
  */
 function isClaudeSDKSessionActive(sessionId) {
     const session = getSession(sessionId);
-    return session && session.status === 'active';
+    return Boolean(session && session.status === 'active');
+}
+/**
+ * When the run behind a session started, or null when no run is up.
+ *
+ * The history reader uses this to tell a background agent launched by the
+ * live process (still able to report back) from one launched by an earlier
+ * process that has since exited (never will): a launch row older than the
+ * live run cannot belong to it.
+ * @param {string} sessionId - Session identifier
+ * @returns {number|null} Epoch milliseconds the live run started, or null
+ */
+function getClaudeSDKSessionStartTime(sessionId) {
+    const session = getSession(sessionId);
+    return session && session.status === 'active' ? session.startTime : null;
 }
 /**
  * Gets all active SDK session IDs
@@ -922,7 +1339,9 @@ export const claudeRuntime = {
         resolve: resolveToolApproval,
         listPending: getPendingApprovalsForSession,
     },
+    listBackgroundWork: listClaudeSDKBackgroundWork,
+    stopBackgroundTask: stopClaudeSDKTask,
 };
 // Export public API
-export { queryClaudeSDK, abortClaudeSDKSession, isClaudeSDKSessionActive, getActiveClaudeSDKSessions, resolveToolApproval, getPendingApprovalsForSession, reconnectSessionWriter };
+export { queryClaudeSDK, abortClaudeSDKSession, listClaudeSDKBackgroundWork, stopClaudeSDKTask, isClaudeSDKSessionActive, getClaudeSDKSessionStartTime, getActiveClaudeSDKSessions, resolveToolApproval, getPendingApprovalsForSession, reconnectSessionWriter, extractTokenBudget, extractCumulativeTokenBudget };
 //# sourceMappingURL=claude-runtime.provider.js.map