openmausbot 0.1.89 → 0.1.91

package/dist-server/server/decider/jev.js

@@ -0,0 +1,183 @@
+export const JEV_DEFAULT_BASE_URL = "https://api.typesafe.ai";
+export const JEV_MODEL = "jev-latest";
+export const JEV_MAX_OPTIONS = 255;
+export const JEV_MIN_LEVELS = 2;
+export const JEV_MAX_LEVELS = 10;
+function isLoopback(hostname) {
+    const host = hostname.replace(/^\[|\]$/g, "");
+    return host === "localhost" || host === "127.0.0.1" || host === "::1" || host.startsWith("127.");
+}
+/** The endpoint for a base URL, or null when the key must not be sent there:
+ * https anywhere, plain http only to this machine (a local Jev-compatible
+ * server or a test double). */
+export function jevEndpoint(baseUrl) {
+    const root = (baseUrl?.trim() || JEV_DEFAULT_BASE_URL).replace(/\/+$/, "");
+    let url;
+    try {
+        url = new URL(`${root}/v1/systemone`);
+    }
+    catch {
+        return null;
+    }
+    if (url.username || url.password)
+        return null;
+    if (url.protocol === "https:")
+        return url;
+    return url.protocol === "http:" && isLoopback(url.hostname) ? url : null;
+}
+/** Questions within the API's limits: 2–255 options, 2–10 levels. */
+export function questionsFit(questions) {
+    const entries = Object.entries(questions);
+    if (!entries.length)
+        return false;
+    return entries.every(([, question]) => {
+        if (question.type === "choice") {
+            const count = Object.keys(question.options).length;
+            return count >= 2 && count <= JEV_MAX_OPTIONS;
+        }
+        if (question.type === "score")
+            return question.levels.length >= JEV_MIN_LEVELS && question.levels.length <= JEV_MAX_LEVELS;
+        return true;
+    });
+}
+export function jevRequestBody(state, questions) {
+    const wire = {};
+    for (const [id, question] of Object.entries(questions)) {
+        if (question.type === "choice") {
+            wire[id] = { type: "choice", instructions: question.instructions, criteria: { ...question.options } };
+        }
+        else if (question.type === "score") {
+            wire[id] = { type: "score", instructions: question.instructions, criteria: [...question.levels] };
+        }
+        else {
+            const criteria = question.criteria?.yes || question.criteria?.no
+                ? { ...(question.criteria.yes ? { true: question.criteria.yes } : {}), ...(question.criteria.no ? { false: question.criteria.no } : {}) }
+                : undefined;
+            wire[id] = { type: "noul", instructions: question.instructions, ...(criteria ? { criteria } : {}) };
+        }
+    }
+    return { state, model: JEV_MODEL, questions: wire };
+}
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const isProbability = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+/** Jev rounds to two places, so a map can sum to 0.98 or 1.02. */
+const SUM_TOLERANCE = 0.1;
+const EPSILON = 1e-9;
+function parseChoice(raw, question) {
+    const offered = new Set(Object.keys(question.options));
+    const choice = raw.choice;
+    if (typeof choice !== "string" || !offered.has(choice))
+        return null;
+    if (!isRecord(raw.probabilities))
+        return null;
+    const probabilities = {};
+    let sum = 0;
+    for (const [key, value] of Object.entries(raw.probabilities)) {
+        if (!offered.has(key) || !isProbability(value))
+            return null;
+        probabilities[key] = value;
+        sum += value;
+    }
+    if (!(Math.abs(sum - 1) <= SUM_TOLERANCE))
+        return null;
+    const pTop = probabilities[choice];
+    if (pTop === undefined)
+        return null;
+    const others = Object.entries(probabilities).filter(([key]) => key !== choice).map(([, value]) => value);
+    const runnerUp = others.length ? Math.max(...others) : 0;
+    // Ties break to the first key on the vendor side; a choice that is not
+    // the most likely option means the answer is not what it claims to be.
+    if (runnerUp > pTop + EPSILON)
+        return null;
+    return { type: "choice", choice, pTop, margin: pTop - runnerUp, probabilities };
+}
+function parseScore(raw, question) {
+    const levels = question.levels.length;
+    const score = raw.score;
+    if (typeof score !== "number" || !Number.isFinite(score) || score < -EPSILON || score > levels - 1 + EPSILON)
+        return null;
+    if (!isRecord(raw.probabilities))
+        return null;
+    const probabilities = Array.from({ length: levels }, () => 0);
+    for (const [key, value] of Object.entries(raw.probabilities)) {
+        const index = Number(key);
+        if (!Number.isInteger(index) || index < 0 || index >= levels || String(index) !== key || !isProbability(value))
+            return null;
+        probabilities[index] = value;
+    }
+    const sum = probabilities.reduce((total, value) => total + value, 0);
+    if (!(Math.abs(sum - 1) <= SUM_TOLERANCE))
+        return null;
+    const level = probabilities.indexOf(Math.max(...probabilities));
+    return { type: "score", score, level, probabilities };
+}
+function parseYesNo(raw) {
+    return isProbability(raw.noul) ? { type: "yesno", p: raw.noul } : null;
+}
+const WIRE_TYPE = { choice: "choice", score: "score", yesno: "noul" };
+/** Strictly decode one response body against the questions that were asked. */
+export function parseJevResponse(body, questions) {
+    if (!isRecord(body) || !isRecord(body.answers))
+        return { ok: false };
+    const answers = {};
+    for (const [id, question] of Object.entries(questions)) {
+        const raw = body.answers[id];
+        if (!isRecord(raw))
+            return { ok: false };
+        if (raw.type !== undefined && raw.type !== WIRE_TYPE[question.type])
+            return { ok: false };
+        const parsed = question.type === "choice" ? parseChoice(raw, question)
+            : question.type === "score" ? parseScore(raw, question)
+                : parseYesNo(raw);
+        if (!parsed)
+            return { ok: false };
+        answers[id] = parsed;
+    }
+    const usage = isRecord(body.usage) ? body.usage.input_tokens : undefined;
+    const inputTokens = typeof usage === "number" && Number.isFinite(usage) && usage >= 0 ? usage : undefined;
+    const model = typeof body.model === "string" && body.model.length <= 80 ? body.model : undefined;
+    return { ok: true, answers, ...(inputTokens !== undefined ? { inputTokens } : {}), ...(model ? { model } : {}) };
+}
+function refusal(status) {
+    if (status === 401 || status === 403)
+        return { ok: false, reason: "rejected", status };
+    if (status === 429)
+        return { ok: false, reason: "rate_limited", status };
+    if (status === 529 || status === 503)
+        return { ok: false, reason: "overloaded", status };
+    return { ok: false, reason: "http_error", status };
+}
+async function decide(request) {
+    const endpoint = jevEndpoint(request.baseUrl);
+    if (!endpoint || !questionsFit(request.questions))
+        return { ok: false, reason: "misconfigured" };
+    let response;
+    try {
+        response = await request.fetch(endpoint, {
+            method: "POST",
+            headers: { authorization: `Bearer ${request.key}`, "content-type": "application/json", accept: "application/json" },
+            body: JSON.stringify(jevRequestBody(request.state, request.questions)),
+            signal: request.signal,
+            // Never replay the key to wherever a redirect points.
+            redirect: "error",
+        });
+    }
+    catch {
+        // The caller tells a timeout or a Stop from a dead network by its own signals.
+        return { ok: false, reason: "unreachable" };
+    }
+    if (!response.ok) {
+        await response.body?.cancel().catch(() => undefined);
+        return refusal(response.status);
+    }
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        return { ok: false, reason: "malformed" };
+    }
+    const parsed = parseJevResponse(body, request.questions);
+    return parsed.ok ? parsed : { ok: false, reason: "malformed" };
+}
+export const jevBackend = { id: "jev", decide };

package/dist-server/server/decider/log.js

@@ -0,0 +1,62 @@
+// The decision model's own log: one row per call that reached a backend,
+// one file per UTC month under <data>/decider-log/YYYY-MM.ndjson.
+//
+// Not the authorization decision log (server/decision-log.ts, <data>/
+// decisions/), which records approvals. This one records what a fast
+// classifier picked and how sure it was, so its accuracy and cost can be
+// measured later. A row never holds the message text, the options' text or
+// the key: only the seam, the chosen option key (a bot id for room routing),
+// the probabilities and a short hash of the state.
+//
+// Same discipline as the other logs: 0600, fire-and-forget, serialized per
+// directory, and months older than the shared retention window pruned.
+import { createHash } from "node:crypto";
+import { appendFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { boundRetentionDays, pruneMonthFiles } from "../decision-log.js";
+export const DECIDER_LOG_DIR = "decider-log";
+const PRUNE_EVERY_MS = 60 * 60_000;
+const writeQueues = new Map();
+const lastPrune = new Map();
+export function stateHash(state) {
+    let text;
+    try {
+        text = JSON.stringify(state) ?? "";
+    }
+    catch {
+        text = "";
+    }
+    return createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+function monthKey(at) {
+    return `${at.getUTCFullYear()}-${String(at.getUTCMonth() + 1).padStart(2, "0")}`;
+}
+export function deciderLogFileFor(dataDir, at) {
+    return join(dataDir, DECIDER_LOG_DIR, `${monthKey(at)}.ndjson`);
+}
+async function write(dataDir, row) {
+    const at = new Date(row.at);
+    await mkdir(join(dataDir, DECIDER_LOG_DIR), { recursive: true, mode: 0o700 });
+    await appendFile(deciderLogFileFor(dataDir, at), JSON.stringify(row) + "\n", { mode: 0o600 });
+    if (at.getTime() - (lastPrune.get(dataDir) ?? 0) >= PRUNE_EVERY_MS) {
+        lastPrune.set(dataDir, at.getTime());
+        await pruneMonthFiles(join(dataDir, DECIDER_LOG_DIR), boundRetentionDays(), at);
+    }
+}
+/** Append one row. Never throws and never waits: a full disk must not turn
+ * into a slower or failed room turn. */
+export function appendDeciderLog(dataDir, row) {
+    const previous = writeQueues.get(dataDir) ?? Promise.resolve();
+    const queued = previous.then(() => write(dataDir, row)).catch(() => {
+        /* logging must never take down a decision */
+    });
+    writeQueues.set(dataDir, queued);
+    void queued.finally(() => {
+        if (writeQueues.get(dataDir) === queued)
+            writeQueues.delete(dataDir);
+    });
+}
+/** Test seam: wait until every queued row for this directory is on disk. */
+export async function flushDeciderLog(dataDir) {
+    await writeQueues.get(dataDir);
+}

package/dist-server/server/decider/relay.js

@@ -0,0 +1,52 @@
+// What Cloud Pro's decision relay accepts through the included token
+// (docs/cloud-pro.md, "Included Boat computers, voice and decisions"; the
+// Admin checks the same): room routing's one request and the Settings key
+// check, within its size caps. Anything else (another job, another question,
+// a larger state) is never sent through the included token: it goes only
+// with the person's own key, until the relay accepts it too.
+import { jevRequestBody } from "./jev.js";
+import { ROOM_ROUTING_INSTRUCTIONS, ROOM_ROUTING_STATE_KEYS } from "./room-routing.js";
+/** The Settings key check's fixed request. */
+export const KEY_CHECK_STATE = { purpose: "OpenMausBot is checking that a decision-model key works." };
+export const KEY_CHECK_QUESTION = "Is this a connection check?";
+/** The relay's caps: the whole request body, and the state as JSON. Both
+ * measured in UTF-8 bytes, which is never less than characters. */
+export const RELAY_MAX_BODY_BYTES = 64 * 1024;
+export const RELAY_MAX_STATE_BYTES = 24_000;
+/** Where a request may use the included token. A job added later is not here
+ * until the relay accepts it. */
+const RELAY_SEAMS = new Set(["roomRouting", "keyCheck"]);
+const ROOM_STATE_KEYS = new Set(ROOM_ROUTING_STATE_KEYS);
+const ROOM_STATE_REQUIRED = ROOM_ROUTING_STATE_KEYS.filter((key) => key !== "recent_messages");
+export function relaySeam(seam) {
+    return RELAY_SEAMS.has(seam);
+}
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+function shapeFits(seam, state, questions) {
+    const ids = Object.keys(questions);
+    const question = questions.answer;
+    if (ids.length !== 1 || !question)
+        return false;
+    if (seam === "keyCheck") {
+        return question.type === "yesno" && question.instructions === KEY_CHECK_QUESTION && !question.criteria &&
+            JSON.stringify(state) === JSON.stringify(KEY_CHECK_STATE);
+    }
+    if (seam === "roomRouting") {
+        return question.type === "choice" && question.instructions === ROOM_ROUTING_INSTRUCTIONS && isRecord(state) &&
+            Object.keys(state).every((key) => ROOM_STATE_KEYS.has(key)) && ROOM_STATE_REQUIRED.every((key) => key in state);
+    }
+    // Any other seam: the relay takes nothing from it.
+    return false;
+}
+/** Whether this exact request may go through the included token. */
+export function relayAccepts(seam, state, questions) {
+    try {
+        if (!shapeFits(seam, state, questions))
+            return false;
+        return Buffer.byteLength(JSON.stringify(state)) <= RELAY_MAX_STATE_BYTES &&
+            Buffer.byteLength(JSON.stringify(jevRequestBody(state, questions))) <= RELAY_MAX_BODY_BYTES;
+    }
+    catch {
+        return false;
+    }
+}

package/dist-server/server/decider/room-routing.js

@@ -0,0 +1,88 @@
+/** Turn starts take seconds anyway, and people far from the US West Coast
+ * see 400–700 ms round trips; 1.5 s keeps a slow answer usable. */
+export const ROOM_ROUTING_TIMEOUT_MS = 1_500;
+/** Bench calibration: answers at >= 0.6 were right 92–99% of the time. */
+export const ROOM_ROUTING_MIN_PROBABILITY = 0.6;
+export const EVERYONE_OPTION = "__everyone__";
+const EVERYONE_MEANING = "Several members: the message explicitly needs answers or work from more than one member of the room, for example it asks everyone or asks each member for their part.";
+/** Fixed: Cloud Pro's decision relay accepts room routing only with these
+ * exact instructions (relay.ts). */
+export const ROOM_ROUTING_INSTRUCTIONS = "Which bot in this room should answer `new_message`? Choose __everyone__ only when the message needs several members to answer.";
+/** Every key the state may carry; `recent_messages` is left out when there
+ * are none. Cloud Pro's relay accepts no other. */
+export const ROOM_ROUTING_STATE_KEYS = ["room", "humans_in_room", "bots_in_room", "recent_messages", "new_message"];
+const NAME_MAX = 80;
+const TITLE_MAX = 120;
+const DESCRIPTION_MAX = 400;
+const LINE_MAX = 500;
+/** The room context window bounds how many lines; this bounds their size,
+ * because large irrelevant state makes the classifier worse, not better. */
+const RECENT_BUDGET_CHARS = 6_000;
+function clip(value, max) {
+    const flat = value.replace(/\s+/g, " ").trim();
+    return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+/** What one bot is, as an option: "Maya, Product Designer. Owns UI…". */
+export function memberOption(member) {
+    const name = clip(member.name, NAME_MAX) || "Unnamed bot";
+    const title = member.title ? clip(member.title, TITLE_MAX) : "";
+    const description = member.description ? clip(member.description, DESCRIPTION_MAX) : "";
+    return `${name}${title ? `, ${title}` : ""} bot.${description ? ` ${description}` : ""}`;
+}
+/** The newest lines that fit the budget, oldest first, each clipped. */
+function recentWithinBudget(recent) {
+    const kept = [];
+    let used = 0;
+    for (let index = recent.length - 1; index >= 0; index--) {
+        const line = recent[index];
+        const text = clip(line.text, LINE_MAX);
+        if (!text)
+            continue;
+        const size = text.length + line.from.length;
+        if (used + size > RECENT_BUDGET_CHARS)
+            break;
+        used += size;
+        kept.unshift({ from: clip(line.from, NAME_MAX), text });
+    }
+    return kept;
+}
+export function roomRoutingRequest(input) {
+    const options = {};
+    for (const member of input.members)
+        options[member.id] = memberOption(member);
+    options[EVERYONE_OPTION] = EVERYONE_MEANING;
+    const recent = recentWithinBudget(input.recent);
+    const state = {
+        room: clip(input.room, NAME_MAX),
+        humans_in_room: input.humans.map((human) => clip(human, NAME_MAX)),
+        bots_in_room: input.members.map((member) => clip(member.name, NAME_MAX)),
+        ...(recent.length ? { recent_messages: recent } : {}),
+        new_message: { from: clip(input.message.from, NAME_MAX), text: input.message.text.trim().slice(0, 8_000) },
+    };
+    return { state, question: { instructions: ROOM_ROUTING_INSTRUCTIONS, options } };
+}
+/** Ask once and turn the answer into a route. Never throws. */
+export async function decideRoomResponder(decider, input, options = {}) {
+    try {
+        if (input.members.length < 2)
+            return { kind: "fallback", reason: "no_choice" };
+        const { state, question } = roomRoutingRequest(input);
+        const result = await decider.choose("roomRouting", state, question, {
+            timeoutMs: options.timeoutMs ?? ROOM_ROUTING_TIMEOUT_MS,
+            signal: options.signal,
+        });
+        if (!result.ok)
+            return { kind: "fallback", reason: result.reason };
+        const { choice, pTop } = result.answers;
+        if (pTop < ROOM_ROUTING_MIN_PROBABILITY)
+            return { kind: "fallback", reason: "low_confidence" };
+        if (choice === EVERYONE_OPTION)
+            return { kind: "everyone", probability: pTop };
+        if (!input.members.some((member) => member.id === choice))
+            return { kind: "fallback", reason: "malformed" };
+        return { kind: "member", botId: choice, probability: pTop };
+    }
+    catch {
+        return { kind: "fallback", reason: "malformed" };
+    }
+}

package/dist-server/server/decider/types.js

@@ -0,0 +1,5 @@
+// The decision model's vocabulary, shared by every backend and caller. A
+// question is one of three typed shapes; an answer comes back typed to match.
+// Nothing here names a vendor: `jev` is one backend, and another (a local
+// Jev-compatible server, an LLM) plugs in behind the same types.
+export const DECIDER_JOBS = ["roomRouting"];

package/dist-server/server/delegations.js

@@ -259,8 +259,10 @@ export function pendingDelegationSnapshot() {
     })));
 }
 /** How many handoffs one turn may queue. Small on purpose: this is the only
- * thing standing between a confused bot and a fan-out of real turns. */
-const MAX_QUEUED_PER_THREAD = 4;
+ * thing standing between a confused bot and a fan-out of real turns. Six,
+ * not four: a lead running a weekly check-in over a five-member team is the
+ * ordinary case, and hitting the cap there silently dropped one teammate. */
+const MAX_QUEUED_PER_THREAD = 6;
 /** Validate and enqueue a delegation. Pushes a "Delegated to @B: reason"
  * chip to the source thread so the user can see what was queued. */
 export function queueDelegation(bus, from, item, maxDepth, sourceThreadId = from.threadId) {
@@ -838,7 +840,13 @@ export function buildDelegationFailurePrompt(targetName, reason) {
         "Take over: tell the user what failed in plain terms, then decide the next step — retry with a narrower task, do the work yourself, or propose an alternative. Do not re-delegate the exact same task unchanged.",
     ].join("\n\n");
 }
-export const DELEGATION_WAKE_MAX_PER_WINDOW = 3;
+// Must not be smaller than MAX_QUEUED_PER_THREAD: every delegate reply is
+// one wake, so a fan-out that the queue cap allows has to be resumable
+// within the window. Three failed a five-member weekly check-in whose
+// replies all landed inside four minutes ("Delegation follow-up limit
+// reached"), while the same routine passed a week earlier only because the
+// replies happened to spread over twenty.
+export const DELEGATION_WAKE_MAX_PER_WINDOW = 6;
 export const DELEGATION_WAKE_WINDOW_MS = 5 * 60 * 1000;
 /** Bounded auto-wake budget per source thread. A delegation completion
  * wakes the source; if that source re-delegates and the new completion

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

@@ -43,7 +43,7 @@ export function skipSubscriptionAuthForLocalInject(model) {
 import { newEventId, newId, TurnNotStartedError } 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 { MAX_QUESTION_TEXT, 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";
@@ -275,7 +275,7 @@ export function createAcpDriver(support) {
                 };
                 const allowedCredentials = new Set(support.credentialEnv ?? []);
                 // two lists, one rule: foreign PROVIDER keys must not flip a CLI's
-                // billing off its own login, and WORKSPACE credentials (box token,
+                // billing off its own login, and WORKSPACE credentials (boat token,
                 // voice key, …) are the harness's secrets — riding along in
                 // `...process.env` is not a grant. A driver keeps only what its
                 // credentialEnv allowlist names.
@@ -439,7 +439,7 @@ export function createAcpDriver(support) {
                 }
                 // The bot's computer, mounted exactly like the Claude driver does:
                 // host and sandbox Cua connections expose Cua Driver's own MCP server.
-                // (A cloud box is not mounted here at all: a cloud turn runs ON the box.)
+                // (A cloud boat is not mounted here at all: a cloud turn runs ON the boat.)
                 if (turn.integrations?.localComputer) {
                     const local = turn.integrations.localComputer;
                     servers.push({
@@ -722,7 +722,8 @@ 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);
+                    const rawSummary = String(toolCall.rawInput?.command ?? toolCall.title ?? tool);
+                    const summary = rawSummary.slice(0, isQuestion ? MAX_QUESTION_TEXT : 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

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

@@ -278,7 +278,7 @@ function routineFields(args) {
     const runOn = destination(args.run_on ?? args.runOn);
     const timeoutMinutes = args.timeout_minutes ?? args.timeoutMinutes;
     if (runOn != null && runOn !== "maus" && runOn !== "cloud") {
-        return { fields, error: 'Use run_on="maus" for the bot’s current model and configured computer (including VPS), or run_on="box" only for the Box-hosted agent. Legacy "cloud" also means Box.' };
+        return { fields, error: 'Use run_on="maus" for the bot’s current model and configured computer (including VPS), or run_on="box" only for the Boat-hosted agent. Legacy "cloud" also means Boat.' };
     }
     if (timeoutMinutes != null && (typeof timeoutMinutes !== "number" || !Number.isInteger(timeoutMinutes) || timeoutMinutes < 5 || timeoutMinutes > 240)) {
         return { fields, error: "timeout_minutes must be a whole number from 5 to 240. Use clear_timeout to remove a limit." };
@@ -982,11 +982,14 @@ export async function callTool(name, args, context) {
         if (!routineId || !action) {
             return { text: "propose_routine_action needs a routine_id and supported action.", isError: true };
         }
+        const forBotId = String(args.for_bot_id ?? "").trim();
         const body = {
             fromBotId: BOT_ID,
             fromThreadId: THREAD_ID,
             action,
             routineId,
+            // JSON.stringify drops the key entirely when no target was named
+            ...(forBotId ? { forBotId } : {}),
         };
         if (action === "update") {
             if (!jsonRecord(args.changes)) {
@@ -1098,6 +1101,7 @@ export async function callTool(name, args, context) {
                 action: args.action,
                 text: args.text,
                 oldText: args.old_text,
+                ...(typeof args.until === "string" && args.until.trim() ? { until: args.until.trim() } : {}),
             }),
         });
         if (r.error || r.ok !== true) {

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

@@ -24,6 +24,7 @@ export function catalogProfileFromEnv(env) {
         skillAuthoring: env.OMB_SKILL_AUTHORING_ENABLED === "1",
         sharedComputers: env.OMB_SHARED_COMPUTERS_ENABLED === "1",
         voiceNotes: env.OMB_VOICE_NOTES === "1",
+        cloudHome: env.OMB_CLOUD_HOME === "1",
         botId: env.OMB_BOT_ID ?? "",
     };
 }
@@ -128,8 +129,9 @@ const ROUTINE_FIELDS_SCHEMA = {
     schedule: ROUTINE_SCHEDULE_SCHEMA,
     run_on: {
         type: "string",
+        // "box" is Boat's historical run_on destination id (agents wire contract).
         enum: ["maus", "box"],
-        description: "Default maus keeps the bot's selected model and configured computer, INCLUDING a self-hosted VPS. Omit this field for normal schedules. box explicitly switches the agent to the Box-hosted runner; it requires Box setup and is not the generic cloud/VPS option. Legacy cloud values from list_routines mean box, not VPS.",
+        description: "Default maus keeps the bot's selected model and configured computer, INCLUDING a self-hosted VPS. Omit this field for normal schedules. box explicitly switches the agent to the Boat-hosted runner; it requires Boat setup and is not the generic cloud/VPS option. Legacy cloud values from list_routines mean box, not VPS.",
     },
     timeout_minutes: {
         type: "integer",
@@ -293,7 +295,7 @@ const toolDefinitions = (externalRuntime) => [
         description: "Choose where this conversation does computer work. Call with no arguments to inspect actual available choices and the current place. For a task needing computer interaction, select the requested place, or auto to choose a suitable configured computer without asking the user to use menus. OpenMausBot reuses an existing computer first; with a configured provider it can start or provision one when needed. Do not provision for ordinary chat or just to inspect availability. A pending result means end this turn immediately: OpenMausBot updates the conversation selector and resumes the original request with that computer's real tools. Do not use the old tools after requesting a switch, repeat the task, or claim the action is done. This cannot change permissions, override Off, or switch a teammate/routine/channel.",
         inputSchema: { type: "object", additionalProperties: false, properties: {
                 surface: { type: "string", enum: ["auto", "cloud", "vm", "local", "browser"],
-                    description: "auto = suitable configured computer, cloud = remote Box/VPS, vm = isolated Local VM, local = user's own desktop, browser = built-in browser. Omit to list." },
+                    description: "auto = suitable configured computer, cloud = remote Boat/VPS, vm = isolated Local VM, local = user's own desktop, browser = built-in browser. Omit to list." },
             } },
     },
     {
@@ -523,6 +525,7 @@ const toolDefinitions = (externalRuntime) => [
                 action: { type: "string", enum: ["append", "replace", "remove", "supersede"] },
                 text: { type: "string", minLength: 1, description: "Non-blank new text for append, replace, or supersede: the fact itself, without a date or bullet. Omit for remove; use remove to delete a passage." },
                 old_text: { type: "string", minLength: 1, description: "Exact unique existing passage for replace, supersede, or remove. Omit for append." },
+                until: { type: "string", pattern: "^\\d{4}-\\d{2}-\\d{2}$", description: "Optional, for append or supersede: YYYY-MM-DD, the last day a temporary fact holds (an exam this weekend, a trip next week). After that day the entry is hidden from your memory." },
             },
             required: ["action"],
         },
@@ -614,12 +617,16 @@ const toolDefinitions = (externalRuntime) => [
     },
     {
         name: "propose_routine_action",
-        description: "Prepare a user-requested change to one of this bot's existing routines. Use list_routines first to get the routine id." + PROPOSAL_OUTCOME,
+        description: "Prepare a user-requested change to one of this bot's existing routines. Use list_routines first to get the routine id. If the user asks to change ANOTHER bot's routine and that bot is in your section, call list_bots and pass that bot's id as for_bot_id; the routine keeps its owner and every run keeps that bot's engine and permissions." + PROPOSAL_OUTCOME,
         inputSchema: {
             type: "object",
             additionalProperties: false,
             properties: {
                 routine_id: { type: "string", minLength: 1, description: "Routine id from list_routines." },
+                for_bot_id: {
+                    type: "string",
+                    description: "Only when the requested change targets ANOTHER bot's routine and that bot is in your section: that bot's id from list_bots. Learn the routine id from that bot's own routines (it can run list_routines). Omit to change one of your own routines.",
+                },
                 action: {
                     type: "string",
                     enum: ["update", "pause", "resume", "run_now", "delete"],
@@ -753,8 +760,23 @@ const ROOM_ONLY_TOOLS = new Set(["list_room_targets", "coordinate_bots"]);
 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"]);
+// A Cloud home never offers this computer or a Local VM, so its bots are not
+// shown them as choices, nor a VM shell they could never have.
+const LOCAL_VM_TOOL_NAMES = new Set(["vm_exec"]);
+const CLOUD_HOME_SURFACE = {
+    type: "string", enum: ["auto", "cloud", "browser"],
+    description: "auto = suitable configured computer, cloud = remote Boat/VPS, browser = built-in browser. Omit to list. This server runs in the cloud: the user's own computer and a Local VM are not places here.",
+};
 /** The tools one turn is shown, exactly as tools/list serializes them. */
 export function availableTools(profile) {
+    const tools = catalogTools(profile);
+    return profile.cloudHome
+        ? tools.filter(tool => !LOCAL_VM_TOOL_NAMES.has(tool.name)).map(tool => tool.name === "select_computer"
+            ? { ...tool, inputSchema: { ...tool.inputSchema, properties: { surface: CLOUD_HOME_SURFACE } } }
+            : tool)
+        : tools;
+}
+function catalogTools(profile) {
     const TOOLS = toolDefinitions(profile.externalRuntime);
     const BOT_SCOPED_TOOLS = profile.botId === WATCHER_OPTIONS_CARD_BOT_ID
         ? TOOLS