openmausbot 0.1.86 → 0.1.88

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

@@ -1,11 +1,11 @@
 // propose_profile: a bot proposes changes to its own name, title, description,
-// SOUL.md, or working folder; confirmed cards and Full Access submissions share
+// SOUL.md, working folder, or alert/voice toggles; confirmed cards and Full Access submissions share
 // the same validated commit path. Same
 // shape as routine-requests.ts, much smaller: the profile commits in one
 // store call, and staleness is a hash of the five fields instead of a
 // scheduler revision. Everything here is re-validated at confirm time —
 // a card can sit open for days.
-import { lineDiff } from "../shared/line-diff.js";
+import { soulDiffLines } from "../shared/line-diff.js";
 import { BOT_PROFILE_LIMITS } from "../shared/bot-profile.js";
 import { PROFILE_REQUEST_FIELDS } from "../shared/profile-request.js";
 import { parseBotProfilePatch } from "./bot-profile.js";
@@ -15,22 +15,32 @@ import { profileRevision, profileSnapshot } from "./profile-revision.js";
 import { recordProfileChange } from "./profile-versions.js";
 import { redactSecretsInText } from "./redact.js";
 const MAX_REASON = 500;
-const MAX_DIFF_LINES = 400;
 const STALE = "This bot's profile changed after this card was prepared. Ask the bot to review it and propose again.";
 const NO_SUCH_BOT = "That bot no longer exists";
 const LABELS = {
     name: "Name",
     title: "Title",
     description: "Description",
+    notifications: "Notifications",
+    speakReplies: "Speak replies",
 };
 const PRIVATE_WORKSPACE = "its private workspace";
-const CHOOSE_ONE = "Choose at least one of name, title, description, soul, cwd";
+const CHOOSE_ONE = "Choose at least one of name, title, description, soul, cwd, notifications, speakReplies";
+const toggleText = (value) => (value ? "on" : "off");
+/** The fields that change what a bot is told: every card field except the
+ * working folder and the two toggles. */
+const TEXT_FIELDS = ["name", "title", "description", "soul"];
 export class ProfileRequestError extends Error {
     status;
-    constructor(message, status = 400) {
+    /** True when no retry of this card can ever succeed — the proposal went
+     * stale (revision mismatch, target or folder gone) and the card must
+     * settle as expired instead of staying actionable. */
+    terminal;
+    constructor(message, status = 400, options) {
         super(message);
         this.name = "ProfileRequestError";
         this.status = status;
+        this.terminal = options?.terminal === true;
     }
 }
 function reasonText(value) {
@@ -44,8 +54,9 @@ function reasonText(value) {
     }
     return redactSecretsInText(trimmed);
 }
-/** `parseBotProfilePatch` would silently accept a key like `notifications` —
- * valid for the broader bot patch, not for a profile request. Reject keys
+/** `parseBotProfilePatch` would silently accept a key like `voice` —
+ * valid for the broader bot patch, not for a profile request (a voice pick
+ * needs the harness catalog rendered on the card). Reject keys
  * outside the proposable fields ourselves first, for exact copy. */
 function parseChanges(input) {
     if (typeof input !== "object" || input === null || Array.isArray(input)) {
@@ -84,6 +95,11 @@ function parseChanges(input) {
         if (field === "cwd")
             continue;
         const value = parsed.patch[field];
+        if (field === "notifications" || field === "speakReplies") {
+            if (value !== undefined)
+                changes[field] = value;
+            continue;
+        }
         // This payload is hidden under the card's visible fields, so the store's
         // shallow card redaction cannot reach it. Scrub before it is persisted.
         if (typeof value !== "string")
@@ -125,36 +141,27 @@ export function profileCardCopy(target, fullProfile, before, changes, reason) {
             continue;
         if (changes[field] === undefined)
             continue;
+        if (field === "notifications" || field === "speakReplies") {
+            lines.push(`${LABELS[field]}: ${toggleText(before[field])} → ${toggleText(changes[field])}`);
+            continue;
+        }
         lines.push(`${LABELS[field]}: "${before[field] ?? ""}" → "${changes[field]}"`);
     }
     if (changes.cwd !== undefined) {
         lines.push(`Working folder: ${before.cwd || PRIVATE_WORKSPACE} → ${changes.cwd || PRIVATE_WORKSPACE}`);
     }
     if (changes.soul !== undefined) {
-        const beforeSoul = before.soul ?? "";
-        const afterSoul = changes.soul;
-        const bytesBefore = Buffer.byteLength(beforeSoul, "utf8");
-        const bytesAfter = Buffer.byteLength(afterSoul, "utf8");
-        lines.push(`SOUL.md (${bytesBefore} → ${bytesAfter} bytes):`);
-        const diff = lineDiff(beforeSoul, afterSoul);
-        if (diff.length > MAX_DIFF_LINES) {
-            // Truncating a diff can hide the very instructions being approved.
-            // The full replacement is already byte-bounded by profile validation
-            // and is readable in the same generic card on desktop and phones.
-            lines.push("Large change — complete proposed instructions (replaces the current SOUL.md):");
-            lines.push(afterSoul || "(empty)");
-        }
-        else {
-            lines.push(...diff);
-        }
+        lines.push(...soulDiffLines(before.soul ?? "", changes.soul));
     }
     // The closing line says the consequence of exactly what is on the card:
-    // a folder change moves where the bot's tools read and write; the other
-    // fields change what it is told. Either way nothing runs on confirm.
-    const onlyFolder = Object.keys(changes).every((field) => field === "cwd");
+    // a folder change moves where the bot's tools read and write; the text
+    // fields change what it is told; a card of only toggles, only a folder,
+    // or both carries no instruction change at all. Either way nothing runs
+    // on confirm.
+    const changesText = TEXT_FIELDS.some((field) => changes[field] !== undefined);
     if (changes.cwd !== undefined)
         lines.push(`${target.name}'s tools will read and write files in that folder.`);
-    lines.push(onlyFolder ? "Nothing runs." : `Changes what ${target.name} is told on every turn. Nothing runs.`);
+    lines.push(changesText ? `Changes what ${target.name} is told on every turn. Nothing runs.` : "Nothing runs.");
     const detail = lines.join("\n");
     const fields = PROFILE_REQUEST_FIELDS.filter((field) => changes[field] !== undefined);
     const summary = `${title} · ${fields.join(", ")}`;
@@ -199,13 +206,20 @@ export class ProfileRequestService {
         const before = {};
         const finalChanges = {};
         for (const field of PROFILE_REQUEST_FIELDS) {
-            const value = changes[field];
-            if (value === undefined)
-                continue;
-            if (value === snapshot[field])
-                continue;
-            before[field] = redactSecretsInText(snapshot[field]);
-            finalChanges[field] = value;
+            if (field === "notifications" || field === "speakReplies") {
+                const value = changes[field];
+                if (value === undefined || value === snapshot[field])
+                    continue;
+                before[field] = snapshot[field];
+                finalChanges[field] = value;
+            }
+            else {
+                const value = changes[field];
+                if (value === undefined || value === snapshot[field])
+                    continue;
+                before[field] = redactSecretsInText(snapshot[field]);
+                finalChanges[field] = value;
+            }
         }
         if (Object.keys(finalChanges).length === 0) {
             throw new ProfileRequestError("Nothing would change");
@@ -290,20 +304,29 @@ export class ProfileRequestService {
                     throw new ProfileRequestError("This profile confirmation card is no longer available", 409);
                 return { claimed: true, state: "already_settled", behavior: "allow" };
             }
+            // An expired card is settled terminal state, not a decision waiting on
+            // a slower click: the proposal it carried can never be confirmed as
+            // prepared, even when the condition that expired it reverses (the
+            // revision matches again, the folder comes back). The committed
+            // receipt above still recovers a write that already happened; nothing
+            // past this point can.
+            if (card.expired) {
+                return { claimed: true, state: "invalid", error: "This profile request expired before it was confirmed. Ask for a fresh proposal.", status: 409 };
+            }
             if (args.behavior === "deny") {
                 this.store.patchMessage(args.threadId, message.id, { card: { ...card, answered: "deny", held: undefined } });
                 return { claimed: true, state: "denied" };
             }
             if (!target)
-                throw new ProfileRequestError(NO_SUCH_BOT, 404);
+                throw new ProfileRequestError(NO_SUCH_BOT, 404, { terminal: true });
             const crossBot = payload.targetBotId !== payload.botId;
             if (crossBot && this.validateTarget) {
                 const refusal = this.validateTarget(payload.botId, payload.targetBotId);
                 if (refusal)
-                    throw new ProfileRequestError(refusal, 404);
+                    throw new ProfileRequestError(refusal, 404, { terminal: true });
             }
             if (profileRevision(target) !== payload.expectedRevision) {
-                throw new ProfileRequestError(STALE, 409);
+                throw new ProfileRequestError(STALE, 409, { terminal: true });
             }
             const { cwd, ...rest } = payload.changes;
             const validated = Object.keys(rest).length ? parseChanges(rest) : {};
@@ -314,7 +337,7 @@ export class ProfileRequestService {
                 // applicable as prepared.
                 const checked = validateBotCwd(cwd || null);
                 if (!checked.ok)
-                    throw new ProfileRequestError(checked.error, 409);
+                    throw new ProfileRequestError(checked.error, 409, { terminal: true });
                 patch.cwd = checked.cwd ?? undefined;
             }
             if (!this.store.patchBotProfile(target.id, patch))
@@ -333,12 +356,16 @@ export class ProfileRequestService {
             const status = error instanceof ProfileRequestError ? error.status : 400;
             const detail = error instanceof Error ? error.message : String(error);
             const saved = this.store.bot(payload.targetBotId)?.lastProfileRequestId === payload.requestId;
+            // A terminal failure (stale revision, target gone) can never be
+            // confirmed as prepared: settle the card as expired with its options
+            // removed so it stops looking actionable, and say so in one line.
+            const expired = !saved && error instanceof ProfileRequestError && error.terminal;
             const notice = card.dismissed && card.options.length === 0
                 ? "Profile saved. Recording the operation receipt could not finish; the changes will not be applied again."
                 : "Profile saved. Confirm again to finish recording this decision; the changes will not be applied again.";
             try {
                 this.store.patchMessage(args.threadId, message.id, {
-                    card: { ...card, held: saved ? notice : redactSecretsInText(detail).slice(0, 500) },
+                    card: { ...card, ...(expired ? { expired: true, options: [] } : {}), held: saved ? notice : redactSecretsInText(detail).slice(0, 500) },
                 });
             }
             catch { /* The durable profile receipt still permits a safe retry. */ }

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

@@ -4,7 +4,15 @@
 // routine's expectedUpdatedAt (bots have no updatedAt of their own).
 import { createHash } from "node:crypto";
 export function profileSnapshot(bot) {
-    return { name: bot.name, title: bot.title, description: bot.description, soul: bot.soul ?? "", cwd: bot.cwd ?? "" };
+    return {
+        name: bot.name,
+        title: bot.title,
+        description: bot.description,
+        soul: bot.soul ?? "",
+        cwd: bot.cwd ?? "",
+        notifications: bot.notifications ?? true,
+        speakReplies: bot.speakReplies ?? false,
+    };
 }
 export function profileRevision(bot) {
     // A later proposal can restore identical text. Keep its private receipt

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

@@ -60,11 +60,14 @@ async function writeRows(botId, rows) {
 export function recordProfileChange(botId, actor, via, before, after) {
     const at = Date.now();
     const rows = [];
+    // Toggles land in history as the same on/off wording the card shows;
+    // every other proposable field is text.
+    const historyText = (value) => value === undefined ? "" : typeof value === "boolean" ? (value ? "on" : "off") : value;
     for (const field of PROFILE_REQUEST_FIELDS) {
-        const b = before[field] ?? "";
-        const a = after[field] ?? "";
+        const b = before[field];
+        const a = after[field];
         if (b !== a)
-            rows.push(rowFor(field, at, actor, via, b, a));
+            rows.push(rowFor(field, at, actor, via, historyText(b), historyText(a)));
     }
     if (!rows.length)
         return;

package/dist-server/server/provider-key-check.js

@@ -1,8 +1,9 @@
-export const PROVIDER_KEY_KINDS = ["anthropic", "openaiCompat", "xai"];
+export const PROVIDER_KEY_KINDS = ["anthropic", "openaiCompat", "xai", "mistral"];
 const DEFAULT_URLS = {
     anthropic: "https://api.anthropic.com",
     openaiCompat: "https://openrouter.ai/api/v1",
     xai: "https://api.x.ai/v1",
+    mistral: "https://api.mistral.ai/v1",
 };
 const MAX_MODELS = 5;
 function isLoopback(hostname) {
@@ -18,7 +19,7 @@ export function providerModelsUrl(provider, base) {
 }
 function modelIds(body) {
     const record = body && typeof body === "object" ? body : null;
-    const list = Array.isArray(record?.data) ? record.data : Array.isArray(record?.models) ? record.models : [];
+    const list = Array.isArray(body) ? body : Array.isArray(record?.data) ? record.data : Array.isArray(record?.models) ? record.models : [];
     const ids = [];
     for (const entry of list) {
         const item = entry && typeof entry === "object" ? entry : null;

package/dist-server/server/published-teams.js

@@ -0,0 +1,80 @@
+// What this installation has shared, per team: the package id and the
+// release last exported, plus the key each bot, group chat and routine was
+// published under.
+//
+// Keys are a package's identity across releases (Admin refuses a release
+// that silently drops one, and later updates match on them). They must not
+// come from names once they exist: renaming a bot, a room, a routine or the
+// team would otherwise read as "everything removed, everything added". So
+// the first export records them here, keyed by record id, and every later
+// export of the same team reuses them. Teams are name strings in OMB, so the
+// team entry is renamed with the section (section-context.ts calls
+// renamePublishedTeam from the one function every rename goes through).
+//
+// Server-private: nothing here is on the wire, and nothing here is a secret.
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { writeFileAtomic } from "./atomic.js";
+import { DATA_DIR } from "./config.js";
+export const PUBLISHED_TEAMS_FILE = join(DATA_DIR, "published-teams.json");
+const keyMap = z.record(z.string(), z.string());
+const publishedTeamSchema = z.object({
+    packageId: z.string().min(1),
+    lastRelease: z.string().min(1),
+    keys: z.object({ bots: keyMap, rooms: keyMap, routines: keyMap }).default({ bots: {}, rooms: {}, routines: {} }),
+});
+const fileSchema = z.object({ version: z.literal(1), teams: z.record(z.string(), z.unknown()) });
+function load() {
+    const teams = new Map();
+    if (!existsSync(PUBLISHED_TEAMS_FILE))
+        return teams;
+    try {
+        const file = fileSchema.parse(JSON.parse(readFileSync(PUBLISHED_TEAMS_FILE, "utf8")));
+        // Own entries only: a team may be called anything, including __proto__.
+        for (const [section, value] of Object.entries(file.teams)) {
+            const entry = publishedTeamSchema.safeParse(value);
+            if (entry.success)
+                teams.set(section, entry.data);
+        }
+    }
+    catch {
+        // An unreadable record only costs key stability on the next export,
+        // which then derives keys from names as a first export does.
+    }
+    return teams;
+}
+function save(teams) {
+    mkdirSync(DATA_DIR, { recursive: true, mode: 0o700 });
+    const out = Object.create(null);
+    for (const [section, entry] of teams)
+        out[section] = entry;
+    writeFileAtomic(PUBLISHED_TEAMS_FILE, JSON.stringify({ version: 1, teams: out }, null, 2), { mode: 0o600 });
+}
+export function readPublishedTeam(section) {
+    return load().get(section) ?? null;
+}
+export function writePublishedTeam(section, entry) {
+    const teams = load();
+    teams.set(section, entry);
+    save(teams);
+}
+/** Follow a team rename; null forgets the team (it was deleted). */
+export function renamePublishedTeam(name, nextName) {
+    const teams = load();
+    const entry = teams.get(name);
+    if (!entry || name === nextName)
+        return;
+    teams.delete(name);
+    if (nextName !== null)
+        teams.set(nextName, entry);
+    save(teams);
+}
+/** "1.2.3" → "1.2.4"; nothing published yet (or unreadable) starts at 1.0.0. */
+export function nextPatchRelease(release) {
+    const match = release?.match(/^(\d{1,6})\.(\d{1,6})\.(\d{1,6})$/);
+    if (!match)
+        return "1.0.0";
+    const [major, minor, patch] = match.slice(1).map(Number);
+    return patch < 999_999 ? `${major}.${minor}.${patch + 1}` : `${major}.${minor + 1}.0`;
+}

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

@@ -6,6 +6,7 @@ const nodeSchema = z.object({
     id: z.string(), rootId: z.string(), parentId: z.string().optional(),
     groupId: z.string().optional(), threadId: z.string(), botId: z.string(),
     key: z.string(), text: z.string(), createdAt: z.number(),
+    requestBatchKey: z.string().optional(),
     status: z.enum(["source", "queued", "running", "waiting", "resume", "completed", "failed", "cancelled"]),
     result: z.string().default(""), reported: z.boolean().default(false),
     executions: z.number().int().nonnegative().default(0), startedAt: z.number().optional(),
@@ -159,7 +160,7 @@ export class RoomHandoffs {
         const root = this.root(n);
         return `Room handoff hard cap exhausted: node was ${n.status} after ${duration(this.now() - root.createdAt)} of the ${duration(this.limits.hardCapMs)} wall-clock cap`;
     }
-    enqueue(source, generation, parentId, target, key, text, approvalGranted = false, rework = false, sourceText = "") {
+    enqueue(source, generation, parentId, target, key, text, approvalGranted = false, rework = false, sourceText = "", requestBatchKey) {
         if (this.loadError)
             throw new Error(this.loadError);
         let parent = parentId ? this.nodes.get(parentId) : this.nodes.get(generation);
@@ -178,10 +179,17 @@ export class RoomHandoffs {
         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.kind !== kind || existing.requestBatchKey !== requestBatchKey)
                 throw new Error("request_key was already used for different work");
             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.");
@@ -221,7 +229,7 @@ export class RoomHandoffs {
         }
         const node = { ...target, id: randomUUID(), rootId: parent.rootId, parentId: parent.id,
             key, text, createdAt: this.now(), status: "queued", result: "", reported: false, executions: 0, approvalGranted,
-            kind };
+            kind, ...(target.groupId && requestBatchKey ? { requestBatchKey } : {}) };
         const problem = this.hooks.validate(node, parent);
         if (problem)
             throw new Error(problem);
@@ -239,6 +247,14 @@ export class RoomHandoffs {
         }
         return { node, duplicate: false };
     }
+    /** A room brief is displayed once; each recipient keeps its own execution and result. */
+    sharedRequest(node) {
+        const batch = node.groupId && node.requestBatchKey && node.parentId
+            ? this.children(node.parentId).filter(n => n.requestBatchKey === node.requestBatchKey &&
+                n.groupId === node.groupId && n.threadId === node.threadId && n.text === node.text)
+            : [node];
+        return { id: batch[0]?.id ?? node.id, botIds: batch.map(n => n.botId) };
+    }
     sourceSettled(generation, ok) {
         const node = this.nodes.get(generation);
         if (!node || node.status !== "source")

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

@@ -0,0 +1,25 @@
+// Preset bots for New bot (server/presets.ts has the store and the rules).
+// GET lists what New bot offers: the organization's presets first, then
+// imported files', never one from a withdrawn release. DELETE removes an
+// imported preset (the person's own click; no confirm step). Organization
+// presets are Admin's to remove. Both are admin-scoped by default in
+// server/request-auth.ts, like the New bot defaults: a preset adds skills
+// and starter notes to the bot made from it.
+import { listBotPresets, ORG_PRESET_REMOVE_MESSAGE, PRESET_UNAVAILABLE_MESSAGE } from "../presets.js";
+import { PASS } from "./table.js";
+export function createBotPresetRoutes(deps) {
+    return async ({ res, path, method, json }) => {
+        if (path === "/api/bot-presets" && method === "GET") {
+            return json(res, 200, { presets: listBotPresets(deps.presets, deps.orgStatuses()) });
+        }
+        const m = path.match(/^\/api\/bot-presets\/([\w-]+)$/);
+        if (!m || method !== "DELETE")
+            return PASS;
+        const removed = deps.presets.removeFilePreset(m[1]);
+        if (removed === "not_found")
+            return json(res, 404, { error: PRESET_UNAVAILABLE_MESSAGE });
+        if (removed === "organization")
+            return json(res, 409, { error: ORG_PRESET_REMOVE_MESSAGE });
+        return json(res, 200, { ok: true });
+    };
+}

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

@@ -211,10 +211,15 @@ const routineRequestCardDataSchema = z.object({
 }).strict();
 export class RoutineRequestError extends Error {
     status;
-    constructor(message, status = 400) {
+    /** True when no retry of this card can ever succeed — the routine moved
+     * under the proposal — so the card must settle as expired rather than
+     * staying actionable. */
+    terminal;
+    constructor(message, status = 400, options) {
         super(message);
         this.name = "RoutineRequestError";
         this.status = status;
+        this.terminal = options?.terminal === true;
     }
 }
 function text(value, field, max) {
@@ -786,9 +791,9 @@ export function routineRequestFingerprint(payload, messageId) {
 function verifyManageSnapshot(operation, manager, botId) {
     const current = ownedRoutine(manager, operation.routineId, botId);
     if (!current)
-        throw new RoutineRequestError("That routine no longer exists", 404);
+        throw new RoutineRequestError("That routine no longer exists", 404, { terminal: true });
     if (current.updatedAt !== operation.expectedUpdatedAt) {
-        throw new RoutineRequestError("That routine changed after this confirmation card was prepared. Ask the bot to review it and propose the action again.", 409);
+        throw new RoutineRequestError("That routine changed after this confirmation card was prepared. Ask the bot to review it and propose the action again.", 409, { terminal: true });
     }
     return current;
 }
@@ -828,7 +833,7 @@ function revalidateOperation(operation, manager, botId, now) {
         if (duplicate) {
             // The tool cannot choose a result destination. Return the existing ID,
             // without moving its reports or treating a renamed request as new work.
-            throw new RoutineRequestError(`An enabled routine with the same instructions and execution settings already exists (${duplicate.id}). Use list_routines to review it, then update or run that routine instead.`, 409);
+            throw new RoutineRequestError(`An enabled routine with the same instructions and execution settings already exists (${duplicate.id}). Use list_routines to review it, then update or run that routine instead.`, 409, { terminal: true });
         }
     }
     const current = operation.action === "create"
@@ -848,7 +853,7 @@ function revalidateOperation(operation, manager, botId, now) {
         }
     }
     if (schedule?.type === "once" && schedule.at <= now) {
-        throw new RoutineRequestError("That one-time schedule is now in the past. Ask the bot to propose a new time.", 409);
+        throw new RoutineRequestError("That one-time schedule is now in the past. Ask the bot to propose a new time.", 409, { terminal: true });
     }
     if (schedule?.type === "interval") {
         const base = operation.action === "create"
@@ -923,7 +928,7 @@ export class RoutineRequestService {
             if (refusal)
                 throw new RoutineRequestError(refusal, 403);
         }
-        await this.requireCloudReadiness(operation);
+        await this.requireCloudReadiness(operation, botId);
         // The readiness probe is asynchronous. Another request can edit or
         // delete the routine while it is in flight, so re-check the captured
         // revision before rendering and persisting the confirmation snapshot.
@@ -1006,7 +1011,7 @@ export class RoutineRequestService {
         }
         throw new RoutineRequestError(result.state === "invalid" ? result.error : "The routine change could not be applied", result.state === "invalid" ? result.status : 409);
     }
-    async requireCloudReadiness(operation) {
+    async requireCloudReadiness(operation, proposerBotId) {
         if (!this.cloudReady || operation.action === "pause" || operation.action === "delete")
             return;
         const definition = effectiveDefinition(operation, this.routines);
@@ -1014,7 +1019,10 @@ export class RoutineRequestService {
             return;
         let readiness;
         try {
-            readiness = await this.cloudReady();
+            const targetBotId = operation.action === "create"
+                ? operation.forBot?.botId ?? proposerBotId
+                : this.routines.listRoutines().find(routine => routine.id === operation.routineId)?.botId ?? proposerBotId;
+            readiness = await this.cloudReady(targetBotId);
         }
         catch (error) {
             const detail = error instanceof Error ? error.message : String(error);
@@ -1104,6 +1112,19 @@ export class RoutineRequestService {
                 }
                 return this.settleApplied(args.threadId, message.id, card, payload, receipt.resultId, receipt.appliedAt);
             }
+            // An expired card is settled terminal state, not a decision waiting on
+            // a slower click: the proposal it carried can never be confirmed as
+            // prepared, even when the routine moves back under it. The committed
+            // receipt above still recovers a write that already happened; nothing
+            // past this point can.
+            if (card.expired) {
+                return {
+                    claimed: true,
+                    state: "invalid",
+                    error: "This routine request expired before it was confirmed. Ask for a fresh proposal.",
+                    status: 409,
+                };
+            }
             if (args.behavior === "deny") {
                 this.store.patchMessage(args.threadId, message.id, { card: { ...card, answered: "deny", held: undefined } });
                 return { claimed: true, state: "denied" };
@@ -1112,7 +1133,7 @@ export class RoutineRequestService {
             if (payload.operation.action === "create" && payload.operation.forBot && this.validateTarget) {
                 const refusal = this.validateTarget(payload.botId, payload.operation.forBot);
                 if (refusal)
-                    throw new RoutineRequestError(refusal, 404);
+                    throw new RoutineRequestError(refusal, 404, { terminal: true });
             }
             const resultId = this.apply(payload, message.id, fingerprint);
             return this.settleApplied(args.threadId, message.id, card, payload, resultId);
@@ -1120,8 +1141,12 @@ export class RoutineRequestService {
         catch (error) {
             const status = error instanceof RoutineRequestError ? error.status : 400;
             const detail = error instanceof Error ? error.message : String(error);
+            // A terminal failure (the routine moved under the proposal) can never
+            // be confirmed as prepared: settle the card as expired with its
+            // options removed so it stops looking actionable.
+            const expired = error instanceof RoutineRequestError && error.terminal;
             this.store.patchMessage(args.threadId, message.id, {
-                card: { ...card, held: redactSecretsInText(detail).slice(0, 500) },
+                card: { ...card, ...(expired ? { expired: true, options: [] } : {}), held: redactSecretsInText(detail).slice(0, 500) },
             });
             return {
                 claimed: true,

package/dist-server/server/routines.js

@@ -7,7 +7,24 @@ import { writeFileAtomic } from "./atomic.js";
 import { redactSecretsInText } from "./redact.js";
 import { normalizeCronSchedule, nextCronRuns } from "../shared/routine-schedule.js";
 import { isRoutineProblemRun } from "../shared/routines.js";
+import { ROUTINE_PARTS } from "./package-parts.js";
 const persistedSourceThreadId = z.string().trim().min(1).optional().catch(undefined);
+const HASH = /^[a-f0-9]{64}$/;
+function loadInstalledPackage(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const stamp = value;
+    if (typeof stamp.installId !== "string" || !/^[a-f0-9]{32}$/.test(stamp.installId) || typeof stamp.key !== "string" || !stamp.key || stamp.key.length > 80)
+        return undefined;
+    const parts = stamp.parts;
+    if (!parts || typeof parts !== "object" || !ROUTINE_PARTS.every((part) => HASH.test(String(parts[part]?.r)) && HASH.test(String(parts[part]?.w))))
+        return undefined;
+    return {
+        installId: stamp.installId,
+        key: stamp.key,
+        parts: Object.fromEntries(ROUTINE_PARTS.map((part) => [part, { r: parts[part].r, w: parts[part].w }])),
+    };
+}
 const webhookRunReceiptSchema = z.object({
     webhookId: z.string().min(1).max(200),
     deliveryId: z.string().min(1).max(200),
@@ -490,9 +507,12 @@ export class RoutineManager {
                         overlap: routine.overlap === "queue" ? "queue" : undefined,
                         skippedRuns: Number.isSafeInteger(routine.skippedRuns) && routine.skippedRuns > 0 ? routine.skippedRuns : undefined,
                         lastSkippedAt: Number.isSafeInteger(routine.lastSkippedAt) && routine.lastSkippedAt >= 0 && routine.lastSkippedAt <= MAX_DATE_MS ? routine.lastSkippedAt : undefined,
+                        installedPackage: loadInstalledPackage(routine.installedPackage),
                     };
                     if (loaded.timeoutMinutes === undefined)
                         delete loaded.timeoutMinutes;
+                    if (loaded.installedPackage === undefined)
+                        delete loaded.installedPackage;
                     delete loaded.failureStreak;
                     return [loaded];
                 })
@@ -582,7 +602,27 @@ export class RoutineManager {
             .sort((a, b) => (b.finishedAt ?? b.createdAt) - (a.finishedAt ?? a.createdAt) || b.createdAt - a.createdAt);
         const success = outcomes.findIndex(run => run.status === "completed");
         const failures = success < 0 ? outcomes.length : success;
-        return { ...cloneRoutine(routine), ...(failures ? { failureStreak: failures } : {}) };
+        const { installedPackage: _installedPackage, ...visible } = cloneRoutine(routine);
+        return { ...visible, ...(failures ? { failureStreak: failures } : {}) };
+    }
+    /** Routines added from the organization's library, with their stamps. */
+    packageStamps() {
+        return this.routines.flatMap((routine) => routine.installedPackage
+            ? [{ routineId: routine.id, botId: routine.botId, enabled: routine.enabled, stamp: structuredClone(routine.installedPackage) }]
+            : []);
+    }
+    /** Record which organization install a just-created routine belongs to. */
+    stampInstalledPackage(id, stamp) {
+        const clean = loadInstalledPackage(stamp);
+        if (!clean)
+            throw new Error("Invalid routine package stamp");
+        if (!this.routines.some((routine) => routine.id === id))
+            return false;
+        this.commitMutation(() => {
+            const routine = this.routines.find((candidate) => candidate.id === id);
+            routine.installedPackage = clean;
+        });
+        return true;
     }
     /** Whether this computer should stay awake for routines: a run is in
      * flight, or an enabled routine is due within the horizon. The schedule

package/dist-server/server/section-context.js

@@ -9,6 +9,7 @@ import { join } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.js";
 import { DATA_DIR } from "./config.js";
+import { renamePublishedTeam } from "./published-teams.js";
 export const SECTION_CONTEXT_MAX_BYTES = 24_000;
 export const SECTION_CONTEXTS_FILE = join(DATA_DIR, "section-contexts.json");
 const sectionContextRecordSchema = z.object({ text: z.string(), updatedAt: z.number().finite() });
@@ -94,6 +95,15 @@ export function changeEmptySection(name, nextName) {
     if (nextName !== null && context)
         data.contexts[nextName] = context;
     saveFile(data);
+    // Every team rename and removal funnels through here, so the team's
+    // published package id and keys follow it (published-teams.ts). The team
+    // itself is already renamed; a failure here costs only key stability.
+    try {
+        renamePublishedTeam(name, nextName);
+    }
+    catch (error) {
+        console.warn(`[teams] Could not move the shared-package record for this team: ${error.message}`);
+    }
 }
 export function readSectionContext(section) {
     const record = loadFile().contexts[sectionContextKey(section)];