openmausbot 0.1.92 → 0.1.93

package/dist-server/server/boat.js

@@ -923,9 +923,9 @@ export async function verifyToken(token) {
         return { ok: false, message: "Couldn't reach boat.dev to check that token — check your connection and retry." };
     }
 }
-/** A rejected Cloud Pro relay token: nothing the person pasted, so nothing
- * for them to fix in Settings. */
-const INCLUDED_BOAT_UNAVAILABLE = "Cloud Pro's included cloud computers aren't available right now. Try again later.";
+/** A rejected Cloud relay token: nothing the person pasted, so nothing
+ * for them to fix in Settings. Plan-neutral: every Cloud plan includes them. */
+const INCLUDED_BOAT_UNAVAILABLE = "The cloud computers included with your Cloud plan aren't available right now. Try again later.";
 /** Turn a provider refusal into something a person can act on. The
  * provider's own message is better than anything we can invent — it knows
  * the plan, the limit and the link — so prefer it and only fall back to

package/dist-server/server/cloud-owner.js

@@ -29,7 +29,7 @@
 import { lstatSync, readFileSync } from "node:fs";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.js";
-export const CLOUD_PERSONAL_REFUSAL = "Cloud Pro is personal: only your own devices can connect.";
+export const CLOUD_PERSONAL_REFUSAL = "OMB Cloud is personal: only your own devices can connect.";
 const KEY = /^p_[\w-]{22}$/;
 const keys = z.array(z.string().regex(KEY)).max(100_000);
 const recordFile = z.object({

package/dist-server/server/computer-control.js

@@ -71,6 +71,12 @@ export class ComputerControl {
         });
         return { snapshot: this.changed(botId), owned: true, acquired: true };
     }
+    /** Whether this workspace lease is the one holding the wheel right now.
+     * Read-only: unlike `acquireLease`, a free computer is not taken. */
+    ownsLease(botId, controlLeaseId) {
+        const entry = this.entries.get(botId);
+        return entry?.heldSinceMs != null && entry.controlLeaseId === controlLeaseId;
+    }
     /** The person hands the wheel back. Also settles any open help request —
      * the waiting bot resumes from this one state change. */
     release(botId) {

package/dist-server/server/config.js

@@ -388,6 +388,7 @@ const appConfigSchema = z.object({
         phone: z.enum(["ios", "android"]).optional(),
     }).optional(),
     mistral: z.object({ key: optionalText }).optional(),
+    cerebras: z.object({ key: optionalText }).optional(),
     xai: z.object({ key: optionalText, url: optionalText }).optional(),
     /** Anthropic API key for Claude Code billed per token, handed only to
      * Claude instances; `url` only for a proxy or a test double. Never a
@@ -884,6 +885,9 @@ export function loadConfig() {
     cfg.mistral = { ...cfg.mistral };
     if (process.env.MISTRAL_API_KEY !== undefined)
         cfg.mistral.key = process.env.MISTRAL_API_KEY;
+    cfg.cerebras = { ...cfg.cerebras };
+    if (process.env.CEREBRAS_API_KEY !== undefined)
+        cfg.cerebras.key = process.env.CEREBRAS_API_KEY;
     cfg.xai = { ...cfg.xai };
     if (process.env.XAI_API_KEY !== undefined)
         cfg.xai.key = process.env.XAI_API_KEY;
@@ -961,6 +965,7 @@ export function syncCredentialEnv(patch) {
     const secrets = [
         [patch.xai?.key, "XAI_API_KEY"],
         [patch.mistral?.key, "MISTRAL_API_KEY"],
+        [patch.cerebras?.key, "CEREBRAS_API_KEY"],
         [patch.anthropic?.key, "OMB_ANTHROPIC_API_KEY"],
         [patch.openaiCompat?.key, "OPENAI_COMPAT_API_KEY"],
         [patch.openai?.key, "OMB_OPENAI_API_KEY"],
@@ -1007,6 +1012,7 @@ export function syncCredentialEnv(patch) {
 export const WORKSPACE_CREDENTIAL_ENV = [
     "XAI_API_KEY",
     "MISTRAL_API_KEY",
+    "CEREBRAS_API_KEY",
     "OMB_ANTHROPIC_API_KEY",
     "OMB_ANTHROPIC_API_URL",
     "OMB_HOSTED_MODEL_TOKEN",
@@ -1079,6 +1085,7 @@ export const PROVIDER_CREDENTIAL_ENV = [
     "OPENCODE_API_KEY",
     "XAI_API_KEY",
     "MISTRAL_API_KEY",
+    "CEREBRAS_API_KEY",
     "CURSOR_API_KEY",
     "CURSOR_AUTH_TOKEN",
 ];
@@ -1111,7 +1118,7 @@ export function saveConfig(patch, options = {}) {
     const storedProfiles = storedBrowserProfilesSchema.safeParse(disk.browserProfiles);
     if (storedProfiles.success)
         disk.browserProfiles = storedProfiles.data;
-    for (const key of ["xai", "anthropic", "mistral", "openai", "openrouter", "openaiCompat", "composio", "box", "opencodeGo", "tts", "decider", "imageGen", "profile", "rooms", "threads", "context", "memory", "localVm", "features", "cloudOverflow", "budgets", "billing", "decisions", "onboarding", "browserEngine", "newBots"]) {
+    for (const key of ["xai", "anthropic", "mistral", "cerebras", "openai", "openrouter", "openaiCompat", "composio", "box", "opencodeGo", "tts", "decider", "imageGen", "profile", "rooms", "threads", "context", "memory", "localVm", "features", "cloudOverflow", "budgets", "billing", "decisions", "onboarding", "browserEngine", "newBots"]) {
         const section = checkedPatch[key];
         if (!section)
             continue;
@@ -1340,6 +1347,8 @@ export function instanceOwnsRouting(cfg, entry, routingDefaults) {
                 || ownUrl(routingDefaults?.url || cfg.openaiCompat?.url || process.env.OPENAI_COMPAT_URL || "https://openrouter.ai/api/v1");
         case "mistral":
             return own(entry.environment?.MISTRAL_API_KEY) || ownUrl("https://api.mistral.ai/v1");
+        case "cerebras":
+            return own(entry.environment?.CEREBRAS_API_KEY) || ownUrl("https://api.cerebras.ai/v1");
         case "grok":
             return own(entry.environment?.XAI_API_KEY) || (own(config.apiKeyEnv) && config.apiKeyEnv !== "XAI_API_KEY")
                 || ownUrl("https://api.x.ai/v1", cfg.xai?.url);
@@ -1357,6 +1366,8 @@ function injectedEnvironment(cfg, instanceId, driver) {
     const environment = new Map();
     if (driver === "mistral" && cfg.mistral?.key)
         environment.set("MISTRAL_API_KEY", cfg.mistral.key);
+    if (driver === "cerebras" && cfg.cerebras?.key)
+        environment.set("CEREBRAS_API_KEY", cfg.cerebras.key);
     if (driver === "grok" && cfg.xai?.key)
         environment.set("XAI_API_KEY", cfg.xai.key);
     // The workspace Anthropic key reaches Claude Code as the variable it
@@ -1453,6 +1464,7 @@ export function instanceConfigs(cfg) {
         computer: { driver: "boxAgent" },
         openaiCompat: { driver: "openai-compat" },
         mistral: { driver: "mistral" },
+        cerebras: { driver: "cerebras" },
         ...API_KEY_FLEET,
         qwen: { driver: "qwenAgent" },
         hermes: { driver: "hermesAgent" },
@@ -1471,6 +1483,7 @@ export function instanceConfigs(cfg) {
         cursor: { driver: "cursorAgent" },
         openaiCompat: { driver: "openai-compat" },
         mistral: { driver: "mistral" },
+        cerebras: { driver: "cerebras" },
         ...API_KEY_FLEET,
         ...CUSTOM_ONLY,
     };

package/dist-server/server/container-computer.js

@@ -82,7 +82,7 @@ export function poolLocalVmTarget(seat) {
         label: `pool-${seat}`,
     };
 }
-/** Only provisioning creates this durable directory; idle removal keeps it. */
+/** Only provisioning creates this durable directory; idle shutdown keeps it. */
 export function localVmWorkspaceExists(target) {
     try {
         return lstatSync(target.workspaceDir, { throwIfNoEntry: false })?.isDirectory() === true;
@@ -269,6 +269,7 @@ function emptyStatus(platform, target) {
         desktopReady: false,
         desktop_error: null,
         create_supported: true,
+        resumable: false,
         ready: false,
         problem: "Install a supported container runtime first",
         image_ref: IMAGE,
@@ -283,21 +284,8 @@ function emptyStatus(platform, target) {
         viewer_url: target.viewerPort ? `http://127.0.0.1:${target.viewerPort}/vnc.html` : "",
     };
 }
-/** Whether a turn may recreate this Local VM itself instead of failing.
- *
- * True for exactly one state: the container is gone, and a plain `run` is all
- * that is needed to bring it back. That is what `LocalVmIdleTimer` leaves
- * behind — it removes an unused Local VM rather than pausing it — so a turn
- * arriving after an idle period should not have to send the person to App
- * Settings for a container the app itself deleted.
- *
- * Every other problem in `statusProblem` stays the person's call and returns
- * false here: no runtime, daemon down, image never prepared, `create_supported`
- * false, and any existing container — stale image, unmanaged, unsafe network,
- * security or persistence. A stopped container is excluded deliberately, since
- * `statusProblem` says this desktop image cannot safely resume and asks for a
- * recreate rather than a start.
- */
+/** Recreate a missing desktop when its image and runtime are already prepared.
+ * This also recovers desktops deleted by older versions' idle cleanup. */
 export function localVmRecreatableOnDemand(status) {
     return Boolean(status.runtime)
         && status.daemonUp
@@ -305,12 +293,28 @@ export function localVmRecreatableOnDemand(status) {
         && status.container === "missing"
         && status.create_supported;
 }
+/** Start only an existing, compatible desktop with the managed safety boundary.
+ * Fails closed on fields left "unknown" by a partial inspect, which
+ * `statusProblem` alone would let through. */
+export function localVmResumable(status) {
+    return Boolean(status.runtime) && status.daemonUp && status.image && status.container === "stopped"
+        && existingContainerProblem(status) === null
+        && status.network === "loopback" && status.security === "hardened" && status.persistence === "durable";
+}
+/** What a turn may do on its own to bring this Local VM up, if anything. */
+export function localVmWakeAction(status) {
+    if (localVmRecreatableOnDemand(status))
+        return "run";
+    if (localVmResumable(status))
+        return "start";
+    return null;
+}
 /** Whether Auto may attach this Local VM without a person choosing it: the
- * desktop is ready, or its image is prepared and the container can simply be
- * recreated after idling away. Anything else — no runtime, daemon down, image
+ * desktop is ready, a compatible stopped desktop can be started, or its image
+ * is prepared and a missing container can be recreated. Anything else — no runtime, daemon down, image
  * never prepared, an unmanaged or unsafe container — stays the person's call. */
 export function autoLocalVmAttachable(status) {
-    return status.ready === true || localVmRecreatableOnDemand(status);
+    return status.ready === true || localVmWakeAction(status) !== null;
 }
 function statusProblem(status) {
     if (!status.runtime)
@@ -324,6 +328,19 @@ function statusProblem(status) {
     }
     if (status.container === "missing")
         return "Create the Local VM";
+    const existing = existingContainerProblem(status);
+    if (existing)
+        return existing;
+    if (status.container === "stopped")
+        return "The Local VM is stopped; start it to continue";
+    if (status.desktop_error)
+        return `The Local VM desktop failed to start: ${status.desktop_error}`;
+    if (!status.desktopReady)
+        return "The Local VM started, but Cua Driver is not ready yet";
+    return null;
+}
+/** Problems with an existing container that only a recreate fixes. */
+function existingContainerProblem(status) {
     if (!status.imageMatches)
         return "The existing Local VM uses an older desktop or Cua Driver; recreate it";
     if (!status.managed)
@@ -334,12 +351,6 @@ function statusProblem(status) {
         return "The existing Local VM is missing safety limits; recreate it";
     if (status.persistence === "unsafe")
         return "The existing Local VM is missing its durable folder; recreate it";
-    if (status.container === "stopped")
-        return "This desktop image cannot safely resume; recreate the Local VM";
-    if (status.desktop_error)
-        return `The Local VM desktop failed to start: ${status.desktop_error}`;
-    if (!status.desktopReady)
-        return "The Local VM started, but Cua Driver is not ready yet";
     return null;
 }
 /** Shared with the BYO-VPS backend (vps-computer.ts): both containers are
@@ -457,6 +468,7 @@ export async function containerComputerStatus(runner = sh, platform = process.pl
             const inspected = JSON.parse(stdout);
             const detail = inspected[0];
             status.container = detail?.State?.Running ? "running" : "stopped";
+            status.stopped_at = status.container === "stopped" ? detail?.State?.FinishedAt ?? null : null;
             status.network = dockerPortsAreLocal(detail?.HostConfig?.PortBindings) ? "loopback" : "unsafe";
             status.viewer_port = dockerViewerPort(detail?.NetworkSettings?.Ports, target.viewerPort);
             status.imageMatches =
@@ -530,6 +542,7 @@ export async function containerComputerStatus(runner = sh, platform = process.pl
     }
     status.problem = statusProblem(status);
     status.ready = status.problem === null;
+    status.resumable = localVmResumable(status);
     return status;
 }
 function loopback(address) {
@@ -597,8 +610,8 @@ function appleWorkspaceMountIsSafe(mounts, platform, expectedWorkspace) {
  * runtime-specific capability exception is Podman's Firefox sandbox chroot.
  * Callers also differ on restart policy — the VPS
  * container must survive a reboot nobody is watching ("unless-stopped"),
- * while the Local VM must NOT auto-resume: its desktop leaves a stale X lock
- * on stop, so a restarted container is a broken one. */
+ * while Local VM starts remain controlled by OMB's idle policy and turn
+ * lifecycle rather than a daemon restart policy. */
 export function dockerSecurityIsHardened(config, options = {}) {
     if (!config)
         return false;
@@ -727,10 +740,8 @@ export async function containerComputerAction(action, runner = sh, platform = pr
     if (action === "run" && !before.create_supported) {
         throw Object.assign(new Error(before.problem ?? "This runtime cannot create a per-bot Local VM"), { status: 409 });
     }
-    if (action === "start") {
-        throw Object.assign(new Error("This desktop image cannot safely resume; remove and recreate the Local VM"), {
-            status: 409,
-        });
+    if (action === "start" && !localVmResumable(before)) {
+        throw Object.assign(new Error(before.problem ?? "The Local VM is not stopped"), { status: 409 });
     }
     if (action === "stop" && before.container !== "running") {
         throw Object.assign(new Error("The Local VM is not running"), { status: 409 });
@@ -943,7 +954,7 @@ export function setupCommands(runtime, platform = process.platform, target = SHA
         run: runtime === "container" && target.key !== SHARED_LOCAL_VM_TARGET.key
             ? null
             : command(containerRunArgs(runtime, "CHANGE_ME", target)),
-        start: null,
+        start: command(["start", target.containerName]),
         stop: command(["stop", target.containerName]),
         remove: command(["rm", runtime === "container" ? "--force" : "-f", target.containerName]),
         view: target.viewerPort ? `http://127.0.0.1:${target.viewerPort}/vnc.html` : "",

package/dist-server/server/digest.js

@@ -1,3 +1,4 @@
+import { toolIdentity } from "../shared/tool-name.js";
 /** Evidence is observed, not inferred from a provider's brand. In particular,
  * OpenAI-compatible and Grok turns now expose structured tool activity too. */
 export function coverageForDriver(_driverKind, fullResults = false, observedTools = false) {
@@ -20,13 +21,19 @@ export function buildTurnDigest(input) {
     for (const m of input.activities) {
         if (m.kind !== "activity" || !m.tool?.itemId || m.turnId !== input.turnId)
             continue;
-        const entry = byName.get(m.tool.name) ?? { name: fitBytes(m.tool.name, 160), count: 0, failed: 0 };
+        // by identity, not by the chip's title: a command-titled chip would
+        // otherwise be its own bucket and carry the unredacted command line into
+        // a row that is FTS-indexed and replayed into rebuilt context
+        const identity = toolIdentity(m.tool.name);
+        const entry = byName.get(identity) ?? { name: fitBytes(identity, 160), count: 0, failed: 0 };
         entry.count += 1;
         if (m.tool.ok === false)
             entry.failed += 1;
+        // the driver's summary is the bounded, redacted one-line command; the
+        // title is neither, so a shell bucket says what it ran only through this
         if (entry.sample === undefined && m.tool.summary)
             entry.sample = fitBytes(m.tool.summary.replace(/\s+/g, " "), 300);
-        byName.set(m.tool.name, entry);
+        byName.set(identity, entry);
     }
     // busiest first; ties keep first-seen order (Map preserves insertion)
     const ranked = [...byName.values()].sort((a, b) => b.count - a.count);
@@ -78,6 +85,9 @@ function firstSentence(reply) {
 export function renderDigest(d) {
     const parts = ["[digest]"];
     if (d.tools.length) {
+        // every entry ends at "×N" or "(N failed)": the phones split the tools
+        // part on exactly that (ios DigestSummary, android TurnDigest), so a
+        // shell bucket's sample stays in the stored digest, not in this line
         const tools = d.tools.map((t) => `${t.name} ×${t.count}${t.failed ? ` (${t.failed} failed)` : ""}`).join(", ");
         parts.push(`tools: ${tools}${d.toolsDropped ? ` +${d.toolsDropped} more` : ""}${d.hookCoverage === "preview" ? " (from tool previews)" : ""}`);
     }

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.
@@ -87,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
@@ -96,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`
@@ -495,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
@@ -505,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())
@@ -597,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);
@@ -616,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)
@@ -916,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,
@@ -957,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)) {
@@ -1159,7 +1290,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) => {
@@ -1227,6 +1358,7 @@ export function createAcpDriver(support) {
                     asks,
                     runningTools: new Set(),
                     interruptTimer: null,
+                    stopQuietWatch: null,
                     flushAssistantText,
                     receiveModelVariants,
                 };
@@ -1252,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
@@ -1512,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)
@@ -1538,13 +1674,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 +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);

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;