@songsid/agend 2.1.8-beta.2 → 2.1.8-beta.4

package/dist/fleet-manager.js

@@ -3,6 +3,7 @@ import { randomBytes, randomUUID } from "node:crypto";
 import { spawnSync } from "node:child_process";
 import { freemem, totalmem, cpus } from "node:os";
 import { createServer } from "node:http";
+import { Worker } from "node:worker_threads";
 import { join, dirname, basename } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getAgendHome, ensureWorkspaceGit } from "./paths.js";
@@ -16,7 +17,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /** Fallback access policy for a channel with no `access:` block — open (no gate). */
 const DEFAULT_OPEN_ACCESS = { mode: "open", allowed_users: [], max_pending_codes: 0, code_expiry_minutes: 0 };
-import { STATUS_EMOJI_KEYS, builtinStatusEmojis, reactionForm, reactionMatchKey, resolveStatusEmojis, statusAvoidList, statusMatchKey, statusMatchKeys, textForm, } from "./status-emojis.js";
+import { STATUS_EMOJI_CONFIG_KEYS, STATUS_EMOJI_KEYS, STATUS_EMOJI_SUGGESTIONS, TELEGRAM_REACTION_EMOJIS, builtinStatusEmojis, customEmojiValue, emojiImageUrl, normalizeEmoji, previewStatusEmojis, reactionForm, reactionMatchKey, resolveStatusEmojis, statusAvoidList, statusEmojiProblem, statusMatchKey, statusMatchKeys, textForm, } from "./status-emojis.js";
 import { isProbeableRouteTarget } from "./fleet-context.js";
 import { loadFleetConfig, loadRawFleetConfig, DEFAULT_COST_GUARD, DEFAULT_DAILY_SUMMARY, DEFAULT_INSTANCE_CONFIG } from "./config.js";
 import { EventLog } from "./event-log.js";
@@ -28,7 +29,7 @@ import { IpcClient } from "./channel/ipc-bridge.js";
 import { createAdapter } from "./channel/factory.js";
 import { TelegramAdapter } from "./channel/adapters/telegram.js";
 import { createBackend } from "./backend/factory.js";
-import { isModelCompatible } from "./backend/types.js";
+import { isModelCompatible, SYSINFO_BACKEND_IDS } from "./backend/types.js";
 import { createLogger, rotateLogIfNeeded } from "./logger.js";
 import { processAttachments } from "./channel/attachment-handler.js";
 import { routeToolCall } from "./channel/tool-router.js";
@@ -3915,7 +3916,7 @@ export class FleetManager {
             }
             else if (data.command === "sysinfo") {
                 // Slash commands are Discord-only; use plain lines (no markdown table)
-                await data.respond(this.topicCommands.getSysInfoText({ platform: "discord" }));
+                await this.topicCommands.sendSysInfo(text => data.respond(text), { platform: "discord" });
             }
             else if (data.command === "dashboard") {
                 // Reply is ephemeral (adapter defers non-chat commands ephemerally), so
@@ -4275,7 +4276,7 @@ export class FleetManager {
             }
             else if (data.command === "sysinfo") {
                 // Slash commands are Discord-only; use plain lines (no markdown table)
-                await data.respond(this.topicCommands.getSysInfoText({ platform: "discord" }));
+                await this.topicCommands.sendSysInfo(text => data.respond(text), { platform: "discord" });
             }
             else if (data.command === "dashboard") {
                 // Reply is ephemeral (adapter defers non-chat commands ephemerally), so
@@ -5850,7 +5851,8 @@ export class FleetManager {
             : type.startsWith("fleet_decision_") ? "fleet_decision_response"
                 : type === "fleet_task" ? "fleet_task_response"
                     : type === "fleet_set_display_name" ? "fleet_display_name_response"
-                        : "fleet_description_response";
+                        : type === "fleet_list_emojis" || type === "fleet_set_persona_emoji" || type === "fleet_preview_emojis" ? "fleet_persona_emoji_response"
+                            : "fleet_description_response";
         ipc.send({ type: responseType, fleetRequestId, error: message });
     }
     dispatchTypedIpc(name, msg) {
@@ -5875,6 +5877,24 @@ export class FleetManager {
             this.handleSetDescription(name, msg);
             return;
         }
+        if (type === "fleet_list_emojis" || type === "fleet_set_persona_emoji" || type === "fleet_preview_emojis") {
+            this.handlePersonaEmoji(name, msg);
+            return;
+        }
+    }
+    /** `list_emojis` / `set_persona_emoji` / `preview_emojis` over IPC; the agent endpoint calls the same methods. */
+    handlePersonaEmoji(instanceName, msg) {
+        const fleetRequestId = msg.fleetRequestId;
+        const payload = (msg.payload ?? {});
+        const ipc = this.instanceIpcClients.get(instanceName);
+        if (!ipc)
+            return;
+        const op = msg.type === "fleet_list_emojis" ? this.listEmojisFor(instanceName, payload.refresh === true)
+            : msg.type === "fleet_preview_emojis" ? this.previewEmojis(instanceName, payload)
+                : this.setPersonaEmoji(instanceName, payload);
+        op.then((r) => typeof r.error === "string"
+            ? ipc.send({ type: "fleet_persona_emoji_response", fleetRequestId, error: r.error })
+            : ipc.send({ type: "fleet_persona_emoji_response", fleetRequestId, result: r }), (err) => ipc.send({ type: "fleet_persona_emoji_response", fleetRequestId, error: err.message }));
     }
     handleScheduleCrud(instanceName, msg) {
         const fleetRequestId = msg.fleetRequestId;
@@ -6217,6 +6237,15 @@ export class FleetManager {
             return { error: `Instance '${instance}' not found` };
         return { display_name: name };
     }
+    async handleListEmojisHttp(instance, refresh) {
+        return this.listEmojisFor(instance, refresh);
+    }
+    async handleSetPersonaEmojiHttp(instance, args) {
+        return this.setPersonaEmoji(instance, args);
+    }
+    async handlePreviewEmojisHttp(instance, args) {
+        return this.previewEmojis(instance, args);
+    }
     async handleSetDescriptionHttp(instance, description) {
         if (!this.fleetConfig)
             return { error: "Fleet config not available" };
@@ -6834,6 +6863,8 @@ export class FleetManager {
     deliveryStatusChains = new Map();
     /** #725: in-flight CLI env probes, keyed by backend name. Coalesces concurrent /model requests. */
     pendingCliEnvProbes = new Map();
+    /** Forced vendor catalog refreshes are separate flights, but sysinfo joins either flight. */
+    pendingVendorCliEnvProbes = new Map();
     /**
      * The status emojis for an instance (#1005): its own `status_emojis`, then
      * its channel's `options.status_emojis`, then the platform built-in. An
@@ -6864,10 +6895,15 @@ export class FleetManager {
     }
     warnedStatusEmojis = new Set();
     /**
-     * A Discord connection's server emojis for the Settings picker (#1005).
-     * Cached per connection — a server's emoji set changes rarely — and one
-     * fetch at a time; `refresh` forces a new one. Uses the running adapter, so
-     * the bot token never leaves the server.
+     * A Discord connection's server emojis for the Settings picker (#1005), from
+     * every server its bot can draw on (#1021): the primary `group_id` server,
+     * then each other server the bot is a member of that ClassicBot's
+     * `allowed_guilds` admits (unset = all, as for classic routing). A bot can
+     * react with a custom emoji from any server it is in. Cached per server — a
+     * server's emoji set changes rarely — and one fetch per server at a time;
+     * `refresh` forces new ones. One server refusing (e.g. Missing Access) is
+     * reported on that server and does not hide the others. Uses the running
+     * adapter, so the bot token never leaves the server.
      */
     async listGuildEmojis(channelId, refresh = false) {
         const world = this.worlds.get(channelId);
@@ -6878,28 +6914,267 @@ export class FleetManager {
         const adapter = world.adapter;
         if (!adapter.listGuildEmojis)
             return { ok: false, error: "this adapter cannot list server emojis" };
-        const cached = this.guildEmojiCache.get(channelId);
-        if (!refresh && cached && Date.now() - cached.fetched_at < FleetManager.GUILD_EMOJI_TTL_MS)
-            return { ok: true, ...cached };
-        let pending = this.guildEmojiFetches.get(channelId);
-        if (!pending) {
-            pending = adapter.listGuildEmojis().then(emojis => {
-                const entry = { fetched_at: Date.now(), emojis };
-                this.guildEmojiCache.set(channelId, entry);
-                return entry;
-            }).finally(() => this.guildEmojiFetches.delete(channelId));
-            this.guildEmojiFetches.set(channelId, pending);
-        }
+        const listEmojis = adapter.listGuildEmojis.bind(adapter);
+        let servers;
         try {
-            return { ok: true, ...(await pending) };
+            servers = adapter.listMemberGuilds
+                ? (await adapter.listMemberGuilds()).filter(g => g.primary || (this.classicChannels?.isGuildAllowed(g.id) ?? false))
+                : [{ id: "", name: "", primary: true }];
         }
         catch (e) {
-            return { ok: false, error: `Discord refused the emoji list: ${e.message}` };
-        }
+            return { ok: false, error: `Discord refused the server list: ${e.message}` };
+        }
+        const guilds = await Promise.all(servers.map(async (g) => {
+            const key = `${channelId}\0${g.id}`;
+            const cached = this.guildEmojiCache.get(key);
+            if (!refresh && cached && Date.now() - cached.fetched_at < FleetManager.GUILD_EMOJI_TTL_MS)
+                return { ...g, ...cached };
+            let pending = this.guildEmojiFetches.get(key);
+            if (!pending) {
+                pending = (g.id ? listEmojis(g.id) : listEmojis()).then(emojis => {
+                    const entry = { fetched_at: Date.now(), emojis };
+                    this.guildEmojiCache.set(key, entry);
+                    return entry;
+                }).finally(() => this.guildEmojiFetches.delete(key));
+                this.guildEmojiFetches.set(key, pending);
+            }
+            try {
+                return { ...g, ...(await pending) };
+            }
+            catch (e) {
+                return { ...g, error: `Discord refused the emoji list: ${e.message}` };
+            }
+        }));
+        const listed = guilds.filter((g) => !!g.emojis);
+        if (!listed.length)
+            return { ok: false, error: guilds[0]?.error ?? "no server to list emojis from" };
+        return {
+            ok: true,
+            fetched_at: Math.min(...listed.map(g => g.fetched_at)),
+            emojis: listed.flatMap(g => g.emojis),
+            guilds,
+        };
     }
     static GUILD_EMOJI_TTL_MS = 10 * 60_000;
+    /** Keyed `<connection>\0<server id>`. */
     guildEmojiCache = new Map();
     guildEmojiFetches = new Map();
+    /**
+     * What `instanceName` may pick as its persona emoji (the `list_emojis`
+     * tool): its current status set with where each value comes from, the
+     * standard emojis its platform takes, and on Discord the server emojis its
+     * bot can draw on — the same lists, and the same resolution, as the
+     * Settings picker (#1005/#1021), so an agent and an operator see one truth.
+     */
+    async listEmojisFor(instanceName, refresh = false) {
+        const self = this.fleetConfig?.instances[instanceName];
+        if (!self)
+            return { error: this.personaEmojiMissing(instanceName) };
+        const worldId = this.getInstanceAdapterId(instanceName);
+        const { platform } = this.resolveStatusEmojisFor(instanceName);
+        const channel = (worldId ? this.worlds.get(worldId)?.channelConfig : undefined) ?? this.getChannelConfig(worldId ?? undefined);
+        const current = previewStatusEmojis({ platform, platformConfig: channel?.options?.status_emojis, instanceConfig: self.status_emojis });
+        const out = {
+            platform: platform ?? null,
+            statuses: current.entries.map(e => ({ status: e.key, value: e.value, source: e.source })),
+            standard: platform === "telegram"
+                ? { reactions: [...TELEGRAM_REACTION_EMOJIS], note: "Telegram reacts only with these; progress_prefix may be any single emoji" }
+                : { suggestions: STATUS_EMOJI_SUGGESTIONS, note: "any single emoji works" },
+        };
+        if (platform === "discord" && worldId) {
+            const listed = await this.listGuildEmojis(worldId, refresh);
+            out.server_emojis = listed.ok
+                ? listed.guilds.map(g => g.emojis
+                    ? {
+                        server: g.name || g.id, primary: g.primary,
+                        emojis: g.emojis.filter(e => e.available).map(e => {
+                            const value = customEmojiValue(e);
+                            return { value, image_url: emojiImageUrl(value) };
+                        }),
+                    }
+                    : { server: g.name || g.id, primary: g.primary, error: g.error })
+                : { error: listed.error };
+        }
+        return out;
+    }
+    /**
+     * `preview_emojis` (#1040): download a few Discord server emojis so an agent
+     * can look at them before it picks one — a name and an id say nothing about
+     * what an emoji looks like. The fleet fetches, not the agent (not every
+     * backend can), and returns a local path per emoji to Read, as
+     * download_attachment does for an attachment.
+     *
+     * SSRF-safe by construction: nothing from the caller reaches a URL. The
+     * caller names emojis; each must be an available one in a server this bot
+     * can draw on (the list set_persona_emoji checks), and the CDN URL is built
+     * from that listed emoji's numeric id. Static PNG, size-capped, cached by id.
+     */
+    async previewEmojis(instanceName, args) {
+        const self = this.fleetConfig?.instances[instanceName];
+        if (!self)
+            return { error: this.personaEmojiMissing(instanceName) };
+        const wanted = args.emojis;
+        if (!Array.isArray(wanted) || wanted.length === 0 || wanted.some(e => typeof e !== "string")) {
+            return { error: "emojis is required: a list of <:name:id> values from list_emojis" };
+        }
+        if (wanted.length > FleetManager.EMOJI_PREVIEW_MAX) {
+            return { error: `at most ${FleetManager.EMOJI_PREVIEW_MAX} at a time: narrow them down by name first` };
+        }
+        const { platform } = this.resolveStatusEmojisFor(instanceName);
+        const worldId = this.getInstanceAdapterId(instanceName);
+        if (platform !== "discord" || !worldId) {
+            return { error: "only Discord server emojis need a preview; standard emojis are what they look like" };
+        }
+        const listed = await this.listGuildEmojis(worldId);
+        if (!listed.ok)
+            return { error: `cannot list this bot's server emojis: ${listed.error}` };
+        const previews = [];
+        const errors = [];
+        for (const raw of wanted) {
+            const e = normalizeEmoji(raw);
+            if (e?.kind !== "custom") {
+                errors.push({ emoji: raw, error: "not a server emoji (a standard emoji needs no preview)" });
+                continue;
+            }
+            const found = listed.emojis.find(g => g.id === e.id);
+            if (!found?.available) {
+                errors.push({ emoji: raw, error: "not a server emoji this bot can use" });
+                continue;
+            }
+            try {
+                previews.push({ emoji: customEmojiValue(found), path: await this.fetchEmojiPreview(found.id) });
+            }
+            catch (err) {
+                errors.push({ emoji: raw, error: `download failed: ${err.message}` });
+            }
+        }
+        return { previews, errors, note: "Read each path to see the emoji (a static PNG)." };
+    }
+    static EMOJI_PREVIEW_MAX = 8;
+    static EMOJI_PREVIEW_MAX_BYTES = 256 * 1024;
+    static EMOJI_PREVIEW_TTL_MS = 24 * 60 * 60_000;
+    /** One emoji's static PNG under the inbox, reused while fresh; stale ones are pruned. */
+    async fetchEmojiPreview(id) {
+        if (!/^\d{15,25}$/.test(id))
+            throw new Error("not a Discord emoji id");
+        const dir = join(this.dataDir, "inbox", "emoji-previews");
+        mkdirSync(dir, { recursive: true });
+        const now = Date.now();
+        for (const name of readdirSync(dir)) {
+            try {
+                if (now - statSync(join(dir, name)).mtimeMs > FleetManager.EMOJI_PREVIEW_TTL_MS)
+                    unlinkSync(join(dir, name));
+            }
+            catch { /* raced */ }
+        }
+        const path = join(dir, `${id}.png`);
+        if (existsSync(path))
+            return path;
+        const response = await fetch(`https://cdn.discordapp.com/emojis/${id}.png?size=96`, { signal: AbortSignal.timeout(10_000), redirect: "error" });
+        if (!response.ok)
+            throw new Error(`HTTP ${response.status}`);
+        if (!/^image\/png\b/.test(response.headers.get("content-type") ?? ""))
+            throw new Error("not a PNG");
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error("empty response");
+        const chunks = [];
+        let size = 0;
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > FleetManager.EMOJI_PREVIEW_MAX_BYTES) {
+                await reader.cancel();
+                throw new Error("image too large");
+            }
+            chunks.push(value);
+        }
+        const tmp = `${path}.${process.pid}.tmp`;
+        writeFileSync(tmp, Buffer.concat(chunks));
+        renameSync(tmp, path);
+        return path;
+    }
+    /**
+     * `set_persona_emoji`: `instanceName` sets one of its own status emojis —
+     * `delivered` unless it names another — in its per-instance `status_emojis`
+     * override (#1005 addendum 2), so its stamp is told apart from other bots'
+     * on a shared message. The value is judged exactly as Settings and the
+     * react path judge it (statusEmojiProblem on the instance's platform), and
+     * a Discord server emoji must be one its bot can use: an emoji from a
+     * server it is not in would be stored, preview fine, and fail every react.
+     * An empty emoji removes that status's override.
+     */
+    async setPersonaEmoji(instanceName, args) {
+        const self = this.fleetConfig?.instances[instanceName];
+        if (!self)
+            return { error: this.personaEmojiMissing(instanceName) };
+        const status = (args.status ?? "delivered");
+        if (!STATUS_EMOJI_CONFIG_KEYS.includes(status)) {
+            return { error: `status must be one of ${STATUS_EMOJI_CONFIG_KEYS.join(", ")}` };
+        }
+        // Only an explicit "" removes the override. The agent endpoint, typed IPC
+        // and agent-cli do not run the MCP schema, so a call missing `emoji` must
+        // be refused here, never read as "clear my delivered stamp".
+        if (typeof args.emoji !== "string") {
+            return { error: 'emoji is required: one emoji, a <:name:id> from list_emojis, or "" to remove your override' };
+        }
+        const raw = args.emoji.trim();
+        // Whitespace is not an explicit "": a stray " " must not clear the stamp either.
+        if (!raw && args.emoji !== "") {
+            return { error: 'emoji is blank: pass one emoji, a <:name:id> from list_emojis, or exactly "" to remove your override' };
+        }
+        let value;
+        if (raw) {
+            const { platform } = this.resolveStatusEmojisFor(instanceName);
+            const problem = statusEmojiProblem(platform, status, raw);
+            if (problem)
+                return { error: `${problem}. Call list_emojis for what ${platform ?? "this channel"} accepts.` };
+            const e = normalizeEmoji(raw);
+            if (e.kind === "custom") {
+                const worldId = this.getInstanceAdapterId(instanceName);
+                if (!worldId)
+                    return { error: "no connection to check that server emoji against" };
+                const listed = await this.listGuildEmojis(worldId);
+                if (!listed.ok)
+                    return { error: `cannot check that server emoji: ${listed.error}` };
+                const found = listed.emojis.find(g => g.id === e.id);
+                if (!found?.available) {
+                    return { error: `${raw} is not a server emoji this bot can use${found ? " (Discord marks it unavailable)" : ""}. Call list_emojis for the ones it can.` };
+                }
+                value = customEmojiValue(found);
+            }
+            else {
+                value = e.value;
+            }
+        }
+        // Re-read after the validation above, which may have waited on Discord:
+        // another set_persona_emoji or a Settings save can have changed another
+        // status, or replaced this instance's config object, meanwhile. Change
+        // only this one key on what is there now.
+        const current = this.fleetConfig?.instances[instanceName];
+        if (!current)
+            return { error: this.personaEmojiMissing(instanceName) };
+        const map = { ...(current.status_emojis ?? {}) };
+        if (value)
+            map[status] = value;
+        else
+            delete map[status];
+        if (Object.keys(map).length)
+            current.status_emojis = map;
+        else
+            delete current.status_emojis;
+        this.saveFleetConfig();
+        this.logger.info({ instanceName, status, value: value ?? null }, value ? "Persona emoji set" : "Persona emoji cleared");
+        const resolved = this.resolveStatusEmojisFor(instanceName);
+        return { status, value: value ?? null, now: resolved[status], status_emojis: current.status_emojis ?? null };
+    }
+    personaEmojiMissing(instanceName) {
+        return this.classicChannels?.getAll().some(c => c.instanceName === instanceName)
+            ? "ClassicBot instances have no per-instance status emojis; an operator sets the connection's in Settings"
+            : `Instance '${instanceName}' not found`;
+    }
     /** What the instructions tell `instanceName` not to react with (its own status set). */
     statusEmojiAvoidList(instanceName) {
         return statusAvoidList(this.resolveStatusEmojisFor(instanceName));
@@ -10325,6 +10600,32 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         catch { /* missing / stale / corrupt */ }
         return null;
     }
+    /** Return cached CLI versions immediately. Refresh is started after /sysinfo is sent. */
+    getBackendCliVersionSnapshot() {
+        const snapshot = {};
+        for (const backend of SYSINFO_BACKEND_IDS) {
+            const cached = this.readCliEnv(backend);
+            const needsRefresh = this.cliEnvNeedsRefresh(cached);
+            const version = typeof cached?.version === "string" && cached.version.trim()
+                ? cached.version.trim()
+                : null;
+            snapshot[backend] = {
+                version,
+                probing: needsRefresh && version === null,
+            };
+        }
+        return snapshot;
+    }
+    /** Called only after the user-visible sysinfo send/respond has settled. */
+    refreshBackendCliVersions() {
+        for (const backend of SYSINFO_BACKEND_IDS) {
+            if (!this.cliEnvNeedsRefresh(this.readCliEnv(backend)))
+                continue;
+            void this.probeBackendBounded(backend, { nonBlocking: true }).catch(err => {
+                this.logger.debug({ err, backend }, "Background CLI version refresh failed");
+            });
+        }
+    }
     /** True when a cached CLI env is old enough that `/model` should re-probe. */
     cliEnvNeedsRefresh(env) {
         return !env || typeof env.probedAt !== "number" || Date.now() - env.probedAt >= CLI_ENV_FRESH_MS;
@@ -10335,33 +10636,97 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
      * previous list, never stall the command that asked for it.
      */
     async probeBackendBounded(backend, opts = {}) {
-        // #725: single-flight per backend — if a probe for this backend is already
-        // in flight, return the same promise instead of starting a duplicate.
-        // Refresh probes (refreshVendorCatalog=true) are always started fresh since
-        // the caller explicitly asked for a new vendor fetch.
-        if (!opts.refreshVendorCatalog) {
-            const existing = this.pendingCliEnvProbes.get(backend);
-            if (existing)
-                return existing;
-        }
-        const work = this.probeBackend(backend, opts);
+        // #725: single-flight per backend. Explicit vendor refreshes remain a
+        // separate flight from an ordinary probe, while sysinfo can join either.
+        const regularFlight = this.pendingCliEnvProbes.get(backend);
+        const vendorFlight = this.pendingVendorCliEnvProbes.get(backend);
+        if (opts.refreshVendorCatalog && vendorFlight)
+            return vendorFlight;
+        if (!opts.refreshVendorCatalog && (vendorFlight || regularFlight))
+            return vendorFlight ?? regularFlight;
+        const worker = opts.nonBlocking ? this.startCliEnvProbeWorker(backend, opts) : undefined;
+        const work = worker?.promise ?? this.probeBackend(backend, opts);
         work.catch(() => { });
         let timer;
         const deadline = new Promise(resolve => {
             timer = setTimeout(() => {
+                worker?.terminate();
                 this.logger.warn({ backend, deadlineMs: CLI_ENV_PROBE_DEADLINE_MS }, "CLI env live probe exceeded its deadline — serving the cached model list");
                 resolve(null);
             }, CLI_ENV_PROBE_DEADLINE_MS);
         });
         const bounded = Promise.race([work, deadline]).finally(() => {
             clearTimeout(timer);
-            if (this.pendingCliEnvProbes.get(backend) === bounded)
-                this.pendingCliEnvProbes.delete(backend);
+            const flights = opts.refreshVendorCatalog ? this.pendingVendorCliEnvProbes : this.pendingCliEnvProbes;
+            if (flights.get(backend) === bounded)
+                flights.delete(backend);
         });
-        if (!opts.refreshVendorCatalog)
-            this.pendingCliEnvProbes.set(backend, bounded);
+        (opts.refreshVendorCatalog ? this.pendingVendorCliEnvProbes : this.pendingCliEnvProbes).set(backend, bounded);
         return bounded;
     }
+    startCliEnvProbeWorker(backend, opts) {
+        const workerData = {
+            backend,
+            instanceDir: join(getAgendHome(), "cli-env"),
+            config: {
+                workingDirectory: "",
+                instanceDir: join(getAgendHome(), "cli-env"),
+                instanceName: `probe-${backend}`,
+                mcpServers: {},
+            },
+            refreshVendorCatalog: opts.refreshVendorCatalog === true,
+        };
+        // `tsx src/cli.ts` needs its TS module resolver inside the separate isolate.
+        // Published builds load the compiled worker and require no tsx dependency.
+        const worker = import.meta.url.endsWith(".ts")
+            ? new Worker(`const { workerData } = require("node:worker_threads"); import("tsx/esm/api").then(({ tsImport }) => tsImport(workerData.entry, workerData.entry));`, { eval: true, execArgv: [], workerData: { ...workerData, entry: new URL("./backend/cli-env-probe-worker.ts", import.meta.url).href } })
+            : new Worker(new URL("./backend/cli-env-probe-worker.js", import.meta.url), { execArgv: [], workerData });
+        let settled = false;
+        let resolveProbe;
+        const promise = new Promise(resolve => { resolveProbe = resolve; });
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            resolveProbe(value);
+            void worker.terminate().catch(err => {
+                this.logger.debug({ backend, err }, "CLI env worker termination failed");
+            });
+        };
+        worker.once("message", (message) => {
+            if (settled)
+                return;
+            if (!message.ok) {
+                this.logger.warn({ backend, error: message.error }, "CLI env worker failed");
+                finish(null);
+            }
+            else if (!message.result) {
+                finish(null);
+            }
+            else {
+                try {
+                    finish(this.persistCliEnvProbeResult(backend, message.result));
+                }
+                catch (err) {
+                    this.logger.warn({ backend, err }, "CLI env cache write failed");
+                    finish(null);
+                }
+            }
+        });
+        worker.once("error", err => {
+            if (settled)
+                return;
+            this.logger.warn({ backend, err }, "CLI env worker crashed");
+            finish(null);
+        });
+        worker.once("exit", code => {
+            if (settled)
+                return;
+            this.logger.warn({ backend, code }, "CLI env worker exited without a result");
+            finish(null);
+        });
+        return { promise, terminate: () => { finish(null); } };
+    }
     /**
      * Resolve the effective model for a fleet or ClassicBot instance, plus where it
      * came from. Single source of truth for `/model` and `/ctx` — precedence:
@@ -10428,35 +10793,39 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             if (opts.refreshVendorCatalog && be.refreshModelCatalog)
                 await be.refreshModelCatalog();
             const probed = await be.probeCLIEnv({ workingDirectory: "", instanceDir: join(getAgendHome(), "cli-env"), instanceName: `probe-${backend}`, mcpServers: {} });
-            const env = { backend, probedAt: Date.now(), ...probed };
-            // An empty result must never overwrite a catalog we already have. Some
-            // probes hit the network (`agy models` fetches, 5s cap), so a slow moment
-            // returns [] — and writing that would blank the list for the whole 24h
-            // TTL, long after the CLI recovered. Observed live: a good 11-model
-            // antigravity cache replaced by an empty one. Keep the known models and
-            // let the fresher currentModel/version through.
-            if (!env.models?.length) {
-                const previous = this.readCliEnv(backend);
-                if (previous?.models?.length)
-                    env.models = previous.models;
-            }
-            // Same protection for the extended catalog: one offline moment must not
-            // blank a good account list for the whole cache TTL.
-            if (!env.apiModels?.length) {
-                const previous = this.readCliEnv(backend);
-                if (previous?.apiModels?.length)
-                    env.apiModels = previous.apiModels;
-            }
-            const path = this.cliEnvPath(backend);
-            mkdirSync(dirname(path), { recursive: true });
-            writeFileSync(path, JSON.stringify(env, null, 2));
-            return env;
+            return this.persistCliEnvProbeResult(backend, probed);
         }
         catch (err) {
             this.logger.warn({ err, backend }, "CLI env probe failed");
             return null;
         }
     }
+    /** Preserve the existing cache merge rules for both in-process and worker probes. */
+    persistCliEnvProbeResult(backend, probed) {
+        const env = { backend, probedAt: Date.now(), ...probed };
+        // An empty result must never overwrite a catalog we already have. Some
+        // probes hit the network (`agy models` fetches, 5s cap), so a slow moment
+        // returns [] — and writing that would blank the list for the whole 24h
+        // TTL, long after the CLI recovered. Observed live: a good 11-model
+        // antigravity cache replaced by an empty one. Keep the known models and
+        // let the fresher currentModel/version through.
+        if (!env.models?.length) {
+            const previous = this.readCliEnv(backend);
+            if (previous?.models?.length)
+                env.models = previous.models;
+        }
+        // Same protection for the extended catalog: one offline moment must not
+        // blank a good account list for the whole cache TTL.
+        if (!env.apiModels?.length) {
+            const previous = this.readCliEnv(backend);
+            if (previous?.apiModels?.length)
+                env.apiModels = previous.apiModels;
+        }
+        const path = this.cliEnvPath(backend);
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, JSON.stringify(env, null, 2));
+        return env;
+    }
     /** Background-probe every distinct backend in use at startup (non-blocking). */
     probeCliEnvs() {
         const backends = new Set();