openmausbot 0.1.74 → 0.1.76

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

@@ -0,0 +1,252 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { newId } from "./contracts.js";
+import { fitsOnOneLine, parseBotProfilePatch } from "./bot-profile.js";
+import { profileSnapshot } from "./profile-revision.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 fieldsSchema = z.object({
+    name: z.string().optional(), title: z.string().optional(), description: z.string().optional(), soul: 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(),
+}).strict();
+const planSchema = z.object({
+    reason: z.string().trim().min(1).max(500),
+    newTeams: z.array(teamName).max(8).default([]),
+    operations: z.array(z.discriminatedUnion("action", [
+        z.object({ action: z.literal("create"), key: z.string().trim().min(1).max(80), fields: fieldsSchema }).strict(),
+        z.object({ action: z.literal("update"), botId: z.string().min(1).max(128), fields: fieldsSchema }).strict(),
+    ])).min(1).max(24),
+}).strict();
+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");
+}
+export class TeamSetupRequestService {
+    resolving = new Set();
+    options;
+    constructor(options) { this.options = options; }
+    chief(botId) {
+        const chief = this.options.store.bot(botId);
+        if (!chief || chief.hidden || !chief.chiefOfStaff)
+            throw new TeamSetupError("Only an active Chief of Staff can propose team setup", 403);
+        return chief;
+    }
+    fields(input, current) {
+        const { section: targetSection, modelSelection, ...profile } = input;
+        const safe = Object.fromEntries(Object.entries(profile).map(([key, value]) => [key, redactSecretsInText(value)]));
+        const parsed = parseBotProfilePatch(safe, true);
+        if (!parsed.ok)
+            throw new TeamSetupError(parsed.error);
+        const result = { ...parsed.patch };
+        if (targetSection !== undefined)
+            result.section = targetSection;
+        if (modelSelection) {
+            const selection = modelSelection;
+            const error = this.options.validateModel(selection, current);
+            if (error)
+                throw new TeamSetupError(error);
+            result.modelSelection = selection;
+        }
+        return result;
+    }
+    validate(request, confirming) {
+        const chief = this.chief(request.botId);
+        if (!this.options.ownsThread(request.botId, request.threadId))
+            throw new TeamSetupError("The requesting conversation no longer exists", 409);
+        if (confirming && !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)
+            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)
+            throw new TeamSetupError("A Chief may coordinate at most 100 additional teams", 409);
+        for (const name of request.newTeams)
+            if (existingTeams.has(name))
+                throw new TeamSetupError(`Team ${JSON.stringify(name)} now exists. Review a new proposal.`, 409);
+        const allowed = (name) => request.newTeams.includes(section(name)) || this.options.canAccessTeam(chief, name);
+        const targets = new Set();
+        const projected = this.options.store.bots.map((bot) => ({ id: bot.id, name: bot.name, section: section(bot.section), chiefOfStaff: bot.chiefOfStaff, hidden: bot.hidden }));
+        for (const operation of request.operations) {
+            if (targets.has(operation.botId))
+                throw new TeamSetupError("A bot appears twice in the prepared setup");
+            targets.add(operation.botId);
+            const target = this.options.store.bot(operation.botId);
+            if (operation.action === "create") {
+                if (target)
+                    throw new TeamSetupError("A proposed bot already exists. Review a new proposal.", 409);
+                if (!operation.fields.name?.trim() || !operation.fields.title?.trim() || !operation.fields.soul?.trim() || !operation.fields.modelSelection)
+                    throw new TeamSetupError("Each new bot needs a name, title, soul instructions, and exact model selection");
+            }
+            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)
+                    throw new TeamSetupError(`@${target.name} changed. This setup was cancelled; review a new proposal.`, 409);
+                if (this.options.targetBusy(target.id) && (confirming || target.id !== chief.id))
+                    throw new TeamSetupError(`Stop @${target.name}'s work before changing its setup`, 409);
+            }
+            const fields = this.fields(operation.fields, target ?? undefined);
+            const destination = fields.section ?? target?.section ?? chief.section;
+            if (!allowed(destination))
+                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 at = projected.findIndex((bot) => bot.id === operation.botId);
+            if (at < 0)
+                projected.push(next);
+            else
+                projected[at] = next;
+        }
+        if (this.options.store.bots.length + request.operations.filter((op) => op.action === "create").length > this.options.maxBots)
+            throw new TeamSetupError("This setup exceeds the workspace bot limit", 409);
+        for (const name of request.newTeams)
+            if (!request.operations.some((op) => section(op.fields.section) === name))
+                throw new TeamSetupError(`New team ${JSON.stringify(name)} needs a specialist in this setup`);
+        for (const operation of request.operations) {
+            const candidate = projected.find((bot) => bot.id === operation.botId);
+            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);
+        }
+        if (request.deletion) {
+            const target = this.options.store.bot(request.deletion.botId);
+            if (!target || target.hidden || target.id === chief.id || !this.options.canAccessTeam(chief, target.section) || (Array.isArray(chief.peers) && !chief.peers.includes(target.id)))
+                throw new TeamSetupError("This deletion target is no longer an authorized teammate", 403);
+            if (teamSetupRevision(target) !== request.deletion.expectedRevision || this.options.targetBusy(target.id))
+                throw new TeamSetupError("The deletion target changed or is working. Review a new deletion proposal.", 409);
+        }
+    }
+    propose(args) {
+        const parsed = planSchema.safeParse(args.plan);
+        if (!parsed.success)
+            throw new TeamSetupError(parsed.error.issues[0]?.message ?? "Invalid team setup");
+        const chief = this.chief(args.botId);
+        const combined = new Map();
+        for (const operation of parsed.data.operations) {
+            const key = operation.action === "create" ? `create:${operation.key}` : `update:${operation.botId}`;
+            const previous = combined.get(key);
+            combined.set(key, { ...operation, fields: { ...previous?.fields, ...operation.fields } });
+        }
+        if (combined.size > 8)
+            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;
+            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) } : {}),
+            };
+        });
+        const request = { version: 1, requestId: newId(), botId: args.botId, threadId: args.threadId,
+            reason: redactSecretsInText(parsed.data.reason), createdAt: Date.now(), requesterRevision: teamSetupRevision(chief),
+            newTeams: [...new Set(parsed.data.newTeams)], operations };
+        this.validate(request, false);
+        return this.card(request, args.from);
+    }
+    proposeDeletion(args) {
+        const chief = this.chief(args.botId);
+        const target = this.options.store.bot(args.targetBotId);
+        if (!target)
+            throw new TeamSetupError("That bot no longer exists", 404);
+        if (!args.reason.trim() || args.reason.length > 500)
+            throw new TeamSetupError("A deletion reason of at most 500 characters is required");
+        const request = { version: 1, requestId: newId(), botId: args.botId, threadId: args.threadId,
+            reason: redactSecretsInText(args.reason), createdAt: Date.now(), requesterRevision: teamSetupRevision(chief), newTeams: [], operations: [],
+            deletion: { botId: target.id, name: target.name, expectedRevision: teamSetupRevision(target) } };
+        this.validate(request, false);
+        return this.card(request, args.from);
+    }
+    card(request, from) {
+        const permission = this.options.canPersist(request.botId, request.threadId);
+        if (!permission.ok)
+            throw new TeamSetupError(permission.error, permission.status);
+        const chief = this.chief(request.botId);
+        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, and skills. Generated project files remain. Active work or owned computers can block deletion.");
+        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.`);
+        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 (!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("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");
+        const message = this.options.store.appendMessage(request.threadId, { role: "bot", kind: "options", ...(from ? { from } : {}), card: {
+                title, subtitle: detail, options: [request.deletion ? "Delete bot" : "Apply setup", "Cancel"], requestId: request.requestId,
+                tool: request.deletion ? "delete_bot" : "set_up_team", teamSetupRequest: request,
+            } });
+        return { requestId: request.requestId, messageId: message.id, title, summary: title, detail };
+    }
+    async resolve(args) {
+        const message = this.options.store.messagesFor(args.threadId).find((item) => item.card?.requestId === args.requestId && item.card.teamSetupRequest);
+        const card = message?.card, request = card?.teamSetupRequest;
+        if (!message || !card || !request)
+            return null;
+        if (request.botId !== args.botId || request.threadId !== args.threadId || request.requestId !== args.requestId)
+            throw new TeamSetupError("This setup belongs to another conversation", 403);
+        if (args.behavior !== "allow" && args.behavior !== "deny")
+            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) {
+            const result = request.result ?? { state: "cancelled", bots: [], newTeams: [], error: "This setup card was closed" };
+            return { result, request: { ...request, result }, messageId: message.id, duplicate: true };
+        }
+        if (this.resolving.has(request.requestId))
+            throw new TeamSetupError("This setup is already being applied", 409);
+        this.resolving.add(request.requestId);
+        try {
+            const receipt = this.options.store.bot(request.botId)?.lastTeamSetupReceipt;
+            let result;
+            if (receipt?.requestId === request.requestId)
+                result = receipt.result;
+            else if (args.behavior === "deny")
+                result = { state: "denied", bots: [], newTeams: [] };
+            else {
+                try {
+                    this.validate(request, true);
+                    if (request.deletion) {
+                        await this.options.deleteBot(request.deletion.botId, () => this.validate(request, true), request);
+                        result = { state: "applied", bots: [{ id: request.deletion.botId, name: request.deletion.name, action: "deleted" }], newTeams: [] };
+                    }
+                    else
+                        result = this.options.store.applyTeamSetup(request);
+                }
+                catch (error) {
+                    const saved = this.options.store.bot(request.botId)?.lastTeamSetupReceipt;
+                    const detail = redactSecretsInText(error instanceof Error ? error.message : String(error));
+                    result = saved?.requestId === request.requestId
+                        ? { ...saved.result, error: `The changes were saved, but cleanup needs attention: ${detail}` }
+                        : { state: error instanceof TeamSetupError ? "cancelled" : "failed", bots: [], newTeams: [], error: detail };
+                }
+            }
+            this.options.store.patchMessage(args.threadId, message.id, { card: { ...card, answered: result.state === "applied" ? "allow" : "deny", held: result.error, teamSetupRequest: { ...request, result } } });
+            return { result, request: { ...request, result }, messageId: message.id, duplicate: false };
+        }
+        finally {
+            this.resolving.delete(request.requestId);
+        }
+    }
+}

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

@@ -133,6 +133,14 @@ 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 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 ||
+    (Array.isArray(value) &&
+        value.every((question) => isRecord(question) &&
+            typeof question.question === "string" &&
+            Array.isArray(question.options) &&
+            question.options.every((option) => isRecord(option) && typeof option.label === "string")));
 function isRuntimeEvent(value) {
     if (!isRecord(value) ||
         typeof value.eventId !== "string" ||
@@ -179,7 +187,8 @@ function isRuntimeEvent(value) {
             return ((value.requestType === "permission" || value.requestType === "question") &&
                 typeof value.tool === "string" &&
                 typeof value.summary === "string" &&
-                stringsOrMissing(value.choices));
+                stringsOrMissing(value.choices) &&
+                askQuestionsOrMissing(value.questions));
         case "request.resolved":
             return ((value.behavior === "allow" || value.behavior === "deny" || value.behavior === "answer") &&
                 (value.source === "user" ||

package/dist-server/server/turn-dispatch-guard.js

@@ -44,8 +44,11 @@ export class RetiredTurnRegistry {
 export class ProviderTurnGenerationRegistry {
     #owners = new Map();
     #completed;
+    #earlyCompletions = new Map();
+    #limit;
     constructor(limit = 4_096) {
         this.#completed = new RetiredTurnRegistry(limit);
+        this.#limit = limit;
     }
     bind(threadId, generation, turnId) {
         if (this.#completed.has(turnId))
@@ -53,23 +56,48 @@ export class ProviderTurnGenerationRegistry {
         this.#owners.set(turnId, { threadId, generation });
         return true;
     }
-    complete(threadId, turnId) {
-        this.#completed.retire(turnId);
+    complete(threadId, turnId, outcome) {
+        if (this.#completed.has(turnId))
+            return null;
         const owner = this.#owners.get(turnId);
-        if (!owner || owner.threadId !== threadId)
+        if (owner && owner.threadId !== threadId)
             return null;
+        this.#completed.retire(turnId);
+        if (!owner) {
+            // Only a later ACK for this exact provider id may consume the result.
+            // Never attribute an unbound event to the thread's current generation.
+            if (outcome !== undefined) {
+                this.#earlyCompletions.set(turnId, { threadId, outcome });
+                while (this.#earlyCompletions.size > this.#limit) {
+                    this.#earlyCompletions.delete(this.#earlyCompletions.keys().next().value);
+                }
+            }
+            return null;
+        }
         this.#owners.delete(turnId);
         return owner;
     }
+    takeEarlyCompletion(threadId, turnId) {
+        const receipt = this.#earlyCompletions.get(turnId);
+        if (receipt?.threadId !== threadId)
+            return undefined;
+        this.#earlyCompletions.delete(turnId);
+        return receipt.outcome;
+    }
     deleteGeneration(threadId, generation) {
+        const removed = [];
         for (const [turnId, owner] of this.#owners) {
             if (owner.threadId === threadId && owner.generation === generation) {
                 this.#owners.delete(turnId);
+                this.#completed.retire(turnId);
+                removed.push(turnId);
             }
         }
+        return removed;
     }
     clear() {
         this.#owners.clear();
+        this.#earlyCompletions.clear();
     }
 }
 /** Thread gate for the narrow interval after Stop wins but before an async

package/dist-server/server/workspace.js

@@ -52,6 +52,19 @@ export function ensureWorkspace(botId) {
 export function workspaceDir(botId) {
     return join(WORKSPACES_DIR, botId);
 }
+/** File locations, not file contents or wider tool permissions. Threads keep
+ * independent working directories; the same bot can find its earlier output
+ * without assuming that a file absent from the current directory was lost. */
+export function workspaceLocationsPrompt(botId, cwd, botCwd) {
+    return "\n\nFile locations for this bot (absolute paths): " + JSON.stringify({
+        currentWorkingFolder: cwd ?? "Provider default; inspect the working directory before using relative paths",
+        sharedBotFolder: workspaceDir(botId),
+        otherThreadFiles: join(TASK_WORKSPACES_DIR, botId),
+        ...(botCwd ? { configuredProjectFolder: botCwd } : {}),
+    }) + ". Different conversations can have different working folders. For an existing file, use the exact path from the conversation; if missing here, check this bot's listed folders before saying it is gone or recreating it." +
+        " Follow an explicitly requested destination. Otherwise put new task output in the current working folder and report its absolute path so another thread or room can use it." +
+        " Do not move old files, edit another active thread's work, or read another bot's private folders without authorization. These paths do not grant additional access.";
+}
 /** Lines as a person counts them: a file that ends in a newline has no
  * extra empty line after it. Every budget check and every "N lines"
  * message uses this one count. */

package/dist-server/shared/approval-mode.js

@@ -16,6 +16,13 @@ export function supportsApprovalMode(driverKind, mode) {
         return true;
     return ["codex", "claudeAgent", "antigravityAgent", "cursorAgent", "grokAgent", "opencodeGo"].includes(driverKind ?? "");
 }
+/** A Full/Custom grant belongs to one provider's tool semantics. Other
+ * modes carry across only when the destination actually implements them.
+ * Adapted from tahodev's provider-switch guard in PR #1120. */
+export function modelSwitchNeedsAsk(mode, fromDriver, toDriver) {
+    return !supportsApprovalMode(toDriver, mode) ||
+        ((mode === "full" || mode === "custom") && fromDriver !== toDriver);
+}
 export function hasNativeAutoReview(driverKind) {
     return ["codex", "claudeAgent", "cursorAgent", "grokAgent"].includes(driverKind ?? "");
 }

package/dist-server/shared/ask-question.js

@@ -0,0 +1,172 @@
+/**
+ * Structured questions raised by a provider's own "ask the human" tool —
+ * Claude Code's built-in `AskUserQuestion`.
+ *
+ * That tool reaches us as a PERMISSION ask (the CLI routes it through
+ * --permission-prompt-tool like any other tool use), which is exactly the
+ * wrong shape: a person cannot answer "which model should this bot use?"
+ * with Deny / Always allow / Allow once. So the ask is re-read here into the
+ * questions the model actually posed, the card renders them as choices, and
+ * the answer goes back as text.
+ *
+ * The payload is bot-authored, so every field is treated as untrusted: the
+ * shape is validated rather than cast, and the counts and lengths are capped
+ * so a runaway (or hostile) tool call cannot produce an unreadable card.
+ */
+/** The provider tool whose input this module understands. */
+export const ASK_USER_QUESTION_TOOL = "AskUserQuestion";
+/** Caps. Claude Code's own limits are smaller (1-4 questions, 2-4 options);
+ * these leave room for a provider that widens them without letting a card
+ * grow without bound. */
+export const MAX_QUESTIONS = 6;
+export const MAX_OPTIONS = 12;
+const MAX_QUESTION_TEXT = 400;
+const MAX_LABEL = 120;
+const MAX_DESCRIPTION = 400;
+/** One free-text answer. Long enough for a sentence or two of context. */
+export const MAX_CUSTOM_ANSWER = 2000;
+function text(value, limit) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed.slice(0, limit) : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseOption(value) {
+    // A bare string is not the documented shape, but it is the obvious
+    // degradation and costs one line to accept.
+    if (typeof value === "string") {
+        const label = text(value, MAX_LABEL);
+        return label ? { label } : null;
+    }
+    if (!isRecord(value))
+        return null;
+    const label = text(value.label, MAX_LABEL);
+    if (!label)
+        return null;
+    const description = text(value.description, MAX_DESCRIPTION);
+    return description ? { label, description } : { label };
+}
+function parseQuestion(value) {
+    if (!isRecord(value))
+        return null;
+    const question = text(value.question, MAX_QUESTION_TEXT);
+    if (!question)
+        return null;
+    const options = [];
+    const seen = new Set();
+    for (const raw of Array.isArray(value.options) ? value.options : []) {
+        const option = parseOption(raw);
+        // Duplicate labels are the one thing a radio group cannot survive: the
+        // answer text could no longer say which row was picked.
+        if (!option || seen.has(option.label))
+            continue;
+        seen.add(option.label);
+        options.push(option);
+        if (options.length === MAX_OPTIONS)
+            break;
+    }
+    // A question with nothing to choose from is still answerable — the card
+    // always offers free text — so an empty option list is kept, not dropped.
+    const header = text(value.header, MAX_LABEL);
+    return {
+        question,
+        ...(header ? { header } : {}),
+        ...(value.multiSelect === true ? { multiSelect: true } : {}),
+        options,
+    };
+}
+/** The questions inside an AskUserQuestion tool input, or null when the
+ * payload is not one (a malformed call falls back to the ordinary card). */
+export function parseAskQuestions(input) {
+    if (!isRecord(input) || !Array.isArray(input.questions))
+        return null;
+    const questions = [];
+    for (const raw of input.questions) {
+        const question = parseQuestion(raw);
+        if (!question)
+            continue;
+        questions.push(question);
+        if (questions.length === MAX_QUESTIONS)
+            break;
+    }
+    return questions.length ? questions : null;
+}
+/** The one line the card subtitle and a spoken prompt show. */
+export function askQuestionSummary(questions) {
+    const first = questions[0]?.question ?? "";
+    const rest = questions.length - 1;
+    return rest > 0 ? `${first} (+${rest} more question${rest > 1 ? "s" : ""})` : first;
+}
+/** Flat labels for clients that only know how to render a list of choices
+ * (the phone companions, and any older desktop build). Only a single
+ * question can be answered that way without losing which one was answered. */
+export function questionChoices(questions) {
+    if (questions.length !== 1)
+        return undefined;
+    const only = questions[0];
+    if (only.multiSelect || only.options.length < 2)
+        return undefined;
+    return only.options.map((option) => option.label);
+}
+/** The lead-in on a formatted answer. It exists for the model — the answer
+ * is delivered on the deny channel, so it has to say what it is — and the
+ * card strips it back off when it shows the person what they sent. */
+export const ANSWER_PREAMBLE = "The user answered your questions.";
+/**
+ * What the model is told. It arrives as the tool's result, so it has to
+ * stand on its own: name each question, then what was picked for it.
+ */
+export function formatQuestionAnswers(questions, answers) {
+    const blocks = [];
+    questions.forEach((question, index) => {
+        const picked = (answers[index] ?? []).map((value) => value.trim()).filter(Boolean);
+        if (!picked.length)
+            return;
+        blocks.push(`Q: ${question.question}\nA: ${picked.join(", ")}`);
+    });
+    if (!blocks.length)
+        return "";
+    return `${ANSWER_PREAMBLE}\n\n${blocks.join("\n\n")}`;
+}
+/** The same answer with the model-facing lead-in removed, for the settled
+ * card. Anything that does not carry the lead-in is shown as it is. */
+export function answerWithoutPreamble(answer) {
+    return answer.startsWith(`${ANSWER_PREAMBLE}\n\n`) ? answer.slice(ANSWER_PREAMBLE.length + 2) : answer;
+}
+/**
+ * The answer text, read back as one value per question.
+ *
+ * `AskUserQuestion` is answered through its own `answers` field, keyed by the
+ * question's text — but the card sends ONE answer for the whole set, because
+ * a person answers the whole card at once. `formatQuestionAnswers` writes
+ * each question's text beside its answer for exactly this reason, so the map
+ * is recovered rather than guessed.
+ *
+ * A message that carries no blocks at all is the flat path: an older client,
+ * or a phone answering a single-question card with one of the option labels
+ * the harness also sends. With exactly one question there is no ambiguity
+ * about what it answers, so the whole message is that question's answer.
+ * With more than one there is, and nothing is filed.
+ */
+export function questionAnswersByQuestion(message, questions) {
+    const answers = {};
+    const known = new Map(questions.map((entry) => [entry.question, entry.question]));
+    for (const block of message.split("\n\n")) {
+        const match = /^Q: ([\s\S]+?)\nA: ([\s\S]+)$/.exec(block.trim());
+        if (!match)
+            continue;
+        // Only a question this ask actually posed. An unrecognized block is
+        // dropped rather than filed under a key the tool never asked about.
+        const question = known.get(match[1].trim());
+        if (question)
+            answers[question] = match[2].trim();
+    }
+    if (Object.keys(answers).length)
+        return answers;
+    const only = questions.length === 1 ? questions[0] : undefined;
+    const flat = message.trim();
+    return only && flat ? { [only.question]: flat } : {};
+}

package/dist-server/shared/provider-safety.js

@@ -0,0 +1,6 @@
+/** Match provider error wording, not ordinary assistant discussions of safety. */
+export function isProviderSafetyBlock(message) {
+    return /\bblocked by (?:our|the provider['’]s) safety systems\b|\bsafety monitoring\b.{0,100}\b(?:paused|ended|blocked)\b|\b(?:safety_check_failed|safety_policy_violation)\b/i.test(message);
+}
+export const PROVIDER_SAFETY_GUIDANCE = "The provider stopped this task. Full access controls tool approvals, not provider safety checks. Review the provider’s findings in Codex if available; OpenMausBot cannot override this block.";
+export const PROVIDER_SAFETY_HELP_URL = "https://learn.chatgpt.com/docs/agent-approvals-security#safety-monitoring-and-paused-tasks";

package/dist-server/shared/team-backup.js

@@ -21,6 +21,7 @@ const task = z.object({
     title: z.string().max(2_000),
     createdAt: timestamp,
     openedBy: z.object({ botId: key, name, at: timestamp }).optional(),
+    closedBy: z.object({ botId: key, name, at: timestamp }).optional(),
     activeLeafId: key.nullable(),
     messages: z.array(message).max(100_000),
 });

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

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmausbot",
-  "version": "0.1.74",
+  "version": "0.1.76",
   "description": "Run the OpenMausBot server anywhere and pair your devices to it",
   "license": "Apache-2.0",
   "type": "module",