@cjhyy/code-shell-core 0.7.0-beta.1 → 0.7.1

package/dist/session/transcript.js

@@ -10,11 +10,15 @@ export class Transcript {
     events = [];
     filePath;
     currentTurn = 0;
+    writer;
+    dirty = false;
+    lastFlushFailure;
     getFilePath() {
         return this.filePath;
     }
-    constructor(filePath) {
+    constructor(filePath, writer = appendFileSync) {
         this.filePath = filePath;
+        this.writer = writer;
         mkdirSync(dirname(filePath), { recursive: true });
         if (!existsSync(filePath)) {
             writeFileSync(filePath, "", "utf-8");
@@ -179,18 +183,65 @@ export class Transcript {
     get eventCount() {
         return this.events.length;
     }
+    /** True once any event failed both persistence attempts. Sticky by design. */
+    flushFailed() {
+        return this.dirty;
+    }
+    /** Structured details for the most recent unrecoverable flush failure. */
+    getFlushFailure() {
+        return this.lastFlushFailure ? { ...this.lastFlushFailure } : undefined;
+    }
     findMessageByClientId(clientMessageId) {
         return this.events.find((event) => event.type === "message" &&
             event.data.clientMessageId === clientMessageId);
     }
     flush(event) {
+        const line = JSON.stringify(event) + "\n";
         try {
-            appendFileSync(this.filePath, JSON.stringify(event) + "\n", "utf-8");
+            this.writer(this.filePath, line, "utf-8");
+            return true;
         }
-        catch {
-            // Silently fail on flush errors — events are still in memory
+        catch (firstError) {
+            try {
+                this.writer(this.filePath, line, "utf-8");
+                logger.warn("transcript.flush_retry_recovered", {
+                    filePath: this.filePath,
+                    errno: this.errorErrno(firstError),
+                    message: this.errorMessage(firstError),
+                });
+                return true;
+            }
+            catch (retryError) {
+                const err = retryError;
+                const failure = {
+                    errno: this.errorErrno(retryError),
+                    ...(typeof err?.code === "string" ? { code: err.code } : {}),
+                    message: this.errorMessage(retryError),
+                    timestamp: Date.now(),
+                    attempts: 2,
+                    recoverable: false,
+                    filePath: this.filePath,
+                };
+                // Sticky: a later successful append cannot restore an earlier missing
+                // JSONL event, so the transcript remains degraded for this instance.
+                this.dirty = true;
+                this.lastFlushFailure = failure;
+                logger.error("transcript.flush_failed", { ...failure });
+                return false;
+            }
         }
     }
+    errorErrno(error) {
+        const err = error;
+        if (typeof err?.errno === "number" || typeof err?.errno === "string")
+            return err.errno;
+        if (typeof err?.code === "string")
+            return err.code;
+        return "UNKNOWN";
+    }
+    errorMessage(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
     /**
      * Repair tool_result pairing issues:
      * - Orphaned tool_results (no matching tool_use) get removed
@@ -227,6 +278,70 @@ export class Transcript {
             return true;
         });
     }
+    static readEvents(filePath) {
+        let raw;
+        try {
+            raw = readFileSync(filePath, "utf-8");
+        }
+        catch {
+            return { events: [], malformedLineCount: 0 };
+        }
+        const lines = raw.split("\n").filter((line) => line.trim().length > 0);
+        const events = [];
+        let malformedLineCount = 0;
+        for (const line of lines) {
+            try {
+                events.push(JSON.parse(line));
+            }
+            catch {
+                malformedLineCount++;
+            }
+        }
+        return { events, malformedLineCount };
+    }
+    static eventsToMessages(events) {
+        const messages = [];
+        for (const event of events) {
+            switch (event.type) {
+                case "message": {
+                    const { role, content } = event.data;
+                    messages.push({ role, content });
+                    break;
+                }
+                case "tool_use":
+                    break;
+                case "tool_result": {
+                    const { toolCallId, result, error, contentBlocks } = event.data;
+                    const block = {
+                        type: "tool_result",
+                        tool_use_id: toolCallId,
+                        content: error
+                            ? `Error: ${error}`
+                            : Array.isArray(contentBlocks) && contentBlocks.length > 0
+                                ? contentBlocks
+                                : (result ?? "(no output)"),
+                    };
+                    const last = messages[messages.length - 1];
+                    if (last?.role === "user" && Array.isArray(last.content)) {
+                        last.content.push(block);
+                    }
+                    else {
+                        messages.push({ role: "user", content: [block] });
+                    }
+                    break;
+                }
+                case "summary": {
+                    const { summary } = event.data;
+                    messages.push({
+                        role: "user",
+                        content: `<system-reminder>Previous conversation was summarized:\n${summary}</system-reminder>`,
+                    });
+                    break;
+                }
+            }
+        }
+        return messages;
+    }
     static loadFromFile(filePath) {
         const transcript = new Transcript(filePath);
         if (!existsSync(filePath))

package/dist/tool-system/builtin/agent-notifications.d.ts

@@ -6,8 +6,9 @@ import type { BackgroundAgentCompletedEvent, StreamEvent } from "../../types.js"
  * background sub-agent that finishes (completed | failed) enqueues an item
  * here; the UI layer subscribes and, when the main agent is idle, drains
  * the queue and submits the formatted XML as a new user turn so the LLM
- * sees the result. Cancellation does NOT enqueue (user explicitly stopped
- * the agent; no follow-up needed).
+ * sees the result. Sub-agent cancellation does NOT enqueue (user explicitly
+ * stopped the agent; no follow-up needed). DriveAgent cancellation does enqueue
+ * so a detached external CLI job never leaves the waiting session hanging.
  *
  * The result text lives only in this queue + the eventual user message —
  * not in `asyncAgentRegistry`. Registry stays metadata-only.
@@ -29,7 +30,7 @@ export type NotificationItem = {
     agentId: string;
     name?: string;
     description: string;
-    status: "completed" | "failed";
+    status: "completed" | "failed" | "cancelled";
     /** What kind of background work this was (lets UIs localize the toast). */
     workKind?: "agent" | "shell" | "video" | "cc";
     /** For workKind === "shell": the command that ran. */
@@ -41,8 +42,14 @@ export type NotificationItem = {
      *  if this notification is lost, and the user sees a real session id (not just
      *  an opaque background jobId). */
     ccSessionId?: string;
-    /** Error message (failed only). */
+    /** Error message (failed/cancelled only). */
     error?: string;
+    /** Files attributed to an external DriveAgent transcript. */
+    changedFiles?: string[];
+    /** DriveAgent cwd used to canonicalize path aliases in clients. */
+    cwd?: string;
+    /** Client id of the real user turn that launched this background work. */
+    originClientMessageId?: string;
     enqueuedAt: number;
 };
 type Listener = () => void;

package/dist/tool-system/builtin/agent-notifications.js

@@ -139,6 +139,15 @@ export function notificationItemToStreamEvent(item) {
         event.finalText = item.finalText;
     if (item.error !== undefined)
         event.error = item.error;
+    if (item.ccSessionId !== undefined)
+        event.ccSessionId = item.ccSessionId;
+    if (item.changedFiles !== undefined)
+        event.changedFiles = item.changedFiles;
+    if (item.cwd !== undefined)
+        event.cwd = item.cwd;
+    if (item.originClientMessageId !== undefined) {
+        event.originClientMessageId = item.originClientMessageId;
+    }
     return event;
 }
 /**
@@ -147,10 +156,7 @@ export function notificationItemToStreamEvent(item) {
  * values get the quote escape too; element bodies don't need it.
  */
 function escapeXmlText(s) {
-    return s
-        .replace(/&/g, "&")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;");
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 function escapeXmlAttr(s) {
     return escapeXmlText(s).replace(/"/g, "&quot;");
@@ -173,7 +179,9 @@ export function buildNotificationMessage(items) {
         const desc = `    <description>${escapeXmlText(item.description)}</description>`;
         const body = item.status === "completed"
             ? `    <result>\n${escapeXmlText(item.finalText ?? "")}\n    </result>`
-            : `    <error>${escapeXmlText(item.error ?? "")}</error>`;
+            : item.status === "cancelled"
+                ? `    <cancelled>${escapeXmlText(item.error ?? "cancelled")}</cancelled>`
+                : `    <error>${escapeXmlText(item.error ?? "")}</error>`;
         return [opening, desc, body, "  </agent>"].join("\n");
     })
         .join("\n");
@@ -194,9 +202,13 @@ export function buildNotificationMessage(items) {
 export function buildNotificationSummary(items) {
     const header = "📨 background agents completed";
     const rows = items.map((item) => {
-        const badge = item.status === "completed" ? "✓" : "✗";
+        const badge = item.status === "completed" ? "✓" : item.status === "cancelled" ? "cancelled" : "✗";
         const namePart = item.name ? `${item.name}  ·  ` : "";
-        const statusPart = item.status === "failed" ? `  ·  failed: ${item.error ?? "unknown"}` : "";
+        const statusPart = item.status === "failed"
+            ? `  ·  failed: ${item.error ?? "unknown"}`
+            : item.status === "cancelled"
+                ? `  ·  cancelled`
+                : "";
         return `  └─ ${namePart}${item.description}  ·  ${badge}${statusPart}`;
     });
     return [header, ...rows].join("\n");

package/dist/tool-system/builtin/agent.js

@@ -269,7 +269,9 @@ streamOverride) {
     // that no longer exists. The child Engine is a fresh instance; plan-mode
     // isolation between parent and child is enforced via separate Engine
     // instances (finalized in T6).
-    const { text } = await spawner.spawn({ ...opts, streamOverride });
+    const { text, usage } = await spawner.spawn({ ...opts, streamOverride });
+    if (usage)
+        opts.recordBilledUsage?.(usage);
     const finalText = text || `Agent completed but produced no text output.`;
     safeEmit(startEndSink, { type: "agent_end", agentId, name, description, text: finalText, agentType });
     emitSubAgentHook(opts.hooks, "subagent_finish", { agentId, description, text: finalText });
@@ -372,6 +374,7 @@ export async function agentTool(args, ctx) {
             appendSystemPrompt: overrides.appendSystemPrompt,
             readOnlySession: overrides.resolvedType === "researcher" || overrides.resolvedType === "explorer",
             hooks: ctx?.hooks,
+            recordBilledUsage: ctx?.recordBilledUsage,
             signal: controller.signal,
         }, parentStream, // uiStream: agent_start/end → main feed
         transcriptSink)
@@ -581,6 +584,7 @@ async function runSyncSubAgent(args) {
         readOnlySession: overrides.resolvedType === "researcher" || overrides.resolvedType === "explorer",
         resumeSessionId,
         hooks: ctx?.hooks,
+        recordBilledUsage: ctx?.recordBilledUsage,
         signal: syncController.signal,
     });
     // Sentinel that the timer resolves with, so we can tell "agent finished" from

package/dist/tool-system/builtin/arena.js

@@ -390,6 +390,7 @@ export async function arenaTool(args, ctx) {
             signal,
         });
         const result = await arena.run(topic);
+        ctx.recordBilledUsage?.(result.usage);
         // Use session renderer (markdown, no ANSI) for tool results.
         // Terminal renderer (chalk) is only for direct stdout printing.
         const formattedResult = formatArenaResultForSession(result);

package/dist/tool-system/builtin/background-jobs.d.ts

@@ -1,8 +1,8 @@
 /**
  * Registry of NON-agent background jobs (GenerateVideo poll loops, DriveAgent
  * external CLI runs). Mirrors the role `asyncAgentRegistry` plays for background
- * sub-agents, but a job is not an agent — it has no transcript, no abort(), and
- * must NOT show up in AgentStatus.
+ * sub-agents, but a job is not an agent — it has no transcript and must NOT
+ * show up in AgentStatus.
  *
  * The engine's wait-for-background loop parks the turn until a session has no
  * more RUNNING jobs, so the goal-stop-hook doesn't force the model to busy-loop
@@ -21,11 +21,15 @@
  * loop observe the same instance.
  */
 type Listener = () => void;
-export type BackgroundJobStatus = "running" | "completed" | "failed";
+export type BackgroundJobStatus = "running" | "cancelling" | "completed" | "failed" | "cancelled";
+export type BackgroundJobKind = "drive-agent" | "video" | "job";
+export type ExternalCliKind = "claude" | "codex";
 /** A background job, running or finished. */
 export interface BackgroundJobEntry {
     jobId: string;
     sessionId: string;
+    /** Machine-readable kind for tools that need to target a subset of jobs. */
+    kind?: BackgroundJobKind;
     /** Human description (e.g. "Generating video: <prompt>"). Shown to the goal
      *  judge (running) and in the background panel (all). */
     description: string;
@@ -42,16 +46,31 @@ export interface BackgroundJobEntry {
     changedFiles?: string[];
     /** Working directory for jobs that operate on the filesystem, e.g. DriveAgent. */
     cwd?: string;
+    /** DriveAgent prompt summary, separate from the UI-oriented description. */
+    promptSummary?: string;
+    /** External CLI kind for DriveAgent jobs. */
+    cli?: ExternalCliKind;
+    /** Client message that launched this external job. */
+    originClientMessageId?: string;
+    /** Optional cancellation hook for jobs backed by a live process. It may
+     *  return a richer terminal outcome when cancellation races with a result
+     *  that must still be retained (for example, a remotely rendered video). */
+    abort?: () => void | BackgroundJobOutcome | Promise<void | BackgroundJobOutcome>;
 }
 /** Outcome passed to finish() to record how a job ended. */
 export interface BackgroundJobOutcome {
-    status?: "completed" | "failed";
+    status?: "completed" | "failed" | "cancelled";
     finalText?: string;
     ccSessionId?: string;
     changedFiles?: string[];
 }
 export interface BackgroundJobStartOptions {
+    kind?: BackgroundJobKind;
     cwd?: string;
+    promptSummary?: string;
+    cli?: ExternalCliKind;
+    originClientMessageId?: string;
+    abort?: () => void | BackgroundJobOutcome | Promise<void | BackgroundJobOutcome>;
 }
 declare class BackgroundJobRegistry {
     private jobs;
@@ -61,7 +80,11 @@ declare class BackgroundJobRegistry {
     /** Mark a job terminal (retained, not deleted). Unknown id is a no-op (no
      *  notify) so a double-finish or a finish after reset stays quiet. */
     finish(jobId: string, outcome?: BackgroundJobOutcome): void;
-    /** True while any RUNNING job spawned by `sessionId` remains. */
+    get(jobId: string): BackgroundJobEntry | undefined;
+    /** Persist artifacts discovered while a running job is winding down. */
+    recordArtifacts(jobId: string, artifacts: Pick<BackgroundJobOutcome, "ccSessionId" | "changedFiles">): void;
+    cancel(jobId: string, outcome?: Omit<BackgroundJobOutcome, "status">): Promise<boolean>;
+    /** True while any running/cancelling job spawned by `sessionId` remains. */
     hasRunningForSession(sessionId: string): boolean;
     /** Running jobs spawned by `sessionId`. Feeds the goal judge's task list. */
     listRunningForSession(sessionId: string): BackgroundJobEntry[];

package/dist/tool-system/builtin/background-jobs.js

@@ -1,8 +1,8 @@
 /**
  * Registry of NON-agent background jobs (GenerateVideo poll loops, DriveAgent
  * external CLI runs). Mirrors the role `asyncAgentRegistry` plays for background
- * sub-agents, but a job is not an agent — it has no transcript, no abort(), and
- * must NOT show up in AgentStatus.
+ * sub-agents, but a job is not an agent — it has no transcript and must NOT
+ * show up in AgentStatus.
  *
  * The engine's wait-for-background loop parks the turn until a session has no
  * more RUNNING jobs, so the goal-stop-hook doesn't force the model to busy-loop
@@ -27,6 +27,31 @@ function isValidSessionId(sid) {
 /** Generous per-session cap on retained terminal jobs — a leak backstop, not a
  *  UX limit; a human never spawns this many background jobs in one session. */
 const MAX_TERMINAL_JOBS_PER_SESSION = 50;
+const CANCEL_WAIT_TIMEOUT_MS = 5_000;
+function isActiveStatus(status) {
+    return status === "running" || status === "cancelling";
+}
+async function waitForAbort(abort) {
+    let timer;
+    try {
+        const result = await Promise.race([
+            Promise.resolve().then(abort),
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(undefined), CANCEL_WAIT_TIMEOUT_MS);
+            }),
+        ]);
+        return result && typeof result === "object" ? result : undefined;
+    }
+    catch {
+        // Cancellation is best-effort; the terminal state still closes after the
+        // abort hook settles or the hard deadline expires.
+        return undefined;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 class BackgroundJobRegistry {
     jobs = new Map(); // jobId -> entry (insertion-ordered)
     listeners = new Set();
@@ -37,10 +62,17 @@ class BackgroundJobRegistry {
         this.jobs.set(jobId, {
             jobId,
             sessionId,
+            ...(options?.kind ? { kind: options.kind } : {}),
             description,
             status: "running",
             startedAt: Date.now(),
             ...(options?.cwd ? { cwd: normalizeCwdPath(options.cwd) } : {}),
+            ...(options?.promptSummary ? { promptSummary: options.promptSummary } : {}),
+            ...(options?.cli ? { cli: options.cli } : {}),
+            ...(options?.originClientMessageId
+                ? { originClientMessageId: options.originClientMessageId }
+                : {}),
+            ...(options?.abort ? { abort: options.abort } : {}),
         });
         this.notify();
     }
@@ -50,6 +82,8 @@ class BackgroundJobRegistry {
         const entry = this.jobs.get(jobId);
         if (!entry)
             return;
+        if (entry.status !== "running")
+            return;
         entry.status = outcome?.status ?? "completed";
         entry.finishedAt = Date.now();
         if (outcome?.finalText !== undefined)
@@ -61,22 +95,67 @@ class BackgroundJobRegistry {
         this.evictTerminalOverCap(entry.sessionId);
         this.notify();
     }
-    /** True while any RUNNING job spawned by `sessionId` remains. */
+    get(jobId) {
+        return this.jobs.get(jobId);
+    }
+    /** Persist artifacts discovered while a running job is winding down. */
+    recordArtifacts(jobId, artifacts) {
+        const entry = this.jobs.get(jobId);
+        if (!entry || !isActiveStatus(entry.status))
+            return;
+        if (artifacts.ccSessionId !== undefined)
+            entry.ccSessionId = artifacts.ccSessionId;
+        if (artifacts.changedFiles !== undefined)
+            entry.changedFiles = artifacts.changedFiles;
+    }
+    async cancel(jobId, outcome) {
+        const entry = this.jobs.get(jobId);
+        if (!entry)
+            return false;
+        if (entry.status !== "running")
+            return false;
+        // Publish a non-terminal guard before invoking external code. A completion
+        // callback may synchronously re-enter finish(); it must not publish
+        // completed/failed, while cwd/session conflict checks must still see the
+        // process as active until the abort hook confirms exit.
+        entry.status = "cancelling";
+        this.notify();
+        const abortOutcome = entry.abort ? await waitForAbort(entry.abort) : undefined;
+        // Session teardown/reset may have removed the entry while termination was
+        // in flight. Do not resurrect or notify for a closed session.
+        if (this.jobs.get(jobId) !== entry || entry.status !== "cancelling")
+            return false;
+        entry.status = abortOutcome?.status ?? "cancelled";
+        entry.finishedAt = Date.now();
+        const finalText = abortOutcome?.finalText ?? outcome?.finalText;
+        const ccSessionId = abortOutcome?.ccSessionId ?? outcome?.ccSessionId;
+        const changedFiles = abortOutcome?.changedFiles ?? outcome?.changedFiles;
+        if (finalText !== undefined)
+            entry.finalText = finalText;
+        if (ccSessionId !== undefined)
+            entry.ccSessionId = ccSessionId;
+        if (changedFiles !== undefined)
+            entry.changedFiles = changedFiles;
+        this.evictTerminalOverCap(entry.sessionId);
+        this.notify();
+        return true;
+    }
+    /** True while any running/cancelling job spawned by `sessionId` remains. */
     hasRunningForSession(sessionId) {
         for (const e of this.jobs.values()) {
-            if (e.sessionId === sessionId && e.status === "running")
+            if (e.sessionId === sessionId && isActiveStatus(e.status))
                 return true;
         }
         return false;
     }
     /** Running jobs spawned by `sessionId`. Feeds the goal judge's task list. */
     listRunningForSession(sessionId) {
-        return [...this.jobs.values()].filter((e) => e.sessionId === sessionId && e.status === "running");
+        return [...this.jobs.values()].filter((e) => e.sessionId === sessionId && isActiveStatus(e.status));
     }
     /** Running jobs, across all sessions, that are operating in the same cwd. */
     listRunningByCwd(cwd) {
         const normalized = normalizeCwdPath(cwd);
-        return [...this.jobs.values()].filter((e) => e.status === "running" && e.cwd === normalized);
+        return [...this.jobs.values()].filter((e) => isActiveStatus(e.status) && e.cwd === normalized);
     }
     /** All jobs (running + retained terminal) for `sessionId`. Feeds the panel. */
     listForSession(sessionId) {
@@ -89,12 +168,26 @@ class BackgroundJobRegistry {
     /** Drop every job of a session — called when the session is deleted/closed. */
     dropForSession(sessionId) {
         let removed = false;
+        const aborts = [];
         for (const [id, e] of this.jobs) {
             if (e.sessionId === sessionId) {
+                // Delete first so a synchronous/queued completion caused by abort sees
+                // no live registry entry and cannot publish a late result for a closed
+                // session. Terminal jobs have nothing left to stop.
                 this.jobs.delete(id);
+                if (isActiveStatus(e.status) && e.abort)
+                    aborts.push(e.abort);
                 removed = true;
             }
         }
+        for (const abort of aborts) {
+            try {
+                void Promise.resolve(abort()).catch(() => undefined);
+            }
+            catch {
+                // teardown is best-effort across jobs; continue reaping the rest
+            }
+        }
         if (removed)
             this.notify();
     }
@@ -106,12 +199,21 @@ class BackgroundJobRegistry {
     };
     /** Test helper: drop all tracked jobs. */
     reset() {
+        const aborts = [...this.jobs.values()].flatMap((entry) => isActiveStatus(entry.status) && entry.abort ? [entry.abort] : []);
         this.jobs.clear();
+        for (const abort of aborts) {
+            try {
+                void Promise.resolve(abort()).catch(() => undefined);
+            }
+            catch {
+                // ignore
+            }
+        }
     }
     /** Backstop: keep at most MAX_TERMINAL_JOBS_PER_SESSION terminal jobs per
      *  session, evicting the oldest (insertion order). Running jobs never evicted. */
     evictTerminalOverCap(sessionId) {
-        const terminal = [...this.jobs.values()].filter((e) => e.sessionId === sessionId && e.status !== "running");
+        const terminal = [...this.jobs.values()].filter((e) => e.sessionId === sessionId && !isActiveStatus(e.status));
         const over = terminal.length - MAX_TERMINAL_JOBS_PER_SESSION;
         if (over <= 0)
             return;

package/dist/tool-system/builtin/background-work.d.ts

@@ -1,5 +1,5 @@
 import { type AsyncAgentStatus } from "./agent-registry.js";
-import { type BackgroundJobStatus } from "./background-jobs.js";
+import { type BackgroundJobKind, type BackgroundJobStatus, type ExternalCliKind } from "./background-jobs.js";
 import { type BgShell } from "../../runtime/background-shell.js";
 export type BackgroundWorkKind = "subagent" | "job" | "shell";
 export interface BackgroundWorkItem {
@@ -51,6 +51,11 @@ export type BackgroundWorkEntry = WithSource<{
     finalText?: string;
     /** Files an external agent (DriveAgent) changed, parsed from its transcript. */
     changedFiles?: string[];
+    /** Machine-readable job kind and external-session linkage for DriveAgent. */
+    jobKind?: BackgroundJobKind;
+    externalSessionId?: string;
+    cli?: ExternalCliKind;
+    cwd?: string;
 }>;
 /**
  * Every background-work item spawned by `sessionId`, with per-kind detail, for

package/dist/tool-system/builtin/background-work.js

@@ -14,7 +14,7 @@
 import { readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { asyncAgentRegistry } from "./agent-registry.js";
-import { backgroundJobRegistry } from "./background-jobs.js";
+import { backgroundJobRegistry, } from "./background-jobs.js";
 import { backgroundShellManager } from "../../runtime/background-shell.js";
 import { codeShellHome } from "../../session/session-manager.js";
 /** List every still-running background work item spawned by `sessionId`. */
@@ -125,6 +125,10 @@ export function listBackgroundWorkForUI(sessionId, opts = {}) {
             ...(j.finishedAt != null ? { finishedAt: j.finishedAt } : {}),
             ...(j.finalText != null ? { finalText: j.finalText } : {}),
             ...(j.changedFiles && j.changedFiles.length ? { changedFiles: j.changedFiles } : {}),
+            ...(j.kind ? { jobKind: j.kind } : {}),
+            ...(j.ccSessionId ? { externalSessionId: j.ccSessionId } : {}),
+            ...(j.cli === "claude" || j.cli === "codex" ? { cli: j.cli } : {}),
+            ...(j.cwd ? { cwd: j.cwd } : {}),
             sourceSession: sourceSession(sessionId, j.sessionId),
         });
     }

package/dist/tool-system/builtin/bash.d.ts

@@ -16,9 +16,7 @@
  *     Killed by signal, the truncation message, sandbox denial hints).
  */
 import type { ToolContext } from "../context.js";
-import type { ToolDefinition, ToolResult } from "../../types.js";
+import type { ToolDefinition } from "../../types.js";
+import type { ToolExecutionResult } from "./index.js";
 export declare const bashToolDef: ToolDefinition;
-export declare function bashTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string | {
-    result: string;
-    sandbox: ToolResult["sandbox"];
-}>;
+export declare function bashTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string | ToolExecutionResult>;

package/dist/tool-system/builtin/bash.js

@@ -82,7 +82,8 @@ export async function bashTool(args, ctx) {
     const sandbox = sandboxMark(backend);
     // Tag every textual return below with the sandbox mark so the UI badge
     // shows up whether the command succeeded, failed, timed out, or aborted.
-    const mark = (result) => ({ result, sandbox });
+    const mark = (result) => ({ ok: true, result, sandbox });
+    const fail = (error, details = {}) => ({ ok: false, error, sandbox, ...details });
     // Project localEnvironment.env (ctx.shellEnv) layers on top of either the
     // full passthrough (off) or the hardened allowlist (sandboxed) — see
     // mergeShellEnv. Background mode merges the same way inside the manager.
@@ -93,7 +94,8 @@ export async function bashTool(args, ctx) {
     // blocked, and Engine.run's wait-for-background loop never waits on it
     // (§难点5: that loop only looks at asyncAgentRegistry).
     if (args.run_in_background === true) {
-        return mark(runInBackground(command, ctx));
+        const backgroundResult = runInBackground(command, ctx);
+        return backgroundResult.startsWith("Error:") ? fail(backgroundResult) : mark(backgroundResult);
     }
     // A6: lifecycle (spawn, kill cascade, IO drain, byte cap, abort/timeout)
     // is centralized in safeSpawnShell. We still handle Bash's user-facing
@@ -112,13 +114,13 @@ export async function bashTool(args, ctx) {
         signal: ctx?.signal,
     });
     if (result.aborted) {
-        return mark(wasAbortedBeforeStart ? "Bash aborted before starting." : "Bash aborted by signal.");
+        return fail(wasAbortedBeforeStart ? "Bash aborted before starting." : "Bash aborted by signal.");
     }
     if (result.timedOut) {
-        return mark(`Command timed out after ${timeout}ms`);
+        return fail(`Command timed out after ${timeout}ms`);
     }
     if (result.spawnFailed) {
-        return mark(`Failed to spawn command: ${result.error ?? "unknown error"}`);
+        return fail(`Failed to spawn command: ${result.error ?? "unknown error"}`);
     }
     let body = "";
     if (result.stdout)
@@ -150,6 +152,9 @@ export async function bashTool(args, ctx) {
     const hint = backend.hintForBlockedOutput?.(result.stderr);
     if (hint)
         output += hint;
+    if ((code !== 0 && code !== null) || (code === null && sig)) {
+        return fail(output, { exitCode: code, signal: sig, stderr: result.stderr });
+    }
     return mark(output);
 }
 /**

package/dist/tool-system/builtin/browser-tools.d.ts

@@ -22,9 +22,9 @@
  */
 import type { ToolDefinition } from "../../types.js";
 import type { ToolContext } from "../context.js";
-import type { BuiltinToolResult } from "./index.js";
+import type { BuiltinToolReturn } from "./index.js";
 export declare const browserObserveToolDef: ToolDefinition;
-export declare function browserObserveTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<BuiltinToolResult>;
+export declare function browserObserveTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<BuiltinToolReturn>;
 export declare const browserActToolDef: ToolDefinition;
 export declare function browserActTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
 export declare const browserNavigateToolDef: ToolDefinition;