openmausbot 0.1.92 → 0.1.93

package/dist-server/server/drivers/acp/quiet-status.js

@@ -0,0 +1,257 @@
+// What an ACP agent is doing while it sends nothing.
+//
+// ACP has no "still working" message, and agents go quiet for minutes in
+// normal work: Qwen Code 0.24 says nothing over the wire while it waits out
+// a rate limit, while its SDK retries a request, or while one slow model
+// call runs. Silence alone cannot tell that from a wedged process, so a
+// quiet turn is probed from outside: the agent's own debug log where it
+// keeps one, and the process tree's open connections and CPU time. The
+// result becomes a plain-words notice in the chat, so the person is never
+// left watching a spinner without knowing why.
+import { execFile } from "node:child_process";
+import { closeSync, fstatSync, openSync, readSync } from "node:fs";
+/** Qwen Code's debug log (QWEN_DEBUG_LOG_FILE=1), lines like
+ *  `2026-10-02T02:50:41.757Z [WARN] [RETRY] Attempt 1 failed with status 429. Retrying after explicit delay of 20000ms...`.
+ *  Only the facts worth telling a person are parsed; every other line still
+ *  counts as proof the process is alive. */
+export function parseQwenLogLine(line) {
+    if (line.includes("[RETRY]") && /\bAttempt \d+ failed\b/.test(line)) {
+        const attempt = /\bAttempt (\d+) failed/.exec(line);
+        const status = /\bwith status (\d{3})\b/.exec(line);
+        const explicit = /explicit delay of (\d+)\s*ms/.exec(line);
+        const seconds = /Retrying in (\d+)\s*s\b/.exec(line);
+        return {
+            kind: "retry",
+            attempt: attempt ? Number(attempt[1]) : null,
+            status: status ? Number(status[1]) : null,
+            delayMs: explicit ? Number(explicit[1]) : seconds ? Number(seconds[1]) * 1000 : null,
+        };
+    }
+    if (/\[compaction\] hard-tier rescue triggered|Reactive compression|tryCompress/.test(line)
+        && !/succeeded|failed|skipped|stopped/.test(line)) {
+        return { kind: "compressing" };
+    }
+    const gate = /\[compaction\] cheap-gate NOOP: effectiveTokens=(\d+), auto=(\d+)/.exec(line);
+    if (gate)
+        return { kind: "context", tokens: Number(gate[1]), threshold: Number(gate[2]) };
+    return null;
+}
+/** Reads the lines appended to a log file since the last read. A file that
+ *  does not exist yet is simply empty; the first read skips what was already
+ *  there, so an old conversation's log is not replayed as news. */
+export class LogTail {
+    offset = null;
+    partial = "";
+    path;
+    maxBytes;
+    constructor(path, maxBytes = 256 * 1024) {
+        this.path = path;
+        this.maxBytes = maxBytes;
+    }
+    read() {
+        let fd;
+        try {
+            fd = openSync(this.path, "r");
+        }
+        catch {
+            if (this.offset === null)
+                this.offset = 0;
+            return [];
+        }
+        try {
+            const size = fstatSync(fd).size;
+            if (this.offset === null) {
+                this.offset = size;
+                return [];
+            }
+            // truncated or replaced: start over from its beginning
+            if (size < this.offset) {
+                this.offset = 0;
+                this.partial = "";
+            }
+            if (size === this.offset)
+                return [];
+            // a burst bigger than the cap keeps only its tail
+            const start = Math.max(this.offset, size - this.maxBytes);
+            if (start > this.offset)
+                this.partial = "";
+            const buf = Buffer.alloc(size - start);
+            readSync(fd, buf, 0, buf.length, start);
+            this.offset = size;
+            const text = this.partial + buf.toString("utf8");
+            const lines = text.split(/\r?\n/);
+            this.partial = lines.pop() ?? "";
+            return lines.filter((l) => l.trim());
+        }
+        catch {
+            return [];
+        }
+        finally {
+            try {
+                closeSync(fd);
+            }
+            catch { }
+        }
+    }
+}
+const run = (file, args, timeoutMs = 4_000) => new Promise((resolve) => {
+    execFile(file, args, { timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024, windowsHide: true }, (err, stdout) => {
+        // lsof exits 1 when it finds nothing to list; its stdout is still the answer
+        if (err && !(typeof stdout === "string" && err.code === 1))
+            resolve(null);
+        else
+            resolve(String(stdout));
+    });
+});
+/** `ps` TIME: [[dd-]hh:]mm:ss[.cc] */
+function psTimeMs(raw) {
+    const m = /^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+(?:\.\d+)?)$/.exec(raw.trim());
+    if (!m)
+        return null;
+    const [, d, h, min, s] = m;
+    return ((Number(d ?? 0) * 24 + Number(h ?? 0)) * 60 + Number(min)) * 60_000 + Number(s) * 1000;
+}
+/** The root and every descendant, from a `pid ppid ...` table. */
+export function treePids(rows, root) {
+    const kids = new Map();
+    for (const r of rows) {
+        const list = kids.get(r.ppid);
+        if (list)
+            list.push(r.pid);
+        else
+            kids.set(r.ppid, [r.pid]);
+    }
+    const out = [];
+    const queue = [root];
+    while (queue.length && out.length < 512) {
+        const pid = queue.shift();
+        if (out.includes(pid))
+            continue;
+        out.push(pid);
+        queue.push(...(kids.get(pid) ?? []));
+    }
+    return out;
+}
+async function samplePosix(root) {
+    const table = await run("ps", ["-A", "-o", "pid=,ppid=,time="]);
+    if (table === null)
+        return { cpuMs: null, connections: null };
+    const rows = [];
+    for (const line of table.split("\n")) {
+        const [pid, ppid, time] = line.trim().split(/\s+/);
+        if (!pid || !ppid || !time)
+            continue;
+        rows.push({ pid: Number(pid), ppid: Number(ppid), cpuMs: psTimeMs(time) });
+    }
+    const pids = treePids(rows, root);
+    if (!rows.some((r) => r.pid === root))
+        return { cpuMs: null, connections: null };
+    let cpuMs = 0;
+    for (const r of rows)
+        if (pids.includes(r.pid))
+            cpuMs += r.cpuMs ?? 0;
+    const lsof = await run("lsof", ["-nP", "-a", "-p", pids.join(","), "-iTCP", "-sTCP:ESTABLISHED", "-Fn"]);
+    // -Fn prints one `n<addr>` line per connection
+    const connections = lsof === null ? null : lsof.split("\n").filter((l) => l.startsWith("n")).length;
+    return { cpuMs, connections };
+}
+async function sampleWindows(root) {
+    const script = "$ErrorActionPreference='SilentlyContinue';" +
+        "$all=Get-CimInstance Win32_Process|Select-Object ProcessId,ParentProcessId,KernelModeTime,UserModeTime;" +
+        `$ids=@(${root});$q=@(${root});` +
+        "while($q.Count){$p=$q[0];$q=@($q|Select-Object -Skip 1);foreach($c in $all|Where-Object{$_.ParentProcessId -eq $p}){if($ids -notcontains $c.ProcessId){$ids+=$c.ProcessId;$q+=$c.ProcessId}}};" +
+        "$cpu=($all|Where-Object{$ids -contains $_.ProcessId}|ForEach-Object{[double]$_.KernelModeTime+[double]$_.UserModeTime}|Measure-Object -Sum).Sum/10000;" +
+        "$n=@(Get-NetTCPConnection -State Established|Where-Object{$ids -contains $_.OwningProcess}).Count;" +
+        "Write-Output \"$cpu $n\"";
+    const out = await run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], 8_000);
+    const [cpu, n] = (out ?? "").trim().split(/\s+/);
+    const cpuMs = Number(cpu);
+    const connections = Number(n);
+    return {
+        cpuMs: cpu !== undefined && Number.isFinite(cpuMs) ? cpuMs : null,
+        connections: n !== undefined && Number.isFinite(connections) ? connections : null,
+    };
+}
+/** CPU time and open connections of a process and its children. Best
+ *  effort: a missing tool or a refused query reads as null (unknown), never
+ *  as "idle". */
+export function sampleProcessTree(pid) {
+    return (process.platform === "win32" ? sampleWindows(pid) : samplePosix(pid))
+        .catch(() => ({ cpuMs: null, connections: null }));
+}
+/** CPU a process tree can burn on bookkeeping while doing no real work. */
+const BUSY_CPU_MS_PER_MIN = 3_000;
+export function classifyQuiet(input) {
+    const { logged, sample, previous } = input;
+    if (logged?.kind === "retry")
+        return { kind: "retrying", status: logged.status, delayMs: logged.delayMs, attempt: logged.attempt };
+    if (logged?.kind === "compressing")
+        return { kind: "compressing" };
+    const nearFullContext = input.context !== null && input.context.threshold > 0
+        && input.context.tokens >= input.context.threshold * 0.9;
+    if (sample.connections !== null && sample.connections > 0)
+        return { kind: "waiting-model", nearFullContext };
+    const cpuDelta = sample.cpuMs !== null && previous?.cpuMs != null ? sample.cpuMs - previous.cpuMs : null;
+    if (cpuDelta !== null && input.sinceMs > 0 && cpuDelta > BUSY_CPU_MS_PER_MIN * (input.sinceMs / 60_000))
+        return { kind: "busy" };
+    if (sample.connections === 0 && cpuDelta !== null)
+        return { kind: "no-signs" };
+    return { kind: "unknown" };
+}
+/** Two states read the same to a person when this matches; a notice is
+ *  sent only when it changes. */
+export function quietKey(state) {
+    if (state.kind === "retrying")
+        return `retrying:${state.attempt ?? "?"}:${state.status ?? "?"}`;
+    if (state.kind === "waiting-model")
+        return `waiting-model:${state.nearFullContext}`;
+    return state.kind;
+}
+const minutes = (ms) => {
+    if (ms < 90_000)
+        return `${Math.max(1, Math.round(ms / 1000))} s`;
+    return `${Math.round(ms / 60_000)} min`;
+};
+/** The chat notice for a quiet state. */
+export function describeQuiet(name, state, quietMs, stopAfterMs) {
+    const quiet = minutes(quietMs);
+    switch (state.kind) {
+        case "retrying": {
+            const why = state.status === 429 ? "hit a rate limit (HTTP 429)"
+                : state.status !== null && state.status >= 500 ? `got a server error from its model provider (HTTP ${state.status})`
+                    : state.status !== null ? `got an error from its model provider (HTTP ${state.status})`
+                        : "had a failed model request";
+            const next = state.delayMs !== null ? ` Next try in ${Math.max(1, Math.round(state.delayMs / 1000))} s.` : "";
+            const attempt = state.attempt !== null ? ` (attempt ${state.attempt + 1})` : "";
+            return `${name} ${why} and is retrying${attempt}.${next} It is still working.`;
+        }
+        case "compressing":
+            return `${name} is compressing its conversation history to make room. This can take a few minutes; it is still working.`;
+        case "waiting-model":
+            return state.nearFullContext
+                ? `${name} is waiting on its model: no reply for ${quiet}, but its request is still open. Its history is nearly full, so it may be compressing it.`
+                : `${name} is waiting on its model: no reply for ${quiet}, but its request is still open. Slow models and rate limits look like this.`;
+        case "busy":
+            return `${name} is busy on this computer but has sent nothing for ${quiet}.`;
+        case "between-requests":
+            return `${name} has sent nothing for ${quiet} and has no request open to its model right now. ` +
+                "It may be waiting before a retry. Still waiting; press Stop to end the turn.";
+        case "no-signs":
+            return `${name} has sent nothing for ${quiet}, has no open request to its model, and is not using the CPU. It may be stuck. ` +
+                `Press Stop to end the turn; otherwise it is stopped after ${minutes(stopAfterMs)} of silence.`;
+        case "unknown":
+            return `${name} has sent nothing for ${quiet}. Still waiting; press Stop to end the turn.`;
+    }
+}
+/** A short phrase for the final stuck error: what the agent looked like last. */
+export function lastSeenPhrase(state) {
+    switch (state.kind) {
+        case "retrying": return "retrying a failed model request";
+        case "compressing": return "compressing its history";
+        case "waiting-model": return "waiting on its model with a request open";
+        case "busy": return "busy on this computer";
+        case "between-requests": return "no request open to its model";
+        case "no-signs": return "no open request and no CPU use";
+        case "unknown": return "no readable process state";
+    }
+}

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

@@ -6,6 +6,7 @@ import { createHash } from "node:crypto";
 import { join } from "node:path";
 import { qualifiedModelLabel } from "../../contracts.js";
 import { harnessHome } from "../../env-path.js";
+import { parseQwenLogLine } from "./quiet-status.js";
 import { decodeInjectId, hostApiKey, localHost, mergeLocalInject } from "../local-inject.js";
 import { createAcpDriver } from "./core.js";
 const EMPTY = { default: "", options: [] };
@@ -199,6 +200,15 @@ export function resolveQwenTurnModel(model, env) {
         throw new Error("This Qwen model is no longer configured. Refresh models and select it again.");
     return matches[0].id;
 }
+/** Where Qwen Code 0.24 writes a session's debug log: `<runtime dir>/debug/<session id>.txt`,
+ * the runtime dir being QWEN_RUNTIME_DIR, else QWEN_HOME, else ~/.qwen. */
+export function qwenDebugLogPath(env, sessionId) {
+    const off = ["", "0", "false", "off", "no"].includes((env.QWEN_DEBUG_LOG_FILE ?? "").trim().toLowerCase());
+    if (off || !/^[\w-]{1,128}$/.test(sessionId))
+        return null;
+    const base = env.QWEN_RUNTIME_DIR || env.QWEN_HOME || harnessHome("qwen", env);
+    return join(base, "debug", `${sessionId}.txt`);
+}
 /** Qwen Code's own approval ladder, passed through (qwen --help, 0.24):
  * `--approval-mode default` asks, `auto-edit` approves file edits, `auto`
  * runs Qwen's LLM classifier that approves safe actions and blocks risky
@@ -243,5 +253,13 @@ const support = {
     authFailure: "continue",
     isAuthenticated: () => true,
     buildPromptText: (turn) => (turn.system ? `${turn.system}\n\n${turn.text}` : turn.text),
+    // Qwen says nothing over ACP while it retries a rate limit or compresses
+    // its history, but its debug log does. Turn the log on (unless the person
+    // turned it off) and read it while a prompt is quiet.
+    transformEnv: (env) => {
+        if (env.QWEN_DEBUG_LOG_FILE === undefined)
+            env.QWEN_DEBUG_LOG_FILE = "1";
+    },
+    statusLog: { path: qwenDebugLogPath, parse: parseQwenLogLine },
 };
 export const QwenAgentDriver = createAcpDriver(support);

package/dist-server/server/drivers/builtIn.js

@@ -15,6 +15,7 @@ import { HermesAgentDriver } from "./acp/hermes.js";
 import { OpenAICompatDriver } from "./openai-compat.js";
 import { PiDriver } from "./pi.js";
 import { MistralDriver } from "./mistral.js";
+import { CerebrasDriver } from "./cerebras.js";
 import { MinimaxDriver } from "./minimax.js";
 export const BUILT_IN_DRIVERS = [
     GrokDriver,
@@ -35,4 +36,5 @@ export const BUILT_IN_DRIVERS = [
     BoatAgentDriver,
     MinimaxDriver,
     MistralDriver,
+    CerebrasDriver,
 ];

package/dist-server/server/drivers/cerebras.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { createOpenAIChatRuntime } from "./openai-chat.js";
+// Cerebras serves open models on wafer-scale chips: same OpenAI chat
+// contract, several times the tokens per second of a GPU cloud.
+const DEFAULT_URL = "https://api.cerebras.ai/v1";
+// The account tier is unknown: use the shared free-tier limit, not paid 128K.
+// https://inference-docs.cerebras.ai/models/overview
+const DEFAULT_MODELS = {
+    default: "gpt-oss-120b",
+    options: [
+        { id: "gpt-oss-120b", label: "GPT OSS 120B", contextWindow: 65536 },
+        { id: "qwen-3.8-27b", label: "Qwen3.8 27B", contextWindow: 65536 },
+    ],
+};
+const configSchema = z.object({
+    url: z.string().trim().url().default(DEFAULT_URL),
+    model: z.string().trim().min(1).optional(),
+    tools: z.boolean().optional(),
+});
+function decodeConfig(raw) {
+    const config = configSchema.parse(raw ?? {});
+    config.url = config.url.replace(/\/+$/, "");
+    const url = new URL(config.url);
+    if (url.protocol !== "https:" && !(url.protocol === "http:" &&
+        ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))) {
+        throw new Error("Cerebras requires HTTPS, except for a local test endpoint.");
+    }
+    return config;
+}
+const modelCard = z.object({ id: z.string().min(1) });
+/** Cerebras answers "Only 'text' content type can be used" for these. */
+const TEXT_ONLY_MODELS = /^(?:gpt-oss|llama3\.1-8b|llama-3\.3-70b)/i;
+export const CerebrasDriver = {
+    driverKind: "cerebras",
+    metadata: { displayName: "Cerebras (API)", supportsMultipleInstances: true, access: "api" },
+    models: DEFAULT_MODELS,
+    install: {
+        docsUrl: "https://cloud.cerebras.ai/",
+        settings: "connections",
+        signInCommand: "Save a Cerebras API key in Settings → Connections, or set CEREBRAS_API_KEY on the server.",
+    },
+    decodeConfig,
+    defaultConfig: () => decodeConfig({}),
+    async create(input) {
+        const { config } = input;
+        const apiKey = (input.environment.CEREBRAS_API_KEY ?? process.env.CEREBRAS_API_KEY ?? "").trim();
+        const known = new Map(DEFAULT_MODELS.options.map((option) => [option.id, option]));
+        const withConfiguredModel = (options) => {
+            const preferred = config.model ?? DEFAULT_MODELS.default;
+            if (config.model && !options.some((option) => option.id === config.model)) {
+                options = [{ id: config.model, label: config.model }, ...options];
+            }
+            return { default: options.some((option) => option.id === preferred) ? preferred : options[0].id, options };
+        };
+        let catalog = withConfiguredModel(DEFAULT_MODELS.options);
+        const refreshModels = async () => {
+            if (!apiKey)
+                return;
+            try {
+                const response = await fetch(`${config.url}/models`, {
+                    headers: { authorization: `Bearer ${apiKey}` },
+                    redirect: "error",
+                    signal: AbortSignal.timeout(8_000),
+                });
+                if (!response.ok)
+                    return;
+                const json = await response.json();
+                const rows = Array.isArray(json) ? json : z.object({ data: z.array(z.unknown()) }).parse(json).data;
+                const options = [];
+                const seen = new Set();
+                for (const row of rows) {
+                    const parsed = modelCard.safeParse(row);
+                    if (!parsed.success || !parsed.data.id.trim() || seen.has(parsed.data.id))
+                        continue;
+                    seen.add(parsed.data.id);
+                    options.push(known.get(parsed.data.id) ?? { id: parsed.data.id, label: parsed.data.id });
+                }
+                if (options.length)
+                    catalog = withConfiguredModel(options);
+            }
+            catch {
+                // A failed refresh keeps the last usable catalog, including custom models.
+            }
+        };
+        if (apiKey)
+            void refreshModels();
+        return createOpenAIChatRuntime({
+            input, driverKind: "cerebras", apiKey, apiUrl: config.url,
+            tools: config.tools, models: () => catalog, refreshModels, reasoning: true,
+            reasoningReplayField: "reasoning",
+            computerUse: true, imageInput: (model) => !TEXT_ONLY_MODELS.test(model),
+            nudgeAnnouncedAction: true,
+            requestBody: (model, messages, stream) => ({
+                model, messages, stream,
+                ...(stream ? { stream_options: { include_usage: true } } : {}),
+            }),
+            httpErrorLabel: "Cerebras",
+            missingKeyError: "Save a Cerebras API key in Settings → Connections, or set CEREBRAS_API_KEY.",
+            unavailableReason: "No Cerebras API key — open Settings → Connections.",
+            timeoutMs: 180_000, billing: "metered", includeUsageInCompleted: true,
+            nativeLog: {
+                source: "cerebras.chat.completions",
+                outgoing: (_turn, messages, model) => ({ model, messageCount: messages.length }),
+                incoming: ({ text, reasoning, usage }) => ({ textLength: text.length, reasoningLength: reasoning.length, usage }),
+            },
+        });
+    },
+};

package/dist-server/server/drivers/chat-mcp-tools.js

@@ -266,6 +266,22 @@ function boundedText(value) {
         end -= 1;
     return `${bytes.subarray(0, end).toString()}\n[MCP result truncated at 50KB; request less output.]`;
 }
+/** Optional fields a tool documents as "omit to use the default", where a
+ * blank string is an error instead. Smaller models fill optional fields with
+ * "" rather than leaving them out; dropping the blank restores the documented
+ * call. agent_browser_read: "Omit url to read the active tab." */
+const BUILT_IN_BROWSER_BLANK_MEANS_OMITTED = {
+    agent_browser_read: ["url"],
+};
+function omitBlankDefaults(builtInBrowser, tool, args) {
+    if (!builtInBrowser || !object(args))
+        return;
+    for (const field of BUILT_IN_BROWSER_BLANK_MEANS_OMITTED[tool] ?? []) {
+        const value = args[field];
+        if (typeof value === "string" && !value.trim())
+            delete args[field];
+    }
+}
 export async function mountChatTools(integrations, signal, computerUse = false) {
     const servers = [];
     if (computerUse && integrations?.computer)
@@ -316,12 +332,12 @@ export async function mountChatTools(integrations, signal, computerUse = false)
             // image delivery, including custom servers. Text stays bounded below.
             const client = "boxId" in descriptor ? new ChatBoatClient(descriptor) : new ChatMcpClient(descriptor, computerUse);
             clients.push(client);
-            return { name, client, tools: await client.tools(signal) };
+            return { name, client, builtInBrowser: descriptor === integrations?.browser, tools: await client.tools(signal) };
         }));
         for (const mount of mounts) {
             if (mount.status === "rejected")
                 throw mount.reason;
-            const { name: server, client, tools } = mount.value;
+            const { name: server, client, builtInBrowser, tools } = mount.value;
             const originalNames = new Set();
             for (const tool of tools) {
                 if (!object(tool) || typeof tool.name !== "string" || !tool.name.trim() || originalNames.has(tool.name))
@@ -352,7 +368,7 @@ export async function mountChatTools(integrations, signal, computerUse = false)
                     const suffix = `_${index}`;
                     name = base.slice(0, 64 - suffix.length) + suffix;
                 }
-                registered.set(name, { client, name: tool.name, schema });
+                registered.set(name, { client, builtInBrowser, name: tool.name, schema });
                 definitions.push({ type: "function", function: { name, description, parameters } });
                 if (Buffer.byteLength(JSON.stringify(definitions)) > CATALOG_BYTES)
                     throw new Error("MCP tool catalog exceeds the 1MB limit");
@@ -371,6 +387,7 @@ export async function mountChatTools(integrations, signal, computerUse = false)
         const tool = registered.get(name);
         if (!tool)
             throw new Error("The requested tool was not advertised for this turn");
+        omitBlankDefaults(tool.builtInBrowser, tool.name, args);
         if (!object(args) || !tool.schema(args))
             throw new Error("Tool arguments do not match the advertised input schema; use its required fields and types");
     };

package/dist-server/server/drivers/claude.js

@@ -1032,11 +1032,18 @@ export const ClaudeDriver = {
         // harness snapshots every instance whenever it describes them — app
         // load, the Engines page, and right after `claude update`, which is
         // exactly when the answer changes — so a turn normally finds it filled.
-        // Most turns before any snapshot assume a current CLI. A coordinated
-        // turn checks first because the snapshot-refresh flag is newer than the
+        // Most flags before any snapshot assume a current CLI; autocompact
+        // requires confirmed help support. A coordinated turn checks first
+        // because the snapshot-refresh flag is newer than the
         // other context controls and an unknown flag would reject that request.
         let cliVersion = null;
         let cliVersionChecked = false;
+        // Whether `claude --help` lists --autocompact, read once per CLI version
+        // by snapshot(). The flag is not in every build above its version floor
+        // (2.1.129 rejects it), so the listing wins over the floor; null until
+        // probed, or when the probe fails.
+        let cliHasAutocompact = null;
+        let cliHelpVersion = null;
         const readCliVersion = (env) => new Promise((resolve) => {
             execCli(config.cli, ["--version"], { timeout: 8000, env }, (err, stdout) => resolve(err ? null : stdout.trim() || null));
         });
@@ -1230,7 +1237,7 @@ export const ClaudeDriver = {
                     args.push("--setting-sources", "project");
             }
             const compactWindow = autoCompactWindow(turnEnvironment);
-            if (compactWindow && claudeCliSupports(cliVersion, "--autocompact")) {
+            if (compactWindow && cliHasAutocompact === true) {
                 args.push("--autocompact", compactWindow);
             }
             // An old pair conversation can still carry its first assignment in
@@ -2263,6 +2270,13 @@ export const ClaudeDriver = {
                 return { state: "unavailable", reason: `\`${config.cli}\` CLI not found` };
             cliVersion = parseClaudeCliVersion(version);
             cliVersionChecked = true;
+            if (version !== cliHelpVersion) {
+                const help = await new Promise((resolve) => {
+                    execCli(config.cli, ["--help"], { timeout: 8000, env }, (err, stdout) => resolve(err ? null : stdout));
+                });
+                cliHasAutocompact = help === null ? null : /^\s*--autocompact\b/m.test(help);
+                cliHelpVersion = version;
+            }
             const update = claudeCliUpdate(version, config.cli);
             const warning = claudeInheritWarning(env);
             if (config.requireApiKey) {

package/dist-server/server/drivers/openai-chat.js

@@ -30,6 +30,17 @@ const usageFrom = (usage) => usage
 const asError = (value) => value instanceof Error ? value : new Error(String(value));
 class UnsupportedChatToolsError extends Error {
 }
+const NUDGE_ANNOUNCED_ACTION = "You said what you would do next but called no tool. Do it now with your tools, or reply with your final answer if nothing is left to do.";
+/** A short reply that only announces a next step, with nothing to answer. */
+export function announcesAction(text) {
+    const reply = text.trim();
+    if (!reply || reply.length > 400 || reply.includes("?"))
+        return false;
+    return /(?:[:\u2014\u2013]|\.\.\.|\u2026)$/.test(reply) ||
+        /^(?:checking|let me|i'll|i will|i'm going to|i am going to|opening|pulling|looking|searching|navigating|reading|fetching|loading|now (?:i'll|let me|opening|checking|pulling|reading))\b/i.test(reply);
+}
+const TEXT_ONLY_ATTACHMENT_NOTE = "[The person attached image(s), but this model cannot see images. Say so if the request depends on them.]";
+const TEXT_ONLY_SCREENSHOT_NOTE = "[Screenshot not shown: this model cannot see images. Read the page with a snapshot or a text tool instead.]";
 function rejectsToolsParameter(status, body) {
     if (status !== 400 && status !== 422)
         return false;
@@ -282,6 +293,7 @@ export function createOpenAIChatRuntime(options) {
                 clearTimeout(idleTimer);
         }
     };
+    const seesImages = (turn) => options.imageInput?.(turn.model || options.models().default) ?? true;
     const messagesFor = (turn) => {
         // The system message is the head of the resent prefix, so only the
         // stable half belongs there: a volatile edit must not re-price the
@@ -302,7 +314,9 @@ export function createOpenAIChatRuntime(options) {
                 role: message.role,
                 content: message.text,
             })),
-            { role: "user", content: options.computerUse ? chatUserContent(userTurn) : userTurn.text },
+            { role: "user", content: !options.computerUse ? userTurn.text
+                    : seesImages(turn) ? chatUserContent(userTurn)
+                        : userTurn.images?.length ? `${userTurn.text}\n\n${TEXT_ONLY_ATTACHMENT_NOTE}` : userTurn.text },
         ];
     };
     const sendTurn = async (turn) => {
@@ -381,6 +395,7 @@ export function createOpenAIChatRuntime(options) {
             let toolFailed = false;
             const denials = [];
             const seenCalls = new Set();
+            let nudged = false;
             try {
                 tools = await mountChatTools(options.tools === false ? undefined : turn.integrations, abort.signal, options.computerUse);
                 let optionalQuestionOnly = options.tools !== false && tools.definitions.length === 0;
@@ -490,6 +505,11 @@ export function createOpenAIChatRuntime(options) {
                         if (completion.finishReason && completion.finishReason !== "stop") {
                             throw new ChatProtocolError(`provider did not finish the response (${completion.finishReason})`);
                         }
+                        if (options.nudgeAnnouncedAction && !nudged && tools.definitions.length && announcesAction(completion.text)) {
+                            nudged = true;
+                            messages.push({ role: "assistant", content: completion.text }, { role: "user", content: NUDGE_ANNOUNCED_ACTION });
+                            continue;
+                        }
                         if (toolFailed) {
                             stopReason = "tool_error";
                             throw new ChatProtocolError("One or more tool operations failed or were denied. See the tool results; the final response is not an execution receipt.");
@@ -508,7 +528,7 @@ export function createOpenAIChatRuntime(options) {
                     if (seenCalls.size > MAX_CHAT_TOOL_CALLS)
                         throw new ChatProtocolError("tool-call limit reached");
                     messages.push({ role: "assistant", content: completion.text || null, tool_calls: completion.toolCalls,
-                        ...(completion.protocolReasoning && !reasoningReplayRejected.has(model) ? { reasoning_content: completion.protocolReasoning } : {}),
+                        ...(completion.protocolReasoning && !reasoningReplayRejected.has(model) ? { [options.reasoningReplayField ?? "reasoning_content"]: completion.protocolReasoning } : {}),
                         ...(completion.protocolReasoningDetails.length ? { reasoning_details: completion.protocolReasoningDetails } : {}),
                     });
                     const screenshotParts = [];
@@ -573,6 +593,10 @@ export function createOpenAIChatRuntime(options) {
                                 started = true;
                                 if (allowed) {
                                     result = await tools.execute(call.function.name, args, abort.signal);
+                                    if (result.images?.length && !seesImages(turn)) {
+                                        const { images: _dropped, ...rest } = result;
+                                        result = { ...rest, text: `${rest.text}\n${TEXT_ONLY_SCREENSHOT_NOTE}` };
+                                    }
                                     if (result.images?.length) {
                                         try {
                                             assertImageTransport(options.apiUrl);

package/dist-server/server/drivers/prompt-split.js

@@ -57,6 +57,8 @@ export function readPromptSplitReceipt(scope, key) {
                     stable: record.stable,
                     volatile: record.volatile,
                     ...(typeof record.turnsSinceFull === "number" ? { turnsSinceFull: record.turnsSinceFull } : {}),
+                    ...(typeof record.lastUsed === "number" && record.lastUsed > 0 ? { lastUsed: record.lastUsed } : {}),
+                    ...(typeof record.peakUsed === "number" && record.peakUsed > 0 ? { peakUsed: record.peakUsed } : {}),
                 };
             }
         }

package/dist-server/server/env-path.js

@@ -64,8 +64,9 @@ function knownDirs() {
  * invisible until it restarts, because Windows never pushes PATH changes
  * into a live process. Scanning the standard install locations recovers
  * those without a restart — `~/.grok/bin` (the x.ai installer) and
- * `%APPDATA%\npm` (global npm shims), plus `%LOCALAPPDATA%\agy\bin`, cover
- * every engine we ship an install command for. */
+ * `%APPDATA%\npm` (global npm shims), plus `%LOCALAPPDATA%\agy\bin` and
+ * `%LOCALAPPDATA%\cursor-agent`, cover every engine we ship an install
+ * command for. */
 function windowsKnownDirs() {
     const home = homedir();
     const appData = process.env.APPDATA ?? join(home, "AppData", "Roaming");
@@ -74,12 +75,15 @@ function windowsKnownDirs() {
         join(appData, "npm"), // npm -g shims: claude, codex
         join(home, ".grok", "bin"), // x.ai installer
         join(localAppData, "agy", "bin"), // Antigravity installer
+        // Cursor installer: cursor-agent.* and its `agent` copies (MOCA-272)
+        join(localAppData, "cursor-agent"),
         join(home, ".local", "bin"), // claude native installer
         join(home, ".claude", "local"),
         join(home, "bin"), // Factory droid installer (%USERPROFILE%\bin)
         join(home, ".bun", "bin"),
         join(home, ".deno", "bin"),
         join(home, "go", "bin"),
+        join(process.env.ProgramFiles ?? "C:\\Program Files", "Docker", "Docker", "resources", "bin"), // Docker Desktop installer
     ];
 }
 let cached = null;