@songsid/agend 2.1.4-beta.12 → 2.1.4-beta.14

package/dist/fleet-manager.d.ts

@@ -36,6 +36,25 @@ export declare function selectLruEvictions(warm: string[], cap: number, opts: {
     isIdle: (name: string) => boolean;
     lastInboundAt: (name: string) => number;
 }): string[];
+/**
+ * Answer shape for `list_models`. `scope` reports where the LIST came from —
+ * "instance" only when it was read through that instance's own backend config,
+ * "global" for the account/CLI catalog — so a caller can tell an authoritative
+ * per-instance list from a best-effort account-wide one.
+ */
+export interface ModelCatalog {
+    backend: string;
+    scope: "instance" | "global";
+    /** Set whenever an instance was asked about, even if the list is global. */
+    instance?: string;
+    current_model: string | null;
+    models: import("./backend/types.js").ModelOption[];
+    /** "cache" = startup probe cache, "live" = probed now, "fallback" = none available. */
+    source: "cache" | "live" | "fallback";
+    probed_at?: string;
+    /** Caveat the caller should read before trusting the list. */
+    note?: string;
+}
 export interface DeliveryOptions {
     /** Explicitly identify agent-to-agent delivery when metadata is unavailable. */
     isCrossInstance?: boolean;
@@ -471,9 +490,13 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private startTopicCleanupPoller;
     /**
      * Patch only values changed in the effective config into the original YAML
-     * document. Unknown keys, explicit overrides and comments remain untouched.
+     * document. Unknown keys and comments remain untouched; redundant
+     * non-identity instance leaves are canonicalized to inheritance afterward.
      */
     saveFleetConfig(explicitPatches?: RawConfigPatch[]): void;
+    /** One-time upgrade migration; invalid YAML is never rewritten. */
+    private slimFleetConfigAtStartup;
+    private writeFleetConfigBackup;
     private patchFleetDocument;
     removeInstance(name: string): Promise<void>;
     startStatuslineWatcher(name: string): void;
@@ -844,6 +867,34 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private probeCliEnvs;
     /** Best-effort model list for `/model`: cached CLI env first, else live probe. Never throws. */
     private getModelOptions;
+    /**
+     * Model catalog behind the `list_models` tool.
+     *
+     * The two scopes are not cosmetic. "global" is the account/CLI catalog served
+     * from the startup probe cache; "instance" is resolved through that instance's
+     * OWN backend config, and for a Codex instance on a custom provider that is a
+     * different catalog entirely — `listModels()` reads models_cache.json out of
+     * the instance's private CODEX_HOME. Answering such an instance with the
+     * account list would name models its CLI rejects, which is exactly the
+     * mistake this tool exists to prevent.
+     *
+     * `scope` always describes where the returned LIST came from, not what was
+     * asked for: an instance query that falls back to the account catalog reports
+     * scope "global" and says so in `note`, rather than implying instance-level
+     * accuracy it does not have.
+     *
+     * Never throws — a model listing is an aid, and failing it must not fail a turn.
+     */
+    listModelCatalog(opts?: {
+        backend?: string;
+        instanceName?: string;
+    }): Promise<ModelCatalog>;
+    /** The custom provider an instance overrides its backend with, if any. */
+    private customProviderFor;
+    /** Ask a backend for its catalog using ONE instance's real config. Never throws. */
+    private instanceScopedModels;
+    /** Account-wide catalog: probe cache first, live probe on miss. */
+    private globalModelCatalog;
     /** `/model` slash handler (admin only). No arg → DC menu; `/model <name>` → apply directly. */
     /** Label an effort choice, marking the one currently configured. */
     private effortChoiceLabel;

package/dist/fleet-manager.js

@@ -9,7 +9,7 @@ import { formatUpdateProgress } from "./update-progress.js";
 import { sdNotify, sdNotifyBlocking } from "./sd-notify.js";
 import { readFleetMemory } from "./process-memory.js";
 import { ReplyDeduper } from "./reply-dedup.js";
-import { isScalar, parseDocument } from "yaml";
+import { isMap, isScalar, parseDocument } from "yaml";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /** Fallback access policy for a channel with no `access:` block — open (no gate). */
@@ -54,6 +54,7 @@ import { releaseProcessFleetLock } from "./fleet-lock.js";
 import { GENERAL_PAUSE_ERROR, isGeneralInstance } from "./general-instance.js";
 import { loadOrCreateWebToken, WEB_TOKEN_INVALID_MESSAGE } from "./web-auth.js";
 import { RestartProgress } from "./restart-progress.js";
+import { collectRedundantInstanceDefaultPaths } from "./fleet-yaml-slim.js";
 import { getTmuxSession } from "./config.js";
 export function resolveReplyThreadId(argsThreadId, instanceConfig) {
     if (typeof argsThreadId === "string" && argsThreadId.length > 0) {
@@ -1453,6 +1454,7 @@ export class FleetManager {
         // Rotate fleet.log if oversized (before any logging)
         rotateLogIfNeeded(join(this.dataDir, "fleet.log"));
         const fleet = this.loadConfig(configPath);
+        this.slimFleetConfigAtStartup();
         setLocale(detectLocale(fleet)); // user-facing text language (fleet.yaml defaults.locale / timezone)
         const savedUpdateProgress = readUpdateProgress(this.dataDir);
         const pendingUpdateProgress = savedUpdateProgress
@@ -4229,7 +4231,8 @@ export class FleetManager {
     }
     /**
      * Patch only values changed in the effective config into the original YAML
-     * document. Unknown keys, explicit overrides and comments remain untouched.
+     * document. Unknown keys and comments remain untouched; redundant
+     * non-identity instance leaves are canonicalized to inheritance afterward.
      */
     saveFleetConfig(explicitPatches = []) {
         if (!this.fleetConfig || !this.configPath)
@@ -4245,9 +4248,9 @@ export class FleetManager {
         }
         this.rawFleetConfig = loadRawFleetConfig(this.configPath);
         this.patchFleetDocument(this.rawFleetDocument, [], this.savedFleetConfigSnapshot, this.fleetConfig);
-        // Settings edits are expressed against the raw config. Persist them even
-        // when the chosen override equals the inherited effective value, a case
-        // the before/after runtime diff cannot observe.
+        // Settings edits are expressed against the raw config, so apply them before
+        // canonicalization. A non-identity value equal to its inherited default is
+        // intentionally stored as inheritance rather than an explicit duplicate.
         for (const patch of explicitPatches) {
             if (patch.remove) {
                 // YAML's deleteIn throws when an inherited nested key has no raw parent
@@ -4262,7 +4265,24 @@ export class FleetManager {
                 this.patchFleetDocument(this.rawFleetDocument, patch.path, before, patch.value);
             }
         }
+        const rawAfterPatches = this.rawFleetDocument.toJS();
+        const redundantPaths = collectRedundantInstanceDefaultPaths(rawAfterPatches);
+        for (const path of redundantPaths) {
+            if (this.rawFleetDocument.hasIn(path))
+                this.rawFleetDocument.deleteIn(path);
+            // Avoid leaving empty operational maps such as `terminal: {}` while
+            // preserving the instance mapping itself and all surrounding comments.
+            for (let depth = path.length - 1; depth > 2; depth--) {
+                const parentPath = path.slice(0, depth);
+                const parent = this.rawFleetDocument.getIn(parentPath, true);
+                if (!isMap(parent) || parent.items.length > 0)
+                    break;
+                this.rawFleetDocument.deleteIn(parentPath);
+            }
+        }
         const output = String(this.rawFleetDocument);
+        if (redundantPaths.length > 0)
+            this.writeFleetConfigBackup(source);
         const tempPath = `${this.configPath}.tmp-${process.pid}`;
         writeFileSync(tempPath, output, "utf-8");
         if (existsSync(this.configPath))
@@ -4270,7 +4290,36 @@ export class FleetManager {
         renameSync(tempPath, this.configPath);
         this.rawFleetConfig = loadRawFleetConfig(this.configPath);
         this.savedFleetConfigSnapshot = structuredClone(this.fleetConfig);
-        this.logger.info({ path: this.configPath }, "Saved fleet config (lossless patch)");
+        this.logger.info({ path: this.configPath, strippedDefaults: redundantPaths.length }, "Saved fleet config (lossless patch)");
+    }
+    /** One-time upgrade migration; invalid YAML is never rewritten. */
+    slimFleetConfigAtStartup() {
+        const redundantPaths = collectRedundantInstanceDefaultPaths(this.rawFleetConfig);
+        if (redundantPaths.length === 0)
+            return;
+        const validation = validateFleetConfig(this.rawFleetConfig);
+        if (!validation.valid) {
+            this.logger.warn({ errors: validation.errors, redundantDefaults: redundantPaths.length }, "Skipping fleet.yaml default slimming because the raw config is invalid");
+            return;
+        }
+        try {
+            this.saveFleetConfig();
+            this.logger.info({ strippedDefaults: redundantPaths.length, backup: `${this.configPath}.bak` }, "Slimmed redundant instance defaults in fleet.yaml");
+        }
+        catch (err) {
+            // A migration must not turn a previously bootable fleet into an outage.
+            this.logger.warn({ err }, "Could not slim fleet.yaml; continuing with the original config");
+        }
+    }
+    writeFleetConfigBackup(source) {
+        if (!this.configPath)
+            return;
+        const backupPath = `${this.configPath}.bak`;
+        const tempPath = `${backupPath}.tmp-${process.pid}`;
+        writeFileSync(tempPath, source, "utf-8");
+        if (existsSync(this.configPath))
+            chmodSync(tempPath, statSync(this.configPath).mode);
+        renameSync(tempPath, backupPath);
     }
     patchFleetDocument(document, path, before, after) {
         if (Object.is(before, after))
@@ -4322,7 +4371,12 @@ export class FleetManager {
                 currentNode.value = after;
             }
             else {
-                document.setIn(path, after);
+                // Use a YAML collection node for newly-added objects. Passing the raw
+                // object creates a scalar wrapper: it serializes, but nested hasIn /
+                // deleteIn cannot traverse it (notably when slimming create_instance).
+                document.setIn(path, after !== null && typeof after === "object"
+                    ? document.createNode(after)
+                    : after);
             }
         }
     }
@@ -6403,6 +6457,17 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 return null;
             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;
+            }
             const path = this.cliEnvPath(backend);
             mkdirSync(dirname(path), { recursive: true });
             writeFileSync(path, JSON.stringify(env, null, 2));
@@ -6441,6 +6506,108 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         const env = await this.probeBackend(backendName);
         return env?.models ?? [];
     }
+    /**
+     * Model catalog behind the `list_models` tool.
+     *
+     * The two scopes are not cosmetic. "global" is the account/CLI catalog served
+     * from the startup probe cache; "instance" is resolved through that instance's
+     * OWN backend config, and for a Codex instance on a custom provider that is a
+     * different catalog entirely — `listModels()` reads models_cache.json out of
+     * the instance's private CODEX_HOME. Answering such an instance with the
+     * account list would name models its CLI rejects, which is exactly the
+     * mistake this tool exists to prevent.
+     *
+     * `scope` always describes where the returned LIST came from, not what was
+     * asked for: an instance query that falls back to the account catalog reports
+     * scope "global" and says so in `note`, rather than implying instance-level
+     * accuracy it does not have.
+     *
+     * Never throws — a model listing is an aid, and failing it must not fail a turn.
+     */
+    async listModelCatalog(opts = {}) {
+        const { instanceName } = opts;
+        if (instanceName) {
+            const backend = this.backendNameForInstance(instanceName);
+            const resolved = this.resolveInstanceModel(instanceName);
+            const currentModel = resolved.source === "unresolved" ? null : resolved.model;
+            const provider = this.customProviderFor(instanceName, backend);
+            const scoped = await this.instanceScopedModels(instanceName, backend);
+            if (scoped.length) {
+                return {
+                    backend, scope: "instance", instance: instanceName,
+                    current_model: currentModel, models: scoped, source: "live",
+                    ...(provider ? { note: `Catalog read through this instance's ${backend} provider "${provider}" — it may differ from the account catalog.` } : {}),
+                };
+            }
+            // No instance-local catalog (never launched, or the backend has no
+            // per-instance list). The account catalog is the best available answer,
+            // but it is labelled honestly rather than dressed up as instance scope.
+            const global = await this.globalModelCatalog(backend);
+            return {
+                ...global, instance: instanceName, current_model: currentModel,
+                note: provider
+                    ? `No instance-local catalog yet; showing the account catalog, which may NOT match this instance's ${backend} provider "${provider}".`
+                    : "No instance-local catalog yet; showing the account catalog.",
+            };
+        }
+        return this.globalModelCatalog(opts.backend ?? this.fleetConfig?.defaults?.backend ?? "claude-code");
+    }
+    /** The custom provider an instance overrides its backend with, if any. */
+    customProviderFor(instanceName, backend) {
+        const opts = this.fleetConfig?.instances?.[instanceName]?.backend_options?.[backend]
+            ?? this.fleetConfig?.defaults?.backend_options?.[backend];
+        const provider = opts?.provider;
+        return typeof provider === "string" && provider.trim() ? provider.trim() : null;
+    }
+    /** Ask a backend for its catalog using ONE instance's real config. Never throws. */
+    async instanceScopedModels(instanceName, backend) {
+        try {
+            const inst = this.fleetConfig?.instances?.[instanceName];
+            const instanceDir = this.getInstanceDir(instanceName);
+            const be = createBackend(backend, instanceDir);
+            if (!be.listModels)
+                return [];
+            return await be.listModels({
+                workingDirectory: inst?.working_directory ?? "",
+                instanceDir,
+                instanceName,
+                mcpServers: {},
+                model: inst?.model,
+                backendOptions: inst?.backend_options?.[backend] ?? this.fleetConfig?.defaults?.backend_options?.[backend],
+            }) ?? [];
+        }
+        catch {
+            // listModels is documented never to throw, but a backend constructor can
+            // (missing binary). A catalog is an aid; degrade to the account list.
+            return [];
+        }
+    }
+    /** Account-wide catalog: probe cache first, live probe on miss. */
+    async globalModelCatalog(backend) {
+        const cached = this.readCliEnv(backend);
+        if (cached?.models?.length) {
+            return {
+                backend, scope: "global", current_model: cached.currentModel ?? null,
+                models: cached.models, source: "cache",
+                probed_at: new Date(cached.probedAt).toISOString(),
+            };
+        }
+        const env = await this.probeBackend(backend);
+        if (env?.models?.length) {
+            return {
+                backend, scope: "global", current_model: env.currentModel ?? null,
+                models: env.models, source: "live",
+                probed_at: new Date(env.probedAt).toISOString(),
+            };
+        }
+        // Reported rather than thrown: "we could not enumerate" is a useful answer,
+        // and the caller can still set a model by name (AgEnD passes it through).
+        return {
+            backend, scope: "global", current_model: env?.currentModel ?? null,
+            models: [], source: "fallback",
+            note: `Could not enumerate models for ${backend} (CLI missing, not logged in, or it offers no list). Model names are passed through to the CLI, so a known-good name still works.`,
+        };
+    }
     /** `/model` slash handler (admin only). No arg → DC menu; `/model <name>` → apply directly. */
     /** Label an effort choice, marking the one currently configured. */
     effortChoiceLabel(level, current) {