openmausbot 0.1.92 → 0.1.94

package/dist-server/server/tunnel.js

@@ -91,20 +91,38 @@ export function tunnelAccess(document) {
 export function platformName(platform = process.platform) {
     return platform === "darwin" ? "darwin" : platform === "win32" ? "windows" : "linux";
 }
+const STOPPED_TUNNEL = { status: "stopped", ready: false };
 /** The desktop honours OMB_CONTROL_PLANE_URL only in development builds; a
  * server's operator owns its environment, so it is honoured here always and
- * the caller says so in its output. */
+ * the caller says so in its output. One-shot commands (login, status) pass no
+ * `recovery` and so start no background timers. */
 export function createTunnelAccount(options) {
     const env = options.env ?? process.env;
     const credentials = openTunnelCredentials(options.dataDir);
     const controlPlane = resolveCompanionControlPlaneURL({ isPackaged: true, environment: env });
     const client = controlPlane ? createControlPlaneClient({ baseURL: controlPlane, fetchImpl: options.fetchImpl }) : null;
+    const recovery = options.recovery;
     const service = createCompanionAccountService({
         client,
         readCredentials: () => credentials.read(),
         updateCredentials: (derive, afterPersist) => credentials.update(derive, afterPersist),
         identity: { name: options.machineName ?? hostname(), platform: platformName(), appVersion: options.version },
         newClientInstanceId: () => randomUUID(),
+        ...(recovery
+            ? {
+                autoRecover: true,
+                companionIsOn: () => recovery.running() !== null,
+                managedConnectionState: () => recovery.running()?.state() ?? STOPPED_TUNNEL,
+                activatePersistedEndpoint: async () => {
+                    const tunnel = recovery.running();
+                    const access = tunnelAccess(credentials.read());
+                    if (!tunnel || !access)
+                        return tunnel?.state() ?? STOPPED_TUNNEL;
+                    return tunnel.restart(access);
+                },
+                ...options.clock,
+            }
+            : {}),
     });
     return { service, credentials, controlPlane };
 }
@@ -206,6 +224,7 @@ export function startTunnel(options) {
         address: options.access.endpoint,
         state: () => current,
         started,
+        restart: (access) => tunnel.start({ endpoint: access.endpoint, token: access.token, originTarget: options.originTarget }),
         stop: async () => {
             await tunnel.stop();
         },

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

@@ -0,0 +1,10 @@
+// The line the harness prints when a turn starts (stderr, which the desktop
+// app keeps in server.log). It shows the start of the prompt, so a stuck turn
+// can be traced to what was asked. Words spoken on a Live call are never
+// logged — the call's summary line (liveCallSummaryLine) has counters only —
+// so a turn carrying any of them shows `text=(spoken)` instead.
+const LOGGED_CHARS = 70;
+export function turnStartLogLine(turn) {
+    const text = turn.spoken ? "(spoken)" : JSON.stringify(turn.text.slice(0, LOGGED_CHARS));
+    return `[omb-turn] bot=${turn.botId} text=${text} images=${turn.images} depth=${turn.depth} card=${turn.card}`;
+}

package/dist-server/server/turn-resources.js

@@ -7,6 +7,71 @@ import { relative, resolve, sep } from "node:path";
 export class TurnResources {
     owners = new Map();
     reclaims = new Map();
+    /** Arrival-ordered waiters per requested resource (#1652). Entries exist
+     * only while a turn is genuinely waiting (the exclusive bind's poll loop):
+     * a lazy claim that failed once and moved on must not sit at the front and
+     * block an actively waiting turn behind it from being granted the seat. */
+    waiters = new Map();
+    /** Exponentially weighted moving average of recent wait durations per
+     * resource, recorded when a waiting turn finally acquires. No history,
+     * no estimate: the chip shows one only once this map has an entry. */
+    waitStats = new Map();
+    /** Join the waitlist for a resource and return the stable position: where
+     * this turn sits among the waiters, in arrival order. Joining twice keeps
+     * the original place; positions only improve (a waiter ahead leaving),
+     * never jitter. */
+    startWaiting(resource, owner) {
+        const queue = this.waiters.get(resource);
+        if (!queue) {
+            this.waiters.set(resource, [owner]);
+            return 1;
+        }
+        const index = queue.findIndex(waiting => sameOwner(waiting, owner));
+        if (index >= 0)
+            return index + 1;
+        queue.push(owner);
+        return queue.length;
+    }
+    /** Leave the waitlist without claiming: the wait stopped, parked, or was
+     * cancelled. Idempotent, and safe for an owner who never joined. */
+    stopWaiting(resource, owner) {
+        const queue = this.waiters.get(resource);
+        if (!queue)
+            return;
+        const next = queue.filter(waiting => !sameOwner(waiting, owner));
+        if (next.length)
+            this.waiters.set(resource, next);
+        else
+            this.waiters.delete(resource);
+    }
+    /** This owner's current position in a resource's waitlist, or undefined
+     * when they are not waiting for it. */
+    waitPosition(resource, owner) {
+        const queue = this.waiters.get(resource);
+        if (!queue)
+            return undefined;
+        const index = queue.findIndex(waiting => sameOwner(waiting, owner));
+        return index < 0 ? undefined : index + 1;
+    }
+    /** Record how long a wait lasted once it ended in acquisition, feeding the
+     * per-resource estimate. Clamped to sane values so a clock skew cannot
+     * poison the average. */
+    noteWait(resource, waitedMs) {
+        if (!Number.isFinite(waitedMs) || waitedMs < 0)
+            return;
+        const sample = Math.min(waitedMs, 24 * 60 * 60_000);
+        const stats = this.waitStats.get(resource);
+        // Weight 1/4: recent waits dominate, one outlier does not rewrite the
+        // estimate, and the very first wait seeds the history on its own.
+        this.waitStats.set(resource, stats
+            ? { ewmaMs: stats.ewmaMs + 0.25 * (sample - stats.ewmaMs), samples: stats.samples + 1 }
+            : { ewmaMs: sample, samples: 1 });
+    }
+    /** The smoothed recent wait for a resource, or undefined until at least one
+     * wait has completed — the chip's estimate condition (#1652). */
+    waitEstimateMs(resource) {
+        return this.waitStats.get(resource)?.ewmaMs;
+    }
     blocker(resource, owner, now = Date.now()) {
         this.expireIdle(resource, now);
         for (const [key, current] of this.owners) {
@@ -26,6 +91,16 @@ export class TurnResources {
             // hold the seat past every quiet window (#1653).
             return true;
         }
+        // The free seat belongs to the front waiter; a current holder's
+        // revalidation above never loses its own claim to this queue.
+        const queue = this.waiters.get(resource);
+        if (queue?.length && !sameOwner(queue[0], owner))
+            return false;
+        if (queue?.length) {
+            queue.shift();
+            if (!queue.length)
+                this.waiters.delete(resource);
+        }
         const record = { owner };
         if (options.idle) {
             record.idle = options.idle;
@@ -60,6 +135,28 @@ export class TurnResources {
         if (current?.idle && sameOwner(current.owner, owner))
             current.activityAt = now;
     }
+    /** A screen-touching computer tool call started on this claim (#1653):
+     * the desktop is executing real I/O for the sitting owner, so the seat
+     * cannot be idle-released mid-call. Only the sitting owner's start
+     * counts; a start whose completion never arrives holds the seat until
+     * settle — the pre-#1653 behavior, never an overlapping handoff. */
+    beginComputerCall(resource, owner) {
+        const current = this.owners.get(resource);
+        if (current?.idle && sameOwner(current.owner, owner)) {
+            current.computerCallsInFlight = (current.computerCallsInFlight ?? 0) + 1;
+        }
+    }
+    /** The in-flight computer call finished: drop its fence and let the
+     * completion's own activity tick govern the quiet window. A no-op when
+     * the claim lapsed or another turn seated itself in between. */
+    endComputerCall(resource, owner) {
+        const current = this.owners.get(resource);
+        if (!current?.idle || !sameOwner(current.owner, owner))
+            return;
+        const inFlight = current.computerCallsInFlight ?? 0;
+        if (inFlight > 0)
+            current.computerCallsInFlight = inFlight - 1;
+    }
     /** Who may still re-claim `resource` directly after an idle release
      * (#1653): the mid-task turn that went quiet, until its reclaim window
      * ends or another turn seats itself. The direct re-claim itself is
@@ -76,6 +173,13 @@ export class TurnResources {
         return reclaimed.owner;
     }
     release(owner) {
+        for (const [key, queue] of this.waiters) {
+            const next = queue.filter(waiting => !sameOwner(waiting, owner));
+            if (next.length)
+                this.waiters.set(key, next);
+            else
+                this.waiters.delete(key);
+        }
         for (const [key, current] of this.owners) {
             if (sameOwner(current.owner, owner))
                 this.owners.delete(key);
@@ -92,6 +196,7 @@ export class TurnResources {
     releaseOne(resource, owner, now = Date.now()) {
         if (this.owns(resource, owner, now))
             this.owners.delete(resource);
+        this.stopWaiting(resource, owner);
         // owns() may have just expired a quiet claim into a reclaim record
         // for this same owner: an early release keeps no reclaim priority.
         const reclaimed = this.reclaims.get(resource);
@@ -106,11 +211,30 @@ export class TurnResources {
         const current = this.owners.get(resource);
         if (!current?.idle || current.activityAt === undefined)
             return;
+        // A call the desktop is still executing fences the seat (#1653):
+        // releasing mid-call would hand one desktop to two turns at once.
+        if ((current.computerCallsInFlight ?? 0) > 0)
+            return;
         if (!current.idle.quietElapsed(current.activityAt, now))
             return;
         this.owners.delete(resource);
         this.reclaims.set(resource, { owner: current.owner, until: now + current.idle.reclaimMs });
     }
+    /** Whether any live owner holds this resource: the parked-resume drain's
+     * gate (#1651) — a resume fires only when the seat it queued on is free. */
+    free(resource, now = Date.now()) {
+        for (const key of this.owners.keys()) {
+            if (!overlaps(key, resource))
+                continue;
+            // A quiet-window claim expires the moment anything needs to know
+            // whether the seat is free: the parked-resume gate must not wait on
+            // a claim whose window already elapsed (#1653).
+            this.expireIdle(key, now);
+            if (this.owners.has(key))
+                return false;
+        }
+        return true;
+    }
 }
 function sameOwner(a, b) {
     return a.threadId === b.threadId && a.generation === b.generation;

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

@@ -817,7 +817,7 @@ export function vpsContainerRunArgs(containerName, imageRef = VPS_IMAGE, viewerS
         // someone opens the panel. unless-stopped survives reboots while still
         // honoring an explicit Stop. The shared hardening check accepts exactly
         // this policy for the VPS caller (and only "no"/unset for the Local VM,
-        // whose desktop cannot safely resume).
+        // whose starts are controlled by OMB's turn lifecycle).
         "--restart",
         "unless-stopped",
         "-e",

package/dist-server/server/workspace-backup.js

@@ -37,6 +37,7 @@ const EXCLUSION_NOTES = [
     "Device pairing, server identity, live leases and runtime files (existing destination identities are preserved).",
     "Saved credentials, provider and MCP connections, managed provider login homes and browser login profiles are not transferred. Destination connections are preserved; reconnect on a new device.",
     "Downloaded tools and caches; these can be installed again.",
+    "Installed dependency folders (node_modules) and symbolic links inside conversation work folders; reinstall or recreate them in the project.",
     "External project folders, CLI login homes, browser session homes, OS keychains, companion devices and other servers.",
     "VM/container disk layers and remote cloud data; durable files inside this workspace are included.",
 ];
@@ -327,6 +328,8 @@ export async function createWorkspaceBackupSnapshot(dataDir, options, jobId) {
     const warnings = ["Stop external editors and managed desktops before exporting; files written outside this server cannot be frozen by the backup gate.", "Conversation text and user files are not redacted and may contain secrets you pasted. Keep the encrypted backup private.", RESTORE_WARNING];
     let bytes = 0;
     let skippedLinks = 0;
+    let skippedDependencies = 0;
+    let skippedWorkLinks = 0;
     try {
         const root = realpathSync(dataDir);
         const sourceDb = join(root, "messages.db");
@@ -370,6 +373,21 @@ export async function createWorkspaceBackupSnapshot(dataDir, options, jobId) {
                     throw new Error("A workspace filename cannot be safely restored on supported platforms.");
                 const source = join(directory, name);
                 const stat = lstatSync(source);
+                // Installed dependencies come back from the project's lockfile, can
+                // hold more files than this format allows, and are often a link an
+                // agent made to another checkout's install. Leave them out.
+                if (name === "node_modules" && (stat.isDirectory() || stat.isSymbolicLink())) {
+                    skippedDependencies++;
+                    continue;
+                }
+                // A conversation's work folder (task-workspaces/<bot>/<thread>) holds
+                // what an agent made there, and agents link things in (another
+                // checkout, a virtualenv). A link's target is not this workspace's
+                // data, so the link is left out rather than failing the backup.
+                if (stat.isSymbolicLink() && path.startsWith("task-workspaces/")) {
+                    skippedWorkLinks++;
+                    continue;
+                }
                 if (stat.isSymbolicLink()) {
                     let target;
                     try {
@@ -430,6 +448,10 @@ export async function createWorkspaceBackupSnapshot(dataDir, options, jobId) {
         walk(root);
         if (skippedLinks)
             warnings.push(`${skippedLinks} managed skill discovery link(s) were omitted and are recreated by the app.`);
+        if (skippedDependencies)
+            warnings.push(`${skippedDependencies} installed dependency folder(s) (node_modules) were omitted; reinstall them in the project after restoring.`);
+        if (skippedWorkLinks)
+            warnings.push(`${skippedWorkLinks} symbolic link(s) in conversation work folders were omitted; what they point to is outside this backup.`);
         const summary = {
             format: "openmaus.workspace-backup", version: 1, id: job.id, createdAt: new Date().toISOString(),
             appVersion: options.appVersion ?? "unknown", files: entries.filter((entry) => entry.type === "file").length,

package/dist-server/server/workspace.js

@@ -20,7 +20,7 @@ export const WORKSPACES_DIR = join(DATA_DIR, "workspaces");
 export const TASK_WORKSPACES_DIR = join(DATA_DIR, "task-workspaces");
 /** MCP support does not imply native filesystem tools or a local working directory. */
 export function supportsWorkspaceFiles(driverKind) {
-    return !["grok", "openai-compat", "minimax", "mistral", "boxAgent"].includes(driverKind);
+    return !["grok", "openai-compat", "minimax", "mistral", "cerebras", "boxAgent"].includes(driverKind);
 }
 /** Default task files are private to the thread, outside the bot's shared
  * memory folder. This is directory organization, not a shell sandbox. */

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

@@ -21,7 +21,7 @@ export function supportsApprovalMode(driverKind, mode) {
     // engines could never stop asking — not by its own level, and not through
     // a Chief's delegated Full access either.
     return ["codex", "claudeAgent", "antigravityAgent", "cursorAgent", "grokAgent", "opencodeGo", "qwenAgent", "geminiAgent",
-        "openai-compat", "grok", "minimax", "mistral"].includes(driverKind ?? "");
+        "openai-compat", "grok", "minimax", "mistral", "cerebras"].includes(driverKind ?? "");
 }
 /** A Full/Custom grant belongs to one provider's tool semantics. Other
  * modes carry across only when the destination actually implements them.

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

@@ -15,6 +15,7 @@
  */
 /** The provider tool whose input this module understands. */
 export const ASK_USER_QUESTION_TOOL = "AskUserQuestion";
+export const QUESTION_DISMISS_MESSAGE = "The user closed this question without answering. Use your best judgment and continue.";
 /** 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. */
@@ -27,6 +28,18 @@ 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;
+/** Older live question cards predate requestType and only omit the permission
+ * tool. Keep those actionable too, while excluding other durable proposal
+ * card kinds that share requestId. */
+export function isPersistentQuestionCard(card) {
+    return Boolean(card && (card.requestType === "question" || card.questionRequest ||
+        (!card.requestType && !card.tool && !card.routineRequest && !card.skillRequest && !card.profileRequest &&
+            !card.modelRequest && !card.tighteningRequest && !card.teamSetupRequest)));
+}
+/** System/provider completion ends the live run, not the human's question. */
+export function shouldSettleRequestCard(card, source) {
+    return !isPersistentQuestionCard(card) || source === "user";
+}
 function text(value, limit) {
     if (typeof value !== "string")
         return undefined;

package/dist-server/shared/call-consent.js

@@ -0,0 +1,28 @@
+// Spoken answers to a permission card, shared by both call modes. Anything
+// else is read as a reply to the bot, not as consent — an approval must
+// never be granted by a sentence that merely contained the word "sure".
+export const YES = /^(yes|yeah|yep|yup|sure|ok|okay|go ahead|do it|allow|approve|approved|fine|please do)\b/i;
+export const NO = /^(no|nope|don'?t|do not|stop|deny|denied|cancel|never|skip it)\b/i;
+const FILLER = /^(?:(?:um+|uh+|er+|so|well|hmm+)[\s,.!?-]+)+/i;
+/** On a Live call these only hedge: "okay…" then a pause then "wait, what
+ * does it delete?", a bystander's "okay", or the voice's own "Okay, I need
+ * your permission" heard back through a phone's speaker. They are filler
+ * there, never the answer; a clear yes or no after them still counts. */
+const LIVE_HEDGES = /^(?:(?:um+|uh+|er+|so|well|hmm+|ok|okay|sure|fine)(?:[\s,.!?-]+|$))+/i;
+// A Live approval grants the entire action on the card. Extra conditions,
+// questions or corrections are not permission for that unchanged action.
+const LIVE_YES = /^(?:yes|yeah|yep|yup|go ahead|do it|allow(?: it)?|approve(?: it)?|approved|please do)(?:[\s,]+(?:please|go ahead|do it))*[.!]*$/i;
+/** "allow", "deny", or null when the words are not a clear decision. The
+ * answer must open the utterance; filler before it ("uh, yes") is dropped.
+ * `live`: a Live call, whose microphone stays open while the voice speaks
+ * and which decides after a short quiet window — hedges never decide there.
+ * `turns` (take turns) keeps its own rule: its microphone is closed while
+ * the bot talks. */
+export function spokenConsent(text, mode = "turns") {
+    const said = text.trim().replace(mode === "live" ? LIVE_HEDGES : FILLER, "");
+    if ((mode === "live" ? LIVE_YES : YES).test(said))
+        return "allow";
+    if (NO.test(said))
+        return "deny";
+    return null;
+}

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

@@ -0,0 +1,124 @@
+/** "approval": a provider or peer ask the voice may decide with a strict yes/no.
+ * "review": a harness-native proposal (skill, routine, profile, default
+ * model, tightening, team setup) that must be reviewed on screen.
+ * "question": a provider question. An expired proposal is settled: nothing
+ * can answer it any more. */
+export function liveCardKind(card) {
+    if (!card?.requestId || card.answered || card.dismissed || card.expired)
+        return null;
+    if (card.skillRequest || card.routineRequest || card.profileRequest || card.modelRequest || card.tighteningRequest || card.teamSetupRequest) {
+        return "review";
+    }
+    return card.tool ? "approval" : "question";
+}
+/** Why a decision made on a Live call must not reach this card, or null to
+ * deliver it. A card settled a moment earlier (answered or dismissed on
+ * screen) is refused before anything runs: delivering to it would add a
+ * false "the action was not run" line after the tap did run it. A card that
+ * is not on the thread is left to the normal answer path. */
+export function liveDecisionRefusal(card) {
+    if (!card)
+        return null;
+    const kind = liveCardKind(card);
+    if (kind === "review")
+        return "This request is reviewed on screen.";
+    return kind ? null : "The request is no longer open.";
+}
+const TOOL_PHRASES = {
+    Bash: "run a command",
+    Read: "read a file",
+    Write: "write a file",
+    Edit: "edit a file",
+    WebFetch: "fetch a web page",
+    WebSearch: "search the web",
+    schedule_routine: "schedule a routine",
+    manage_routine: "change a routine",
+    stage_skill: "enable a learned skill",
+    update_skill: "update a learned skill",
+    update_profile: "update its profile",
+    shell: "run a command",
+    edit: "edit a file",
+    read: "read a file",
+    fetch: "fetch a web page",
+    delete: "delete a file",
+    think: "think",
+    other: "take an action",
+    tool: "use a tool",
+};
+/** Same rule as toolLabel in src/components/ApprovalCard.tsx, in English. */
+export function toolPhrase(tool) {
+    if (!tool)
+        return "take an action";
+    return TOOL_PHRASES[tool] ?? tool.replace(/^mcp__[^_]+__/, "").replace(/_/g, " ");
+}
+const DETAIL_LIMIT = 400;
+function duration(ms) {
+    const seconds = Math.max(0, Math.round(ms / 1_000));
+    if (seconds < 60)
+        return `${seconds} second${seconds === 1 ? "" : "s"}`;
+    const minutes = Math.round(seconds / 60);
+    return `${minutes} minute${minutes === 1 ? "" : "s"}`;
+}
+/** A bot's step as the voice may name it: the tool's own spoken label, or
+ * the tool's name ("team notes: query database") — never its arguments,
+ * which can hold paths, queries or private text. */
+export function liveStepLabel(tool) {
+    if (tool.spoken?.trim())
+        return brief(tool.spoken, 80);
+    const parts = tool.name.split("__");
+    if (parts[0] === "mcp" && parts.length >= 3) {
+        const server = parts[1].replace(/[-_]+/g, " ").trim();
+        const action = parts.slice(2).join(" ").replace(/_+/g, " ").trim();
+        return brief(`${server}: ${action}`, 80);
+    }
+    return toolPhrase(tool.name);
+}
+function brief(text, limit = DETAIL_LIMIT) {
+    const flat = text.replace(/\s+/g, " ").trim().replace(/[.!?]+$/, "");
+    return flat.length <= limit ? flat : `${flat.slice(0, limit).replace(/\s+\S*$/, "")}…`;
+}
+// The voice IS the bot to the person on the call, so everything below is
+// either said as the bot ("I …") or addressed to the voice as "you". Never
+// name the bot in the third person: the voice then talks about itself as a
+// separate "backend" (seen in the first test calls).
+export function spokenApprovalPrompt(card) {
+    const detail = brief(card.subtitle);
+    return `I want to ${toolPhrase(card.tool)}.${detail ? ` ${detail}.` : ""} May I?`;
+}
+export function spokenReviewPrompt(card) {
+    const title = brief(card.title || "a proposal", 200);
+    return `Tell the user, in your own words, that you need their decision in the chat: ${title}. They review it on screen and choose there; it cannot be decided by voice.`;
+}
+/** The bot waits for an app to be connected in the chat (a connector card). */
+export function spokenConnectorPrompt(label) {
+    return `Tell the user, in your own words, that you need them to connect ${brief(label || "an app", 80)} in the chat before you can go on. It cannot be done by voice.`;
+}
+/** The bot waits for a credential entered on screen (a secret card). It must
+ * never travel through the call, so the voice never asks for it aloud. */
+export function spokenSecretPrompt(label) {
+    return `Tell the user, in your own words, that you need ${brief(label || "a credential", 80)} entered in the chat on screen before you can go on. Never ask them to say it aloud.`;
+}
+export function spokenQuestionPrompt(card) {
+    const detail = brief(card.subtitle || card.title);
+    const choices = card.options.length ? ` The options are ${card.options.join(", ")}.` : "";
+    // brief() drops the detail's own closing mark, so the "?" is never doubled
+    return `Ask the user, in your own words: ${detail}?${choices} Then delegate their answer.`;
+}
+export const LIVE_COPY = {
+    notHeard: "The request was not heard clearly. Ask the user to say it again.",
+    notClear: "That was not a clear yes or no. Ask the user again for a clear yes or no.",
+    deniedMessage: "Denied by the user, on a live call.",
+    answeredInChat: "The user answered that request in the chat. Do not ask about it again.",
+    working: "You are working on the request now. Nothing is done until the result comes back; do not guess it.",
+    answerPassed: "You are using the user's answer now. Wait for the result.",
+    granted: "Thanks, I'll go ahead.",
+    denied: "Okay, I won't do it.",
+    saveFailed: (detail) => `The decision could not be saved${detail ? `: ${detail}` : "."} Ask the user to try again.`,
+    noAnswer: "I'm done. The result, or what went wrong, is in the chat.",
+    typedAnswerLead: (typed) => `About what you typed in the chat ("${brief(typed, 200)}"):`,
+    progress: (spoken) => `Progress: ${brief(spoken, 200)}`,
+    status: (workedMs, steps, lastStep, lastStepAgoMs) => `Status note, do not announce it: you are still working on it (${duration(workedMs)} so far, ${steps} step${steps === 1 ? "" : "s"}${lastStep ? `; last step: ${lastStep}, ${duration(lastStepAgoMs)} ago` : ""}).`,
+    signedOut: "The call has ended because the sign-in that started it has ended. Sign in again to start a new call.",
+    unpaired: "The call has ended because the phone that started it was unpaired from this computer.",
+    permissionRequest: (prompt) => `You need the user's permission. Say it in your own words: ${prompt} Ask for a clear yes or no, then delegate their answer.`,
+};