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

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

@@ -40,6 +40,8 @@ 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;
 }
 /** Outcome passed to finish() to record how a job ended. */
 export interface BackgroundJobOutcome {
@@ -48,11 +50,14 @@ export interface BackgroundJobOutcome {
     ccSessionId?: string;
     changedFiles?: string[];
 }
+export interface BackgroundJobStartOptions {
+    cwd?: string;
+}
 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;
@@ -60,8 +65,12 @@ declare class BackgroundJobRegistry {
     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

@@ -20,6 +20,7 @@
  * 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;
 }
@@ -30,7 +31,7 @@ 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, {
@@ -39,6 +40,7 @@ class BackgroundJobRegistry {
             description,
             status: "running",
             startedAt: Date.now(),
+            ...(options?.cwd ? { cwd: normalizeCwdPath(options.cwd) } : {}),
         });
         this.notify();
     }
@@ -71,10 +73,19 @@ class BackgroundJobRegistry {
     listRunningForSession(sessionId) {
         return [...this.jobs.values()].filter((e) => e.sessionId === sessionId && e.status === "running");
     }
+    /** 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);
+    }
     /** 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;

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>;

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

@@ -3,6 +3,8 @@
  */
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
+import { setDottedSetting } from "../../settings/manager.js";
+import { enforcePathPolicyWithApproval } from "../path-policy.js";
 export const configToolDef = {
     name: "Config",
     description: "Read or update the project's .code-shell/settings.json configuration. " +
@@ -26,11 +28,14 @@ export const configToolDef = {
         required: ["action"],
     },
 };
-export async function configTool(args) {
+export async function configTool(args, ctx) {
     const action = args.action;
-    const cwd = args.__cwd ?? process.cwd();
+    const cwd = ctx?.cwd ?? process.cwd();
     const configPath = join(cwd, ".code-shell", "settings.json");
     if (action === "read") {
+        const blocked = await enforcePathPolicyWithApproval(configPath, "read", ctx);
+        if (blocked)
+            return blocked;
         if (!existsSync(configPath)) {
             return "No project settings found. Use /init to create one.";
         }
@@ -38,6 +43,9 @@ export async function configTool(args) {
         return content;
     }
     if (action === "write") {
+        const blocked = await enforcePathPolicyWithApproval(configPath, "write", ctx);
+        if (blocked)
+            return blocked;
         const key = args.key;
         const value = args.value;
         if (!key)
@@ -49,16 +57,13 @@ export async function configTool(args) {
         if (existsSync(configPath)) {
             settings = JSON.parse(readFileSync(configPath, "utf-8"));
         }
-        // Set nested key
-        const parts = key.split(".");
-        let obj = settings;
-        for (let i = 0; i < parts.length - 1; i++) {
-            if (typeof obj[parts[i]] !== "object" || obj[parts[i]] === null) {
-                obj[parts[i]] = {};
-            }
-            obj = obj[parts[i]];
+        try {
+            setDottedSetting(settings, key, value);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return `Error: ${message}`;
         }
-        obj[parts[parts.length - 1]] = value;
         // Never resurrect a deleted project root: a recursive mkdir of
         // <cwd>/.code-shell would recreate `cwd` itself as an empty shell when the
         // directory has been deleted (e.g. a stale session pointing at a removed

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

@@ -1,7 +1,10 @@
 import type { ToolDefinition } from "../../types.js";
 import type { AgentRunResult } from "../../cc-orchestrator/external-agent-driver.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";
+export declare const DRIVE_AGENT_FOREGROUND_HANDOFF_MS = 110000;
+export declare const DRIVE_AGENT_TOOL_TIMEOUT_MS = 1800000;
 export declare const driveAgentToolDef: ToolDefinition;
 type PermMode = "default" | "acceptEdits" | "bypassPermissions";
 type Runner = (opts: {
@@ -10,10 +13,20 @@ type Runner = (opts: {
     resumeSessionId?: string;
     cwd: string;
     permissionMode?: PermMode;
+    signal?: AbortSignal;
+    imagePaths?: string[];
 }) => Promise<AgentRunResult>;
+type SessionStore = {
+    get(cli: DriveCli, sessionId: string): ExternalAgentSessionBinding | undefined;
+    record(binding: ExternalAgentSessionRecord): void;
+};
+export interface DriveAgentToolOptions {
+    foregroundHandoffMs?: number;
+    sessionStore?: SessionStore;
+}
 /** 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): (args: Record<string, unknown>, ctx?: ToolContext) => Promise<string>;
+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 driveClaudeCodeToolDef: ToolDefinition;
 /** Back-compat factory: a DriveAgent pinned to cli:"claude" with the `cli` arg
@@ -24,7 +37,8 @@ type LegacyRunner = (opts: {
     resumeSessionId?: string;
     cwd: string;
     permissionMode?: PermMode;
+    signal?: AbortSignal;
 }) => Promise<AgentRunResult>;
-export declare function makeDriveClaudeCodeTool(runner?: LegacyRunner): (args: Record<string, unknown>, ctx?: ToolContext) => Promise<string>;
+export declare function makeDriveClaudeCodeTool(runner?: LegacyRunner, options?: DriveAgentToolOptions): (args: Record<string, unknown>, ctx?: ToolContext) => Promise<string>;
 export declare const driveClaudeCodeTool: (args: Record<string, unknown>, ctx?: ToolContext) => Promise<string>;
 export {};