@phnx-labs/agents-cli 1.22.34 → 1.22.37

package/dist/lib/staleness/prune.js

@@ -0,0 +1,69 @@
+import { getWriter, getDetector } from './registry.js';
+/**
+ * Kinds prune reconciles. Restricted to the name-keyed file/dir resources whose
+ * writer implements `remove()`. Deliberately excluded, each with a reason:
+ *   - hooks — a version-home hook script is coupled to a settings.json /
+ *     hooks.json REGISTRATION. Pruning the last hook to zero would delete the
+ *     script but must also GC its registration in the same pass, and that lands
+ *     in `src/lib/hooks.ts` — a Windows-portable-path surface the CI windows leg
+ *     gates on. Split to RUSH-2456 so this PR stays Linux-only-green; hook FILES
+ *     are still reconciled by the in-write orphan sweep (versions.ts, gated on
+ *     `hooksToSync > 0`).
+ *   - rules / permissions — synced as a wholesale rewrite (one composed file /
+ *     the full allowlist), so a removed rule or group already drops out.
+ *   - plugins — carry their own reconciliation via `cleanOrphanedPluginSkills`.
+ *   - mcp — registered through each agent's CLI/config, a separate removal path.
+ *   - subagents / workflows — no clean per-name inverse yet (multi-agent index
+ *     finalize; native workflow trees); tracked for a follow-up.
+ */
+export const PRUNABLE_KINDS = ['commands', 'skills'];
+/** Names the manifest recorded as installed for a kind (source-name keyed). */
+function manifestNames(manifest, kind) {
+    switch (kind) {
+        case 'commands': {
+            // Object keys are the source command names; writtenCommands carries any
+            // extra names the writer actually emitted (dual-write / command-skill).
+            const names = new Set(Object.keys(manifest.commands ?? {}));
+            for (const c of manifest.writtenCommands ?? [])
+                names.add(c);
+            return [...names];
+        }
+        case 'skills': return Object.keys(manifest.skills ?? {});
+    }
+}
+function emptyPruned() {
+    return { commands: [], skills: [] };
+}
+/**
+ * Remove resources that a prior sync installed and that are now gone from
+ * source, from one agent@version home. Deletes nothing when no manifest exists.
+ */
+export function pruneRemovedResources(input) {
+    const { agent, version, versionHome, cwd, previousManifest, sourceNames } = input;
+    if (!previousManifest) {
+        return { pruned: emptyPruned(), skippedNoManifest: true };
+    }
+    const pruned = emptyPruned();
+    for (const kind of PRUNABLE_KINDS) {
+        const writer = getWriter(kind, agent);
+        const detector = getDetector(kind, agent);
+        // No writer.remove (unsupported kind/agent) or no detector: nothing to do.
+        if (!writer?.remove || !detector)
+            continue;
+        const installed = manifestNames(previousManifest, kind);
+        if (installed.length === 0)
+            continue;
+        const stillInSource = new Set(sourceNames[kind]);
+        const materialized = new Set(detector.list({ version, versionHome, cwd }));
+        for (const name of installed) {
+            if (stillInSource.has(name))
+                continue; // still provided by some layer
+            if (!materialized.has(name))
+                continue; // already gone from the home
+            const result = writer.remove({ version, versionHome, name, cwd });
+            if (result.removed)
+                pruned[kind].push(name);
+        }
+    }
+    return { pruned, skippedNoManifest: false };
+}

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

@@ -5,7 +5,7 @@ import type { ResourceDetector } from './detectors/types.js';
 import type { RulesSelection } from './writers/rules.js';
 export type { ResourceKind } from './writers/kinds.js';
 export { kindToCapability, ALL_RESOURCE_KINDS } from './writers/kinds.js';
-export type { ResourceWriter, WriteArgs, WriteResult } from './writers/types.js';
+export type { ResourceWriter, WriteArgs, WriteResult, RemoveArgs, RemoveResult } from './writers/types.js';
 export type { ResourceDetector, DetectArgs } from './detectors/types.js';
 export type { RulesSelection } from './writers/rules.js';
 /** Per-kind selection payload. Most kinds are string[]; rules is special. */

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

@@ -25,8 +25,8 @@ import { supports } from '../../capabilities.js';
 import { safeJoin } from '../../paths.js';
 import { markdownToToml } from '../../convert.js';
 import { commandAppliesTo, parseCommandMetadata } from '../../commands.js';
-import { installCommandSkillToVersion, shouldAlsoInstallCommandAsSkill, shouldInstallCommandAsSkill, } from '../../command-skills.js';
-import { installGooseCommandToVersion } from '../../goose-commands.js';
+import { installCommandSkillToVersion, listCommandSkillsInVersion, removeCommandSkillFromVersion, shouldAlsoInstallCommandAsSkill, shouldInstallCommandAsSkill, } from '../../command-skills.js';
+import { installGooseCommandToVersion, listGooseCommandsInVersion, removeGooseCommandFromVersion, } from '../../goose-commands.js';
 import { resolveCommandSource, trustedSkillRoots } from './sources.js';
 import { lazyAgentMap } from './lazy-map.js';
 function buildCommandsWriter(agent) {
@@ -82,6 +82,38 @@ function buildCommandsWriter(agent) {
             }
             return { synced };
         },
+        remove({ versionHome, name }) {
+            const agentConfig = AGENTS[agent];
+            const agentDir = path.join(versionHome, agentConfigDirName(agent));
+            let removed = false;
+            // Native command file (Claude, Codex <0.117, Grok, Cursor, …). The
+            // extension follows the agent's format, mirroring the write path above.
+            if (agentConfig.commandsSubdir) {
+                const ext = agentConfig.format === 'toml' ? '.toml' : '.md';
+                const nativeFile = safeJoin(path.join(agentDir, agentConfig.commandsSubdir), `${name}${ext}`);
+                try {
+                    if (fs.existsSync(nativeFile) && fs.lstatSync(nativeFile).isFile()) {
+                        fs.unlinkSync(nativeFile);
+                        removed = true;
+                    }
+                }
+                catch { /* already gone / inaccessible */ }
+            }
+            // Command-as-skill dir (Codex >=0.117, Kimi; Cursor dual-write). Gated on
+            // it currently being a command-skill, and removeCommandSkillFromVersion
+            // re-checks the `agents_command` marker before deleting — so a real skill
+            // of the same name is never destroyed by a command prune.
+            if (listCommandSkillsInVersion(agentDir).includes(name)) {
+                if (removeCommandSkillFromVersion(agentDir, name).success)
+                    removed = true;
+            }
+            // Goose recipe YAML + its slash_commands registry entry.
+            if (agent === 'goose' && listGooseCommandsInVersion(versionHome).includes(name)) {
+                if (removeGooseCommandFromVersion(versionHome, name).success)
+                    removed = true;
+            }
+            return { removed };
+        },
     };
 }
 // Built lazily on first access — see lazy-map.ts for the cycle rationale.

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

@@ -95,6 +95,22 @@ function buildHooksWriter(agent) {
             }
             return { synced };
         },
+        remove({ versionHome, name }) {
+            // Delete the copied hook artifact from `{agentDir}/hooks/<name>`. Native
+            // settings.json/hooks.json registration is regenerated by the write path
+            // that runs alongside this prune (registerHooksToSettings above reads the
+            // remaining source manifest), so a removed hook drops out of both.
+            const agentDir = path.join(versionHome, agentConfigDirName(agent));
+            const hookTarget = safeJoin(path.join(agentDir, 'hooks'), name);
+            try {
+                if (fs.existsSync(hookTarget)) {
+                    removePath(hookTarget);
+                    return { removed: true };
+                }
+            }
+            catch { /* already gone / inaccessible */ }
+            return { removed: false };
+        },
     };
 }
 export const hooksWriters = lazyAgentMap(() => {

package/dist/lib/staleness/writers/kinds.d.ts

@@ -2,6 +2,12 @@
  * Canonical list of resource kinds dispatched through the writer/detector
  * registry. Each name is the capability name on AgentConfig — except
  * "permissions", which maps to the legacy capability name "allowlist".
+ *
+ * NOTE: "rules" in this registry is the WRITER key for what ResourceSelection
+ * calls "memory". The --rule/--rules CLI flag therefore maps to the "memory"
+ * key in ResourceSelection, not to a key called "rules". The memory file is
+ * composed from all layers (not a per-repo artifact), so it is always set to
+ * 'all' rather than filtered by individual names.
  */
 import type { CapabilityName } from '../../types.js';
 export type ResourceKind = 'commands' | 'skills' | 'hooks' | 'rules' | 'mcp' | 'permissions' | 'subagents' | 'plugins' | 'workflows';

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

@@ -9,6 +9,7 @@ import * as path from 'path';
 import { AGENTS, agentConfigDirName } from '../../agents.js';
 import { capableAgents } from '../../capabilities.js';
 import { safeJoin } from '../../paths.js';
+import { listCommandSkillsInVersion } from '../../command-skills.js';
 import { resolveSkillSource } from './sources.js';
 import { lazyAgentMap } from './lazy-map.js';
 const SKILL_COPY_IGNORE = new Set(['.DS_Store', '.git', '.gitignore', '.venv', '__pycache__', 'node_modules']);
@@ -66,6 +67,24 @@ function buildSkillsWriter(agent) {
             }
             return { synced };
         },
+        remove({ versionHome, name }) {
+            const agentDir = path.join(versionHome, agentConfigDirName(agent));
+            // A command-installed-as-skill lives in the same skills/ dir but is owned
+            // by the commands writer's prune — never delete it from here, or a
+            // still-live converted command would vanish under a skill prune.
+            if (listCommandSkillsInVersion(agentDir).includes(name)) {
+                return { removed: false };
+            }
+            const destDir = safeJoin(path.join(agentDir, 'skills'), name);
+            try {
+                if (fs.existsSync(destDir) && fs.lstatSync(destDir).isDirectory()) {
+                    removePath(destDir);
+                    return { removed: true };
+                }
+            }
+            catch { /* already gone / inaccessible */ }
+            return { removed: false };
+        },
     };
 }
 export const skillsWriters = lazyAgentMap(() => {

package/dist/lib/staleness/writers/subagents.d.ts

@@ -1,8 +1,7 @@
 /**
  * Subagents writer. Every agent's on-disk layout (target dir, file/dir shape,
- * transform, and any post-sync finalize such as Kimi's parent index) is
- * declared once in the subagent registry; this writer is generic and iterates
- * the registry instead of a per-agent `else if` chain.
+ * transform) is declared once in the subagent registry; this writer is generic
+ * and iterates the registry instead of a per-agent `else if` chain.
  *
  * Source-side discovery is `listInstalledSubagents` from lib/subagents.ts —
  * it reads user + system layers only (project layer excluded for the same

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

@@ -24,10 +24,6 @@ function buildSubagentsWriter(agent) {
                 }
                 catch { /* per-item sync failure: skip */ }
             }
-            // Optional cross-item pass (e.g. Kimi's `_agents-cli.yaml` parent index).
-            if (target.finalize && synced.length > 0) {
-                target.finalize(dir, synced.map((name) => map.get(name)));
-            }
             return { synced };
         },
     };

package/dist/lib/staleness/writers/types.d.ts

@@ -29,8 +29,40 @@ export interface WriteResult {
     /** Names actually written. Empty array = write produced nothing (not an error). */
     synced: string[];
 }
+/**
+ * Inverse of a write: locate and delete the materialized artifact for one
+ * resource `name` from a version home. Used only by the manifest-bounded prune
+ * pass (RUSH-2438), which supplies names it has already proven were
+ * agents-installed and are gone from source — the writer just owns the layout
+ * knowledge (native file vs command-skill dir vs recipe) so prune never
+ * re-derives it.
+ */
+export interface RemoveArgs {
+    /** Agent version (e.g. "1.2.3"). */
+    version: string;
+    /** Absolute path to the version's home dir. */
+    versionHome: string;
+    /** Resource name to remove (no extension). */
+    name: string;
+    /** Current working directory — used by writers that consult project-layer state. */
+    cwd: string;
+}
+export interface RemoveResult {
+    /** True when an artifact owned by this writer was found and deleted. */
+    removed: boolean;
+}
 export interface ResourceWriter<Sel = string[]> {
     readonly kind: ResourceKind;
     readonly agent: AgentId;
     write(args: WriteArgs<Sel>): WriteResult;
+    /**
+     * Optional inverse of `write` for the prune pass. Only the name-keyed
+     * file/dir kinds implement it (commands, skills, hooks); kinds whose sync is
+     * a wholesale rewrite (rules, permissions) or that carry their own
+     * reconciliation (plugins via cleanOrphanedPluginSkills) leave it undefined.
+     * Absence is not a silent skip: `pruneRemovedResources` only iterates
+     * `PRUNABLE_KINDS`, and a registry completeness test asserts every writer for
+     * those kinds implements `remove`.
+     */
+    remove?(args: RemoveArgs): RemoveResult;
 }

package/dist/lib/startup/command-registry.d.ts

@@ -37,20 +37,19 @@ export declare const loadCli: ModuleLoader;
 export declare const loadSubagents: ModuleLoader;
 export declare const loadPlugins: ModuleLoader;
 export declare const loadWorkflows: ModuleLoader;
-export declare const loadWorktree: ModuleLoader;
 export declare const loadVersions: ModuleLoader;
 export declare const loadUpdate: ModuleLoader;
 export declare const loadImport: ModuleLoader;
-export declare const loadExport: ModuleLoader;
 export declare const loadPackages: ModuleLoader;
 export declare const loadRoutines: ModuleLoader;
 export declare const loadMonitors: ModuleLoader;
 export declare const loadProjects: ModuleLoader;
 export declare const loadRun: ModuleLoader;
 export declare const loadResume: ModuleLoader;
+export declare const loadOpen: ModuleLoader;
 export declare const loadReconnect: ModuleLoader;
 export declare const loadFork: ModuleLoader;
-export declare const loadDefaults: ModuleLoader;
+export declare const loadConfig: ModuleLoader;
 export declare const loadSet: ModuleLoader;
 export declare const loadModels: ModuleLoader;
 export declare const loadModes: ModuleLoader;
@@ -65,12 +64,9 @@ export declare const loadProfiles: ModuleLoader;
 export declare const loadHarness: ModuleLoader;
 export declare const loadSecrets: ModuleLoader;
 export declare const loadLogin: ModuleLoader;
-export declare const loadWallet: ModuleLoader;
-export declare const loadHelper: ModuleLoader;
 export declare const loadMenubar: ModuleLoader;
 export declare const loadBeta: ModuleLoader;
 export declare const loadSync: ModuleLoader;
-export declare const loadLock: ModuleLoader;
 export declare const loadRefreshRules: ModuleLoader;
 export declare const loadFactory: ModuleLoader;
 export declare const loadUsage: ModuleLoader;
@@ -88,19 +84,16 @@ export declare const loadTmux: ModuleLoader;
 export declare const loadWatchdog: ModuleLoader;
 export declare const loadBrowser: ModuleLoader;
 export declare const loadComputer: ModuleLoader;
-export declare const loadHosts: ModuleLoader;
-export declare const loadLease: ModuleLoader;
 export declare const loadLogs: ModuleLoader;
 export declare const loadEvents: ModuleLoader;
 export declare const loadSsh: ModuleLoader;
-export declare const loadPull: ModuleLoader;
-export declare const loadPush: ModuleLoader;
 export declare const loadRepo: ModuleLoader;
 export declare const loadSetup: ModuleLoader;
 export declare const loadUninstall: ModuleLoader;
 export declare const loadUpgrade: ModuleLoader;
 export declare const loadSessions: ModuleLoader;
 export declare const loadTeams: ModuleLoader;
+export declare const loadTickets: ModuleLoader;
 export declare const loadCloud: ModuleLoader;
 export declare const loadMessage: ModuleLoader;
 export declare const loadSend: ModuleLoader;
@@ -109,11 +102,11 @@ export declare const loadMailboxes: ModuleLoader;
 export declare const loadServe: ModuleLoader;
 export declare const loadShare: ModuleLoader;
 export declare const loadAudit: ModuleLoader;
-export declare const loadWebhook: ModuleLoader;
-export declare const loadFunnel: ModuleLoader;
+export declare const loadWebhooks: ModuleLoader;
 export declare const loadHumans: ModuleLoader;
 export declare const loadAccounts: ModuleLoader;
 export declare const loadDaemon: ModuleLoader;
+export declare const loadCp: ModuleLoader;
 /**
  * Commands whose modules pull in the SQLite-backed session/cloud stack. They are
  * registered AFTER `applyGlobalHelpConventions` (mirroring main's order: help
@@ -150,6 +143,7 @@ export declare const COMMAND_LOADERS: Record<string, ModuleLoader[]>;
  * registered command tree so a new command can never drift out of it.
  */
 export declare const KNOWN_TOP_LEVEL_COMMANDS: ReadonlySet<string>;
+export declare const RETIRED_TOP_LEVEL_COMMANDS: ReadonlySet<string>;
 /** Whether `name` is a top-level command this CLI registers. See {@link KNOWN_TOP_LEVEL_COMMANDS}. */
 export declare function isKnownTopLevelCommand(name: string): boolean;
 /**

package/dist/lib/startup/command-registry.js

@@ -39,20 +39,19 @@ export const loadCli = async () => (await import('../../commands/cli.js')).regis
 export const loadSubagents = async () => (await import('../../commands/subagents.js')).registerSubagentsCommands;
 export const loadPlugins = async () => (await import('../../commands/plugins.js')).registerPluginsCommands;
 export const loadWorkflows = async () => (await import('../../commands/workflows.js')).registerWorkflowsCommands;
-export const loadWorktree = async () => (await import('../../commands/worktree.js')).registerWorktreeCommands;
 export const loadVersions = async () => (await import('../../commands/versions.js')).registerVersionsCommands;
 export const loadUpdate = async () => (await import('../../commands/update.js')).registerUpdateCommand;
 export const loadImport = async () => (await import('../../commands/import.js')).registerImportCommand;
-export const loadExport = async () => (await import('../../commands/export.js')).registerExportCommand;
 export const loadPackages = async () => (await import('../../commands/packages.js')).registerPackagesCommands;
 export const loadRoutines = async () => (await import('../../commands/routines.js')).registerRoutinesCommands;
 export const loadMonitors = async () => (await import('../../commands/monitors.js')).registerMonitorsCommands;
 export const loadProjects = async () => (await import('../../commands/projects.js')).registerProjectsCommands;
 export const loadRun = async () => (await import('../../commands/exec.js')).registerRunCommand;
 export const loadResume = async () => (await import('../../commands/resume.js')).registerResumeCommand;
+export const loadOpen = async () => (await import('../../commands/open.js')).registerOpenCommand;
 export const loadReconnect = async () => (await import('../../commands/reconnect.js')).registerReconnectCommand;
 export const loadFork = async () => (await import('../../commands/fork.js')).registerForkCommand;
-export const loadDefaults = async () => (await import('../../commands/defaults.js')).registerDefaultsCommands;
+export const loadConfig = async () => (await import('../../commands/config.js')).registerConfigCommand;
 export const loadSet = async () => (await import('../../commands/set.js')).registerSetCommand;
 export const loadModels = async () => (await import('../../commands/models.js')).registerModelsCommand;
 export const loadModes = async () => (await import('../../commands/modes.js')).registerModesCommand;
@@ -67,12 +66,9 @@ export const loadProfiles = async () => (await import('../../commands/profiles.j
 export const loadHarness = async () => (await import('../../commands/harness.js')).registerHarnessCommands;
 export const loadSecrets = async () => (await import('../../commands/secrets.js')).registerSecretsCommands;
 export const loadLogin = async () => (await import('../../commands/login.js')).registerLoginCommands;
-export const loadWallet = async () => (await import('../../commands/wallet.js')).registerWalletCommands;
-export const loadHelper = async () => (await import('../../commands/helper.js')).registerHelperCommand;
 export const loadMenubar = async () => (await import('../../commands/menubar.js')).registerMenubarCommands;
 export const loadBeta = async () => (await import('../../commands/beta.js')).registerBetaCommands;
 export const loadSync = async () => (await import('../../commands/sync.js')).registerSyncCommand;
-export const loadLock = async () => (await import('../../commands/lock.js')).registerLockCommand;
 export const loadRefreshRules = async () => (await import('../../commands/refresh-rules.js')).registerRefreshRulesCommand;
 export const loadFactory = async () => (await import('../../commands/factory.js')).registerFactoryCommands;
 export const loadUsage = async () => (await import('../../commands/usage.js')).registerUsageCommand;
@@ -91,19 +87,16 @@ export const loadTmux = async () => (await import('../../commands/tmux.js')).reg
 export const loadWatchdog = async () => (await import('../../commands/watchdog.js')).registerWatchdogCommand;
 export const loadBrowser = async () => (await import('../../commands/browser.js')).registerBrowserCommand;
 export const loadComputer = async () => (await import('../../commands/computer.js')).registerComputerCommand;
-export const loadHosts = async () => (await import('../../commands/hosts.js')).registerHostsCommand;
-export const loadLease = async () => (await import('../../commands/lease.js')).registerLeaseCommand;
 export const loadLogs = async () => (await import('../../commands/logs.js')).registerLogsCommand;
 export const loadEvents = async () => (await import('../../commands/events.js')).registerEventsCommand;
 export const loadSsh = async () => (await import('../../commands/ssh.js')).registerSshCommands;
-export const loadPull = async () => (await import('../../commands/pull.js')).registerPullCommand;
-export const loadPush = async () => (await import('../../commands/push.js')).registerPushCommand;
 export const loadRepo = async () => (await import('../../commands/repo.js')).registerRepoCommands;
 export const loadSetup = async () => (await import('../../commands/setup.js')).registerSetupCommand;
 export const loadUninstall = async () => (await import('../../commands/uninstall.js')).registerUninstallCommands;
 export const loadUpgrade = async () => (await import('../../commands/upgrade.js')).registerUpgradeCommand;
 export const loadSessions = async () => (await import('../../commands/sessions.js')).registerSessionsCommands;
 export const loadTeams = async () => (await import('../../commands/teams.js')).registerTeamsCommands;
+export const loadTickets = async () => (await import('../../commands/tickets.js')).registerTicketsCommand;
 export const loadCloud = async () => (await import('../../commands/cloud.js')).registerCloudCommands;
 export const loadMessage = async () => (await import('../../commands/message.js')).registerMessageCommand;
 export const loadSend = async () => (await import('../../commands/send.js')).registerSendCommand;
@@ -112,11 +105,11 @@ export const loadMailboxes = async () => (await import('../../commands/mailboxes
 export const loadServe = async () => (await import('../../commands/serve.js')).registerServeCommand;
 export const loadShare = async () => (await import('../../commands/share.js')).registerShareCommands;
 export const loadAudit = async () => (await import('../../commands/audit.js')).registerAuditCommands;
-export const loadWebhook = async () => (await import('../../commands/webhook.js')).registerWebhookCommand;
-export const loadFunnel = async () => (await import('../../commands/funnel.js')).registerFunnelCommand;
+export const loadWebhooks = async () => (await import('../../commands/webhook.js')).registerWebhooksCommand;
 export const loadHumans = async () => (await import('../../commands/humans.js')).registerHumansCommands;
 export const loadAccounts = async () => (await import('../../commands/accounts.js')).registerAccountsCommand;
 export const loadDaemon = async () => (await import('../../commands/daemon.js')).registerDaemonCommand;
+export const loadCp = async () => (await import('../../commands/cp.js')).registerCpCommand;
 /**
  * Commands whose modules pull in the SQLite-backed session/cloud stack. They are
  * registered AFTER `applyGlobalHelpConventions` (mirroring main's order: help
@@ -166,7 +159,6 @@ export const COMMAND_LOADERS = {
     subagents: [loadSubagents],
     plugins: [loadPlugins],
     workflows: [loadWorkflows],
-    worktree: [loadWorktree],
     add: [loadVersions],
     use: [loadVersions],
     list: [loadVersions],
@@ -176,23 +168,18 @@ export const COMMAND_LOADERS = {
     update: [loadUpdate],
     prune: [loadVersions, loadPrune],
     import: [loadImport],
-    export: [loadExport],
     registry: [loadPackages],
     search: [loadPackages],
     install: [loadPackages],
-    // packages.ts also registers `publish` at top level (commands/packages.ts:435).
-    // It was missing here, so `agents publish` only worked via the unknown-command
-    // fallback that registers the whole tree — and the --host router could not see
-    // it as a real command at all (RUSH-2022).
-    publish: [loadPackages],
     routines: [loadRoutines],
     monitors: [loadMonitors],
     projects: [loadProjects],
     run: [loadRun],
     resume: [loadResume],
+    open: [loadOpen],
     reconnect: [loadReconnect],
     fork: [loadFork],
-    defaults: [loadDefaults],
+    config: [loadConfig],
     set: [loadSet],
     models: [loadModels],
     modes: [loadModes],
@@ -202,20 +189,15 @@ export const COMMAND_LOADERS = {
     apply: [loadApply],
     status: [loadStatus],
     snapshot: [loadSnapshot],
-    profile: [loadProfiles],
     profiles: [loadProfiles],
     harness: [loadHarness],
     harnesses: [loadHarness],
     secrets: [loadSecrets],
     login: [loadLogin],
     logout: [loadLogin],
-    whoami: [loadLogin],
-    wallet: [loadWallet],
-    helper: [loadHelper],
     menubar: [loadMenubar],
     beta: [loadBeta],
     sync: [loadSync],
-    lock: [loadLock],
     'refresh-rules': [loadRefreshRules],
     factory: [loadFactory],
     usage: [loadUsage],
@@ -233,8 +215,6 @@ export const COMMAND_LOADERS = {
     watchdog: [loadWatchdog],
     browser: [loadBrowser],
     computer: [loadComputer],
-    hosts: [loadHosts],
-    lease: [loadLease],
     logs: [loadLogs],
     events: [loadEvents],
     ssh: [loadSsh],
@@ -242,8 +222,6 @@ export const COMMAND_LOADERS = {
     // `fleet` is a commander alias of `devices` (see commands/ssh.ts); list it so
     // lazy registration loads the devices tree when the user types `agents fleet`.
     fleet: [loadSsh],
-    pull: [loadPull],
-    push: [loadPush],
     // `repos` is the canonical command name; `repo` remains a convenience alias
     // (see commands/repo.ts). List both so lazy registration loads the tree
     // whichever the user types.
@@ -256,6 +234,7 @@ export const COMMAND_LOADERS = {
     // Observe-umbrella alias of sessions --active (same lazy module).
     roster: [loadSessions],
     teams: [loadTeams],
+    tickets: [loadTickets],
     cloud: [loadCloud],
     message: [loadMessage],
     send: [loadSend],
@@ -268,11 +247,14 @@ export const COMMAND_LOADERS = {
     mailbox: [loadMailboxes],
     serve: [loadServe],
     share: [loadShare],
+    // `unshare` is a top-level convenience alias of `share delete` (see
+    // commands/share.ts) — same module, registered as its own program.command().
+    unshare: [loadShare],
     audit: [loadAudit],
-    webhook: [loadWebhook],
-    funnel: [loadFunnel],
+    webhooks: [loadWebhooks],
     humans: [loadHumans],
     daemon: [loadDaemon],
+    cp: [loadCp],
 };
 /**
  * Top-level names that {@link COMMAND_LOADERS} does not carry because they are
@@ -306,6 +288,7 @@ export const KNOWN_TOP_LEVEL_COMMANDS = new Set([
     ...Object.keys(COMMAND_LOADERS),
     ...INLINE_COMMAND_NAMES,
 ]);
+export const RETIRED_TOP_LEVEL_COMMANDS = new Set(['webhook']);
 /** Whether `name` is a top-level command this CLI registers. See {@link KNOWN_TOP_LEVEL_COMMANDS}. */
 export function isKnownTopLevelCommand(name) {
     return KNOWN_TOP_LEVEL_COMMANDS.has(name);

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

@@ -19,4 +19,14 @@
  * actually be the agents-cli package (its package.json `name`), not some
  * unrelated ancestor that happens to be version-controlled.
  */
+/**
+ * Whether a version string is the `0.0.0-dev.<sha>[-dirty]` stamp
+ * `scripts/install.sh` writes for a side-by-side dev install (`install.sh:61`).
+ *
+ * Split out from {@link detectDevBuild} because a caller holding only a version
+ * string — a fleet rollout reading `agents --version` off a remote box — cannot
+ * run signal 2 (it needs that machine's filesystem), and must not re-spell the
+ * stamp prefix.
+ */
+export declare function isDevVersionStamp(version: string): boolean;
 export declare function detectDevBuild(argv1: string, version: string): boolean;

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

@@ -21,8 +21,20 @@ import * as path from 'path';
  * actually be the agents-cli package (its package.json `name`), not some
  * unrelated ancestor that happens to be version-controlled.
  */
+/**
+ * Whether a version string is the `0.0.0-dev.<sha>[-dirty]` stamp
+ * `scripts/install.sh` writes for a side-by-side dev install (`install.sh:61`).
+ *
+ * Split out from {@link detectDevBuild} because a caller holding only a version
+ * string — a fleet rollout reading `agents --version` off a remote box — cannot
+ * run signal 2 (it needs that machine's filesystem), and must not re-spell the
+ * stamp prefix.
+ */
+export function isDevVersionStamp(version) {
+    return version.startsWith('0.0.0-dev');
+}
 export function detectDevBuild(argv1, version) {
-    if (version.startsWith('0.0.0-dev'))
+    if (isDevVersionStamp(version))
         return true;
     try {
         const cliPath = fs.realpathSync(argv1 || '');

package/dist/lib/startup/spellcheck.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Top-level command spellcheck (RUSH-2329).
+ *
+ * Candidates are plain strings from KNOWN_TOP_LEVEL_COMMANDS — never the live
+ * commander registry — so an unknown / typo'd invocation does not pay for
+ * registerAllEagerCommands (~250-330ms of dynamic import + module eval).
+ */
+/** Calculate the Levenshtein edit distance between two strings. */
+export declare function levenshtein(a: string, b: string): number;
+/**
+ * Closest top-level command name by Levenshtein distance.
+ * Iterates candidates in first-seen order so ties break the same way as the
+ * historical registerAllEagerCommands registration order (RUSH-2329).
+ */
+export declare function closestTopLevelCommand(unknown: string, candidates: Iterable<string>): {
+    closest: string | null;
+    minDist: number;
+};

package/dist/lib/startup/spellcheck.js

@@ -0,0 +1,45 @@
+/**
+ * Top-level command spellcheck (RUSH-2329).
+ *
+ * Candidates are plain strings from KNOWN_TOP_LEVEL_COMMANDS — never the live
+ * commander registry — so an unknown / typo'd invocation does not pay for
+ * registerAllEagerCommands (~250-330ms of dynamic import + module eval).
+ */
+/** Calculate the Levenshtein edit distance between two strings. */
+export function levenshtein(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array(m + 1)
+        .fill(null)
+        .map(() => Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] =
+                a[i - 1] === b[j - 1]
+                    ? dp[i - 1][j - 1]
+                    : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+        }
+    }
+    return dp[m][n];
+}
+/**
+ * Closest top-level command name by Levenshtein distance.
+ * Iterates candidates in first-seen order so ties break the same way as the
+ * historical registerAllEagerCommands registration order (RUSH-2329).
+ */
+export function closestTopLevelCommand(unknown, candidates) {
+    let closest = null;
+    let minDist = Infinity;
+    for (const cmd of candidates) {
+        const dist = levenshtein(unknown, cmd);
+        if (dist < minDist) {
+            minDist = dist;
+            closest = cmd;
+        }
+    }
+    return { closest, minDist };
+}