openmausbot 0.1.85 → 0.1.86

package/dist-server/server/managed-desktop.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { lstatSync, mkdirSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, renameSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 const uuid = z.string().uuid();
@@ -9,9 +9,18 @@ const connectionSchema = z.object({
     email: z.string().email().max(320), deviceId: uuid, token: z.string().regex(/^omg_[A-Za-z0-9_-]{43}$/),
     expiresAt: z.number().finite().int().positive(),
     providers: z.array(z.object({ id: z.enum(["anthropic", "openai", "openrouter"]), configured: z.boolean(), models: z.array(model).max(500) }).strict()).max(3),
+    /** The Admin is up but its operator licence lapsed: keep the instances
+     * listed as unavailable instead of treating it as a revocation. */
+    suspended: z.literal("license-expired").optional(),
 }).strict();
+/** The saved enrollment's identity (never its token), sent before it is
+ * cleared or when it has already expired, so references to its old
+ * device-scoped ids still move to the stable ids. */
+const identitySchema = z.object({ portalOrigin: z.string().max(2048), organizationId: uuid, email: z.string().email().max(320), deviceId: uuid }).strict();
+const PROVIDER_IDS = ["anthropic", "openai", "openrouter"];
 const signature = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
 const expiredMessage = "Company access has ended. Reconnect your organization or explicitly choose a personal model; personal billing will not be used automatically.";
+export const LICENSE_EXPIRED_MESSAGE = "Your organisation's OpenMaus Admin licence has expired. Contact your admin.";
 /** Validate only messages received over Electron's private utility-parent port.
  * Never expose this input to renderer HTTP or merge it into saved AppConfig.
  */
@@ -33,10 +42,18 @@ export function parseManagedDesktopConnection(raw, now = Date.now()) {
     return { ...value, portalOrigin: url.origin, email: value.email.toLowerCase(), providers: value.providers.map(provider => ({ ...provider, models: [...new Set(provider.models)] })).sort((a, b) => a.id.localeCompare(b.id)) };
 }
 export function companyInstanceId(connection, provider) {
-    // Device identity prevents an old company's native resume cursor from being
-    // inherited by a different enrollment using the same organization/email.
+    // Stable for one person in one organisation, so re-enrolling this computer
+    // keeps bots' Company model choices and native resume. Another account or
+    // organisation still gets separate ids, homes and cursors.
+    return `company.${signature([connection.portalOrigin, connection.organizationId, connection.email.toLowerCase()]).slice(0, 24)}.${provider}`;
+}
+/** The pre-0.1.86 id, which also hashed the enrollment's deviceId. */
+export function legacyCompanyInstanceId(connection, provider) {
     return `company.${signature([connection.portalOrigin, connection.organizationId, connection.deviceId]).slice(0, 24)}.${provider}`;
 }
+/** Everything that decides which native instances exist and what they hold.
+ * Expiry and licence suspension change availability only, never a process. */
+const instanceSignature = (connection) => signature(connection && (({ expiresAt: _expiresAt, suspended: _suspended, ...identity }) => identity)(connection));
 export function companyInstanceConfigs(connection, runtimeDirectory) {
     const entries = {};
     for (const provider of connection.providers) {
@@ -86,9 +103,18 @@ export class ManagedDesktopProviders {
     known = new Set();
     owns(instanceId) { return this.known.has(instanceId); }
     apply(raw, force = false) {
-        const connection = parseManagedDesktopConnection(raw, this.now()), nextSignature = signature(connection);
-        if (!force && nextSignature === this.currentSignature)
+        const connection = parseManagedDesktopConnection(raw, this.now()), nextSignature = instanceSignature(connection);
+        if (!force && nextSignature === this.currentSignature) {
+            // A renewal or licence change: same processes, new availability.
+            const previous = this.connection;
+            this.connection = connection;
+            if (connection && previous && (connection.expiresAt !== previous.expiresAt || connection.suspended !== previous.suspended)) {
+                clearTimeout(this.timer);
+                this.scheduleExpiry(this.revision);
+                this.options.onAvailability?.();
+            }
             return this.tail;
+        }
         this.currentSignature = nextSignature;
         this.connection = connection;
         const revision = ++this.revision;
@@ -107,6 +133,7 @@ export class ManagedDesktopProviders {
             // workspace backups. Device-scoped ids prevent a new enrollment from
             // inheriting another account's native conversation or credentials.
             const directory = this.ensureDirectory(["providers", "company"]);
+            await this.migrateLegacyIds(connection);
             const configs = companyInstanceConfigs(connection, directory);
             for (const [id, entry] of Object.entries(configs)) {
                 if (this.options.registry.entries().some(existing => existing.instanceId === id))
@@ -117,7 +144,9 @@ export class ManagedDesktopProviders {
                 this.ids.add(id);
                 this.known.add(id);
             }
-            const active = () => revision === this.revision && connection.expiresAt > this.now();
+            // Read the current grant: renewals and licence changes update it in place.
+            const active = () => revision === this.revision && Boolean(this.connection && this.connection.expiresAt > this.now() && !this.connection.suspended);
+            const unavailable = () => this.connection?.suspended === "license-expired" ? LICENSE_EXPIRED_MESSAGE : expiredMessage;
             await this.options.registry.load(configs, instance => {
                 const provider = connection.providers.find(provider => companyInstanceId(connection, provider.id) === instance.instanceId);
                 const models = { default: provider.models[0], options: provider.models.map(id => ({ id, label: `${id} (Company)` })) };
@@ -127,17 +156,17 @@ export class ManagedDesktopProviders {
                     startAuthentication: undefined, getAuthentication: undefined, completeAuthentication: undefined, cancelAuthentication: undefined, signOut: undefined,
                     snapshot: async () => {
                         if (!active())
-                            return { state: "unavailable", reason: expiredMessage };
+                            return { state: "unavailable", reason: unavailable() };
                         const snapshot = await instance.snapshot();
                         if (!active())
-                            return { state: "unavailable", reason: expiredMessage };
+                            return { state: "unavailable", reason: unavailable() };
                         return { ...snapshot, authenticated: snapshot.state === "available", billing: "metered", account: { email: connection.email, organization: connection.organizationName, method: "api-key" } };
                     },
                     adapter: {
                         ...instance.adapter,
                         sendTurn: async (input) => {
                             if (!active())
-                                throw new Error(expiredMessage);
+                                throw new Error(unavailable());
                             if (!input.model || !provider.models.includes(input.model))
                                 throw new Error("This model is not enabled by your Company administrator.");
                             return instance.adapter.sendTurn(input);
@@ -147,7 +176,7 @@ export class ManagedDesktopProviders {
             });
             if (revision === this.revision) {
                 this.options.afterReplace?.([...this.ids]);
-                this.scheduleExpiry(connection, revision);
+                this.scheduleExpiry(revision);
             }
         };
         this.tail = this.tail.catch(() => { }).then(replace).catch(async (error) => {
@@ -188,17 +217,53 @@ export class ManagedDesktopProviders {
         }
         return directory;
     }
-    scheduleExpiry(connection, revision) {
+    scheduleExpiry(revision) {
+        const expiresAt = this.connection?.expiresAt;
+        if (expiresAt === undefined)
+            return;
         this.timer = setTimeout(() => {
             if (revision !== this.revision)
                 return;
-            if (connection.expiresAt > this.now())
-                this.scheduleExpiry(connection, revision);
+            if ((this.connection?.expiresAt ?? 0) > this.now())
+                this.scheduleExpiry(revision);
             else
                 void this.apply(null).catch(() => { });
-        }, Math.min(2_147_483_647, Math.max(1, connection.expiresAt - this.now())));
+        }, Math.min(2_147_483_647, Math.max(1, expiresAt - this.now())));
         this.timer.unref?.();
     }
+    /** Moves an enrollment's old device-scoped ids to the stable ids: native
+     * homes are renamed only when the stable one does not exist yet, then saved
+     * references follow. Best effort: a failure is logged and never keeps
+     * Company models down. */
+    async migrateLegacyIds(identity) {
+        try {
+            const directory = this.ensureDirectory(["providers", "company"]);
+            const aliases = PROVIDER_IDS.map(provider => ({ from: legacyCompanyInstanceId(identity, provider), to: companyInstanceId(identity, provider) }));
+            for (const { from, to } of aliases) {
+                const legacy = join(directory, from), stable = join(directory, to);
+                if (!existsSync(legacy) || existsSync(stable))
+                    continue;
+                const stat = lstatSync(legacy);
+                if (stat.isDirectory() && !stat.isSymbolicLink())
+                    renameSync(legacy, stable);
+            }
+            await this.options.migrate?.(aliases);
+        }
+        catch (error) {
+            console.warn(`[company] could not move saved Company model references to their stable ids: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /** Migrates a saved enrollment that is being cleared or has expired. */
+    async migrateIdentity(raw) {
+        const parsed = identitySchema.parse(raw), url = new URL(parsed.portalOrigin);
+        if (url.origin !== parsed.portalOrigin || (url.protocol !== "https:" && !(url.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname)))) {
+            throw new Error("Company identity must use an HTTPS origin or loopback fixture.");
+        }
+        const identity = { ...parsed, email: parsed.email.toLowerCase() };
+        const migration = this.tail.catch(() => { }).then(() => this.migrateLegacyIds(identity));
+        this.tail = migration;
+        return migration;
+    }
     async close() {
         await this.apply(null, true);
     }

package/dist-server/server/managed-policy.js

@@ -0,0 +1,153 @@
+import { z } from "zod";
+/** An organisation's desktop policy, received only over Electron's private
+ * utility-parent port while this desktop is enrolled. It lives in memory: it
+ * is never merged into config.json, and it adds no prompts or approvals —
+ * a disallowed action is simply refused with a sentence saying who manages it. */
+const policySchema = z.object({
+    organizationId: z.string().uuid(),
+    organizationName: z.string().trim().min(1).max(100),
+    expiresAt: z.number().int().positive(),
+    version: z.number().int().min(0).max(2_147_483_647),
+    companyModelsOnly: z.boolean(),
+    allowedEngines: z.union([z.literal("all"), z.array(z.string().regex(/^[A-Za-z][A-Za-z0-9-]{0,63}$/)).max(64)]),
+    mcp: z.object({ allowCustom: z.boolean(), allowlist: z.array(z.string().trim().min(1).max(200)).max(100) }).strict(),
+    computers: z.object({ thisComputer: z.boolean(), localVm: z.boolean(), box: z.boolean(), vps: z.boolean() }).strict(),
+    remoteAccess: z.boolean(),
+}).strict();
+const computerLabels = { thisComputer: "this computer", localVm: "local virtual machines", box: "Box cloud computers", vps: "VPS computers" };
+export function parseManagedPolicy(raw, now = Date.now()) {
+    if (raw === null)
+        return null;
+    const parsed = policySchema.safeParse(raw);
+    if (!parsed.success)
+        throw new Error("Invalid organisation policy from the desktop parent.");
+    return parsed.data.expiresAt > now ? parsed.data : null;
+}
+/** `*` in a host pattern stands for one or more whole labels, never part of
+ * one, so `*.example.com` cannot match `evil.test/x.example.com`. */
+function hostMatches(pattern, host) {
+    if (!pattern.length)
+        return !host.length;
+    if (pattern[0] === "*") {
+        for (let taken = 1; taken <= host.length - (pattern.length - 1); taken++)
+            if (hostMatches(pattern.slice(1), host.slice(taken)))
+                return true;
+        return false;
+    }
+    return host.length > 0 && pattern[0] === host[0] && hostMatches(pattern.slice(1), host.slice(1));
+}
+/** A name entry matches the configured server name. An address entry
+ * (https:// only) is parsed like the server's URL: no credentials, the same
+ * port, the host compared label by label, and the path separately (`*` there
+ * matches any characters). Anything that does not parse never matches. */
+export function mcpEntryMatches(entry, name, url) {
+    if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(entry))
+        return entry.toLowerCase() === name.toLowerCase();
+    if (!url)
+        return false;
+    let pattern, target;
+    try {
+        pattern = new URL(entry);
+        target = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    if (pattern.protocol !== "https:" || target.protocol !== "https:" || pattern.username || pattern.password || target.username || target.password ||
+        pattern.search || pattern.hash || pattern.port !== target.port)
+        return false;
+    const labels = pattern.hostname.split(".");
+    if (labels.some(label => !label || (label !== "*" && label.includes("*"))) || labels.every(label => label === "*"))
+        return false;
+    if (!hostMatches(labels, target.hostname.split(".")))
+        return false;
+    const path = pattern.pathname.split("*").map(part => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+    return new RegExp(`^${path}$`).test(target.pathname);
+}
+/** A resource key claimed by bindTurnComputer, mapped to the policy's kind. */
+export function computerKindForResource(resource) {
+    if (resource === "computer:host")
+        return "thisComputer";
+    if (resource.startsWith("computer:vm:"))
+        return "localVm";
+    if (resource.startsWith("computer:box:") || resource.startsWith("computer:box-bot:"))
+        return "box";
+    if (resource.startsWith("computer:vps:"))
+        return "vps";
+}
+export class ManagedDesktopPolicy {
+    policy = null;
+    timer;
+    now;
+    onChange;
+    constructor(options = {}) {
+        this.now = options.now ?? Date.now;
+        this.onChange = options.onChange ?? (() => { });
+    }
+    apply(raw) {
+        const next = parseManagedPolicy(raw, this.now());
+        const changed = JSON.stringify(next) !== JSON.stringify(this.policy);
+        this.policy = next;
+        clearTimeout(this.timer);
+        // The last applied policy holds only as long as the device credential.
+        if (next) {
+            this.timer = setTimeout(() => this.apply(null), Math.min(2_147_483_647, Math.max(1, next.expiresAt - this.now())));
+            this.timer.unref?.();
+        }
+        if (changed)
+            this.onChange();
+    }
+    current() {
+        return this.policy && this.policy.expiresAt > this.now() ? this.policy : null;
+    }
+    close() { clearTimeout(this.timer); this.policy = null; }
+    /** Why this organisation does not allow an instance to run a turn, or undefined. */
+    modelRefusal(instance, company) {
+        const policy = this.current();
+        if (!policy)
+            return;
+        if (policy.companyModelsOnly && !company)
+            return `${policy.organizationName} allows only company models on this computer. Choose a Company model for this bot.`;
+        if (policy.allowedEngines !== "all" && !policy.allowedEngines.includes(instance.driverKind)) {
+            return `${policy.organizationName} does not allow the ${instance.displayName ?? instance.driverKind} engine on this computer. Choose another model for this bot.`;
+        }
+    }
+    mcpAllowed(name, url) {
+        const policy = this.current();
+        return !policy || policy.mcp.allowCustom || policy.mcp.allowlist.some(entry => mcpEntryMatches(entry, name, url));
+    }
+    /** Only approved servers reach engines while custom servers are off. */
+    filterMcp(servers) {
+        if (!this.restrictsMcp())
+            return servers;
+        return Object.fromEntries(Object.entries(servers).filter(([name, server]) => this.mcpAllowed(name, "url" in server && typeof server.url === "string" ? server.url : undefined)));
+    }
+    restrictsMcp() { const policy = this.current(); return Boolean(policy && !policy.mcp.allowCustom); }
+    mcpRefusal(name, url) {
+        const policy = this.current();
+        if (!policy || this.mcpAllowed(name, url))
+            return;
+        return `${policy.organizationName} allows only MCP servers it has approved. Ask your administrator to add this server to the approved list.`;
+    }
+    computerAllowed(kind) { return this.current()?.computers[kind] ?? true; }
+    computerRefusal(kind) {
+        const policy = this.current();
+        if (!policy || policy.computers[kind])
+            return;
+        return `${policy.organizationName} does not allow bots to use ${computerLabels[kind]}.`;
+    }
+    remoteAccessRefusal() {
+        const policy = this.current();
+        if (!policy || policy.remoteAccess)
+            return;
+        return `${policy.organizationName} does not allow remote access to this computer.`;
+    }
+    /** Read-only view for the renderer; carries nothing secret. */
+    summary() {
+        const policy = this.current();
+        if (!policy)
+            return null;
+        const { organizationId: _id, expiresAt: _expires, ...visible } = policy;
+        return visible;
+    }
+}

package/dist-server/server/message-db.js

@@ -408,6 +408,25 @@ export function setActiveLeaf(threadId, leafId) {
         "ON CONFLICT(thread_id) DO UPDATE SET active_leaf_id = excluded.active_leaf_id")
         .run(threadId, leafId);
 }
+/** Newest message timestamp per thread. One grouped read, chunked under
+ * SQLite's variable limit. Threads with no rows are absent. */
+export function latestMessageAts(threadIds) {
+    const ids = [...new Set(threadIds.filter((id) => id.length > 0))];
+    const out = new Map();
+    const chunk = 400;
+    for (let i = 0; i < ids.length; i += chunk) {
+        const slice = ids.slice(i, i + chunk);
+        const placeholders = slice.map(() => "?").join(", ");
+        const rows = db()
+            .prepare(`SELECT thread_id, MAX(at) AS at FROM messages WHERE thread_id IN (${placeholders}) GROUP BY thread_id`)
+            .all(...slice);
+        for (const row of rows) {
+            if (typeof row.at === "number" && Number.isFinite(row.at))
+                out.set(row.thread_id, row.at);
+        }
+    }
+    return out;
+}
 export function deleteThread(threadId) {
     writeFollowups((connection) => {
         connection.prepare("DELETE FROM chat_followups WHERE thread_id = ?").run(threadId);
@@ -415,6 +434,15 @@ export function deleteThread(threadId) {
         connection.prepare("DELETE FROM thread_state WHERE thread_id = ?").run(threadId);
     });
 }
+/** Every thread whose stored messages mention `fragment` anywhere (an
+ * attachment's file name, say). A scan, like search; used only to decide
+ * whether a member on a workspace with a restricted bot may fetch a file. */
+export function threadsReferencing(fragment) {
+    if (!fragment)
+        return [];
+    const rows = db().prepare("SELECT DISTINCT thread_id FROM messages WHERE instr(json, ?) > 0").all(fragment);
+    return rows.map((row) => row.thread_id);
+}
 /** Case-insensitive substring search over text messages, newest first.
  * A LIKE scan, deliberately: local transcripts are megabytes at most, a
  * scan is milliseconds, and it needs no FTS extension to exist. */

package/dist-server/server/model-context-window.js

@@ -6,6 +6,11 @@ export function modelContextWindow(model) {
     if (!model)
         return undefined;
     const id = model.toLowerCase();
+    // Opus 5.5 is 1M without a `[1m]` suffix. Only the exact slug, or that
+    // slug after a slash or a provider dot. A longer suffix such as
+    // `claude-opus-5-5-local` stays on the generic Claude rule, as does `host::`.
+    if (/(?:^|[/.])claude-opus-5(?:-5|\.5)$/.test(id))
+        return 1_000_000;
     if (/claude/.test(id) || /^(opus|sonnet|haiku|fable)\b/.test(id))
         return /\[1m\]|-1m\b|1m-context/.test(id) ? 1_000_000 : 200_000;
     if (/^(gpt-5|o[34]\b|codex)/.test(id))
@@ -14,6 +19,8 @@ export function modelContextWindow(model) {
         return 1_000_000;
     if (/gemini/.test(id))
         return 1_000_000;
+    if (id === "grok-4.7")
+        return 500_000;
     if (id.startsWith("grok"))
         return 256_000;
     return undefined;

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

@@ -0,0 +1,121 @@
+import { billableFor } from "./prices.js";
+const AS_OF = "2026-09-23";
+const OPENAI = "https://developers.openai.com/api/docs/pricing";
+const ANTHROPIC = "https://platform.claude.com/docs/en/about-claude/pricing";
+const XAI = "https://docs.x.ai/developers/models";
+const GOOGLE = "https://ai.google.dev/gemini-api/docs/pricing";
+const MINIMAX = "https://platform.minimax.io/docs/guides/pricing-paygo";
+// OpenRouter's FAQ (https://openrouter.ai/docs/faq) says it passes provider
+// prices through without markup, but its live list does discount some
+// models, so these are read from that list rather than copied from the
+// vendors. Its 5.5% fee on buying credits is not a per-token price.
+const OPENROUTER = "https://openrouter.ai/api/v1/models";
+const price = (source, input, cached, output, extra = {}) => ({
+    inputPerMillion: input,
+    cachedInputPerMillion: cached,
+    outputPerMillion: output,
+    asOf: AS_OF,
+    source,
+    ...extra,
+});
+/** Keyed by the model id as a bot's selection names it, lower-cased. */
+export const LIST_PRICES = {
+    // OpenAI, Standard tier, short context (<272K input tokens).
+    "gpt-6-astra": price(OPENAI, 10, 1, 50),
+    // Labelled promotional pricing on the source page, with no end date given.
+    "gpt-5.6-sol": price(OPENAI, 4, 0.4, 20),
+    "gpt-5.6-terra": price(OPENAI, 2, 0.2, 12),
+    "gpt-5.6-luna": price(OPENAI, 0.2, 0.02, 1.2),
+    "gpt-5.5": price(OPENAI, 5, 0.5, 30),
+    "gpt-5.4": price(OPENAI, 2.5, 0.25, 15),
+    "gpt-5.4-mini": price(OPENAI, 0.75, 0.075, 4.5),
+    "gpt-5.3-codex": price(OPENAI, 1.75, 0.175, 14),
+    // gpt-5.3-codex-spark has no published API price: unpriced.
+    // Anthropic: base input, cache hit, output. No long-context tier.
+    "claude-fable-5-1": price(ANTHROPIC, 10, 0.25, 50),
+    "claude-fable-5": price(ANTHROPIC, 10, 1, 50),
+    "claude-opus-5": price(ANTHROPIC, 5, 0.5, 25),
+    "claude-sonnet-5": price(ANTHROPIC, 2, 0.2, 10),
+    "claude-haiku-4-5": price(ANTHROPIC, 1, 0.1, 5),
+    "claude-haiku-4-5-20251001": price(ANTHROPIC, 1, 0.1, 5),
+    // xAI, under 200k prompt tokens. grok-4, grok-4-fast and grok-3-mini are
+    // retired or unlisted: unpriced.
+    "grok-4.7": price(XAI, 2, 0.5, 6),
+    "grok-4.6": price(XAI, 2, 0.5, 6),
+    "grok-4.5": price(XAI, 2, 0.3, 6),
+    // Google Gemini API, paid tier, prompts up to 200k tokens.
+    "gemini-2.5-pro": price(GOOGLE, 1.25, 0.125, 10),
+    "gemini-2.5-flash": price(GOOGLE, 0.3, 0.03, 2.5),
+    "gemini-3.1-pro-preview": price(GOOGLE, 2, 0.2, 12),
+    "gemini-3.8-flash": price(GOOGLE, 0.75, 0.075, 3.75, {
+        changes: [{ from: "2027-01-01", inputPerMillion: 1.5, cachedInputPerMillion: 0.15, outputPerMillion: 7.5 }],
+    }),
+    // MiniMax, international pay-as-you-go, Standard. M3 up to 512k input
+    // tokens, at the price charged (the page shows it as 50% off, permanently).
+    "minimax-m3": price(MINIMAX, 0.3, 0.06, 1.2),
+    "minimax-m2.7": price(MINIMAX, 0.3, 0.06, 1.2),
+    "minimax-m2.7-highspeed": price(MINIMAX, 0.6, 0.06, 2.4),
+    // OpenRouter ids, as its live model list prices them.
+    "openai/gpt-6-astra": price(OPENROUTER, 10, 1, 50),
+    "openai/gpt-5.6-sol": price(OPENROUTER, 2, 0.2, 10),
+    "openai/gpt-5.6-terra": price(OPENROUTER, 2, 0.2, 12),
+    "openai/gpt-5.6-luna": price(OPENROUTER, 0.2, 0.02, 1.2),
+    "openai/gpt-5.5": price(OPENROUTER, 5, 0.5, 30),
+    "openai/gpt-5.4": price(OPENROUTER, 2.5, 0.25, 15),
+    "openai/gpt-5.4-mini": price(OPENROUTER, 0.75, 0.075, 4.5),
+    "openai/gpt-5.3-codex": price(OPENROUTER, 1.75, 0.175, 14),
+    "anthropic/claude-fable-5.1": price(OPENROUTER, 10, 0.25, 50),
+    "anthropic/claude-fable-5": price(OPENROUTER, 10, 1, 50),
+    "anthropic/claude-opus-5": price(OPENROUTER, 5, 0.5, 25),
+    "anthropic/claude-sonnet-5": price(OPENROUTER, 2, 0.2, 10),
+    "anthropic/claude-haiku-4.5": price(OPENROUTER, 1, 0.1, 5),
+    "x-ai/grok-4.7": price(OPENROUTER, 1.6, 0.4, 4.8),
+    "x-ai/grok-4.6": price(OPENROUTER, 2, 0.5, 6),
+    "x-ai/grok-4.5": price(OPENROUTER, 2, 0.3, 6),
+    "google/gemini-2.5-pro": price(OPENROUTER, 1.25, 0.125, 10),
+    "google/gemini-2.5-flash": price(OPENROUTER, 0.3, 0.03, 2.5),
+    "google/gemini-3.1-pro-preview": price(OPENROUTER, 2, 0.2, 12),
+    "google/gemini-3.8-flash": price(OPENROUTER, 0.75, 0.075, 3.75),
+    "minimax/minimax-m3": price(OPENROUTER, 0.3, 0.06, 1.2),
+    "minimax/minimax-m2.7": price(OPENROUTER, 0.3, 0.06, 1.2),
+};
+/** Catalog ids that name a listed model with a setting attached: the
+ * Antigravity picker offers Gemini 3.8 Flash at three thinking levels. */
+const ALIASES = {
+    "gemini-3.8-flash-high": "gemini-3.8-flash",
+    "gemini-3.8-flash-medium": "gemini-3.8-flash",
+    "gemini-3.8-flash-low": "gemini-3.8-flash",
+};
+/** The list price for a model at a moment, or null when it is not listed. */
+export function listPriceFor(model, at = new Date()) {
+    const key = model.trim().toLowerCase();
+    const entry = LIST_PRICES[ALIASES[key] ?? key];
+    if (!entry)
+        return null;
+    const day = at.toISOString().slice(0, 10);
+    const change = entry.changes?.filter((candidate) => candidate.from <= day).at(-1);
+    const current = change ?? entry;
+    return {
+        inputPerMillion: current.inputPerMillion,
+        outputPerMillion: current.outputPerMillion,
+        ...(current.cachedInputPerMillion !== undefined ? { cachedInputPerMillion: current.cachedInputPerMillion } : {}),
+    };
+}
+/** The price an estimate uses: the operator's own price for this exact
+ * model (Settings → Usage → prices, `driver/model` or model id), then the
+ * built-in list, then the operator's `default` row. */
+export function estimatePriceFor(turn, operatorPrices, at = new Date()) {
+    return operatorPrices?.[`${turn.driverKind}/${turn.model}`] ?? operatorPrices?.[turn.model] ??
+        listPriceFor(turn.model, at) ?? operatorPrices?.default ?? null;
+}
+/** What the ledger books for a settled turn: the engine's own cost when it
+ * reported one, else an estimate, else null (unpriced). */
+export function ledgerCost(turn, operatorPrices, at = new Date()) {
+    if (typeof turn.costUsd === "number" && Number.isFinite(turn.costUsd) && turn.costUsd >= 0) {
+        return { costUsd: turn.costUsd, costSource: "reported" };
+    }
+    const unit = estimatePriceFor(turn, operatorPrices, at);
+    if (!unit)
+        return { costUsd: null };
+    return { costUsd: billableFor(turn, { [turn.model]: unit }), costSource: "estimated" };
+}

package/dist-server/server/notify.js

@@ -33,6 +33,13 @@ export function blockedTarget(bot, room) {
         return { threadId: bot.threadId };
     return { threadId: room.threadId, group: { id: room.id, name: room.name } };
 }
+/** A workspace spend notice (server/spend.ts decides when). It opens the
+ * thread whose turn crossed the line, so clicking it lands somewhere real,
+ * but it is the workspace's news, not that bot's: the bot's notification
+ * toggle does not silence it. */
+export function buildSpendNotification(bot, threadId, text) {
+    return { kind: "spend", botId: bot.id, botName: bot.name, threadId, title: text.title, body: summarize(text.body, 200) };
+}
 /** Build the frame for one event, or null when it should stay quiet.
  *
  * Kept pure and separate from the event fold so the policy — which is the
@@ -62,7 +69,9 @@ export function buildNotification(kind, bot, threadId, detail, extra) {
                             ? `${who} couldn't start`
                             : kind === "incident"
                                 ? `${who} hit a problem`
-                                : `${who} finished`;
+                                : kind === "delegation-settled"
+                                    ? `${who} resumed with results`
+                                    : `${who} finished`;
     // A "finished" with nothing to say is not worth a notification — the
     // badge in the sidebar already carries that much.
     if (kind === "done" && !body)

package/dist-server/server/peer-roster.js

@@ -3,6 +3,7 @@
 // every other bot now gets are rendered from here, so there is one set of
 // caps, one sanitizer, and one reachability rule to audit rather than two
 // that drift.
+import { sameAudience } from "./bot-visibility.js";
 const sectionKey = (section) => section?.trim() || "";
 export const PEER_ACCESS_HELP = "Call list_bots for reachable teammates. If the intended Chief is missing, ask the user to check team membership and this bot's allowed peers, or message the Chief directly. A Chief's access to another team does not grant that team's bots access back to the Chief. Do not use computer control to bypass this.";
 /** Coordination is scoped to the bot's own team unless the owner explicitly
@@ -51,9 +52,19 @@ export function peerStatusWords(status) {
  * written by an older build) falls back to the unset rule rather than
  * throwing mid-turn: the list is operator-owned local state, so degrading to
  * the documented default is safer than failing a turn. */
-export const peerAllowed = (from, targetId) => !Array.isArray(from.peers) || from.peers.includes(targetId);
+export const peerAllowed = (from, target) => {
+    const targetId = typeof target === "string" ? target : target.id;
+    if (Array.isArray(from.peers) && !from.peers.includes(targetId))
+        return false;
+    // Given the record, also require the same audience: a teammate that other
+    // people can see would carry this bot's words, or bring back a restricted
+    // bot's answers, to people who cannot see the other (bot-visibility.ts).
+    // Bots nobody restricted all share "everyone", so this changes nothing
+    // until an admin restricts one.
+    return typeof target === "string" || sameAudience(from.visibility, target.visibility);
+};
 export function canReachPeer(from, target) {
-    return from.id !== target.id && !target.hidden && canAccessTeam(from, target.section) && peerAllowed(from, target.id);
+    return from.id !== target.id && !target.hidden && canAccessTeam(from, target.section) && peerAllowed(from, target);
 }
 /** The peers a bot can both see and reach right now. The roster, list_bots
  * and @mention resolution all read this one list, so what a bot is TOLD

package/dist-server/server/recent-work.js

@@ -143,3 +143,18 @@ export function parseSince(value, now = Date.now()) {
     const parsed = Date.parse(/^\d{4}-\d{2}-\d{2}$/.test(text) ? `${text}T00:00` : value.trim());
     return Number.isFinite(parsed) ? parsed : null;
 }
+/** The forms that name a whole day rather than one instant. */
+const WHOLE_DAY = /^(?:today|yesterday|\d{4}-\d{2}-\d{2})$/;
+/** The closing end of a window a person types. `since` takes a day's first
+ * instant, so `until` has to take its last: read the same way, `since` and
+ * `until` on one day span no time at all and a full day of work reads back as
+ * nothing. Only the forms that name a day are stretched — a span ("24h"), an
+ * epoch, or a date with a clock time still means the instant it names. */
+export function parseUntil(value, now = Date.now()) {
+    const at = parseSince(value, now);
+    if (at === null || !WHOLE_DAY.test(value.trim().toLowerCase()))
+        return at;
+    const end = new Date(at);
+    end.setHours(23, 59, 59, 999);
+    return end.getTime();
+}