openmausbot 0.1.85 → 0.1.87

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

@@ -70,19 +70,21 @@ function sameDriverFileIdentity(expected, actual) {
 }
 function decodeLegacyDescriptor(value, platform) {
     const supportedPlatform = legacyPlatform(platform);
-    if (!supportedPlatform || !value || value.mode === "unavailable" || typeof value.mcpCommand !== "string") {
+    if (!supportedPlatform || !value ||
+        !(value.mode === "embedded" || (supportedPlatform === "darwin" && value.mode === "standalone")) ||
+        (Object.hasOwn(value, "status") && value.status !== "ready") ||
+        typeof value.socketPath !== "string" || !value.socketPath ||
+        typeof value.mcpCommand !== "string" || !value.mcpCommand.trim()) {
         return null;
     }
-    if (value.mcpArgs !== undefined && !Array.isArray(value.mcpArgs))
+    if (!Array.isArray(value.mcpArgs) || value.mcpArgs[0] !== "mcp")
         return null;
-    if (value.mcpEnv !== undefined &&
-        (!value.mcpEnv || typeof value.mcpEnv !== "object" || Array.isArray(value.mcpEnv))) {
+    if (!value.mcpEnv || typeof value.mcpEnv !== "object" || Array.isArray(value.mcpEnv))
         return null;
-    }
-    const args = value.mcpArgs ?? ["mcp"];
+    const args = value.mcpArgs;
     if (!args.every((arg) => typeof arg === "string"))
         return null;
-    const env = value.mcpEnv ?? {};
+    const env = value.mcpEnv;
     if (!Object.values(env).every((entry) => typeof entry === "string"))
         return null;
     return {
@@ -288,31 +290,78 @@ function validateLegacyDescriptorRuntime(descriptorFile, platform, { uid = proce
         return false;
     }
 }
+/** An older fallback cannot override a present but unavailable, malformed, or
+ * unreadable descriptor at a more specific location. */
+function firstPresentCuaDescriptor(candidates) {
+    for (const file of new Set(candidates)) {
+        try {
+            lstatSync(file);
+            return file;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                return file;
+        }
+    }
+    return null;
+}
 export function readCuaConnection({ platform = process.platform, userData = process.env.OMB_USER_DATA, home = homedir(), validateLinuxRuntime = validateLinuxDescriptorRuntime, validateLegacyRuntime = validateLegacyDescriptorRuntime, } = {}) {
     const candidates = userData ? [join(userData, "cua-connection.json")] : [];
-    if (platform === "darwin") {
-        // Legacy/dev fallback. Packaged Electron passes its exact userData path.
+    if (platform === "darwin" && !userData) {
+        // Legacy/dev fallback only when Electron did not provide its exact path.
         for (const directory of ["OpenMausBot", "openmausbot", "OpenGrokBot", "opengrokbot"]) {
             candidates.push(join(home, "Library", "Application Support", directory, "cua-connection.json"));
         }
     }
-    for (const file of new Set(candidates)) {
-        try {
+    const file = firstPresentCuaDescriptor(candidates);
+    if (!file)
+        return null;
+    try {
+        const raw = JSON.parse(readFileSync(file, "utf8"));
+        if (platform === "linux") {
+            const decoded = decodeLinuxDescriptor(raw);
+            if (decoded && validateLinuxRuntime(file, raw))
+                return decoded;
+        }
+        else {
+            const decoded = decodeLegacyDescriptor(raw, platform);
+            if (decoded && validateLegacyRuntime(file, platform))
+                return decoded;
+        }
+    }
+    catch {
+        // Missing, invalid, tampered, or stale descriptors are unavailable.
+    }
+    return null;
+}
+/** An unavailable descriptor is diagnostic only. It never becomes a connection
+ * and only a private, well-formed macOS/Windows descriptor may supply text. */
+export function readCuaUnavailableReason({ platform = process.platform, userData = process.env.OMB_USER_DATA, home = homedir(), } = {}) {
+    if (!legacyPlatform(platform))
+        return null;
+    const candidates = userData ? [join(userData, "cua-connection.json")] : [];
+    if (platform === "darwin" && !userData) {
+        for (const directory of ["OpenMausBot", "openmausbot", "OpenGrokBot", "opengrokbot"]) {
+            candidates.push(join(home, "Library", "Application Support", directory, "cua-connection.json"));
+        }
+    }
+    const file = firstPresentCuaDescriptor(candidates);
+    if (!file)
+        return null;
+    try {
+        if (validateLegacyDescriptorRuntime(file, platform)) {
             const raw = JSON.parse(readFileSync(file, "utf8"));
-            if (platform === "linux") {
-                const decoded = decodeLinuxDescriptor(raw);
-                if (decoded && validateLinuxRuntime(file, raw))
-                    return decoded;
-            }
-            else {
-                const decoded = decodeLegacyDescriptor(raw, platform);
-                if (decoded && validateLegacyRuntime(file, platform))
-                    return decoded;
+            if (raw && typeof raw === "object" && !Array.isArray(raw) &&
+                Object.keys(raw).length === 2 &&
+                raw.mode === "unavailable") {
+                const reason = raw.reason;
+                if (typeof reason === "string" && reason.trim() && reason.length <= 2_000)
+                    return reason.trim();
             }
         }
-        catch {
-            // Missing, invalid, tampered, or stale descriptors are unavailable.
-        }
+    }
+    catch {
+        // No usable diagnostic; the caller still refuses computer control.
     }
     return null;
 }

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 organization's OpenMaus Admin license 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/mcp-bridge.js

@@ -36,14 +36,14 @@ import { createToolListNormalizer } from "./mcp-tool-schema.js";
 // stdin/stdout/stderr resets the window.
 export const BRIDGE_INACTIVITY_MS = 45_000;
 const PROBE_TIMEOUT_MS = 10_000;
-/** Run the liveness command; alive means "exited 0 within the timeout". The
- * probe is its own short-lived process, so it cannot inherit the wedged
- * connection it is diagnosing. */
-export function runLivenessProbe(probe, timeoutMs = PROBE_TIMEOUT_MS) {
+/** Run the liveness command; alive means "exited 0 within the timeout". A
+ * separate bounded command checks the transport without waiting for an
+ * answer on the possibly wedged MCP stream. */
+export function runLivenessProbe(probe, timeoutMs = PROBE_TIMEOUT_MS, env) {
     return new Promise((resolve) => {
         const child = spawn(probe.command, probe.args, {
             shell: false,
-            env: { ...process.env, PATH: augmentedPath() },
+            env: env ?? { ...process.env, PATH: augmentedPath() },
             stdio: ["ignore", "ignore", "ignore"],
         });
         const timer = setTimeout(() => {
@@ -265,7 +265,7 @@ export function runMcpBridge(options) {
         const liveness = options.liveness;
         watchdog = createInactivityWatchdog({
             inactivityMs: BRIDGE_INACTIVITY_MS,
-            probe: () => runLivenessProbe(liveness),
+            probe: () => runLivenessProbe(liveness, PROBE_TIMEOUT_MS, options.env),
             onDead: () => {
                 process.stderr.write(`${options.label} transport went silent and stopped answering liveness probes; ending the bridge\n`);
                 process.exitCode = 1;

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;