@phnx-labs/agents-cli 1.20.28 → 1.20.30

package/dist/lib/devices/registry.d.ts

@@ -0,0 +1,78 @@
+/** Operating-system family of a device, used to pick the remote shell. */
+export type DevicePlatform = 'windows' | 'linux' | 'macos' | 'unknown';
+/** Remote shell dialect derived from the platform. */
+export type DeviceShell = 'powershell' | 'posix';
+/** How `agents ssh` authenticates to a device. Both are first-class, fully
+ * non-interactive: `key` uses the ssh agent / on-disk keys, `password` pulls
+ * the secret from a Keychain-backed secrets bundle via an askpass shim. */
+export type DeviceAuthMethod = 'key' | 'password';
+/** How to reach a device on the network. */
+export interface DeviceAddress {
+    /** Where the address came from: a Tailscale node, or a manual entry. */
+    via: 'tailscale' | 'manual';
+    /** Fully-qualified DNS name (Tailscale MagicDNS), without a trailing dot. */
+    dnsName?: string;
+    /** Raw IP address (IPv4 preferred). */
+    ip?: string;
+}
+/** Authentication settings for a device. */
+export interface DeviceAuth {
+    method: DeviceAuthMethod;
+    /** Secrets bundle holding the password (when method === 'password'). */
+    bundle?: string;
+    /** Key within the bundle whose value is the password. Defaults to 'password'. */
+    bundleKey?: string;
+}
+/** Last-known Tailscale reachability snapshot for a device. */
+export interface DeviceTailscale {
+    online: boolean;
+    /** True when the last handshake was a direct (non-relayed) connection. */
+    direct: boolean;
+    /** DERP relay region code (e.g. 'sfo'); empty when direct. */
+    relay?: string;
+    lastSeen?: string;
+}
+/** A single registered device. */
+export interface DeviceProfile {
+    name: string;
+    platform: DevicePlatform;
+    shell: DeviceShell;
+    user?: string;
+    address: DeviceAddress;
+    auth: DeviceAuth;
+    tailscale?: DeviceTailscale;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Map of device name to profile. */
+export type DeviceRegistry = Record<string, DeviceProfile>;
+/** Throw if `name` is not usable as an ssh alias (no spaces, quotes, etc.). */
+export declare function assertValidDeviceName(name: string): void;
+/** Map a Tailscale `OS` field to our platform enum. */
+export declare function platformFromOs(os: string | undefined): DevicePlatform;
+/** The remote shell a platform speaks. */
+export declare function shellForPlatform(platform: DevicePlatform): DeviceShell;
+/**
+ * Load all devices from the registry file. Returns an empty object only when
+ * the file does not exist. A malformed file is a hard error — silently
+ * returning {} would let the next write wipe the user's device list.
+ */
+export declare function loadDevices(): Promise<DeviceRegistry>;
+/** Get a single device profile, or null if it is not registered. */
+export declare function getDevice(name: string): Promise<DeviceProfile | null>;
+/** Fields a caller may supply when creating or updating a device. */
+export interface DeviceInput {
+    platform?: DevicePlatform;
+    user?: string;
+    address?: DeviceAddress;
+    auth?: DeviceAuth;
+    tailscale?: DeviceTailscale;
+}
+/**
+ * Create the device if absent, otherwise merge the supplied fields into the
+ * existing profile. `shell` is always re-derived from the (possibly new)
+ * platform so the two can never drift. Returns the resulting profile.
+ */
+export declare function upsertDevice(name: string, input: DeviceInput): Promise<DeviceProfile>;
+/** Remove a device. Returns false if it was not registered. */
+export declare function removeDevice(name: string): Promise<boolean>;

package/dist/lib/devices/registry.js

@@ -0,0 +1,168 @@
+/**
+ * Device registry.
+ *
+ * Manages the persistent registry of SSH device profiles stored at
+ * ~/.agents/.history/devices/registry.json. Each profile records what we had
+ * to re-derive by hand the first time we reached a host: its platform (so we
+ * know PowerShell vs POSIX), the login user, how to address it (Tailscale
+ * DNS name / IP), and how to authenticate (pubkey, or a password pulled from
+ * a secrets bundle).
+ *
+ * Like the team registry this is per-machine runtime state (it embeds a host
+ * list + addresses) and lives under .history/ so it is NOT pulled in by
+ * `agents repo push`. The load/save/lock plumbing is a deliberate clone of
+ * src/lib/teams/registry.ts so the data-loss guarantees match exactly.
+ */
+import * as fs from 'fs/promises';
+import * as fsSync from 'fs';
+import * as path from 'path';
+import { randomBytes } from 'crypto';
+import lockfile from 'proper-lockfile';
+import { getDevicesRegistryPath } from '../state.js';
+function registryPath() {
+    return getDevicesRegistryPath();
+}
+/** Valid logical device name: the ssh-alias charset, so it renders into an
+ * unambiguous `Host` stanza and is safe as an ssh target. */
+const DEVICE_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+/** Throw if `name` is not usable as an ssh alias (no spaces, quotes, etc.). */
+export function assertValidDeviceName(name) {
+    if (!DEVICE_NAME_RE.test(name)) {
+        throw new Error(`Invalid device name ${JSON.stringify(name)}. Use letters, digits, '.', '_', '-' (no spaces) — e.g. 'win-mini'.`);
+    }
+}
+/** Map a Tailscale `OS` field to our platform enum. */
+export function platformFromOs(os) {
+    switch ((os ?? '').toLowerCase()) {
+        case 'windows':
+            return 'windows';
+        case 'linux':
+            return 'linux';
+        case 'macos':
+        case 'darwin':
+            return 'macos';
+        default:
+            return 'unknown';
+    }
+}
+/** The remote shell a platform speaks. */
+export function shellForPlatform(platform) {
+    return platform === 'windows' ? 'powershell' : 'posix';
+}
+/**
+ * Atomic JSON write: write to a unique sibling tmp file then rename over the
+ * target. rename(2) is atomic on POSIX, so a crashed write leaves the old file
+ * untouched instead of producing a half-written registry that loadDevices()
+ * would reject.
+ */
+async function atomicWriteJson(p, data) {
+    await fs.mkdir(path.dirname(p), { recursive: true });
+    const tmp = `${p}.tmp.${process.pid}.${randomBytes(4).toString('hex')}`;
+    await fs.writeFile(tmp, JSON.stringify(data, null, 2));
+    try {
+        await fs.rename(tmp, p);
+    }
+    catch (err) {
+        await fs.unlink(tmp).catch(() => { });
+        throw err;
+    }
+}
+/**
+ * Run `fn` while holding an exclusive cross-process lock on the registry file.
+ * proper-lockfile requires the target to exist, so we touch it first. Stale
+ * locks (from crashed callers) auto-expire after `stale` ms.
+ */
+async function withRegistryLock(p, fn) {
+    await fs.mkdir(path.dirname(p), { recursive: true });
+    if (!fsSync.existsSync(p)) {
+        try {
+            await fs.writeFile(p, '{}', { flag: 'wx' });
+        }
+        catch (err) {
+            if (err && err.code !== 'EEXIST')
+                throw err;
+        }
+    }
+    const release = await lockfile.lock(p, {
+        retries: { retries: 60, minTimeout: 25, maxTimeout: 250, factor: 1.5 },
+        stale: 10_000,
+    });
+    try {
+        return await fn();
+    }
+    finally {
+        await release();
+    }
+}
+/**
+ * Load all devices from the registry file. Returns an empty object only when
+ * the file does not exist. A malformed file is a hard error — silently
+ * returning {} would let the next write wipe the user's device list.
+ */
+export async function loadDevices() {
+    const p = registryPath();
+    let raw;
+    try {
+        raw = await fs.readFile(p, 'utf-8');
+    }
+    catch (err) {
+        if (err && err.code === 'ENOENT')
+            return {};
+        throw err;
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Device registry corrupted at ${p}: ${err?.message ?? err}. Inspect and restore from backup.`);
+    }
+}
+async function saveDevices(reg) {
+    await atomicWriteJson(registryPath(), reg);
+}
+/** Get a single device profile, or null if it is not registered. */
+export async function getDevice(name) {
+    const reg = await loadDevices();
+    return reg[name] ?? null;
+}
+/**
+ * Create the device if absent, otherwise merge the supplied fields into the
+ * existing profile. `shell` is always re-derived from the (possibly new)
+ * platform so the two can never drift. Returns the resulting profile.
+ */
+export async function upsertDevice(name, input) {
+    assertValidDeviceName(name);
+    const p = registryPath();
+    return withRegistryLock(p, async () => {
+        const reg = await loadDevices();
+        const now = new Date().toISOString();
+        const prev = reg[name];
+        const platform = input.platform ?? prev?.platform ?? 'unknown';
+        const merged = {
+            name,
+            platform,
+            shell: shellForPlatform(platform),
+            user: input.user ?? prev?.user,
+            address: input.address ?? prev?.address ?? { via: 'manual' },
+            auth: input.auth ?? prev?.auth ?? { method: 'key' },
+            tailscale: input.tailscale ?? prev?.tailscale,
+            createdAt: prev?.createdAt ?? now,
+            updatedAt: now,
+        };
+        reg[name] = merged;
+        await saveDevices(reg);
+        return merged;
+    });
+}
+/** Remove a device. Returns false if it was not registered. */
+export async function removeDevice(name) {
+    const p = registryPath();
+    return withRegistryLock(p, async () => {
+        const reg = await loadDevices();
+        if (!reg[name])
+            return false;
+        delete reg[name];
+        await saveDevices(reg);
+        return true;
+    });
+}

package/dist/lib/devices/ssh-config.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Render the device registry into an OpenSSH `ssh_config` include block.
+ *
+ * Writing a managed include (e.g. `~/.ssh/config.d/agents`) makes every tool
+ * that speaks ssh — plain `ssh`/`scp`/`rsync`/`git`, and `agents sessions
+ * --host` — resolve the registry's logical device names transparently, without
+ * each of them learning about the registry. `agents ssh` stays the value-add
+ * layer (preflight, password-from-bundle auth, platform-aware exec) on top.
+ *
+ * `renderSshConfig` is a pure function (registry in, config text out) so the
+ * exact rendering is unit-testable.
+ */
+import { type DeviceProfile, type DeviceRegistry } from './registry.js';
+/** The HostName an ssh client should dial for a device: DNS name first, then IP. */
+export declare function hostNameFor(device: DeviceProfile): string | undefined;
+/**
+ * Render the whole registry into ssh_config text. Devices are emitted in
+ * stable alphabetical order (so the file does not churn between runs) and
+ * addressless devices are skipped.
+ */
+export declare function renderSshConfig(reg: DeviceRegistry): string;

package/dist/lib/devices/ssh-config.js

@@ -0,0 +1,33 @@
+const HEADER = [
+    '# Managed by `agents devices` — do not edit by hand.',
+    '# Regenerate with: agents devices render',
+    '# Include from ~/.ssh/config with:  Include config.d/agents',
+].join('\n');
+/** The HostName an ssh client should dial for a device: DNS name first, then IP. */
+export function hostNameFor(device) {
+    return device.address.dnsName ?? device.address.ip;
+}
+/** Render a single device into an ssh_config `Host` stanza, or null if it has no address. */
+function renderHost(device) {
+    const hostName = hostNameFor(device);
+    if (!hostName)
+        return null;
+    const lines = [`Host ${device.name}`, `    HostName ${hostName}`];
+    if (device.user)
+        lines.push(`    User ${device.user}`);
+    return lines.join('\n');
+}
+/**
+ * Render the whole registry into ssh_config text. Devices are emitted in
+ * stable alphabetical order (so the file does not churn between runs) and
+ * addressless devices are skipped.
+ */
+export function renderSshConfig(reg) {
+    const stanzas = [];
+    for (const name of Object.keys(reg).sort()) {
+        const stanza = renderHost(reg[name]);
+        if (stanza)
+            stanzas.push(stanza);
+    }
+    return [HEADER, '', ...stanzas, ''].join('\n');
+}

package/dist/lib/devices/tailscale.d.ts

@@ -0,0 +1,31 @@
+import { type DeviceInput, type DevicePlatform } from './registry.js';
+/** A single node distilled from `tailscale status --json`. */
+export interface TailscaleNode {
+    name: string;
+    platform: DevicePlatform;
+    dnsName?: string;
+    ip?: string;
+    online: boolean;
+    direct: boolean;
+    relay?: string;
+    lastSeen?: string;
+}
+/**
+ * Slugify a raw Tailscale HostName into a valid logical device name (ssh alias
+ * charset). Used only as a fallback — when a node has a DNSName we prefer its
+ * first label, which is the canonical slug Tailscale itself derived.
+ */
+export declare function slugifyHostName(hostName: string): string;
+/**
+ * Parse `tailscale status --json` output into one node per tailnet device,
+ * including Self. Throws on malformed JSON. Nodes without a HostName are
+ * skipped (they cannot be addressed by a logical name).
+ */
+export declare function parseTailscaleStatus(json: string): TailscaleNode[];
+/** Turn a parsed Tailscale node into the registry fields it can populate. */
+export declare function nodeToDeviceInput(node: TailscaleNode): DeviceInput;
+/**
+ * Run `tailscale status --json` and return its raw stdout. Throws a clear
+ * error when the binary is missing or the daemon is not reachable.
+ */
+export declare function tailscaleStatusJson(): string;

package/dist/lib/devices/tailscale.js

@@ -0,0 +1,126 @@
+/**
+ * Tailscale ingestion for the device registry.
+ *
+ * `tailscale status --json` already hands us most of a device registry for
+ * free — per node: `OS` (→ platform), `Online`/`LastSeen` (→ reachability),
+ * `Relay` vs `CurAddr` (→ direct-vs-relayed latency hint), `DNSName`, and
+ * `TailscaleIPs`. `parseTailscaleStatus` turns that JSON into draft device
+ * profiles so `agents devices sync` can self-populate instead of you
+ * hand-entering hosts. Kept a pure function (JSON in, profiles out) so it is
+ * unit-testable without a live tailnet.
+ */
+import { spawnSync } from 'child_process';
+import { platformFromOs, } from './registry.js';
+/** Strip MagicDNS's trailing dot so the name is usable as an ssh HostName. */
+function trimDnsDot(dns) {
+    if (!dns)
+        return undefined;
+    return dns.endsWith('.') ? dns.slice(0, -1) : dns;
+}
+/** First IPv4 in the node's address list (preferred over IPv6 for ssh). */
+function firstIpv4(ips) {
+    if (!ips)
+        return undefined;
+    return ips.find((ip) => /^\d{1,3}(\.\d{1,3}){3}$/.test(ip)) ?? ips[0];
+}
+/**
+ * Slugify a raw Tailscale HostName into a valid logical device name (ssh alias
+ * charset). Used only as a fallback — when a node has a DNSName we prefer its
+ * first label, which is the canonical slug Tailscale itself derived.
+ */
+export function slugifyHostName(hostName) {
+    return hostName
+        .toLowerCase()
+        .replace(/['’"]/g, '') // drop quotes/apostrophes (so "Bisma's" → "bismas", matching MagicDNS)
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+/**
+ * The logical name for a node. macOS computer names contain spaces and
+ * apostrophes ("Bisma's MacBook Pro") and iOS devices all report HostName
+ * "localhost" — both break as ssh aliases and the latter collides in the
+ * registry. The MagicDNS label (first segment of DNSName) is already a unique,
+ * valid slug per device, so prefer it; fall back to a slugified HostName.
+ */
+function deviceNameFor(raw, dnsName) {
+    const label = dnsName?.split('.')[0];
+    if (label && label.length > 0)
+        return label;
+    const host = raw.HostName?.trim();
+    if (!host)
+        return null;
+    const slug = slugifyHostName(host);
+    return slug.length > 0 ? slug : null;
+}
+function toNode(raw) {
+    const dnsName = trimDnsDot(raw.DNSName);
+    const name = deviceNameFor(raw, dnsName);
+    if (!name)
+        return null;
+    // A non-empty CurAddr means the last handshake was a direct connection;
+    // an empty CurAddr with a Relay means traffic is going through DERP.
+    const direct = Boolean(raw.CurAddr && raw.CurAddr.length > 0);
+    return {
+        name,
+        platform: platformFromOs(raw.OS),
+        dnsName,
+        ip: firstIpv4(raw.TailscaleIPs),
+        online: Boolean(raw.Online),
+        direct,
+        relay: raw.Relay || undefined,
+        lastSeen: raw.LastSeen,
+    };
+}
+/**
+ * Parse `tailscale status --json` output into one node per tailnet device,
+ * including Self. Throws on malformed JSON. Nodes without a HostName are
+ * skipped (they cannot be addressed by a logical name).
+ */
+export function parseTailscaleStatus(json) {
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch (err) {
+        throw new Error(`Could not parse tailscale status JSON: ${err?.message ?? err}`);
+    }
+    const out = [];
+    if (parsed.Self) {
+        const self = toNode(parsed.Self);
+        if (self)
+            out.push(self);
+    }
+    for (const raw of Object.values(parsed.Peer ?? {})) {
+        const node = toNode(raw);
+        if (node)
+            out.push(node);
+    }
+    return out;
+}
+/** Turn a parsed Tailscale node into the registry fields it can populate. */
+export function nodeToDeviceInput(node) {
+    return {
+        platform: node.platform,
+        address: { via: 'tailscale', dnsName: node.dnsName, ip: node.ip },
+        tailscale: {
+            online: node.online,
+            direct: node.direct,
+            relay: node.relay,
+            lastSeen: node.lastSeen,
+        },
+    };
+}
+/**
+ * Run `tailscale status --json` and return its raw stdout. Throws a clear
+ * error when the binary is missing or the daemon is not reachable.
+ */
+export function tailscaleStatusJson() {
+    const res = spawnSync('tailscale', ['status', '--json'], { encoding: 'utf-8' });
+    if (res.error && res.error.code === 'ENOENT') {
+        throw new Error('tailscale not found on PATH. Install Tailscale, or add devices manually with `agents devices add`.');
+    }
+    if (res.status !== 0) {
+        throw new Error(`tailscale status failed: ${(res.stderr || res.stdout || '').trim() || `exit ${res.status}`}`);
+    }
+    return res.stdout ?? '';
+}

package/dist/lib/exec.js

@@ -534,6 +534,20 @@ export function buildExecCommand(options) {
             cmd.push('--dangerously-bypass-approvals-and-sandbox');
         }
     }
+    else if (options.agent === 'kimi' && !interactive) {
+        // kimi's headless prompt mode (`-p`/`--prompt`) is self-contained and REFUSES
+        // to be combined with any startup-mode flag: `--plan`, `--auto`, and `--yolo`
+        // all abort with "Cannot combine --prompt with --X" (verified against the live
+        // kimi CLI). The write-capable modes (edit/auto/skip) all collapse to kimi's
+        // default `-p` behavior, which already auto-approves tool calls, so we emit no
+        // mode flag. Plan (read-only) has no headless equivalent, so fail closed rather
+        // than silently letting a plan-mode run mutate the workspace.
+        if (resolvedMode === 'plan') {
+            throw new Error('kimi has no headless read-only mode: `--prompt` cannot be combined with `--plan`. ' +
+                'Run kimi in plan mode interactively (omit the prompt), or use --mode edit, auto, or skip.');
+        }
+        // edit/auto/skip: emit no mode flag — `kimi -p` auto-runs.
+    }
     else {
         cmd.push(...modeFlags);
     }

package/dist/lib/models.js

@@ -165,6 +165,26 @@ export function locateModelSource(agent, version) {
             return { path: pathBin, kind: 'cli' };
         return null;
     }
+    if (agent === 'antigravity') {
+        // The `agy` shim under node_modules/.bin exposes `agy models`. We don't parse
+        // any bundle; the CLI produces its own (display-name-only) catalog.
+        const cli = path.join(versionDir, 'node_modules', '.bin', 'agy');
+        if (fs.existsSync(cli))
+            return { path: cli, kind: 'cli' };
+        const pathBin = findOnPath('agy');
+        if (pathBin)
+            return { path: pathBin, kind: 'cli' };
+        return null;
+    }
+    if (agent === 'kimi') {
+        const cli = path.join(versionDir, 'node_modules', '.bin', 'kimi');
+        if (fs.existsSync(cli))
+            return { path: cli, kind: 'cli' };
+        const pathBin = findOnPath('kimi');
+        if (pathBin)
+            return { path: pathBin, kind: 'cli' };
+        return null;
+    }
     if (agent === 'cursor') {
         // cursor-agent is installed via curl script, not agents-cli. Version argument
         // is accepted for API symmetry but ignored -- cursor lives on PATH.
@@ -606,6 +626,114 @@ function extractOpenClawCatalog(binaryPath) {
     }));
     return { models, aliases: {} };
 }
+/**
+ * Extract Antigravity's catalog via `agy models`. Antigravity is unusual: it
+ * prints DISPLAY NAMES ONLY, one per line, with no machine ids and no --json:
+ *   Gemini 3.5 Flash (Medium)
+ *   Claude Sonnet 4.6 (Thinking)
+ * Verified (agy 1.0.11) that those display strings ARE the accepted `--model`
+ * values -- `agy --model "Claude Opus 4.6 (Thinking)"` routes to that model,
+ * and an unknown value silently falls back to the first row. So we use each
+ * display string as both id and displayName, and mark the first row default.
+ */
+function extractAntigravityCatalog(binaryPath) {
+    let stdout;
+    try {
+        stdout = execFileSync(binaryPath, ['models'], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 15_000,
+            maxBuffer: 8 * 1024 * 1024,
+        });
+    }
+    catch {
+        return { models: [], aliases: {} };
+    }
+    // Strip ANSI in case a spinner or color codes slip through.
+    // eslint-disable-next-line no-control-regex
+    const plain = stdout.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '');
+    const models = [];
+    const seen = new Set();
+    for (const raw of plain.split('\n')) {
+        const name = raw.trim();
+        if (!name)
+            continue;
+        // Guard against any stray banner/usage lines: real rows look like
+        // "<Vendor> <Model> (<Level>)". Require an alphanumeric start and a
+        // parenthesized suffix, which every observed model row has.
+        if (!/^[A-Za-z0-9].*\([^)]+\)\s*$/.test(name))
+            continue;
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        models.push({
+            id: name,
+            displayName: name,
+            // Antigravity's first listed model is its default (unknown --model values
+            // fall back to it), so flag the first row we accept.
+            isDefault: models.length === 0,
+        });
+    }
+    return { models, aliases: {} };
+}
+/**
+ * Extract Kimi's catalog via `kimi provider list --json`, which emits the raw
+ * providers/models config. Model ids are the `models` object keys (e.g.
+ * `kimi-code/kimi-for-coding`). The default is reported on a separate plain
+ * `Default model: <id>` line by `kimi provider list` (no flags), so we run that
+ * too to flag the default row.
+ */
+function extractKimiCatalog(binaryPath) {
+    let jsonOut;
+    try {
+        jsonOut = execFileSync(binaryPath, ['provider', 'list', '--json'], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 15_000,
+            maxBuffer: 16 * 1024 * 1024,
+        });
+    }
+    catch {
+        return { models: [], aliases: {} };
+    }
+    const firstBrace = jsonOut.indexOf('{');
+    if (firstBrace === -1)
+        return { models: [], aliases: {} };
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonOut.slice(firstBrace));
+    }
+    catch {
+        return { models: [], aliases: {} };
+    }
+    // Resolve the default model id from the plain listing's "Default model:" line.
+    let defaultId = null;
+    try {
+        const plain = execFileSync(binaryPath, ['provider', 'list'], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 10_000,
+            maxBuffer: 4 * 1024 * 1024,
+        });
+        const m = plain.match(/Default model:\s*(\S+)/);
+        if (m)
+            defaultId = m[1];
+    }
+    catch {
+        /* default flag is best-effort */
+    }
+    const modelsObj = parsed?.models && typeof parsed.models === 'object' ? parsed.models : {};
+    const models = [];
+    for (const id of Object.keys(modelsObj)) {
+        const info = modelsObj[id] ?? {};
+        models.push({
+            id,
+            displayName: typeof info.displayName === 'string' ? info.displayName : undefined,
+            isDefault: defaultId != null && id === defaultId,
+        });
+    }
+    return { models, aliases: {} };
+}
 /**
  * Build (or load from cache) the model catalog for a specific (agent, version).
  * Cache is keyed on source-file mtime (binary or js module), so re-extracts
@@ -654,6 +782,10 @@ export function getModelCatalog(agent, version) {
             ({ models, aliases } = extractCursorCatalog(src.path));
         else if (agent === 'openclaw')
             ({ models, aliases } = extractOpenClawCatalog(src.path));
+        else if (agent === 'antigravity')
+            ({ models, aliases } = extractAntigravityCatalog(src.path));
+        else if (agent === 'kimi')
+            ({ models, aliases } = extractKimiCatalog(src.path));
     }
     const catalog = {
         agent,
@@ -663,11 +795,12 @@ export function getModelCatalog(agent, version) {
         models,
         aliases,
     };
-    // Don't cache empty CLI extractions: the CLI may have been mid-install,
-    // network-dependent, or transiently failing. Caching 0 models would mask
-    // the real catalog forever (mtime won't change). Bundle/binary/js sources
-    // are deterministic, so cache those even when empty.
-    if (src.kind !== 'cli' || models.length > 0) {
+    // Never cache an empty extraction, regardless of source kind. A 0-model
+    // result is always suspect: the CLI may have been mid-install, network-
+    // dependent, or transiently failing, and a js/bundle/binary extractor that
+    // regex-misses would otherwise pin an empty catalog forever (mtime won't
+    // change until the source file does). Only persist a non-empty catalog.
+    if (models.length > 0) {
         cache.entries[key] = { sourcePath: src.path, mtime, catalog };
         saveCache();
     }

package/dist/lib/runner.js

@@ -95,14 +95,14 @@ export function buildJobCommand(config, resolvedPrompt) {
         appendModelAndReasoning(cmd, config);
     }
     if (config.agent === 'kimi') {
+        // kimi daemon jobs always run headless via `--prompt`, which cannot be
+        // combined with any startup-mode flag (--plan/--auto/--yolo all abort with
+        // "Cannot combine --prompt with --X"). edit/auto/skip reduce to kimi's default
+        // headless auto-run, so emit no flag; plan has no headless read-only
+        // equivalent, so fail closed rather than silently allowing writes.
         if (mode === 'plan') {
-            cmd.push('--plan');
-        }
-        else if (mode === 'auto') {
-            cmd.push('--auto');
-        }
-        else if (mode === 'skip') {
-            cmd.push('--yolo');
+            throw new Error('kimi has no headless read-only mode: routine jobs cannot run kimi with --mode plan ' +
+                '(kimi rejects --prompt + --plan). Use --mode edit, auto, or skip.');
         }
         appendModelAndReasoning(cmd, config);
     }