zcode-acp-server 0.11.9 → 0.14.2

package/dist/handlers/session.js

@@ -14,7 +14,7 @@ import process from "node:process";
 import { randomUUID } from "node:crypto";
 import { RequestError } from "@agentclientprotocol/sdk";
 import { EventStreamListener, TurnMonitor } from "../backend/listener.js";
-import { buildModes, buildConfigOptions } from "../config/options.js";
+import { buildModes, buildConfigOptions, formatModelValue, loadAllModels, } from "../config/options.js";
 import { emitInitialUsage } from "../config/model-cache.js";
 import { buildProviderRegistry } from "../config/provider-registry.js";
 import { buildResumeRuntimeModel } from "../config/runtime-model.js";
@@ -349,11 +349,11 @@ export async function resumeSession(server, params, cx) {
     // in this backend subprocess.
     const { zcodeSid, alreadyLive } = await resolveResumeTarget(server, acpSid);
     if (!alreadyLive) {
-        // runtimeModel overlay: a resumed session may carry a stale/revoked model in
-        // its history → send fails with "历史模型不可用". Overlaying the current
-        // enabled provider redirects the session onto a working model. The overlay
-        // deliberately carries NO apiKey (the backend's schema rejects it; it resolves
-        // auth from its own config/OAuth store).
+        // No runtimeModel pinning here: the session keeps its own persisted
+        // model (see resumePreservingModel — an overlay is a FALLBACK only, when
+        // the faithful resume fails outright). The params deliberately carry NO
+        // apiKey either (the backend's schema rejects it; it resolves auth from
+        // its own config/OAuth store).
         const zcParams = {
             sessionId: zcodeSid,
             workspace: workspaceFor(cwd),
@@ -364,16 +364,15 @@ export async function resumeSession(server, params, cx) {
         if (params.mcpServers && params.mcpServers.length > 0) {
             zcParams.mcpServers = params.mcpServers;
         }
-        const runtimeModel = buildResumeRuntimeModel();
-        if (runtimeModel !== null)
-            zcParams.runtimeModel = runtimeModel;
         // Push the provider registry BEFORE resume: a resumed session may carry a
         // third-party model in its history, and the backend needs the provider
         // registered to even process the resume turn.
         await syncProviderRegistry(server, cwd);
-        const resumeResult = await resumeBackendSession(server, zcParams);
+        const resumeResult = await resumePreservingModel(server, zcParams);
         // The resume RPC succeeded — the session is now loaded in this backend.
         server.markBackendLoaded(acpSid);
+        // The session kept its own model — repair it only if it's no longer enabled.
+        await repairUnavailableModel(server, zcodeSid);
         // The backend's session record is the root authority: adopt its
         // workspace as the session root (heals any stale/polluted entry).
         const backendWs = workspaceFromResumeResult(resumeResult);
@@ -418,16 +417,15 @@ export async function loadSession(server, params, cx) {
             sessionId: zcodeSid,
             workspace: workspaceFor(cwd),
         };
-        const runtimeModel = buildResumeRuntimeModel();
-        if (runtimeModel !== null)
-            zcParams.runtimeModel = runtimeModel;
         // Push the provider registry BEFORE resume: a loaded session may carry a
         // third-party model in its history, and the backend needs the provider
         // registered to process it.
         await syncProviderRegistry(server, cwd);
-        const resumeResult = await resumeBackendSession(server, zcParams);
+        const resumeResult = await resumePreservingModel(server, zcParams);
         // The resume RPC succeeded — the session is now loaded in this backend.
         server.markBackendLoaded(acpSid);
+        // The session kept its own model — repair it only if it's no longer enabled.
+        await repairUnavailableModel(server, zcodeSid);
         // The backend's session record is the root authority: adopt its
         // workspace as the session root (heals any stale/polluted entry).
         const backendWs = workspaceFromResumeResult(resumeResult);
@@ -572,11 +570,20 @@ export async function prompt(server, params, cx, requestId) {
     }
     // Out-of-band running indicator: clients that did not send this prompt
     // (re-attached mobile, second editor) learn the turn started here — the
-    // session/load replayMeta only snapshots attach time. Best-effort: a dead
+    // session/load replayMeta only snapshots attach time. Emitted per attached
+    // alias (see server.sessionAliases) so a client holding this conversation
+    // under a different ACP id opens its live turn too. Best-effort: a dead
     // client must not fail the turn.
-    const emitTurnState = (running) => cx
-        .notify("$/zcode/turnState", { sessionId: params.sessionId, running })
-        .catch((e) => log(`turnState notify failed: ${e instanceof Error ? e.message : String(e)}`));
+    const emitTurnState = async (running) => {
+        const results = await Promise.allSettled(server
+            .sessionAliases(params.sessionId)
+            .map((sid) => cx.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)}`);
+            }
+        }
+    };
     await emitTurnState(true);
     const listener = new EventStreamListener(backend, zcodeSid);
     const monitor = new TurnMonitor(backend, zcodeSid, () => server.nextId());
@@ -648,7 +655,7 @@ export async function prompt(server, params, cx, requestId) {
                 // 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);
+                    stopBackendTurn(server, zcodeSid, turn.foregroundExecutionId);
                     return { stopReason: "cancelled" };
                 }
                 differ.markSeen(await fetchMessages(server, zcodeSid));
@@ -657,6 +664,23 @@ export async function prompt(server, params, cx, requestId) {
                 await sleep(backoffMs(attempt - 1));
             }
             const chunkMsgId = randomUUID();
+            // Drain gate: a recent cancel/preempt means the backend side needs
+            // settling before the send — see drainBackendAfterCancel.
+            const cancelledRecently = server.lastCancelledAt.get(zcodeSid) !== undefined &&
+                Date.now() - server.lastCancelledAt.get(zcodeSid) < DRAIN_WINDOW_MS;
+            if (cancelledRecently) {
+                const drained = await drainBackendAfterCancel(server, {
+                    acpSid: params.sessionId,
+                    zcodeSid,
+                    turn,
+                    listener,
+                    monitor: new TurnMonitor(backend, zcodeSid, () => server.nextId()),
+                    differ,
+                    cx,
+                });
+                if (drained === "cancelled")
+                    return { stopReason: "cancelled" };
+            }
             // 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
@@ -674,7 +698,7 @@ export async function prompt(server, params, cx, requestId) {
             let sendAttempt = 0;
             while (true) {
                 if (turn.cancelled) {
-                    stopBackendTurn(server, zcodeSid);
+                    stopBackendTurn(server, zcodeSid, turn.foregroundExecutionId);
                     return { stopReason: "cancelled" };
                 }
                 sendAttempt++;
@@ -688,7 +712,7 @@ export async function prompt(server, params, cx, requestId) {
                 if (expectBusy) {
                     await sleep(SEND_RETRY_INTERVAL_MS);
                     if (turn.cancelled) {
-                        stopBackendTurn(server, zcodeSid);
+                        stopBackendTurn(server, zcodeSid, turn.foregroundExecutionId);
                         return { stopReason: "cancelled" };
                     }
                 }
@@ -715,7 +739,13 @@ export async function prompt(server, params, cx, requestId) {
             }
             try {
                 // Event-driven turn loop: translate events via EventTranslator + dispatch.
-                const result = await runEventTurn(server, listener, monitor, differ, cx, params.sessionId, chunkMsgId, turn, preempted);
+                // 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).
+                const gateArmed = preempted ||
+                    Date.now() - (server.lastCancelledAt.get(zcodeSid) ?? 0) < CANCEL_RESIDUE_WINDOW_MS;
+                const result = await runEventTurn(server, listener, monitor, differ, cx, params.sessionId, chunkMsgId, turn, gateArmed);
                 // (Session title: already set once at the FIRST prompt, before the
                 // turn loop — nothing here may change it again.)
                 // Auto-compact: if context usage exceeds the threshold, compact before
@@ -736,12 +766,14 @@ export async function prompt(server, params, cx, requestId) {
                 // Only a transient TurnFailedError is retryable; everything else (send
                 // failures, non-transient turn errors, exhausted retries, cancellation)
                 // propagates to the caller.
-                if (e instanceof TurnFailedError &&
-                    attempt < MAX_TURN_ATTEMPTS &&
-                    !turn.cancelled &&
-                    isTransientTurnError(e.turnError)) {
-                    lastTurnError = e.turnError;
-                    continue;
+                if (e instanceof TurnFailedError) {
+                    const transient = isTransientTurnError(e.turnError);
+                    if (attempt < MAX_TURN_ATTEMPTS && !turn.cancelled && transient) {
+                        lastTurnError = e.turnError;
+                        continue;
+                    }
+                    if (!transient)
+                        throw turnFailureRequestError(e);
                 }
                 throw e;
             }
@@ -769,6 +801,13 @@ export async function prompt(server, params, cx, requestId) {
         await emitTurnState(stillBusy);
     }
 }
+/** How long after a cancel a new prompt's attribution gate stays armed (the
+ *  abandoned turn may still be streaming its finalisation into the backend). */
+const CANCEL_RESIDUE_WINDOW_MS = 120_000;
+/** How long after a cancel/preempt a new prompt still runs the drain gate
+ *  (drainBackendAfterCancel) before sending — same bound as the drain wait
+ *  itself, so the gate never waits twice its window. */
+const DRAIN_WINDOW_MS = 90_000;
 /**
  * `session/set_config_option` → dispatch model/mode/thought and emit the
  * resulting config_option_update (+ current_mode_update for mode).
@@ -803,9 +842,11 @@ export async function setConfigOptionHandler(server, params, cx) {
  * on a session with no active turn, and on a turn already aborted), so firing
  * it eagerly is safe; the loop's `stopSent` guard prevents a second send.
  *
- * `turn.cancelled` is still set so the turn loop switches to its silent-drain
- * path (translate to detect turnDone, but discard every internal event — no
- * text/tool/usage is pushed after the user stopped).
+ * `turn.cancelled` is still set so the turn loop returns at once (the backend
+ * ignores session/stop — verified 0.16.5, the model stream runs to its natural
+ * end — so waiting for a terminal event would hang the stop for the whole
+ * remaining generation). The loop's return resolves session/prompt with
+ * stopReason "cancelled" immediately.
  */
 export async function cancel(server, params) {
     const zcodeSid = server.resolveSid(params.sessionId);
@@ -815,13 +856,13 @@ export async function cancel(server, params) {
     // prior turn is still finalising, pendingTurns holds both it and any newer
     // prompt waiting on the backend's prompt lock; breaking on the first match
     // could leave the live one running. Each turn guards its own stopSent, so
-    // multiple matching turns may each fire session/stop once — the backend
-    // treats stop as idempotent, so the duplicate is harmless.
+    // multiple matching turns may each fire the stop pair once — the backend
+    // treats both as idempotent, so the duplicate is harmless.
     for (const [, turn] of server.pendingTurns) {
         if (turn.zcodeSid === zcodeSid) {
             turn.cancelled = true;
             if (!turn.stopSent) {
-                stopBackendTurn(server, zcodeSid);
+                stopBackendTurn(server, zcodeSid, turn.foregroundExecutionId);
                 turn.stopSent = true;
             }
             // Record cancel time so a prompt arriving in the backend's ~20s
@@ -845,6 +886,55 @@ class TurnFailedError extends Error {
         this.turnError = turnError;
     }
 }
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function finiteNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value !== "string" || value.trim() === "")
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+/** Build a small, safe ACP error payload from a backend turn failure. */
+function acpTurnFailureData(turnError) {
+    const cause = asRecord(turnError["cause"]) ?? turnError;
+    const context = asRecord(cause["context"]);
+    const summary = asRecord(context?.["responseBodySummary"]);
+    const headers = asRecord(summary?.["responseHeaders"]);
+    const retryAfterMs = finiteNumber(context?.["retryAfterMs"]) ??
+        (() => {
+            const seconds = finiteNumber(headers?.["retry-after"]);
+            return seconds === undefined ? undefined : seconds * 1000;
+        })();
+    const data = { type: "zcode_turn_failed" };
+    const code = cause["code"] ?? cause["type"];
+    if (typeof code === "string" && code.trim())
+        data.code = code;
+    const reason = context?.["reason"];
+    if (typeof reason === "string" && reason.trim())
+        data.reason = reason;
+    const statusCode = finiteNumber(context?.["statusCode"] ?? context?.["responseStatus"]);
+    if (statusCode !== undefined)
+        data.statusCode = statusCode;
+    const providerCode = context?.["providerCode"];
+    if (typeof providerCode === "string" && providerCode.trim())
+        data.providerCode = providerCode;
+    const retryable = context?.["retryable"];
+    if (typeof retryable === "boolean")
+        data.retryable = retryable;
+    if (retryAfterMs !== undefined)
+        data.retryAfterMs = retryAfterMs;
+    return data;
+}
+function turnFailureRequestError(error) {
+    const cause = asRecord(error.turnError["cause"]);
+    const detail = formatTurnError(cause ?? error.turnError) || error.message;
+    return new RequestError(-32603, `ZCode turn failed: ${detail}`, acpTurnFailureData(error.turnError));
+}
 /**
  * Fire-and-forget `session/stop` to the backend. Mirrors Python's
  * `_cancel_backend_turn`: send stop with an id (some backends route by id
@@ -855,13 +945,131 @@ class TurnFailedError extends Error {
  * 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) {
+function stopBackendTurn(server, zcodeSid, foregroundExecutionId) {
     try {
         server.ensureBackend().send("session/stop", { sessionId: zcodeSid });
     }
     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.
+    // 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.
+    // Omitted when unknown, targeting whatever is currently foreground.
+    try {
+        server.ensureBackend().send("v4/command", {
+            commandId: randomUUID(),
+            clientId: "zcode-acp-server",
+            sessionId: zcodeSid,
+            type: "stop",
+            payload: foregroundExecutionId
+                ? { expectedForegroundExecutionId: foregroundExecutionId }
+                : {},
+            issuedAt: Date.now(),
+        });
+        log(`  [stop] v4/command stop sent for ${zcodeSid}`);
+    }
+    catch (e) {
+        log(`  [stop] v4/command stop send failed (ignored): ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+/**
+ * Last-resort stop: tear down the session's resident runtime, killing any
+ * generation that survived the stop pair (session/stop + v4/command stop).
+ *
+ * The primary path is stopBackendTurn's v4/command stop — the official one —
+ * which kills the generation instantly. This close is the escalation when
+ * both stops are ignored (drain gate, 5s grace): `session/close` closes the
+ * runtime itself, which kills the generation immediately; the conversation
+ * is persisted in the backend's session store, so `session/resume` restores
+ * it (verified live: resume succeeds and the partial reply is in the
+ * 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) {
+    try {
+        server.ensureBackend().send("session/close", { sessionId: zcodeSid });
+        log(`  [stop] session/close fired for ${zcodeSid} (backend ignores session/stop)`);
+    }
+    catch (e) {
+        log(`  [stop] session/close send failed (ignored): ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+/**
+ * Drain gate: a recent cancel/preempt means the backend side needs settling
+ * before the next send. Primary path: stopBackendTurn's v4/command stop kills
+ * the generation at once, so the first probe here already sees idle.
+ * Fallbacks: on a backend that honours session/stop we poll the projection
+ * until idle (a send that lands mid-generation is accepted as a steer whose
+ * input the backend silently DROPS when the old turn finishes); if the
+ * generation is STILL running after a grace period — both stops ignored —
+ * escalate to session/close, which tears down the runtime and kills it
+ * outright (the probe then fails into the reload branch). A visible chunk
+ * tells the user why the send waits. Bounded: on timeout send anyway — the
+ * steer-drop risk returns (the turn.steerQueued guard in runEventTurn reports
+ * it), but blocking the prompt forever is worse.
+ *
+ * Two post-drain repairs, both mirroring established patterns (prompt's
+ * eviction recovery / transient-retry re-baseline):
+ * - resubscribe: session/close killed the runtime this prompt subscribed to;
+ *   the reload revives the session but not the event push, so re-arm it —
+ *   without resubscribe the next turn runs deaf (no events at all, and stall
+ *   recovery can't engage because it needs turn.started).
+ * - re-baseline: the abandoned turn committed messages to the session history
+ *   while we waited (and close persisted its partial output); without markSeen
+ *   the completion diff replays that residue as this turn's output.
+ *
+ * Returns "cancelled" when the turn was flagged cancelled during the drain
+ * (stop pair fired; caller resolves session/prompt at once).
+ */
+export async function drainBackendAfterCancel(server, deps) {
+    const { acpSid, zcodeSid, turn, listener, monitor, differ, cx } = deps;
+    const DRAIN_TIMEOUT_MS = 90_000;
+    const DRAIN_POLL_MS = 1000;
+    const escalateAfterMs = deps.escalateAfterMs ?? 5_000;
+    const drainT0 = Date.now();
+    let noticed = false;
+    let escalated = false;
+    while (Date.now() - drainT0 < DRAIN_TIMEOUT_MS) {
+        if (turn.cancelled) {
+            stopBackendTurn(server, zcodeSid, turn.foregroundExecutionId);
+            return "cancelled";
+        }
+        const proj = await monitor.pollOnce();
+        if (!proj) {
+            // Probe failed — most likely the session was just closed by the
+            // escalation (close tears down the runtime). Reload it so the send
+            // below doesn't die on "session is not active", then re-arm the event
+            // push (see docstring).
+            try {
+                await reloadBackendSession(server, acpSid, zcodeSid);
+                await listener.resubscribe(() => server.nextId());
+            }
+            catch (e) {
+                warn(`drain gate: reload after close failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            break;
+        }
+        if (proj.status === "idle")
+            break;
+        if (proj.status === "running" && !escalated && Date.now() - drainT0 > escalateAfterMs) {
+            escalated = true;
+            closeBackendSession(server, zcodeSid);
+        }
+        if (!noticed) {
+            noticed = true;
+            await sendTextChunk(cx, acpSid, "[上一个回复仍在生成，等待结束后发送…]", randomUUID());
+        }
+        await sleep(DRAIN_POLL_MS);
+    }
+    differ.markSeen(await fetchMessages(server, zcodeSid));
+    return "drained";
 }
 /**
  * Serialize a per-session critical section. Each section awaits the previous
@@ -931,7 +1139,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);
+            stopBackendTurn(server, zcodeSid, turn.foregroundExecutionId);
             turn.stopSent = true;
         }
         // Record cancel time so the prompt()'s send-retry can use the recovery
@@ -1087,20 +1295,69 @@ async function resumeBackendSession(server, zcParams) {
  * Reload a session into the backend subprocess via `session/resume` — the
  * recovery path after the backend evicted the resident runtime (idle timeout
  * / LRU). Same param shape as session/load·resume (workspace from the
- * recorded session cwd, runtimeModel overlay for stale history models).
- * Marks the session backend-loaded on success.
+ * recorded session cwd, default-model overlay only if a faithful resume
+ * fails). Marks the session backend-loaded on success.
  */
 async function reloadBackendSession(server, acpSid, zcodeSid) {
     const zcParams = {
         sessionId: zcodeSid,
         workspace: workspaceFor(server.sessionCwds.get(acpSid) ?? process.cwd()),
     };
-    const runtimeModel = buildResumeRuntimeModel();
-    if (runtimeModel !== null)
-        zcParams.runtimeModel = runtimeModel;
-    await resumeBackendSession(server, zcParams);
+    await resumePreservingModel(server, zcParams);
     server.markBackendLoaded(acpSid);
 }
+/**
+ * Resume WITHOUT pinning a model, so the session keeps its own selection (the
+ * backend persists it per session — sessions the user ran on GLM-5.3-Flash
+ * used to be silently re-pinned to the first config model by an unconditional
+ * runtimeModel overlay). The overlay is now a FALLBACK repair only: when the
+ * faithful resume fails outright (history carrying a stale/revoked model),
+ * retry once pinned to the first enabled provider's first model.
+ */
+async function resumePreservingModel(server, zcParams) {
+    try {
+        return await resumeBackendSession(server, zcParams);
+    }
+    catch (err) {
+        const overlay = buildResumeRuntimeModel();
+        if (overlay === null)
+            throw err;
+        warn(`resume failed (${err instanceof Error ? err.message : String(err)}); retrying with default-model overlay`);
+        return resumeBackendSession(server, { ...zcParams, runtimeModel: overlay });
+    }
+}
+/**
+ * After a faithful resume the session keeps its own last model; when that
+ * model no longer belongs to an enabled provider in config.json (deleted or
+ * revoked elsewhere), the first send would fail with the backend's
+ * stale-history-model error. Repair proactively: switch to the default
+ * (first enabled) model. Best-effort — a failed check leaves the model
+ * untouched.
+ */
+async function repairUnavailableModel(server, zcodeSid) {
+    try {
+        const backend = server.ensureBackend();
+        const resp = await backend.request(server.nextId(), "session/read", { sessionId: zcodeSid }, 5000);
+        if (resp.error)
+            return;
+        const settings = (resp.result ?? {}).settings;
+        const cur = settings?.model?.current;
+        if (!cur?.providerId || !cur.modelId)
+            return;
+        const available = loadAllModels();
+        if (available.some((m) => m.providerId === cur.providerId && m.modelId === cur.modelId))
+            return;
+        const fallback = available[0];
+        if (!fallback)
+            return;
+        warn(`session ${zcodeSid} model ${cur.providerId}/${cur.modelId} is no longer enabled; switching to ${fallback.providerId}/${fallback.modelId}`);
+        const { applyModelSwitch } = await import("../config/runtime-model.js");
+        await applyModelSwitch(server, zcodeSid, formatModelValue(fallback.providerId, fallback.modelId));
+    }
+    catch (e) {
+        warn(`model repair check failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
 /** Get or create the session-level ProjectionDiffer (persists across turns). */
 function getOrCreateDiffer(server, zcodeSid) {
     let d = server.differs.get(zcodeSid);
@@ -1121,12 +1378,13 @@ function getOrCreateDiffer(server, zcodeSid) {
  * handling (requestPermission / ExitPlanMode / AskUserQuestion) lands in
  * Commit 6 — for now they're polled to keep the inbox clear.
  */
-async function runEventTurn(server, listener, monitor, differ, cx, acpSid, chunkMsgId, turn, preempted) {
+export async function runEventTurn(server, listener, monitor, differ, cx, acpSid, chunkMsgId, turn, gateArmed) {
     const backend = server.ensureBackend();
     const translator = new EventTranslator();
     differ.resetTurn();
     const NO_PROGRESS_MS = 120_000;
-    let lastProgress = Date.now();
+    let lastProtocolProgressAt = Date.now();
+    let nextNoProgressDecisionAt = lastProtocolProgressAt + NO_PROGRESS_MS;
     let lastStallCheck = Date.now();
     let emittedText = false;
     let emittedOutput = false;
@@ -1140,7 +1398,42 @@ async function runEventTurn(server, listener, monitor, differ, cx, acpSid, chunk
     let turnStartedAt = null;
     let thinkingHintSent = false;
     const THINKING_HINT_DELAY_MS = 1200;
-    while (Date.now() - lastProgress < NO_PROGRESS_MS) {
+    const recordProtocolProgress = () => {
+        lastProtocolProgressAt = Date.now();
+        nextNoProgressDecisionAt = lastProtocolProgressAt + NO_PROGRESS_MS;
+    };
+    while (true) {
+        if (Date.now() >= nextNoProgressDecisionAt) {
+            if (listener.hasQueuedEvents()) {
+                // An event that arrived exactly at the deadline is real protocol
+                // progress. Consume it below before making any terminal decision.
+                recordProtocolProgress();
+            }
+            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.foregroundExecutionId);
+                return { stopReason: "max_turn_requests" };
+            }
+            else {
+                const lockState = await probePromptLock(server, turn.zcodeSid);
+                if (lockState === "held") {
+                    // A prompt-lock failure is direct evidence that the backend still owns
+                    // an active turn. It is liveness, not protocol progress: leave
+                    // lastProtocolProgressAt untouched and schedule a later decision.
+                    // This protects legitimately long model/tool operations without
+                    // allowing a stale `projection.status=running` to refresh the clock.
+                    const activeTools = [...translator.seenToolIds].filter((toolId) => !translator.finalToolIds.has(toolId)).length;
+                    log(`  [stall] prompt lock still held after ${Math.round((Date.now() - lastProtocolProgressAt) / 1000)}s silence (activeTools=${activeTools}); deferring terminal decision`);
+                    nextNoProgressDecisionAt = Date.now() + NO_PROGRESS_MS;
+                }
+                else {
+                    log(`  [stall] no-progress deadline reached; prompt lock=${lockState}`);
+                    stopBackendTurn(server, turn.zcodeSid, turn.foregroundExecutionId);
+                    return { stopReason: "max_turn_requests" };
+                }
+            }
+        }
         // Drain + handle server→client requests (interaction/*). Refreshes the
         // no-progress timer when any are handled. Pass `turn` so interaction
         // requests become turn-cancel aware (user stop aborts pending popups).
@@ -1154,21 +1447,25 @@ async function runEventTurn(server, listener, monitor, differ, cx, acpSid, chunk
             warn(`handleServerRequests threw: ${e instanceof Error ? e.message : String(e)}`);
         }
         if (handled) {
-            lastProgress = Date.now();
+            recordProtocolProgress();
         }
         if (turn.cancelled) {
-            // Cancel requested: ensure stop was fired (cancel()/preempt normally do
-            // this, but guard anyway). We do NOT silence subsequent events here — if
-            // the backend ignored the stop and kept producing, that content is still
-            // valuable to the user and should be displayed (the backend is the single
-            // source of truth within a session). Cross-turn contamination is handled
-            // separately by the turn-attribution gate below, which discards this
-            // turn's leftover events from the *next* turn's queue. The loop exits
-            // normally on the terminal event (translator.turnDone below).
+            // Cancel requested: fire the stop (cancel()/preempt normally already
+            // did — this is a guard) and END THE TURN AT ONCE. The backend's
+            // session/stop is fire-and-forget and, as verified against app-server
+            // 0.16.5, does NOT abort the in-flight model stream — waiting for the
+            // backend's terminal event used to keep the turn streaming for the
+            // full remaining generation (10s+ past the stop) while the user stared
+            // at a live spinner. Returning here resolves session/prompt with
+            // stopReason "cancelled" immediately; the finally below unregisters
+            // the turn listener, so events the backend still pushes are delivered
+            // 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);
+                stopBackendTurn(server, turn.zcodeSid, turn.foregroundExecutionId);
                 turn.stopSent = true;
             }
+            return { stopReason: "cancelled" };
         }
         const ev = await listener.pollEvent(500);
         if (ev === null) {
@@ -1197,7 +1494,7 @@ async function runEventTurn(server, listener, monitor, differ, cx, acpSid, chunk
             // user stopped.
             if (!turn.cancelled &&
                 translator.turnStarted &&
-                Date.now() - lastProgress > 15_000 &&
+                Date.now() - lastProtocolProgressAt > 15_000 &&
                 Date.now() - lastStallCheck > 15_000) {
                 lastStallCheck = Date.now();
                 const proj = await monitor.pollOnce();
@@ -1210,7 +1507,7 @@ async function runEventTurn(server, listener, monitor, differ, cx, acpSid, chunk
                     // turn is alive (it stays queued for the next poll).
                     await sleep(1500);
                     if (listener.hasQueuedEvents()) {
-                        lastProgress = Date.now();
+                        recordProtocolProgress();
                         continue; // alive — events will be consumed by the next poll
                     }
                     const proj2 = await monitor.pollOnce();
@@ -1224,7 +1521,7 @@ async function runEventTurn(server, listener, monitor, differ, cx, acpSid, chunk
                             }
                             else if (!emittedOutput) {
                                 // No text and no output → suspected failure.
-                                stopBackendTurn(server, turn.zcodeSid);
+                                stopBackendTurn(server, turn.zcodeSid, turn.foregroundExecutionId);
                                 throw new RequestError(-32603, "turn produced no output");
                             }
                         }
@@ -1237,7 +1534,6 @@ async function runEventTurn(server, listener, monitor, differ, cx, acpSid, chunk
                     // Second probe says the backend is still working (or events arrived
                     // mid-probe) — keep waiting; queued events are consumed by the next
                     // poll iteration.
-                    lastProgress = Date.now();
                     if (proj2?.status === "running") {
                         await listener.resubscribe(() => server.nextId());
                     }
@@ -1248,13 +1544,23 @@ async function runEventTurn(server, listener, monitor, differ, cx, acpSid, chunk
                     // The send-retry loop in prompt() already covers the recovery window
                     // for the NEXT turn; for this in-flight turn we just resubscribe and
                     // let the backend emit its terminal event when ready.
-                    lastProgress = Date.now();
                     await listener.resubscribe(() => server.nextId());
                 }
             }
             continue;
         }
-        lastProgress = Date.now();
+        recordProtocolProgress();
+        // Steer-swallow guard: a send accepted while the previous turn is still
+        // generating is queued as steer input, which the backend silently DROPS
+        // when that turn ends — no new turn ever starts (no turn.started), and
+        // the attribution gate below would discard the steerQueued event like
+        // any other residue, leaving this prompt to hang until the 120s watchdog
+        // with the message lost. turn.steerQueued is definitive proof of the
+        // swallow: report it at once so the user can resend immediately.
+        if (ev.type === "turn.steerQueued" && !translator.turnStarted && gateArmed) {
+            await sendTextChunk(cx, acpSid, "[消息被并入仍在生成的回合，将被丢弃，请重新发送]", chunkMsgId);
+            return { stopReason: "max_turn_requests" };
+        }
         // Turn-attribution gate: before this turn's own turn.started arrives, any
         // event is leftover from a prior turn (cancelled/preempted but still
         // finalising) that landed in the queue while send was retrying on a busy
@@ -1266,15 +1572,26 @@ async function runEventTurn(server, listener, monitor, differ, cx, acpSid, chunk
         // terminal event here would flip them and make THIS turn exit prematurely
         // at the first check after its own turn.started passes the gate.
         //
-        // The gate is armed ONLY when this send preempted another prompt. Without
-        // preemption no prior-turn residue can exist: the queue can only contain
-        // events of a backend-owned turn that was already active at send time
-        // (e.g. the main-branch turn auto-resumed after a compaction) — this send
-        // was steered into it and produces NO new turn.started, so dropping those
-        // events would silently swallow the entire turn's output in the UI.
-        if (shouldDropEventForTurnAttribution(ev, translator.turnStarted, preempted)) {
+        // Armed when this send preempted another prompt, OR when a cancel is
+        // recent: the backend ignores session/stop, so an abandoned turn keeps
+        // streaming until its natural end while the turn loop has already
+        // returned — a prompt sent in that window reaches subscribe while the
+        // residue is still arriving. Backend serialisation bounds the exposure:
+        // a send is accepted only after the prior turn released the lock, so the
+        // residue can only arrive BEFORE this turn's turn.started. (A send that
+        // lands mid-generation instead is a steer whose input is dropped — the
+        // turn.steerQueued guard above reports that at once.)
+        if (shouldDropEventForTurnAttribution(ev, translator.turnStarted, gateArmed)) {
             continue;
         }
+        if (ev.type === "turn.started") {
+            // Remember the runtime's foreground execution id: the v4/command stop
+            // (see stopBackendTurn) targets it if the user cancels mid-turn.
+            const fge = ev.payload
+                ?.foregroundExecutionId;
+            if (fge)
+                turn.foregroundExecutionId = fge;
+        }
         const internalEvents = translator.translate(ev);
         // Capture the turn-start timestamp for the thinking-phase hint above.
         // Done after translate so the flag flip on the turn.started event is
@@ -1340,7 +1657,7 @@ async function runEventTurn(server, listener, monitor, differ, cx, acpSid, chunk
             }
             if (translator.turnFailed) {
                 // Best-effort stop in case the failed turn left a residual lock.
-                stopBackendTurn(server, turn.zcodeSid);
+                stopBackendTurn(server, turn.zcodeSid, turn.foregroundExecutionId);
                 // 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.
@@ -1390,9 +1707,37 @@ async function runEventTurn(server, listener, monitor, differ, cx, acpSid, chunk
             return { stopReason: "end_turn" };
         }
     }
-    // 120s no progress: abandon.
-    stopBackendTurn(server, turn.zcodeSid);
-    return { stopReason: "max_turn_requests" };
+}
+/**
+ * Probe the backend's authoritative prompt lock without waiting for it to
+ * change. `session/read` projection status is intentionally not considered:
+ * that projection can remain stale at `running`, which is the condition this
+ * probe is used to disambiguate.
+ */
+async function probePromptLock(server, zcodeSid) {
+    const backend = server.ensureBackend();
+    if (backend.isDead)
+        return "unknown";
+    try {
+        const resp = await backend.request(server.nextId(), "session/goal", { sessionId: zcodeSid, action: "show" }, 10_000);
+        if (!resp.error)
+            return "released";
+        // Lock-busy must match by error CODE, not message text: backend message
+        // wording drifts between releases (repo Gotcha), and a missed match kills
+        // a live turn. 1308 is the prompt-lock-busy code (same one the send-retry
+        // loop keys on); message matching kept as a legacy fallback.
+        if (resp.error.code === 1308)
+            return "held";
+        const message = (resp.error.message ?? "").toLowerCase();
+        if (message.includes("prompt is running") || message.includes("already running")) {
+            return "held";
+        }
+        return "unknown";
+    }
+    catch (e) {
+        log(`  [stall] prompt-lock probe failed: ${e instanceof Error ? e.message : String(e)}`);
+        return "unknown";
+    }
 }
 /**
  * Turn-attribution gate decision (pure, exported for tests): whether an event