openmausbot 0.1.97 → 0.1.99

package/dist-server/server/store.js

@@ -5,7 +5,7 @@
 import { createHash } from "node:crypto";
 import { chmodSync, existsSync, readFileSync, mkdirSync, rmSync, statSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { writeFileAtomic } from "./atomic.js";
+import { writeFileAtomic, writeFileAtomicIfChanged } from "./atomic.js";
 import { parseToolScope, toolScopeWidens } from "../shared/tool-scope.js";
 import { ensureSections, readSections, changeEmptySection } from "./section-context.js";
 import { removeBotFolder, soulFile, soulHash, writeSoulMirror } from "./bot-folder.js";
@@ -22,6 +22,7 @@ import { approvalModeFor, isApprovalMode, modelSwitchNeedsAsk } from "../shared/
 import { REMOVED_COMPUTER_DRIVER } from "./computer-engine-removal.js";
 import { isMentionBoundary, isMentionNameContinuation } from "../shared/mention-boundary.js";
 import { CONNECTOR_SLUG_PATTERN, CONNECTOR_TOOL_NAME_PATTERN } from "../shared/wire.js";
+import { sameModelSelection } from "../shared/thread-model.js";
 export const groupWireProjectionIsExact = true;
 // Unicode's complete emoji sequences include flags, skin tones and ZWJ
 // combinations. Also allow unqualified single symbols (e.g. ♥), but not
@@ -32,13 +33,19 @@ export function isProjectEmoji(value) {
 }
 export const taskWireProjectionIsExact = true;
 /** The typed wire projection for one task. Pairs with the assertion above:
- * returning WireTask means an undeclared server field cannot ride silently. */
-export function toWireTask(task) {
-    const { resumeCursors: _resumeCursors, lastInstanceId: _lastInstanceId, handedMessages: _handedMessages, appliedCompactionId: _appliedCompactionId, contextFloor: _contextFloor, lastContextModel: _lastContextModel, surfaceSource, ...wire } = task;
+ * returning WireTask means an undeclared server field cannot ride silently.
+ * A thread with no model of its own follows its bot: the wire carries the
+ * model it runs on either way, so every client reads one effective model. */
+export function toWireTask(task, botModel) {
+    const { resumeCursors: _resumeCursors, lastInstanceId: _lastInstanceId, handedMessages: _handedMessages, appliedCompactionId: _appliedCompactionId, contextFloor: _contextFloor, lastContextModel: _lastContextModel, surfaceSource, ...stored } = task;
+    const wire = { ...stored, modelSelection: structuredClone(task.modelSelection ?? botModel), followsBotModel: task.modelSelection === undefined };
     // Who pinned stays private. A client learns only whether the pin is the
     // machine's own record, so it never presents one as the person's choice.
     return surfaceSource === "auto" && wire.surface !== undefined ? { ...wire, surfaceAuto: true } : wire;
 }
+/** The level a thread drops to when its engine changes under a level the new
+ * engine would have to confirm (modelSwitchNeedsAsk), as on every switch. */
+const ASK_NOW = { approvalMode: "ask", autoApprove: false, alwaysAllow: [] };
 const TASK_PATCH_FIELDS = [
     "title", "projectId", "modelSelection", "approvalMode", "autoApprove", "alwaysAllow",
     "unread", "rewound", "archivedAt", "pinned", "pinnedMessageId", "resumeCursors", "lastInstanceId", "cwd",
@@ -326,6 +333,9 @@ export function parseConnectorTools(value) {
 }
 const BOTS_FILE = join(DATA_DIR, "bots.json");
 const GROUPS_FILE = join(DATA_DIR, "groups.json");
+/** Written once the copies older builds made of a bot's model on its threads
+ * are cleared (Store load), so that cleanup runs once per data directory. */
+const THREAD_MODEL_COPIES_CLEARED = join(DATA_DIR, "thread-model-copies-cleared");
 /** The registries carry souls, project paths and per-bot settings, so they are
  * owner-only like the other data-dir stores. A file written by an older
  * release (or loosened by hand) is tightened on load. Best effort: failing to
@@ -456,6 +466,7 @@ export class Store {
     threads = new Map();
     defaultSelection;
     completeNewBotSelection;
+    driverKindOf;
     listeners = new Set();
     /** A broken team registry must not prevent loading independent chat data. */
     registeringInitialSections = true;
@@ -465,9 +476,14 @@ export class Store {
     constructor(defaultSelection, 
     /** Workspace-wide new-bot defaults (config newBots), applied to every
      * new bot's selection whichever path created it. */
-    completeNewBotSelection = (selection) => selection) {
+    completeNewBotSelection = (selection) => selection, 
+    /** The driver an engine instance runs, for the level a thread keeps when
+     * its engine changes (modelSwitchNeedsAsk). Unknown counts as another
+     * driver, so Full and Custom fall back to Ask. */
+    driverKindOf = () => undefined) {
         this.defaultSelection = defaultSelection;
         this.completeNewBotSelection = completeNewBotSelection;
+        this.driverKindOf = driverKindOf;
         mkdirSync(DATA_DIR, { recursive: true });
         for (const file of [BOTS_FILE, GROUPS_FILE])
             tightenRegistryFile(file);
@@ -696,11 +712,17 @@ export class Store {
         }
         if (groupsMigrated)
             this.saveGroups();
+        // Older builds copied a bot's model onto every thread it made, so a
+        // thread on exactly its bot's model is a copy, not a person's pick: once
+        // per data directory it is cleared and the thread follows its bot. A
+        // different model can't be told apart from a pick and stays. Only over a
+        // bot list this load could read, so an unreadable file is not skipped.
+        const clearModelCopies = !existsSync(THREAD_MODEL_COPIES_CLEARED) && (botsLoaded || !existsSync(BOTS_FILE));
         // bots saved before tasks existed have one endless thread; adopt it as
         // their first task so nothing is lost and nothing special-cases it
         for (const b of this.bots) {
-            // Folders are organizational only. Preserve existing thread model
-            // snapshots while discarding the unshipped folder-default setting.
+            // Folders are organizational only. Preserve threads' own models while
+            // discarding the unshipped folder-default setting.
             if (b.projects?.some((project) => "modelSelection" in project)) {
                 b.projects = b.projects.map(({ id, name, emoji }) => ({ id, name, ...(isProjectEmoji(emoji) ? { emoji } : {}) }));
                 botsMigrated = true;
@@ -730,8 +752,8 @@ export class Store {
                 botsMigrated = true;
             }
             for (const task of b.tasks) {
-                if (task.modelSelection === undefined) {
-                    task.modelSelection = structuredClone(b.modelSelection);
+                if (clearModelCopies && task.modelSelection !== undefined && sameModelSelection(task.modelSelection, b.modelSelection)) {
+                    delete task.modelSelection;
                     botsMigrated = true;
                 }
                 if (!task.resumeCursors) {
@@ -774,6 +796,8 @@ export class Store {
         }
         if (botsMigrated)
             this.saveBots();
+        if (clearModelCopies)
+            writeFileAtomic(THREAD_MODEL_COPIES_CLEARED, "Threads follow their bot's model; the copies older builds made are cleared.\n", { mode: 0o600 });
         // Search reads SQLite directly, so migrate every known legacy transcript
         // at startup rather than waiting until the user happens to open it. Only
         // pending JSON files are touched; already-migrated threads stay lazy.
@@ -896,10 +920,13 @@ export class Store {
         if (botsDirty)
             this.saveBots();
     }
+    // Many saves repeat what is already on disk (the same resume cursor, an
+    // unchanged task field), so both registries skip a byte-identical write.
+    // Events are still emitted by the callers either way.
     saveBots(bots = this.bots, registerSections = true) {
         if (registerSections)
             this.rememberSections([...this.bots, ...bots].map((bot) => bot.section));
-        writeFileAtomic(BOTS_FILE, JSON.stringify(bots.map(({ busy: _busy, activity: _activity, ...bot }) => ({
+        writeFileAtomicIfChanged(BOTS_FILE, JSON.stringify(bots.map(({ busy: _busy, activity: _activity, ...bot }) => ({
             ...bot,
             tasks: bot.tasks?.map(({ busy: _taskBusy, activity: _taskActivity, turnStartedAt: _taskTurnStarted, ...task }) => persistedPin(task)),
         })), null, 2), { mode: 0o600 });
@@ -907,7 +934,7 @@ export class Store {
     saveGroups(groups = this.groups, registerSections = true) {
         if (registerSections)
             this.rememberSections(groups.map((group) => group.section));
-        writeFileAtomic(GROUPS_FILE, JSON.stringify(groups.map(({ busyBotId: _busyBotId, turnStartedAt: _turnStartedAt, ...g }) => ({
+        writeFileAtomicIfChanged(GROUPS_FILE, JSON.stringify(groups.map(({ busyBotId: _busyBotId, turnStartedAt: _turnStartedAt, ...g }) => ({
             ...g,
             ...(g.tasks ? { tasks: g.tasks.map((task) => persistedPin(task)) } : {}),
         })), null, 2), { mode: 0o600 });
@@ -1120,6 +1147,9 @@ export class Store {
             else if (!patch.busyBotId)
                 delete group.turnStartedAt;
         }
+        if (Object.prototype.hasOwnProperty.call(patch, "turnTimeoutMinutes") && patch.turnTimeoutMinutes == null) {
+            delete group.turnTimeoutMinutes;
+        }
         if (!group.dm && Object.prototype.hasOwnProperty.call(patch, "pinnedMessageId")) {
             const active = this.activeGroupTask(group.id);
             if (active)
@@ -1260,6 +1290,20 @@ export class Store {
         this.emit({ type: "group", groupId });
         return task;
     }
+    /** Null removes the conversation's own ceiling so the next turn uses the
+     * global group limit. A sibling conversation is left alone. */
+    setGroupTaskTurnTimeout(groupId, threadId, minutes) {
+        const task = this.groupTaskByThread(groupId, threadId);
+        if (!task)
+            return null;
+        if (minutes == null)
+            delete task.turnTimeoutMinutes;
+        else
+            task.turnTimeoutMinutes = minutes;
+        this.saveGroups();
+        this.emit({ type: "group", groupId });
+        return task;
+    }
     renameGroupTask(groupId, threadId, title) {
         const task = this.groupTaskByThread(groupId, threadId);
         if (!task)
@@ -1626,7 +1670,6 @@ export class Store {
                 createdAt: bot.createdAt,
                 updatedAt: bot.createdAt,
                 resumeCursors: {},
-                modelSelection: structuredClone(bot.modelSelection),
                 unread: false,
                 activity: "idle",
                 busy: false,
@@ -1658,7 +1701,8 @@ export class Store {
         return bot;
     }
     /** All setup fields and the Chief's receipt commit before publishing any
-     * mutation. Model defaults never rewrite saved thread selections. */
+     * mutation. A new model moves the threads that follow the bot, never a
+     * thread's own model. */
     applyTeamSetup(request) {
         const chief = this.bot(request.botId);
         if (!chief)
@@ -1687,7 +1731,7 @@ export class Store {
                     // a restricted Chief never creates a bot everyone sees.
                     ...(chief.visibility && chief.visibility !== "everyone" ? { visibility: structuredClone(chief.visibility) } : {}),
                     tasks: [{ threadId: operation.threadId, title: UNTITLED_THREAD, createdAt, updatedAt: createdAt, resumeCursors: {},
-                            modelSelection: structuredClone(modelSelection), approvalMode: "ask", autoApprove: false,
+                            approvalMode: "ask", autoApprove: false,
                             unread: false, activity: "idle", busy: false }],
                 };
                 // "" is the private-workspace spelling on proposal; the record
@@ -1702,13 +1746,7 @@ export class Store {
                 const previous = nextBots[at];
                 next = { ...previous, ...operation.fields };
                 if (operation.fields.modelSelection)
-                    next.tasks = previous.tasks?.map((task) => ({
-                        ...task,
-                        modelSelection: structuredClone(task.modelSelection ?? previous.modelSelection),
-                        approvalMode: approvalModeFor(this.projectBotForTask(previous.id, task.threadId)),
-                        autoApprove: task.autoApprove ?? previous.autoApprove,
-                        alwaysAllow: structuredClone(task.alwaysAllow ?? previous.alwaysAllow ?? []),
-                    }));
+                    next.tasks = this.withDefaultModel(previous, operation.fields.modelSelection);
                 nextBots[at] = next;
             }
             if (operation.fields.chiefOfStaff === false)
@@ -1746,23 +1784,38 @@ export class Store {
         this.emit({ type: "bot", botId: chief.id });
         return result;
     }
-    /** One reviewed default-model change (propose_model): task stamping is
-     * identical to applyTeamSetup's update branch — saved per-thread
-     * selections are never rewritten, and a thread with no selection of its
-     * own is pinned to the previous default so it does not silently follow
-     * the new one. */
+    /** Moving this thread from one model to another takes its level back to
+     * Ask where the new engine would have to confirm it (modelSwitchNeedsAsk),
+     * as on every engine switch. Read before anything changes. */
+    switchNeedsAsk(botId, threadId, from, to) {
+        if (from.instanceId === to.instanceId)
+            return false;
+        const thread = this.projectBotForTask(botId, threadId);
+        return Boolean(thread) && modelSwitchNeedsAsk(approvalModeFor(thread), this.driverKindOf(from.instanceId), this.driverKindOf(to.instanceId));
+    }
+    /** A bot's threads as a change of its model to `next` leaves them. Each
+     * keeps the level it runs at now (older threads may still inherit the
+     * bot's, which may change in the same write); one that follows the bot
+     * moves with it, back to Ask where the new engine would have to confirm
+     * its level; a thread's own model stays. */
+    withDefaultModel(bot, next) {
+        return bot.tasks?.map((task) => ({
+            ...task,
+            approvalMode: approvalModeFor(this.projectBotForTask(bot.id, task.threadId)),
+            autoApprove: task.autoApprove ?? bot.autoApprove,
+            alwaysAllow: structuredClone(task.alwaysAllow ?? bot.alwaysAllow ?? []),
+            ...(task.modelSelection === undefined && this.switchNeedsAsk(bot.id, task.threadId, bot.modelSelection, next) ? structuredClone(ASK_NOW) : {}),
+        }));
+    }
+    /** One reviewed default-model change (propose_model), with
+     * applyTeamSetup's task stamping (withDefaultModel): every thread that
+     * follows the bot moves to the new model, and a thread's own model, which a
+     * person picked there, stays. */
     applyModelDefault(id, modelSelection) {
         const previous = this.bot(id);
         if (!previous)
             return null;
-        const next = { ...previous, modelSelection: structuredClone(modelSelection) };
-        next.tasks = previous.tasks?.map((task) => ({
-            ...task,
-            modelSelection: structuredClone(task.modelSelection ?? previous.modelSelection),
-            approvalMode: approvalModeFor(this.projectBotForTask(previous.id, task.threadId)),
-            autoApprove: task.autoApprove ?? previous.autoApprove,
-            alwaysAllow: structuredClone(task.alwaysAllow ?? previous.alwaysAllow ?? []),
-        }));
+        const next = { ...previous, modelSelection: structuredClone(modelSelection), tasks: this.withDefaultModel(previous, modelSelection) };
         this.saveBots(this.bots.map((candidate) => candidate.id === id ? next : candidate));
         this.bots = this.bots.map((candidate) => candidate.id === id ? next : candidate);
         this.emit({ type: "bot", botId: id });
@@ -1860,9 +1913,16 @@ export class Store {
             patch = { ...patch };
             delete patch.toolScope;
         }
+        // A new model moves the threads that follow the bot; one whose level the
+        // new engine would have to confirm goes back to Ask. That is a
+        // revocation, so it holds in memory like the others below.
+        const toAsk = patch.modelSelection ? (bot.tasks ?? []).filter((task) => task.modelSelection === undefined &&
+            this.switchNeedsAsk(id, task.threadId, bot.modelSelection, patch.modelSelection)) : [];
         // Runtime revocations must become effective in memory even when disk is
         // unavailable. Profile edits use the separate atomic path below.
         Object.assign(bot, patch);
+        for (const task of toAsk)
+            Object.assign(task, structuredClone(ASK_NOW));
         const task = this.activeTask(id);
         if (task) {
             for (const key of ["resumeCursors", "rewound", "pinnedMessageId", "unread"]) {
@@ -2586,37 +2646,61 @@ export class Store {
         this.emit({ type: "bot", botId });
         return cleared;
     }
-    /** Model/provider changes are one configuration transaction: never publish
-     * a new provider before its confirmed approval downgrade, or change the
-     * default while leaving the selected thread behind after a write failure. */
+    /** A person picks a model in one thread, and with updateBotDefault makes it
+     * the bot's model too. A thread on its bot's model follows the bot: it
+     * keeps no model of its own. Model/provider changes are one configuration
+     * transaction: never publish a new provider before its confirmed approval
+     * downgrade, or change the default while leaving the selected thread
+     * behind after a write failure. */
     switchTaskModel(botId, threadId, selection, updateBotDefault, resetApprovalToAsk, taskPatch = {}) {
         const bot = this.bot(botId);
         const task = this.taskByThread(botId, threadId);
         if (!bot || !task)
             return null;
-        const patch = { modelSelection: structuredClone(selection),
-            ...(resetApprovalToAsk ? { approvalMode: "ask", autoApprove: false, alwaysAllow: [] } : {}) };
-        const nextTask = persistedPin({ ...task, ...taskPatch, ...patch,
+        const approval = resetApprovalToAsk ? structuredClone(ASK_NOW) : {};
+        const own = sameModelSelection(selection, updateBotDefault ? selection : bot.modelSelection) ? undefined : structuredClone(selection);
+        const nextTask = persistedPin({ ...task, ...taskPatch, modelSelection: own, ...approval,
             ...(typeof taskPatch.title === "string" ? { title: taskPatch.title.trim().slice(0, 80) || UNTITLED_THREAD } : {}) });
-        // Older threads may still inherit settings. Freeze their effective
-        // values before updating the default so "other threads unchanged" also
-        // holds for workspaces created before per-thread approval settings.
-        const nextTasks = bot.tasks.map((candidate) => candidate === task ? nextTask : !updateBotDefault ? candidate : {
-            ...candidate,
-            modelSelection: structuredClone(candidate.modelSelection ?? bot.modelSelection),
-            approvalMode: approvalModeFor(this.projectBotForTask(botId, candidate.threadId)),
-            autoApprove: candidate.autoApprove ?? bot.autoApprove,
-            alwaysAllow: structuredClone(candidate.alwaysAllow ?? bot.alwaysAllow ?? []),
-        });
-        const next = { ...bot, ...(updateBotDefault ? patch : {}),
-            tasks: nextTasks };
-        this.saveBots(this.bots.map((candidate) => candidate === bot ? next : candidate));
+        // A new bot model moves the threads that follow it (withDefaultModel);
+        // every other thread keeps its model and the level it runs at now.
+        const others = updateBotDefault ? this.withDefaultModel(bot, selection) : bot.tasks;
+        const nextTasks = bot.tasks.map((candidate, index) => candidate === task ? nextTask : others[index]);
+        const botPatch = updateBotDefault ? { modelSelection: structuredClone(selection), ...approval } : {};
+        this.saveBots(this.bots.map((candidate) => candidate === bot ? { ...bot, ...botPatch, tasks: nextTasks } : candidate));
         bot.tasks.forEach((candidate, index) => Object.assign(candidate, nextTasks[index]));
-        if (updateBotDefault)
-            Object.assign(bot, patch);
+        Object.assign(bot, botPatch);
         this.emit({ type: "bot", botId });
         return task;
     }
+    /** These threads follow their bot's model again: each one's own model is
+     * cleared ("Switch them too", "Use the bot's model", or a model that can't
+     * run here). A level the bot's engine would have to confirm goes back to
+     * Ask, as on every engine switch, and `reset` adds what a changed model
+     * needs (a hosted workspace's fresh session). One write. Returns the
+     * threads that changed; a listed thread that already follows stays as it is. */
+    followBotModel(botId, threadIds, reset = () => ({})) {
+        const bot = this.bot(botId);
+        if (!bot?.tasks)
+            return [];
+        const listed = new Set(threadIds);
+        const patches = bot.tasks.map((task) => !listed.has(task.threadId) || task.modelSelection === undefined ? null : {
+            ...reset(task.modelSelection, bot.modelSelection),
+            modelSelection: undefined,
+            ...(this.switchNeedsAsk(botId, task.threadId, task.modelSelection, bot.modelSelection) ? structuredClone(ASK_NOW) : {}),
+        });
+        const moved = bot.tasks.filter((_, index) => patches[index]).map((task) => task.threadId);
+        if (!moved.length)
+            return [];
+        const nextTasks = bot.tasks.map((task, index) => patches[index] ? { ...task, ...patches[index] } : task);
+        this.saveBots(this.bots.map((candidate) => candidate === bot ? { ...bot, tasks: nextTasks } : candidate));
+        bot.tasks.forEach((task, index) => { if (patches[index])
+            Object.assign(task, patches[index]); });
+        const active = bot.tasks.find((task) => task.threadId === bot.threadId);
+        if (active)
+            this.mirrorActiveTask(bot, active);
+        this.emit({ type: "bot", botId });
+        return moved;
+    }
     /** One durable write: never leave only part of a bot's threads updated. */
     setAllThreadApprovalMode(botId, mode) {
         const bot = this.bot(botId);
@@ -2656,9 +2740,9 @@ export class Store {
         bot.pinnedMessageId = task.pinnedMessageId;
     }
     /** A fresh context on the same bot: new thread, new session, same
-     * persona/tools/computer. Becomes the active task. It runs on the bot's
-     * default model unless the caller hands it one (a thread opened from
-     * another of this bot's threads keeps that thread's model). */
+     * persona/tools/computer. Becomes the active task. It follows the bot's
+     * model unless the caller hands it another one: a thread opened from
+     * another of this bot's threads keeps the model a person picked there. */
     createTask(botId, title, activate = true, projectId, openedBy, approvalMode, modelSelection) {
         const bot = this.bot(botId);
         if (!bot)
@@ -2674,7 +2758,7 @@ export class Store {
             ...(projectId ? { projectId } : {}),
             ...(openedBy ? { openedBy: structuredClone(openedBy) } : {}),
             resumeCursors: {},
-            modelSelection: structuredClone(modelSelection ?? bot.modelSelection),
+            ...(modelSelection && !sameModelSelection(modelSelection, bot.modelSelection) ? { modelSelection: structuredClone(modelSelection) } : {}),
             approvalMode: approvalMode ?? approvalModeFor(bot),
             autoApprove: approvalMode ? false : Boolean(bot.autoApprove),
             alwaysAllow: approvalMode ? [] : [...(bot.alwaysAllow ?? [])],
@@ -2780,10 +2864,14 @@ export class Store {
         this.emit({ type: "bot", botId });
         return bot;
     }
+    /** A first run: no bot yet, so seedIfEmpty makes one. */
+    needsSeed() {
+        return this.bots.length === 0;
+    }
     /** First-run seed: one bot so the app never opens empty — it gets a
      * random friendly name like every other bot. */
     seedIfEmpty() {
-        if (this.bots.length)
+        if (!this.needsSeed())
             return;
         this.createBot();
     }

package/dist-server/server/system-prompt.js

@@ -123,7 +123,7 @@ export function customMcpPrompt(names) {
 }
 export const CREDENTIAL_PROMPT = " If a supported API key is missing for the service actually needed, use request_credential to create a secure credential request. Before requesting a computer-provider key, inspect the configured targets with select_computer; an existing self-hosted VPS does not need Boat credentials. Do not request a different provider's key merely because a task mentions cloud. A freshly QR-paired mobile app or the desktop app can show the secure entry card. Never claim it opened unless the request succeeded, and never ask the user to paste credentials into chat.";
 export const THREADS_PROMPT = " A thread is one conversation with its own history and its own run; a bot can have several running at once, and the person sees them as rows under that bot. Use start_thread to open one on yourself for separate work, or on a teammate to hand them a job that should run on its own. Use list_threads to see how the ones you opened are going. When you mention a thread to the person, write its title as #Title so it links. Do not use a ticket comment, a note, or a room post as a stand-in for a thread.";
-const PROPOSAL_RESULT_PROMPT = " Follow the tool result: with granted Full Access it may report applied immediately; then continue the requested work without asking for another confirmation. If it reports a pending review, end the turn and wait for the in-app decision. Never claim success before an applied result, and report failures honestly. Full Access does not grant another bot broader permissions.";
+const PROPOSAL_RESULT_PROMPT = " Follow the tool result: a change to your own routines, skills, profile or model applies immediately and the person sees it with an Undo; then continue the requested work without asking for another confirmation. A change for another bot may wait for the person. If it reports a pending review, end the turn and wait for the in-app decision. Never claim success before an applied result, and report failures honestly. Full Access does not grant another bot broader permissions.";
 export const ROUTINE_PROMPT = " If the user explicitly asks to list or review, schedule, run, or change routines, use list_routines and propose_routine or propose_routine_action. Keep run_on omitted or maus to use the bot's current model and configured computer, including its VPS. A routine's box (legacy cloud) destination runs on the bot's cloud computer, not the configured VPS; choose it only when the user explicitly wants the cloud computer. Convert calendar requests such as the first or last day of each month or the second Monday to a five-field cron expression with an explicit IANA timezone; use interval for elapsed every-N-minutes work. Never replace a calendar rule with daily AI date checking or an approximate weekly schedule; clarify ambiguous or unsupported requests." + PROPOSAL_RESULT_PROMPT;
 export const ROUTINE_EXECUTION_PROMPT = " Execute this routine now: use available peer tools for required handoffs rather than merely announcing that you will wait; after an accepted delegation, end this turn for automatic resumption, and report a concrete blocker if no handoff is possible.";
 export const LEARN_PROMPT = " If the user sends /learn or asks you to save a reusable procedure from this work, use skills_list and skill_manage. Create new skills; update an existing learned skill only when the user explicitly asks to revise that exact name. Include source provenance." + PROPOSAL_RESULT_PROMPT;

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

@@ -78,6 +78,9 @@ export function createTeamBackup(store, routines, name) {
                 ? { botId: task.closedBy.botId, name: task.closedBy.name, at: task.closedBy.at }
                 : undefined,
             pinned: task.pinned === true ? true : undefined,
+            turnTimeoutMinutes: "turnTimeoutMinutes" in task && typeof task.turnTimeoutMinutes === "number"
+                ? task.turnTimeoutMinutes
+                : undefined,
             activeLeafId: store.activeLeaf(task.threadId),
             messages: store.messagesFor(task.threadId).map((message) => ({
                 id: message.id, role: message.role, text: messageText(message), at: message.at,
@@ -97,7 +100,10 @@ export function createTeamBackup(store, routines, name) {
                 ? { kind: "mentions" }
                 : group.defaultResponder.kind === "auto" && group.defaultResponder.fallbackBotId && !memberIds.includes(group.defaultResponder.fallbackBotId)
                     ? { kind: "auto" } : group.defaultResponder,
-            activeTask: group.threadId, tasks: history(group),
+            activeTask: group.threadId,
+            tasks: history(group).map((task, index) => group.dm && index === 0 && typeof group.turnTimeoutMinutes === "number"
+                ? { ...task, turnTimeoutMinutes: group.turnTimeoutMinutes }
+                : task),
         };
     });
     const validRoutines = routines.filter((routine) => {
@@ -197,8 +203,9 @@ export function importTeamBackup(store, routines, input, selection, options = {}
             const bot = store.bot(botIds.get(source.key));
             const tasks = source.tasks.map((task, i) => {
                 const record = {
+                    // Each imported thread follows the imported bot's model.
                     threadId: i === 0 ? bot.threadId : newId(), title: task.title, createdAt: task.createdAt, resumeCursors: {},
-                    modelSelection: structuredClone(bot.modelSelection), activity: "idle", busy: false, unread: false,
+                    activity: "idle", busy: false, unread: false,
                     ...(task.titleFromFirstMessage ? { titleFromFirstMessage: true } : {}),
                 };
                 // Same rule as a message's `from`: the opener is remapped to its
@@ -229,9 +236,16 @@ export function importTeamBackup(store, routines, input, selection, options = {}
             groups.push(group);
             groupIds.set(source.key, group.id);
             const responder = source.defaultResponder;
-            store.patchGroup(group.id, { bulletin: source.bulletin, setupCompletedAt: Date.now(), defaultResponder: responder.kind === "member" ? { kind: "member", botId: botIds.get(responder.botId) }
+            store.patchGroup(group.id, {
+                bulletin: source.bulletin,
+                setupCompletedAt: Date.now(),
+                ...(source.dm && source.tasks[0]?.turnTimeoutMinutes != null
+                    ? { turnTimeoutMinutes: source.tasks[0].turnTimeoutMinutes }
+                    : {}),
+                defaultResponder: responder.kind === "member" ? { kind: "member", botId: botIds.get(responder.botId) }
                     : responder.kind === "auto" ? { kind: "auto", ...(responder.fallbackBotId ? { fallbackBotId: botIds.get(responder.fallbackBotId) } : {}) }
-                        : responder });
+                        : responder
+            });
             // Use the existing task APIs for rooms; direct-message rooms have one.
             const threads = source.tasks.map((task, i) => {
                 if (i === 0) {
@@ -248,6 +262,7 @@ export function importTeamBackup(store, routines, input, selection, options = {}
                     updatedAt: task.messages.reduce((max, message) => Math.max(max, message.at), task.createdAt),
                     ...(task.pinned === true ? { pinned: true } : {}),
                     ...(task.titleFromFirstMessage ? { titleFromFirstMessage: true } : {}),
+                    ...(task.turnTimeoutMinutes != null ? { turnTimeoutMinutes: task.turnTimeoutMinutes } : {}),
                 }));
                 store.switchGroupTask(group.id, threads[source.tasks.findIndex((task) => task.key === source.activeTask)]);
             }

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

@@ -0,0 +1,25 @@
+import { readyToRun, signedOut } from "./default-model-selection.js";
+import { sameModelSelection } from "../shared/thread-model.js";
+function canRunOn(engine, selection, context) {
+    return Boolean(engine?.enabled) && engine.snapshot.state === "available" && context.refusal?.(engine) === undefined &&
+        context.allows?.(selection) !== false;
+}
+/** Why this thread's own model gives way to its bot's, or null when the turn
+ * runs on it as picked:
+ * - "unavailable": its engine is gone, disabled, unavailable or not allowed
+ *   (by the organisation, or a hosted workspace's assigned models);
+ * - "signed-out": its engine is signed out and the bot's model is on another
+ *   engine that can run. On the same engine the turn runs as picked, so the
+ *   engine's own sign-in prompt shows; a fallback never hides it. */
+export function threadModelFallback(own, botModel, engine, context = {}) {
+    if (sameModelSelection(own, botModel))
+        return null;
+    const mine = engine(own.instanceId);
+    if (!canRunOn(mine, own, context))
+        return "unavailable";
+    if (!signedOut(mine))
+        return null;
+    // On the same engine the bot's model is signed out too, so it never stands in.
+    const theirs = engine(botModel.instanceId);
+    return canRunOn(theirs, botModel, context) && readyToRun(theirs, context) ? "signed-out" : null;
+}

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

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 /**
  * Automatic continuity: when a turn ends without a final answer and the work
- * is resumable (budget cap or tool errors), persist a structured handoff and
+ * is resumable (a budget cap), persist a structured handoff and
  * let the harness start a `Continue:` thread on the same bot — transparent to
  * the bot, which just sees a normal new thread seeded with the handoff.
  *
@@ -82,23 +82,21 @@ export function writeTurnHandoff(input) {
         return null;
     }
 }
-/** Provider config errors are not resumable: looping on them burns budget and
- * masks the real fix (change the model or the tool set). Everything else that
- * stops a turn without a final answer is a candidate for auto-continuation. */
-const NOT_RESUMABLE = /not a multimodal model|unknown model|does not support|tool arguments do not match/i;
+/** The harness's own budget stops, in its own words: the chat driver's
+ * "Stopped after 64 steps without a final answer…" and the older model-call
+ * cap. Matched from the start of the failure, so a provider's error text can
+ * never read as one: "upstream HTTP 429: Rate limit reached" is not a spent
+ * budget. */
+const CAP_STOP = /^(?:stopped after \d+ [a-z ]+ without a final answer|model-call limit reached)/i;
 /** Classify a terminal turn as resumable. Returns the reason for the
  * continuation (`cap` = budget exhausted), or null when the turn must not be
- * auto-continued. A tool error is never continued: it includes a person's or
- * the approval policy's denial, and a new unattended thread would retry what
- * was refused. */
+ * auto-continued. Only a cap is continued. A provider error (a rate limit, a
+ * quota, a rejected key, a model that cannot take the request) fails the same
+ * way in a new thread: continuing would go straight back to the provider that
+ * just refused. A tool error includes a person's or the approval policy's
+ * denial, and a new unattended thread would retry what was refused. */
 export function classifyContinuable(_stopReason, failure) {
-    if (!failure)
-        return null;
-    if (NOT_RESUMABLE.test(failure))
-        return null;
-    if (/limit reached|stopped after \d+ steps|without a final answer/i.test(failure))
-        return "cap";
-    return null;
+    return failure && CAP_STOP.test(failure) ? "cap" : null;
 }
 const CONTINUE_TITLE = /^Continue: /;
 const MAX_PER_BOT_PER_HOUR = 5;
@@ -131,7 +129,10 @@ export function makeCapContinuationSubscriber(deps) {
             if (CONTINUE_TITLE.test(deadTask.title ?? ""))
                 return;
             const approvalMode = deadTask.approvalMode === "ask" || deadTask.approvalMode === "full" ? deadTask.approvalMode : undefined;
-            const contTask = deps.store.createTask(bot.id, `Continue: ${(deadTask.title ?? "task").slice(0, 90)}`, true, deadTask.projectId, undefined, approvalMode, deadTask.modelSelection);
+            const contTask = deps.store.createTask(
+            // Not activated: the person's open thread stays theirs, and their next
+            // message goes where they were, not into the continuation.
+            bot.id, `Continue: ${(deadTask.title ?? "task").slice(0, 90)}`, false, deadTask.projectId, undefined, approvalMode, deadTask.modelSelection);
             if (!contTask)
                 return;
             rec.count += 1;

package/dist-server/server/webhook-ingress.js

@@ -84,11 +84,16 @@ export function createWebhookIngressHandler(manager, claimRequest) {
         let release;
         try {
             release = claimRequest?.();
-            const pathSecret = match[2] ? decodeURIComponent(match[2]) : "";
-            const secret = pathSecret || bearerSecret(req);
+            let secret = "";
+            try {
+                secret = (match[2] ? decodeURIComponent(match[2]) : "") || bearerSecret(req);
+            }
+            catch {
+                // A malformed escape is not a secret this server issued.
+            }
             // Reject bad capability URLs before buffering or parsing attacker input.
             if (!manager.authorize(match[1], secret)) {
-                manager.recordRejected(match[1], 401, "Invalid webhook URL or secret", {
+                manager.recordUnauthorized(match[1], {
                     contentType: header(req, "content-type"),
                     eventName: eventName(req),
                     deliveryId: deliveryId(req),