@cjhyy/code-shell-core 0.7.1 → 0.8.1

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

@@ -11,12 +11,16 @@
  * the right boundary: long-running cross-process work belongs to
  * RunManager, not here.
  */
+import { notificationQueue } from "./agent-notifications.js";
 /** Process-wide cap on concurrent background sub-agents (aligns with Codex max_threads=6). */
 export const MAX_BACKGROUND_AGENTS = 6;
 class AsyncAgentRegistry {
     agents = new Map();
     listeners = new Set();
     snapshot = [];
+    writerLeases = new Map();
+    generationByChildSession = new Map();
+    closedDirectionIntake = new Set();
     // ── observer API (React useSyncExternalStore compatible) ──────────────
     subscribe = (cb) => {
         this.listeners.add(cb);
@@ -28,16 +32,16 @@ class AsyncAgentRegistry {
         return this.snapshot;
     };
     hasRunning = () => {
-        return this.snapshot.some((e) => e.status === "running");
+        return this.snapshot.some((e) => e.status === "running" || e.status === "cancelling");
     };
     /** True if any background agent spawned by `sessionId` is still running.
      *  Drives Engine.run's "wait for my background agents before resolving". */
     hasRunningForSession = (sessionId) => {
-        return this.snapshot.some((e) => e.status === "running" && e.sessionId === sessionId);
+        return this.snapshot.some((e) => (e.status === "running" || e.status === "cancelling") && e.sessionId === sessionId);
     };
     /** Count of agents currently in the "running" state (cap enforcement). */
     runningCount() {
-        return this.snapshot.filter((e) => e.status === "running").length;
+        return this.snapshot.filter((e) => e.status === "running" || e.status === "cancelling").length;
     }
     notify() {
         this.snapshot = [...this.agents.values()];
@@ -52,9 +56,128 @@ class AsyncAgentRegistry {
     }
     // ── mutators ──────────────────────────────────────────────────────────
     register(entry) {
+        if (entry.childSessionId && entry.runtimeGeneration === undefined) {
+            const generation = (this.generationByChildSession.get(entry.childSessionId) ?? 0) + 1;
+            entry.runtimeGeneration = generation;
+            this.generationByChildSession.set(entry.childSessionId, generation);
+        }
+        else if (entry.childSessionId && entry.runtimeGeneration !== undefined) {
+            this.generationByChildSession.set(entry.childSessionId, Math.max(this.generationByChildSession.get(entry.childSessionId) ?? 0, entry.runtimeGeneration));
+        }
+        this.closedDirectionIntake.delete(entry.agentId);
         this.agents.set(entry.agentId, entry);
         this.notify();
     }
+    allocateRuntimeGeneration(childSessionId) {
+        const generation = (this.generationByChildSession.get(childSessionId) ?? 0) + 1;
+        this.generationByChildSession.set(childSessionId, generation);
+        return generation;
+    }
+    acquireWriterLease(childSessionId, runtimeGeneration, ownerToken) {
+        if (!childSessionId || !ownerToken || !Number.isSafeInteger(runtimeGeneration))
+            return undefined;
+        if (this.writerLeases.has(childSessionId))
+            return undefined;
+        const lease = { childSessionId, runtimeGeneration, ownerToken };
+        this.writerLeases.set(childSessionId, lease);
+        return lease;
+    }
+    getWriterLease(childSessionId) {
+        return this.writerLeases.get(childSessionId);
+    }
+    releaseWriterLease(lease) {
+        const held = this.writerLeases.get(lease.childSessionId);
+        if (held?.ownerToken !== lease.ownerToken ||
+            held.runtimeGeneration !== lease.runtimeGeneration) {
+            return false;
+        }
+        this.writerLeases.delete(lease.childSessionId);
+        return true;
+    }
+    bindLiveControl(agentId, control, lease) {
+        const entry = this.agents.get(agentId);
+        const held = this.writerLeases.get(lease.childSessionId);
+        if (!entry ||
+            entry.status !== "running" ||
+            entry.childSessionId !== control.childSessionId ||
+            entry.childSessionId !== lease.childSessionId ||
+            entry.runtimeGeneration !== control.runtimeGeneration ||
+            entry.runtimeGeneration !== lease.runtimeGeneration ||
+            held?.ownerToken !== lease.ownerToken) {
+            return false;
+        }
+        entry.liveControl = control;
+        entry.writerLease = lease;
+        this.notify();
+        return true;
+    }
+    closeDirectionIntake(agentId, lease) {
+        const entry = this.agents.get(agentId);
+        const held = this.writerLeases.get(lease.childSessionId);
+        if (!entry ||
+            entry.childSessionId !== lease.childSessionId ||
+            entry.runtimeGeneration !== lease.runtimeGeneration ||
+            entry.writerLease?.ownerToken !== lease.ownerToken ||
+            held?.ownerToken !== lease.ownerToken ||
+            held.runtimeGeneration !== lease.runtimeGeneration) {
+            return false;
+        }
+        this.closedDirectionIntake.add(agentId);
+        return true;
+    }
+    updateProgress(agentId, progress) {
+        const entry = this.agents.get(agentId);
+        if (!entry || entry.status !== "running")
+            return false;
+        entry.progress = progress;
+        this.notify();
+        return true;
+    }
+    routeDirection(request) {
+        const rejected = (reason, target) => ({
+            status: "rejected",
+            reason,
+            ...(target ? { target } : {}),
+            rejectedAt: Date.now(),
+        });
+        if (!request.prompt.trim())
+            return rejected("invalid-request");
+        // Authenticate the caller before resolving the target. Besides enforcing
+        // the flat child hierarchy, this prevents a sub-agent from probing agent
+        // ids and distinguishing an existing child from an unknown one.
+        if (request.callerIsSubAgent)
+            return rejected("not-direct-parent");
+        const entry = this.agents.get(request.agentId);
+        if (!entry)
+            return rejected("target-not-found");
+        const target = entry.childSessionId
+            ? { sessionId: entry.childSessionId, agentId: entry.agentId, authority: "agent" }
+            : undefined;
+        if (entry.sessionId !== request.callerSessionId) {
+            return rejected("not-direct-parent", target);
+        }
+        if (entry.status !== "running")
+            return rejected("target-not-running", target);
+        if (this.closedDirectionIntake.has(entry.agentId))
+            return rejected("intake-closed", target);
+        if (!entry.liveControl || !entry.writerLease || !target)
+            return rejected("target-not-ready", target);
+        const held = this.writerLeases.get(entry.writerLease.childSessionId);
+        if (entry.liveControl.runtimeGeneration !== entry.runtimeGeneration ||
+            entry.writerLease.runtimeGeneration !== entry.runtimeGeneration ||
+            held?.runtimeGeneration !== entry.runtimeGeneration ||
+            held.ownerToken !== entry.writerLease.ownerToken) {
+            return rejected("runtime-generation-mismatch", target);
+        }
+        return entry.liveControl.routeDirection({
+            kind: "direction",
+            from: { sessionId: request.callerSessionId, authority: "agent" },
+            to: target,
+            delivery: request.delivery,
+            runtimeGeneration: entry.runtimeGeneration,
+            payload: { prompt: request.prompt, origin: "agent_send_input" },
+        });
+    }
     appendToTranscript(agentId, entry) {
         const e = this.agents.get(agentId);
         if (!e)
@@ -89,15 +212,49 @@ class AsyncAgentRegistry {
     listForSession(sessionId) {
         return [...this.agents.values()].filter((e) => e.sessionId === sessionId);
     }
+    completeTerminal(agentId, status, lease) {
+        const e = this.agents.get(agentId);
+        const held = this.writerLeases.get(lease.childSessionId);
+        if (!e ||
+            (e.status !== "running" && e.status !== "cancelling") ||
+            e.childSessionId !== lease.childSessionId ||
+            e.runtimeGeneration !== lease.runtimeGeneration ||
+            e.writerLease?.ownerToken !== lease.ownerToken ||
+            held?.ownerToken !== lease.ownerToken ||
+            held.runtimeGeneration !== lease.runtimeGeneration) {
+            return false;
+        }
+        e.status = status;
+        e.finishedAt = Date.now();
+        e.finishedFadeAt = e.finishedAt + 30_000;
+        this.closedDirectionIntake.add(agentId);
+        this.writerLeases.delete(lease.childSessionId);
+        if (e.sessionId)
+            notificationQueue.clearProgress(e.sessionId, agentId, lease.runtimeGeneration);
+        notificationQueue.clearDirections(lease.childSessionId, lease.runtimeGeneration);
+        e.liveControl = undefined;
+        e.writerLease = undefined;
+        e.progress = undefined;
+        this.notify();
+        return true;
+    }
     markFinished(agentId, status) {
         const e = this.agents.get(agentId);
-        if (!e)
+        if (!e || (e.status !== "running" && e.status !== "cancelling"))
             return;
-        if (e.status !== "running")
+        // Live runtimes require the full generation/owner fence. Their supervisor
+        // must call completeTerminal after Engine.run has completely settled.
+        if (e.writerLease)
             return;
         e.status = status;
         e.finishedAt = Date.now();
         e.finishedFadeAt = e.finishedAt + 30_000;
+        this.closedDirectionIntake.add(agentId);
+        if (e.sessionId && e.runtimeGeneration !== undefined) {
+            notificationQueue.clearProgress(e.sessionId, agentId, e.runtimeGeneration);
+        }
+        e.liveControl = undefined;
+        e.progress = undefined;
         this.notify();
     }
     markCompleted(agentId) {
@@ -115,20 +272,29 @@ class AsyncAgentRegistry {
             return false;
         if (e.status !== "running")
             return false;
+        e.status = "cancelling";
+        this.closedDirectionIntake.add(agentId);
+        if (e.sessionId && e.runtimeGeneration !== undefined) {
+            notificationQueue.clearProgress(e.sessionId, agentId, e.runtimeGeneration);
+        }
+        e.progress = undefined;
+        this.notify();
         try {
             e.abort();
         }
         catch {
             // ignore abort errors — we still mark cancelled
         }
-        // Reuse markFinished for the status/timestamp/notify bookkeeping rather
-        // than duplicating it (the entry is still "running" after abort()).
-        this.markFinished(agentId, "cancelled");
+        // Legacy/ad-hoc entries have no live writer lease to fence. There is no
+        // supervisor terminal callback coming for them, so preserve their historic
+        // immediate terminal bookkeeping after the abort request.
+        if (!e.writerLease)
+            this.markFinished(agentId, "cancelled");
         return true;
     }
     reset() {
         for (const e of this.agents.values()) {
-            if (e.status === "running") {
+            if (e.status === "running" || e.status === "cancelling") {
                 try {
                     e.abort();
                 }
@@ -138,6 +304,9 @@ class AsyncAgentRegistry {
             }
         }
         this.agents.clear();
+        this.writerLeases.clear();
+        this.generationByChildSession.clear();
+        this.closedDirectionIntake.clear();
         this.notify();
     }
 }

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

@@ -1,4 +1,4 @@
-import { asyncAgentRegistry, } from "./agent-registry.js";
+import { asyncAgentRegistry } from "./agent-registry.js";
 let entryIdCounter = 0;
 function nextId(agentId) {
     return `bg-${agentId}-${++entryIdCounter}`;

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

@@ -17,6 +17,8 @@ export interface AgentTypeOverrides {
     maxTurns?: number;
     toolAllowlist?: string[];
     skillAllowlist?: string[];
+    sandboxMode?: AgentDefinition["sandbox"];
+    mcpAllowlist?: string[];
     appendSystemPrompt?: string;
 }
 /**