@cjhyy/code-shell-core 0.6.0-rc.9 → 0.7.0

package/dist/skills/scanner.d.ts

@@ -1,6 +1,7 @@
 /**
- * Skill scanner — discovers <base>/<name>/SKILL.md files from project + user
- * directories AND from installed plugins. Mirrors Claude Code's
+ * Skill scanner — discovers <base>/<name>/SKILL.md files from project
+ * `.code-shell/skills`, project `.agents/skills`, user `.code-shell/skills`,
+ * and installed plugins. Mirrors Claude Code's
  * `loadSkillsFromSkillsDir` (skills/loadSkillsDir.ts:407) plus plugin
  * integration (utils/plugins/pluginLoader.ts).
  */

package/dist/skills/scanner.js

@@ -1,6 +1,7 @@
 /**
- * Skill scanner — discovers <base>/<name>/SKILL.md files from project + user
- * directories AND from installed plugins. Mirrors Claude Code's
+ * Skill scanner — discovers <base>/<name>/SKILL.md files from project
+ * `.code-shell/skills`, project `.agents/skills`, user `.code-shell/skills`,
+ * and installed plugins. Mirrors Claude Code's
  * `loadSkillsFromSkillsDir` (skills/loadSkillsDir.ts:407) plus plugin
  * integration (utils/plugins/pluginLoader.ts).
  */
@@ -20,6 +21,7 @@ function userHome() {
 function bases(cwd) {
     return [
         { dir: join(cwd, ".code-shell", "skills"), source: "project" },
+        { dir: join(cwd, ".agents", "skills"), source: "project" },
         { dir: join(userHome(), ".code-shell", "skills"), source: "user" },
     ];
 }
@@ -158,13 +160,14 @@ function installedPluginsMtime() {
     }
 }
 /**
- * mtime of each local skills base dir (project + user). A directory's mtime
- * changes when a child entry is added/removed, so installing a new skill into
- * `<cwd>/.code-shell/skills` or `~/.code-shell/skills` busts the cache on the
- * next scan — the just-installed skill becomes visible to the running session
- * without a restart. (Editing an existing skill's *contents* does not bump the
- * dir mtime; install paths additionally call invalidateSkillCache() to cover
- * that, so this is the passive half of a two-part guard.)
+ * mtime of each local skills base dir (project .code-shell/.agents + user). A
+ * directory's mtime changes when a child entry is added/removed, so installing
+ * a new skill into `<cwd>/.code-shell/skills`, `<cwd>/.agents/skills`, or
+ * `~/.code-shell/skills` busts the cache on the next scan — the just-installed
+ * skill becomes visible to the running session without a restart. (Editing an
+ * existing skill's *contents* does not bump the dir mtime; install paths
+ * additionally call invalidateSkillCache() to cover that, so this is the
+ * passive half of a two-part guard.)
  */
 function skillsDirsMtime(cwd) {
     return bases(cwd)

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/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,14 @@
  * 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";
 /** 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;
@@ -40,28 +43,54 @@ export interface BackgroundJobEntry {
     ccSessionId?: string;
     /** Files the external agent changed (parsed from its transcript, #6). */
     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?: string;
+    /** Client message that launched this external job. */
+    originClientMessageId?: string;
+    /** Optional cancellation hook for jobs backed by a live process. */
+    abort?: () => void | Promise<void>;
 }
 /** 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?: string;
+    originClientMessageId?: string;
+    abort?: () => void | Promise<void>;
+}
 declare class BackgroundJobRegistry {
     private jobs;
     private listeners;
     /** Register a running job. Invalid sessionId is ignored (cannot be waited on). */
-    start(jobId: string, sessionId: string, description?: string): void;
+    start(jobId: string, sessionId: string, description?: string, options?: BackgroundJobStartOptions): void;
     /** 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[];
+    /** Running jobs, across all sessions, that are operating in the same cwd. */
+    listRunningByCwd(cwd: string): BackgroundJobEntry[];
     /** All jobs (running + retained terminal) for `sessionId`. Feeds the panel. */
     listForSession(sessionId: string): BackgroundJobEntry[];
+    /** All jobs (running + retained terminal) across sessions. Feeds all-scope UI. */
+    list(): BackgroundJobEntry[];
     /** Drop every job of a session — called when the session is deleted/closed. */
     dropForSession(sessionId: string): void;
     subscribe: (cb: Listener) => (() => void);

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
@@ -20,25 +20,57 @@
  * loops run in the main engine process, so start/finish and the engine's wait
  * loop observe the same instance.
  */
+import { normalizeCwdPath } from "../../cc-orchestrator/cwd-normalize.js";
 function isValidSessionId(sid) {
     return typeof sid === "string" && sid.length > 0;
 }
 /** 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 {
+        await Promise.race([
+            Promise.resolve().then(abort),
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, CANCEL_WAIT_TIMEOUT_MS);
+            }),
+        ]);
+    }
+    catch {
+        // Cancellation is best-effort; the terminal state still closes after the
+        // abort hook settles or the hard deadline expires.
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 class BackgroundJobRegistry {
     jobs = new Map(); // jobId -> entry (insertion-ordered)
     listeners = new Set();
     /** Register a running job. Invalid sessionId is ignored (cannot be waited on). */
-    start(jobId, sessionId, description = "") {
+    start(jobId, sessionId, description = "", options) {
         if (!isValidSessionId(sessionId))
             return;
         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();
     }
@@ -48,6 +80,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)
@@ -59,31 +93,97 @@ 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();
+        if (entry.abort)
+            await waitForAbort(entry.abort);
+        // 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 = "cancelled";
+        entry.finishedAt = Date.now();
+        if (outcome?.finalText !== undefined)
+            entry.finalText = outcome.finalText;
+        if (outcome?.ccSessionId !== undefined)
+            entry.ccSessionId = outcome.ccSessionId;
+        if (outcome?.changedFiles !== undefined)
+            entry.changedFiles = outcome.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) => isActiveStatus(e.status) && e.cwd === normalized);
     }
     /** All jobs (running + retained terminal) for `sessionId`. Feeds the panel. */
     listForSession(sessionId) {
         return [...this.jobs.values()].filter((e) => e.sessionId === sessionId);
     }
+    /** All jobs (running + retained terminal) across sessions. Feeds all-scope UI. */
+    list() {
+        return [...this.jobs.values()];
+    }
     /** 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();
     }
@@ -95,12 +195,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,16 +1,3 @@
-/**
- * Unified view over the THREE kinds of async background work — background
- * sub-agents (asyncAgentRegistry), background jobs / video polls
- * (backgroundJobRegistry), and background shells (backgroundShellManager).
- *
- * Used by the goal-stop-hook to show the judge LLM what's still running, so it
- * can tell "the goal is done except for a finite task that will wake me" (a
- * download / video render → allow stop, wait for the wakeup) from "a long-lived
- * service that the goal doesn't depend on" (a dev server → judge the goal
- * normally). Replacing the old mechanical `hasRunningForSession` short-circuit:
- * a boolean can't distinguish a finite download from a never-ending dev server,
- * but the judge — given each task's kind + command — can.
- */
 import { type AsyncAgentStatus } from "./agent-registry.js";
 import { type BackgroundJobStatus } from "./background-jobs.js";
 import { type BgShell } from "../../runtime/background-shell.js";
@@ -30,12 +17,21 @@ export interface BackgroundWorkItem {
 /** List every still-running background work item spawned by `sessionId`. */
 export declare function listRunningBackgroundWork(sessionId: string): BackgroundWorkItem[];
 /** One background-work row for the desktop panel, discriminated by `kind`. */
-export type BackgroundWorkEntry = {
+export interface BackgroundWorkSourceSession {
+    sessionId: string;
+    shortId: string;
+    title?: string;
+    current: boolean;
+}
+type WithSource<T> = T & {
+    sourceSession: BackgroundWorkSourceSession;
+};
+export type BackgroundWorkEntry = WithSource<{
     kind: "shell";
     /** Full shell snapshot — the panel already renders this shape (output/kill
      *  still go through the dedicated agent/backgroundShells RPC by shellId). */
     shell: BgShell;
-} | {
+}> | WithSource<{
     kind: "subagent";
     agentId: string;
     name?: string;
@@ -44,7 +40,7 @@ export type BackgroundWorkEntry = {
     status: AsyncAgentStatus;
     startedAt: number;
     finishedAt?: number;
-} | {
+}> | WithSource<{
     kind: "job";
     jobId: string;
     description: string;
@@ -55,7 +51,7 @@ export type BackgroundWorkEntry = {
     finalText?: string;
     /** Files an external agent (DriveAgent) changed, parsed from its transcript. */
     changedFiles?: string[];
-};
+}>;
 /**
  * Every background-work item spawned by `sessionId`, with per-kind detail, for
  * the desktop panel. Includes finished sub-agents that are still within their
@@ -64,4 +60,7 @@ export type BackgroundWorkEntry = {
  * keep them. Jobs are only ever present while running (the registry drops them
  * on finish).
  */
-export declare function listBackgroundWorkForUI(sessionId: string): BackgroundWorkEntry[];
+export declare function listBackgroundWorkForUI(sessionId: string, opts?: {
+    scope?: "session" | "all";
+}): BackgroundWorkEntry[];
+export {};

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

@@ -11,9 +11,12 @@
  * a boolean can't distinguish a finite download from a never-ending dev server,
  * but the judge — given each task's kind + command — can.
  */
+import { readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
 import { asyncAgentRegistry } from "./agent-registry.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`. */
 export function listRunningBackgroundWork(sessionId) {
     const items = [];
@@ -39,6 +42,38 @@ export function listRunningBackgroundWork(sessionId) {
     }
     return items;
 }
+const sessionTitleCache = new Map();
+function shortSessionId(sessionId) {
+    return sessionId.length <= 10 ? sessionId : sessionId.slice(0, 10);
+}
+function readSessionTitle(sessionId) {
+    try {
+        const statePath = join(codeShellHome(), "sessions", sessionId, "state.json");
+        const st = statSync(statePath);
+        const cached = sessionTitleCache.get(sessionId);
+        if (cached && cached.mtimeMs === st.mtimeMs)
+            return cached.title;
+        const raw = JSON.parse(readFileSync(statePath, "utf8"));
+        const title = typeof raw.title === "string" && raw.title.trim()
+            ? raw.title.trim()
+            : typeof raw.summary === "string" && raw.summary.trim()
+                ? raw.summary.trim()
+                : undefined;
+        sessionTitleCache.set(sessionId, { mtimeMs: st.mtimeMs, title });
+        return title;
+    }
+    catch {
+        return undefined;
+    }
+}
+function sourceSession(currentSessionId, ownerSessionId) {
+    return {
+        sessionId: ownerSessionId,
+        shortId: shortSessionId(ownerSessionId),
+        title: readSessionTitle(ownerSessionId),
+        current: ownerSessionId === currentSessionId,
+    };
+}
 /**
  * Every background-work item spawned by `sessionId`, with per-kind detail, for
  * the desktop panel. Includes finished sub-agents that are still within their
@@ -47,18 +82,24 @@ export function listRunningBackgroundWork(sessionId) {
  * keep them. Jobs are only ever present while running (the registry drops them
  * on finish).
  */
-export function listBackgroundWorkForUI(sessionId) {
+export function listBackgroundWorkForUI(sessionId, opts = {}) {
     const entries = [];
-    for (const s of backgroundShellManager.listForSession(sessionId)) {
-        entries.push({ kind: "shell", shell: s });
+    const scope = opts.scope ?? "session";
+    const shells = scope === "all"
+        ? backgroundShellManager.list()
+        : backgroundShellManager.listForSession(sessionId);
+    for (const s of shells) {
+        entries.push({ kind: "shell", shell: s, sourceSession: sourceSession(sessionId, s.sessionId) });
     }
     const now = Date.now();
-    for (const a of asyncAgentRegistry.listForSession(sessionId)) {
+    const agents = scope === "all" ? asyncAgentRegistry.list() : asyncAgentRegistry.listForSession(sessionId);
+    for (const a of agents) {
         // Keep running agents, plus finished ones still inside their fade window so
         // a completion is briefly visible. (finishedFadeAt = finishedAt + 30s.)
         const fresh = a.status === "running" || (a.finishedFadeAt != null && a.finishedFadeAt > now);
         if (!fresh)
             continue;
+        const ownerSessionId = a.sessionId ?? sessionId;
         entries.push({
             kind: "subagent",
             agentId: a.agentId,
@@ -68,9 +109,13 @@ export function listBackgroundWorkForUI(sessionId) {
             status: a.status,
             startedAt: a.startedAt,
             finishedAt: a.finishedAt,
+            sourceSession: sourceSession(sessionId, ownerSessionId),
         });
     }
-    for (const j of backgroundJobRegistry.listForSession(sessionId)) {
+    const jobs = scope === "all"
+        ? backgroundJobRegistry.list()
+        : backgroundJobRegistry.listForSession(sessionId);
+    for (const j of jobs) {
         entries.push({
             kind: "job",
             jobId: j.jobId,
@@ -80,6 +125,7 @@ export function listBackgroundWorkForUI(sessionId) {
             ...(j.finishedAt != null ? { finishedAt: j.finishedAt } : {}),
             ...(j.finalText != null ? { finalText: j.finalText } : {}),
             ...(j.changedFiles && j.changedFiles.length ? { changedFiles: j.changedFiles } : {}),
+            sourceSession: sourceSession(sessionId, j.sessionId),
         });
     }
     return entries;

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

@@ -2,5 +2,6 @@
  * ConfigTool — read or update project settings.
  */
 import type { ToolDefinition } from "../../types.js";
+import type { ToolContext } from "../context.js";
 export declare const configToolDef: ToolDefinition;
-export declare function configTool(args: Record<string, unknown>): Promise<string>;
+export declare function configTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;