openmausbot 0.1.96 → 0.1.97

package/dist-server/server/turn-continuation.js

@@ -0,0 +1,162 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * Automatic continuity: when a turn ends without a final answer and the work
+ * is resumable (budget cap or tool errors), persist a structured handoff and
+ * let the harness start a `Continue:` thread on the same bot — transparent to
+ * the bot, which just sees a normal new thread seeded with the handoff.
+ *
+ * The handoff is written by the driver that has the full transcript in hand;
+ * the continuation is driven by a bus subscriber in the harness (index.ts).
+ */
+/** Resolve the handoff directory the same way the server resolves its data
+ * dir (server/cli.ts): OMB_DATA_DIR wins, else ~/.openmausbot. */
+export function handoffDir() {
+    return join(process.env.OMB_DATA_DIR || join(homedir(), ".openmausbot"), "handoffs");
+}
+/** Persist a structured markdown handoff for a turn that ended without a
+ * final answer. Returns the file path, or null when the write fails. */
+export function writeTurnHandoff(input) {
+    try {
+        const dir = handoffDir();
+        mkdirSync(dir, { recursive: true });
+        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const file = join(dir, `cap-${String(input.threadId).slice(0, 8)}-${String(input.turnId).slice(0, 8)}-${stamp}.md`);
+        const L = [];
+        L.push("# Handoff - turn ended without a final answer", "");
+        L.push(`- Thread: ${input.threadId}`);
+        L.push(`- Turn: ${input.turnId}`);
+        L.push(`- Model: ${input.model ?? "unknown"}`);
+        L.push(`- Tool calls used: ${input.toolCalls}`);
+        if (input.hasUsage && input.usage)
+            L.push(`- Tokens this turn: ${input.usage.input} in / ${input.usage.output} out`);
+        L.push(`- Stop reason: ${input.failure ?? "unknown"}`);
+        L.push(`- Written at: ${new Date().toISOString()}`, "");
+        L.push("## Original task (first user message)", "```");
+        const firstUser = input.messages.find((m) => m.role === "user");
+        const firstText = firstUser && typeof firstUser.content === "string"
+            ? firstUser.content
+            : JSON.stringify(firstUser?.content ?? null);
+        L.push(String(firstText).slice(0, 8000), "```", "");
+        L.push("## Work performed (tool calls in order)", "");
+        let n = 0;
+        for (const m of input.messages) {
+            if (m.role === "assistant" && Array.isArray(m.tool_calls)) {
+                for (const tc of m.tool_calls) {
+                    n += 1;
+                    const args = String(tc.function?.arguments ?? "").replace(/\s+/g, " ").slice(0, 300);
+                    L.push(`${n}. ${tc.function?.name ?? "tool"} - ${args}`);
+                }
+            }
+            else if (m.role === "tool") {
+                let verdict = "?";
+                try {
+                    verdict = JSON.parse(String(m.content)).ok ? "ok" : "FAILED";
+                }
+                catch { /* keep "?" */ }
+                L.push(`   result ${verdict}: ${String(m.content ?? "").replace(/\s+/g, " ").slice(0, 220)}`);
+            }
+        }
+        if (n === 0)
+            L.push("(none recorded)");
+        L.push("", "## Last assistant text", "");
+        let last = null;
+        for (let i = input.messages.length - 1; i >= 0; i -= 1) {
+            const c = input.messages[i].content;
+            if (input.messages[i].role === "assistant" && typeof c === "string" && c.trim()) {
+                last = c;
+                break;
+            }
+        }
+        L.push(last ? last.slice(0, 6000) : "(none)", "");
+        L.push("## Instructions for whoever continues this task", "");
+        L.push("1. Read this file completely.");
+        L.push("2. Re-verify the current state of every file, branch, and PR mentioned above before acting - it may be stale.");
+        L.push("3. Continue from the first unfinished step. Do not redo completed work.");
+        L.push("4. If you get close to your own turn budget, append your progress to this file before stopping.");
+        writeFileSync(file, L.join("\n"), { mode: 0o600 });
+        return file;
+    }
+    catch {
+        return null;
+    }
+}
+/** Provider config errors are not resumable: looping on them burns budget and
+ * masks the real fix (change the model or the tool set). Everything else that
+ * stops a turn without a final answer is a candidate for auto-continuation. */
+const NOT_RESUMABLE = /not a multimodal model|unknown model|does not support|tool arguments do not match/i;
+/** Classify a terminal turn as resumable. Returns the reason for the
+ * continuation (`cap` = budget exhausted), or null when the turn must not be
+ * auto-continued. A tool error is never continued: it includes a person's or
+ * the approval policy's denial, and a new unattended thread would retry what
+ * was refused. */
+export function classifyContinuable(_stopReason, failure) {
+    if (!failure)
+        return null;
+    if (NOT_RESUMABLE.test(failure))
+        return null;
+    if (/limit reached|stopped after \d+ steps|without a final answer/i.test(failure))
+        return "cap";
+    return null;
+}
+const CONTINUE_TITLE = /^Continue: /;
+const MAX_PER_BOT_PER_HOUR = 5;
+const WINDOW_MS = 3600e3;
+/** Bus subscriber: on `cap.exhausted`, create a `Continue:` task on the same
+ * bot and start a turn seeded with the handoff. Bounded — at most five
+ * continuations per bot per hour, never a continuation of a continuation, and
+ * never the same source thread twice. A failure escalates with an activity
+ * message carrying the handoff path instead of silently recursing. */
+export function makeCapContinuationSubscriber(deps) {
+    const state = new Map();
+    return (event) => {
+        if (event.type !== "cap.exhausted" || !event.handoffPath)
+            return;
+        void (async () => {
+            const bot = deps.store.botByThread(event.threadId);
+            if (!bot)
+                return;
+            const now = deps.now ? deps.now() : Date.now();
+            let rec = state.get(bot.id);
+            if (!rec || now - rec.last > WINDOW_MS || rec.continued.size > 100) {
+                rec = { last: now, count: 0, continued: new Set() };
+                state.set(bot.id, rec);
+            }
+            if (rec.count >= MAX_PER_BOT_PER_HOUR || rec.continued.has(event.threadId))
+                return;
+            const deadTask = deps.store.taskByThread(bot.id, event.threadId);
+            if (!deadTask)
+                return;
+            if (CONTINUE_TITLE.test(deadTask.title ?? ""))
+                return;
+            const approvalMode = deadTask.approvalMode === "ask" || deadTask.approvalMode === "full" ? deadTask.approvalMode : undefined;
+            const contTask = deps.store.createTask(bot.id, `Continue: ${(deadTask.title ?? "task").slice(0, 90)}`, true, deadTask.projectId, undefined, approvalMode, deadTask.modelSelection);
+            if (!contTask)
+                return;
+            rec.count += 1;
+            rec.last = now;
+            rec.continued.add(event.threadId);
+            const prompt = `[Auto-continuation] The task "${deadTask.title}" stopped because its turn ended without a final answer (${event.reason}). A handoff file with the full state was written to ${event.handoffPath}. Read that file first, re-verify the current state of anything it mentions, then continue the task from where it stopped. Do not redo completed work. If you cannot finish, append your progress to the handoff file and say exactly what is blocking.`;
+            try {
+                await deps.startTurn(bot.id, prompt, { threadId: contTask.threadId, unattended: true });
+                deps.store.appendMessage(event.threadId, {
+                    role: "bot", kind: "activity",
+                    tool: { name: `Turn ended without a final answer — work continues in a new task (handoff: ${event.handoffPath})`, ok: true },
+                    threadRef: { botId: bot.id, threadId: contTask.threadId, title: contTask.title },
+                });
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                console.error("[cap-continuation] failed:", msg);
+                try {
+                    deps.store.appendMessage(event.threadId, {
+                        role: "bot", kind: "activity",
+                        tool: { name: `Turn ended without a final answer — auto-continuation failed (${String(msg).slice(0, 200)}). Handoff: ${event.handoffPath}. Start a new thread that reads it to continue.`, ok: false },
+                    });
+                }
+                catch { /* the escalation message itself failed; nothing else to do */ }
+            }
+        })();
+    };
+}

package/dist-server/server/workspace.js

@@ -20,7 +20,7 @@ export const WORKSPACES_DIR = join(DATA_DIR, "workspaces");
 export const TASK_WORKSPACES_DIR = join(DATA_DIR, "task-workspaces");
 /** MCP support does not imply native filesystem tools or a local working directory. */
 export function supportsWorkspaceFiles(driverKind) {
-    return !["grok", "openai-compat", "minimax", "mistral", "cerebras", "boxAgent"].includes(driverKind);
+    return !["grok", "openai-compat", "minimax", "mistral", "cerebras"].includes(driverKind);
 }
 /** Default task files are private to the thread, outside the bot's shared
  * memory folder. This is directory organization, not a shell sandbox. */

package/dist-server/shared/ask-question.js

@@ -109,55 +109,6 @@ export function parseAskQuestions(input) {
     }
     return questions.length ? questions : null;
 }
-/** The fenced block a turn-boundary agent ends its run with when it wants
- * to ask the person something (the BoatAgent transport): the harness cannot
- * pause mid-run, so the questions ride the final output and OMB parses them
- * at settle. The block is model-authored — untrusted input like any tool
- * call — so its body runs through parseAskQuestions and the same caps. */
-const OMB_ASK_FENCE = /(^|\n)[ \t]{0,3}(`{3,}|~{3,})[ \t]*omb-ask[ \t]*\r?\n([\s\S]*?)\r?\n[ \t]{0,3}\2[ \t]*(?=\r?\n|$)/;
-const OMB_ASK_FENCE_GLOBAL = new RegExp(OMB_ASK_FENCE.source, OMB_ASK_FENCE.flags + "g");
-/** The questions inside the first fenced omb-ask block in an output, or
- * null when there is nothing worth showing (no fence, invalid JSON, or no
- * entry that parses as a question). The first fence wins: a second block
- * in the same output is ignored, not merged. */
-export function parseOmbAskQuestions(output) {
-    const match = OMB_ASK_FENCE.exec(output);
-    if (!match)
-        return null;
-    try {
-        return parseAskQuestions(JSON.parse(match[3]));
-    }
-    catch {
-        return null;
-    }
-}
-/** The output with its omb-ask block(s) removed, for display: the person
- * reads the prose around the ask, never the raw protocol JSON. Text
- * without a block is returned untouched. */
-export function stripOmbAskBlock(output) {
-    if (!OMB_ASK_FENCE.test(output))
-        return output;
-    return output.replace(OMB_ASK_FENCE_GLOBAL, "").replace(/\n{3,}/g, "\n\n").trim();
-}
-/** The prompt contract that teaches a model the turn-held ask transport: end
- * the reply with a fenced `omb-ask` block carrying the questions, and the
- * answers come back on the next prompt. A harness that cannot pause mid-run
- * (the BoatAgent transport) appends this to every prompt; the caps in the text
- * are the constants above, so the taught contract and the parser cannot
- * drift apart. */
-export function ombAskProtocolPrompt() {
-    return [
-        "",
-        "## Asking the person a question",
-        "When a decision belongs to the person, end your reply with a fenced block exactly like this:",
-        "",
-        "```omb-ask",
-        '{"questions":[{"question":"Ship the release now?","header":"Release","options":[{"label":"Ship now"},{"label":"Wait for the QA signoff"}]}]}',
-        "```",
-        "",
-        `The block must be the last thing in your reply. You may ask up to ${MAX_QUESTIONS} questions at once, each with up to ${MAX_OPTIONS} options; the person can always answer in their own words. Their answers arrive on your next prompt as \`Q:\`/\`A:\` lines — never invent them.`,
-    ].join("\n");
-}
 /** The one line the card subtitle and a spoken prompt show. */
 export function askQuestionSummary(questions) {
     const first = questions[0]?.question ?? "";
@@ -254,10 +205,6 @@ export const ASK_USER_TOOL_DEFINITION = {
         },
     },
 };
-/** The synthetic tool string for an ask parsed out of model-authored final
- * output (the BoatAgent turn-held transport): there is no tool call to name,
- * but the event and the ASKS_A_PERSON backstop need one string. */
-export const OMB_ASK_TOOL = "omb-ask";
 /** The lead-in on a formatted answer. It exists for the model — the answer
  * is delivered on the deny channel, so it has to say what it is — and the
  * card strips it back off when it shows the person what they sent. */
@@ -283,23 +230,6 @@ export function formatQuestionAnswers(questions, answers) {
 export function answerWithoutPreamble(answer) {
     return answer.startsWith(`${ANSWER_PREAMBLE}\n\n`) ? answer.slice(ANSWER_PREAMBLE.length + 2) : answer;
 }
-/** The longest formatted answer OMB will echo back into a follow-up prompt
- * (the BoatAgent continuation). formatQuestionAnswers itself does not
- * truncate — the tool-result channel has no stated limit — but a prompt is
- * not the place to find one: six answers at the custom-answer cap is the
- * most a legitimate reply weighs, so that is the ceiling. */
-export const MAX_ANSWER_ECHO = 6 * MAX_CUSTOM_ANSWER;
-/** Cap a formatted answer for echoing into a follow-up prompt. An over-cap
- * echo is cut back to the last whole block so no partial answer reads as
- * one, and says it was truncated. */
-export function capAnswerEcho(answer, limit = MAX_ANSWER_ECHO) {
-    if (answer.length <= limit)
-        return answer;
-    const cut = answer.slice(0, limit);
-    const boundary = cut.lastIndexOf("\n\nQ: ");
-    const kept = boundary > 0 ? cut.slice(0, boundary) : cut;
-    return kept + "\n\n[answer truncated]";
-}
 /**
  * The answer text, read back as one value per question.
  *

package/dist-server/shared/cloud-computer.js

@@ -3,10 +3,8 @@
 // select_computer offer) and the renderer (the Works on panel, the composer's
 // place chip, Webhooks and Routines), so the two never disagree.
 /** An engine with computer tools gets the cloud computer as one more stdio
- * computer server. The Computer engine (boxAgent) runs its whole turn on its
- * Boat, so it can work on a Boat but not on a VPS. */
-export function canWorkOnCloud(engine, backend) {
-    const runsOnBoat = engine?.driverKind === "boxAgent";
-    const hasComputerTools = engine?.computerMcp === true;
-    return backend === "vps" ? hasComputerTools && !runsOnBoat : hasComputerTools || runsOnBoat;
+ * computer server, on a Boat and on a VPS alike. The turn always stays on the
+ * bot's own engine; nothing hands it to another one. */
+export function canWorkOnCloud(engine) {
+    return engine?.computerMcp === true;
 }

package/dist-server/shared/credential-request.js

@@ -18,7 +18,7 @@ export const CREDENTIAL_TARGETS = {
     },
     opencodeGoApiKey: {
         label: "OpenCode API key",
-        description: "Used for OpenCode Go and other key-backed OpenCode providers.",
+        description: "Used for OpenCode Zen and Go.",
         placeholder: "Paste your OpenCode API key",
         helpUrl: "https://opencode.ai/docs/providers/",
     },

package/dist-server/shared/failed-turn.js

@@ -1,7 +1,3 @@
-// A failed turn is stored as an activity row named "error: <what went
-// wrong>", in a 1:1 chat and a room alike. The server writes every such row
-// through failedTurnTool and the clients read it back through
-// failedTurnCause, so the marker and the one length limit live here only.
 const MARKER = "error:";
 /** The longest cause a row keeps. Clients wrap the row and show it whole, so
  * this only bounds a pathological message (a provider's HTML body, a stack
@@ -16,6 +12,7 @@ export function failedTurnTool(cause, flags = {}) {
         ...(flags.setup ? { setup: true } : {}),
         ...(flags.terminal ? { terminal: true } : {}),
         ...(flags.claudeUpdate ? { claudeUpdate: true } : {}),
+        ...(flags.place ? { place: flags.place } : {}),
     };
 }
 /** The cause a failed-turn row carries, without its marker; null for any