openmausbot 0.1.91 → 0.1.93

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.
@@ -52,6 +53,10 @@ import { redactSecretsInText } from "../../redact.js";
 import { recoveryPromptFor } from "../../resume-recovery.js";
 import { sessionIdlePolicy } from "../session-idle.js";
 import { classifyError } from "../retry.js";
+const ACCOUNT_ERROR_CODES = new Set([
+    "invalid_credentials", "inactive_subscription", "insufficient_funds", "quota_or_region_restriction",
+]);
+const isAccountError = (code) => code !== undefined && ACCOUNT_ERROR_CODES.has(code);
 /** ACP vendors put the actionable cause in error.data while keeping the
  * JSON-RPC message generic. Only surface known text fields, never a response
  * body/config dump, and redact before bounding the displayed diagnostic. */
@@ -83,8 +88,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
@@ -92,13 +102,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`
@@ -141,6 +161,24 @@ function acpVariantOption(result) {
     };
 }
 const TOOL_LOG_TEXT_LIMIT = 64_000;
+/** Every model id a session config snapshot offers under `configId`,
+ * flattening grouped options. Empty when the agent listed none. */
+export function offeredModels(result, configId) {
+    const option = (Array.isArray(result?.configOptions) ? result.configOptions : []).find((entry) => entry?.id === configId);
+    const ids = [];
+    const visit = (entries) => {
+        if (!Array.isArray(entries))
+            return;
+        for (const entry of entries) {
+            if (typeof entry?.value === "string")
+                ids.push(entry.value);
+            else if (Array.isArray(entry?.options))
+                visit(entry.options);
+        }
+    };
+    visit(option?.options);
+    return ids;
+}
 async function readAcpImageBlocks(images) {
     return Promise.all(images.map(async (image) => ({
         type: "image",
@@ -250,6 +288,11 @@ export function versionAtLeast(installed, floor) {
     return true;
 }
 export function createAcpDriver(support) {
+    // Without a per-turn configureSession nothing would ever apply the mode
+    // that sessionScopedApproval keeps out of the spawn contract.
+    if (support.sessionScopedApproval && !support.configureSession) {
+        throw new Error(`${support.displayName}: sessionScopedApproval needs configureSession to apply each turn's mode`);
+    }
     const DRIVER_KIND = support.driverKind;
     const SOURCE = support.nativeSource;
     const decodeConfig = decodeAcpConfig(support.defaultCli);
@@ -289,13 +332,18 @@ export function createAcpDriver(support) {
                 return env;
             };
             let models = support.models;
+            // Models this account itself offered (see sessionModelEnv): the
+            // discovered catalog, never the static one, or a live session's list.
+            let accountModels = null;
             const refreshModels = async () => {
                 if (!support.resolveModels)
                     return;
                 try {
                     const resolved = await support.resolveModels(childEnv(), config, instanceId);
-                    if (resolved.options.length)
+                    if (resolved.options.length) {
                         models = resolved;
+                        accountModels = new Set(resolved.options.map((option) => option.id));
+                    }
                 }
                 catch {
                     // Keep the last usable catalog when an optional discovery source is down.
@@ -463,6 +511,101 @@ export function createAcpDriver(support) {
                 }
                 return servers;
             };
+            /** 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.
              *  The child is NOT killed here — a clean settle leaves it pooled for
@@ -473,6 +616,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())
@@ -565,7 +709,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);
@@ -584,9 +728,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)
@@ -884,12 +1032,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,
@@ -925,6 +1087,7 @@ export function createAcpDriver(support) {
                         appendNative(threadId, { dir: "in", source: SOURCE, msg: nativeLogMessage(msg) });
                         // 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)) {
@@ -1026,8 +1189,12 @@ export function createAcpDriver(support) {
                     return { turnId };
                 }
                 const resolvedModel = support.resolveTurnModel?.(turn.model, env);
-                support.applyTurnEnv?.(env, { model: resolvedModel, requestedModel: turn.model, fullAuto: turnConfig.fullAuto === true });
-                const cliTurn = resolvedModel !== undefined && resolvedModel !== turn.model
+                support.applyTurnEnv?.(env, {
+                    model: resolvedModel, requestedModel: turn.model, fullAuto: turnConfig.fullAuto === true, botId: turn.botId, cwd,
+                });
+                // Rebound once, before the prompt, when a fallbackModel support swaps
+                // a model this session does not offer for one it does.
+                let cliTurn = resolvedModel !== undefined && resolvedModel !== turn.model
                     ? { ...turn, model: resolvedModel }
                     : turn;
                 const mcpServers = acpMcpServers(turn);
@@ -1067,7 +1234,31 @@ 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 contractKey = JSON.stringify([launch.command, launch.args ?? [], spawnArgs, cwd, turnConfig.fullAuto === true, envFingerprint]);
+                // 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.
+                const contractKey = JSON.stringify([
+                    launch.command, launch.args ?? [], spawnArgs, cwd,
+                    support.sessionScopedApproval ? null : turnConfig.fullAuto === true, envFingerprint,
+                    support.spawnFingerprint?.(spawnEnv) ?? null,
+                ]);
+                // The new-session default model rides the spawn env but stays out of
+                // the fingerprint above: only session/new reads it, and a pooled
+                // process switches later models over the wire as before.
+                const launchModel = support.sessionModelEnv && cliTurn.model && /^[\w.:/-]{1,200}$/u.test(cliTurn.model)
+                    && accountModels?.has(cliTurn.model) ? cliTurn.model : undefined;
+                const launchEnv = support.sessionModelEnv && launchModel
+                    ? { ...spawnEnv, [support.sessionModelEnv]: launchModel }
+                    : spawnEnv;
+                // whether this turn's process was started by this turn: its model
+                // list is then current, not a pooled process's older one
+                let launchedThisTurn = false;
+                const launchSession = () => {
+                    const opened = openSession(threadId, launch, [...(launch.args ?? []), ...spawnArgs], launchEnv, cwd, contractKey);
+                    opened.launchModel = launchModel;
+                    launchedThisTurn = true;
+                    return opened;
+                };
                 const sessionKey = JSON.stringify(mcpServers);
                 if (turn.sessionReset) {
                     closeSession(threadId, "reset");
@@ -1092,14 +1283,14 @@ export function createAcpDriver(support) {
                         else
                             closeSession(threadId, "contract");
                     }
-                    session = openSession(threadId, launch, [...(launch.args ?? []), ...spawnArgs], spawnEnv, cwd, contractKey);
+                    session = launchSession();
                     sessions.set(threadId, session);
                 }
                 // `session` rebinds mid-turn: when the establishment retry below
                 // 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) => {
@@ -1107,6 +1298,16 @@ export function createAcpDriver(support) {
                     rejectStartup = reject;
                 }) : null;
                 const asks = new Map();
+                // What this turn reports and applies. A model fallback (below)
+                // replaces both: a saved variant belongs to the model it replaced.
+                let reportedModel = turn.model;
+                let variant = turn.variant;
+                // set below when this process lists fewer models than the catalog
+                let staleProcess = false;
+                // Set while a sessionScopedApproval support applies this turn's mode.
+                // Still set if that throws: the pooled session may be left on an
+                // earlier turn's looser mode, so its process must not be reused.
+                let approvalUnconfirmed = false;
                 const modelOf = (result) => {
                     const option = (Array.isArray(result?.configOptions) ? result.configOptions : []).find((entry) => entry?.id === (support.selectModel?.configId ?? "model"));
                     return typeof option?.currentValue === "string" ? option.currentValue : null;
@@ -1122,7 +1323,7 @@ export function createAcpDriver(support) {
                     emit({
                         ...base(threadId, turnId),
                         type: "session.model-variants",
-                        model: nativeModel === cliTurn.model ? (turn.model ?? nativeModel) : nativeModel,
+                        model: nativeModel === cliTurn.model ? (reportedModel ?? nativeModel) : nativeModel,
                         variants: {
                             options: option?.options ?? [],
                             ...(option?.currentValue !== undefined ? { currentValue: option.currentValue } : {}),
@@ -1133,8 +1334,8 @@ export function createAcpDriver(support) {
                     if (!support.modelVariants)
                         throw new Error(`${support.displayName} does not support model variants`);
                     const option = acpVariantOption(session.sessionConfigResult);
-                    if (!option || !option.options.some((entry) => entry.id === turn.variant)) {
-                        throw new Error(`${support.displayName} does not advertise variant ${turn.variant} for this model`);
+                    if (!option || !option.options.some((entry) => entry.id === variant)) {
+                        throw new Error(`${support.displayName} does not advertise variant ${variant} for this model`);
                     }
                     return option;
                 };
@@ -1157,6 +1358,7 @@ export function createAcpDriver(support) {
                     asks,
                     runningTools: new Set(),
                     interruptTimer: null,
+                    stopQuietWatch: null,
                     flushAssistantText,
                     receiveModelVariants,
                 };
@@ -1182,6 +1384,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
@@ -1304,7 +1507,7 @@ export function createAcpDriver(support) {
                                 // session/new on the replacement child.
                                 session.current = null;
                                 closeSession(threadId, "reestablish");
-                                session = openSession(threadId, launch, [...(launch.args ?? []), ...spawnArgs], spawnEnv, cwd, contractKey);
+                                session = launchSession();
                                 sessions.set(threadId, session);
                                 session.current = current;
                                 runtimeAcceptsImages = await handshake();
@@ -1352,6 +1555,43 @@ export function createAcpDriver(support) {
                             if (support.selectModel) {
                                 const { configId } = support.selectModel;
                                 selectedModel = modelOf(session.sessionConfigResult);
+                                const wanted = cliTurn.model;
+                                const offered = offeredModels(session.sessionConfigResult, configId);
+                                // A process started without a default model lists exactly
+                                // what this account offers.
+                                if (support.sessionModelEnv && !session.launchModel && offered.length)
+                                    accountModels = new Set(offered);
+                                // The instance catalog lists the model but a pooled process
+                                // does not: the process is older than the catalog (a provider
+                                // added since it started). That is no reason to run another
+                                // model. The switch below fails with the runtime's own words,
+                                // and the process is closed so the retry starts on a fresh
+                                // one. A process this turn started is current, so there the
+                                // catalog is the stale one and the fallback applies.
+                                staleProcess = Boolean(support.fallbackModel && wanted && !launchedThisTurn && offered.length
+                                    && !offered.includes(wanted) && models.options.some((option) => option.id === wanted));
+                                // A local inject writes its provider for this turn, so a
+                                // process started earlier may not list it yet: never replace it.
+                                if (support.fallbackModel && offered.length && !skipSubscriptionAuthForLocalInject(turn.model)
+                                    && !staleProcess && (!wanted || !offered.includes(wanted))) {
+                                    const fallback = support.fallbackModel(session.sessionConfigResult, models.default);
+                                    if (fallback && fallback !== wanted && offered.includes(fallback)) {
+                                        const notice = wanted ? `${wanted}\n${fallback}` : null;
+                                        if (notice && session.fallbackNotice !== notice) {
+                                            session.fallbackNotice = notice;
+                                            emit({
+                                                ...base(threadId, turnId),
+                                                type: "runtime.notice",
+                                                message: `${support.displayName} no longer offers ${wanted}, so this conversation uses ${fallback}. ` +
+                                                    "Choose another model for this bot to stop seeing this.",
+                                            });
+                                        }
+                                        cliTurn = { ...cliTurn, model: fallback };
+                                        current.turn = cliTurn;
+                                        reportedModel = fallback;
+                                        variant = undefined;
+                                    }
+                                }
                                 if (cliTurn.model && cliTurn.model !== selectedModel) {
                                     sessionResult = await request("session/set_config_option", { sessionId, configId, value: cliTurn.model }, INIT_TIMEOUT, receiveModelVariants);
                                     selectedModel = modelOf(session.sessionConfigResult);
@@ -1363,6 +1603,7 @@ export function createAcpDriver(support) {
                                 }
                             }
                             if (support.configureSession) {
+                                approvalUnconfirmed = support.sessionScopedApproval === true;
                                 await support.configureSession({
                                     request: (method, params, timeoutMs) => request(method, params, timeoutMs ?? SESSION_CONFIG_TIMEOUT),
                                     sessionId,
@@ -1372,17 +1613,18 @@ export function createAcpDriver(support) {
                                         ? sessionResult.models.availableModels
                                         : [],
                                 });
+                                approvalUnconfirmed = false;
                                 // initialize's currentModelId is the CLI default,
                                 // not the model this turn asked for. After a successful pin,
                                 // report the slug we set so the UI does not claim otherwise.
                                 if (!selectedModel && cliTurn.model)
                                     selectedModel = cliTurn.model;
                             }
-                            if (turn.variant !== undefined) {
+                            if (variant !== undefined) {
                                 const option = requestedVariantOption();
-                                await request("session/set_config_option", { sessionId, configId: option.configId, value: turn.variant }, SESSION_CONFIG_TIMEOUT, receiveModelVariants);
-                                if (requestedVariantOption().currentValue !== turn.variant) {
-                                    throw new Error(`${support.displayName} did not apply variant ${turn.variant}`);
+                                await request("session/set_config_option", { sessionId, configId: option.configId, value: variant }, SESSION_CONFIG_TIMEOUT, receiveModelVariants);
+                                if (requestedVariantOption().currentValue !== variant) {
+                                    throw new Error(`${support.displayName} did not apply variant ${variant}`);
                                 }
                             }
                         }
@@ -1403,12 +1645,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)
@@ -1421,7 +1666,7 @@ export function createAcpDriver(support) {
                         if (support.modelVariants && cliTurn.model && modelOf(session.sessionConfigResult) !== cliTurn.model) {
                             throw new Error(`${support.displayName} changed model before the prompt`);
                         }
-                        if (turn.variant !== undefined && requestedVariantOption().currentValue !== turn.variant) {
+                        if (variant !== undefined && requestedVariantOption().currentValue !== variant) {
                             throw new Error(`${support.displayName} changed variant before the prompt`);
                         }
                         if (state.settled || state.stopped || session.closing)
@@ -1429,23 +1674,62 @@ 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.
                         const usage = result?.usage ?? result?._meta ?? {};
                         if (typeof usage.inputTokens === "number" || typeof usage.outputTokens === "number") {
+                            // opencode 1.18.25 keeps only the uncached share in inputTokens
+                            // and reports cache reads beside it (omitted when 0); some
+                            // agents count them inside inputTokens. `input` is the whole
+                            // prompt with `cachedInput` naming its cached part — the same
+                            // convention as the Claude driver and the store — and
+                            // totalTokens tells the two wire shapes apart. Cache writes
+                            // stay out of `input`, exactly as in the Claude driver, and an
+                            // absent cache count emits the bare shape with no cachedInput
+                            // key: absent is not zero.
+                            const input = usage.inputTokens ?? 0;
+                            const output = usage.outputTokens ?? 0;
+                            const cachedRead = typeof usage.cachedReadTokens === "number" && usage.cachedReadTokens > 0
+                                ? usage.cachedReadTokens
+                                : null;
+                            const exclusive = cachedRead !== null
+                                && (typeof usage.totalTokens !== "number"
+                                    || usage.totalTokens >= input + output + cachedRead);
                             emit({
                                 ...base(threadId, turnId),
                                 type: "thread.token-usage.updated",
-                                input: usage.inputTokens ?? 0,
-                                output: usage.outputTokens ?? 0,
+                                input: cachedRead !== null && exclusive ? input + cachedRead : input,
+                                output,
+                                ...(cachedRead !== null
+                                    ? { cachedInput: exclusive ? cachedRead : Math.min(cachedRead, input) }
+                                    : {}),
                             });
                         }
                         const reason = result?.stopReason;
@@ -1468,6 +1752,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);
@@ -1475,12 +1764,19 @@ export function createAcpDriver(support) {
                             // classifier is preferred; loginNote remains a compatibility
                             // fallback for existing ACP supports.
                             const needsAuth = code === "invalid_credentials" || code === "inactive_subscription"
-                                || message === support.loginNote;
+                                || code === "insufficient_funds" || message === support.loginNote;
+                            // A key, credit, quota or subscription problem is the account's,
+                            // not the process's: the child that reported it is healthy, so it
+                            // stays pooled and the retry after a fix starts warm.
+                            const accountError = isAccountError(code);
                             const failure = classifyError({ text: message });
                             const transientStartup = failure.transient || (failure.reason === "unknown" && code === "upstream_outage");
                             const denied = /\b(?:(?:permission|access) denied|(?:approval|permission) (?:required|denied|rejected)|requires? (?:approval|permission)|policy (?:restriction|violation)|(?:blocked|denied|restricted) by (?:the )?policy)\b/i.test(message);
-                            if (turn.startupRecovery && transientStartup && !needsAuth && !denied && (!code || code === "upstream_outage")
-                                && ![-32700, -32600, -32601, -32602].includes(e?.code)
+                            // An unconfirmed approval switch sent no prompt and its process
+                            // is discarded either way, so a fresh one can take the turn.
+                            const retryableStartup = approvalUnconfirmed || (transientStartup && (!code || code === "upstream_outage")
+                                && ![-32700, -32600, -32601, -32602].includes(e?.code));
+                            if (turn.startupRecovery && retryableStartup && !needsAuth && !accountError && !denied
                                 && !state.promptSent && !state.startupActivity && !state.producedItem && !state.text
                                 && !state.stopped && !session.closing && !asks.size && !current.runningTools.size) {
                                 // Quiesce before killing: the child's close event must not
@@ -1508,7 +1804,7 @@ export function createAcpDriver(support) {
                             emit({
                                 ...base(threadId, turnId),
                                 type: "runtime.error",
-                                message,
+                                message: accountError ? support.describeAccountError?.(code, cliTurn.model) ?? message : message,
                                 ...(needsAuth ? { setup: true } : {}),
                             });
                             // Internal RPC failures can leave a live child poisoned just
@@ -1516,10 +1812,20 @@ export function createAcpDriver(support) {
                             // start the next turn. Never replay this accepted prompt: it
                             // may already have executed tools. The next explicit turn can
                             // resume the recorded session on a fresh process.
-                            if (!needsAuth && (e?.acpPromptStall === true || e?.acpSessionFailure === true
+                            if (!needsAuth && !accountError && (e?.acpPromptStall === true || e?.acpSessionFailure === true
                                 || code === "upstream_outage") && session.child.exitCode === null && !session.closing) {
                                 closeSession(threadId, e?.acpPromptStall === true ? "prompt-stall" : "rpc-failure");
                             }
+                            else if (approvalUnconfirmed && session.child.exitCode === null && !session.closing) {
+                                // Fail closed: the session may still hold a looser mode from
+                                // an earlier turn. Nothing was prompted; the next turn starts
+                                // a fresh process, whose session begins in the runtime's own
+                                // default mode, and applies its mode there.
+                                closeSession(threadId, "approval-unconfirmed");
+                            }
+                            else if (staleProcess && !state.promptSent && session.child.exitCode === null && !session.closing) {
+                                closeSession(threadId, "stale-models");
+                            }
                             settle(threadId, session, false, needsAuth ? "auth_required" : "rpc_error");
                         }
                     }