openmausbot 0.1.85 → 0.1.87

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

@@ -29,8 +29,9 @@ import { homedir } from "node:os";
 import { lstat, mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
 import { createHash } from "node:crypto";
-import { PROVIDER_CREDENTIAL_ENV, WORKSPACE_CREDENTIAL_ENV } from "../../config.js";
+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 { describeSpawnFailure, execCli, killCliTree, spawnCli } from "../../procs.js";
 /**
  * A `host::model` pick talks to a loopback server with its own key.
@@ -42,9 +43,38 @@ export function skipSubscriptionAuthForLocalInject(model) {
 import { newEventId, newId } from "../../contracts.js";
 import { augmentedPath } from "../../env-path.js";
 import { supportsApprovalMode } from "../../../shared/approval-mode.js";
+import { parseAskQuestions, parseChoices, questionAnswersByQuestion } from "../../../shared/ask-question.js";
 import { appendNative } from "../native.js";
+import { acpPermissionCommand, permissionLaunchCwd } from "../permission-command.js";
 import { commandSummary, toolDetailPreview } from "../../tool-summary.js";
 import { extractMcpImages } from "../../mcp-tool-images.js";
+import { redactSecretsInText } from "../../redact.js";
+import { recoveryPromptFor } from "../../resume-recovery.js";
+/** ACP vendors put the actionable cause in error.data while keeping the
+ * JSON-RPC message generic. Only surface known text fields, never a response
+ * body/config dump, and redact before bounding the displayed diagnostic. */
+function acpRpcError(value, method) {
+    const message = typeof value?.message === "string" ? value.message : "ACP request failed";
+    const data = value?.data;
+    const detail = typeof data === "string" ? data
+        : typeof data?.details === "string" ? data.details
+            : typeof data?.message === "string" ? data.message
+                : typeof data?.error?.message === "string" ? data.error.message
+                    : "";
+    const context = [
+        method,
+        typeof data?.service === "string" ? `service: ${data.service}` : "",
+        typeof data?.errorName === "string" ? data.errorName : "",
+    ].filter(Boolean).join(", ");
+    const diagnostic = `${detail && detail !== message ? `${message}: ${detail}` : message} (${context})`;
+    const error = new Error(redactSecretsInText(diagnostic).slice(0, 1500));
+    return Object.assign(error, { code: value?.code, data,
+        // -32603 is JSON-RPC's internal error. Invalid params, unsupported
+        // methods and auth refusals are user/configuration issues, not evidence
+        // of a broken process. Preserve their session instead of retrying them.
+        acpSessionFailure: value?.code === -32603,
+    });
+}
 const envOr = (key, fallback) => Number(process.env[key] ?? fallback);
 const INIT_TIMEOUT = envOr("OPENMAUS_ACP_INIT_TIMEOUT_MS", 300_000);
 const SESSION_CONFIG_TIMEOUT = envOr("OPENMAUS_ACP_SESSION_CONFIG_TIMEOUT_MS", 300_000); // configureSession's per-request default
@@ -171,6 +201,17 @@ function sessionOperationKey(toolCall) {
         locations: toolCall?.locations,
     }));
 }
+/** The banner an ACP CLI prints for `--version`. Hermes writes its whole banner
+ *  to stderr with an empty stdout, so an stdout-only read reports a perfectly
+ *  good install as "CLI not found". Prefer stdout; fall back to the first
+ *  stderr line; null when both are empty. */
+export function versionFromProbe(stdout, stderr) {
+    const out = (stdout ?? "").trim();
+    if (out)
+        return out;
+    const err = (stderr ?? "").trim().split(/\r\n|\n|\r/, 1)[0]?.trim() ?? "";
+    return err || null;
+}
 export function createAcpDriver(support) {
     const DRIVER_KIND = support.driverKind;
     const SOURCE = support.nativeSource;
@@ -205,6 +246,8 @@ export function createAcpDriver(support) {
                     if (!allowedCredentials.has(key))
                         delete env[key];
                 }
+                // The operator's own secrets are outside any driver's allowlist.
+                stripControlPlaneEnv(env);
                 support.transformEnv?.(env, activeConfig, instanceId);
                 return env;
             };
@@ -385,7 +428,25 @@ export function createAcpDriver(support) {
                 session.current = null;
                 active.delete(threadId);
                 current.flushAssistantText();
-                emit({ ...base(threadId, current.turnId), type: "turn.completed", ok, stopReason, cost: null });
+                // `end_turn` with nothing to show for it — no reply, no image, no
+                // tool result — is a lost turn, not a success. An engine can report
+                // exactly that (a provider may cut a reasoning-only stream and
+                // still answer end_turn), and ok:true would end the thread quietly
+                // while the person's message went unanswered. Keep the completion,
+                // but report it as a failure so terminal chips, incidents and
+                // follow-ups see what happened.
+                let finalOk = ok;
+                let finalStopReason = stopReason;
+                if (finalOk && finalStopReason === null && !current.state.producedItem) {
+                    finalOk = false;
+                    finalStopReason = "empty_turn";
+                    emit({
+                        ...base(threadId, current.turnId),
+                        type: "runtime.error",
+                        message: `${DRIVER_KIND} ended the turn with no reply, image, or tool result`,
+                    });
+                }
+                emit({ ...base(threadId, current.turnId), type: "turn.completed", ok: finalOk, stopReason: finalStopReason, cost: null });
                 if (session.child.exitCode === null && !session.closing && !session.dead) {
                     armIdle(threadId);
                 }
@@ -400,6 +461,7 @@ export function createAcpDriver(support) {
              *  session.current, so a request that lands between turns is answered
              *  (never brokered) instead of left hanging. */
             const openSession = (threadId, launch, argv, env, cwd, contractKey) => {
+                const commandCwd = permissionLaunchCwd(cwd);
                 const child = spawnCli(launch.command, argv, {
                     cwd,
                     env,
@@ -426,7 +488,7 @@ export function createAcpDriver(support) {
                     if (timeoutMs) {
                         timer = setTimeout(() => {
                             rpcPending.delete(id);
-                            reject(new Error(`${method} timed out`));
+                            reject(Object.assign(new Error(`${method} timed out`), { acpSessionFailure: true }));
                         }, timeoutMs);
                         timer.unref?.();
                     }
@@ -455,6 +517,7 @@ export function createAcpDriver(support) {
                     };
                     armIdle();
                     rpcPending.set(id, {
+                        method,
                         // Consume configuration in wire order: an update following this
                         // response may arrive before the awaiting continuation resumes.
                         resolve: (result) => { receive?.(result); resolve(result); },
@@ -601,16 +664,34 @@ export function createAcpDriver(support) {
                         }
                     }
                     const tool = kind === "execute" ? "shell" : kind === "edit" ? "edit" : kind || "tool";
+                    const isShellCommand = !isQuestion && kind === "execute" && !/^mcp(?:__|[.:])/i.test(String(toolCall.title ?? ""));
                     const summary = String(toolCall.rawInput?.command ?? toolCall.title ?? tool).slice(0, 200);
+                    // One structured question beside the flat choices: the richer card
+                    // renders from it while older clients keep answering through
+                    // `choices`. Built once here so the emit and the answer path can
+                    // never disagree. parseAskQuestions enforces the shared caps.
+                    const questionChoices = isQuestion
+                        ? options.flatMap((option) => typeof option.name === "string" && option.name.trim() ? [option.name.trim()] : [])
+                        : [];
+                    const askQuestions = isQuestion && questionChoices.length
+                        ? parseAskQuestions({ questions: [{ question: summary, options: questionChoices }] }) ?? undefined
+                        : undefined;
                     const requestId = newId();
                     const finish = (behavior, source = "user", message, always) => {
                         if (!current.asks.delete(requestId))
-                            return;
+                            return "unavailable";
                         clearTimeout(timer);
                         const want = behavior === "allow" ? "allow" : "reject";
                         const forSession = want === "allow" && always === true && !isQuestion && !current.controlsHost;
+                        // A structured card replies in the Q:/A: block format; recover the
+                        // picked label from it so exact-match keeps working. Flat clients
+                        // send the bare label, which the single-question fallback inside
+                        // questionAnswersByQuestion already returns unchanged.
+                        const picked = askQuestions
+                            ? questionAnswersByQuestion(message ?? "", askQuestions)[askQuestions[0].question] ?? message
+                            : message;
                         const named = isQuestion && behavior === "answer"
-                            ? options.filter((option) => option.optionId === message || option.name?.trim() === message)
+                            ? options.filter((option) => option.optionId === picked || parseChoices([option.name], 1)?.[0] === picked)
                             : [];
                         const optionId = behavior === "cancel"
                             ? null
@@ -641,6 +722,7 @@ export function createAcpDriver(support) {
                             source: optionId ? source : "system",
                             approvalScope: current.controlsHost ? "local-computer" : undefined,
                         });
+                        return !optionId ? "rejected" : isQuestion ? "answered" : behavior === "allow" ? "allowed-once" : "rejected";
                     };
                     const timer = setTimeout(() => {
                         emit({ ...base(threadId, current.turnId), type: "runtime.error", message: DENY_TIMEOUT_NOTE });
@@ -655,9 +737,10 @@ export function createAcpDriver(support) {
                         requestType: isQuestion ? "question" : "permission",
                         tool,
                         summary,
-                        choices: isQuestion
-                            ? options.flatMap((option) => typeof option.name === "string" && option.name.trim() ? [option.name.trim()] : [])
-                            : undefined,
+                        command: isShellCommand ? acpPermissionCommand(toolCall.rawInput, commandCwd) : undefined,
+                        requiresExplicitApproval: isShellCommand && (toolCall.rawInput?.dangerouslyDisableSandbox === true || toolCall.rawInput?.sandbox_permissions === "require_escalated") || undefined,
+                        choices: askQuestions?.[0]?.options.map(option => option.label) ?? (isQuestion ? questionChoices : undefined),
+                        ...(askQuestions ? { questions: askQuestions } : {}),
                         approvalScope: current.controlsHost ? "local-computer" : undefined,
                         // the driver can honor a session-wide allow either way
                         allowSession: !isQuestion && !current.controlsHost ? true : undefined,
@@ -686,6 +769,7 @@ export function createAcpDriver(support) {
                             const delta = content?.text;
                             if (content?.type === "image" && typeof content.data === "string" && content.data) {
                                 current.flushAssistantText();
+                                current.state.producedItem = true;
                                 emit({
                                     ...base(threadId, current.turnId),
                                     type: "item.completed",
@@ -722,6 +806,7 @@ export function createAcpDriver(support) {
                         }
                         case "tool_call_update": {
                             if (u.status === "completed" || u.status === "failed") {
+                                current.state.producedItem = true;
                                 emit({
                                     ...base(threadId, current.turnId),
                                     type: "item.completed",
@@ -788,9 +873,7 @@ export function createAcpDriver(support) {
                                 if (pend.idleTimer)
                                     clearTimeout(pend.idleTimer);
                                 if (msg.error) {
-                                    const error = new Error(msg.error.message ?? JSON.stringify(msg.error));
-                                    Object.assign(error, { code: msg.error.code, data: msg.error.data });
-                                    pend.reject(error);
+                                    pend.reject(acpRpcError(msg.error, pend.method));
                                 }
                                 else {
                                     pend.resolve(msg.result);
@@ -923,6 +1006,10 @@ export function createAcpDriver(support) {
                 const envFingerprint = createHash("sha256").update(JSON.stringify(spawnEnv)).digest("hex").slice(0, 16);
                 const contractKey = JSON.stringify([launch.command, launch.args ?? [], spawnArgs, cwd, turnConfig.fullAuto === true, envFingerprint]);
                 const sessionKey = JSON.stringify(mcpServers);
+                if (turn.sessionReset) {
+                    closeSession(threadId, "reset");
+                    sessionAllows.delete(threadId);
+                }
                 const pooled = sessions.get(threadId);
                 let session;
                 if (pooled && !pooled.dead && !pooled.closing && pooled.contractKey === contractKey) {
@@ -948,7 +1035,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: "" };
+                const state = { settled: false, promptSent: false, text: "", producedItem: false };
                 const asks = new Map();
                 const modelOf = (result) => {
                     const option = (Array.isArray(result?.configOptions) ? result.configOptions : []).find((entry) => entry?.id === (support.selectModel?.configId ?? "model"));
@@ -987,6 +1074,7 @@ export function createAcpDriver(support) {
                     state.text = "";
                     if (!text.trim())
                         return;
+                    state.producedItem = true;
                     emit({ ...base(threadId, turnId), type: "item.completed", itemType: "assistant_text", text });
                 };
                 const current = {
@@ -1073,8 +1161,10 @@ export function createAcpDriver(support) {
                         };
                         let runtimeAcceptsImages = await handshake();
                         let init = session.initResult;
-                        const cursor = typeof turn.resumeCursor === "string" ? turn.resumeCursor : null;
+                        const cursor = !turn.sessionReset && typeof turn.resumeCursor === "string" ? turn.resumeCursor : null;
                         let sessionResult = null;
+                        let promptTurn = turn;
+                        let rebuiltFromReplay = false;
                         for (;;) {
                             const liveSessionId = session.sessionId;
                             if (liveSessionId !== null && session.sessionKey === sessionKey && (cursor === null || cursor === liveSessionId)) {
@@ -1100,7 +1190,17 @@ export function createAcpDriver(support) {
                                         }
                                     });
                                 }
-                                catch {
+                                catch (error) {
+                                    const classification = support.classifyError?.(error);
+                                    // OpenCode encodes ACPSessionNotFoundError as invalidParams
+                                    // with just the rejected sessionId. Other invalidParams
+                                    // responses (model/config errors) must not erase history.
+                                    const data = error?.data;
+                                    const missingSession = data && typeof data === "object" && !Array.isArray(data)
+                                        && data.sessionId === cursor && Object.keys(data).length === 1;
+                                    if (classification === "invalid_credentials" || classification === "inactive_subscription"
+                                        || (error?.code === -32602 && !missingSession))
+                                        throw error;
                                     /* session gone, load unsupported, or too slow — the
                                      * fallbacks below choose between one fresh process and a
                                      * genuinely new session */
@@ -1127,8 +1227,16 @@ export function createAcpDriver(support) {
                             }
                             // a genuinely fresh native session forgets what the previous
                             // one allowed
-                            if (!cursor)
-                                sessionAllows.delete(threadId);
+                            sessionAllows.delete(threadId);
+                            if (cursor) {
+                                const recovery = recoveryPromptFor({
+                                    recoveryText: turn.recoveryText,
+                                    currentText: turn.text,
+                                    failure: "before-accept",
+                                });
+                                promptTurn = { ...turn, text: recovery.text };
+                                rebuiltFromReplay = recovery.replayed;
+                            }
                             sessionResult = await request("session/new", { cwd, mcpServers: sessionServers }, NEW_SESSION_TIMEOUT, (result) => {
                                 session.sessionId = typeof result?.sessionId === "string" ? result.sessionId : null;
                                 session.sessionKey = sessionKey;
@@ -1151,6 +1259,7 @@ export function createAcpDriver(support) {
                                 type: "session.started",
                                 sessionId,
                                 model: selectedModel ?? init?._meta?.modelState?.currentModelId ?? cliTurn.model ?? null,
+                                ...(rebuiltFromReplay ? { rebuilt: true } : {}),
                             });
                         };
                         try {
@@ -1177,7 +1286,7 @@ export function createAcpDriver(support) {
                                         ? sessionResult.models.availableModels
                                         : [],
                                 });
-                                // initialize's currentModelId is the CLI default (grok-4.6),
+                                // initialize's currentModelId is the CLI default,
                                 // not the model this turn asked for. After a successful pin,
                                 // report the slug we set so the UI does not claim otherwise.
                                 if (!selectedModel && cliTurn.model)
@@ -1198,11 +1307,28 @@ export function createAcpDriver(support) {
                             throw error;
                         }
                         emitSessionStarted();
+                        // The stable/volatile split: the full prompt rides only the turn
+                        // that establishes - or re-instructs, after a soul edit - this
+                        // native session. Later turns go through bare unless the volatile
+                        // half changed, so a memory edit neither appends a second copy of
+                        // the prompt to the agent's session history nor re-prices the
+                        // prefix its provider cached. Receipts are durable because the
+                        // native session outlives this process; an un-split turn (a direct
+                        // 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));
+                            promptInput = { ...promptTurn, system: "", text: composed.text };
+                            pendingSplitReceipt = { key: receiptKey, receipt: composed.receipt };
+                        }
                         const text = support.buildPromptText
-                            ? support.buildPromptText(turn)
-                            : turn.system
-                                ? `${turn.system}\n\n${turn.text}`
-                                : turn.text;
+                            ? support.buildPromptText(promptInput)
+                            : promptInput.system
+                                ? `${promptInput.system}\n\n${promptInput.text}`
+                                : promptInput.text;
                         const imageBlocks = support.images === true && runtimeAcceptsImages
                             ? await readAcpImageBlocks(turn.images ?? [])
                             : [];
@@ -1216,6 +1342,12 @@ export function createAcpDriver(support) {
                         const promptIdleMs = promptIdleTimeoutMs();
                         const result = await request("session/prompt", { sessionId, prompt: [{ type: "text", text }, ...imageBlocks] }, undefined, undefined, promptIdleMs, `${DRIVER_KIND} went fully silent ${Math.round(promptIdleMs / 1000)} s after the message and the turn was stopped. ` +
                             "Raise OPENMAUS_ACP_PROMPT_IDLE_TIMEOUT_MS if this model legitimately takes longer to answer.");
+                        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);
+                        }
                         // opencode 1.18.18 reports usage at the result root; grok and
                         // gemini put it under _meta. Read both rather than lose the count.
                         const usage = result?.usage ?? result?._meta ?? {};
@@ -1261,11 +1393,14 @@ export function createAcpDriver(support) {
                                 message,
                                 ...(needsAuth ? { setup: true } : {}),
                             });
-                            // A prompt that went idle has a wedged child under the RPC — it
-                            // will never answer the next prompt either. Do not leave it
-                            // pooled: close it so the next turn spawns a fresh agent.
-                            if (e?.acpPromptStall === true && session.child.exitCode === null && !session.closing) {
-                                closeSession(threadId, "prompt-stall");
+                            // Internal RPC failures can leave a live child poisoned just
+                            // like a silent prompt. Evict before completion listeners can
+                            // start the next turn. Never replay this accepted prompt: it
+                            // may already have executed tools. The next explicit turn can
+                            // resume the recorded session on a fresh process.
+                            if (!needsAuth && (e?.acpPromptStall === true || e?.acpSessionFailure === true
+                                || code === "upstream_outage") && session.child.exitCode === null && !session.closing) {
+                                closeSession(threadId, e?.acpPromptStall === true ? "prompt-stall" : "rpc-failure");
                             }
                             settle(threadId, session, false, needsAuth ? "auth_required" : "rpc_error");
                         }
@@ -1278,7 +1413,7 @@ export function createAcpDriver(support) {
                 if (support.snapshot)
                     return support.snapshot(env, config, instanceId);
                 const version = await new Promise((resolve) => {
-                    execCli(config.cli, ["--version"], { timeout: 8000, env }, (err, stdout) => resolve(err ? null : stdout.trim()));
+                    execCli(config.cli, ["--version"], { timeout: 8000, env }, (err, stdout, stderr) => resolve(err ? null : versionFromProbe(stdout, stderr)));
                 });
                 if (!version)
                     return { state: "unavailable", reason: `\`${config.cli}\` CLI not found` };
@@ -1319,12 +1454,7 @@ export function createAcpDriver(support) {
                         const finish = turn?.asks.get(requestId);
                         if (!finish)
                             return "unavailable"; // settled, timed out, or turn gone
-                        finish(decision.behavior, "user", decision.message, decision.always === true);
-                        return decision.behavior === "allow"
-                            ? "allowed-once"
-                            : decision.behavior === "answer"
-                                ? "answered"
-                                : "rejected";
+                        return finish(decision.behavior, "user", decision.message, decision.always === true);
                     },
                     hasSession: (threadId) => active.has(threadId),
                     stopAll: async () => {

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

@@ -9,8 +9,9 @@ import { join } from "node:path";
 import { decodeInjectId, hostApiKey, localHost, mergeLocalInject } from "../local-inject.js";
 import { createAcpDriver } from "./core.js";
 export const STATIC_GROK_MODELS = {
-    default: "grok-4.6",
+    default: "grok-4.7",
     options: [
+        { id: "grok-4.7", label: "Grok 4.7", contextWindow: 500_000 },
         { id: "grok-4.6", label: "Grok 4.6" },
         { id: "grok-4.5", label: "Grok 4.5" },
     ],
@@ -28,7 +29,7 @@ function unquote(raw) {
     }
     return value;
 }
-/** Local slugs from ~/.grok/config.toml, plus the two cloud defaults.
+/** Local slugs from ~/.grok/config.toml, plus the cloud defaults.
  *  `grok -m <slug>` already accepts these; the picker just didn't list them. */
 export function readGrokModelCatalog(env = process.env) {
     const path = join(grokHome(env), "config.toml");
@@ -218,7 +219,7 @@ const support = {
     // agent flags: Grok 1.0.6 only applies them when they sit AFTER `agent`
     // and BEFORE `stdio` (`grok agent -m slug stdio`). Putting -m first is
     // accepted as a TUI option and then ignored, so ACP session/new keeps
-    // [models].default (grok-4.6) and oMLX never sees a request.
+    // [models].default (currently grok-4.7) and oMLX never sees a request.
     // Auto selects Grok's native classifier; if its feature gate is disabled,
     // residual requests still ask. Never replace it with bypassPermissions.
     // Verified: grok 1.0.3 --help and xai-org/grok-build@37949780,