zcode-acp-server 0.47.6 → 0.47.8

package/dist/handlers/session.js

@@ -30,7 +30,7 @@ import { refreshTerminalTabTitle } from "../terminal-title.js";
 import { buildDiffContent, EventTranslator, extractLocations, formatTurnError, isBackendLostError, isTransientTurnError, ProjectionDiffer, } from "../translators/index.js";
 import { clientConnectionRoot, log, warn } from "../utils.js";
 import { dispatchEvent } from "./dispatch.js";
-import { sendSessionUpdate, sendTextChunk, withReplayBatch } from "./io.js";
+import { emitSessionTurnState, sendSessionUpdate, sendTextChunk, withReplayBatch } from "./io.js";
 import { EDIT_DIFF_READ_LIMIT, fetchMessages, fetchMessagesSinceAnchor, fullSlice, readTailLimit, REPLY_READ_LIMIT, replayMessages, sliceTail, TURN_READ, } from "./replay.js";
 import { extractPermDeniedPath, extractSandboxDenial, GENERIC_HINT_KEY, handleSandboxDenial, READ_ONLY_TOOLS, } from "./sandbox-allow.js";
 import { handleServerRequests } from "./server-requests.js";
@@ -114,7 +114,7 @@ async function syncProviderRegistry(server, cwd) {
         // models the user's config selects never reach `settings.model.available`
         // (verified 2026-09 — switches then fail with "Provider Registry 中不存在
         // Model"). Pushing the snapshot restores desktop parity. Best-effort.
-        await pushAccountProviderConfig(server.ensureBackend(), () => server.nextId());
+        await pushAccountProviderConfig(await server.ensureBackend(), () => server.nextId());
         const registry = buildProviderRegistry();
         if (registry.providers.length === 0) {
             // Every configured provider lacks models (or none are configured). The
@@ -125,9 +125,7 @@ async function syncProviderRegistry(server, cwd) {
             log("provider-registry: no usable providers — skipping sync");
             return;
         }
-        const resp = await server
-            .ensureBackend()
-            .request(server.nextId(), "workspace/updateProviderRegistry", { workspace: workspaceFor(cwd), registry }, 10000);
+        const resp = await (await server.ensureBackend()).request(server.nextId(), "workspace/updateProviderRegistry", { workspace: workspaceFor(cwd), registry }, 10000);
         if (resp.error) {
             // 3.12+ removed the method (the registry is built from the bundled table,
             // personal config, and the account snapshot) — a no-op, not a failure.
@@ -372,7 +370,7 @@ function emitBootUsageUpdate(server, acpSid) {
                 const zcodeSid = server.resolveSid(acpSid);
                 let used = 0;
                 if (zcodeSid) {
-                    const backend = server.ensureBackend();
+                    const backend = await server.ensureBackend();
                     const resp = await backend.request(server.nextId(), "session/read", 
                     // messageLimit: only the projection is read; the cap keeps the
                     // backend from serializing the whole message array for it.
@@ -398,25 +396,6 @@ function emitBootUsageUpdate(server, acpSid) {
         })();
     });
 }
-/**
- * Broadcast turn liveness to attached clients ($/zcode/turnState): `running:true`
- * at turn start, `running:false` at completion (or on any early-return path).
- *
- * Emitted per attached alias (see server.sessionAliases) so every client holding
- * this conversation under its own ACP id updates its running indicator.
- * Clients that don't recognize the notification simply drop it.
- */
-export async function emitSessionTurnState(server, acpSid, running, cx) {
-    const targetCx = cx ?? server.clients.broadcast();
-    const results = await Promise.allSettled(server
-        .sessionAliases(acpSid)
-        .map((sid) => targetCx.notify("$/zcode/turnState", { sessionId: sid, running })));
-    for (const r of results) {
-        if (r.status === "rejected") {
-            log(`turnState notify failed: ${r.reason instanceof Error ? r.reason.message : String(r.reason)}`);
-        }
-    }
-}
 /**
  * Reload the session into the backend when the resident verification went
  * stale — the backend evicts idle resident runtimes (~10min idle + LRU), and
@@ -542,7 +521,7 @@ export async function ensureRealSession(server, acpSid, opts = {}) {
     // The create body runs synchronously up to its first await, so the `creating`
     // promise is stored before any concurrent caller can observe the entry.
     const creating = (async () => {
-        const backend = server.ensureBackend();
+        const backend = await server.ensureBackend();
         // Push the provider registry BEFORE session/create: the backend resolves
         // the session's default model against the registry, and without the
         // provider's reasoning/model definitions it falls back to the bare
@@ -609,7 +588,7 @@ export async function ensureRealSession(server, acpSid, opts = {}) {
         // resume this session via the placeholder id.
         recordMaterializedSession(acpSid, sid, pending.cwd);
         log(`session/new ${acpSid} → created ${sid} (lazy, on first use)`);
-        server.ensureBackgroundListener(sid);
+        await server.ensureBackgroundListener(sid);
         // Sync to the App's tasks-index.sqlite so the App UI shows this session.
         // Best-effort; failures are logged inside upsertSessionTask and swallowed.
         const { upsertSessionTask } = await import("../tasks-index.js");
@@ -633,7 +612,7 @@ export async function ensureRealSession(server, acpSid, opts = {}) {
 }
 /** `session/list` → zcode `session/list`. */
 export async function listSessions(server, params) {
-    const backend = server.ensureBackend();
+    const backend = await server.ensureBackend();
     const zcParams = {};
     // Serve mode (ADR-0014) pins the workspace: a remote client must not use a
     // client-supplied cwd to enumerate the machine's sessions in OTHER projects
@@ -669,7 +648,7 @@ async function adoptStoredTitle(server, acpSid, zcodeSid) {
     if (server.sessionTitles.has(acpSid))
         return;
     try {
-        const backend = server.ensureBackend();
+        const backend = await server.ensureBackend();
         const resp = await backend.request(server.nextId(), "session/list", {}, 15000);
         if (resp.error)
             return;
@@ -870,7 +849,7 @@ export async function resumeSession(server, params, cx) {
     // above); without this, a loaded session has no readable root.
     server.sessionCwds.set(acpSid, cwd);
     log(`session/resume -> ${zcodeSid}`);
-    server.ensureBackgroundListener(zcodeSid);
+    await server.ensureBackgroundListener(zcodeSid);
     await adoptStoredTitle(server, acpSid, zcodeSid);
     // Martty's /resume rides session/resume (no history by ACP design) and only
     // folds updates addressed to a session id it has already adopted — i.e.
@@ -937,7 +916,7 @@ export async function resumeIntoSession(server, cx, acpSid, zcodeTarget) {
             // Materialized but empty: discard the orphan backend session and the
             // stale mappings before adopting the target.
             try {
-                server.ensureBackend().send("session/close", { sessionId: current });
+                (await server.ensureBackend()).send("session/close", { sessionId: current });
             }
             catch (e) {
                 log(`/resume: closing empty session ${current} failed (ignored): ` +
@@ -983,7 +962,7 @@ export async function resumeIntoSession(server, cx, acpSid, zcodeTarget) {
         const finalCwd = backendWs && !server.serveMode ? backendWs : cwd;
         server.sessionCwds.set(acpSid, finalCwd);
         recordMaterializedSession(acpSid, zcodeTarget, finalCwd);
-        server.ensureBackgroundListener(zcodeTarget);
+        await server.ensureBackgroundListener(zcodeTarget);
         await adoptStoredTitle(server, acpSid, zcodeTarget);
     }
     catch (e) {
@@ -1086,7 +1065,7 @@ export async function loadSession(server, params, cx, opts = {}) {
     // Same as resumeSession: backend-authoritative session root for file access.
     server.sessionCwds.set(acpSid, cwd);
     log(`session/load → ${zcodeSid}`);
-    server.ensureBackgroundListener(zcodeSid);
+    await server.ensureBackgroundListener(zcodeSid);
     await adoptStoredTitle(server, acpSid, zcodeSid);
     // Goal-loop restart recovery (ADR-0022 §6): surface a recovery hint at most
     // once per bridge process per session — never auto-resume a spend-incurring
@@ -1349,7 +1328,7 @@ export async function runOneTurn(server, opts) {
                 // reconcile the differ baseline so the retried turn's new messages
                 // aren't treated as already-seen, surface a retry hint, then back off.
                 if (turn.cancelled) {
-                    stopBackendTurn(server, zcodeSid, turn);
+                    void stopBackendTurn(server, zcodeSid, turn);
                     return { stopReason: "cancelled" };
                 }
                 differ.markSeen(await fetchMessagesSinceAnchor(server, zcodeSid, differ.historyAnchor));
@@ -1415,7 +1394,7 @@ export async function runOneTurn(server, opts) {
             let queuedNoticeSent = false;
             while (true) {
                 if (turn.cancelled) {
-                    stopBackendTurn(server, zcodeSid, turn);
+                    void stopBackendTurn(server, zcodeSid, turn);
                     return { stopReason: "cancelled" };
                 }
                 sendAttempt++;
@@ -1433,7 +1412,7 @@ export async function runOneTurn(server, opts) {
                 if (expectBusy) {
                     await sleep(SEND_RETRY_INTERVAL_MS);
                     if (turn.cancelled) {
-                        stopBackendTurn(server, zcodeSid, turn);
+                        void stopBackendTurn(server, zcodeSid, turn);
                         return { stopReason: "cancelled" };
                     }
                 }
@@ -1608,7 +1587,7 @@ export async function runOneTurn(server, opts) {
                             .catch((err) => warn(`recover: backend kill failed: ${err instanceof Error ? err.message : String(err)}`));
                     }
                     try {
-                        backend = server.ensureBackend();
+                        backend = await server.ensureBackend();
                         listener = new EventStreamListener(backend, zcodeSid);
                         monitor = new TurnMonitor(backend, zcodeSid, () => server.nextId());
                         await reloadBackendSession(server, acpSid, zcodeSid);
@@ -1695,7 +1674,7 @@ async function runPrompt(server, params, cx, requestId, continuationRound = fals
     // respawns under the profile and the subscribe-recovery path reloads the
     // session. No-op unless the config appeared mid-run.
     await server.applySandboxFlip();
-    const backend = server.ensureBackend();
+    const backend = await server.ensureBackend();
     // Extract prompt text + image attachments from ACP ContentBlock[].
     const text = extractPromptText(params.prompt);
     const attachments = extractAttachments(params.prompt);
@@ -1730,7 +1709,7 @@ async function runPrompt(server, params, cx, requestId, continuationRound = fals
     // titles): a mid-session backend respawn (sandbox flip, dynamic allow
     // batches, dead-reader recovery) replaces the instance the listeners were
     // registered on — ensureBackgroundListener re-registers on the current one.
-    server.ensureBackgroundListener(zcodeSid);
+    await server.ensureBackgroundListener(zcodeSid);
     // Slash-command interception: dispatches directly to ZCode methods and
     // returns end_turn without entering the turn loop. Known passthrough
     // commands and unknown /x both return null for the normal turn loop.
@@ -1962,7 +1941,7 @@ export async function cancel(server, params) {
             matched = true;
             turn.cancelled = true;
             if (!turn.stopSent) {
-                stopBackendTurn(server, zcodeSid, turn);
+                void stopBackendTurn(server, zcodeSid, turn);
                 turn.stopSent = true;
             }
             // Record cancel time so a prompt arriving in the backend's ~20s
@@ -2069,7 +2048,7 @@ export function isBackendLostRequestError(e) {
  * backend's prompt lock releases when ITS finalisation completes — that,
  * not any bridge-side signal, is what the next prompt's send-retry waits on.
  */
-function stopBackendTurn(server, zcodeSid, turn) {
+async function stopBackendTurn(server, zcodeSid, turn) {
     const foregroundExecutionId = turn.foregroundExecutionId;
     // A turn whose send was NEVER accepted owns no generation of its own; while
     // our detached compaction runs, the only thing foreground on this session
@@ -2084,7 +2063,8 @@ function stopBackendTurn(server, zcodeSid, turn) {
         return;
     }
     try {
-        server.ensureBackend().send("session/stop", { sessionId: zcodeSid });
+        const backend = await server.ensureBackend();
+        backend.send("session/stop", { sessionId: zcodeSid });
     }
     catch (e) {
         log(`  [stop] session/stop send failed (ignored): ${e instanceof Error ? e.message : String(e)}`);
@@ -2101,7 +2081,8 @@ function stopBackendTurn(server, zcodeSid, turn) {
     // at cancel time, letting the backend guard against stopping a newer one.
     // Omitted when unknown, targeting whatever is currently foreground.
     try {
-        server.ensureBackend().send("v4/command", {
+        const backend = await server.ensureBackend();
+        backend.send("v4/command", {
             commandId: randomUUID(),
             clientId: "zcode-acp-server",
             sessionId: zcodeSid,
@@ -2130,9 +2111,10 @@ function stopBackendTurn(server, zcodeSid, turn) {
  * history). Callers reload the session on next use — prompt()'s subscribe
  * recovery and the drain gate's reload both handle the closed window.
  */
-function closeBackendSession(server, zcodeSid) {
+async function closeBackendSession(server, zcodeSid) {
     try {
-        server.ensureBackend().send("session/close", { sessionId: zcodeSid });
+        const backend = await server.ensureBackend();
+        backend.send("session/close", { sessionId: zcodeSid });
         log(`  [stop] session/close fired for ${zcodeSid} (backend ignores session/stop)`);
     }
     catch (e) {
@@ -2176,7 +2158,7 @@ export async function drainBackendAfterCancel(server, deps) {
     let escalated = false;
     while (Date.now() - drainT0 < DRAIN_TIMEOUT_MS) {
         if (turn.cancelled) {
-            stopBackendTurn(server, zcodeSid, turn);
+            void stopBackendTurn(server, zcodeSid, turn);
             return "cancelled";
         }
         const proj = await monitor.pollOnce();
@@ -2198,7 +2180,7 @@ export async function drainBackendAfterCancel(server, deps) {
             break;
         if (proj.status === "running" && !escalated && Date.now() - drainT0 > escalateAfterMs) {
             escalated = true;
-            closeBackendSession(server, zcodeSid);
+            void closeBackendSession(server, zcodeSid);
         }
         if (!noticed) {
             noticed = true;
@@ -2283,7 +2265,7 @@ export function preemptInFlightTurn(server, zcodeSid, selfRequestId) {
             continue;
         turn.cancelled = true; // signal the old turn to stop its retry loops
         if (!turn.stopSent) {
-            stopBackendTurn(server, zcodeSid, turn);
+            void stopBackendTurn(server, zcodeSid, turn);
             turn.stopSent = true;
         }
         // Record cancel time so the prompt()'s send-retry can use the recovery
@@ -2419,7 +2401,7 @@ function fileUriToPath(uri) {
  * backend-authoritative session workspace from it. Throws on failure.
  */
 async function resumeBackendSession(server, zcParams) {
-    const backend = server.ensureBackend();
+    const backend = await server.ensureBackend();
     const MAX_ATTEMPTS = 2;
     const ATTEMPT_TIMEOUT_MS = 15_000;
     for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
@@ -2738,7 +2720,7 @@ async function fetchMessagesForReplay(server, zcodeSid) {
  */
 async function repairUnavailableModel(server, zcodeSid) {
     try {
-        const backend = server.ensureBackend();
+        const backend = await server.ensureBackend();
         const resp = await backend.request(server.nextId(), "session/read", 
         // messageLimit: only settings.model.current is read; the cap keeps the
         // backend from serializing the whole message array for it.
@@ -2871,7 +2853,7 @@ export function turnResult(translator, stopReason) {
  * Commit 6 — for now they're polled to keep the inbox clear.
  */
 export async function runEventTurn(server, listener, monitor, differ, cx, acpSid, chunkMsgId, turn, gateArmed) {
-    const backend = server.ensureBackend();
+    const backend = await server.ensureBackend();
     const translator = new EventTranslator();
     differ.resetTurn();
     const NO_PROGRESS_MS = 120_000;
@@ -3051,7 +3033,7 @@ export async function runEventTurn(server, listener, monitor, differ, cx, acpSid
             }
             else if (!emittedOutput) {
                 // No text and no output → suspected failure.
-                stopBackendTurn(server, turn.zcodeSid, turn);
+                void stopBackendTurn(server, turn.zcodeSid, turn);
                 throw new RequestError(-32603, "turn produced no output");
             }
         }
@@ -3068,7 +3050,7 @@ export async function runEventTurn(server, listener, monitor, differ, cx, acpSid
             else if (turn.cancelled) {
                 // Preserve the pre-existing bounded cancel behaviour. A stuck prompt
                 // lock after stop must not keep a user-cancelled turn alive forever.
-                stopBackendTurn(server, turn.zcodeSid, turn);
+                void stopBackendTurn(server, turn.zcodeSid, turn);
                 return turnResult(translator, "max_turn_requests");
             }
             else {
@@ -3109,7 +3091,7 @@ export async function runEventTurn(server, listener, monitor, differ, cx, acpSid
                         return turnResult(translator, "end_turn");
                     }
                     log(`  [stall] watermark frozen ${Math.round(frozenMs / 1000)}s with no output; stopping backend turn`);
-                    stopBackendTurn(server, turn.zcodeSid, turn);
+                    void stopBackendTurn(server, turn.zcodeSid, turn);
                     return turnResult(translator, "max_turn_requests");
                 }
             }
@@ -3142,7 +3124,7 @@ export async function runEventTurn(server, listener, monitor, differ, cx, acpSid
             // to no turn listener, and the next turn's turn-attribution gate
             // discards any residue that slipped into the queue meanwhile.
             if (!turn.stopSent) {
-                stopBackendTurn(server, turn.zcodeSid, turn);
+                void stopBackendTurn(server, turn.zcodeSid, turn);
                 turn.stopSent = true;
             }
             return turnResult(translator, "cancelled");
@@ -3408,7 +3390,7 @@ export async function runEventTurn(server, listener, monitor, differ, cx, acpSid
             }
             if (translator.turnFailed) {
                 // Best-effort stop in case the failed turn left a residual lock.
-                stopBackendTurn(server, turn.zcodeSid, turn);
+                void stopBackendTurn(server, turn.zcodeSid, turn);
                 // Throw a TurnFailedError carrying the structured error so the caller
                 // (prompt's retry loop) can classify transient vs fatal. The error
                 // message is formatted for display when it ultimately reaches the user.
@@ -3564,7 +3546,7 @@ export function flattenTodos(todos, todoGroups) {
 }
 /** Build a {projection, messages, todos} snapshot from session/messages + session/read. */
 async function buildSnapshot(server, zcodeSid, opts = {}) {
-    const backend = server.ensureBackend();
+    const backend = await server.ensureBackend();
     const [msgs, readResp] = await Promise.all([
         fetchMessages(server, zcodeSid, opts),
         backend.request(server.nextId(), "session/read", { sessionId: zcodeSid }, 8000),
@@ -3669,7 +3651,7 @@ const PLAN_RECHECK_DELAY_MS = 600;
 // Exported for unit tests (plan recheck timing).
 export async function dispatchPlanIfChanged(server, cx, acpSid, zcodeSid, differ, chunkMsgId, recheck = true) {
     try {
-        const backend = server.ensureBackend();
+        const backend = await server.ensureBackend();
         const readResp = await backend.request(server.nextId(), "session/read", { sessionId: zcodeSid }, 8000);
         const read = (readResp.result ?? {});
         const todos = flattenTodos(read.todos, read.todoGroups);