zcode-acp-server 0.44.4 → 0.46.0

package/dist/handlers/session.js

@@ -1333,7 +1333,16 @@ export async function runOneTurn(server, opts) {
             const cancelledRecently = server.lastCancelledAt.get(zcodeSid) !== undefined &&
                 Date.now() - server.lastCancelledAt.get(zcodeSid) < DRAIN_WINDOW_MS &&
                 !server.autoCompactInFlight.has(zcodeSid);
-            if (cancelledRecently) {
+            // Drain gate, behavior-adaptive: on a backend that has REJECTED a send
+            // with the whole-turn busy error (0.16.9 — sendPrompt's
+            // activeAbortController guard spans the entire turn), a mid-turn send
+            // is never accepted as steer, so the send loop's busy-retry below is
+            // the authoritative readiness probe and the pre-send poll (with its
+            // close-escalation) is skipped. Backends that never showed the
+            // rejection (0.16.5: a mid-generation send is accepted as steer and
+            // silently dropped) keep the full gate.
+            const drainRan = cancelledRecently && !server.observedSendBusyReject;
+            if (drainRan) {
                 const drained = await drainBackendAfterCancel(server, {
                     acpSid,
                     zcodeSid,
@@ -1348,12 +1357,14 @@ export async function runOneTurn(server, opts) {
             }
             // Send the prompt, retrying while the backend reports it's still busy.
             // The backend's prompt lock is the single authoritative readiness signal:
-            // a rejected send (code 1308 "prompt is running") means a previous turn
-            // (cancelled, preempted, or still finalising) hasn't released the lock
-            // yet. Rather than guessing when the backend is ready — or blocking on a
-            // local shadow flag — we retry with a fixed delay until the backend
-            // accepts. This covers the preempt path (new prompt interrupting an
-            // in-flight one) and the stop-recovery window after a manual cancel.
+            // a rejected send (1308 "prompt is running" on 0.16.5; -32010 "A prompt
+            // is already running for this session" spanning the WHOLE turn on
+            // 0.16.9) means a previous turn (cancelled, preempted, or still
+            // finalising) hasn't released the lock yet. Rather than guessing when
+            // the backend is ready — or blocking on a local shadow flag — we retry
+            // with a fixed delay until the backend accepts. This covers the preempt
+            // path (new prompt interrupting an in-flight one) and the
+            // stop-recovery window after a manual cancel.
             const SEND_RETRY_INTERVAL_MS = 500;
             const SEND_RETRY_TIMEOUT_MS = 30_000;
             // Cold-start rejections recover in seconds (observed); a longer budget
@@ -1364,6 +1375,7 @@ export async function runOneTurn(server, opts) {
                 : { sessionId: zcodeSid, content: sendText };
             const sendT0 = Date.now();
             let sendAttempt = 0;
+            let queuedNoticeSent = false;
             while (true) {
                 if (turn.cancelled) {
                     stopBackendTurn(server, zcodeSid, turn);
@@ -1375,8 +1387,12 @@ export async function runOneTurn(server, opts) {
                 // will reject an immediate send. On the first attempt with no recent
                 // cancel, send immediately so normal prompts aren't delayed.
                 const recentCancel = server.lastCancelledAt.get(zcodeSid);
+                // With whole-turn busy semantics a rejection is cheap and retried —
+                // no need to pre-sleep after a cancel on such backends.
                 const expectBusy = sendAttempt > 1 ||
-                    (recentCancel !== undefined && Date.now() - recentCancel < SEND_RETRY_TIMEOUT_MS);
+                    (!server.observedSendBusyReject &&
+                        recentCancel !== undefined &&
+                        Date.now() - recentCancel < SEND_RETRY_TIMEOUT_MS);
                 if (expectBusy) {
                     await sleep(SEND_RETRY_INTERVAL_MS);
                     if (turn.cancelled) {
@@ -1388,6 +1404,15 @@ export async function runOneTurn(server, opts) {
                 if (!sendResp.error) {
                     const accepted = (sendResp.result ?? {});
                     if (accepted.accepted) {
+                        // A retried send means another turn (typically the cancelled
+                        // one) was still unwinding during our attempts and commits its
+                        // residue AFTER this turn's pre-send baseline. The drain gate
+                        // re-baselines after its wait; the fast path has no wait, so
+                        // re-baseline here or the completion diff replays that residue
+                        // as this turn's output.
+                        if (sendAttempt > 1) {
+                            differ.markSeen(await fetchMessages(server, zcodeSid));
+                        }
                         // From this moment the turn may own a running generation —
                         // stopBackendTurn's compaction guard no longer spares it.
                         turn.sendAccepted = true;
@@ -1400,6 +1425,17 @@ export async function runOneTurn(server, opts) {
                 const isBusy = sendErrCode === 1308 ||
                     sendErrMsg.includes("prompt is running") ||
                     sendErrMsg.includes("already running");
+                // Whole-turn busy rejection observed (code AND message: -32010 is
+                // shared by unrelated errors, e.g. "Subagent sessions are read-only")
+                // — this backend never accepts a mid-turn send as steer. Disarm the
+                // drain gate's pre-send poll for the rest of this backend process.
+                if (isBusy &&
+                    sendErrCode === -32010 &&
+                    sendErrMsg.includes("already running") &&
+                    !server.observedSendBusyReject) {
+                    server.observedSendBusyReject = true;
+                    log("  [send] whole-turn busy rejection observed — drain gate disarmed for this backend");
+                }
                 const isWarming = isTransientSendError(sendResp.error.message ?? "");
                 if (!isBusy && !isWarming) {
                     // Permanent error (auth, malformed, a truly removed model, …) —
@@ -1447,6 +1483,14 @@ export async function runOneTurn(server, opts) {
                 if (Date.now() - sendT0 > budget) {
                     throw new Error(`zcode send failed: ${isBusy ? "backend still busy" : "send keeps being rejected"} after ${Math.round(budget / 1000)}s (${sendResp.error.message ?? ""})`);
                 }
+                // Fast-path parity with the drain gate's wait note: the pre-send
+                // poll was skipped (whole-turn busy semantics), so this busy wait is
+                // the first thing telling the user their prompt queues behind a
+                // turn. Legacy backends got the note from the drain itself.
+                if (isBusy && !drainRan && !queuedNoticeSent && !turn.goalLoop) {
+                    queuedNoticeSent = true;
+                    await sendTextChunk(cx, acpSid, messages().promptQueuedBehindTurn, randomUUID());
+                }
                 log(`  [send] backend ${isBusy ? "busy" : "cold-start reject"} (${sendResp.error.message ?? ""}), retrying in ${SEND_RETRY_INTERVAL_MS}ms`);
             }
             // Continuation round status line: the respawn+reload window (~seconds)
@@ -1460,9 +1504,10 @@ export async function runOneTurn(server, opts) {
             try {
                 // Event-driven turn loop: translate events via EventTranslator + dispatch.
                 // Arm the attribution gate also on a recent cancel: the abandoned turn
-                // is still finalising in the backend (session/stop is not honored —
-                // verified 0.16.5), and its leftover deltas stream past the subscribe
-                // of this new prompt (see the gate comment in runEventTurn).
+                // is still finalising in the backend (stops are honored on 0.16.9 but
+                // finalisation still trails the stop), and its leftover deltas stream
+                // past the subscribe of this new prompt (see the gate comment in
+                // runEventTurn).
                 const gateArmed = preempted ||
                     Date.now() - (server.lastCancelledAt.get(zcodeSid) ?? 0) < CANCEL_RESIDUE_WINDOW_MS;
                 const result = await runEventTurn(server, listener, monitor, differ, cx, acpSid, chunkMsgId, turn, gateArmed);
@@ -1977,12 +2022,13 @@ function stopBackendTurn(server, zcodeSid, turn) {
     catch (e) {
         log(`  [stop] session/stop send failed (ignored): ${e instanceof Error ? e.message : String(e)}`);
     }
-    // The official stop path (this is what the desktop app's stop button uses —
-    // found in the app bundle): a v4 command that asks the runtime to stop the
-    // active foreground execution. session/stop alone is a no-op on the Aug-28
-    // app-server (its abort controller is never registered; backend log shows
-    // `hadActivePrompt: false`), while this kills the generation instantly —
-    // verified: turn.completed arrives the same instant the command lands.
+    // The official stop path (the desktop app's stop button sends exactly this):
+    // a v4 command that asks the runtime to stop the active foreground
+    // execution — it also holds the queue and pauses the active goal, reaching
+    // runtime-owned executions the bootstrap abort controller can miss. On
+    // 0.16.9 session/stop alone also works (the abort controller is registered
+    // at send-accept now — source: server-operations.ts sendPrompt), but the
+    // pair stays: belt and braces, and 0.16.5 builds need the v4 leg.
     // expectedForegroundExecutionId is passed when known — it is captured from
     // the turn's own turn.started, so it names the execution that is foreground
     // at cancel time, letting the backend guard against stopping a newer one.
@@ -2727,6 +2773,57 @@ export async function runEventTurn(server, listener, monitor, differ, cx, acpSid
     let turnStartedAt = null;
     let thinkingHintSent = false;
     const THINKING_HINT_DELAY_MS = 1200;
+    // Sub-agent visibility (session/subagents RPC, 0.16.9): the model can run
+    // sub-agents for minutes behind a silent stream — the watermark keeps
+    // moving but the editor shows nothing. Piggyback on the stall-reconcile
+    // cadence (it fires exactly in those quiet phases) to poll the backend's
+    // sub-agent roster and surface CHANGES as one-line text updates, plus a
+    // one-shot terminal summary when the roster drains. Best-effort: probe
+    // failures (old backends answer -32601) are silent and never affect the
+    // turn.
+    let lastSubagentLine = "";
+    let subagentEndedBaseline = null;
+    let subagentEndedLineSent = false;
+    const turnEpoch = Date.now();
+    const pollSubagentsOnce = async () => {
+        if (turn.cancelled)
+            return;
+        let result;
+        try {
+            const resp = await backend.request(server.nextId(), "session/subagents", { sessionId: turn.zcodeSid }, 8000);
+            if (resp.error || resp.result === undefined)
+                return;
+            result = resp.result;
+        }
+        catch {
+            return;
+        }
+        const roster = result;
+        const running = Array.isArray(roster.running) ? roster.running : [];
+        const endedTotal = typeof roster.ended?.total === "number" ? roster.ended.total : 0;
+        if (subagentEndedBaseline === null)
+            subagentEndedBaseline = endedTotal;
+        if (running.length > 0) {
+            const count = (status) => running.filter((a) => a.status === status).length;
+            const line = messages().subagentStatusLine(count("running"), count("waiting"), count("blocked"));
+            if (line !== lastSubagentLine) {
+                lastSubagentLine = line;
+                await sendTextChunk(cx, acpSid, line, randomUUID());
+            }
+        }
+        else if (lastSubagentLine !== "") {
+            lastSubagentLine = "";
+            const endedDuringTurn = (roster.ended?.items ?? []).filter((item) => typeof item.endedAt === "number" && item.endedAt >= turnEpoch - 5_000);
+            if (!subagentEndedLineSent &&
+                subagentEndedBaseline !== null &&
+                endedTotal > subagentEndedBaseline) {
+                subagentEndedLineSent = true;
+                const failed = endedDuringTurn.filter((item) => item.status === "failed").length;
+                const cancelled = endedDuringTurn.filter((item) => item.status === "cancelled").length;
+                await sendTextChunk(cx, acpSid, messages().subagentEndedLine(endedTotal - subagentEndedBaseline, failed, cancelled), randomUUID());
+            }
+        }
+    };
     const recordProtocolProgress = () => {
         lastProtocolProgressAt = Date.now();
         nextNoProgressDecisionAt = lastProtocolProgressAt + NO_PROGRESS_MS;
@@ -2900,6 +2997,7 @@ export async function runEventTurn(server, listener, monitor, differ, cx, acpSid
                 const proj = await monitor.pollOnce();
                 noteWatermark(proj);
                 await forwardAuthoritativeProgress();
+                await pollSubagentsOnce();
                 if (proj?.status === "idle") {
                     // A single idle probe can also fire mid-work: the backend is silent
                     // during the model's thinking/connection phase and may report idle