openmausbot 0.1.92 → 0.1.94

package/dist-server/server/drivers/acp/core.js

@@ -31,8 +31,9 @@ import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
 import { createHash } from "node:crypto";
 import { PROVIDER_CREDENTIAL_ENV, stripControlPlaneEnv, WORKSPACE_CREDENTIAL_ENV } from "../../config.js";
 import { decodeInjectId } from "../local-inject.js";
-import { promptHalves, readPromptSplitReceipt, splitSessionPrompt, writePromptSplitReceipt } from "../prompt-split.js";
+import { deletePromptSplitReceipt, promptHalves, readPromptSplitReceipt, splitSessionPrompt, writePromptSplitReceipt } from "../prompt-split.js";
 import { describeSpawnFailure, execCli, killCliTree, spawnCli } from "../../procs.js";
+import { classifyQuiet, describeQuiet, lastSeenPhrase, LogTail, quietKey, sampleProcessTree, } from "./quiet-status.js";
 /**
  * A `host::model` pick talks to a loopback server with its own key.
  * Subscription ACP login (grok.com cached_token) must not fail that turn.
@@ -40,6 +41,12 @@ import { describeSpawnFailure, execCli, killCliTree, spawnCli } from "../../proc
 export function skipSubscriptionAuthForLocalInject(model) {
     return Boolean(decodeInjectId(model));
 }
+/** A catalog can contain credential-bearing native configuration, including late replies. */
+export function acpNativeIncomingLogMessage(message, privateResponses) {
+    if (!privateResponses.has(message?.id))
+        return message;
+    return { jsonrpc: message.jsonrpc, id: message.id, ...(message.error !== undefined ? { error: "[MCP catalog error omitted]" } : { result: "[MCP catalog omitted]" }) };
+}
 import { newEventId, newId, TurnNotStartedError } from "../../contracts.js";
 import { augmentedPath } from "../../env-path.js";
 import { supportsApprovalMode } from "../../../shared/approval-mode.js";
@@ -52,6 +59,8 @@ import { redactSecretsInText } from "../../redact.js";
 import { recoveryPromptFor } from "../../resume-recovery.js";
 import { sessionIdlePolicy } from "../session-idle.js";
 import { classifyError } from "../retry.js";
+import { canUseMcpServer, narrowsNativeTools, parseToolScope } from "../../../shared/tool-scope.js";
+import { gateServer } from "../../mcp-gate-config.js";
 const ACCOUNT_ERROR_CODES = new Set([
     "invalid_credentials", "inactive_subscription", "insufficient_funds", "quota_or_region_restriction",
 ]);
@@ -87,8 +96,13 @@ const SESSION_CONFIG_TIMEOUT = envOr("OPENMAUS_ACP_SESSION_CONFIG_TIMEOUT_MS", 3
 const NEW_SESSION_TIMEOUT = envOr("OPENMAUS_ACP_NEW_SESSION_TIMEOUT_MS", 300_000);
 const LOAD_SESSION_TIMEOUT = envOr("OPENMAUS_ACP_LOAD_SESSION_TIMEOUT_MS", 120_000); // history replay on a long thread is slow
 /** ACP agents may compact their own history without telling the client;
- * re-send the full prompt after this many bare turns as a backstop. */
+ * re-send the full prompt after this many bare turns as a backstop to
+ * compaction detection. */
 const ACP_PROMPT_RE_ANCHOR_TURNS = 8;
+/** A reported context below this share of the peak marks a compaction.
+ * OpenCode compactions measured 30-52% of the peak; ordinary dips stay
+ * above 83%. A false alarm costs one extra full prompt. */
+const ACP_COMPACTION_COLLAPSE_RATIO = 0.6;
 // Read lazily (not at import) so a test can shorten the window. Unlike the
 // setup calls above, session/prompt legitimately streams for minutes, so a
 // wall-clock deadline would false-positive: this guard only trips when the
@@ -96,13 +110,23 @@ const ACP_PROMPT_RE_ANCHOR_TURNS = 8;
 // streams thought chunks, then goes silent forever and never resolves). 0
 // disables the guard, restoring the pre-fix "hang until the user cancels"
 // behavior.
+//
+// Healthy agents go silent for minutes too. Qwen Code 0.24 sends nothing
+// over ACP while it compresses history, while it backs off a rate limit
+// (60 s up to 5 min per wait), or while one model request runs (its SDK
+// waits up to 600 s). The old 180 s default killed those turns mid-work,
+// and the retry redid it all. A false trip costs the whole turn; a real
+// wedge only costs waiting, and the user can press Stop - so the default
+// sits above the longest normal silence.
+export const DEFAULT_ACP_PROMPT_IDLE_MS = 15 * 60_000;
 const promptIdleTimeoutMs = () => {
     const raw = process.env.OPENMAUS_ACP_PROMPT_IDLE_TIMEOUT_MS;
     if (raw === undefined)
-        return 180_000;
+        return DEFAULT_ACP_PROMPT_IDLE_MS;
     const ms = Number(raw);
     return Number.isFinite(ms) && ms > 0 ? ms : 0;
 };
+const formatQuietLimit = (ms) => ms >= 120_000 && ms % 60_000 === 0 ? `${ms / 60_000} min` : `${Math.round(ms / 1000)} s`;
 /** Keep a turn's set of running tool calls in step with the agent's
  * `tool_call` / `tool_call_update` notifications: a call is running from
  * the first update that is not terminal until one that is. A `tool_call`
@@ -117,6 +141,18 @@ function trackRunningTool(current, update, defaultStatus) {
     else if (status === "pending" || status === "in_progress")
         current.runningTools.add(update.toolCallId);
 }
+let unkeyedToolSeq = 0;
+/** Stamp an unkeyed `tool_call` with a synthetic id and queue it for the
+ * call's first terminal update, which carries no id of its own to match.
+ * FIFO is the best available pairing when the agent omits `toolCallId`:
+ * the ids exist to pair start with completion, not to order concurrent
+ * unkeyed calls, and the synthetic id deliberately stays out of
+ * `runningTools` so turn-settle semantics are unchanged. */
+function nextUnkeyedToolId(current) {
+    const id = `acp-tool-unkeyed-${++unkeyedToolSeq}`;
+    current.unkeyedToolIds.push(id);
+    return id;
+}
 const CLIENT_FILE_MAX_BYTES = 8 * 1024 * 1024;
 function acpVariantOption(result) {
     const option = (Array.isArray(result?.configOptions) ? result.configOptions : []).find((entry) => entry?.type === "select" && typeof entry.id === "string"
@@ -493,7 +529,113 @@ export function createAcpDriver(support) {
                     }
                     servers.push({ name, command: server.command, args: server.args, env: acpEnv(server.env) });
                 }
-                return servers;
+                if (turn.toolScope === undefined)
+                    return servers;
+                return servers.filter((server) => canUseMcpServer(turn.toolScope, server.name)).map((server) => {
+                    const original = "url" in server
+                        ? { type: server.type, url: server.url, headers: Object.fromEntries(server.headers.map(({ name, value }) => [name, value])) }
+                        : { command: server.command, args: server.args, env: Object.fromEntries(server.env.map(({ name, value }) => [name, value])) };
+                    const gated = gateServer({ name: server.name, server: original, threadId: turn.threadId, budget: 0,
+                        toolScope: turn.toolScope, nodeEnv: { ELECTRON_RUN_AS_NODE: "1" } });
+                    if (!gated)
+                        throw new Error("Tool selection requires an MCP gate.");
+                    return { name: server.name, command: gated.command, args: gated.args, env: acpEnv(gated.env) };
+                });
+            };
+            /** While a prompt runs, notice when the agent goes quiet and tell the
+             *  person what it is doing: retrying, compressing, waiting on its
+             *  model, busy, or showing no sign of life (see quiet-status.ts). A
+             *  notice is sent only when that answer changes. New lines in the
+             *  agent's own log also restart the prompt's idle deadline, so a
+             *  turn that is visibly retrying is never stopped as stuck. */
+            const startQuietWatch = (threadId, session, current) => {
+                const noticeAfterMs = envOr("OMB_ACP_QUIET_NOTICE_MS", 60_000);
+                const tickMs = envOr("OMB_ACP_QUIET_TICK_MS", 15_000);
+                const logPath = support.statusLog && session.sessionId
+                    ? support.statusLog.path(session.env, session.sessionId)
+                    : null;
+                const tail = logPath ? new LogTail(logPath) : null;
+                tail?.read(); // skip what this log held before the prompt
+                let logged = null;
+                let context = null;
+                let previous = null;
+                let previousAt = 0;
+                let shownKey = null;
+                let noSignsSince = null;
+                let notices = 0;
+                let probing = false;
+                let state = null;
+                const tick = async () => {
+                    if (probing || current.state.settled || session.current !== current)
+                        return;
+                    const now = Date.now();
+                    for (const line of tail?.read() ?? []) {
+                        session.acp.touch();
+                        const signal = support.statusLog.parse(line);
+                        if (signal?.kind === "context")
+                            context = { tokens: signal.tokens, threshold: signal.threshold };
+                        else if (signal)
+                            logged = { signal, at: now };
+                    }
+                    const quietMs = now - session.acp.lastInboundAt;
+                    // A running tool or an open question is already on screen.
+                    if (quietMs < noticeAfterMs || current.asks.size || current.runningTools.size) {
+                        if (quietMs < noticeAfterMs)
+                            logged = null;
+                        previous = null;
+                        shownKey = null;
+                        noSignsSince = null;
+                        state = null;
+                        return;
+                    }
+                    // A retry stays the answer until well past its wait (Qwen's SDK
+                    // retries on its own for about a minute before the next logged
+                    // attempt); after that the probe takes over.
+                    if (logged?.signal.kind === "retry"
+                        && now - logged.at > (logged.signal.delayMs ?? 60_000) + 120_000)
+                        logged = null;
+                    probing = true;
+                    const sample = session.child.pid ? await sampleProcessTree(session.child.pid) : { cpuMs: null, connections: null };
+                    probing = false;
+                    if (current.state.settled || session.current !== current)
+                        return;
+                    let next = classifyQuiet({
+                        logged: logged?.signal ?? null, context, sample, previous, sinceMs: previous ? now - previousAt : 0,
+                    });
+                    const first = previous === null;
+                    previous = sample;
+                    previousAt = now;
+                    // CPU use needs two samples; the first only sets the baseline
+                    // (unless the log already said what is going on).
+                    if (first && next.kind === "unknown")
+                        return;
+                    // An SDK sleeping between its own retries holds no socket and
+                    // burns no CPU (seen with Qwen against a 429ing endpoint), so
+                    // "no sign of life" is called only once that has lasted minutes.
+                    if (next.kind === "no-signs") {
+                        noSignsSince ??= now;
+                        if (now - noSignsSince < envOr("OMB_ACP_STUCK_AFTER_MS", 180_000))
+                            next = { kind: "between-requests" };
+                    }
+                    else {
+                        noSignsSince = null;
+                    }
+                    state = next;
+                    const key = quietKey(next);
+                    if (key === shownKey || notices >= 12)
+                        return;
+                    shownKey = key;
+                    notices += 1;
+                    emit({
+                        ...base(threadId, current.turnId),
+                        type: "runtime.notice",
+                        message: describeQuiet(support.displayName, next, quietMs, promptIdleTimeoutMs()),
+                    });
+                };
+                const timer = setInterval(() => { void tick(); }, tickMs);
+                timer.unref?.();
+                current.stopQuietWatch = () => clearInterval(timer);
+                return { lastState: () => state };
             };
             /** The one completion path for a turn: the prompt result, a crashed
              *  child, an unanswered cancel, or an rpc error the turn body throws.
@@ -505,6 +647,7 @@ export function createAcpDriver(support) {
                     return;
                 current.state.settled = true;
                 current.acknowledge();
+                current.stopQuietWatch?.();
                 if (current.interruptTimer)
                     clearTimeout(current.interruptTimer);
                 for (const finish of current.asks.values())
@@ -555,6 +698,7 @@ export function createAcpDriver(support) {
                     stdio: ["pipe", "pipe", "pipe"],
                 });
                 let nextId = 1;
+                const privateResponses = new Set();
                 const rpcPending = new Map();
                 const send = (obj) => {
                     // A permission/file response resumes an agent that was waiting on us.
@@ -571,6 +715,8 @@ export function createAcpDriver(support) {
                 };
                 const request = (method, params, timeoutMs, receive, idleMs, idleMessage) => new Promise((resolve, reject) => {
                     const id = nextId++;
+                    if (method === "_x.ai/mcp/list")
+                        privateResponses.add(id);
                     let timer = null;
                     if (timeoutMs) {
                         timer = setTimeout(() => {
@@ -597,7 +743,7 @@ export function createAcpDriver(support) {
                                 return;
                             }
                             rpcPending.delete(id);
-                            const error = new Error(idleMessage ?? `${method} stopped responding`);
+                            const error = new Error((typeof idleMessage === "function" ? idleMessage() : idleMessage) ?? `${method} stopped responding`);
                             Object.assign(error, { acpPromptStall: true });
                             reject(error);
                         }, idleMs);
@@ -616,9 +762,13 @@ export function createAcpDriver(support) {
                     });
                     send({ jsonrpc: "2.0", id, method, params });
                 });
+                let lastInboundAt = Date.now();
                 const acp = {
                     send,
                     request,
+                    get lastInboundAt() { return lastInboundAt; },
+                    touch: () => { for (const p of rpcPending.values())
+                        p.armIdle(); },
                     failAll: (error) => {
                         for (const p of rpcPending.values()) {
                             if (p.timer)
@@ -891,7 +1041,7 @@ export function createAcpDriver(support) {
                                 ...base(threadId, current.turnId),
                                 type: "item.started",
                                 itemType: "tool",
-                                itemId: u.toolCallId,
+                                itemId: (typeof u.toolCallId === "string" && u.toolCallId) ? u.toolCallId : nextUnkeyedToolId(current),
                                 title: String(u.rawInput?.command ?? u.title ?? "tool").slice(0, 80),
                                 summary: commandSummary(u.rawInput),
                                 input: toolDetailPreview(u.rawInput),
@@ -906,7 +1056,7 @@ export function createAcpDriver(support) {
                                     ...base(threadId, current.turnId),
                                     type: "item.completed",
                                     itemType: "tool",
-                                    itemId: u.toolCallId,
+                                    itemId: (typeof u.toolCallId === "string" && u.toolCallId) ? u.toolCallId : current.unkeyedToolIds.shift(),
                                     ok: u.status !== "failed",
                                     output: toolDetailPreview(u.rawOutput ?? u.content),
                                 });
@@ -916,12 +1066,26 @@ export function createAcpDriver(support) {
                             }
                             break;
                         }
+                        case "usage_update": {
+                            // opencode 1.18 sends `used` flat; ignore non-positive reports
+                            const used = u.used ?? u.usage?.used;
+                            if (typeof used !== "number" || !(used > 0))
+                                break;
+                            if (current.state.usagePeak !== null && used < current.state.usagePeak * ACP_COMPACTION_COLLAPSE_RATIO) {
+                                current.state.usageCompacted = true;
+                            }
+                            if (current.state.usagePeak === null || used > current.state.usagePeak)
+                                current.state.usagePeak = used;
+                            current.state.usageLast = used;
+                            break;
+                        }
                     }
                 };
                 const session = {
                     child,
                     acp,
                     launch,
+                    env,
                     cwd,
                     contractKey,
                     sessionKey: null,
@@ -954,9 +1118,10 @@ export function createAcpDriver(support) {
                         catch {
                             continue;
                         }
-                        appendNative(threadId, { dir: "in", source: SOURCE, msg: nativeLogMessage(msg) });
+                        appendNative(threadId, { dir: "in", source: SOURCE, msg: nativeLogMessage(acpNativeIncomingLogMessage(msg, privateResponses)) });
                         // Inbound traffic proves the child is alive and making progress,
                         // so every idle deadline restarts; only total silence trips it.
+                        lastInboundAt = Date.now();
                         for (const p of rpcPending.values())
                             p.armIdle();
                         if (msg.id !== undefined && (msg.result !== undefined || msg.error !== undefined)) {
@@ -1029,6 +1194,13 @@ export function createAcpDriver(support) {
                 return session;
             };
             const sendTurn = async (turn) => {
+                const parsedScope = parseToolScope(turn.toolScope);
+                if (!parsedScope.ok)
+                    throw new Error(parsedScope.error);
+                turn = { ...turn, toolScope: parsedScope.scope };
+                if (narrowsNativeTools(turn.toolScope) && !support.toolScopeSessionParams) {
+                    throw new Error(`${support.displayName}: native tool selection is not supported by this engine. Keep native:* in the selection or choose a supported engine.`);
+                }
                 const { threadId } = turn;
                 if (active.has(threadId))
                     throw new Error("a turn is already running on this thread");
@@ -1059,7 +1231,7 @@ export function createAcpDriver(support) {
                 }
                 const resolvedModel = support.resolveTurnModel?.(turn.model, env);
                 support.applyTurnEnv?.(env, {
-                    model: resolvedModel, requestedModel: turn.model, fullAuto: turnConfig.fullAuto === true, botId: turn.botId, cwd,
+                    model: resolvedModel, requestedModel: turn.model, fullAuto: turnConfig.fullAuto === true, botId: turn.botId, cwd, toolScope: turn.toolScope,
                 });
                 // Rebound once, before the prompt, when a fallbackModel support swaps
                 // a model this session does not offer for one it does.
@@ -1103,6 +1275,8 @@ export function createAcpDriver(support) {
                 // riding a child spawned under the old env. Hash it so secrets
                 // never sit in the key itself.
                 const envFingerprint = createHash("sha256").update(JSON.stringify(spawnEnv)).digest("hex").slice(0, 16);
+                const inheritedScopeFingerprint = narrowsNativeTools(turn.toolScope) && support.toolScopeCacheKey
+                    ? createHash("sha256").update(support.toolScopeCacheKey({ config: turnConfig, env, cwd })).digest("hex") : null;
                 // A support that applies the approval mode to the session on every
                 // turn gets the same process whatever the mode: an approval change
                 // is one RPC, not a cold start.
@@ -1110,6 +1284,8 @@ export function createAcpDriver(support) {
                     launch.command, launch.args ?? [], spawnArgs, cwd,
                     support.sessionScopedApproval ? null : turnConfig.fullAuto === true, envFingerprint,
                     support.spawnFingerprint?.(spawnEnv) ?? null,
+                    turn.toolScope ?? null,
+                    inheritedScopeFingerprint,
                 ]);
                 // The new-session default model rides the spawn env but stays out of
                 // the fingerprint above: only session/new reads it, and a pooled
@@ -1128,7 +1304,7 @@ export function createAcpDriver(support) {
                     launchedThisTurn = true;
                     return opened;
                 };
-                const sessionKey = JSON.stringify(mcpServers);
+                const sessionKey = JSON.stringify([mcpServers, turn.toolScope ?? null, inheritedScopeFingerprint]);
                 if (turn.sessionReset) {
                     closeSession(threadId, "reset");
                     sessionAllows.delete(threadId);
@@ -1159,7 +1335,7 @@ export function createAcpDriver(support) {
                 // respawns the child, every wire call must reach the live record, so
                 // nothing captures the connection off it.
                 const request = (method, params, timeoutMs, receive, idleMs, idleMessage) => session.acp.request(method, params, timeoutMs, receive, idleMs, idleMessage);
-                const state = { settled: false, promptSent: false, text: "", producedItem: false, startupActivity: false, stopped: false };
+                const state = { settled: false, promptSent: false, text: "", producedItem: false, startupActivity: false, stopped: false, usagePeak: null, usageLast: null, usageCompacted: false };
                 let acknowledge = () => { };
                 let rejectStartup = (_error) => { };
                 const startupAck = turn.startupRecovery ? new Promise((resolve, reject) => {
@@ -1226,7 +1402,9 @@ export function createAcpDriver(support) {
                     acknowledge,
                     asks,
                     runningTools: new Set(),
+                    unkeyedToolIds: [],
                     interruptTimer: null,
+                    stopQuietWatch: null,
                     flushAssistantText,
                     receiveModelVariants,
                 };
@@ -1252,6 +1430,7 @@ export function createAcpDriver(support) {
                 emit({ ...base(threadId, turnId), type: "turn.started" });
                 session.current = current;
                 (async () => {
+                    let pendingSplitReceipt = null;
                     try {
                         // The handshake is paid once per process, not once per turn. It
                         // is a function so the establishment retry below can pay it
@@ -1334,10 +1513,12 @@ export function createAcpDriver(support) {
                             // an agent that advertised its transport, so an agent without
                             // http/sse never sees an entry it would refuse the session over
                             const sessionServers = mcpServers.filter((server) => !("type" in server) || init?.agentCapabilities?.mcpCapabilities?.[server.type] === true);
+                            const selectionParams = narrowsNativeTools(turn.toolScope)
+                                ? support.toolScopeSessionParams(turn, init, sessionServers.length > 0, { config: turnConfig, env, cwd }) : {};
                             let loaded = false;
                             if (cursor) {
                                 try {
-                                    await request(support.resumeMethod === "resume" ? "session/resume" : "session/load", { sessionId: cursor, cwd, mcpServers: sessionServers }, LOAD_SESSION_TIMEOUT, (result) => {
+                                    await request(support.resumeMethod === "resume" ? "session/resume" : "session/load", { sessionId: cursor, cwd, mcpServers: sessionServers, ...selectionParams }, LOAD_SESSION_TIMEOUT, (result) => {
                                         if (result) {
                                             loaded = true;
                                             session.sessionId = cursor;
@@ -1393,7 +1574,7 @@ export function createAcpDriver(support) {
                                 promptTurn = { ...turn, text: recovery.text };
                                 rebuiltFromReplay = recovery.replayed;
                             }
-                            sessionResult = await request("session/new", { cwd, mcpServers: sessionServers }, NEW_SESSION_TIMEOUT, (result) => {
+                            sessionResult = await request("session/new", { cwd, mcpServers: sessionServers, ...selectionParams }, NEW_SESSION_TIMEOUT, (result) => {
                                 session.sessionId = typeof result?.sessionId === "string" ? result.sessionId : null;
                                 session.sessionKey = sessionKey;
                                 receiveModelVariants(result);
@@ -1479,6 +1660,7 @@ export function createAcpDriver(support) {
                                     sessionModels: Array.isArray(sessionResult?.models?.availableModels)
                                         ? sessionResult.models.availableModels
                                         : [],
+                                    currentModelId: session.sessionConfigResult?.models?.currentModelId,
                                 });
                                 approvalUnconfirmed = false;
                                 // initialize's currentModelId is the CLI default,
@@ -1512,12 +1694,15 @@ export function createAcpDriver(support) {
                         // adapter call) keeps the legacy full-prompt shape.
                         const halves = promptHalves(turn);
                         let promptInput = promptTurn;
-                        let pendingSplitReceipt = null;
                         if (halves.stable !== null) {
                             const receiptKey = JSON.stringify([threadId, sessionId]);
-                            const composed = splitSessionPrompt(halves.stable, halves.volatile, readPromptSplitReceipt(DRIVER_KIND, receiptKey), promptTurn.system, promptTurn.text, Boolean(turn.mentionTurn), ACP_PROMPT_RE_ANCHOR_TURNS);
+                            const previousReceipt = readPromptSplitReceipt(DRIVER_KIND, receiptKey);
+                            // Carry the high-water mark, not just the final report: several
+                            // ordinary dips across turns can add up to a compaction.
+                            state.usagePeak = previousReceipt?.peakUsed ?? previousReceipt?.lastUsed ?? null;
+                            const composed = splitSessionPrompt(halves.stable, halves.volatile, previousReceipt, promptTurn.system, promptTurn.text, Boolean(turn.mentionTurn), ACP_PROMPT_RE_ANCHOR_TURNS);
                             promptInput = { ...promptTurn, system: "", text: composed.text };
-                            pendingSplitReceipt = { key: receiptKey, receipt: composed.receipt };
+                            pendingSplitReceipt = { key: receiptKey, receipt: composed.receipt, previous: previousReceipt };
                         }
                         const text = support.buildPromptText
                             ? support.buildPromptText(promptInput)
@@ -1538,13 +1723,32 @@ export function createAcpDriver(support) {
                         state.promptSent = true;
                         acknowledge();
                         const promptIdleMs = promptIdleTimeoutMs();
-                        const result = await request("session/prompt", { sessionId, prompt: [{ type: "text", text }, ...imageBlocks] }, undefined, undefined, promptIdleMs, `${DRIVER_KIND} sent nothing for ${Math.round(promptIdleMs / 1000)} s with no tool running, so the turn was stopped as stuck. ` +
-                            "Send the message again to retry. On a self-hosted server, OPENMAUS_ACP_PROMPT_IDLE_TIMEOUT_MS sets this limit (0 turns it off).");
+                        const quiet = startQuietWatch(threadId, session, current);
+                        const result = await request("session/prompt", { sessionId, prompt: [{ type: "text", text }, ...imageBlocks] }, undefined, undefined, promptIdleMs, () => {
+                            const last = quiet.lastState();
+                            return `${DRIVER_KIND} sent nothing for ${formatQuietLimit(promptIdleMs)} with no tool running, so the turn was stopped as stuck` +
+                                `${last ? ` (last seen: ${lastSeenPhrase(last)})` : ""}. ` +
+                                "Send the message again to retry. On a self-hosted server, OPENMAUS_ACP_PROMPT_IDLE_TIMEOUT_MS sets this limit (0 turns it off).";
+                        });
                         if (pendingSplitReceipt) {
                             // session/prompt resolving is the acceptance boundary: a
                             // rejected prompt leaves the receipt unwritten, so the next
-                            // turn redelivers what this one never received.
-                            writePromptSplitReceipt(DRIVER_KIND, pendingSplitReceipt.key, pendingSplitReceipt.receipt);
+                            // turn redelivers what this one never received. After a
+                            // compaction, drop it so the next turn re-sends the full prompt.
+                            if (state.usageCompacted) {
+                                deletePromptSplitReceipt(DRIVER_KIND, pendingSplitReceipt.key);
+                            }
+                            else {
+                                const previousLastUsed = typeof pendingSplitReceipt.previous?.lastUsed === "number"
+                                    ? pendingSplitReceipt.previous.lastUsed
+                                    : undefined;
+                                const lastUsed = state.usageLast ?? previousLastUsed;
+                                writePromptSplitReceipt(DRIVER_KIND, pendingSplitReceipt.key, {
+                                    ...pendingSplitReceipt.receipt,
+                                    ...(lastUsed === undefined ? {} : { lastUsed }),
+                                    ...(state.usagePeak === null ? {} : { peakUsed: state.usagePeak }),
+                                });
+                            }
                         }
                         // opencode 1.18.18 reports usage at the result root; grok and
                         // gemini put it under _meta. Read both rather than lose the count.
@@ -1597,6 +1801,11 @@ export function createAcpDriver(support) {
                         }
                     }
                     catch (e) {
+                        // A rejected prompt can still have compacted native history. Its
+                        // old receipt must not suppress the next turn's standing rules.
+                        if (pendingSplitReceipt && state.promptSent && state.usageCompacted) {
+                            deletePromptSplitReceipt(DRIVER_KIND, pendingSplitReceipt.key);
+                        }
                         if (!state.settled) {
                             const message = e instanceof Error ? e.message : String(e);
                             const code = support.classifyError?.(e);

package/dist-server/server/drivers/acp/cursor.js

@@ -30,9 +30,21 @@ export function resolveCursorAcpModelId(available, wanted) {
     const exact = ids.find((m) => m.modelId.toLowerCase() === want);
     if (exact)
         return exact.modelId;
-    const byBase = ids.find((m) => base(m.modelId) === want);
+    // A base can be advertised several times with different parameters, e.g.
+    // `composer-2.5[fast=false]` and `composer-2.5[fast=true]`. The plain slug
+    // means Standard, so prefer the non-fast variant; a `-fast` slug has no base
+    // of its own and means the fast=true variant of the base without the suffix.
+    const isFast = (id) => /[[,]\s*fast\s*=\s*true\s*[\],]/i.test(id);
+    const sameBase = ids.filter((m) => base(m.modelId) === want);
+    const byBase = sameBase.find((m) => !isFast(m.modelId)) ?? sameBase[0];
     if (byBase)
         return byBase.modelId;
+    if (want.endsWith("-fast")) {
+        const stem = want.slice(0, -"-fast".length);
+        const fast = ids.find((m) => base(m.modelId) === stem && isFast(m.modelId));
+        if (fast)
+            return fast.modelId;
+    }
     const byName = ids.find((m) => (m.name ?? "").trim().toLowerCase() === want);
     if (byName)
         return byName.modelId;