openmausbot 0.1.97 → 0.1.98

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/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

@@ -96,7 +96,10 @@ export function classifyContinuable(_stopReason, failure) {
         return null;
     if (NOT_RESUMABLE.test(failure))
         return null;
-    if (/limit reached|stopped after \d+ steps|without a final answer/i.test(failure))
+    // Only OpenMausBot's own step cap. A provider's "Rate limit reached" or
+    // "usage limit reached" is not a budget a new thread can continue past:
+    // continuing would go straight back to the provider that said slow down.
+    if (/stopped after \d+ steps without a final answer|model-call limit reached/i.test(failure))
         return "cap";
     return null;
 }
@@ -131,7 +134,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),

package/dist-server/server/webhooks.js

@@ -10,6 +10,7 @@ const MAX_ATTEMPTS = 2_000;
 const MAX_EVENT_CHARS = 48_000;
 const RATE_WINDOW_MS = 60_000;
 const RATE_LIMIT = 10;
+const UNAUTHORIZED_REASON = "Invalid webhook URL or secret";
 /** Unfinished (queued, running or waiting) runs one webhook may hold before
  * new deliveries are refused with 429. A webhook can set its own limit; one
  * fanning out a project manager's events needs more than a CI hook does. */
@@ -223,6 +224,8 @@ export class WebhookManager {
     deliveries = [];
     attempts = [];
     rate = new Map();
+    /** Bad-secret requests folded into each webhook's rolling record. */
+    unauthorized = new Map();
     constructor(options) {
         this.options = options;
         this.file = options.file ?? join(DATA_DIR, "webhooks.json");
@@ -305,6 +308,7 @@ export class WebhookManager {
         this.deliveries = this.deliveries.filter((delivery) => !delivery.key.startsWith(`${trigger.endpointId}:`));
         this.attempts = this.attempts.filter((attempt) => attempt.webhookId !== trigger.id);
         this.rate.delete(trigger.endpointId);
+        this.unauthorized.delete(trigger.id);
         this.options.cancelQueued?.(trigger.id, "The webhook was deleted before this delivery started");
         this.save();
         this.options.emit?.({ kind: "webhook.deleted", webhookId: id });
@@ -374,6 +378,33 @@ export class WebhookManager {
             return null;
         return this.recordRejectedForTrigger(trigger, statusCode, reason, event);
     }
+    /** A request with a wrong secret can come from anyone who reaches the
+     * receiver, before any rate limit applies. Each webhook keeps one rolling
+     * record of them, updated in place and saved with the next real change, so
+     * a flood neither pushes real deliveries out of the shared history nor
+     * rewrites the file on every request. */
+    recordUnauthorized(endpointId, event = {}) {
+        const trigger = this.webhooks.find((candidate) => candidate.endpointId === endpointId);
+        if (!trigger)
+            return null;
+        const at = this.attempts.findLastIndex((attempt) => attempt.webhookId === trigger.id && attempt.outcome === "rejected" && attempt.statusCode === 401);
+        if (at === -1) {
+            this.unauthorized.set(trigger.id, 1);
+            return this.appendAttempt(trigger, event, { outcome: "rejected", statusCode: 401, reason: UNAUTHORIZED_REASON, deliveryId: event.deliveryId });
+        }
+        const count = (this.unauthorized.get(trigger.id) ?? 1) + 1;
+        this.unauthorized.set(trigger.id, count);
+        // Same id: clients replace the record they hold instead of adding one.
+        const attempt = this.buildAttempt(trigger, event, {
+            outcome: "rejected",
+            statusCode: 401,
+            reason: `${UNAUTHORIZED_REASON} (${count} requests)`,
+            deliveryId: event.deliveryId,
+        }, this.attempts[at].id);
+        this.attempts[at] = attempt;
+        this.options.emit?.({ kind: "webhook.attempt", attempt: { ...attempt } });
+        return attempt;
+    }
     dispatch(trigger, event) {
         if (!trigger.enabled)
             fail(409, "This webhook is paused");
@@ -524,8 +555,16 @@ export class WebhookManager {
         return attempt;
     }
     appendAttempt(trigger, event, details) {
+        const attempt = this.buildAttempt(trigger, event, details);
+        this.attempts.push(attempt);
+        if (this.attempts.length > MAX_ATTEMPTS)
+            this.attempts.splice(0, this.attempts.length - MAX_ATTEMPTS);
+        this.options.emit?.({ kind: "webhook.attempt", attempt: { ...attempt } });
+        return attempt;
+    }
+    buildAttempt(trigger, event, details, id = randomUUID()) {
         const attempt = {
-            id: randomUUID(),
+            id,
             webhookId: trigger.id,
             receivedAt: this.now(),
             outcome: details.outcome,
@@ -541,10 +580,6 @@ export class WebhookManager {
             attempt.runId = details.runId;
         if (details.reason)
             attempt.reason = details.reason;
-        this.attempts.push(attempt);
-        if (this.attempts.length > MAX_ATTEMPTS)
-            this.attempts.splice(0, this.attempts.length - MAX_ATTEMPTS);
-        this.options.emit?.({ kind: "webhook.attempt", attempt: { ...attempt } });
         return attempt;
     }
     emit(trigger) {