openmausbot 0.1.86 → 0.1.88

package/dist-server/server/team-computers.js

@@ -92,6 +92,16 @@ export class TeamComputers {
     setProblem(id, problem) {
         return this.patch(id, { problem: problem?.slice(0, 500) });
     }
+    /** Relabel an existing team's assignment; this never changes its computer. */
+    renameSection(from, to) {
+        const entry = this.forSection(from);
+        if (!entry || from === to)
+            return false;
+        if (this.forSection(to))
+            throw failure("This team already has a computer");
+        this.patch(entry.id, { section: to });
+        return true;
+    }
     patch(id, patch) {
         const entries = this.list();
         const entry = entries.find(candidate => candidate.id === id);

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

@@ -1,5 +1,5 @@
 import { parseJson } from "./schema.js";
-import { isBotPackage, parseBotPackage } from "./bot-package.js";
+import { isBotPackage, parseBotPackage, parsePackageDocument } from "./bot-package.js";
 import { parseTeamManifest } from "./team-manifest.js";
 export const TEAM_LIBRARY_REPOSITORY = "https://github.com/milind-soni/openmausbot-teams";
 export const TEAM_LIBRARY_RAW_ROOT = "https://raw.githubusercontent.com/milind-soni/openmausbot-teams/main";
@@ -127,7 +127,11 @@ export async function fetchTeamCatalog(fetcher = fetch) {
 function parseShareable(value) {
     if (typeof value === "string")
         return parseBotPackage(value);
-    return isBotPackage(value) ? parseBotPackage(value) : parseTeamManifest(value);
+    if (!isBotPackage(value))
+        return parseTeamManifest(value);
+    // A shared team (v2) is read as a file: it cannot claim a publisher.
+    // Version 1 keeps its original shape for older callers.
+    return value.version === 1 ? parseBotPackage(value) : parsePackageDocument(value, { trust: "file" });
 }
 async function fetchShareable(url, fetcher) {
     return url.endsWith(".md")

package/dist-server/server/team-manifest.js

@@ -140,13 +140,14 @@ export function parseTeamManifest(value) {
  * 1. Allowlist, not blocklist. The returned object is built field by field
  *    from the parsed member, so every privilege-bearing BotRecord field —
  *    approvalMode, autoApprove, alwaysAllow, chiefOfStaff, approvePeerComms, composio,
- *    computer, cloudBackend, cwd — is structurally absent, whatever the
+ *    connectorTools, computer, cloudBackend, cwd — is structurally absent, whatever the
  *    file claimed. parseTeamManifest already drops unknown member keys;
  *    this keeps the guarantee even if the schema grows a field later,
  *    because nothing new can reach a bot record without someone
  *    consciously widening this return type. The caller must still force
- *    composio: false on the created record — that is the one privilege
- *    where *absence* means allowed, so leaving it unset is not safe.
+ *    composio: false (and connectorTools: {}) on the created record —
+ *    composio is the one privilege where *absence* means allowed, so
+ *    leaving it unset is not safe.
  *
  * 2. No name captures. Display names are identity wherever bots address
  *    each other — @mention resolution in rooms, the Chief of Staff roster,

package/dist-server/server/team-setup-requests.js

@@ -1,15 +1,27 @@
 import { createHash } from "node:crypto";
 import { z } from "zod";
+import { soulDiffLines } from "../shared/line-diff.js";
 import { newId } from "./contracts.js";
 import { fitsOnOneLine, parseBotProfilePatch } from "./bot-profile.js";
 import { profileSnapshot } from "./profile-revision.js";
+import { validateBotCwd } from "./bot-cwd.js";
+import { harnessCapabilityLines } from "./harness-capabilities.js";
 import { redactSecretsInText } from "./redact.js";
 const section = (value) => value?.trim() || "";
 const teamName = z.string().trim().min(1).max(60).refine(fitsOnOneLine).refine((value) => redactSecretsInText(value) === value, "Team names cannot contain credentials");
+const FIELD_LABELS = { name: "Name", title: "Title", description: "Description", section: "Section", cwd: "Working folder" };
+// The variant rides ModelSelection, and a proposal that omits it removes it,
+// so the review text says both states outright: set on the current
+// selection, explicitly absent on the proposed one. Otherwise a bot with a
+// configured variant shows a before value that hides the setting changing
+// under it.
+const modelSelectionText = (selection) => `${selection.instanceId}/${selection.model}${selection.variant ? ` (variant ${selection.variant})` : " (no variant)"}${selection.effort ? ` (effort ${selection.effort})` : ""}`;
 const fieldsSchema = z.object({
+    chiefOfStaff: z.boolean().optional(),
     name: z.string().optional(), title: z.string().optional(), description: z.string().optional(), soul: z.string().optional(),
+    cwd: z.string().optional(),
     section: z.string().trim().max(60).refine(fitsOnOneLine).refine((value) => redactSecretsInText(value) === value, "Team names cannot contain credentials").optional(),
-    modelSelection: z.object({ instanceId: z.string().trim().min(1), model: z.string().trim().min(1), effort: z.string().optional() }).strict().optional(),
+    modelSelection: z.object({ instanceId: z.string().trim().min(1), model: z.string().trim().min(1), effort: z.string().optional(), variant: z.string().optional() }).strict().optional(),
 }).strict();
 const planSchema = z.object({
     reason: z.string().trim().min(1).max(500),
@@ -23,15 +35,44 @@ export class TeamSetupError extends Error {
     status;
     constructor(message, status = 400) { super(message); this.status = status; }
 }
-/** Settings relevant to approval, including the previous durable receipt. */
-export function teamSetupRevision(bot) {
-    return createHash("sha256").update(JSON.stringify({
-        ...profileSnapshot(bot), section: section(bot.section), modelSelection: bot.modelSelection,
-        hidden: Boolean(bot.hidden), chiefOfStaff: Boolean(bot.chiefOfStaff), peers: bot.peers,
-        managedSections: bot.managedSections,
-        approvalMode: bot.approvalMode, autoApprove: bot.autoApprove, approvalGrant: bot.approvalGrant,
-        receipt: bot.lastTeamSetupReceipt?.requestId,
-    })).digest("hex");
+/**
+ * The revision a team-setup card pins to. Without `fields` it hashes the
+ * bot's whole state — any drift cancels — which the destructive deletion
+ * path keeps on purpose. With `fields` (setup plans) it pins exactly the
+ * before-values the card displayed for the fields the plan touches;
+ * authority, team scope, peer scope, visibility, busyness, destination, and
+ * name collisions are re-checked fresh at confirm time, so drift on
+ * untouched fields no longer cancels a plan that never claimed to touch
+ * them. Every update card renders a section line, so section stays pinned
+ * even when the plan only carries it through unchanged.
+ */
+export function teamSetupRevision(bot, fields) {
+    if (fields === undefined) {
+        return createHash("sha256").update(JSON.stringify({
+            ...profileSnapshot(bot), section: section(bot.section), modelSelection: bot.modelSelection,
+            hidden: Boolean(bot.hidden), chiefOfStaff: Boolean(bot.chiefOfStaff), peers: bot.peers,
+            managedSections: bot.managedSections,
+            approvalMode: bot.approvalMode, autoApprove: bot.autoApprove, approvalGrant: bot.approvalGrant,
+            receipt: bot.lastTeamSetupReceipt?.requestId,
+        })).digest("hex");
+    }
+    const snapshot = profileSnapshot(bot);
+    const scope = {};
+    if (fields.name !== undefined)
+        scope.name = snapshot.name;
+    if (fields.title !== undefined)
+        scope.title = snapshot.title;
+    if (fields.description !== undefined)
+        scope.description = snapshot.description;
+    if (fields.soul !== undefined)
+        scope.soul = snapshot.soul;
+    if (fields.section !== undefined)
+        scope.section = section(bot.section);
+    if (fields.modelSelection !== undefined)
+        scope.modelSelection = bot.modelSelection;
+    if (fields.chiefOfStaff !== undefined)
+        scope.chiefOfStaff = Boolean(bot.chiefOfStaff);
+    return createHash("sha256").update(JSON.stringify(scope)).digest("hex");
 }
 export class TeamSetupRequestService {
     resolving = new Set();
@@ -43,8 +84,23 @@ export class TeamSetupRequestService {
             throw new TeamSetupError("Only an active Chief of Staff can propose team setup", 403);
         return chief;
     }
+    /**
+     * The Chief's own pinned state: the fields this plan's operations display
+     * about the Chief, or the whole state for deletions. A plan that never
+     * touches the Chief pins nothing of the Chief's — its authority is
+     * re-checked fresh at confirm time either way.
+     */
+    requesterScope(request) {
+        if (request.deletion)
+            return undefined;
+        const scope = {};
+        for (const operation of request.operations)
+            if (operation.botId === request.botId)
+                Object.assign(scope, operation.fields);
+        return scope;
+    }
     fields(input, current) {
-        const { section: targetSection, modelSelection, ...profile } = input;
+        const { section: targetSection, modelSelection, chiefOfStaff, cwd: rawCwd, ...profile } = input;
         const safe = Object.fromEntries(Object.entries(profile).map(([key, value]) => [key, redactSecretsInText(value)]));
         const parsed = parseBotProfilePatch(safe, true);
         if (!parsed.ok)
@@ -52,6 +108,19 @@ export class TeamSetupRequestService {
         const result = { ...parsed.patch };
         if (targetSection !== undefined)
             result.section = targetSection;
+        if (chiefOfStaff !== undefined)
+            result.chiefOfStaff = chiefOfStaff;
+        if (rawCwd !== undefined) {
+            // Create-only, and the exact check the profile path runs: absolute,
+            // exists, is a folder. An existing bot's folder keeps going through
+            // propose_profile, which re-checks the folder at confirm time.
+            if (current)
+                throw new TeamSetupError("A working folder can only be chosen when creating a bot; propose_profile changes it later");
+            const checked = validateBotCwd(rawCwd);
+            if (!checked.ok)
+                throw new TeamSetupError(checked.error);
+            result.cwd = checked.cwd ?? "";
+        }
         if (modelSelection) {
             const selection = modelSelection;
             const error = this.options.validateModel(selection, current);
@@ -69,7 +138,7 @@ export class TeamSetupRequestService {
             throw new TeamSetupError("Full Access is no longer enabled for this conversation", 409);
         if (confirming && !immediate && !this.options.store.messagesFor(request.threadId).some((message) => message.card?.requestId === request.requestId && !message.card.answered && !message.card.dismissed))
             throw new TeamSetupError("This setup card is no longer pending", 409);
-        if (confirming && teamSetupRevision(chief) !== request.requesterRevision)
+        if (confirming && teamSetupRevision(chief, this.requesterScope(request)) !== request.requesterRevision)
             throw new TeamSetupError("The Chief's settings changed. This setup was cancelled; review a new proposal.", 409);
         const existingTeams = new Set(this.options.teams().map(section));
         if (new Set([...(chief.managedSections ?? []), ...request.newTeams]).size > 100)
@@ -94,7 +163,7 @@ export class TeamSetupRequestService {
             else {
                 if (!target || target.hidden || !this.options.canAccessTeam(chief, target.section) || (target.id !== chief.id && Array.isArray(chief.peers) && !chief.peers.includes(target.id)))
                     throw new TeamSetupError("A target bot is outside this Chief's authorized team and peer scope", 403);
-                if (teamSetupRevision(target) !== operation.expectedRevision)
+                if (teamSetupRevision(target, operation.fields) !== operation.expectedRevision)
                     throw new TeamSetupError(`@${target.name} changed. This setup was cancelled; review a new proposal.`, 409);
                 const sourceThreadId = immediate && target.id === chief.id ? request.threadId : undefined;
                 if (this.options.targetBusy(target.id, sourceThreadId) && (confirming || target.id !== chief.id))
@@ -108,7 +177,7 @@ export class TeamSetupRequestService {
                 throw new TeamSetupError("The destination team is outside this Chief's authorized scope", 403);
             if (!request.newTeams.includes(section(destination)) && !existingTeams.has(section(destination)))
                 throw new TeamSetupError("The destination team no longer exists", 409);
-            const next = { id: operation.botId, name: fields.name ?? target.name, section: section(destination), chiefOfStaff: target?.chiefOfStaff, hidden: false };
+            const next = { id: operation.botId, name: fields.name ?? target.name, section: section(destination), chiefOfStaff: fields.chiefOfStaff ?? target?.chiefOfStaff, hidden: false };
             const at = projected.findIndex((bot) => bot.id === operation.botId);
             if (at < 0)
                 projected.push(next);
@@ -125,7 +194,7 @@ export class TeamSetupRequestService {
             if (projected.some((bot) => bot.id !== candidate.id && !bot.hidden && bot.section === candidate.section && bot.name.trim().toLowerCase() === candidate.name.trim().toLowerCase()))
                 throw new TeamSetupError(`@${candidate.name} already exists in that team`, 409);
             if (candidate.chiefOfStaff && projected.some((bot) => bot.id !== candidate.id && bot.chiefOfStaff && bot.section === candidate.section))
-                throw new TeamSetupError("That move would put two Chiefs in one team", 409);
+                throw new TeamSetupError("Each team can have one Chief. Include the current Chief's demotion in this plan.", 409);
         }
         if (request.deletion) {
             const target = this.options.store.bot(request.deletion.botId);
@@ -150,14 +219,19 @@ export class TeamSetupRequestService {
             throw new TeamSetupError("Review at most eight bots in one setup");
         const operations = [...combined.values()].map((operation) => {
             const target = operation.action === "update" ? this.options.store.bot(operation.botId) : undefined;
+            const fields = this.fields({ ...operation.fields, section: operation.fields.section ?? target?.section ?? chief.section ?? "" }, target ?? undefined);
             return { action: operation.action, botId: operation.action === "create" ? newId() : operation.botId,
                 ...(operation.action === "create" ? { threadId: newId() } : {}),
-                fields: this.fields({ ...operation.fields, section: operation.fields.section ?? target?.section ?? chief.section ?? "" }, target ?? undefined),
-                ...(target ? { expectedRevision: teamSetupRevision(target) } : {}),
+                fields,
+                ...(target ? { expectedRevision: teamSetupRevision(target, fields) } : {}),
             };
         });
+        const requesterScope = {};
+        for (const operation of operations)
+            if (operation.botId === chief.id)
+                Object.assign(requesterScope, operation.fields);
         const request = { version: 1, requestId: newId(), botId: args.botId, threadId: args.threadId,
-            reason: redactSecretsInText(parsed.data.reason), createdAt: Date.now(), requesterRevision: teamSetupRevision(chief),
+            reason: redactSecretsInText(parsed.data.reason), createdAt: Date.now(), requesterRevision: teamSetupRevision(chief, requesterScope),
             newTeams: [...new Set(parsed.data.newTeams)], operations };
         this.validate(request, false);
         return request;
@@ -195,18 +269,52 @@ export class TeamSetupRequestService {
         const lines = [`Why: ${request.reason}`];
         if (request.deletion)
             lines.push(`Delete @${request.deletion.name} (${request.deletion.botId}).`, "Permanently removes this bot, all its conversations, memory, instructions, skills, and any computer owned only by it. Generated project files and shared team computers remain. Active work or an unavailable provider can block deletion safely.");
-        if (request.newTeams.length)
-            lines.push(`Create teams: ${request.newTeams.map((name) => JSON.stringify(name)).join(", ")}.`, `Authorize @${chief.name} to coordinate and propose setup changes in these new teams.`);
+        if (request.newTeams.length) {
+            lines.push(`Create teams: ${request.newTeams.map((name) => JSON.stringify(name)).join(", ")}.`);
+            if (!request.operations.some(op => op.botId === chief.id && op.fields.chiefOfStaff === false)) {
+                lines.push(`Authorize @${chief.name} to coordinate and propose setup changes in these new teams.`);
+            }
+        }
         for (const operation of request.operations) {
             const current = this.options.store.bot(operation.botId);
             lines.push(`\n${operation.action === "create" ? "Create" : "Update"} @${operation.fields.name ?? current?.name} (${operation.action === "create" ? "new bot" : operation.botId})`);
             for (const [key, value] of Object.entries(operation.fields)) {
-                const before = current ? (key === "section" ? current.section || "General" : current[key]) : undefined;
-                lines.push(`${key === "modelSelection" ? "Default engine/model" : key}: ${current ? `${JSON.stringify(before ?? "")} → ` : ""}${key === "section" ? JSON.stringify(value || "General") : JSON.stringify(value)}`);
+                if (key === "chiefOfStaff") {
+                    lines.push(`Chief of Staff: ${current?.chiefOfStaff ? "Yes" : "No"} → ${value ? "Yes" : "No"}.${value ? " May coordinate and configure bots in this team." : " Additional managed-team access is removed."}`);
+                    continue;
+                }
+                // The same review shape the profile card uses: labeled before/after
+                // lines, and SOUL.md as a line diff with the shared large-change
+                // fallback — never a JSON.stringify blob of the instructions.
+                if (key === "soul") {
+                    lines.push(...soulDiffLines(current?.soul ?? "", value));
+                }
+                else if (key === "modelSelection") {
+                    lines.push(`Default engine/model: ${current ? `${modelSelectionText(current.modelSelection)} → ` : ""}${modelSelectionText(value)}`);
+                    // An engine switch changes what the bot can do, not just its label:
+                    // show what the destination driver gains and loses. Same-instance
+                    // model or effort changes render nothing extra.
+                    if (current && typeof value === "object" && value !== null &&
+                        value.instanceId !== current.modelSelection.instanceId && this.options.driverCapabilities) {
+                        lines.push(...harnessCapabilityLines(this.options.driverCapabilities(current.modelSelection.instanceId), this.options.driverCapabilities(value.instanceId)));
+                    }
+                }
+                else {
+                    const before = current ? (key === "section" ? current.section || "General" : String(current[key] ?? "")) : undefined;
+                    const after = key === "section" ? value || "General" : String(value);
+                    lines.push(`${FIELD_LABELS[key] ?? key}: ${current ? `"${before}" → ` : ""}"${after}"`);
+                }
+            }
+        }
+        if (!request.deletion) {
+            lines.push("\nDefault models apply to groups and new threads. Every existing thread keeps its current model and permissions.");
+            // Informed consent: creation locks the new bot down, and the owner
+            // signs off on that whole state, not just the two facts named before.
+            if (request.operations.some((operation) => operation.action === "create")) {
+                lines.push("New bots stay owner-owned after creation: connected apps off, approvals at Ask, a private workspace by default, avatar untouched.");
             }
+            lines.push("Existing execution permissions are unchanged.");
         }
-        if (!request.deletion)
-            lines.push("\nDefault models apply to groups and new threads. Every existing thread keeps its current model and permissions.", "New bots start in Ask with connected apps disabled. Existing execution permissions are unchanged.");
         lines.push(immediate ? "Full Access applies this request in the current turn without another confirmation." : "After this decision the Chief continues once with the result.");
         const title = request.deletion ? `Delete @${request.deletion.name}?` : `Apply setup for ${request.operations.length} ${request.operations.length === 1 ? "bot" : "bots"}?`;
         const detail = lines.join("\n");
@@ -256,7 +364,7 @@ export class TeamSetupRequestService {
         let messageId;
         try {
             messageId = this.options.store.appendMessage(request.threadId, { role: "bot", kind: "options", ...(from ? { from } : {}), card: {
-                    ...card, title, options: [], answered: result.state === "applied" ? "allow" : "deny", held: result.error,
+                    ...card, title, options: [], ...(result.state === "applied" ? { answered: "allow" } : { expired: true }), held: result.error,
                     teamSetupRequest: { ...request, result, resumed: true },
                 } }).id;
         }
@@ -278,7 +386,7 @@ export class TeamSetupRequestService {
             throw new TeamSetupError("Confirm or cancel this setup", 400);
         // Stop/dismiss can close a card without a setup decision. It must never
         // resurrect that review or wake the stopped conversation.
-        if (card.answered || card.dismissed) {
+        if (card.answered || card.dismissed || card.expired) {
             const result = request.result ?? { state: "cancelled", bots: [], newTeams: [], error: "This setup card was closed" };
             return { result, request: { ...request, result }, messageId: message.id, duplicate: true };
         }
@@ -294,7 +402,11 @@ export class TeamSetupRequestService {
                 result = { state: "denied", bots: [], newTeams: [] };
             else
                 result = await this.apply(request);
-            this.options.store.patchMessage(args.threadId, message.id, { card: { ...card, answered: result.state === "applied" ? "allow" : "deny", held: result.error, teamSetupRequest: { ...request, result } } });
+            // A setup that could not apply is dead, not denied: the card settles
+            // expired with its options removed, so it stops looking actionable and
+            // the one-line held note says to review a fresh proposal.
+            const dead = result.state !== "applied" && result.state !== "denied";
+            this.options.store.patchMessage(args.threadId, message.id, { card: { ...card, ...(dead ? { expired: true, options: [] } : { answered: result.state === "applied" ? "allow" : "deny" }), held: result.error, teamSetupRequest: { ...request, result } } });
             return { result, request: { ...request, result }, messageId: message.id, duplicate: false };
         }
         finally {

package/dist-server/server/thread-events.js

@@ -133,6 +133,10 @@ const stringOrMissing = (value) => value === undefined || typeof value === "stri
 const stringOrNullOrMissing = (value) => value === undefined || value === null || typeof value === "string";
 const numberOrNullOrMissing = (value) => value === undefined || value === null || typeof value === "number";
 const stringsOrMissing = (value) => value === undefined || (Array.isArray(value) && value.every((item) => typeof item === "string"));
+/** A computer holder as the wait events carry it: a name, and the holding
+ * thread's title when one was known. */
+const computerHolderOrMissing = (value) => value === undefined ||
+    (isRecord(value) && typeof value.name === "string" && stringOrMissing(value.task));
 /** A replayed structured ask. Only the shape the card actually reads is
  * required; the rest is optional and simply absent on an older event. */
 const askQuestionsOrMissing = (value) => value === undefined ||
@@ -175,6 +179,15 @@ function isRuntimeEvent(value) {
                 stringsOrMissing(value.denials) &&
                 (value.usage === undefined ||
                     (isRecord(value.usage) && typeof value.usage.input === "number" && typeof value.usage.output === "number")));
+        case "turn.wait_started":
+            return typeof value.resource === "string" && computerHolderOrMissing(value.holder);
+        case "turn.wait_ended":
+            return (typeof value.resource === "string" &&
+                computerHolderOrMissing(value.holder) &&
+                typeof value.waitedMs === "number" &&
+                Number.isFinite(value.waitedMs) &&
+                value.waitedMs >= 0 &&
+                (value.outcome === "acquired" || value.outcome === "gave_up" || value.outcome === "stopped"));
         case "item.started":
             return (value.itemType === "tool" || value.itemType === "reasoning") && stringOrMissing(value.title);
         case "item.updated":
@@ -188,7 +201,10 @@ function isRuntimeEvent(value) {
                 typeof value.tool === "string" &&
                 typeof value.summary === "string" &&
                 stringsOrMissing(value.choices) &&
-                askQuestionsOrMissing(value.questions));
+                askQuestionsOrMissing(value.questions) &&
+                // Required fields only: events recorded before origin exists replay
+                // unchanged, and a value other than the two documented marks is not.
+                (value.origin === undefined || value.origin === "tool" || value.origin === "output"));
         case "request.resolved":
             return ((value.behavior === "allow" || value.behavior === "deny" || value.behavior === "answer") &&
                 (value.source === "user" ||
@@ -200,7 +216,9 @@ function isRuntimeEvent(value) {
         case "thread.token-usage.updated":
             return typeof value.input === "number" && typeof value.output === "number";
         case "runtime.error":
-            return typeof value.message === "string" && (value.setup === undefined || typeof value.setup === "boolean");
+            return typeof value.message === "string" &&
+                (value.setup === undefined || typeof value.setup === "boolean") &&
+                (value.claudeUpdate === undefined || typeof value.claudeUpdate === "boolean");
         default:
             return false;
     }