openmausbot 0.1.92 → 0.1.94

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

@@ -4,10 +4,13 @@
 // The generic protocol runtime lives in acp/core.ts; this file is only the
 // per-harness quirks. Verified against grok 1.0.0.
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { harnessHome } from "../../env-path.js";
+import { dirname, join, resolve } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { parse as parseYaml } from "yaml";
+import { harnessHome, splitCliString } from "../../env-path.js";
 import { decodeInjectId, hostApiKey, localHost, mergeLocalInject } from "../local-inject.js";
 import { createAcpDriver } from "./core.js";
+import { allowsTool, canUseMcpServer, narrowsNativeTools, parseToolScope } from "../../../shared/tool-scope.js";
 export const STATIC_GROK_MODELS = {
     default: "grok-4.7",
     options: [
@@ -181,6 +184,140 @@ export function grokAcceptsUnadvertisedImages(init) {
     const version = /^1\.0\.(\d+)$/.exec(meta.agentVersion);
     return Boolean(version && Number(version[1]) >= 25);
 }
+// Original names in the official 1.0.41 default registry, not arbitrary
+// owner strings forwarded into Grok's inherit-all profile allowlist.
+const GROK_NATIVE_TOOLS = [
+    ["read_file", "GrokBuild:read_file"], ["search_replace", "GrokBuild:search_replace"], ["write", "OpenCode:write"],
+    ["run_terminal_command", "GrokBuild:run_terminal_cmd"], ["list_dir", "GrokBuild:list_dir"], ["grep", "GrokBuild:grep"],
+    ["kill_command_or_subagent", "GrokBuild:kill_task"], ["todo_write", "GrokBuild:todo_write"],
+    ["get_command_or_subagent_output", "GrokBuild:get_task_output"], ["spawn_subagent", "GrokBuild:task"],
+    ["scheduler_create", "GrokBuild:scheduler_create"], ["scheduler_delete", "GrokBuild:scheduler_delete"], ["scheduler_list", "GrokBuild:scheduler_list"],
+    ["monitor", "GrokBuild:monitor"], ["search_tool", "GrokBuild:search_tool"], ["use_tool", "GrokBuild:use_tool"],
+    ["workflow", "GrokBuild:workflow"], ["enter_plan_mode", "GrokBuild:enter_plan_mode"], ["exit_plan_mode", "GrokBuild:exit_plan_mode"],
+    ["ask_user_question", "GrokBuild:ask_user_question"], ["send_feedback", "GrokBuild:send_feedback"],
+    ["image_gen", "GrokBuild:image_gen"], ["image_edit", "GrokBuild:image_edit"],
+    ["image_to_video", "GrokBuild:image_to_video"], ["reference_to_video", "GrokBuild:reference_to_video"],
+];
+/** Read a supported on-disk profile rather than overriding its restriction. */
+export function grokInheritedProfile(cli, env, cwd) {
+    const unsupported = () => { throw new Error("Grok's existing agent profile cannot be safely intersected with tool selection. Use a profile file with explicit tools or a separate default Grok account."); };
+    if ((env.GROK_AGENT && env.GROK_AGENT !== "grok-build") || env.GROK_CONFIG || env.GROK_CONFIG_PATH)
+        return unsupported();
+    const args = splitCliString(cli);
+    // Operator filters are applied after ACP's profile by the CLI. Refuse
+    // unverified overrides rather than replacing an inherited restriction.
+    if (args.some(arg => /^(--tools|--disallowed-tools|--disallowedTools|--agent)(=|$)/.test(arg)))
+        return unsupported();
+    const flags = args.flatMap((arg, index) => arg === "--agent-profile" || arg.startsWith("--agent-profile=") ? [index] : []);
+    if (flags.length > 1)
+        return unsupported();
+    const flag = flags[0] ?? -1;
+    let path = flag >= 0 ? (args[flag].includes("=") ? args[flag].slice(args[flag].indexOf("=") + 1) : args[flag + 1]) : undefined;
+    if (flag >= 0 && (!path || path.startsWith("-")))
+        return unsupported();
+    const files = [join(env.GROK_HOME || harnessHome("grok", env), "config.toml")];
+    for (let directory = resolve(cwd);;) {
+        const file = join(directory, ".grok", "config.toml");
+        if (!files.includes(file))
+            files.push(file);
+        const parent = dirname(directory);
+        if (parent === directory)
+            break;
+        directory = parent;
+    }
+    for (const file of files) {
+        if (!existsSync(file))
+            continue;
+        const text = readFileSync(file, "utf8");
+        if (text.length > 262_144)
+            return unsupported();
+        // Support a deliberately small, unambiguous TOML subset. Scan the whole
+        // file: quoted/dotted keys, inline agent tables and multiline constructs
+        // must never be silently missed by a section regex. Unsupported syntax
+        // refuses this scoped turn; ordinary unrestricted turns are unaffected.
+        let section = "";
+        for (const line of text.split(/\r?\n/).map(line => line.trim()).filter(line => line && !line.startsWith("#"))) {
+            const header = /^\[([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)\]\s*(?:#.*)?$/.exec(line);
+            if (header) {
+                section = header[1];
+                if (section.startsWith("agent."))
+                    return unsupported();
+                continue;
+            }
+            const assignment = /^([A-Za-z0-9_-]+)\s*=\s*(.+)$/.exec(line);
+            if (!assignment || /'''|"""/.test(assignment[2]) || (!section && assignment[1] === "agent"))
+                return unsupported();
+            if (section !== "agent")
+                continue;
+            const match = /^(name|definition)\s*=\s*("(?:[^"\\]|\\.)*"|'[^']*')\s*(?:#.*)?$/.exec(line);
+            if (!match)
+                return unsupported();
+            let value;
+            try {
+                value = match[2].startsWith('"') ? JSON.parse(match[2]) : match[2].slice(1, -1);
+            }
+            catch {
+                return unsupported();
+            }
+            // Grok expands environment variables in paths. Do not resolve a
+            // different literal file or fall back when that contract is unknown.
+            if (value.includes("$") || !value)
+                return unsupported();
+            if (match[1] === "name" && value !== "grok-build")
+                return unsupported();
+            if (match[1] === "definition" && flag < 0) {
+                if (path !== undefined && path !== value)
+                    return unsupported();
+                path = value;
+            }
+        }
+    }
+    if (!path)
+        return;
+    const text = readFileSync(resolve(cwd, path), "utf8");
+    if (text.length > 262_144)
+        return unsupported();
+    const match = /^\s*---\r?\n([\s\S]*?)\r?\n---(?:\r?\n([\s\S]*))?$/.exec(text);
+    if (!match)
+        return unsupported();
+    const profile = parseYaml(match[1]);
+    if (!profile || typeof profile.name !== "string" || typeof profile.description !== "string"
+        || (profile.tools !== undefined && (!Array.isArray(profile.tools) || !profile.tools.every((tool) => typeof tool === "string")))
+        || (profile.disallowedTools !== undefined && (!Array.isArray(profile.disallowedTools) || !profile.disallowedTools.every((tool) => typeof tool === "string"))))
+        return unsupported();
+    const toolConfig = profile.toolConfig ?? { tools: GROK_NATIVE_TOOLS.map(([name, id]) => ({ id, name_override: name })) };
+    if (!Array.isArray(toolConfig.tools) || !toolConfig.tools.every((tool) => typeof tool?.id === "string" && (tool.name_override === undefined || typeof tool.name_override === "string")))
+        return unsupported();
+    return { ...profile, name: profile.name, description: profile.description, toolConfig, ...(match[2]?.trim() ? { promptBody: match[2].trim() } : {}) };
+}
+/** A curated registry: empty/unknown selections never inherit Grok's defaults. */
+export function grokToolScopeProfile(scope, init, inherited, hasMcp = false) {
+    const parsed = parseToolScope(scope);
+    if (!parsed.ok)
+        throw new Error(parsed.error);
+    const meta = init?._meta;
+    if (meta?.grokShell !== true || meta.agentVersion !== "1.0.41") {
+        throw new Error("This Grok runtime does not have verified native tool selection. Use Grok 1.0.41 or Pi; update Grok support before using another version.");
+    }
+    if (hasMcp && (!allowsTool(scope, { kind: "native", name: "search_tool" }) || !allowsTool(scope, { kind: "native", name: "use_tool" }))) {
+        throw new Error("Grok requires native:search_tool and native:use_tool to find and call selected MCP tools. Allow both explicitly or use Pi.");
+    }
+    const candidates = inherited?.toolConfig.tools ?? GROK_NATIVE_TOOLS.map(([name, id]) => ({ id, name_override: name }));
+    const selected = candidates.filter((tool) => {
+        const name = tool.name_override ?? GROK_NATIVE_TOOLS.find(([, id]) => id === tool.id)?.[0];
+        return name !== undefined && allowsTool(scope, { kind: "native", name })
+            && (!inherited?.tools?.length || inherited.tools.includes(name) || inherited.tools.includes(tool.id))
+            && !inherited?.disallowedTools?.some((denied) => denied === name || denied === tool.id);
+    });
+    // Grok rejects an empty curated construction. A real read entry explicitly
+    // disabled by its exact native name constructs an empty final registry.
+    return {
+        ...inherited, name: inherited?.name ?? "openmausbot-tools", description: inherited?.description ?? "Owner-selected tools",
+        injectDefaultTools: false, discoverSkills: false,
+        toolConfig: { ...inherited?.toolConfig, tools: selected.length ? selected : [{ id: "GrokBuild:read_file", name_override: "read_file" }] },
+        tools: [], disallowedTools: [...new Set([...(inherited?.disallowedTools ?? []), ...(selected.length ? [] : ["read_file"])])],
+    };
+}
 const support = {
     driverKind: "grokAgent",
     displayName: "Grok",
@@ -225,17 +362,69 @@ const support = {
             ? "bypassPermissions"
             : turn.approvalMode === "auto" ? "auto" : turn.approvalMode === "edits" ? "acceptEdits" : "default",
         "agent",
+        ...(turn.toolScope !== undefined ? ["--no-leader"] : []),
         ...(turn.model ? ["-m", turn.model] : []),
         // long form on purpose: `--effort` is documented as an alias, and an
         // alias is the part a CLI is free to rename
         ...(turn.effort ? ["--reasoning-effort", turn.effort] : []),
         "stdio",
     ],
+    toolScopeSessionParams: (turn, init, hasMcp, { config, env, cwd }) => {
+        if (!narrowsNativeTools(turn.toolScope))
+            return {};
+        const profile = grokToolScopeProfile(turn.toolScope, init, grokInheritedProfile(config.cli, env, cwd), hasMcp);
+        // Establish on the selected model. Changing harnesses after session/new
+        // can discard an ACP profile and restore the model's default tools.
+        if (turn.model)
+            profile.model = ensureGrokInjectSlug(turn.model, env);
+        return { _meta: { agentProfile: profile } };
+    },
+    toolScopeCacheKey: ({ config, env, cwd }) => JSON.stringify(grokInheritedProfile(config.cli, env, cwd) ?? null),
     // -m on argv is necessary but not sufficient: session/new still starts on
     // [models].default. Pin the slug over the wire, same as Hermes/Droid.
-    async configureSession({ request, sessionId, turn }) {
+    async configureSession({ request, sessionId, turn, currentModelId }) {
+        if (turn.toolScope !== undefined) {
+            const available = new Set([
+                ...(turn.integrations?.agents ? ["agents"] : []), ...(turn.integrations?.composio ? ["composio"] : []),
+                ...(turn.integrations?.browser ? ["browser"] : []), ...(turn.integrations?.localComputer ? ["computer"] : []),
+                ...Object.keys(turn.integrations?.custom ?? {}),
+            ].filter((name) => canUseMcpServer(turn.toolScope, name)));
+            const deadline = Date.now() + 10_000;
+            for (;;) {
+                const reply = await request("_x.ai/mcp/list", { sessionId, cache: true }, 10_000);
+                const catalog = reply?.result;
+                if (!Array.isArray(catalog?.servers))
+                    throw new Error("Grok could not confirm its MCP catalog. No prompt was sent.");
+                for (const server of catalog.servers) {
+                    if (server?.session?.enabled === false)
+                        continue;
+                    if (!available.has(server?.name))
+                        throw new Error("Grok has an MCP connection outside the bot's selection. Disable native MCP connections before using tool selection. No prompt was sent.");
+                    if (Array.isArray(server?.session?.tools) && server.session.tools.some((tool) => typeof tool.name !== "string" || !allowsTool(turn.toolScope, { kind: "mcp", server: server.name, name: tool.name }))) {
+                        throw new Error("Grok could not enforce the selected MCP catalog. No prompt was sent.");
+                    }
+                }
+                if (catalog.sessionMcpResolved === true) {
+                    if ([...available].some((name) => !catalog.servers.some((server) => server.name === name && server.session?.enabled === true && server.session.status === "ready"))) {
+                        throw new Error("Grok could not connect a selected MCP server. No prompt was sent.");
+                    }
+                    break;
+                }
+                if (Date.now() >= deadline)
+                    throw new Error("Grok did not confirm its selected MCP catalog in time. No prompt was sent.");
+                await delay(50);
+            }
+        }
         if (!turn.model)
             return;
+        if (narrowsNativeTools(turn.toolScope)) {
+            if (currentModelId !== turn.model) {
+                throw new Error("Grok could not confirm the selected model without replacing its tool profile. Start a new conversation or choose a model with a supported Grok profile. No prompt was sent.");
+            }
+            // The inline profile already pins this model. Repeating set_model can
+            // rebuild the harness, or reject an otherwise valid resumed profile.
+            return;
+        }
         try {
             await request("session/set_model", { sessionId, modelId: turn.model });
         }
@@ -249,6 +438,22 @@ const support = {
     transformEnv: (env) => {
         delete env.XAI_API_KEY;
     },
+    applyTurnEnv: (env, { toolScope }) => {
+        if (toolScope !== undefined) {
+            // The verified runtime gives these local env switches priority over
+            // account defaults, preventing an unfiltered managed gateway fallback.
+            env.GROK_MANAGED_MCPS_ENABLED = "false";
+            env.GROK_MANAGED_MCP_GATEWAY_TOOLS_ENABLED = "false";
+            if (narrowsNativeTools(toolScope)) {
+                if (env.GROK_AGENT && env.GROK_AGENT !== "grok-build") {
+                    throw new Error("Grok's existing agent profile cannot be safely intersected with tool selection. Use a separate default Grok account.");
+                }
+                // A model's agent_type otherwise takes priority over ACP profiles.
+                // Preserve profile-file restrictions when intersecting them below.
+                env.GROK_AGENT = "grok-build";
+            }
+        }
+    },
     // Bind the grok.com subscription login. No API-key fallback by design —
     // an unauthenticated CLI is a user action, not something to paper over.
     pickAuthMethod: (methods) => (methods.some((m) => m.id === "cached_token") ? "cached_token" : null),

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/agents-call.js

@@ -507,6 +507,34 @@ export async function callTool(name, args, context) {
             }) });
         return { text: JSON.stringify(r), ...(r.error ? { isError: true } : {}) };
     }
+    if (name === "send_to_bot") {
+        const botId = String(args.bot_id ?? "").trim();
+        const title = String(args.title ?? "").trim();
+        const message = String(args.message ?? "").trim();
+        if (!botId || !title || !message) {
+            return { text: "send_to_bot needs bot_id, title and message.", isError: true };
+        }
+        if (botId === context.botId) {
+            return { text: "send_to_bot is cross-bot only. Use start_thread to send independent work to yourself.", isError: true };
+        }
+        if (turn.threadsOpenedThisTurn >= MAX_THREADS_PER_TURN) {
+            return { text: `You have already opened ${MAX_THREADS_PER_TURN} threads this turn, which is the limit.`, isError: true };
+        }
+        const r = await api("/api/internal/threads", { method: "POST", body: JSON.stringify({
+                fromBotId: context.botId, fromThreadId: context.threadId, toBotId: botId,
+                title, message, depth: context.depth, oneWay: true,
+            }) });
+        if (r.error)
+            return { text: `Couldn't send to that bot: ${String(r.error)}`, isError: true };
+        turn.threadsOpenedThisTurn += 1;
+        const destination = `@${String(r.botName ?? "that bot")} in #${String(r.title ?? title)} [thread id: ${String(r.threadId ?? "")}]`;
+        const state = r.approvalRequired === true
+            ? `Send to ${destination} is pending approval. The person's approval card appears after this turn ends; dispatch starts once approved.`
+            : r.state === "queued"
+                ? `Send to ${destination} is queued ${ordinal(Number(r.position) || 1)} for a free slot and can dispatch after this turn ends.`
+                : `Send to ${destination} is pending until this turn ends, then dispatch starts.`;
+        return { text: `${state} Its result stays in that thread; nothing there will resume you.` };
+    }
     if (name === "list_bots") {
         const r = await api(`/api/internal/agents?self=${encodeURIComponent(BOT_ID)}`);
         const bots = r.bots ?? [];

package/dist-server/server/drivers/agents-catalog.js

@@ -221,6 +221,15 @@ const toolDefinitions = (externalRuntime) => [
                 label: { type: "string", description: "Optional short name (one line, at most 60 characters) for this job. Names the new direct assignment thread." },
             }, required: ["bot_ids", "message", "request_key"] },
     },
+    {
+        name: "send_to_bot",
+        description: "Send work one way to another bot in a fresh thread. This is cross-bot only: use start_thread to send independent work to yourself. The recipient owns the new thread; its results, failures and questions stay there and never resume you. Use coordinate_bots when you need the result returned here.",
+        inputSchema: { type: "object", additionalProperties: false, properties: {
+                bot_id: { type: "string", description: "One reachable teammate id from list_bots or list_room_targets." },
+                title: { type: "string", description: "A short one-line title, at most 80 characters." },
+                message: { type: "string", description: "Complete instructions; the recipient does not inherit this conversation." },
+            }, required: ["bot_id", "title", "message"] },
+    },
     {
         name: "list_bots",
         description: "List the other bots (agents) you may contact in your own team and any additional teams the owner has explicitly allowed you to coordinate, with their team, model and current status. Call this to discover exact teammate IDs before assigning work or requesting advice through your available coordination tools.",
@@ -757,7 +766,7 @@ const VOICE_TOOL_NAMES = new Set(["send_voice_note"]);
 // One teamwork path in room turns; keep all unrelated integrations available.
 // Ordinary direct chats use this same bounded coordinator. Goal-owned turns
 // retain their independent loop and cannot start a second coordinator.
-const ROOM_ONLY_TOOLS = new Set(["list_room_targets", "coordinate_bots"]);
+const ROOM_ONLY_TOOLS = new Set(["list_room_targets", "coordinate_bots", "send_to_bot"]);
 const ROOM_REPLACED_TOOLS = new Set(["ask_bot", "delegate_bot", "check_delegation", "wait_delegation", "start_thread", "send_to_thread", "wait_thread"]);
 const EXTERNAL_TOOL_NAMES = new Set(["list_bots", "ask_bot", "delegate_bot", "check_delegation", "wait_delegation"]);
 const WATCHER_TOOL_NAMES = new Set(["create_options_card"]);

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

@@ -1,6 +1,7 @@
 import { newEventId, newId } from "../contracts.js";
 import { boatCredential, boatProviderApi } from "../included-services.js";
 import { appendNative } from "./native.js";
+import { assertToolScopeSupported } from "../../shared/tool-scope-support.js";
 import { OMB_ASK_TOOL, answerWithoutPreamble, askQuestionSummary, capAnswerEcho, ombAskProtocolPrompt, parseOmbAskQuestions, questionChoices, stripOmbAskBlock, } from "../../shared/ask-question.js";
 // "boxAgent" is Boat's historical driver kind (catalog and wire); keep it.
 const DRIVER_KIND = "boxAgent";
@@ -96,6 +97,7 @@ export const BoatAgentDriver = {
             return body;
         };
         const sendTurn = async (turn) => {
+            turn = { ...turn, toolScope: assertToolScopeSupported(DRIVER_KIND, turn.toolScope) };
             const { threadId } = turn;
             const computer = turn.integrations?.computer;
             const boxId = computer && (!computer.kind || computer.kind === "box") ? computer.boxId : undefined;

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,
 ];