openmausbot 0.1.94 → 0.1.95

package/dist-server/server/lending-memory.js

@@ -39,6 +39,14 @@ export const WORKING_FOLDER_FILES = [".mcp.json", ".claude/settings.json", ".cla
 /** Folders of skills, agents and commands an engine discovers in its working
  * folder: each entry, and a skill's SKILL.md. */
 export const WORKING_FOLDER_DIRS = [".claude/skills", ".claude/agents", ".claude/commands", ".agents/skills"];
+/** The two lists above by first path segment, as the walker looks for them:
+ * each name at the top of a working folder, with the names inside it (none
+ * for a file there, like .mcp.json). These lists alone decide what is watched. */
+const WORKING_FOLDER_TOP = new Map();
+for (const path of [...WORKING_FOLDER_FILES, ...WORKING_FOLDER_DIRS]) {
+    const [top, inner] = path.split("/");
+    WORKING_FOLDER_TOP.set(top, [...WORKING_FOLDER_TOP.get(top) ?? [], ...(inner ? [inner] : [])]);
+}
 /** Instruction files an engine reads from its working folder and every
  * folder above it (Claude Code's project memory; Codex's AGENTS.md). */
 export const ANCESTOR_FILES = ["CLAUDE.md", "CLAUDE.local.md", "AGENTS.md", "AGENTS.override.md"];
@@ -222,9 +230,10 @@ export function memoryFiles(workspace, workingFolders = [], alsoAbove = []) {
         const top = listing(folder, ROOT_ENTRY_CAP, true);
         if (top) {
             listedRoots.set(folder, top);
-            for (const name of present(folder, [".mcp.json", ".claude", ".agents"], top)) {
+            for (const name of present(folder, [...WORKING_FOLDER_TOP.keys()], top)) {
                 const path = join(folder, name);
-                if (name === ".mcp.json") {
+                const wanted = WORKING_FOLDER_TOP.get(name);
+                if (!wanted.length) {
                     add(path, path);
                     continue;
                 }
@@ -235,9 +244,8 @@ export function memoryFiles(workspace, workingFolders = [], alsoAbove = []) {
                     add(path, path);
                 if (!inner && !isLink(path))
                     continue;
-                const wanted = name === ".claude" ? ["settings.json", "settings.local.json", "CLAUDE.md", "skills", "agents", "commands"] : ["skills"];
                 for (const entry of inner ? present(path, wanted, inner) : wanted) {
-                    if (entry === "skills" || entry === "agents" || entry === "commands")
+                    if (WORKING_FOLDER_DIRS.includes(`${name}/${entry}`))
                         capped(join(path, entry));
                     else
                         add(join(path, entry), join(path, entry));
@@ -290,10 +298,6 @@ export function fingerprintOf(files) {
         hash.update(`${name}\u0000${files[name]}\u0000`);
     return hash.digest("hex");
 }
-/** Back-compat for callers that only need the hash of one workspace. */
-export function memoryFingerprint(workspace, workingFolders = []) {
-    return fingerprintOf(memoryFiles(workspace, workingFolders));
-}
 /** What the record keeps of each file: enough to say which ones changed. */
 function digests(files) {
     return Object.fromEntries(Object.entries(files).map(([name, described]) => [name, createHash("sha256").update(described).digest("hex").slice(0, 24)]));

package/dist-server/server/memory-entries.js

@@ -2,12 +2,21 @@
 // `- YYYY-MM-DD · from <source> · text[ · until YYYY-MM-DD]`, with a
 // struck-through body for a superseded fact. Pure helpers shared by the
 // prompt loader (which hides expired lines), background capture (which
-// must not add a fact the notebook already holds) and the nightly tidy-up.
+// must not add a fact the notebook already holds), the nightly tidy-up and
+// the rule that keeps MEMORY.md within what loads (server/workspace.ts).
 export const UNTIL_DATE = /^\d{4}-\d{2}-\d{2}$/;
 const DATED = /^(- (\d{4}-\d{2}-\d{2}) · (?:from [^·\n]* · )?)(.*)$/;
 const UNTIL_MARK = / · until (\d{4}-\d{2}-\d{2})(?= · |$)/;
-const TRAILING_MARKS = /(?: · (?:updated|confirmed|until|expired|superseded) \d{4}-\d{2}-\d{2})+$/;
+const TRAILING_MARKS = /(?: · (?:updated|confirmed|until|expired|superseded|moved) \d{4}-\d{2}-\d{2})+$/;
 const BULLET = /^\s*(?:[-*•]|\d+[.)])\s+/;
+/** A safety or health fact must load into every turn: neither the organize
+ * step nor the size rule moves one out of MEMORY.md, whatever else happens.
+ * Seen live — a model moved "is vegetarian" into a food topic despite being
+ * told diet is core. */
+const ALWAYS_CORE = /\b(?:allerg\w*|anaphyla\w*|intoleran\w*|vegetarian|vegan|halal|kosher|gluten|lactose|diet\w*|diabet\w*|asthma\w*|epilep\w*|pregnan\w*|medicat\w*|medicine|medical|disabilit\w*|wheelchair|blind|deaf|health)\b/i;
+export function alwaysCore(body) {
+    return ALWAYS_CORE.test(body);
+}
 /** Whether `value` is a real calendar date in YYYY-MM-DD form. */
 export function isMemoryDate(value) {
     if (typeof value !== "string" || !UNTIL_DATE.test(value))
@@ -18,20 +27,41 @@ export function isMemoryDate(value) {
 export function untilMark(until) {
     return until ? ` · until ${until}` : "";
 }
+/** A line with an odd number of fences opens or closes a code block. */
+const togglesFence = (line) => (line.match(/```/g)?.length ?? 0) % 2 === 1;
 /** Every dated entry in a MEMORY.md text, in file order. Hand-written lines
- * without a date are not entries and are never touched by upkeep. */
+ * without a date are not entries and are never touched by upkeep. An entry
+ * also owns the lines under it, up to the next dated line: indented ones
+ * (Markdown's list rule; how an entry with a code block is written) and a
+ * code block it opens, through its closing fence (how such entries were
+ * written before). A fence that never closes claims nothing. */
 export function parseMemoryEntries(text) {
     const out = [];
-    text.split("\n").forEach((raw, line) => {
+    const lines = text.split("\n");
+    for (let line = 0; line < lines.length;) {
+        const raw = lines[line];
         const m = DATED.exec(raw);
-        if (!m)
-            return;
+        if (!m) {
+            line += 1;
+            continue;
+        }
+        let open = togglesFence(raw);
+        let end = line + 1;
+        for (let next = line + 1; next < lines.length && !DATED.test(lines[next]); next += 1) {
+            if (!open && !/^[ \t]/.test(lines[next]) && !lines[next].startsWith("```"))
+                break;
+            if (togglesFence(lines[next]))
+                open = !open;
+            if (!open)
+                end = next + 1;
+        }
         const rest = m[3];
         const struck = rest.startsWith("~~");
         const until = UNTIL_MARK.exec(rest)?.[1] ?? null;
         const body = rest.replace(TRAILING_MARKS, "").replace(/^~~/, "").replace(/~~$/, "").trim();
-        out.push({ line, raw, prefix: m[1], body, date: m[2], until, struck });
-    });
+        out.push({ line, end, raw, prefix: m[1], body, date: m[2], until, struck });
+        line = end;
+    }
     return out;
 }
 /** A live entry whose `until` day has passed. The until day itself still counts. */

package/dist-server/server/memory-organize.js

@@ -8,19 +8,12 @@
 // aliases recall matches. An entry judged core is remembered and not asked
 // about again. Pure here: the caller reads, calls the model, writes and
 // journals.
-import { factIdentity, isExpired, parseMemoryEntries } from "./memory-entries.js";
+import { alwaysCore, factIdentity, isExpired, parseMemoryEntries } from "./memory-entries.js";
 import { topicFileName } from "./memory-capture.js";
 export const ORGANIZE_MARKER = "You are the ORGANIZE step of a memory system";
 /** One pass moves at most this many entries. */
 export const MAX_MOVES = 20;
 const PROMPT_ENTRIES = 60;
-/** Lines the model may not move, whatever it answers: a safety or health
- * fact must load into every turn. Seen live — a model moved "is vegetarian"
- * into a food topic despite being told diet is core. */
-const ALWAYS_CORE = /\b(?:allerg\w*|anaphyla\w*|intoleran\w*|vegetarian|vegan|halal|kosher|gluten|lactose|diet\w*|diabet\w*|asthma\w*|epilep\w*|pregnan\w*|medicat\w*|medicine|medical|disabilit\w*|wheelchair|blind|deaf|health)\b/i;
-export function alwaysCore(body) {
-    return ALWAYS_CORE.test(body);
-}
 /** Live, unexpired entries not already judged core: what the call is asked about. */
 export function organizeCandidates(text, today, core) {
     return parseMemoryEntries(text)

package/dist-server/server/memory-topics.js

@@ -90,8 +90,8 @@ export function readTopicHead(path) {
             closeSync(fd);
     }
 }
-/** One line per topic, capped by count and length. The archive the tidy-up
- * keeps is listed last and labelled, so it is not mistaken for current notes. */
+/** One line per topic, capped by count and length. The archive is listed
+ * last and labelled, so it is not mistaken for current notes. */
 export function renderTopicIndex(topics) {
     if (!topics.length)
         return "";
@@ -104,8 +104,8 @@ export function renderTopicIndex(topics) {
             omitted += 1;
             continue;
         }
-        const about = name === "archive.md" && !header.title && !header.description
-            ? "expired and replaced notes, kept for the record"
+        const about = name === "archive.md"
+            ? "older notes moved out of MEMORY.md, kept for the record"
             : [header.title, header.description].filter(Boolean).join(" — ");
         const also = header.aliases.length ? ` (also: ${header.aliases.join(", ")})` : "";
         const line = `- memory/${name}${about ? ` — ${about}` : ""}${also}`.replace(/\s+/g, " ");

package/dist-server/server/memory-upkeep.js

@@ -25,13 +25,13 @@ import { mergeTopicText } from "./memory-topics.js";
 import { applyMoves, MAX_MOVES, organizeCandidates, organizePrompt, parseMoves } from "./memory-organize.js";
 import { recordMemoryChange } from "./memory-journal.js";
 import { applyTidy, contradictionCandidates, contradictionPrompt, parseContradictions, planChanges, planTidy } from "./memory-tidy.js";
-import { ensureWorkspace, listMemoryTopics, memoryDate, memoryEntry, memoryTopicIndex, readMemoryText, updateMemory, workspaceDir, writeMemoryFile, writeMemoryTopic } from "./workspace.js";
+import { appendMemoryArchive, ARCHIVE_TOPIC, ensureWorkspace, listMemoryTopics, memoryDate, memoryEntry, memoryTopicIndex, readMemoryText, updateMemory, workspaceDir, writeMemoryFile, writeMemoryTopic } from "./workspace.js";
 export const CAPTURE_MAX_TURNS = 6;
 export const MODEL_TIMEOUT_MS = 60_000;
 export const TIDY_CHECK_MS = 10 * 60_000;
 /** Below this many live entries there is nothing a contradiction pass may change. */
 export const MIN_ENTRIES_FOR_CONTRADICTIONS = 5;
-export const ARCHIVE_TOPIC = "archive.md";
+const ARCHIVE_PATH = `memory/${ARCHIVE_TOPIC}`;
 /** A topic file past this size gains nothing more from capture. */
 export const TOPIC_MAX_BYTES = 64 * 1024;
 /** On unless switched off: every bot keeps its memory in shape by default. */
@@ -139,25 +139,25 @@ export function createMemoryUpkeep(deps) {
         // From here to the journal rows there is no await, so no write interleaves.
         if (!upkeepEnabled(deps.bot(bot.id)))
             return off;
-        const { parsed, added, topics, full } = writing(bot.id, () => {
+        const { parsed, added, topics } = writing(bot.id, () => {
             const before = readRaw(bot.id, "MEMORY.md");
+            const archiveBefore = readRaw(bot.id, ARCHIVE_PATH);
             const parsed = parseCandidates(answer, today);
             const fresh = newCandidates(parsed, before ?? "");
             const source = `${deps.sourceLabel(bot.id, batch.threadId)} (noticed)`;
             let added = 0;
-            let full = false;
             const byTopic = new Map();
             for (const candidate of fresh) {
                 if (candidate.topic) {
                     byTopic.set(candidate.topic, [...(byTopic.get(candidate.topic) ?? []), candidate]);
                     continue;
                 }
-                const result = updateMemory(bot.id, { action: "append", text: candidate.text, ...(candidate.until ? { until: candidate.until } : {}) }, { source, now: now() });
-                if (result.ok)
+                if (updateMemory(bot.id, { action: "append", text: candidate.text, ...(candidate.until ? { until: candidate.until } : {}) }, { source, now: now() }).ok)
                     added += 1;
-                else if (result.code === "over-budget")
-                    full = true;
             }
+            // Older entries the appends moved out are journaled first, as the
+            // tidy-up does, so undoing the newest row (MEMORY.md) brings them back.
+            recordMemoryChange(bot.id, { path: ARCHIVE_PATH, actor: "upkeep", via: "capture", threadId: batch.threadId, before: archiveBefore, after: readRaw(bot.id, ARCHIVE_PATH) });
             if (added)
                 recordMemoryChange(bot.id, { path: "MEMORY.md", actor: "upkeep", via: "capture", threadId: batch.threadId, before, after: readRaw(bot.id, "MEMORY.md") });
             // Detail goes to a topic file the bot keeps for that subject, created
@@ -188,7 +188,7 @@ export function createMemoryUpkeep(deps) {
                 existing.set(name.toLowerCase(), name);
                 topics += lines.length;
             }
-            return { parsed, added, topics, full };
+            return { parsed, added, topics };
         });
         // Only the owner's own words reach About me: on a shared workspace
         // another person's facts are not the owner's profile. Every parsed fact
@@ -199,7 +199,7 @@ export function createMemoryUpkeep(deps) {
         // whoever wrote MEMORY.md — the bot, the person or this capture — detail
         // that is not core moves to its topic now, not only at night
         const organized = await organize(bot.id);
-        const report = { at, added, topics, aboutMe, organized, ...(full ? { note: "MEMORY.md is full; the tidy-up or a person needs to make room." } : {}) };
+        const report = { at, added, topics, aboutMe, organized };
         record(bot.id, { lastCapture: report });
         if (added || topics || aboutMe)
             log(`memory upkeep: noticed ${added} fact(s) for MEMORY.md, ${topics} for topic files and ${aboutMe} for About me — ${bot.name} (${bot.id}) from ${batch.threadId}`);
@@ -284,11 +284,9 @@ export function createMemoryUpkeep(deps) {
         });
     }
     function appendArchive(botId, archived) {
-        const archivePath = `memory/${ARCHIVE_TOPIC}`;
-        const archiveBefore = readRaw(botId, archivePath);
-        const head = archiveBefore ?? "---\ntitle: Archive\ndescription: expired notes moved out by the tidy-up\n---\n";
-        writeMemoryTopic(botId, ARCHIVE_TOPIC, `${head}${head.endsWith("\n") ? "" : "\n"}${archived.join("\n")}\n`);
-        recordMemoryChange(botId, { path: archivePath, actor: "upkeep", via: "tidy", before: archiveBefore, after: readRaw(botId, archivePath) });
+        const archiveBefore = readRaw(botId, ARCHIVE_PATH);
+        appendMemoryArchive(botId, archived);
+        recordMemoryChange(botId, { path: ARCHIVE_PATH, actor: "upkeep", via: "tidy", before: archiveBefore, after: readRaw(botId, ARCHIVE_PATH) });
     }
     async function runTidy(botId) {
         const bot = deps.bot(botId);

package/dist-server/server/message-file.js

@@ -259,16 +259,12 @@ function safeDisplayName(value) {
     return boundedDisplayName(clean || "download");
 }
 /**
- * Confirm that a stored user message carries the requested attachment as an
- * exact standalone transport tag. Plain prose, inline examples, fenced code,
- * and near-matching paths do not grant access. The HTTP route pairs this
- * message capability with ATTACHMENTS_DIR containment, so this can never
- * become an arbitrary host-file reader.
+ * The user-facing name of the requested attachment when a stored user
+ * message carries it as an exact standalone transport tag, else null. Plain
+ * prose, inline examples, fenced code, and near-matching paths do not grant
+ * access. The HTTP route pairs this message capability with ATTACHMENTS_DIR
+ * containment, so this can never become an arbitrary host-file reader.
  */
-export function messageReferencesAttachment(text, requested) {
-    return messageAttachmentName(text, requested) !== null;
-}
-/** Return the user-facing name carried by an authorised attachment tag. */
 export function messageAttachmentName(text, requested) {
     let wanted;
     try {

package/dist-server/server/outbound-counts.js

@@ -0,0 +1,79 @@
+// How many outbound calls each bot has made today. The daily cap in a
+// bot's outbound policy is only as good as this number, so it lives on
+// disk (0600, like every other record that names what a bot did) and is
+// keyed by the local day, so it rolls over at midnight and not at the
+// next restart.
+//
+// One day is kept per bot: the count exists to enforce today's cap, and
+// the activity log already keeps the history.
+import { readFileSync } from "node:fs";
+import { writeFileAtomic } from "./atomic.js";
+const dayKey = (date) => `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+export class OutboundCounts {
+    file;
+    stored;
+    readable = true;
+    constructor(file) {
+        this.file = file;
+        this.stored = this.load();
+    }
+    load() {
+        try {
+            const value = JSON.parse(readFileSync(this.file, "utf8"));
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                throw new Error("invalid outbound counts");
+            const stored = {};
+            for (const [botId, entry] of Object.entries(value)) {
+                if (!entry || typeof entry !== "object")
+                    throw new Error("invalid outbound count");
+                const { day, count } = entry;
+                if (typeof day === "string" && typeof count === "number" && Number.isInteger(count) && count >= 0) {
+                    stored[botId] = { day, count };
+                }
+                else
+                    throw new Error("invalid outbound count");
+            }
+            return stored;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                this.readable = false;
+            return {};
+        }
+    }
+    save() {
+        writeFileAtomic(this.file, JSON.stringify(this.stored, null, 2), { mode: 0o600 });
+    }
+    /** How many outbound calls this bot has made on the day `now` falls in. */
+    today(botId, now = new Date()) {
+        if (!this.readable)
+            throw new Error("the daily allowance could not be read");
+        const entry = this.stored[botId];
+        return entry && entry.day === dayKey(now) ? entry.count : 0;
+    }
+    /** Count one more, and return the new total for the day. */
+    record(botId, now = new Date()) {
+        return this.reserve(botId, 1, Number.MAX_SAFE_INTEGER, now);
+    }
+    /** Reserve before any provider await. An uncertain send keeps its slot:
+     * refunding transport failures could repeat a send already delivered. */
+    reserve(botId, amount, cap, now = new Date()) {
+        const day = dayKey(now);
+        const entry = this.stored[botId];
+        const count = this.today(botId, now) + amount;
+        if (count > cap)
+            return null;
+        this.stored[botId] = { day, count };
+        try {
+            this.save();
+        }
+        catch (error) {
+            if (entry)
+                this.stored[botId] = entry;
+            else
+                delete this.stored[botId];
+            throw error;
+        }
+        return count;
+    }
+}

package/dist-server/server/outbound-requests.js

@@ -0,0 +1,60 @@
+// Outbound calls held for a person's answer.
+//
+// The connector relay opens one of these when a bot's tool call would send
+// something and the bot's policy says ask. The relay then waits on
+// `answer`; the respond route resolves it when the card is answered. The
+// contract mirrors the other card services: a request is claimed exactly
+// once, a second answer says so instead of doing anything, and nothing
+// waits forever — the relay has its own deadline, so the hold has one too.
+//
+// In-memory on purpose. A restart drops every held relay along with the
+// proxy process that was waiting on it; the card left on the thread then
+// settles as unavailable, the same way an engine's own request does.
+import { randomUUID } from "node:crypto";
+export class OutboundRequestService {
+    held = new Map();
+    /** Hold one call. `answer` settles with the person's verdict or a timeout. */
+    open(input) {
+        const requestId = randomUUID();
+        let settle;
+        const answer = new Promise((resolve) => {
+            settle = resolve;
+        });
+        const timer = setTimeout(() => this.settle(requestId, "timeout"), input.timeoutMs);
+        timer.unref?.();
+        this.held.set(requestId, { botId: input.botId, threadId: input.threadId, tool: input.tool, settle, timer });
+        return { requestId, answer };
+    }
+    settle(requestId, answer) {
+        const entry = this.held.get(requestId);
+        if (!entry || entry.answered)
+            return;
+        entry.answered = answer;
+        clearTimeout(entry.timer);
+        entry.settle(answer);
+    }
+    /** The person's answer, from the respond route. */
+    resolve(input) {
+        const entry = this.held.get(input.requestId);
+        if (!entry || entry.threadId !== input.threadId)
+            return { claimed: false };
+        if (entry.answered)
+            return { claimed: true, state: "already_settled", behavior: entry.answered };
+        const answer = input.behavior === "allow" ? "allow" : "deny";
+        this.settle(input.requestId, answer);
+        return { claimed: true, state: answer === "allow" ? "allowed" : "denied" };
+    }
+    /** Requests still waiting in a thread, oldest first. */
+    pending(threadId) {
+        return [...this.held.entries()]
+            .filter(([, entry]) => entry.threadId === threadId && !entry.answered)
+            .map(([requestId]) => requestId);
+    }
+    /** Forget a settled request once its waiter has read the answer. */
+    forget(requestId) {
+        const entry = this.held.get(requestId);
+        if (entry)
+            clearTimeout(entry.timer);
+        this.held.delete(requestId);
+    }
+}

package/dist-server/server/package-import.js

@@ -41,7 +41,7 @@ export class PackageImportError extends Error {
 export function orgInstallId(adminOrigin, organizationId, packageId) {
     return createHash("sha256").update(`omb-install:v1\n${adminOrigin}\n${organizationId}\n${packageId}`, "utf8").digest("hex").slice(0, 32);
 }
-function memberFromAgent(agent) {
+export function memberFromAgent(agent) {
     return {
         key: agent.key,
         name: agent.name,

package/dist-server/server/peer-delivery.js

@@ -43,6 +43,7 @@ export function peerDeliveryReceipt(receipt) {
         detail: clip(receipt.detail) || "no detail recorded",
         ...(receipt.taskId ? { taskId: receipt.taskId } : {}),
         ...(receipt.requestId ? { requestId: receipt.requestId } : {}),
+        ...(receipt.threadId ? { threadId: receipt.threadId } : {}),
     };
 }
 const named = (receipt) => peerName(receipt.botName ?? "") || peerName(receipt.botId) || "teammate";

package/dist-server/server/proxy-paths.js

@@ -31,7 +31,8 @@ export function resolveProxy(relative) {
  * the smoke test can assert each one actually exists in a packaged layout —
  * the check that would have caught the 0.1.24 breakage. */
 export const SPAWNED_PROXIES = {
-    browser: resolveProxy("browser-proxy"),
+    // The built-in browser and the cloud computer: argv[2] picks which.
+    harnessMcp: resolveProxy("harness-mcp-proxy"),
     localComputer: resolveProxy("local-computer-proxy"),
     permission: resolveProxy("permission-proxy"),
     containerMcp: resolveProxy("container-mcp"),

package/dist-server/server/room-handoffs.js

@@ -225,20 +225,12 @@ export class RoomHandoffs {
         if (path.some(n => n.botId === target.botId && (!n.groupId || !target.groupId || n.groupId === target.groupId))) {
             throw new Error("Cannot assign work back to an ancestor; results return automatically");
         }
-        const existing = this.children(parent.id).find(n => n.key === key);
-        if (existing) {
-            if (existing.groupId !== target.groupId || existing.botId !== target.botId || existing.text !== text ||
-                existing.kind !== kind || existing.requestBatchKey !== requestBatchKey)
-                throw new Error("request_key was already used for different work");
+        // The same text to the same teammate and place under one parent is one
+        // request, so a repeat lands on it. Only rework=true runs a finished or
+        // failed one again.
+        const existing = this.children(parent.id).findLast(n => n.botId === target.botId && n.groupId === target.groupId && n.text === text);
+        if (existing && !(rework && terminal(existing)))
             return { node: existing, duplicate: true };
-        }
-        if (requestBatchKey && target.groupId) {
-            const batch = this.children(parent.id).filter(n => n.requestBatchKey === requestBatchKey && n.groupId === target.groupId);
-            if (batch.some(n => n.text !== text || n.threadId !== target.threadId))
-                throw new Error("request_key was already used for different room work");
-            if (batch.some(n => n.startedAt !== undefined))
-                throw new Error("This shared room request has already started; use a new request_key for additional recipients");
-        }
         if (!rework && this.children(parent.id).some(n => n.kind === kind &&
             n.groupId === target.groupId && n.botId === target.botId && n.status === "completed")) {
             throw new Error("This agent already completed your assignment. Do not send acknowledgements or approvals as new work. Finish with your decision; results return automatically. Only use rework=true for concrete additional work.");

package/dist-server/server/routine-requests.js

@@ -677,7 +677,7 @@ function cardCopy(operation, manager, timeZone, now) {
     const nextRunAt = nextForOperation(operation, manager, now);
     const scheduleTimeZone = definition.schedule.type === "cron" ? definition.schedule.timeZone : timeZone;
     const when = operation.action === "run_now" ? "Now" : scheduleText(definition.schedule, timeZone);
-    const destination = definition.runOn === "cloud" ? "Boat-hosted agent" : "Bot’s current model and configured computer";
+    const destination = definition.runOn === "cloud" ? "Bot’s current model on its Boat cloud computer" : "Bot’s current model and configured computer";
     const current = operation.action === "create"
         ? null
         : manager.listRoutines().find((routine) => routine.id === operation.routineId) ?? null;

package/dist-server/server/routines.js

@@ -1381,7 +1381,11 @@ export class RoutineManager {
             if (event.denials?.length)
                 run.denials = [...new Set([...(run.denials ?? []), ...event.denials])];
             if (!event.ok) {
-                this.failRun(run, event.stopReason ?? run.error ?? "The bot did not complete this run");
+                const genericStopReason = event.stopReason === "error" || event.stopReason === "tool_error";
+                this.failRun(run, (genericStopReason ? run.error : undefined) ??
+                    event.stopReason ??
+                    run.error ??
+                    "The bot did not complete this run");
                 queueMicrotask(() => void this.tick());
                 return cloneRun(run);
             }

package/dist-server/server/setup-mode.js

@@ -51,8 +51,6 @@ function buildSetupPrompt(profileAside, cwd) {
         " Full Access does not supply answers, credentials, or broader permissions for another bot. A credential request still needs the user's secure entry. Report failed or cancelled changes honestly." +
         " Finish by saying exactly what remains for the user to do by hand — authorizing an app or account (OAuth), creating a third-party application or bot token, or deciding a pending review — and point them to the Access section of the bot's settings for the app connections.");
 }
-/** The setup block naming skill_manage, for a turn with skill authoring on. */
-export const SETUP_PROMPT = buildSetupPrompt(SKILL_MANAGE_ASIDE);
 export function setupSystemPrompt(active, options) {
     if (!active)
         return "";

package/dist-server/server/skill-learn.js

@@ -6,7 +6,6 @@
 // prompt and recognises the slash command, so it works on every engine
 // that mounts the agents tools.
 import { SAVE_RUN_AS_SKILL_LINE } from "../shared/learn-request.js";
-export const LEARN_COMMAND = "/learn";
 export const LEARN_SOURCE_PREFIX = "learn:";
 export const LEARN_PROMPT_MARKER = "[/learn]";
 export const LEARN_DESCRIPTION_SOFT_MAX = 60;

package/dist-server/server/skill-library.js

@@ -106,9 +106,6 @@ export function mergeSkills(bundled, user) {
     }
     return [...byId.values()];
 }
-export function skillInstructionsFor(text, capabilities, skills, options) {
-    return renderSkillInstructions(selectBundledSkills(text, capabilities, skills), options);
-}
 export function selectBundledSkills(text, capabilities, skills) {
     const haystack = text.toLowerCase();
     const available = new Set(capabilities);
@@ -309,15 +306,3 @@ export function setLibrarySkillReviewState(name, reviewState, root = skillsLibra
     skillLibraryEvents.emit("invalidate", { kind: "review-state", name });
     return librarySkillListing(root, entry);
 }
-/** The lane's one resolution rule, stated once: a skill name means the
- * bot-private copy when one exists, else the library entry, else the
- * bundled skill. Later slices route every lookup through this order. */
-export function resolveSkillSourceOrder(name, sources) {
-    if (sources.private !== undefined)
-        return { source: "private", name, value: sources.private };
-    if (sources.library !== undefined)
-        return { source: "library", name, value: sources.library };
-    if (sources.bundled !== undefined)
-        return { source: "bundled", name, value: sources.bundled };
-    return null;
-}

package/dist-server/server/store.js

@@ -1463,7 +1463,7 @@ export class Store {
         const full = { id: newId(), at: Date.now(), ...redactBotAuthored(message), parentId: anchorId };
         const children = t.messages.filter((m) => m.parentId === anchorId);
         t.messages.push(full);
-        mdb.appendMessage(threadId, full);
+        mdb.insertMessage(threadId, full); // the leaf stays where it was, in SQLite too
         if (full.kind === "screen") {
             for (const pruned of this.pruneScreenFrames(t)) {
                 mdb.updateMessage(threadId, pruned);
@@ -2376,6 +2376,14 @@ export class Store {
     taskByThread(botId, threadId) {
         return this.bot(botId)?.tasks?.find((t) => t.threadId === threadId);
     }
+    /** The thread `fromBotId` opened on this bot from its conversation
+     * `fromThreadId` with coordinate_bots: one per conversation and teammate,
+     * so whatever that conversation sends later continues it. A thread the
+     * person archived is left alone. */
+    workThread(botId, fromBotId, fromThreadId) {
+        return this.tasks(botId).find((t) => t.openedBy?.kind === "work" && t.openedBy.botId === fromBotId &&
+            t.openedBy.threadId === fromThreadId && t.archivedAt === undefined);
+    }
     /** A turn gets an independent snapshot without changing the selected task
      * or mutating the bot's defaults while another turn is running. */
     projectBotForTask(botId, threadId) {