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

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;
@@ -42,16 +45,29 @@ 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?: 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;
@@ -61,7 +77,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,29 @@ 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 {
+        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();
@@ -37,10 +60,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 +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)
@@ -61,22 +93,65 @@ 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) => 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 +164,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 +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/cron-list.definition.d.ts

@@ -0,0 +1,3 @@
+/** CronList tool metadata, shared by registration and presets. */
+import type { ToolDefinition } from "../../types.js";
+export declare const cronListToolDef: ToolDefinition;

package/dist/tool-system/builtin/cron-list.definition.js

@@ -0,0 +1,6 @@
+/** CronList tool metadata, shared by registration and presets. */
+export const cronListToolDef = {
+    name: "CronList",
+    description: "List all scheduled cron jobs.",
+    inputSchema: { type: "object", properties: {} },
+};

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

@@ -2,6 +2,7 @@
  * Cron tools — CronCreate, CronDelete, CronList.
  */
 import type { ToolDefinition } from "../../types.js";
+export { cronListToolDef } from "./cron-list.definition.js";
 /** Sink notified after a cron job is created/deleted, so the host (Electron
  *  main) can reload+arm the scheduler that actually executes jobs. The worker
  *  process only persists cron jobs (executionEnabled=false); without this the
@@ -12,6 +13,4 @@ export declare const cronCreateToolDef: ToolDefinition;
 export declare function cronCreateTool(args: Record<string, unknown>): Promise<string>;
 export declare const cronDeleteToolDef: ToolDefinition;
 export declare function cronDeleteTool(args: Record<string, unknown>): Promise<string>;
-export declare const cronListToolDef: ToolDefinition;
 export declare function cronListTool(_args: Record<string, unknown>): Promise<string>;
-export {};

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

@@ -3,6 +3,7 @@
  */
 import { cronScheduler } from "../../automation/scheduler.js";
 import { getCurrentSid } from "../../logging/logger.js";
+export { cronListToolDef } from "./cron-list.definition.js";
 let cronChangedSink = null;
 export function setCronChangedSink(sink) {
     cronChangedSink = sink;
@@ -38,7 +39,10 @@ export const cronCreateToolDef = {
     inputSchema: {
         type: "object",
         properties: {
-            name: { type: "string", description: "Short human-readable name for the job (e.g. '工作日晨间简报')" },
+            name: {
+                type: "string",
+                description: "Short human-readable name for the job (e.g. '工作日晨间简报')",
+            },
             schedule: {
                 type: "string",
                 description: "Interval ('5m','1h','1d') or a 5-field cron expression ('0 9 * * 1-5'). " +
@@ -49,7 +53,10 @@ export const cronCreateToolDef = {
                 type: "string",
                 description: "IANA timezone for cron-expression schedules (e.g. 'Asia/Shanghai'). Optional; defaults to the host system's timezone.",
             },
-            cwd: { type: "string", description: "Working directory / project the job runs in. Optional." },
+            cwd: {
+                type: "string",
+                description: "Working directory / project the job runs in. Optional.",
+            },
             permissionLevel: {
                 type: "string",
                 enum: ["read-only", "workspace-write", "full"],
@@ -146,11 +153,6 @@ export async function cronDeleteTool(args) {
         fireCronChanged();
     return deleted ? `Cron job #${id} deleted.` : `Cron job #${id} not found.`;
 }
-export const cronListToolDef = {
-    name: "CronList",
-    description: "List all scheduled cron jobs.",
-    inputSchema: { type: "object", properties: {} },
-};
 export async function cronListTool(_args) {
     const jobs = cronScheduler.list();
     if (jobs.length === 0)

package/dist/tool-system/builtin/drive-claude-code.d.ts

@@ -1,5 +1,6 @@
 import type { ToolDefinition } from "../../types.js";
 import type { AgentRunResult } from "../../cc-orchestrator/external-agent-driver.js";
+import { readExternalChangedFiles } from "../../cc-orchestrator/external-agent-changes.js";
 import type { ToolContext } from "../context.js";
 import { type ExternalAgentSessionBinding, type ExternalAgentSessionRecord } from "../../cc-orchestrator/external-agent-session-store.js";
 export type DriveCli = "claude" | "codex";
@@ -11,6 +12,7 @@ type Runner = (opts: {
     cli: DriveCli;
     prompt: string;
     resumeSessionId?: string;
+    model?: string;
     cwd: string;
     permissionMode?: PermMode;
     signal?: AbortSignal;
@@ -23,11 +25,15 @@ type SessionStore = {
 export interface DriveAgentToolOptions {
     foregroundHandoffMs?: number;
     sessionStore?: SessionStore;
+    /** Test seam for external transcript attribution. */
+    readChangedFiles?: typeof readExternalChangedFiles;
 }
 /** Factory so tests can inject a fake runner. `fixedCli` (back-compat) forces a
  *  cli and hides the `cli` arg — that's how DriveClaudeCode stays a thin alias. */
 export declare function makeDriveAgentTool(runner?: Runner, fixedCli?: DriveCli, options?: DriveAgentToolOptions): (args: Record<string, unknown>, ctx?: ToolContext) => Promise<string>;
 export declare const driveAgentTool: (args: Record<string, unknown>, ctx?: ToolContext) => Promise<string>;
+export declare const driveAgentJobsToolDef: ToolDefinition;
+export declare function driveAgentJobsTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
 export declare const driveClaudeCodeToolDef: ToolDefinition;
 /** Back-compat factory: a DriveAgent pinned to cli:"claude" with the `cli` arg
  *  hidden. The injected `runner` here keeps the old shape (no `cli` field); we
@@ -35,6 +41,7 @@ export declare const driveClaudeCodeToolDef: ToolDefinition;
 type LegacyRunner = (opts: {
     prompt: string;
     resumeSessionId?: string;
+    model?: string;
     cwd: string;
     permissionMode?: PermMode;
     signal?: AbortSignal;