@phnx-labs/agents-cli 1.20.26 → 1.20.27

package/dist/lib/plugins.js

@@ -11,14 +11,14 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { execFileSync } from 'child_process';
-import { getPluginsDir, getTrashPluginsDir, getExtraPluginsDir, getProjectPluginsDir } from './state.js';
+import { getPluginsDir, getTrashPluginsDir, getExtraPluginsDir, getProjectPluginsDir, getSystemPluginsDir } from './state.js';
 import { IS_WINDOWS, isWindowsAbsolutePath, homeDir } from './platform/index.js';
 import { assertSafeGitTransport } from './git.js';
 import { listInstalledVersions, getVersionHomePath } from './versions.js';
 import { AGENTS, agentConfigDirName } from './agents.js';
 import { capableAgents, isCapable } from './capabilities.js';
 import { shouldInstallCommandAsSkill, installCommandSkillToVersion } from './command-skills.js';
-import { copyPluginToMarketplace, syncMarketplaceManifest, registerMarketplace, unregisterMarketplace, addPluginToSettings, removePluginFromSettings, removePluginFromMarketplace, marketplaceIsEmpty, removeEmptyMarketplaceDir, isInstalledInMarketplace, marketplaceRoot, discoverMarketplaces, marketplaceNameFor, MARKETPLACE_NAME, PROJECT_MARKETPLACE_NAME, } from './plugin-marketplace.js';
+import { copyPluginToMarketplace, syncMarketplaceManifest, registerMarketplace, unregisterMarketplace, addPluginToSettings, removePluginFromSettings, removePluginFromMarketplace, marketplaceIsEmpty, removeEmptyMarketplaceDir, isInstalledInMarketplace, marketplaceRoot, discoverMarketplaces, marketplaceNameFor, MARKETPLACE_NAME, PROJECT_MARKETPLACE_NAME, SYSTEM_MARKETPLACE_NAME, } from './plugin-marketplace.js';
 const PLUGIN_MANIFEST_DIR = '.claude-plugin';
 const PLUGIN_MANIFEST_FILE = 'plugin.json';
 const USER_CONFIG_FILE = '.user-config.json';
@@ -186,11 +186,20 @@ export function assertPluginTargetContained(targetRoot, pluginsDir) {
     }
 }
 /**
- * Get a specific plugin by name.
+ * Get a specific plugin by name. On a cross-marketplace name collision the
+ * highest-precedence scope wins (project > extra > user > system) — the same
+ * resolution the sync writer's Map(last-wins) dedupe and collectPluginScopes()
+ * use. discoverPlugins() yields low→high precedence order, so the LAST match is
+ * the winner; returning the first match would resolve to the lowest scope (e.g.
+ * a system plugin over the user's same-named one), which is exactly backwards.
  */
 export function getPlugin(name) {
     const plugins = discoverPlugins();
-    return plugins.find(p => p.name === name) || null;
+    for (let i = plugins.length - 1; i >= 0; i--) {
+        if (plugins[i].name === name)
+            return plugins[i];
+    }
+    return null;
 }
 /**
  * Check if an agent supports a specific plugin.
@@ -382,13 +391,18 @@ export function checkPluginDependencies(manifest) {
 /**
  * Reconstruct a MarketplaceSpec from a marketplace name. The inverse of
  * marketplaceNameFor(): "agents-cli" → user, "agents-project" → project,
- * "agents-<alias>" → extra. The per-version marketplace operations only key off
- * the name (never spec.root), but we resolve the real source root anyway so the
- * spec is honest for any caller that inspects it.
+ * "agents-system" → system, "agents-<alias>" → extra. The per-version
+ * marketplace operations only key off the name (never spec.root), but we
+ * resolve the real source root anyway so the spec is honest for any caller that
+ * inspects it (e.g. descriptionFor, which would otherwise label the system
+ * marketplace as an extra repo named "system").
  */
 function marketplaceSpecForName(name, cwd = process.cwd()) {
     if (!name || name === MARKETPLACE_NAME)
         return { kind: 'user' };
+    if (name === SYSTEM_MARKETPLACE_NAME) {
+        return { kind: 'system', root: getSystemPluginsDir() };
+    }
     if (name === PROJECT_MARKETPLACE_NAME) {
         return { kind: 'project', root: getProjectPluginsDir(cwd) ?? '' };
     }
@@ -1096,10 +1110,38 @@ export async function installPlugin(spec) {
         throw new Error(`Installed source has no valid .claude-plugin/plugin.json`);
     }
     const capabilities = inspectPluginCapabilities(targetRoot);
-    // Persist source for future updates
-    fs.writeFileSync(path.join(targetRoot, SOURCE_FILE), JSON.stringify({ source, isGit: !isLocalPath }), 'utf-8');
+    // Persist source for future updates. `version` records the manifest version
+    // at pull time — a baseline that lets the heal path tell "central is an
+    // untouched copy of upstream" (safe to fast-forward) from "the user edited
+    // it" (leave alone) without hashing the whole tree.
+    fs.writeFileSync(path.join(targetRoot, SOURCE_FILE), JSON.stringify({ source, isGit: !isLocalPath, version: manifest.version }), 'utf-8');
     return { name: manifest.name, root: targetRoot, isNew, capabilities };
 }
+/** Read a plugin's `.source` provenance, or null when absent/unreadable. */
+export function readPluginSourceInfo(root) {
+    const f = path.join(root, SOURCE_FILE);
+    if (!fs.existsSync(f))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(f, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve the CURRENT upstream manifest version for a local-sourced plugin
+ * (the `.system`/local-path case). Returns null for git sources — reading their
+ * upstream version would need a network fetch, so git plugins are refreshed only
+ * via the explicit `agents plugins update`.
+ */
+export function getUpstreamManifestVersion(info) {
+    if (info.isGit)
+        return null;
+    const resolved = info.source.replace(/^~/, homeDir());
+    const m = loadPluginManifest(resolved);
+    return m?.version ?? null;
+}
 /**
  * Update an installed plugin by re-pulling from its original source.
  * Returns true if the update succeeded.
@@ -1136,11 +1178,14 @@ export async function updatePlugin(name) {
                 : null;
             fs.rmSync(plugin.root, { recursive: true, force: true });
             fs.cpSync(resolvedSource, plugin.root, { recursive: true });
-            fs.writeFileSync(path.join(plugin.root, SOURCE_FILE), JSON.stringify(sourceInfo), 'utf-8');
             if (userConfigBackup !== null) {
                 fs.writeFileSync(userConfigPath, userConfigBackup, 'utf-8');
             }
         }
+        // Re-stamp .source with the freshly pulled manifest version so the baseline
+        // tracks what's now on disk (keeps the heal "unmodified?" check honest).
+        const freshVersion = loadPluginManifest(plugin.root)?.version;
+        fs.writeFileSync(path.join(plugin.root, SOURCE_FILE), JSON.stringify({ ...sourceInfo, version: freshVersion }), 'utf-8');
     }
     catch (err) {
         return { success: false, error: err.message };

package/dist/lib/session/remote.d.ts

@@ -0,0 +1,33 @@
+/**
+ * SSH target: a bare ssh-config host alias (e.g. `yosemite-s1`) or `user@host`.
+ * The strict allowlist blocks shell metacharacters and a leading `-`, so a target
+ * can never be smuggled in as an ssh argv flag.
+ */
+export declare const SSH_TARGET_RE: RegExp;
+export declare function assertValidSshTarget(host: string): void;
+/** POSIX single-quote a string for safe interpolation into a remote shell command. */
+export declare function shellQuote(s: string): string;
+/**
+ * Strip the `--host`/`-H` flag (and its value) from a raw `agents sessions` argv,
+ * leaving the args to forward to the remote unchanged. The remote runs the same
+ * binary, so every other flag (`--since`, `--last`, `--json`, query, …) carries
+ * over for free. Handles every form commander accepts: `--host h`, `--host=h`,
+ * `-H h`, `-H=h`, and the glued short form `-Hh`.
+ *
+ * @param argv full process argv; the sessions args begin at index 2
+ *             (`[runtime, script, 'sessions', ...]`).
+ */
+export declare function buildForwardedArgs(argv: string[], hosts?: Set<string>): string[];
+/**
+ * Build the single remote command string for `ssh <host> <cmd>`. Forwarded args
+ * are quoted for the inner login shell, then the whole `agents …` invocation is
+ * quoted again so it survives `bash -lc <...>`.
+ */
+export declare function buildRemoteCommand(forwardedArgs: string[]): string;
+/**
+ * Run the current `agents sessions` invocation on one or more remote machines over
+ * SSH, streaming each remote's output to the terminal. Sets `process.exitCode = 1`
+ * if any host fails. Reads the invocation from `process.argv` (override via
+ * `argv` for testing).
+ */
+export declare function runRemoteSessions(hosts: string[], argv?: string[]): void;

package/dist/lib/session/remote.js

@@ -0,0 +1,114 @@
+/**
+ * `agents sessions --host <target>` — run the session query on a remote machine
+ * over SSH and stream its output back. Session transcripts and the index DB live
+ * on the machine that produced them (see `discover.ts`, all `os.homedir()`-rooted),
+ * so instead of syncing the bytes here we invoke the *remote's own* `agents
+ * sessions` against its already-built index and forward stdout verbatim.
+ *
+ * This is the live counterpart to `agents sessions sync` (R2/CRDT, eventual): no
+ * upfront copy, always current, but the peer must be reachable. SSH access is the
+ * only auth — if you can `ssh <host>`, you own the box (no identity layer by design).
+ *
+ * Mirrors the transport already used by `agents secrets export --to-ssh`
+ * (`src/commands/secrets.ts`): `ssh -o BatchMode=yes <host> bash -lc '<cmd>'`,
+ * with `bash -lc` so the remote login PATH resolves `agents`.
+ */
+import { spawnSync } from 'child_process';
+import chalk from 'chalk';
+/**
+ * SSH target: a bare ssh-config host alias (e.g. `yosemite-s1`) or `user@host`.
+ * The strict allowlist blocks shell metacharacters and a leading `-`, so a target
+ * can never be smuggled in as an ssh argv flag.
+ */
+export const SSH_TARGET_RE = /^[a-zA-Z0-9._-]+(@[a-zA-Z0-9._-]+)?$/;
+export function assertValidSshTarget(host) {
+    if (!SSH_TARGET_RE.test(host)) {
+        throw new Error(`Invalid SSH target ${JSON.stringify(host)}. Expected a host alias or user@host ` +
+            `(letters, digits, '.', '_', '-').`);
+    }
+}
+/** POSIX single-quote a string for safe interpolation into a remote shell command. */
+export function shellQuote(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * Strip the `--host`/`-H` flag (and its value) from a raw `agents sessions` argv,
+ * leaving the args to forward to the remote unchanged. The remote runs the same
+ * binary, so every other flag (`--since`, `--last`, `--json`, query, …) carries
+ * over for free. Handles every form commander accepts: `--host h`, `--host=h`,
+ * `-H h`, `-H=h`, and the glued short form `-Hh`.
+ *
+ * @param argv full process argv; the sessions args begin at index 2
+ *             (`[runtime, script, 'sessions', ...]`).
+ */
+export function buildForwardedArgs(argv, hosts = new Set()) {
+    const args = argv.slice(2);
+    const out = [];
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--host' || a === '-H') {
+            // Commander's `<target...>` variadic accepts both `--host a --host b` and
+            // `--host a b` — consume every consecutive token that is a known host so
+            // the variadic form doesn't leak the extra hosts into the remote argv.
+            // Fall back to consuming the single next token when we have no host set
+            // (e.g. malformed input) so the flag value never leaks either way.
+            if (hosts.size > 0) {
+                while (i + 1 < args.length && hosts.has(args[i + 1]))
+                    i++;
+            }
+            else {
+                i++; // also consume the separate value token
+            }
+            continue;
+        }
+        if (a.startsWith('--host=') || a.startsWith('-H='))
+            continue;
+        if (/^-H.+/.test(a))
+            continue; // glued short form: -Hyosemite-s1
+        out.push(a);
+    }
+    return out;
+}
+/**
+ * Build the single remote command string for `ssh <host> <cmd>`. Forwarded args
+ * are quoted for the inner login shell, then the whole `agents …` invocation is
+ * quoted again so it survives `bash -lc <...>`.
+ */
+export function buildRemoteCommand(forwardedArgs) {
+    const inner = ['agents', ...forwardedArgs].map(shellQuote).join(' ');
+    return `bash -lc ${shellQuote(inner)}`;
+}
+const SSH_OPTS = [
+    '-o', 'BatchMode=yes',
+    '-o', 'StrictHostKeyChecking=accept-new',
+    '-o', 'ConnectTimeout=10',
+];
+/**
+ * Run the current `agents sessions` invocation on one or more remote machines over
+ * SSH, streaming each remote's output to the terminal. Sets `process.exitCode = 1`
+ * if any host fails. Reads the invocation from `process.argv` (override via
+ * `argv` for testing).
+ */
+export function runRemoteSessions(hosts, argv = process.argv) {
+    for (const host of hosts)
+        assertValidSshTarget(host); // fail fast on any bad target
+    const remoteCmd = buildRemoteCommand(buildForwardedArgs(argv, new Set(hosts)));
+    const multi = hosts.length > 1;
+    let failures = 0;
+    for (const host of hosts) {
+        if (multi)
+            process.stdout.write(chalk.cyan(`\n── ${host} ──\n`));
+        const res = spawnSync('ssh', [...SSH_OPTS, host, remoteCmd], { stdio: 'inherit' });
+        if (res.error) {
+            failures++;
+            console.error(chalk.red(`${host}: ${res.error.message}`));
+            continue;
+        }
+        if (res.status !== 0) {
+            failures++;
+            console.error(chalk.red(`${host}: remote query failed (exit ${res.status ?? 'signal'}).`));
+        }
+    }
+    if (failures > 0)
+        process.exitCode = 1;
+}

package/dist/lib/staleness/detectors/commands.js

@@ -1,8 +1,8 @@
 /**
  * Commands detector — mirrors versions.ts:343-357. Inspects the version home,
- * returns command names. Honors the commands-as-skills marker for grok and
- * Codex >= 0.117.0; falls back to scanning `{agentDir}/<commandsSubdir>/` for
- * the native path.
+ * returns command names. Honors the commands-as-skills marker for skills-only
+ * agents (grok, kimi, Codex >= 0.117.0, …); falls back to scanning
+ * `{agentDir}/<commandsSubdir>/` for the native path.
  */
 import * as fs from 'fs';
 import * as path from 'path';
@@ -29,13 +29,14 @@ function buildCommandsDetector(agent) {
         },
     };
 }
-// Detector registration mirrors writers/commands.ts — see that file for the
-// openclaw vs grok asymmetry.
+// Detector registration mirrors writers/commands.ts — skills-capable agents
+// with no native command-file dir convert commands to skills by default; only
+// agents with their own slash-command runtime (nativeCommandRuntime) opt out.
 export const commandsDetectors = lazyAgentMap(() => {
     const m = {};
     for (const id of Object.keys(AGENTS)) {
         const cfg = AGENTS[id];
-        if (cfg.capabilities.commands === false && (!cfg.commandsSubdir || cfg.commandsSubdir === '') && id !== 'grok')
+        if (cfg.capabilities.commands === false && (!cfg.commandsSubdir || cfg.commandsSubdir === '') && cfg.nativeCommandRuntime)
             continue;
         const hasCommands = cfg.capabilities.commands !== false;
         const hasSkills = cfg.capabilities.skills !== false;

package/dist/lib/staleness/writers/commands.js

@@ -80,25 +80,20 @@ function buildCommandsWriter(agent) {
 //   - commands-as-skills (grok, codex >= 0.117.0)
 //
 // Agents that have skills but use a NATIVE non-file slash-command system
-// (openclaw → Gateway-based commands) are NOT registered. The signal is an
-// empty `commandsSubdir`: there's no directory to write to AND the agent
-// doesn't want commands-as-skills either (it has its own runtime command
-// resolver).
+// (openclaw → Gateway-based commands) are NOT registered. They declare
+// `nativeCommandRuntime: true` to opt out — their own runtime resolves slash
+// commands, so there's nothing to write and nothing to convert.
 export const commandsWriters = lazyAgentMap(() => {
     const m = {};
     for (const id of Object.keys(AGENTS)) {
         const cfg = AGENTS[id];
         if (cfg.capabilities.commands === false && (!cfg.skillsDir || cfg.skillsDir === ''))
             continue;
-        // Native non-file slash-command runtime — no version-home write.
+        // Skills-capable agent with no native command-file dir: convert commands to
+        // skills by default (grok, kimi, …). Opt out only agents with their own
+        // slash-command runtime (openclaw).
         if (cfg.capabilities.commands === false && (!cfg.commandsSubdir || cfg.commandsSubdir === '')) {
-            // Grok has empty commandsSubdir AND wants commands-as-skills.
-            // Distinguish: grok has skillsDir set; openclaw also has skillsDir, so we
-            // can't use that. The cleanest signal is the agent's `cliCommand` set —
-            // openclaw flags `commands: false` AND has its Gateway runtime, while
-            // grok flags `commands: false` because grok's slash commands are skills.
-            // We opt in explicitly: only grok takes commands-as-skills today.
-            if (id !== 'grok')
+            if (cfg.nativeCommandRuntime)
                 continue;
         }
         const hasCommands = cfg.capabilities.commands !== false;

package/dist/lib/startup/dev-build.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Decide whether the CLI is running from a source checkout (a "dev build") vs an
+ * installed package. Dev builds suppress autopull / migrations / auto-update so
+ * iterating on the repo never mutates the user's real setup.
+ *
+ * Two signals:
+ *   1. A `0.0.0-dev*` version stamp (scripts/install.sh dev installs).
+ *   2. Running out of an actual agents-cli git checkout.
+ *
+ * Signal 2 must be precise. The naive check —
+ * `existsSync(dirname(dirname(argv[1])) + '/.git')` — false-positives badly:
+ *   - npm-global bins are symlinks. `/opt/homebrew/bin/agents` →
+ *     `…/node_modules/@phnx-labs/agents-cli/dist/index.js`. Without resolving the
+ *     symlink, `dirname(dirname())` walks to `/opt/homebrew`, which is **itself a
+ *     git repo** (Homebrew). So every Homebrew-node user looked like a dev build
+ *     and had migrations + the menu-bar self-heal silently disabled.
+ *
+ * Fix: resolve the symlink with realpath, then require the `.git`'s repo root to
+ * actually be the agents-cli package (its package.json `name`), not some
+ * unrelated ancestor that happens to be version-controlled.
+ */
+export declare function detectDevBuild(argv1: string, version: string): boolean;

package/dist/lib/startup/dev-build.js

@@ -0,0 +1,41 @@
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * Decide whether the CLI is running from a source checkout (a "dev build") vs an
+ * installed package. Dev builds suppress autopull / migrations / auto-update so
+ * iterating on the repo never mutates the user's real setup.
+ *
+ * Two signals:
+ *   1. A `0.0.0-dev*` version stamp (scripts/install.sh dev installs).
+ *   2. Running out of an actual agents-cli git checkout.
+ *
+ * Signal 2 must be precise. The naive check —
+ * `existsSync(dirname(dirname(argv[1])) + '/.git')` — false-positives badly:
+ *   - npm-global bins are symlinks. `/opt/homebrew/bin/agents` →
+ *     `…/node_modules/@phnx-labs/agents-cli/dist/index.js`. Without resolving the
+ *     symlink, `dirname(dirname())` walks to `/opt/homebrew`, which is **itself a
+ *     git repo** (Homebrew). So every Homebrew-node user looked like a dev build
+ *     and had migrations + the menu-bar self-heal silently disabled.
+ *
+ * Fix: resolve the symlink with realpath, then require the `.git`'s repo root to
+ * actually be the agents-cli package (its package.json `name`), not some
+ * unrelated ancestor that happens to be version-controlled.
+ */
+export function detectDevBuild(argv1, version) {
+    if (version.startsWith('0.0.0-dev'))
+        return true;
+    try {
+        const cliPath = fs.realpathSync(argv1 || '');
+        const repoRoot = path.dirname(path.dirname(cliPath));
+        if (!fs.existsSync(path.join(repoRoot, '.git')))
+            return false;
+        const pkgPath = path.join(repoRoot, 'package.json');
+        if (!fs.existsSync(pkgPath))
+            return false;
+        const name = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))?.name;
+        return name === '@phnx-labs/agents-cli';
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/types.d.ts

@@ -77,6 +77,13 @@ export interface AgentConfig {
     commandsDir: string;
     commandsSubdir: string;
     skillsDir: string;
+    /**
+     * Agent resolves slash-commands through its own runtime (e.g. openclaw's
+     * Gateway), so agents-cli commands must NOT be converted into skills for it.
+     * Skills-capable agents WITHOUT a native command-file dir convert commands to
+     * skills by default; set this to opt such an agent out of that conversion.
+     */
+    nativeCommandRuntime?: boolean;
     hooksDir: string;
     pluginManifestDir?: string;
     instructionsFile: string;

package/dist/lib/versions.d.ts

@@ -144,8 +144,10 @@ export declare function isOldestInstalled(agent: AgentId): Promise<{
     installed: boolean;
     version: string | null;
 }>;
+/** Drop the installed-versions cache (call after install/remove mutations). */
+export declare function invalidateInstalledVersionsCache(agent?: AgentId): void;
 /**
- * List all installed versions for an agent.
+ * List all installed versions for an agent (cached by versions-dir mtime).
  */
 export declare function listInstalledVersions(agent: AgentId): string[];
 /**

package/dist/lib/versions.js

@@ -898,14 +898,36 @@ export async function isOldestInstalled(agent) {
     }
     return { installed: isVersionInstalled(agent, oldestVersion), version: oldestVersion };
 }
+// Per-process cache for listInstalledVersions. The agent's versions dir mtime
+// changes whenever a version dir is added or removed (install/remove), so a
+// stamp match means the installed set is unchanged and we skip the readdir +
+// N binary stats. Mirrors the readMeta() cache in state.ts. Hot path:
+// resolveAgentTargets and every enumerate-style consumer hit this.
+const installedVersionsCache = new Map();
+/** Drop the installed-versions cache (call after install/remove mutations). */
+export function invalidateInstalledVersionsCache(agent) {
+    if (agent)
+        installedVersionsCache.delete(agent);
+    else
+        installedVersionsCache.clear();
+}
 /**
- * List all installed versions for an agent.
+ * List all installed versions for an agent (cached by versions-dir mtime).
  */
 export function listInstalledVersions(agent) {
     const agentVersionsDir = path.join(getVersionsDir(), agent);
-    if (!fs.existsSync(agentVersionsDir)) {
+    let stamp;
+    try {
+        stamp = fs.statSync(agentVersionsDir).mtimeMs;
+    }
+    catch {
+        installedVersionsCache.set(agent, { stamp: 0, versions: [] });
         return [];
     }
+    const cached = installedVersionsCache.get(agent);
+    if (cached && cached.stamp === stamp) {
+        return cached.versions;
+    }
     const entries = fs.readdirSync(agentVersionsDir, { withFileTypes: true });
     const versions = [];
     for (const entry of entries) {
@@ -916,7 +938,9 @@ export function listInstalledVersions(agent) {
             }
         }
     }
-    return versions.sort(compareVersions);
+    versions.sort(compareVersions);
+    installedVersionsCache.set(agent, { stamp, versions });
+    return versions;
 }
 /**
  * List every version directory for an agent, including ones missing the
@@ -1831,7 +1855,15 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
         // dot-dirs to keep plugin-managed subtrees (.plugins/, .promptcuts) intact.
         const skillsTargetSweep = path.join(agentDir, 'skills');
         if (!userPassedSelection && fs.existsSync(skillsTargetSweep) && !fs.lstatSync(skillsTargetSweep).isSymbolicLink()) {
+            // Trust real skills AND command-skills: when commandsAsSkills, the
+            // commands writer (above) materialized each command as a skill dir under
+            // skills/. Those names are not in skillsToSync, so without this they'd be
+            // swept as orphans — silently deleting every converted command (e.g.
+            // /recap on kimi/grok).
             const trustedSkills = new Set(skillsToSync);
+            if (commandsAsSkills)
+                for (const cmd of commandsToSync)
+                    trustedSkills.add(cmd);
             for (const entry of fs.readdirSync(skillsTargetSweep, { withFileTypes: true })) {
                 if (!entry.isDirectory() || entry.name.startsWith('.'))
                     continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.26",
+  "version": "1.20.27",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",
@@ -92,10 +92,10 @@
     "diff": "9.0.0",
     "marked": "15.0.12",
     "marked-terminal": "7.3.0",
-    "ora": "9.4.0",
+    "ora": "9.4.1",
     "proper-lockfile": "4.1.2",
     "simple-git": "3.36.0",
-    "smol-toml": "1.6.1",
+    "smol-toml": "1.7.0",
     "yaml": "2.9.0"
   },
   "devDependencies": {