@selesai/code 0.13.39 → 0.14.0

package/dist/modes/rpc/rpc-mode.js

@@ -1,3 +1,6 @@
+import { RpcSubagentBridge } from "./subagent-bridge.js";
+import { RpcReleaseBridge, validateReleaseCommand } from "./release-bridge.js";
+import { RELEASING_BLOCKER_KIND } from "../../core/release-rpc.js";
 /**
  * RPC mode: Headless operation with JSON stdin/stdout protocol.
  *
@@ -10,11 +13,13 @@
  * - Events: AgentSessionEvent objects streamed as they occur
  * - Extension UI: Extension UI requests are emitted, client responds with extension_ui_response
  */
+import { RpcIntercomBridge } from "./intercom-bridge.js";
 import * as crypto from "node:crypto";
 import { spawnSync } from "node:child_process";
 import { chmodSync, copyFileSync, existsSync, readFileSync, unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, relative } from "node:path";
+import { toJsonEvent } from "../json-event.js";
 import { generateHandoff } from "../../core/handoff.js";
 import { buildGitCommandPrompt } from "../../core/git-command.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
@@ -42,6 +47,9 @@ export async function runRpcMode(runtimeHost) {
     let session = runtimeHost.session;
     let unsubscribe;
     let unsubscribeBackpressure;
+    let intercomBridge;
+    let subagentBridge;
+    let releaseBridge;
     const output = (obj) => {
         writeRawStdout(serializeJsonLine(obj));
     };
@@ -95,6 +103,27 @@ export async function runRpcMode(runtimeHost) {
     const pendingExtensionRequests = new Map();
     // Prompts buffered while compacting (queueWhileCompacting) — flushed after compaction_end.
     const compactionPromptQueue = [];
+    // In-flight session transitions (switch/new/fork/reload/extension rebind) and prompts still inside preflight or
+    // run, tracked so release_readiness never answers "safe" in a window where session state is being swapped.
+    let sessionTransitions = 0;
+    let promptsInFlight = 0;
+    const withTransition = async (fn) => {
+        sessionTransitions++;
+        try {
+            return await fn();
+        }
+        finally {
+            sessionTransitions--;
+        }
+    };
+    const TRANSITION_COMMANDS = new Set([
+        "new_session", "handoff_new", "switch_session", "fork", "clone", "import_jsonl", "reload", "navigate_tree",
+    ]);
+    // Atomic `release` command: once committed (synchronously, in the same step as the readiness check) every other command is
+    // refused and the process exits gently right after the response is flushed. `releasedReadiness` is what the commit was based on.
+    let releasing = false;
+    let releaseShutdownPending = false;
+    let releasedReadiness;
     // Shutdown request flag
     let shutdownRequested = false;
     let shuttingDown = false;
@@ -302,16 +331,43 @@ export async function runRpcMode(runtimeHost) {
     runtimeHost.setRebindSession(async () => {
         await rebindSession();
     });
-    const rebindSession = async () => {
+    const bindObservationBridges = () => {
+        intercomBridge?.dispose();
+        subagentBridge?.dispose();
+        releaseBridge?.dispose();
         session = runtimeHost.session;
+        const epoch = crypto.randomUUID();
+        const bus = session.resourceLoader.getEventBus?.();
+        intercomBridge = new RpcIntercomBridge(bus, output, session.sessionId, epoch);
+        subagentBridge = new RpcSubagentBridge(bus, output, { version: 1, sessionId: session.sessionId, epoch });
+        releaseBridge = new RpcReleaseBridge(bus, { version: 1, sessionId: session.sessionId, epoch });
+    };
+    const reloadSession = () => withTransition(reloadSessionUnguarded);
+    const reloadSessionUnguarded = async () => {
+        intercomBridge?.dispose();
+        subagentBridge?.dispose();
+        releaseBridge?.dispose();
+        let rebound = false;
+        try {
+            await session.reload({ beforeSessionStart: () => { bindObservationBridges(); rebound = true; } });
+        }
+        finally {
+            if (!rebound)
+                bindObservationBridges();
+            subagentBridge?.initialize();
+        }
+    };
+    const rebindSession = () => withTransition(rebindSessionUnguarded);
+    const rebindSessionUnguarded = async () => {
+        bindObservationBridges();
         await session.bindExtensions({
             uiContext: createExtensionUIContext(),
             mode: "rpc",
             commandContextActions: {
                 waitForIdle: () => session.waitForIdle(),
-                newSession: async (options) => runtimeHost.newSession(options),
+                newSession: async (options) => withTransition(() => runtimeHost.newSession(options)),
                 fork: async (entryId, forkOptions) => {
-                    const result = await runtimeHost.fork(entryId, forkOptions);
+                    const result = await withTransition(() => runtimeHost.fork(entryId, forkOptions));
                     return { cancelled: result.cancelled };
                 },
                 navigateTree: async (targetId, options) => {
@@ -324,10 +380,10 @@ export async function runRpcMode(runtimeHost) {
                     return { cancelled: result.cancelled };
                 },
                 switchSession: async (sessionPath, options) => {
-                    return runtimeHost.switchSession(sessionPath, options);
+                    return withTransition(() => runtimeHost.switchSession(sessionPath, options));
                 },
                 reload: async () => {
-                    await session.reload();
+                    await reloadSession();
                 },
             },
             shutdownHandler: () => {
@@ -337,10 +393,11 @@ export async function runRpcMode(runtimeHost) {
                 output({ type: "extension_error", extensionPath: err.extensionPath, event: err.event, error: err.error });
             },
         });
+        subagentBridge?.initialize();
         unsubscribe?.();
         unsubscribeBackpressure?.();
         unsubscribe = session.subscribe((event) => {
-            output(event);
+            output(toJsonEvent(event));
             if (event.type === "agent_settled") {
                 void checkShutdownRequested();
             }
@@ -389,10 +446,168 @@ export async function runRpcMode(runtimeHost) {
     };
     await rebindSession();
     registerSignalHandlers();
+    /**
+     * Release blockers owned by this process (not by an extension). Fail closed: if a probe throws, report it
+     * instead of answering "safe". Extension blockers are collected by RpcReleaseBridge.
+     */
+    const coreReleaseBlockers = () => {
+        const blockers = [];
+        const block = (kind, detail) => blockers.push({ source: "core", kind, detail });
+        if (releasing)
+            block(RELEASING_BLOCKER_KIND, "A release was committed; this process is shutting down");
+        if (sessionTransitions > 0)
+            block("session_transition", "Session switch, reload or extension rebind in progress");
+        if (promptsInFlight > 0)
+            block("prompt_in_flight", `${promptsInFlight} prompt command(s) still being processed`);
+        const probe = (kind, check) => {
+            try {
+                check();
+            }
+            catch (e) {
+                block("contributor_error", `${kind} probe failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        };
+        probe("streaming", () => { if (session.isStreaming)
+            block("streaming", "Agent run in progress"); });
+        probe("compacting", () => { if (session.isCompacting)
+            block("compacting", "Compaction or branch summarization in progress"); });
+        probe("retrying", () => { if (session.isRetrying)
+            block("retrying", `Auto-retry in progress (attempt ${session.retryAttempt})`); });
+        probe("queued_messages", () => {
+            const steering = session.getSteeringMessages().length;
+            const followUp = session.getFollowUpMessages().length;
+            if (session.agent.hasQueuedMessages() || session.pendingMessageCount > 0)
+                block("queued_messages", `Queued messages: ${steering} steering, ${followUp} follow-up`);
+        });
+        probe("pending_tool_calls", () => {
+            const pending = session.agent.state.pendingToolCalls.size;
+            if (pending > 0)
+                block("pending_tool_calls", `${pending} tool call(s) in flight`);
+        });
+        probe("pending_bash", () => {
+            if (session.isBashRunning)
+                block("pending_bash", "Bash command running");
+            if (session.hasPendingBashMessages)
+                block("pending_bash", "Bash output awaiting flush into the session");
+        });
+        if (pendingExtensionRequests.size > 0)
+            block("extension_dialog", `${pendingExtensionRequests.size} extension dialog(s) awaiting a response`);
+        if (compactionPromptQueue.length > 0)
+            block("compaction_prompt_queue", `${compactionPromptQueue.length} prompt(s) buffered until compaction ends`);
+        return blockers;
+    };
+    /**
+     * Core half of `stop_all_background`: everything this process runs for the session itself. Mirrors the `abort` command (agent
+     * turn, retry, compaction, branch summary) and additionally kills a running `!bash`, drops queued steer/follow-up messages and
+     * buffered compaction prompts so nothing restarts the turn after the abort. Only what was actually active is reported, so an
+     * idle session yields no items. Foreground subagent runs belong to the turn: they are killed through the turn's abort signal.
+     * Extension dialogs are not touched (they are the host's UI, not background work).
+     */
+    const stopCoreWork = async () => {
+        const items = [];
+        const active = (kind, probe) => {
+            try {
+                return probe();
+            }
+            catch (e) {
+                items.push({ source: "core", kind, detail: `${kind} probe failed: ${e instanceof Error ? e.message : String(e)}`, ok: false, error: "probe_failed" });
+                return true;
+            }
+        };
+        const turn = active("turn", () => session.isStreaming);
+        const retry = active("retry", () => session.isRetrying);
+        const compaction = active("compaction", () => session.isCompacting);
+        const bash = active("bash", () => session.isBashRunning);
+        let queued = { steering: 0, followUp: 0 };
+        try {
+            queued = { steering: session.getSteeringMessages().length, followUp: session.getFollowUpMessages().length };
+        }
+        catch { /* reported by the abort below */ }
+        const bufferedPrompts = compactionPromptQueue.length;
+        const done = (kind, detail, failure) => {
+            const message = failure === undefined ? undefined : (failure instanceof Error ? failure.message : String(failure)).slice(0, 256);
+            items.push({ source: "core", kind, detail: message === undefined ? detail : `${detail} failed: ${message}`, ok: message === undefined, ...(message === undefined ? {} : { error: message }) });
+        };
+        // Order matters: drop queued work first so the abort's idle transition cannot start the next queued turn.
+        let queueFailure;
+        try {
+            compactionPromptQueue.length = 0;
+            session.clearQueue();
+        }
+        catch (e) {
+            queueFailure = e;
+        }
+        if (queued.steering + queued.followUp > 0)
+            done("queued_messages", `Dropped ${queued.steering} steering and ${queued.followUp} follow-up message(s)`, queueFailure);
+        if (bufferedPrompts > 0)
+            done("compaction_prompt_queue", `Dropped ${bufferedPrompts} prompt(s) buffered until compaction ends`, queueFailure);
+        let bashFailure;
+        try {
+            session.abortBash();
+        }
+        catch (e) {
+            bashFailure = e;
+        }
+        if (bash)
+            done("bash", "Aborted running bash command", bashFailure);
+        let abortFailure;
+        try {
+            session.abortBranchSummary();
+            session.abortCompaction();
+            await session.abort();
+        }
+        catch (e) {
+            abortFailure = e;
+        }
+        if (turn)
+            done("turn", "Aborted in-flight agent turn", abortFailure);
+        if (retry)
+            done("retry", "Cancelled auto-retry", abortFailure);
+        if (compaction)
+            done("compaction", "Aborted compaction or branch summarization", abortFailure);
+        if (abortFailure !== undefined && !turn && !retry && !compaction)
+            done("turn", "Abort", abortFailure);
+        return items;
+    };
     // Handle a single command
     const handleCommand = async (command) => {
         const id = command.id;
+        // Committed release: nothing new may start. Only the release probes still answer.
+        if (releasing && command.type !== "release" && command.type !== "release_readiness") {
+            return error(id, command.type, "Session is releasing");
+        }
         switch (command.type) {
+            case "subagent_status":
+                return subagentBridge.request(command);
+            case "release_readiness":
+                return releaseBridge.request(command, coreReleaseBlockers());
+            case "stop_all_background":
+                // Destructive kill switch for "Quit anyway". Refused above while `releasing`. The core abort and every extension's stop
+                // start synchronously inside the bridge and are awaited together under one ~5s budget.
+                return releaseBridge.stopAll(command, stopCoreWork, coreReleaseBlockers);
+            case "release": {
+                // ONE synchronous section: readiness check (core + extension broadcast) and commitment, no `await` in between.
+                // The shutdown itself runs from handleInputLine after the response is written and flushed.
+                if (releasing) {
+                    // Idempotent: a repeated (valid) release reports the committed decision.
+                    const invalid = validateReleaseCommand(command);
+                    if (invalid)
+                        return error(id, command.type, invalid);
+                    return success(id, "release", { released: true, readiness: releasedReadiness });
+                }
+                return releaseBridge.release(command, coreReleaseBlockers(), (readiness) => {
+                    releasing = true;
+                    releasedReadiness = readiness;
+                    releaseShutdownPending = true;
+                });
+            }
+            case "intercom_status":
+            case "intercom_list":
+            case "intercom_send":
+            case "intercom_ask":
+            case "intercom_reply":
+            case "intercom_pending":
+                return intercomBridge.request(command);
             // =================================================================
             // Prompting
             // =================================================================
@@ -411,36 +626,38 @@ export async function runRpcMode(runtimeHost) {
                         images: command.images,
                         streamingBehavior: command.streamingBehavior,
                     };
-                    output(success(id, "prompt")); // accepted into the buffer
+                    output(success(id, "prompt", { disposition: "queued" })); // accepted into the buffer
                     compactionPromptQueue.push(queued);
                     return undefined;
                 }
+                promptsInFlight++;
                 void session
                     .prompt(command.message, {
                     images: command.images,
                     streamingBehavior: command.streamingBehavior,
                     source: "rpc",
-                    preflightResult: (didSucceed) => {
-                        if (didSucceed) {
-                            preflightSucceeded = true;
-                            output(success(id, "prompt"));
-                        }
+                    preflightResult: (disposition) => {
+                        preflightSucceeded = true;
+                        output(success(id, "prompt", { disposition }));
                     },
                 })
                     .catch((e) => {
                     if (!preflightSucceeded) {
                         output(error(id, "prompt", e.message));
                     }
+                })
+                    .finally(() => {
+                    promptsInFlight--;
                 });
                 return undefined;
             }
             case "steer": {
-                await session.steer(command.message, command.images, { source: "rpc" });
-                return success(id, "steer");
+                const disposition = await session.steer(command.message, command.images, { source: "rpc" });
+                return success(id, "steer", { disposition });
             }
             case "follow_up": {
-                await session.followUp(command.message, command.images, { source: "rpc" });
-                return success(id, "follow_up");
+                const disposition = await session.followUp(command.message, command.images, { source: "rpc" });
+                return success(id, "follow_up", { disposition });
             }
             case "abort": {
                 // TUI Esc parity: cancel in-flight branch summarization and compaction as well,
@@ -492,14 +709,13 @@ export async function runRpcMode(runtimeHost) {
                     thinkingLevel: session.thinkingLevel,
                     isStreaming: session.isStreaming,
                     isCompacting: session.isCompacting,
+                    isRetrying: session.isRetrying,
                     steeringMode: session.steeringMode,
                     followUpMode: session.followUpMode,
                     sessionFile: session.sessionFile,
                     sessionId: session.sessionId,
                     sessionName: session.sessionName,
                     autoCompactionEnabled: session.autoCompactionEnabled,
-                    autoHandoffEnabled: session.autoHandoffEnabled,
-                    autoHandoffThresholdTokens: session.autoHandoffThresholdTokens,
                     messageCount: session.messages.length,
                     pendingMessageCount: session.pendingMessageCount,
                     steering: session.getSteeringMessages(),
@@ -533,7 +749,7 @@ export async function runRpcMode(runtimeHost) {
             // Model
             // =================================================================
             case "set_model": {
-                const models = await session.modelRuntime.getAvailable();
+                const models = session.modelRuntime.getAvailableSnapshot();
                 const model = models.find((m) => m.provider === command.provider && m.id === command.modelId);
                 if (!model) {
                     return error(id, "set_model", `Model not found: ${command.provider}/${command.modelId}`);
@@ -605,18 +821,6 @@ export async function runRpcMode(runtimeHost) {
                 session.setAutoCompactionEnabled(command.enabled);
                 return success(id, "set_auto_compaction");
             }
-            case "set_auto_handoff": {
-                session.settingsManager.setAutoHandoffEnabled(command.enabled);
-                return success(id, "set_auto_handoff");
-            }
-            case "set_auto_handoff_threshold": {
-                const tokens = command.tokens;
-                if (!Number.isFinite(tokens) || tokens < 1000) {
-                    return error(id, "set_auto_handoff_threshold", "Threshold must be at least 1000 tokens");
-                }
-                session.settingsManager.setAutoHandoffThresholdTokens(tokens);
-                return success(id, "set_auto_handoff_threshold");
-            }
             // =================================================================
             // Retry
             // =================================================================
@@ -1008,7 +1212,7 @@ export async function runRpcMode(runtimeHost) {
                     catch {
                         // best-effort
                     }
-                    await session.reload();
+                    await reloadSession();
                     return success(id, "factory_reset_settings");
                 }
                 catch (resetError) {
@@ -1276,7 +1480,7 @@ export async function runRpcMode(runtimeHost) {
                     return error(id, "reload", "Wait for compaction to finish before reloading.");
                 }
                 try {
-                    await session.reload();
+                    await reloadSession();
                     return success(id, "reload");
                 }
                 catch (reloadError) {
@@ -1396,6 +1600,9 @@ export async function runRpcMode(runtimeHost) {
         }
         unsubscribe?.();
         unsubscribeBackpressure?.();
+        intercomBridge?.dispose();
+        subagentBridge?.dispose();
+        releaseBridge?.dispose();
         await runtimeHost.dispose();
         detachInput();
         process.stdin.pause();
@@ -1434,11 +1641,17 @@ export async function runRpcMode(runtimeHost) {
         }
         const command = parsed;
         try {
-            const response = await handleCommand(command);
+            const response = await (TRANSITION_COMMANDS.has(command.type) ? withTransition(() => handleCommand(command)) : handleCommand(command));
             if (response) {
                 output(response);
                 await waitForRawStdoutBackpressure();
             }
+            if (releaseShutdownPending) {
+                // The release response is out: flush it fully, then take the normal gentle shutdown path (extensions disposed, exit 0).
+                releaseShutdownPending = false;
+                await flushRawStdout();
+                await shutdown();
+            }
             await checkShutdownRequested();
         }
         catch (commandError) {
@@ -1447,6 +1660,9 @@ export async function runRpcMode(runtimeHost) {
         }
     };
     const onInputEnd = () => {
+        // A committed release already owns the shutdown (response flush, then dispose); a second shutdown() would cut it short.
+        if (releasing)
+            return;
         void shutdown();
     };
     process.stdin.on("end", onInputEnd);

package/dist/modes/rpc/rpc-release-transport.test.d.ts

@@ -0,0 +1 @@
+export {};