openmausbot 0.1.85 → 0.1.87

package/dist-server/server/store.js

@@ -3,7 +3,7 @@
 // ProviderSessionDirectory, recipe step 6: persist the binding from day
 // one). messages-<threadId>.json holds the folded transcript.
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync, mkdirSync, rmSync, unlinkSync } from "node:fs";
+import { chmodSync, existsSync, readFileSync, mkdirSync, rmSync, statSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { writeFileAtomic } from "./atomic.js";
 import { ensureSections, readSections, changeEmptySection } from "./section-context.js";
@@ -18,6 +18,8 @@ import { pickBotName } from "./names.js";
 import { redactSecretsInText } from "./redact.js";
 import { botAvatarProfile } from "../shared/bot-avatar.js";
 import { approvalModeFor, isApprovalMode } from "../shared/approval-mode.js";
+import { isMentionBoundary, isMentionNameContinuation } from "../shared/mention-boundary.js";
+import { CONNECTOR_SLUG_PATTERN, CONNECTOR_TOOL_NAME_PATTERN } from "../shared/wire.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
@@ -30,14 +32,23 @@ 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, ...wire } = task;
+    const { resumeCursors: _resumeCursors, lastInstanceId: _lastInstanceId, handedMessages: _handedMessages, appliedCompactionId: _appliedCompactionId, contextFloor: _contextFloor, lastContextModel: _lastContextModel, surfaceSource: _surfaceSource, ...wire } = task;
     return wire;
 }
 const TASK_PATCH_FIELDS = [
     "title", "projectId", "modelSelection", "approvalMode", "autoApprove", "alwaysAllow",
-    "unread", "rewound", "archivedAt", "pinnedMessageId", "resumeCursors", "lastInstanceId", "cwd",
-    "routineRunId", "surface", "appliedCompactionId", "contextFloor", "lastContextModel",
+    "unread", "rewound", "archivedAt", "pinned", "pinnedMessageId", "resumeCursors", "lastInstanceId", "cwd",
+    "routineRunId", "surface", "surfaceSource", "snoozedUntil", "appliedCompactionId", "contextFloor", "lastContextModel",
 ];
+/** Only `true` is a pin. false/undefined must not land in bots.json or groups.json. */
+function persistedPin(task) {
+    if (task.pinned === true)
+        return task;
+    if (!("pinned" in task))
+        return task;
+    const { pinned: _pinned, ...rest } = task;
+    return rest;
+}
 /** Everything the BOT authored is scrubbed of content-shaped secrets before
  * it is stored: its reply text, a tool title (an ACP engine's title can be
  * the whole command line) and the command beside it, a permission card's
@@ -86,6 +97,9 @@ function redactBotAuthored(message) {
             card.held = redactSecretsInText(card.held);
         if (typeof card.answeredText === "string")
             card.answeredText = redactSecretsInText(card.answeredText);
+        if (card.commandAllowlist && (redactSecretsInText(card.commandAllowlist.command) !== card.commandAllowlist.command ||
+            redactSecretsInText(card.commandAllowlist.cwd) !== card.commandAllowlist.cwd))
+            delete card.commandAllowlist;
         // Bot-authored question text sits behind the subtitle the same way a
         // routine's instructions do, so it is scrubbed on the same boundary.
         if (card.questionRequest) {
@@ -252,8 +266,76 @@ export function titleFromLlm(raw) {
     return line.length >= 1 && line.length <= 48 ? line : null;
 }
 export const botWireProjectionIsExact = true;
+/** Upper bounds keep a grants patch from becoming a persistence blob; they
+ * sit far above any real service's tool count. */
+export const CONNECTOR_SLUGS_MAX = 64;
+export const CONNECTOR_TOOLS_PER_SERVICE_MAX = 500;
+/** Validate and normalize a connectorTools value at the one boundary every
+ * writer shares (patchBot). Returns a canonical copy: slugs checked against
+ * the service pattern, tool lists deduplicated in order, `"*"` kept as-is.
+ * The legacy clear stays a JSON null at the API edge; here callers pass
+ * undefined to return a bot to boolean-only behavior. */
+export function parseConnectorTools(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return { ok: false, error: "connectorTools must be an object of service slugs to tool grants" };
+    }
+    const entries = Object.entries(value);
+    if (entries.length > CONNECTOR_SLUGS_MAX) {
+        return { ok: false, error: `connectorTools may name at most ${CONNECTOR_SLUGS_MAX} services` };
+    }
+    const grants = {};
+    for (const [slug, grant] of entries) {
+        if (!CONNECTOR_SLUG_PATTERN.test(slug)) {
+            return { ok: false, error: `connectorTools service slugs must be lowercase slugs (got "${slug}")` };
+        }
+        if (!grant || typeof grant !== "object" || Array.isArray(grant)) {
+            return { ok: false, error: `connectorTools.${slug} must be a grant like { tools: "*" } or { tools: ["TOOL_NAME"] }` };
+        }
+        const keys = Object.keys(grant);
+        if (keys.length !== 1 || keys[0] !== "tools") {
+            return { ok: false, error: `connectorTools.${slug} accepts only a tools field` };
+        }
+        const tools = grant.tools;
+        if (tools === "*") {
+            grants[slug] = { tools: "*" };
+            continue;
+        }
+        if (!Array.isArray(tools) || tools.length === 0) {
+            return { ok: false, error: `connectorTools.${slug}.tools must be "*" or a non-empty list of tool names (use {} to grant no tools)` };
+        }
+        if (tools.length > CONNECTOR_TOOLS_PER_SERVICE_MAX) {
+            return { ok: false, error: `connectorTools.${slug}.tools may list at most ${CONNECTOR_TOOLS_PER_SERVICE_MAX} tools` };
+        }
+        const names = [];
+        for (const tool of tools) {
+            if (typeof tool !== "string" || !CONNECTOR_TOOL_NAME_PATTERN.test(tool)) {
+                return { ok: false, error: `connectorTools.${slug}.tools names must be Composio tool names like GMAIL_SEND_EMAIL` };
+            }
+            if (!names.includes(tool))
+                names.push(tool);
+        }
+        grants[slug] = { tools: names };
+    }
+    return { ok: true, grants };
+}
 const BOTS_FILE = join(DATA_DIR, "bots.json");
 const GROUPS_FILE = join(DATA_DIR, "groups.json");
+/** 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
+ * tighten must never stop the fleet from loading, and the next save replaces
+ * the file with a 0600 one anyway. Windows has no POSIX mode bits. */
+function tightenRegistryFile(file) {
+    if (process.platform === "win32")
+        return;
+    try {
+        if ((statSync(file).mode & 0o077) !== 0)
+            chmodSync(file, 0o600);
+    }
+    catch {
+        /* absent, or not ours to change */
+    }
+}
 const messagesFile = (threadId) => join(DATA_DIR, `messages-${threadId}.json`);
 const COLORS = [
     "green",
@@ -283,15 +365,15 @@ export function mentionedBots(text, peers) {
     const found = [];
     let at = -1;
     while ((at = lower.indexOf("@", at + 1)) !== -1) {
-        if (at > 0 && !/\s/.test(text[at - 1]))
+        if (!isMentionBoundary(text, at))
             continue; // user@host, not a tag
         const rest = lower.slice(at + 1);
         const hit = candidates.find((p) => {
             const name = p.name.toLowerCase();
             if (!rest.startsWith(name))
                 return false;
-            const after = rest[name.length]; // must not run into a longer word
-            return after === undefined || !/[a-z0-9]/i.test(after);
+            const after = rest.slice(name.length); // must not run into a longer word
+            return !isMentionNameContinuation(after);
         });
         if (hit && !found.includes(hit))
             found.push(hit);
@@ -324,8 +406,15 @@ export function normalizeGroupDefaultResponder(value, memberIds, dm = false) {
  * otherwise the room policy chooses one member, everyone, or nobody. */
 export function roomResponders(text, members, defaultResponder) {
     const available = members.filter((member) => !member.hidden);
-    if (/(?:^|\s)@everyone\b/i.test(text))
-        return available;
+    const everyone = "everyone";
+    for (let at = text.indexOf("@"); at !== -1; at = text.indexOf("@", at + 1)) {
+        const candidate = text.slice(at + 1, at + 1 + everyone.length);
+        if (isMentionBoundary(text, at) &&
+            candidate.toLocaleLowerCase() === everyone &&
+            !isMentionNameContinuation(text.slice(at + 1 + everyone.length))) {
+            return available;
+        }
+    }
     const mentioned = mentionedBots(text, available);
     if (mentioned.length)
         return mentioned;
@@ -342,15 +431,22 @@ export class Store {
     groups = [];
     threads = new Map();
     defaultSelection;
+    completeNewBotSelection;
     listeners = new Set();
     /** A broken team registry must not prevent loading independent chat data. */
     registeringInitialSections = true;
     /** Room turns and old callers have their own activity slot. Clearing
      * that slot must not clear a concurrently running independent task. */
     legacyActivities = new Map();
-    constructor(defaultSelection) {
+    constructor(defaultSelection, 
+    /** Workspace-wide new-bot defaults (config newBots), applied to every
+     * new bot's selection whichever path created it. */
+    completeNewBotSelection = (selection) => selection) {
         this.defaultSelection = defaultSelection;
+        this.completeNewBotSelection = completeNewBotSelection;
         mkdirSync(DATA_DIR, { recursive: true });
+        for (const file of [BOTS_FILE, GROUPS_FILE])
+            tightenRegistryFile(file);
         try {
             this.bots = JSON.parse(readFileSync(BOTS_FILE, "utf8"));
         }
@@ -517,6 +613,7 @@ export class Store {
                     threadId: g.threadId,
                     title: this.firstUserLine(g.threadId) ?? UNTITLED_TASK,
                     createdAt: g.createdAt,
+                    updatedAt: g.createdAt,
                 };
                 if (g.pinnedCwd !== undefined)
                     initialTask.pinnedCwd = g.pinnedCwd;
@@ -552,6 +649,7 @@ export class Store {
                         threadId: b.threadId,
                         title: this.firstUserLine(b.threadId) ?? UNTITLED_TASK,
                         createdAt: b.createdAt,
+                        updatedAt: b.createdAt,
                         resumeCursors: b.resumeCursors ?? {},
                     }];
                 botsMigrated = true;
@@ -564,6 +662,7 @@ export class Store {
                     threadId: b.threadId,
                     title: this.firstUserLine(b.threadId) ?? UNTITLED_TASK,
                     createdAt: b.createdAt,
+                    updatedAt: b.createdAt,
                     resumeCursors: b.resumeCursors ?? {},
                 };
                 b.tasks.unshift(active);
@@ -619,18 +718,126 @@ export class Store {
             if (existsSync(legacyFile))
                 mdb.readThread(threadId, legacyFile);
         }
+        // After legacy transcripts are in SQLite, so the first boot sees their
+        // newest message instead of stamping createdAt and jumping next launch.
+        this.repairThreadUpdatedAts();
+        // After the roster is loaded, so identity resolution sees which opener
+        // ids are still live.
+        this.repairDuplicatePairConversations();
         this.registeringInitialSections = false;
     }
-    saveBots(bots = this.bots) {
-        this.rememberSections([...this.bots, ...bots].map((bot) => bot.section));
+    /** Advance a task's update stamp in memory only. Message writes must not
+     * rewrite bots.json; the next snapshot and the startup repair read this. */
+    noteThreadActivity(threadId, at) {
+        if (!Number.isFinite(at))
+            return;
+        const advance = (current) => Math.max(current ?? 0, at);
+        for (const bot of this.bots) {
+            const task = bot.tasks?.find((candidate) => candidate.threadId === threadId);
+            if (!task)
+                continue;
+            const next = advance(task.updatedAt);
+            if (task.updatedAt !== next)
+                task.updatedAt = next;
+        }
+        for (const group of this.groups) {
+            const task = group.tasks?.find((candidate) => candidate.threadId === threadId);
+            if (!task)
+                continue;
+            const next = advance(task.updatedAt);
+            if (task.updatedAt !== next)
+                task.updatedAt = next;
+        }
+    }
+    /** Fill missing stamps, and raise a stamp that is older than the newest
+     * stored message. Never moves a stamp backwards: there is no per-message
+     * delete, and a clock skew must not reshuffle the list on every boot. */
+    repairThreadUpdatedAts() {
+        const botTasks = this.bots.flatMap((bot) => bot.tasks ?? []);
+        const groupTasks = this.groups.flatMap((group) => group.tasks ?? []);
+        const latest = mdb.latestMessageAts([...botTasks, ...groupTasks].map((task) => task.threadId));
+        let botsDirty = false;
+        let groupsDirty = false;
+        const repair = (task) => {
+            const fromMessages = latest.get(task.threadId);
+            const next = fromMessages !== undefined && (task.updatedAt === undefined || fromMessages > task.updatedAt)
+                ? fromMessages
+                : task.updatedAt ?? task.createdAt;
+            if (task.updatedAt === next)
+                return false;
+            task.updatedAt = next;
+            return true;
+        };
+        for (const task of botTasks)
+            if (repair(task))
+                botsDirty = true;
+        for (const task of groupTasks)
+            if (repair(task))
+                groupsDirty = true;
+        if (botsDirty)
+            this.saveBots();
+        if (groupsDirty)
+            this.saveGroups();
+    }
+    /** At most one live pair row per (recipient, sender identity). Servers
+     * before identity-stable matching minted a second live pair row for a
+     * deleted-and-recreated sender while the predecessor's row dangled live
+     * forever; collapse those on load by keeping the row the resolver favors
+     * (first in the task list — the newest, actively used one) and demoting
+     * the rest to closed plain threads. History is kept, never deleted, and
+     * a demoted row is never re-adopted: adoption skips closed rows. Runs on
+     * every load and touches nothing in a store that already holds the
+     * invariant. */
+    repairDuplicatePairConversations() {
+        let botsDirty = false;
+        const sweep = (tasks, repaired) => {
+            const pairs = new Map();
+            for (const task of tasks ?? []) {
+                const by = task.openedBy;
+                if (by?.kind !== "pair" || task.closedBy)
+                    continue;
+                const identity = this.openerIdentity(by);
+                pairs.set(identity, [...(pairs.get(identity) ?? []), task]);
+            }
+            for (const rows of pairs.values()) {
+                // rows are in task-list order, the same order the resolver's
+                // find() favors: the first is the one it keeps using.
+                for (const duplicate of rows.slice(1)) {
+                    const by = duplicate.openedBy;
+                    const identity = this.openerIdentity(by);
+                    const { kind: _kind, ...opened } = by;
+                    duplicate.openedBy = opened;
+                    duplicate.closedBy = {
+                        botId: identity,
+                        name: this.bot(identity)?.name ?? by.name,
+                        at: Date.now(),
+                    };
+                    repaired();
+                }
+            }
+        };
+        // Pair rows only ever live on bots: the resolver requires a bot
+        // recipient, and group tasks carry no peer stamps.
+        for (const bot of this.bots)
+            sweep(bot.tasks, () => { botsDirty = true; });
+        if (botsDirty)
+            this.saveBots();
+    }
+    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 }) => ({
             ...bot,
-            tasks: bot.tasks?.map(({ busy: _taskBusy, activity: _taskActivity, turnStartedAt: _taskTurnStarted, ...task }) => task),
-        })), null, 2));
+            tasks: bot.tasks?.map(({ busy: _taskBusy, activity: _taskActivity, turnStartedAt: _taskTurnStarted, ...task }) => persistedPin(task)),
+        })), null, 2), { mode: 0o600 });
     }
-    saveGroups() {
-        this.rememberSections(this.groups.map((group) => group.section));
-        writeFileAtomic(GROUPS_FILE, JSON.stringify(this.groups.map(({ busyBotId: _busyBotId, turnStartedAt: _turnStartedAt, ...g }) => g), null, 2));
+    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 }) => ({
+            ...g,
+            ...(g.tasks ? { tasks: g.tasks.map((task) => persistedPin(task)) } : {}),
+        })), null, 2), { mode: 0o600 });
     }
     get sections() { return readSections(); }
     rememberSections(names) {
@@ -644,6 +851,60 @@ export class Store {
             console.warn(`[teams] Startup could not register team names; saved teams and shared instructions were left unchanged: ${error.message}`);
         }
     }
+    /** Rename the same team, preserving its members and existing access grants. */
+    renameSection(name, nextName, computers) {
+        if (!name || !this.sections.includes(name))
+            return "No such team";
+        nextName = nextName.trim();
+        if (!nextName || nextName.length > 60 || [...nextName].some(char => char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127))
+            return "Team name must be 1 to 60 characters without control characters";
+        if (name === nextName)
+            return undefined;
+        if (this.sections.includes(nextName) || computers?.forSection(nextName))
+            return "A team with that name already exists";
+        const members = this.bots.filter(bot => sectionKey(bot.section) === name);
+        const rooms = this.groups.filter(group => sectionKey(group.section) === name);
+        const affected = this.bots.filter(bot => members.includes(bot) || bot.managedSections?.some(section => sectionKey(section) === name));
+        if (affected.some(bot => bot.busy || bot.tasks?.some(task => task.busy)) || rooms.some(group => group.busyBotId)) {
+            return "Stop this team's active work before renaming the team";
+        }
+        // Keep the established empty-team lifecycle: old grants are revoked when
+        // an empty identity is removed, so recreating it cannot restore access.
+        if (!members.length && !rooms.length && !computers?.forSection(name))
+            return this.changeEmptySection(name, nextName);
+        const nextBots = this.bots.map(bot => ({ ...bot,
+            ...(members.includes(bot) ? { section: nextName } : {}),
+            ...(bot.managedSections ? { managedSections: [...new Set(bot.managedSections.map(section => sectionKey(section) === name ? nextName : section))] } : {}),
+        }));
+        const nextGroups = this.groups.map(group => rooms.includes(group) ? { ...group, section: nextName } : group);
+        let computerChanged = false;
+        try {
+            // Register the new name only after saving the records; otherwise the
+            // registry's duplicate-name check would reject this same rename.
+            this.saveBots(nextBots, false);
+            this.saveGroups(nextGroups, false);
+            computerChanged = computers?.renameSection(name, nextName) ?? false;
+            changeEmptySection(name, nextName);
+        }
+        catch (error) {
+            this.saveBots(this.bots, false);
+            this.saveGroups(this.groups, false);
+            if (computerChanged)
+                computers.renameSection(nextName, name);
+            throw error;
+        }
+        // Preserve identities held by the schedulers and other store consumers.
+        for (let i = 0; i < nextBots.length; i++)
+            Object.assign(this.bots[i], nextBots[i]);
+        for (let i = 0; i < nextGroups.length; i++)
+            Object.assign(this.groups[i], nextGroups[i]);
+        for (const bot of affected)
+            this.emit({ type: "bot", botId: bot.id });
+        for (const room of rooms)
+            this.emit({ type: "group", groupId: room.id });
+        this.emit({ type: "sections" });
+        return undefined;
+    }
     /** Empty-only changes cannot merge teams or silently change anybody's access. */
     changeEmptySection(name, nextName) {
         if (!this.sections.includes(name))
@@ -672,6 +933,44 @@ export class Store {
         this.emit({ type: "sections" });
         return undefined;
     }
+    /** Remove the team, keeping its bots, rooms and conversations in General. */
+    deleteSection(name) {
+        if (!name || !this.sections.includes(name))
+            return "No such team";
+        const members = this.bots.filter(bot => sectionKey(bot.section) === name);
+        const rooms = this.groups.filter(group => sectionKey(group.section) === name);
+        if (members.some(bot => bot.busy || bot.tasks?.some(task => task.busy)) || rooms.some(group => group.busyBotId)) {
+            return "Stop this team's active work before deleting the team";
+        }
+        if (this.bots.filter(bot => bot.chiefOfStaff && (!sectionKey(bot.section) || sectionKey(bot.section) === name)).length > 1) {
+            return "General already has a Chief of Staff. Move or change this team's Chief before deleting the team";
+        }
+        const nextBots = this.bots.map(bot => ({ ...bot,
+            ...(sectionKey(bot.section) === name ? { section: undefined } : {}),
+            ...(bot.managedSections ? { managedSections: bot.managedSections.filter(section => sectionKey(section) !== name) } : {}),
+        }));
+        const nextGroups = this.groups.map(group => sectionKey(group.section) === name ? { ...group, section: undefined } : group);
+        try {
+            this.saveBots(nextBots);
+            this.saveGroups(nextGroups);
+            changeEmptySection(name, null);
+        }
+        catch (error) {
+            this.saveBots();
+            this.saveGroups();
+            throw error;
+        }
+        for (let i = 0; i < nextBots.length; i++)
+            Object.assign(this.bots[i], nextBots[i]);
+        for (let i = 0; i < nextGroups.length; i++)
+            Object.assign(this.groups[i], nextGroups[i]);
+        for (const bot of this.bots)
+            this.emit({ type: "bot", botId: bot.id });
+        for (const group of rooms)
+            this.emit({ type: "group", groupId: group.id });
+        this.emit({ type: "sections" });
+        return undefined;
+    }
     // ── groups ────────────────────────────────────────────────────────────
     /** Subscribe to every write. Listeners run after the write and after
      * save; a throwing listener never breaks the write. */
@@ -715,7 +1014,7 @@ export class Store {
             section,
         };
         if (!dm) {
-            group.tasks = [{ threadId, title: UNTITLED_TASK, createdAt }];
+            group.tasks = [{ threadId, title: UNTITLED_TASK, createdAt, updatedAt: createdAt }];
             group.setupCompletedAt = setup?.completed ? createdAt : null;
             group.setupSkippedAt = null;
         }
@@ -847,10 +1146,12 @@ export class Store {
         const group = this.group(groupId);
         if (!group || group.dm)
             return null;
+        const createdAt = Date.now();
         const task = {
             threadId: newId(),
             title: title?.trim().slice(0, 80) || UNTITLED_TASK,
-            createdAt: Date.now(),
+            createdAt,
+            updatedAt: createdAt,
         };
         group.tasks = [task, ...(group.tasks ?? [])];
         if (activate) {
@@ -874,6 +1175,18 @@ export class Store {
         this.emit({ type: "group", groupId });
         return group;
     }
+    setGroupTaskPinned(groupId, threadId, pinned) {
+        const task = this.groupTaskByThread(groupId, threadId);
+        if (!task)
+            return null;
+        if (pinned)
+            task.pinned = true;
+        else
+            delete task.pinned;
+        this.saveGroups();
+        this.emit({ type: "group", groupId });
+        return task;
+    }
     renameGroupTask(groupId, threadId, title) {
         const task = this.groupTaskByThread(groupId, threadId);
         if (!task)
@@ -1003,6 +1316,9 @@ export class Store {
             throw new Error("Cannot import over an existing conversation");
         mdb.importThread(threadId, messages, activeLeafId);
         this.threads.delete(threadId);
+        const newest = messages.reduce((max, message) => Math.max(max, message.at), Number.NEGATIVE_INFINITY);
+        if (Number.isFinite(newest))
+            this.noteThreadActivity(threadId, newest);
     }
     activeLeaf(threadId) {
         return this.thread(threadId).activeLeafId;
@@ -1051,6 +1367,7 @@ export class Store {
                 this.emit({ type: "message.patch", threadId, message: pruned });
             }
         }
+        this.noteThreadActivity(threadId, full.at);
         this.emit({ type: "message", threadId, message: full });
         // The first-run quiz is not a live ask. Talking past it hides it so the
         // transcript is just the greeting plus what they said. Cards with a
@@ -1081,6 +1398,7 @@ export class Store {
                 this.emit({ type: "message.patch", threadId, message: pruned });
             }
         }
+        this.noteThreadActivity(threadId, full.at);
         this.emit({ type: "message", threadId, message: full });
         // announced after the insert so no client ever sees two siblings
         // claiming the same parent
@@ -1118,8 +1436,10 @@ export class Store {
         return pruned;
     }
     /** Fork the conversation: a new user message that replaces `sourceId`
-     * (same parent, new text) and becomes the active leaf. */
-    branchMessage(threadId, sourceId, text) {
+     * (same parent, new text) and becomes the active leaf. `sendId` is the
+     * client's identity for this edit, so its instant bubble reconciles onto
+     * the canonical message and a network retry cannot fork twice. */
+    branchMessage(threadId, sourceId, text, sendId) {
         const t = this.thread(threadId);
         const source = t.messages.find((m) => m.id === sourceId);
         if (!source)
@@ -1132,10 +1452,12 @@ export class Store {
             text,
             parentId: source.parentId ?? null,
             replyToId: source.replyToId,
+            ...(sendId ? { sendId } : {}),
         };
         t.messages.push(full);
         t.activeLeafId = full.id;
         mdb.appendMessage(threadId, full);
+        this.noteThreadActivity(threadId, full.at);
         this.emit({ type: "message", threadId, message: full });
         // The message frame alone leaves every client on the OLD branch: a
         // client adopts a new message as its leaf only when it chains onto the
@@ -1188,6 +1510,11 @@ export class Store {
     botByThread(threadId) {
         return this.bots.find((b) => b.threadId === threadId || b.tasks?.some((t) => t.threadId === threadId)) ?? null;
     }
+    /** The one place a new bot's selection is decided: the caller's choice, or
+     * the workspace default, completed with the workspace's new-bot defaults. */
+    newBotSelection(requested) {
+        return this.completeNewBotSelection(requested ?? this.defaultSelection());
+    }
     createBot(profile = {}, opts = {}) {
         this.rememberSections([profile.section]);
         const name = profile.name?.trim() || pickBotName(this.bots.map((b) => b.name));
@@ -1204,8 +1531,10 @@ export class Store {
             color: profile.color ?? COLORS[this.bots.length % COLORS.length],
             ...(profile.mascotExpression ? { mascotExpression: profile.mascotExpression } : {}),
             ...(profile.mascotBody ? { mascotBody: profile.mascotBody } : {}),
+            // Restricted from its first frame: no one else is ever told it exists.
+            ...(profile.visibility && profile.visibility !== "everyone" ? { visibility: structuredClone(profile.visibility) } : {}),
             unread: false,
-            modelSelection: profile.modelSelection ?? this.defaultSelection(),
+            modelSelection: this.newBotSelection(profile.modelSelection),
             resumeCursors: {},
             createdAt: Date.now(),
         };
@@ -1215,6 +1544,7 @@ export class Store {
                 threadId: bot.threadId,
                 title: UNTITLED_THREAD,
                 createdAt: bot.createdAt,
+                updatedAt: bot.createdAt,
                 resumeCursors: {},
                 modelSelection: structuredClone(bot.modelSelection),
                 unread: false,
@@ -1266,12 +1596,16 @@ export class Store {
                 if (at >= 0 || !operation.threadId || !operation.fields.name || !operation.fields.modelSelection)
                     throw new Error("Invalid new bot in team setup");
                 const createdAt = Date.now();
+                const modelSelection = this.newBotSelection(operation.fields.modelSelection);
                 next = { id: operation.botId, threadId: operation.threadId, name: operation.fields.name,
                     title: "", description: "", soul: "", notifications: true, color: COLORS[nextBots.length % COLORS.length], unread: false,
-                    modelSelection: operation.fields.modelSelection, resumeCursors: {}, createdAt, ...operation.fields,
+                    resumeCursors: {}, createdAt, ...operation.fields, modelSelection,
                     approvalMode: "ask", autoApprove: false, composio: false, approvePeerComms: false,
-                    tasks: [{ threadId: operation.threadId, title: UNTITLED_THREAD, createdAt, resumeCursors: {},
-                            modelSelection: structuredClone(operation.fields.modelSelection), approvalMode: "ask", autoApprove: false,
+                    // A Chief's new teammate is seen by exactly the Chief's audience:
+                    // 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,
                             unread: false, activity: "idle", busy: false }],
                 };
                 nextBots.unshift(next);
@@ -1291,6 +1625,8 @@ export class Store {
                     }));
                 nextBots[at] = next;
             }
+            if (operation.fields.chiefOfStaff === false)
+                delete next.managedSections;
             next.section = sectionKey(next.section) || undefined;
             if (operation.fields.soul !== undefined) {
                 next.soulHash = soulHash(operation.fields.soul);
@@ -1299,14 +1635,14 @@ export class Store {
             changed.push(next);
         }
         const result = { state: "applied", newTeams: request.newTeams, bots: changed.map((bot, index) => ({
-                id: bot.id, name: bot.name, section: bot.section, modelSelection: structuredClone(bot.modelSelection),
+                id: bot.id, name: bot.name, section: bot.section, modelSelection: structuredClone(bot.modelSelection), chiefOfStaff: Boolean(bot.chiefOfStaff),
                 action: request.operations[index].action === "create" ? "created" : "updated",
             })) };
         const chiefAt = nextBots.findIndex((bot) => bot.id === chief.id);
         const nextChief = { ...nextBots[chiefAt], lastTeamSetupReceipt: { requestId: request.requestId, result } };
         // Only the newly-created teams explicitly named in the human review may
         // extend this Chief's reach. Existing teams require owner settings.
-        if (request.newTeams.length) {
+        if (request.newTeams.length && nextChief.chiefOfStaff) {
             nextChief.managedSections = managedSections;
         }
         nextBots[chiefAt] = nextChief;
@@ -1371,6 +1707,16 @@ export class Store {
         const bot = this.bot(id);
         if (!bot)
             return null;
+        // Grants are the one field whose shape every writer must share, so the
+        // store normalizes them itself: API patches arrive pre-validated, import
+        // paths pass {}, and an internal caller that skips the parser still
+        // lands canonical data or stops here.
+        if (patch.connectorTools !== undefined) {
+            const parsed = parseConnectorTools(patch.connectorTools);
+            if (!parsed.ok)
+                throw new Error(parsed.error);
+            patch = { ...patch, connectorTools: parsed.grants };
+        }
         // Runtime revocations must become effective in memory even when disk is
         // unavailable. Profile edits use the separate atomic path below.
         Object.assign(bot, patch);
@@ -1481,6 +1827,39 @@ export class Store {
         this.rememberSections([targetSection]);
         return { ok: true, bots: ids.map((id) => this.bot(id)) };
     }
+    /** Apply only the membership edits the user made, in one bots-file write. */
+    updateTeamMembers(section, addIds, removeIds) {
+        const key = sectionKey(section);
+        if (!key || !this.sections.includes(key))
+            return { ok: false, reason: "unavailable" };
+        const adds = new Set(addIds), removes = new Set(removeIds);
+        const ids = new Set([...adds, ...removes]);
+        for (const id of ids) {
+            const bot = this.bot(id);
+            if (!bot || bot.hidden)
+                return { ok: false, reason: "unavailable" };
+            if (adds.has(id) && removes.has(id))
+                return { ok: false, reason: "membership-changed" };
+            if (removes.has(id) && sectionKey(bot.section) !== key)
+                return { ok: false, reason: "membership-changed" };
+        }
+        const next = this.bots.map(bot => ids.has(bot.id)
+            ? { ...bot, section: adds.has(bot.id) ? key : undefined } : bot);
+        for (const destination of [key, ""]) {
+            if (next.filter(bot => bot.chiefOfStaff && sectionKey(bot.section) === destination).length > 1) {
+                return { ok: false, reason: "chief-conflict" };
+            }
+        }
+        if (ids.size) {
+            this.saveBots(next);
+            for (let i = 0; i < next.length; i++)
+                if (ids.has(next[i].id))
+                    Object.assign(this.bots[i], next[i]);
+            for (const botId of ids)
+                this.emit({ type: "bot", botId });
+        }
+        return { ok: true, bots: this.bots.filter(bot => ids.has(bot.id)) };
+    }
     /** Legacy bot/room activity occupies its own slot; direct conversations
      * use setTaskActivity so settling one thread cannot clear another. */
     setActivity(botId, activity) {
@@ -1509,6 +1888,13 @@ export class Store {
             task.turnStartedAt = Date.now();
         else if (!busy)
             delete task.turnStartedAt;
+        // Reaching here means the thread just did something — exactly the
+        // "activity" an until-activity snooze waits for, including settling
+        // back to idle after a turn. Persist the wake like any task change.
+        if (task.snoozedUntil === 0) {
+            task.snoozedUntil = undefined;
+            this.saveBots();
+        }
         this.refreshBotActivity(bot);
         this.emit({ type: "bot", botId });
         return bot;
@@ -1551,6 +1937,64 @@ export class Store {
             this.emit({ type: "bot", botId: bot.id });
         return changed;
     }
+    /** Company instance ids became stable across re-enrolment. Moves every
+     * saved reference to an old id onto its replacement in one save: model
+     * choices, native resume cursors and handed-message records. An entry that
+     * already exists under the new id wins over the old one. */
+    renameInstances(ids) {
+        const touches = (record) => Boolean(record && Object.keys(record).some(key => ids.has(key)));
+        const rename = (record) => {
+            const next = {};
+            for (const [key, value] of Object.entries(record)) {
+                const target = ids.get(key);
+                if (!target)
+                    next[key] = value;
+                else if (!Object.prototype.hasOwnProperty.call(record, target))
+                    next[target] = value;
+            }
+            return next;
+        };
+        const changed = [];
+        for (const bot of this.bots) {
+            let dirty = false;
+            const selected = ids.get(bot.modelSelection.instanceId);
+            if (selected) {
+                bot.modelSelection = { ...bot.modelSelection, instanceId: selected };
+                dirty = true;
+            }
+            if (touches(bot.resumeCursors)) {
+                bot.resumeCursors = rename(bot.resumeCursors);
+                dirty = true;
+            }
+            for (const task of bot.tasks ?? []) {
+                const taskSelected = task.modelSelection && ids.get(task.modelSelection.instanceId);
+                if (task.modelSelection && taskSelected) {
+                    task.modelSelection = { ...task.modelSelection, instanceId: taskSelected };
+                    dirty = true;
+                }
+                if (touches(task.resumeCursors)) {
+                    task.resumeCursors = rename(task.resumeCursors);
+                    dirty = true;
+                }
+                if (task.handedMessages && touches(task.handedMessages)) {
+                    task.handedMessages = rename(task.handedMessages);
+                    dirty = true;
+                }
+                const last = task.lastInstanceId && ids.get(task.lastInstanceId);
+                if (last) {
+                    task.lastInstanceId = last;
+                    dirty = true;
+                }
+            }
+            if (dirty)
+                changed.push(bot);
+        }
+        if (changed.length)
+            this.saveBots();
+        for (const bot of changed)
+            this.emit({ type: "bot", botId: bot.id });
+        return changed.length;
+    }
     setResumeCursor(botId, instanceId, cursor, threadId) {
         const bot = this.bot(botId);
         if (!bot)
@@ -1795,8 +2239,16 @@ export class Store {
                 Object.assign(task, { [key]: structuredClone(patch[key]) });
             }
         }
+        // "Until new activity" ends the moment the thread has something new for
+        // the person, and every unread wake funnels through patchTask — so this
+        // one hook is the whole activity alarm. A time-based snooze is left to
+        // its clock: attention overrides it on screen without clearing it.
+        if (task.snoozedUntil === 0 && patch.unread === true)
+            task.snoozedUntil = undefined;
         if (typeof patch.title === "string")
             task.title = patch.title.trim().slice(0, 80) || UNTITLED_THREAD;
+        if (Object.prototype.hasOwnProperty.call(patch, "pinned") && task.pinned !== true)
+            delete task.pinned;
         if (bot.threadId === threadId)
             this.mirrorActiveTask(bot, task);
         bot.unread = bot.tasks.some((candidate) => candidate.unread);
@@ -1804,6 +2256,28 @@ export class Store {
         this.emit({ type: "bot", botId });
         return task;
     }
+    /** A Works on change is the newest explicit choice, so this bot's
+     * machine-recorded pins that now point somewhere else give way. A pin a
+     * person set, a legacy pin with unknown provenance, and a pin that already
+     * matches the new destination survive. Returns how many pins were cleared. */
+    clearAutoSurfacePins(botId, destination) {
+        const bot = this.bot(botId);
+        if (!bot?.tasks)
+            return 0;
+        let cleared = 0;
+        for (const task of bot.tasks) {
+            if (task.surface === undefined || task.surfaceSource !== "auto" || task.surface === destination)
+                continue;
+            task.surface = undefined;
+            task.surfaceSource = undefined;
+            cleared++;
+        }
+        if (!cleared)
+            return 0;
+        this.saveBots();
+        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. */
@@ -1814,8 +2288,8 @@ export class Store {
             return null;
         const patch = { modelSelection: structuredClone(selection),
             ...(resetApprovalToAsk ? { approvalMode: "ask", autoApprove: false, alwaysAllow: [] } : {}) };
-        const nextTask = { ...task, ...taskPatch, ...patch,
-            ...(typeof taskPatch.title === "string" ? { title: taskPatch.title.trim().slice(0, 80) || UNTITLED_THREAD } : {}) };
+        const nextTask = persistedPin({ ...task, ...taskPatch, ...patch,
+            ...(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.
@@ -1835,6 +2309,20 @@ export class Store {
         this.emit({ type: "bot", botId });
         return task;
     }
+    /** One durable write: never leave only part of a bot's threads updated. */
+    setAllThreadApprovalMode(botId, mode) {
+        const bot = this.bot(botId);
+        if (!bot)
+            return null;
+        const patch = { approvalMode: mode, autoApprove: false, alwaysAllow: [] };
+        const tasks = (bot.tasks ?? []).map(task => ({ ...task, ...patch }));
+        const next = { ...bot, ...patch, approvalGrant: undefined, tasks };
+        this.saveBots(this.bots.map(candidate => candidate === bot ? next : candidate));
+        bot.tasks?.forEach((task, index) => Object.assign(task, tasks[index]));
+        Object.assign(bot, patch, { approvalGrant: undefined });
+        this.emit({ type: "bot", botId });
+        return bot;
+    }
     mirrorActiveTask(bot, task) {
         bot.threadId = task.threadId;
         bot.resumeCursors = structuredClone(task.resumeCursors);
@@ -1843,23 +2331,25 @@ export class Store {
     }
     /** A fresh context on the same bot: new thread, new session, same
      * persona/tools/computer. Becomes the active task. */
-    createTask(botId, title, activate = true, projectId, openedBy) {
+    createTask(botId, title, activate = true, projectId, openedBy, approvalMode) {
         const bot = this.bot(botId);
         if (!bot)
             return null;
         if (projectId !== undefined && !this.project(botId, projectId))
             return null;
+        const createdAt = Date.now();
         const task = {
             threadId: newId(),
             title: threadTitleFrom(title),
-            createdAt: Date.now(),
+            createdAt,
+            updatedAt: createdAt,
             ...(projectId ? { projectId } : {}),
             ...(openedBy ? { openedBy: structuredClone(openedBy) } : {}),
             resumeCursors: {},
             modelSelection: structuredClone(bot.modelSelection),
-            approvalMode: approvalModeFor(bot),
-            autoApprove: Boolean(bot.autoApprove),
-            alwaysAllow: [...(bot.alwaysAllow ?? [])],
+            approvalMode: approvalMode ?? approvalModeFor(bot),
+            autoApprove: approvalMode ? false : Boolean(bot.autoApprove),
+            alwaysAllow: approvalMode ? [] : [...(bot.alwaysAllow ?? [])],
             unread: false,
             activity: "idle",
             busy: false,
@@ -1932,12 +2422,29 @@ export class Store {
      *   interleave in one transcript. `label` names that thread; the caller
      *   closes it once its result has been reported. A pair conversation
      *   never auto-closes. */
+    /** The identity a peer-opened row belongs to: its opener's id while that
+     * bot lives, else the one live bot the stamp's name still points at —
+     * what a deleted-and-recreated same-name bot inherits — else the dead id
+     * itself. A name two live bots share resolves to nobody's twin:
+     * ambiguous means unmatched, never a wrong merge. */
+    openerIdentity(openedBy) {
+        if (this.bot(openedBy.botId))
+            return openedBy.botId;
+        const named = this.bots.filter((bot) => bot.name === openedBy.name);
+        return named.length === 1 ? named[0].id : openedBy.botId;
+    }
     resolvePairConversation(sender, recipientId, options) {
         if (!this.bot(recipientId))
             return null;
         const title = `@${sender.name}`;
         const opener = (kind, at = Date.now()) => ({ botId: sender.id, name: sender.name, kind, at });
-        const fromSender = this.tasks(recipientId).filter((task) => task.openedBy?.botId === sender.id);
+        // Identity-stable: the sender's own rows, plus ones a deleted
+        // predecessor opened when the stamp's name still points at exactly
+        // this bot — a same-name recreation inherits the conversation instead
+        // of minting a twin while the old row dangles live. A name two live
+        // bots share matches nobody's inheritance: refusing the fallback can
+        // cost a new row, never merge two bots' histories.
+        const fromSender = this.tasks(recipientId).filter((task) => task.openedBy && this.openerIdentity(task.openedBy) === sender.id);
         let pair = fromSender.find((task) => task.openedBy?.kind === "pair");
         if (!pair) {
             const lastActivity = (task) => this.messagesTail(task.threadId, 1).messages.at(-1)?.at ?? task.openedBy?.at ?? task.createdAt;
@@ -1966,6 +2473,14 @@ export class Store {
             // back up, never replaced: closing is only the sidebar's idle state.
             if (pair.closedBy)
                 this.setTaskClosedBy(recipientId, pair.threadId, null);
+            // An inherited row carries the predecessor's id; rebind it to the
+            // live bot so the name fallback is needed only once — a namesake
+            // appearing later cannot claim the row. The hour it was opened
+            // stays: inheritance is not a new conversation.
+            const inherited = pair.openedBy;
+            if (inherited && inherited.botId !== sender.id) {
+                this.setTaskOpenedBy(recipientId, pair.threadId, { ...inherited, botId: sender.id, name: sender.name });
+            }
             return { task: pair, created: false };
         }
         // The brief is never a title. An 80-character slice of an assignment