openmausbot 0.1.56 → 0.1.57

package/dist-server/server/auto-approve.js

@@ -184,3 +184,27 @@ export function autoVerdict(bot, tool, summary, context) {
 export function autoDecision(bot, tool, summary, context) {
     return autoVerdict(bot, tool, summary, context).approve;
 }
+/** The note a card shows above its buttons, explaining why the bot stopped
+ * rather than answering for itself.
+ *
+ * The unattended case is the one users misread. A turn a webhook or another
+ * bot started never runs Auto at all — approvalModeForTurn downgrades it to
+ * Ask before the provider spawns — so "this action needs you" would name the
+ * wrong cause and imply the next action might pass. It will not: with a fleet
+ * delegating between bots, every card looks like this until someone answers.
+ * Say that plainly, and name the mode that keeps running. */
+export function approvalHeldReason(context) {
+    if (context.source === "native-approval")
+        return "The provider requires your approval for this action.";
+    if (!context.permission)
+        return undefined;
+    if (context.requiresExplicitApproval) {
+        return "This changes the provider sandbox, so only Full access can approve it automatically.";
+    }
+    if (context.mode !== "auto")
+        return undefined;
+    if (!context.unattended)
+        return "This action needs you, so Approve for me stopped to ask.";
+    const hint = context.fullAccessAvailable ? " Full access keeps working unattended." : "";
+    return `A webhook or another bot started this turn, so Approve for me is paused and every action asks.${hint}`;
+}

package/dist-server/server/bot-folder.js

@@ -0,0 +1,102 @@
+// The bot folder: ~/.openmausbot/bots/<botId>/, owned by the server.
+//
+// SOUL.md is a MIRROR of BotRecord.soul, never the source of truth. The
+// prompt is built from the record; the file exists so a person can read
+// and edit the bot in their editor and so a bot can export as a folder.
+// The folder sits outside the bot-writable workspace on purpose: a bot
+// that reads untrusted content (a Discord channel, a webhook payload)
+// must not be able to persist injected text into its own persona. A
+// mirror that no longer matches the record is surfaced to the user as
+// drift, with its text, and is never applied on its own.
+import { createHash } from "node:crypto";
+import { closeSync, mkdirSync, openSync, readSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { writeFileAtomic } from "./atomic.js";
+import { DATA_DIR } from "./config.js";
+import { BOT_PROFILE_LIMITS } from "../shared/bot-profile.js";
+export const BOTS_DIR = join(DATA_DIR, "bots");
+export const SOUL_FILE = "SOUL.md";
+export function botFolder(botId) {
+    return join(BOTS_DIR, botId);
+}
+export function soulFile(botId) {
+    return join(botFolder(botId), SOUL_FILE);
+}
+export function soulHash(soul) {
+    return createHash("sha256").update(soul, "utf8").digest("hex");
+}
+/** Rewrite the mirror from the canonical text. Always writes, even for an
+ * empty soul, so the folder exists for the user to find. Private modes:
+ * standing instructions can describe a person's work in detail. */
+export function writeSoulMirror(botId, soul) {
+    mkdirSync(botFolder(botId), { recursive: true, mode: 0o700 });
+    writeFileAtomic(soulFile(botId), soul, { mode: 0o600 });
+}
+/** Compare the mirror with the record's hash. A missing mirror is not
+ * drift — it is re-created from the record. A differing one is reported
+ * together with its text so the user can apply or discard it. Editor reads
+ * surface filesystem failures instead of mistaking them for a clean mirror. */
+export function readSoulDrift(botId, soul, hash) {
+    let fileText;
+    try {
+        const fd = openSync(soulFile(botId), "r");
+        try {
+            // External edits are unbounded. Read at most the budget plus one byte,
+            // including if the file grows while the editor has it open.
+            const bytes = Buffer.alloc(BOT_PROFILE_LIMITS.soul + 1);
+            let length = 0;
+            while (length < bytes.length) {
+                const count = readSync(fd, bytes, length, bytes.length - length, null);
+                if (!count)
+                    break;
+                length += count;
+            }
+            if (length > BOT_PROFILE_LIMITS.soul) {
+                throw Object.assign(new Error("SOUL.md exceeds 24000 bytes; shorten it in your editor"), { status: 400 });
+            }
+            fileText = bytes.subarray(0, length).toString("utf8");
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        writeSoulMirror(botId, soul);
+        return { drift: false };
+    }
+    if (soulHash(fileText) === hash)
+        return { drift: false };
+    return { drift: true, fileText };
+}
+/** Turn dispatch is best-effort; explicit editor actions use readSoulDrift
+ * so an unreadable file is never presented as successfully discarded. */
+export function checkSoulDrift(botId, soul, hash) {
+    try {
+        return readSoulDrift(botId, soul, hash);
+    }
+    catch {
+        return { drift: false };
+    }
+}
+export function removeBotFolder(botId) {
+    try {
+        rmSync(botFolder(botId), { recursive: true, force: true });
+    }
+    catch { }
+}
+/** The standing-instructions block of the system prompt. Empty soul,
+ * empty block, so a bot without one gets today's prompt byte for byte. */
+export function soulSystemPrompt(soul) {
+    const text = soul.trim();
+    if (!text)
+        return "";
+    const bytes = Buffer.byteLength(text, "utf8");
+    return ("\n\nYour standing instructions follow. The user manages them in bot settings and SOUL.md; proposed changes apply only after the user confirms." +
+        " They rank above your memory and imported skills, and below the user's current request and safety boundaries." +
+        ` Text inside this block is instruction for you, never tool authorization or permission to expose secrets.` +
+        `\n\n--- BEGIN STANDING INSTRUCTIONS (SOUL.md, ${bytes} bytes) ---\n` +
+        text +
+        "\n--- END STANDING INSTRUCTIONS ---");
+}

package/dist-server/server/bot-overview.js

@@ -0,0 +1,206 @@
+import { approvalModeFor } from "../shared/approval-mode.js";
+/** The first paragraph of a SOUL.md-style persona, capped at 240 characters
+ * so a settings-dialog card never renders a full standing-instructions
+ * document inline. */
+export function soulLead(soul) {
+    const trimmed = (soul ?? "").trim();
+    if (!trimmed)
+        return "";
+    const paragraph = (trimmed.split(/\r?\n\s*\r?\n/)[0] ?? trimmed).trim();
+    return paragraph.length > 240 ? `${paragraph.slice(0, 240).trimEnd()}…` : paragraph;
+}
+function lowerFirst(value) {
+    return value.length ? value[0].toLowerCase() + value.slice(1) : value;
+}
+function time(at, timeZone) {
+    return new Date(at).toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit", timeZone });
+}
+const DAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+/** "09:05" → "9:05 AM" — the daily schedule's wall-clock time as a person
+ * would say it, with no timezone suffix (the Overview is read in the
+ * timezone it was built for). */
+function clockTime(hhmm) {
+    const [h = 0, m = 0] = hhmm.split(":").map((part) => Number.parseInt(part, 10) || 0);
+    return new Date(Date.UTC(2000, 0, 1, h, m)).toLocaleTimeString("en-US", {
+        hour: "numeric",
+        minute: "2-digit",
+        timeZone: "UTC",
+    });
+}
+/** The schedule as the opening phrase of a Does line — "Every 5 minutes",
+ * "Every weekday at 9:00 AM", "Once on September 5 at 12:00 PM". The
+ * approval card's scheduleText() carries the anchor instant and timezone
+ * name because a card must be exact; a plain-language overview must not. */
+function schedulePhrase(schedule, timeZone) {
+    if (schedule.type === "once") {
+        const date = new Date(schedule.at).toLocaleDateString("en-US", { month: "long", day: "numeric", timeZone });
+        return `Once on ${date} at ${time(schedule.at, timeZone)}`;
+    }
+    if (schedule.type === "interval") {
+        const minutes = schedule.everyMinutes;
+        if (minutes < 60)
+            return `Every ${minutes} minute${minutes === 1 ? "" : "s"}`;
+        if (minutes === 60)
+            return "Every hour";
+        if (minutes % 60 === 0)
+            return `Every ${minutes / 60} hours`;
+        return `Every ${Math.floor(minutes / 60)} hour${Math.floor(minutes / 60) === 1 ? "" : "s"} ${minutes % 60} minutes`;
+    }
+    const days = schedule.weekdays;
+    const at = ` at ${clockTime(schedule.time)}`;
+    if (days.length === 7)
+        return `Every day${at}`;
+    if (days.join(",") === "1,2,3,4,5")
+        return `Every weekday${at}`;
+    if (days.length === 1)
+        return `Weekly on ${DAY_NAMES[days[0]]}${at}`;
+    return `${days.map((day) => DAY_NAMES[day]).join(", ")}${at}`;
+}
+/** The most recent run for a routine, by (finishedAt ?? startedAt ??
+ * scheduledFor) — not merely the first match in `runs`, since callers may
+ * hand this an unsorted or multi-routine list. */
+function latestRunFor(runs, routineId) {
+    let best;
+    let bestAt = -Infinity;
+    for (const run of runs) {
+        if (run.routineId !== routineId)
+            continue;
+        const at = run.finishedAt ?? run.startedAt ?? run.scheduledFor;
+        if (at > bestAt) {
+            bestAt = at;
+            best = run;
+        }
+    }
+    return best;
+}
+function doesLines(facts) {
+    const lines = [];
+    for (const routine of facts.routines) {
+        if (!routine.enabled) {
+            lines.push(`Paused: ${routine.name}.`);
+            continue;
+        }
+        const nextRun = routine.nextRunAt != null ? ` Next run ${time(routine.nextRunAt, facts.timeZone)}.` : "";
+        const latest = latestRunFor(facts.runs, routine.id);
+        const at = latest ? latest.finishedAt ?? latest.startedAt ?? latest.scheduledFor : undefined;
+        const lastRun = latest ? ` Last run ${latest.status} at ${time(at, facts.timeZone)}.` : "";
+        lines.push(`${schedulePhrase(routine.schedule, facts.timeZone)}: ${routine.name}.${nextRun}${lastRun}`);
+    }
+    for (const skill of facts.skills) {
+        if (!skill.enabled)
+            continue;
+        lines.push(`Knows how to ${lowerFirst(skill.description || skill.name)}.`);
+    }
+    for (const webhook of facts.webhooks) {
+        if (!webhook.enabled)
+            continue;
+        lines.push(`Listens for “${webhook.name}” webhooks.`);
+    }
+    return lines;
+}
+/** The connected-apps facts for the route: reads the inventory only when a
+ * connector is configured and the credential store was readable, and treats
+ * a failing read (connector down, token rejected) as "unverified" rather
+ * than letting it fail the whole Overview. `read` is injected so the
+ * fallback is unit-testable without a live connector. */
+export async function connectedAppsFacts(configured, availability, read) {
+    let authoritative = availability !== "unreadable";
+    let services = [];
+    if (configured && authoritative) {
+        try {
+            services = Object.entries(await read())
+                .filter(([, state]) => state.connected)
+                .map(([slug]) => slug);
+        }
+        catch {
+            authoritative = false;
+        }
+    }
+    return { configured, authoritative, services };
+}
+/** Whether this bot could use connected apps at all: apps on for the bot,
+ * a connector configured, and an engine that mounts the Composio MCP. */
+function couldUseApps(facts) {
+    return facts.bot.composio !== false && facts.connectedApps.configured && Boolean(facts.engine?.composioMcp);
+}
+function computerReach(computer) {
+    switch (computer) {
+        case "cloud":
+            return "Computer preference: cloud computer.";
+        case "vm":
+            return "Computer preference: Local VM.";
+        case "local":
+            return "Computer preference: this computer.";
+        case "browser":
+            return "Computer preference: browser only.";
+        case "off":
+            return null;
+        default:
+            return "Computer preference: Auto; availability is checked when a task starts.";
+    }
+}
+function reachesLines(facts) {
+    const lines = [];
+    const computer = computerReach(facts.bot.computer);
+    if (computer)
+        lines.push(computer);
+    lines.push(facts.bot.cwd ? `Works in ${facts.bot.cwd}.` : "Works in its private workspace.");
+    const apps = facts.connectedApps;
+    // Only a bot that could actually use apps gets an apps line here. When it
+    // could, the inventory decides: verified and non-empty → list them;
+    // unverified → say so rather than guess either way.
+    if (couldUseApps(facts) && apps.authoritative && apps.services.length > 0) {
+        const count = apps.services.length;
+        lines.push(`Can use ${count} connected app${count === 1 ? "" : "s"}: ${apps.services.join(", ")}.`);
+    }
+    else if (couldUseApps(facts) && !apps.authoritative) {
+        lines.push("Connected apps could not be checked.");
+    }
+    if (facts.browserEnabled && facts.engine?.browserMcp && facts.bot.browser !== false && facts.bot.computer !== "off")
+        lines.push("Has the built-in browser.");
+    if (facts.engine?.agentsMcp && facts.sectionPeers > 0 && facts.bot.peers?.length !== 0) {
+        lines.push(`Can talk to ${facts.sectionPeers} other bot${facts.sectionPeers === 1 ? "" : "s"} in its section.`);
+    }
+    if (facts.bot.chiefOfStaff)
+        lines.push("Coordinates its section as Chief of Staff.");
+    return lines;
+}
+function wontLines(facts) {
+    const lines = [];
+    const mode = approvalModeFor(facts.bot);
+    if (mode === "ask")
+        lines.push("Command approvals use Ask mode; saved permissions and provider rules still apply.");
+    if (mode === "custom")
+        lines.push("Command approvals follow the provider's custom configuration.");
+    if (facts.bot.peers?.length === 0)
+        lines.push("Cannot initiate contact with other bots.");
+    else if (facts.bot.approvePeerComms)
+        lines.push("Asks before contacting other bots.");
+    // "Has no connected apps." is definite when apps are off for this bot,
+    // not configured, or unsupported by its engine — no inventory needed. Only
+    // the "configured but nothing connected" case rests on the inventory, so
+    // only that case requires it to be authoritative.
+    if (!couldUseApps(facts) || (facts.connectedApps.authoritative && facts.connectedApps.services.length === 0)) {
+        lines.push("Has no connected apps.");
+    }
+    if (facts.bot.computer === "off")
+        lines.push("Can't use a computer.");
+    if (!facts.routines.some((routine) => routine.enabled))
+        lines.push("Won't act on a schedule.");
+    lines.push("Profile proposal cards require your approval.");
+    return lines;
+}
+export function buildBotOverview(facts) {
+    return {
+        who: {
+            name: facts.bot.name,
+            title: facts.bot.title,
+            blurb: facts.bot.description,
+            soulLead: soulLead(facts.bot.soul),
+        },
+        does: doesLines(facts),
+        reaches: reachesLines(facts),
+        wont: wontLines(facts),
+        recent: facts.recent,
+    };
+}

package/dist-server/server/bot-package.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 import { schemaIssue } from "./schema.js";
+import { BOT_PROFILE_LIMITS } from "../shared/bot-profile.js";
 export const BOT_PACKAGE_FORMAT = "openmaus.package";
 export const BOT_PACKAGE_VERSION = 1;
 export const BOTMRR_MARKDOWN_VERSION = 1;
@@ -57,6 +58,9 @@ const packageSchema = z.object({
             name: requiredText(100),
             title: optionalText(200),
             description: optionalText(4_000),
+            soul: z.string().refine((value) => Buffer.byteLength(value, "utf8") <= BOT_PROFILE_LIMITS.soul, {
+                error: "standing instructions must be at most 24000 bytes",
+            }).optional(),
             appearance: z.object({
                 color: z.enum(COLORS, { error: "is not supported" }),
                 mascotExpression: optionalText(80),
@@ -259,6 +263,7 @@ export function packageAgentAsMember(agent) {
         name: agent.name,
         title: agent.title ?? "",
         description: agent.description ?? "",
+        ...(agent.soul !== undefined ? { soul: agent.soul } : {}),
         appearance: {
             color: agent.appearance.color,
             ...(agent.appearance.mascotExpression ? { mascotExpression: agent.appearance.mascotExpression } : {}),

package/dist-server/server/bot-profile.js

@@ -21,6 +21,7 @@ export const BOT_PROFILE_PATCH_FIELDS = [
     "name",
     "title",
     "description",
+    "soul",
     "notifications",
     "avatarUrl",
     "avatarCrop",
@@ -44,6 +45,12 @@ const profilePatchSchema = z.object({
         .string({ error: "description must be a string" })
         .max(BOT_PROFILE_LIMITS.description, { error: "description must be at most 4000 characters" })
         .optional(),
+    soul: z
+        .string({ error: "soul must be a string" })
+        .refine((value) => Buffer.byteLength(value, "utf8") <= BOT_PROFILE_LIMITS.soul, {
+        error: "standing instructions must be at most 24000 bytes",
+    })
+        .optional(),
     notifications: z.boolean({ error: "notifications must be true or false" }).optional(),
     avatarUrl: z
         .union([botAvatarUrlSchema, z.literal(""), z.null()], {

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

@@ -118,22 +118,42 @@ function connectorAdds(args) {
     const toolkits = args.toolkits;
     if (!Array.isArray(toolkits))
         return [];
-    return [...new Set(toolkits.flatMap((item) => {
-            if (typeof item === "string")
-                return [item.toLowerCase()];
-            if (!item || typeof item !== "object" || Array.isArray(item))
-                return [];
-            const row = item;
-            const slug = typeof row.toolkit === "string" ? row.toolkit : row.name;
-            const action = String(row.action ?? "add").toLowerCase();
-            return typeof slug === "string" && ["add", "connect", "initiate"].includes(action) ? [slug.toLowerCase()] : [];
-        }))];
+    const seen = new Set();
+    const requests = [];
+    for (const item of toolkits) {
+        if (typeof item === "string") {
+            const slug = item.trim().toLowerCase();
+            const key = JSON.stringify([slug, ""]);
+            if (!seen.has(key)) {
+                seen.add(key);
+                requests.push({ slug });
+            }
+            continue;
+        }
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            continue;
+        const row = item;
+        const action = String(row.action ?? "add").toLowerCase();
+        if (!["add", "connect", "initiate"].includes(action))
+            continue;
+        const slug = typeof row.toolkit === "string" ? row.toolkit : row.name;
+        if (typeof slug !== "string")
+            continue;
+        const normalized = slug.trim().toLowerCase();
+        const alias = (typeof row.alias === "string" ? row.alias : typeof row.account === "string" ? row.account : "").trim();
+        const key = JSON.stringify([normalized, alias.toLowerCase()]);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        requests.push({ slug: normalized, ...(alias ? { alias } : {}) });
+    }
+    return requests;
 }
-async function showConnectorCards(slugs) {
+async function showConnectorCards(items) {
     const response = await fetch(`${HARNESS}/api/internal/connectors/request`, {
         method: "POST",
         headers: { "content-type": "application/json", authorization: `Bearer ${TOKEN}` },
-        body: JSON.stringify({ botId: BOT_ID, threadId: THREAD_ID, slugs, resumeKey: randomUUID() }),
+        body: JSON.stringify({ botId: BOT_ID, threadId: THREAD_ID, items, resumeKey: randomUUID() }),
         signal: AbortSignal.timeout(30_000),
     });
     if (!response.ok) {
@@ -176,10 +196,11 @@ async function handle(message) {
     if (method === "tools/call") {
         const params = (message.params ?? {});
         const name = String(params.name ?? "");
-        const slugs = /MANAGE_CONNECTIONS$/i.test(name) ? connectorAdds(params.arguments) : [];
-        if (slugs.length) {
-            await showConnectorCards(slugs);
-            send(textResult(id, `OpenMausBot showed the user a secure connection card for ${slugs.join(", ")}. End this turn now. The app will continue the task automatically after the connection finishes.`));
+        const requests = /MANAGE_CONNECTIONS$/i.test(name) ? connectorAdds(params.arguments) : [];
+        if (requests.length) {
+            await showConnectorCards(requests);
+            const labels = requests.map((r) => (r.alias ? `${r.slug} (${r.alias})` : r.slug)).join(", ");
+            send(textResult(id, `OpenMausBot showed the user a secure connection card for ${labels}. End this turn now. The app will continue the task automatically after the connection finishes.`));
             return;
         }
         if (/WAIT_FOR_CONNECTIONS$/i.test(name)) {

package/dist-server/server/container-computer.js

@@ -728,7 +728,10 @@ export function wholeScreenshot(bytes) {
         mime: "image/jpeg",
     };
 }
-export async function containerComputerScreenshot(runner = sh, platform = process.platform, target = SHARED_LOCAL_VM_TARGET) {
+/** The raw frame, in the shape the live screen poller broadcasts to every
+ * client (server/index.ts). The web panel wants a data URL instead, so
+ * containerComputerScreenshot below wraps this one. */
+export async function containerComputerFrame(runner = sh, platform = process.platform, target = SHARED_LOCAL_VM_TARGET) {
     const cacheable = runner === sh && platform === process.platform;
     const now = Date.now();
     const cached = screenshotStatusCache.get(target.key);
@@ -759,7 +762,7 @@ export async function containerComputerScreenshot(runner = sh, platform = proces
         if (!checked.ok) {
             throw Object.assign(new Error("Cua Driver returned an incomplete screenshot"), { status: 502 });
         }
-        return `data:${checked.mime};base64,${data}`;
+        return { png: data, format: checked.mime === "image/jpeg" ? "jpeg" : "png" };
     }
     catch (error) {
         if (cacheable)
@@ -767,6 +770,10 @@ export async function containerComputerScreenshot(runner = sh, platform = proces
         throw error;
     }
 }
+export async function containerComputerScreenshot(runner = sh, platform = process.platform, target = SHARED_LOCAL_VM_TARGET) {
+    const { png, format } = await containerComputerFrame(runner, platform, target);
+    return `data:image/${format};base64,${png}`;
+}
 const screenshotStatusCache = new Map();
 const containerMcpPath = SPAWNED_PROXIES.containerMcp;
 export function containerComputerMcp(runtime, control, target = SHARED_LOCAL_VM_TARGET) {

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

@@ -19,6 +19,7 @@
 //   list_routines()                       → inspect this bot's scheduled work
 //   propose_routine(...)                  → show a confirmation card for a new routine
 //   propose_routine_action(...)           → show a confirmation card for a routine change
+//   propose_profile(...)                  → show a confirmation card for a profile change
 //
 // Speaks raw JSON-RPC 2.0 over stdio (no MCP SDK — house style, matches
 // computer-proxy / permission-proxy). All state comes from env, injected by
@@ -212,6 +213,10 @@ const ROUTINE_FIELDS_SCHEMA = {
         type: "boolean",
         description: "Only for updates: set true to remove an existing safety limit. Do not combine with timeout_minutes.",
     },
+    continuity: {
+        type: "boolean",
+        description: "Opt in to using the latest completed run's bounded report as historical context. Defaults to false; set false in an update to start fresh again. Shown on the confirmation card.",
+    },
 };
 const TOOLS = [
     {
@@ -390,6 +395,31 @@ const TOOLS = [
             required: ["routine_id", "action"],
         },
     },
+    {
+        name: "propose_profile",
+        description: "Propose changes to your own name, title, description, standing instructions (SOUL.md), or working folder (cwd). This only creates a confirmation card; nothing changes until the user approves it. After calling it, end the turn and do not claim the change is applied. Keep SOUL.md short — who you are and the rules you never break; put step-by-step procedure into a skill instead. A Chief of Staff may pass for_bot_id (from list_bots) to propose a change for another bot in its section.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                name: { type: "string", maxLength: 100, description: "New display name." },
+                title: { type: "string", maxLength: 200, description: "New role or title." },
+                description: { type: "string", maxLength: 4000, description: "New one-line blurb shown in rosters." },
+                soul: { type: "string", description: "Full replacement text for SOUL.md, at most 24000 bytes." },
+                cwd: {
+                    type: "string",
+                    maxLength: 1024,
+                    description: "Absolute path of the folder your tools read and write in (for example /Users/me/Projects/site). It must already exist. An empty string means your private workspace.",
+                },
+                reason: { type: "string", minLength: 1, maxLength: 500, description: "One sentence the user will see explaining why." },
+                for_bot_id: {
+                    type: "string",
+                    description: "Chief of Staff only: the id of another bot in your section whose profile this changes. Omit to change your own.",
+                },
+            },
+            required: ["reason"],
+        },
+    },
     {
         name: "skills_list",
         description: "List this bot's imported skills (enabled and disabled) and any staged skill writes waiting for the user to confirm. Use this before skill_manage to avoid duplicate names. Listing does not enable anything.",
@@ -475,12 +505,14 @@ function routineFields(args) {
         fields.timeoutMinutes = null;
     else if (typeof args.timeout_minutes === "number")
         fields.timeoutMinutes = args.timeout_minutes;
+    if (typeof args.continuity === "boolean")
+        fields.continuity = args.continuity;
     return { fields };
 }
-function confirmationResult(r, fallback) {
+function confirmationResult(r, fallback, noun = "routine") {
     const summary = typeof r.summary === "string" && r.summary.trim() ? `\n\n${r.summary.trim()}` : "";
     return {
-        text: `A confirmation card is now visible to the user for ${fallback}.${summary}\n\nThis change has not been applied yet. End this turn and wait for the user to confirm or deny the card; do not claim the routine was created or changed before confirmation.`,
+        text: `A confirmation card is now visible to the user for ${fallback}.${summary}\n\nThis change has not been applied yet. End this turn and wait for the user to confirm or deny the card; do not claim the ${noun} was created or changed before confirmation.`,
     };
 }
 /** Who said a recalled line, as the header of a hit or a read. A user-role
@@ -770,6 +802,35 @@ async function callTool(name, args) {
         });
         return confirmationResult(r, `${action.replace("_", " ")} on routine ${routineId}`);
     }
+    if (name === "propose_profile") {
+        const changes = {};
+        if (typeof args.name === "string")
+            changes.name = args.name.trim();
+        if (typeof args.title === "string")
+            changes.title = args.title.trim();
+        if (typeof args.description === "string")
+            changes.description = args.description.trim();
+        if (typeof args.soul === "string")
+            changes.soul = args.soul;
+        if (typeof args.cwd === "string")
+            changes.cwd = args.cwd.trim();
+        if (!Object.keys(changes).length) {
+            return { text: "propose_profile needs at least one of name, title, description, soul, or cwd.", isError: true };
+        }
+        const forBotId = String(args.for_bot_id ?? "").trim();
+        const r = await api("/api/internal/profile-requests", {
+            method: "POST",
+            body: JSON.stringify({
+                fromBotId: BOT_ID,
+                fromThreadId: THREAD_ID,
+                changes,
+                reason: args.reason,
+                // JSON.stringify drops the key entirely when no target was named
+                forBotId: forBotId || undefined,
+            }),
+        });
+        return confirmationResult(r, "the profile change", "profile");
+    }
     if (name === "session_search") {
         const q = String(args.query ?? "").trim();
         if (!q)