@cjhyy/code-shell-core 0.6.0-rc.15 → 0.6.0-rc.16

package/dist/context/manager.d.ts

@@ -5,7 +5,7 @@
  * Tier 2: LLM summary (async) — generate summary of older messages via model call
  * Tier 3: window compact (sync, emergency) — aggressive truncation fallback
  */
-import type { Message, ContextUsageAnchor } from "../types.js";
+import type { Message, ContextUsageAnchor, PromptTokenConfidence, PromptTokenSource } from "../types.js";
 export interface ContextManagerConfig {
     maxTokens: number;
     compactAtRatio: number;
@@ -81,6 +81,7 @@ export declare class ContextManager {
      * Best-effort token estimate: uses actual API usage as base if available,
      * plus estimation for messages added since the last API call.
      */
+    private estimateTokensHybridInfo;
     private estimateTokensHybrid;
     /**
      * Set the summarize function (injected by Engine).
@@ -150,5 +151,7 @@ export declare class ContextManager {
         ratio: number;
         needsCompact: boolean;
         needsEmergency: boolean;
+        promptTokensSource: PromptTokenSource;
+        promptTokensConfidence: PromptTokenConfidence;
     };
 }

package/dist/context/manager.js

@@ -130,20 +130,31 @@ export class ContextManager {
      * Best-effort token estimate: uses actual API usage as base if available,
      * plus estimation for messages added since the last API call.
      */
-    estimateTokensHybrid(messages) {
+    estimateTokensHybridInfo(messages) {
         const currentEstimate = estimateTokens(messages);
         if (this.lastActualTokens !== undefined &&
             this.lastActualAtMessageCount !== undefined) {
             if (this.lastActualAtMessageCount < messages.length) {
                 const newMessages = messages.slice(this.lastActualAtMessageCount);
                 const newTokens = estimateTokens(newMessages);
-                return this.lastActualTokens + newTokens;
+                return {
+                    tokens: this.lastActualTokens + newTokens,
+                    source: "anchor_delta",
+                    confidence: "medium",
+                };
             }
             if (this.lastActualAnchorEstimate !== undefined && this.lastActualAnchorEstimate > 0) {
-                return Math.round(this.lastActualTokens * (currentEstimate / this.lastActualAnchorEstimate));
+                return {
+                    tokens: Math.round(this.lastActualTokens * (currentEstimate / this.lastActualAnchorEstimate)),
+                    source: "anchor_rescale",
+                    confidence: "medium",
+                };
             }
         }
-        return currentEstimate;
+        return { tokens: currentEstimate, source: "heuristic_estimate", confidence: "low" };
+    }
+    estimateTokensHybrid(messages) {
+        return this.estimateTokensHybridInfo(messages).tokens;
     }
     /**
      * Set the summarize function (injected by Engine).
@@ -577,13 +588,16 @@ export class ContextManager {
      * Check if context is approaching limits.
      */
     checkLimits(messages) {
-        const tokens = this.estimateTokensHybrid(messages);
+        const estimate = this.estimateTokensHybridInfo(messages);
+        const tokens = estimate.tokens;
         const ratio = tokens / this.config.maxTokens;
         return {
             tokens,
             ratio,
             needsCompact: ratio >= this.config.compactAtRatio,
             needsEmergency: ratio >= this.config.summarizeAtRatio,
+            promptTokensSource: estimate.source,
+            promptTokensConfidence: estimate.confidence,
         };
     }
 }

package/dist/engine/engine.js

@@ -1332,27 +1332,34 @@ export class Engine {
                     persistedContextAnchor.model === this.config.llm.model) &&
                 (persistedContextAnchor.messageCount <= messages.length ||
                     persistedContextAnchor.estimateAtAnchor !== undefined);
-            const seededContextAnchor = contextAnchorCompatible
-                ? contextManager.seedActualUsage(persistedContextAnchor)
-                : undefined;
-            // Rough token estimate of the full prompt so the UI's ctx bar isn't 0%
-            // before the first real usage_update arrives. The authoritative count
+            if (contextAnchorCompatible) {
+                contextManager.seedActualUsage(persistedContextAnchor);
+            }
+            // Best-effort token estimate of the full prompt so the UI's ctx bar isn't
+            // 0% before the first real usage_update arrives. The authoritative count
             // comes from `usage.promptTokens` after the first LLM response — this is
-            // just a display-friendly approximation for the first frame.
+            // just a display-friendly approximation for the first frame, annotated
+            // with source/confidence so consumers don't treat heuristics as truth.
             //
             // Only seed once per (process, sid). On subsequent turns the UI already
-            // shows the previous turn's accurate ctx; overwriting it with this rough
-            // char/4 estimate would make the bar visibly drop on every submit.
+            // shows the previous turn's accurate ctx; overwriting it with a fresh
+            // best-effort estimate would make the bar visibly drop on every submit.
             const sid = session.state.sessionId;
             const needsCtxSeed = !this.ctxSeedSent.has(sid);
-            const roughPromptTokens = needsCtxSeed
-                ? seededContextAnchor
-                    ? contextManager.checkLimits(messages).tokens
-                    : messages.reduce((sum, m) => {
-                        const text = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
-                        return sum + Math.ceil(text.length / 4);
-                    }, 0)
-                : 0;
+            const ctxSeed = needsCtxSeed
+                ? (() => {
+                    const checked = contextManager.checkLimits(messages);
+                    return {
+                        tokens: checked.tokens,
+                        source: checked.promptTokensSource,
+                        confidence: checked.promptTokensConfidence,
+                    };
+                })()
+                : {
+                    tokens: 0,
+                    source: "heuristic_estimate",
+                    confidence: "low",
+                };
             if (needsCtxSeed)
                 this.ctxSeedSent.add(sid);
             // Tell the client the sid *now* instead of waiting for run() to resolve.
@@ -1361,7 +1368,9 @@ export class Engine {
             options?.onStream?.({
                 type: "session_started",
                 sessionId: sid,
-                promptTokens: roughPromptTokens,
+                promptTokens: ctxSeed.tokens,
+                promptTokensSource: ctxSeed.source,
+                promptTokensConfidence: ctxSeed.confidence,
             });
             // Replay the last TodoWrite snapshot on resume so the UI's pinned
             // task panel re-hydrates without the LLM needing to call TodoWrite
@@ -1847,6 +1856,8 @@ export class Engine {
                     options?.onStream?.({
                         type: "usage_update",
                         promptTokens: cumulative.cumulativePromptTokens,
+                        promptTokensSource: "session_cumulative",
+                        promptTokensConfidence: "high",
                         cumulativePromptTokens: cumulative.cumulativePromptTokens,
                         cumulativeCacheReadTokens: cumulative.cumulativeCacheReadTokens,
                         cumulativeCacheCreationTokens: cumulative.cumulativeCacheCreationTokens,

package/dist/engine/turn-loop.js

@@ -281,7 +281,12 @@ export class TurnLoop {
         if (ctx === this.lastCtxEmit)
             return;
         this.lastCtxEmit = ctx;
-        this.config.onStream({ type: "usage_update", promptTokens: ctx });
+        this.config.onStream({
+            type: "usage_update",
+            promptTokens: ctx,
+            promptTokensSource: overhead > 0 ? "calibrated_estimate" : "heuristic_estimate",
+            promptTokensConfidence: overhead > 0 ? "medium" : "low",
+        });
     }
     recordResponseUsage(usage) {
         this.currentTurnUsage = addTokenUsage(this.currentTurnUsage, usage);
@@ -320,6 +325,8 @@ export class TurnLoop {
         this.config.onStream({
             type: "usage_update",
             promptTokens,
+            promptTokensSource: "provider_usage",
+            promptTokensConfidence: "high",
             ...(usage.cacheReadTokens !== undefined ? { cacheReadTokens: usage.cacheReadTokens } : {}),
             ...(usage.cacheCreationTokens !== undefined
                 ? { cacheCreationTokens: usage.cacheCreationTokens }

package/dist/protocol/server.js

@@ -734,7 +734,8 @@ export class AgentServer {
             this.transport.send(createErrorResponse(req.id, ErrorCodes.InvalidParams, "sessionId is required"));
             return;
         }
-        const items = listBackgroundWorkForUI(sessionId);
+        const scope = params.scope === "all" ? "all" : "session";
+        const items = listBackgroundWorkForUI(sessionId, { scope });
         this.transport.send(createResponse(req.id, { items }));
     }
     // ─── CloseSession ───────────────────────────────────────────────

package/dist/runtime/background-shell.d.ts

@@ -103,6 +103,7 @@ export declare class BackgroundShellManager {
     /** Raw retained output (no cleaning) — test/UI helper. */
     readOutputRaw(shellId: string): string | undefined;
     listForSession(sessionId: string): BgShell[];
+    list(): BgShell[];
     /**
      * Read a shell's output. `mode=incremental` (default) returns text since the
      * agent's last read; `mode=all` returns the full retained buffer. Output is

package/dist/runtime/background-shell.js

@@ -24,10 +24,10 @@
  */
 import { spawn } from "node:child_process";
 import { join } from "node:path";
-import { mkdirSync, writeFileSync, rmSync, existsSync, readdirSync, readFileSync, } from "node:fs";
+import { mkdirSync, writeFileSync, rmSync, existsSync, readdirSync, readFileSync } from "node:fs";
 import { StringDecoder } from "node:string_decoder";
 import { utf8SafeCutLength } from "./utf8-cut.js";
-import { resolveSpawnTarget, buildSandboxEnv, mergeShellEnv, killProcessGroup, groupAlive, defaultShellBinary } from "./spawn-common.js";
+import { resolveSpawnTarget, buildSandboxEnv, mergeShellEnv, killProcessGroup, groupAlive, defaultShellBinary, } from "./spawn-common.js";
 import { RingFile } from "./ring-file.js";
 import { cleanOutput } from "./output-clean.js";
 import { notificationQueue } from "../tool-system/builtin/agent-notifications.js";
@@ -46,7 +46,7 @@ function nextShellId() {
     // Short, collision-resistant enough within a process: counter + base36 of
     // a monotonic-ish value. Avoids Date.now()/Math.random() (banned in some
     // contexts and unnecessary here).
-    return `bg_${shellCounter.toString(36)}${(shellCounter * 2654435761 % 0xffffff).toString(36)}`;
+    return `bg_${shellCounter.toString(36)}${((shellCounter * 2654435761) % 0xffffff).toString(36)}`;
 }
 function bgShellsRoot() {
     return join(codeShellHome(), "bg-shells");
@@ -77,7 +77,11 @@ export class BackgroundShellManager {
         // the bg-shells root — refuse rather than trust the caller. Mirrors
         // SessionManager.assertSafeSessionId without importing across the layer.
         const sid = opts.sessionId;
-        if (typeof sid !== "string" || sid.length === 0 || sid.includes("..") || sid.includes("/") || sid.includes("\\")) {
+        if (typeof sid !== "string" ||
+            sid.length === 0 ||
+            sid.includes("..") ||
+            sid.includes("/") ||
+            sid.includes("\\")) {
             return { ok: false, error: `invalid sessionId for background shell` };
         }
         // Per-session soft cap (fork-bomb guard, §7).
@@ -219,9 +223,7 @@ export class BackgroundShellManager {
     }
     enqueueExitNotification(sh) {
         const ok = sh.exitCode === 0;
-        const exitDesc = sh.signal
-            ? `signal ${sh.signal}`
-            : `exit ${sh.exitCode ?? "?"}`;
+        const exitDesc = sh.signal ? `signal ${sh.signal}` : `exit ${sh.exitCode ?? "?"}`;
         notificationQueue.enqueue({
             agentId: sh.shellId,
             // English description is the agent-facing wakeup text. The UI ignores
@@ -233,7 +235,9 @@ export class BackgroundShellManager {
             status: ok ? "completed" : "failed",
             workKind: "shell",
             command: sh.command,
-            error: ok ? undefined : `Background shell ${sh.shellId} exited with ${exitDesc}. Use BashOutput("${sh.shellId}") to inspect.`,
+            error: ok
+                ? undefined
+                : `Background shell ${sh.shellId} exited with ${exitDesc}. Use BashOutput("${sh.shellId}") to inspect.`,
             enqueuedAt: Date.now(),
         }, sh.sessionId);
     }
@@ -266,6 +270,9 @@ export class BackgroundShellManager {
             .filter((s) => s.sessionId === sessionId)
             .map((s) => this.toPublic(s));
     }
+    list() {
+        return [...this.shells.values()].map((s) => this.toPublic(s));
+    }
     /**
      * Read a shell's output. `mode=incremental` (default) returns text since the
      * agent's last read; `mode=all` returns the full retained buffer. Output is
@@ -419,7 +426,9 @@ export class BackgroundShellManager {
                     try {
                         rmSync(path, { force: true });
                     }
-                    catch { /* ignore */ }
+                    catch {
+                        /* ignore */
+                    }
                     continue;
                 }
                 // Skip ones we already track in-process (this worker's own).
@@ -433,7 +442,9 @@ export class BackgroundShellManager {
                     try {
                         rmSync(path, { force: true });
                     }
-                    catch { /* ignore */ }
+                    catch {
+                        /* ignore */
+                    }
                 }
             }
         }

package/dist/session/memory.d.ts

@@ -12,7 +12,11 @@
  *              auto-extracted entries (extract-memories output). LLM may
  *              only modify these through permission-gated tool calls.
  *   - dream/   The dream pipeline's workspace. The LLM is free to add /
- *              merge / delete entries here; user/ is read-only to dream.
+ *              merge / delete entries here. The dream loop may ALSO maintain
+ *              user/ entries whose origin is `auto` or `dream` (dedup/merge/
+ *              improve), but origin:`manual` user entries — things the user
+ *              explicitly asked to remember — are never touched by dream.
+ *              See dream-consolidation.ts (the origin guard at ~:240).
  *
  * MEMORY.md is the index file (one per scope).
  *

package/dist/session/memory.js

@@ -12,7 +12,11 @@
  *              auto-extracted entries (extract-memories output). LLM may
  *              only modify these through permission-gated tool calls.
  *   - dream/   The dream pipeline's workspace. The LLM is free to add /
- *              merge / delete entries here; user/ is read-only to dream.
+ *              merge / delete entries here. The dream loop may ALSO maintain
+ *              user/ entries whose origin is `auto` or `dream` (dedup/merge/
+ *              improve), but origin:`manual` user entries — things the user
+ *              explicitly asked to remember — are never touched by dream.
+ *              See dream-consolidation.ts (the origin guard at ~:240).
  *
  * MEMORY.md is the index file (one per scope).
  *

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/background-jobs.d.ts

@@ -69,6 +69,8 @@ declare class BackgroundJobRegistry {
     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

@@ -82,6 +82,10 @@ class BackgroundJobRegistry {
     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;

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/types.d.ts

@@ -319,10 +319,14 @@ export interface TaskInfo {
     activeForm?: string;
     status: "pending" | "in_progress" | "completed" | "stopped";
 }
+export type PromptTokenSource = "provider_usage" | "anchor_delta" | "anchor_rescale" | "calibrated_estimate" | "heuristic_estimate" | "session_cumulative";
+export type PromptTokenConfidence = "high" | "medium" | "low";
 export type StreamEvent = {
     type: "session_started";
     sessionId: string;
     promptTokens: number;
+    promptTokensSource?: PromptTokenSource;
+    promptTokensConfidence?: PromptTokenConfidence;
 } | {
     type: "session_title";
     sessionId: string;
@@ -436,6 +440,8 @@ export type StreamEvent = {
 } | {
     type: "usage_update";
     promptTokens: number;
+    promptTokensSource?: PromptTokenSource;
+    promptTokensConfidence?: PromptTokenConfidence;
     /**
      * Provider-reported prompt-cache counts, forwarded so the UI can show a
      * cache hit rate in the context-ring tooltip. Present only when the LLM

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-core",
-  "version": "0.6.0-rc.15",
+  "version": "0.6.0-rc.16",
   "description": "Core engine for code-shell — agent orchestration, tool execution, hooks, protocol. UI-agnostic.",
   "type": "module",
   "main": "./dist/index.js",