@phnx-labs/agents-cli 1.20.71 → 1.20.73

package/dist/commands/utils.d.ts

@@ -4,6 +4,7 @@
  * Small helpers used across multiple commands: prompt cancellation detection,
  * table formatting, spinner management, and platform-specific workarounds.
  */
+import type { Command } from 'commander';
 import type { AgentId } from '../lib/types.js';
 import { type InstalledAgentTargetResult, type VersionSelectionResult } from '../lib/versions.js';
 /**
@@ -22,6 +23,34 @@ export declare function isPromptCancelled(err: unknown): boolean;
  * True when stdin/stdout are attached to a real terminal.
  */
 export declare function isInteractiveTerminal(): boolean;
+/** The resolved I/O surface for one command invocation — the human/agent split. */
+export interface Surface {
+    /** Machine-readable output was requested (`--json`). */
+    json: boolean;
+    /** Skip confirmation prompts — explicit `--yes`/`-y`, or a non-interactive shell. */
+    assumeYes: boolean;
+    /** Suppress non-essential human chrome (`--quiet`). */
+    quiet: boolean;
+    /**
+     * Safe to show an interactive picker/prompt: a real terminal AND not asking for
+     * `--json` (a JSON consumer is a machine and never wants a picker).
+     */
+    interactive: boolean;
+}
+/**
+ * Compute a command's I/O surface once, in one place, instead of each command
+ * re-deriving the human-vs-agent split (and raw-sniffing `process.std*.isTTY`
+ * with inconsistent stream choices — the audit's R4). Reads the merged option
+ * set via `optsWithGlobals()`, so it sees the command's own flags and any
+ * inherited global ones, and folds in the terminal state:
+ *
+ *   - `assumeYes` = explicit `--yes` OR a non-interactive shell (no one to prompt).
+ *   - `interactive` = a real TTY AND not `--json`.
+ *
+ * Adopt incrementally: a command switches its ad-hoc `isTTY`/`options.yes` checks
+ * to a single `const s = resolveSurface(cmd)` without changing its flag surface.
+ */
+export declare function resolveSurface(cmd: Command): Surface;
 /**
  * Exit with a clean message when a picker would be required in a non-interactive shell.
  */

package/dist/commands/utils.js

@@ -45,6 +45,30 @@ export function isPromptCancelled(err) {
 export function isInteractiveTerminal() {
     return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
+/**
+ * Compute a command's I/O surface once, in one place, instead of each command
+ * re-deriving the human-vs-agent split (and raw-sniffing `process.std*.isTTY`
+ * with inconsistent stream choices — the audit's R4). Reads the merged option
+ * set via `optsWithGlobals()`, so it sees the command's own flags and any
+ * inherited global ones, and folds in the terminal state:
+ *
+ *   - `assumeYes` = explicit `--yes` OR a non-interactive shell (no one to prompt).
+ *   - `interactive` = a real TTY AND not `--json`.
+ *
+ * Adopt incrementally: a command switches its ad-hoc `isTTY`/`options.yes` checks
+ * to a single `const s = resolveSurface(cmd)` without changing its flag surface.
+ */
+export function resolveSurface(cmd) {
+    const opts = cmd.optsWithGlobals();
+    const tty = isInteractiveTerminal();
+    const json = opts.json === true;
+    return {
+        json,
+        assumeYes: opts.yes === true || !tty,
+        quiet: opts.quiet === true,
+        interactive: tty && !json,
+    };
+}
 /**
  * Exit with a clean message when a picker would be required in a non-interactive shell.
  */

package/dist/commands/versions.js

@@ -8,9 +8,9 @@ import { AGENTS, ALL_AGENT_IDS, accountOrgBadge, getAccountEmail, getAccountInfo
 import { formatUsageSummary, getUsageInfoForIdentity, getUsageInfoByIdentity, getUsageLookupKey, } from '../lib/usage.js';
 import { viewAction } from './view.js';
 import { readManifest, writeManifest, createDefaultManifest } from '../lib/manifest.js';
-import { installVersion, removeVersion, listInstalledVersions, isVersionInstalled, isLatestInstalled, isOldestInstalled, getGlobalDefault, setGlobalDefault, getVersionHomePath, getVersionDir, syncResourcesToVersion, parseAgentSpec, promptResourceSelection, promptNewResourceSelection, getAvailableResources, getActuallySyncedResources, getNewResources, getProjectOnlyResources, hasNewResources, printTrashFooter, } from '../lib/versions.js';
+import { installVersion, removeVersion, listInstalledVersions, isVersionInstalled, isLatestInstalled, isOldestInstalled, getGlobalDefault, setGlobalDefault, markVersionIsolated, isVersionIsolated, getVersionHomePath, getVersionDir, syncResourcesToVersion, parseAgentSpec, promptResourceSelection, promptNewResourceSelection, getAvailableResources, getActuallySyncedResources, getNewResources, getProjectOnlyResources, hasNewResources, printTrashFooter, } from '../lib/versions.js';
 import { carryForwardSettings } from '../lib/settings-manifest.js';
-import { createShim, createVersionedAlias, removeShim, shimExists, getShimsDir, getShimPath, getPathShadowingExecutable, isShimsInPath, getPathSetupInstructions, addShimsToPath, switchConfigSymlink, switchHomeFileSymlinks, } from '../lib/shims.js';
+import { createShim, createVersionedAlias, supportsIsolatedInstall, CONFIG_ENV_ISOLATED_AGENTS, removeShim, shimExists, getShimsDir, getShimPath, getPathShadowingExecutable, isShimsInPath, getPathSetupInstructions, addShimsToPath, switchConfigSymlink, switchHomeFileSymlinks, } from '../lib/shims.js';
 import { isInteractiveTerminal, isPromptCancelled, requireInteractiveSelection } from './utils.js';
 import { tryAutoPull } from '../lib/git.js';
 import { getAgentsDir, getTrashVersionsDir } from '../lib/state.js';
@@ -98,8 +98,30 @@ function warnIfShimShadowed(agent) {
     console.log(chalk.green(`  Added shim directory to ${result.location}.`));
     console.log(chalk.gray(`  ${result.reloadHint}`));
 }
+/**
+ * Install an isolated copy of an agent version: a fully self-contained install
+ * that never touches the user's existing setup.
+ *
+ * Unlike a normal install it does NOT set (or offer to set) the global default,
+ * does NOT create/replace the bare `<agent>` shim, does NOT back up or symlink
+ * the user's real `~/.<agent>`, and does NOT carry over settings or resources.
+ * It only creates the versioned alias (so the copy is launchable) and records
+ * the isolated marker. Invoke the copy explicitly with `agents run <agent>@<v>`.
+ */
+function finalizeIsolatedInstall(agent, version) {
+    const agentConfig = AGENTS[agent];
+    const label = agentLabel(agentConfig.id);
+    createVersionedAlias(agent, version);
+    markVersionIsolated(agent, version);
+    console.log(chalk.green(`  Installed ${label}@${version} as an isolated copy.`));
+    console.log(chalk.gray(`  Your existing ${agentConfig.configDir} and default ${label} are untouched.`));
+    console.log(chalk.gray(`  Run it:     agents run ${agent}@${version} "your prompt"`));
+    console.log(chalk.gray(`  It has its own config and login — sign in the first time you run it.`));
+    console.log(chalk.gray(`  Remove it:  agents remove ${agent}@${version} --isolated`));
+}
 async function versionPruneAction(specs, options, commandName) {
     const isProject = options.project;
+    const isIsolated = options.isolated;
     const moved = [];
     for (const spec of specs) {
         const parsed = parseAgentSpec(spec);
@@ -110,6 +132,12 @@ async function versionPruneAction(specs, options, commandName) {
         }
         const { agent, version } = parsed;
         const agentConfig = AGENTS[agent];
+        // --isolated only ever applies to agents that can BE installed isolated;
+        // for the rest no isolated version can exist, so say so plainly.
+        if (isIsolated && !supportsIsolatedInstall(agent)) {
+            console.log(chalk.gray(`${agentLabel(agentConfig.id)} has no isolated installs (--isolated is not supported for it).`));
+            continue;
+        }
         // Script-installed agents (droid, grok) can have a *literal* `latest`
         // version dir on disk when the post-install version probe failed. An
         // explicit `<agent>@latest` should remove that dir directly rather than
@@ -117,9 +145,14 @@ async function versionPruneAction(specs, options, commandName) {
         // so treat an installed literal `latest` as a concrete pinned version.
         const isLiteralLatestInstalled = version === 'latest' && spec.includes('@') && isVersionInstalled(agent, 'latest');
         if (!isLiteralLatestInstalled && (version === 'latest' || version === 'oldest' || !spec.includes('@'))) {
-            const versions = listInstalledVersions(agent);
+            // With --isolated, only isolated installs are eligible for the picker, so
+            // a normal/default install can never be selected here by accident.
+            const versions = listInstalledVersions(agent)
+                .filter((v) => !isIsolated || isVersionIsolated(agent, v));
             if (versions.length === 0) {
-                console.log(chalk.gray(`No versions of ${agentLabel(agentConfig.id)} installed`));
+                console.log(chalk.gray(isIsolated
+                    ? `No isolated ${agentLabel(agentConfig.id)} installs`
+                    : `No versions of ${agentLabel(agentConfig.id)} installed`));
                 continue;
             }
             if (!isInteractiveTerminal()) {
@@ -157,6 +190,9 @@ async function versionPruneAction(specs, options, commandName) {
                     }
                     fixSessionFilePaths(agent, v, versionDir);
                     console.log(chalk.green(`Moved ${agentLabel(agentConfig.id)}@${v} to trash`));
+                    if (isIsolated) {
+                        console.log(chalk.gray(`  Your real ${agentConfig.configDir} and default ${agentLabel(agentConfig.id)} were untouched.`));
+                    }
                     moved.push({ agent, version: v });
                 }
                 // Default reassignment/clearing is handled at the source in
@@ -177,6 +213,13 @@ async function versionPruneAction(specs, options, commandName) {
         else if (!isVersionInstalled(agent, version)) {
             console.log(chalk.gray(`${agentLabel(agentConfig.id)}@${version} not installed`));
         }
+        else if (isIsolated && !isVersionIsolated(agent, version)) {
+            // Safety guard: `--isolated` refuses to remove a normal/default install,
+            // so an accidental `remove <agent>@<default> --isolated` can never delete
+            // the user's primary version or disturb their real ~/.<agent>.
+            console.log(chalk.yellow(`${agentLabel(agentConfig.id)}@${version} is not an isolated install; refusing to remove it under --isolated.`));
+            console.log(chalk.gray(`  Drop --isolated to remove a normal version: agents ${commandName} ${agent}@${version}`));
+        }
         else {
             const versionDir = getVersionDir(agent, version);
             const removed = removeVersion(agent, version);
@@ -186,6 +229,9 @@ async function versionPruneAction(specs, options, commandName) {
             }
             fixSessionFilePaths(agent, version, versionDir);
             console.log(chalk.green(`Moved ${agentLabel(agentConfig.id)}@${version} to trash`));
+            if (isIsolated) {
+                console.log(chalk.gray(`  Your real ${agentConfig.configDir} and default ${agentLabel(agentConfig.id)} were untouched.`));
+            }
             moved.push({ agent, version });
             const remaining = listInstalledVersions(agent);
             if (remaining.length === 0) {
@@ -212,7 +258,8 @@ function configureVersionPruneCommand(cmd, commandName) {
         .description(isAlias
         ? 'Alias for agents prune. Uninstalls agent CLI versions.'
         : 'Uninstall agent CLI versions. Moves version data to trash for recovery.')
-        .option('-p, --project', 'Also clear the pinned version from .agents/agents.yaml in the current project');
+        .option('-p, --project', 'Also clear the pinned version from .agents/agents.yaml in the current project')
+        .option('--isolated', 'Only act on isolated installs (created with `agents add --isolated`). Refuses to remove a normal/default install and never touches your real ~/.<agent>.');
     setHelpSections(cmd, {
         examples: `
       # Prune a specific version
@@ -223,11 +270,15 @@ function configureVersionPruneCommand(cmd, commandName) {
 
       # Prune and also clear the project pin
       agents ${commandName} claude@2.0.50 --project
+
+      # Cleanly remove an isolated copy, leaving your normal install alone
+      agents ${commandName} claude@2.1.112 --isolated
     `,
         notes: `
       - Pruned version directories move to trash with their home/ data intact.
       - Session file paths are rewritten so session history remains readable.
       - Removing the default version unsets the default; run 'agents use' to pick a new one.
+      - --isolated restricts the operation to isolated installs and refuses to remove a normal/default version, so your existing setup is never disturbed.
       - Reinstall any time with 'agents add'.
     `,
     });
@@ -239,6 +290,7 @@ export function registerVersionsCommands(program) {
         .command('add <specs...>')
         .description('Download and install agent CLI versions. Enables subsidized API usage through managed binaries.')
         .option('-p, --project', 'Lock this version to the current project directory only, stored in project-root agents.yaml')
+        .option('--isolated', 'Install a fully self-contained copy that never touches your existing ~/.<agent> or default. Launch it explicitly with `agents run <agent>@<version>`. Cannot be combined with --project.')
         .option('-y, --yes', 'Auto-accept defaults without prompting (useful for scripts and CI)');
     setHelpSections(addCmd, {
         examples: `
@@ -256,16 +308,26 @@ export function registerVersionsCommands(program) {
 
       # Lock a version to this project only (won't affect global default)
       agents add claude@2.1.100 --project
+
+      # Install a clean, separate copy that leaves your existing setup alone
+      agents add claude@2.1.112 --isolated
     `,
         notes: `
       - The first version you install becomes the default automatically.
       - 'add' does NOT change the default if a default already exists. Use 'agents use' to switch.
       - Multi-account: each installed version has separate auth, so you can install the same agent twice for two accounts.
+      - --isolated installs a self-contained copy: it never sets the default, never creates the bare '<agent>' shim, and never backs up or symlinks your real ~/.<agent>. Run it with 'agents run <agent>@<version>' and remove it with 'agents remove <agent>@<version> --isolated'. Mutually exclusive with --project.
     `,
     });
     addCmd.action(async (specs, options) => {
         const isProject = options.project;
+        const isIsolated = options.isolated;
         const skipPrompts = options.yes || !isInteractiveTerminal();
+        if (isIsolated && isProject) {
+            console.log(chalk.red('--isolated and --project cannot be combined.'));
+            console.log(chalk.gray('An isolated copy is global-but-separate; a project pin selects a shared install for one directory.'));
+            return;
+        }
         for (const spec of specs) {
             const parsed = parseAgentSpec(spec);
             if (!parsed) {
@@ -276,6 +338,16 @@ export function registerVersionsCommands(program) {
             const { agent, version } = parsed;
             const agentConfig = AGENTS[agent];
             warnAgentDeprecated(agent);
+            // Isolation relies on a config-dir env var to redirect the copy away
+            // from the user's real ~/.<agent>. Agents without one isolate only by
+            // adopting ~/.<agent> (which --isolated skips), so an isolated copy
+            // would silently read/write the real config. Refuse rather than lie.
+            if (isIsolated && !supportsIsolatedInstall(agent)) {
+                console.log(chalk.red(`${agentLabel(agentConfig.id)} does not support --isolated installs.`));
+                console.log(chalk.gray(`  It has no config-directory env var, so it can only isolate by adopting ${agentConfig.configDir} — which --isolated deliberately avoids.`));
+                console.log(chalk.gray(`  Supported with --isolated: ${CONFIG_ENV_ISOLATED_AGENTS.join(', ')}.`));
+                continue;
+            }
             if (!agentConfig.npmPackage && !agentConfig.installScript) {
                 console.log(chalk.yellow(`${agentLabel(agentConfig.id)} has no npm package. Install manually.`));
                 continue;
@@ -301,6 +373,19 @@ export function registerVersionsCommands(program) {
                 alreadyInstalled = isVersionInstalled(agent, version);
             }
             if (alreadyInstalled) {
+                if (isIsolated) {
+                    if (!isVersionIsolated(agent, installedAsVersion)) {
+                        // A normal and an isolated install of the SAME version share one
+                        // on-disk dir, so they can't coexist. Refuse rather than silently
+                        // convert the user's existing (possibly default) install.
+                        console.log(chalk.yellow(`${agentLabel(agentConfig.id)}@${installedAsVersion} is already installed as a normal (default-eligible) version.`));
+                        console.log(chalk.gray(`  Remove it first (agents remove ${agent}@${installedAsVersion}) then re-add with --isolated, or pick a different version.`));
+                        continue;
+                    }
+                    // Already isolated: re-affirm the alias + marker idempotently.
+                    finalizeIsolatedInstall(agent, installedAsVersion);
+                    continue;
+                }
                 console.log(chalk.gray(`${agentLabel(agentConfig.id)}@${installedAsVersion} already installed`));
                 // Ensure shim exists (in case it was deleted or needs updating)
                 createShim(agent);
@@ -312,15 +397,23 @@ export function registerVersionsCommands(program) {
                 });
                 if (result.success) {
                     spinner.succeed(`Installed ${agentLabel(agentConfig.id)}@${result.installedVersion}`);
+                    const installedVersion = result.installedVersion || version;
+                    // Track the concrete version so a `--project` pin records it instead
+                    // of the `latest`/`oldest` alias.
+                    installedAsVersion = installedVersion;
+                    // Isolated installs stop here: no bare shim, no settings carry-over,
+                    // no resource sync, no default switch, no PATH edits. Just a
+                    // launchable versioned alias + the isolated marker, leaving the
+                    // user's real ~/.<agent> and default untouched.
+                    if (isIsolated) {
+                        finalizeIsolatedInstall(agent, installedVersion);
+                        continue;
+                    }
                     // Create shim if first install
                     if (!shimExists(agent)) {
                         createShim(agent);
                         console.log(chalk.gray(`  Created shim: ${getShimsDir()}/${agentConfig.cliCommand}`));
                     }
-                    const installedVersion = result.installedVersion || version;
-                    // Track the concrete version so a `--project` pin records it instead
-                    // of the `latest`/`oldest` alias.
-                    installedAsVersion = installedVersion;
                     // Seed the fresh version home with user settings from the current
                     // default version (settings.json, keybindings, codex config/auth).
                     // Gap-filling only — never overwrites what the new home has.
@@ -540,8 +633,11 @@ export function registerVersionsCommands(program) {
             const agentConfig = AGENTS[agentId];
             let selectedVersion = version;
             if (!version) {
-                // Interactive version picker
-                const versions = listInstalledVersions(agentId);
+                // Interactive version picker. Isolated installs are walled off from the
+                // real ~/.<agent> on purpose, so they must never be selectable here —
+                // setting one as the default would repoint the real config at it. Filter
+                // them out (same as the `remove` picker), leaving only usable versions.
+                const versions = listInstalledVersions(agentId).filter((v) => !isVersionIsolated(agentId, v));
                 if (versions.length === 0) {
                     console.log(chalk.red(`No versions of ${agentLabel(agentConfig.id)} installed`));
                     console.log(chalk.gray(`Run: agents add ${agentId}@latest`));
@@ -602,6 +698,19 @@ export function registerVersionsCommands(program) {
             }
             // selectedVersion is guaranteed to be defined after the check above
             const finalVersion = selectedVersion;
+            // An isolated install is deliberately walled off from the real
+            // ~/.<agent>. `agents use` would repoint the real config symlink at it
+            // (switchConfigSymlink) and carry settings forward INTO it
+            // (carryForwardSettings) — a direct breach of the isolation guarantee.
+            // Refuse for both the explicit `use <agent>@<isolated>` path (the picker
+            // above already filters isolated versions out of the interactive path).
+            // Isolated copies are launched explicitly via `agents run <agent>@<v>`.
+            if (isVersionIsolated(agentId, finalVersion)) {
+                console.log(chalk.red(`${agentLabel(agentConfig.id)}@${finalVersion} is an isolated install and can't be set as your active version.`));
+                console.log(chalk.gray(`Isolated copies stay walled off from your real ${agentConfig.configDir}. Run it directly: agents run ${agentId}@${finalVersion}`));
+                console.log(chalk.gray(`To install this version normally: agents add ${agentId}@${finalVersion}`));
+                return;
+            }
             if (options.project) {
                 // Set in project manifest
                 const projectManifestDir = path.join(process.cwd(), '.agents');

package/dist/index.js

@@ -26,6 +26,11 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const packageJsonPath = path.join(__dirname, '..', 'package.json');
 const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
 const VERSION = packageJson.version;
+if (process.argv[2] === '__vault-age-helper') {
+    const { runVaultAgeHelperCli } = await import('./lib/secrets/vault-age-helper.js');
+    await runVaultAgeHelperCli();
+    process.exit(process.exitCode ?? 0);
+}
 import { NPM_PACKAGE_NAME, deriveGlobalPrefix, detectPackageManager, installPackageIntoPrefix, installPackageWithBun, verifyInstalledVersion, refreshAliasShims, downloadVerifiedTarball, } from './lib/self-update.js';
 // Detect dev/working-tree builds and default the noisy startup steps off.
 // Three cases trip this:
@@ -50,7 +55,7 @@ if (IS_DEV_BUILD) {
 // module on each invocation (which loaded the whole ~50-module tree before the
 // first byte of output), the registry maps a command name to a thunk that
 // imports only what that command needs. See src/lib/startup/command-registry.ts.
-import { COMMAND_LOADERS, LAZY_COMMAND_NAMES, loadView, loadInspect, loadFeedback, loadCommands, loadHooks, loadSkills, loadRules, loadMemory, loadPermissions, loadMcp, loadCli, loadSubagents, loadPlugins, loadWorkflows, loadWorktree, loadVersions, loadImport, loadPackages, loadDaemon, loadRoutines, loadMonitors, loadRun, loadFork, loadDefaults, loadModels, loadPrune, loadTrash, loadRestore, loadDoctor, loadApply, loadCheck, loadStatus, loadProfiles, loadSecrets, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadDrive, loadFactory, loadUsage, loadCost, loadOutput, loadBudget, loadAlias, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadShare, loadFeed, loadMailboxes, } from './lib/startup/command-registry.js';
+import { COMMAND_LOADERS, LAZY_COMMAND_NAMES, loadView, loadInspect, loadResources, loadFeedback, loadCommands, loadHooks, loadSkills, loadRules, loadMemory, loadPermissions, loadMcp, loadCli, loadSubagents, loadPlugins, loadWorkflows, loadWorktree, loadVersions, loadImport, loadPackages, loadRoutines, loadMonitors, loadRun, loadFork, loadDefaults, loadModels, loadPrune, loadTrash, loadRestore, loadDoctor, loadApply, loadCheck, loadStatus, loadProfiles, loadSecrets, loadLogin, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadDrive, loadFactory, loadUsage, loadCost, loadOutput, loadBudget, loadAlias, loadMine, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadUninstall, loadShare, loadSend, loadHq, loadFeed, loadActivity, loadMailboxes, } from './lib/startup/command-registry.js';
 import { applyGlobalHelpConventions } from './lib/help.js';
 import { renderWhatsNew } from './lib/whats-new.js';
 import { emit, redactArgs } from './lib/events.js';
@@ -68,9 +73,18 @@ if (process.argv[2] === '__shim') {
     const code = await execShimPassthrough(agent, rawArgs, process.cwd(), pinned || undefined);
     process.exit(code);
 }
+if (process.argv[2] === '__daemon-run') {
+    const { runDaemon } = await import('./lib/daemon.js');
+    await runDaemon();
+    process.exit(process.exitCode ?? 0);
+}
+// White-label: the shim for a brand (e.g. `jack`) exports AGENTS_BRAND, so the
+// CLI presents its own name/help/errors as the brand. Unbranded (AGENTS_BRAND
+// unset) resolves to 'agents' and everything below is byte-identical to before.
+const BRAND = resolveBrandName();
 const program = new Command();
 program
-    .name('agents')
+    .name(BRAND)
     .description('Environment manager for AI agents')
     .version(VERSION)
     .option('--verbose', 'Show startup self-heal details on stderr')
@@ -86,7 +100,7 @@ program
 function auditCommandPath(cmd) {
     const parts = [];
     let c = cmd;
-    while (c && c.name() && c.name() !== 'agents') {
+    while (c && c.name() && c.name() !== BRAND) {
         parts.unshift(c.name());
         c = c.parent;
     }
@@ -129,11 +143,36 @@ program.hook('postAction', (_thisCommand, actionCommand) => {
         // Best-effort completion record; the start line is the durable audit fact.
     }
 });
+/**
+ * Skin the static root help for a brand: rewrite the visible `agents` command
+ * examples to the brand name and drop lines for commands this brand disabled.
+ * A no-op for the unbranded `agents` CLI with nothing disabled.
+ */
+function brandRootHelp(raw) {
+    let text = raw;
+    if (BRAND !== 'agents') {
+        text = text
+            .replace(/Usage: agents /g, `Usage: ${BRAND} `)
+            .replace(/^ {2}agents /gm, `  ${BRAND} `)
+            .replace(/Run 'agents /g, `Run '${BRAND} `);
+    }
+    const disabled = disabledCommandsForActiveBrand();
+    if (disabled.size > 0) {
+        text = text
+            .split('\n')
+            .filter((line) => {
+            const m = line.match(/^ {2}([a-z][\w-]*)/);
+            return !(m && disabled.has(m[1]));
+        })
+            .join('\n');
+    }
+    return text;
+}
 // Custom help for the main program only
 const originalHelpInformation = program.helpInformation.bind(program);
 program.helpInformation = function () {
-    if (this.name() === 'agents' && !this.parent) {
-        return `Usage: agents [command] [options]
+    if (this.name() === BRAND && !this.parent) {
+        return brandRootHelp(`Usage: agents [command] [options]
 
 Install, configure, run, and dispatch AI coding agents from one place.
 Works with Claude, Codex, Gemini, Cursor, OpenCode, OpenClaw, and Droid.
@@ -154,6 +193,7 @@ Agent versions:
   trash                           Inspect and restore soft-deleted version directories
   view [agent[@version]]          List versions, or inspect one in detail
   inspect <target>                Deep details for one agent+version, or a DotAgents repo (user|system|project|alias|path)
+  resources                       Show merged DotAgents resources with their winning layer
 
 Agent configuration (synced across versions):
   rules                           Instructions given to agents (CLAUDE.md, etc.)
@@ -173,6 +213,7 @@ Run and dispatch:
   run <agent|profile> [prompt]    Run an agent. Omit prompt for interactive mode.
   defaults                        Configure run defaults by agent/version selector
   teams                           Coordinate multiple agents on shared work
+  hq                              JSON bridge for the interactive Agents HQ floor
   routines                        Run agents on a cron schedule (scheduler auto-starts)
   webhook                         Receive signed GitHub/Linear webhooks for trigger routines
   funnel                          Expose a webhook receiver through Tailscale Funnel
@@ -182,6 +223,7 @@ Run and dispatch:
   pty                             Drive interactive terminal programs (REPLs, TUIs) via a persistent PTY session
 
 Credentials and profiles:
+  profile                         Activate resource profiles across skills, MCP, permissions, and secrets
   profiles                        Bundles of (host CLI, endpoint, model, auth)
   secrets                         Keychain-backed env bundles; use 'secrets exec <bundle> -- <cmd>' to inject into a subprocess
 
@@ -213,7 +255,7 @@ Options:
   --verbose                       Show startup self-heal details on stderr
 
 System config lives in ~/.agents/.system/. Run 'agents <command> --help' for details.
-`;
+`);
     }
     return originalHelpInformation();
 };
@@ -251,6 +293,7 @@ async function showWhatsNew(fromVersion, toVersion) {
 }
 const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
 import { getUpdateCheckPath, getMigratedSentinelPath, getUserAgentsDir, getRuntimeStateDir } from './lib/state.js';
+import { resolveBrandName, disabledCommandsForActiveBrand } from './lib/brand.js';
 import { readUpdateCache, saveUpdateCheck, dismissUpdateVersion, shouldPromptUpgrade, findAgentsCliInstalls, } from './lib/self-update.js';
 const UPDATE_CHECK_FILE = getUpdateCheckPath();
 /**
@@ -668,7 +711,9 @@ async function registerEagerForRequest(name) {
 async function registerAllEagerCommands() {
     await reg(loadView);
     await reg(loadShare);
+    await reg(loadSend);
     await reg(loadInspect);
+    await reg(loadResources);
     await reg(loadFeedback);
     await reg(loadCommands);
     await reg(loadHooks);
@@ -686,7 +731,6 @@ async function registerAllEagerCommands() {
     await reg(loadVersions);
     await reg(loadImport);
     await reg(loadPackages);
-    await reg(loadDaemon);
     await reg(loadRoutines);
     await reg(loadMonitors);
     await reg(loadRun);
@@ -703,6 +747,7 @@ async function registerAllEagerCommands() {
     registerExecAliasCommand(program);
     await reg(loadProfiles);
     await reg(loadSecrets);
+    await reg(loadLogin);
     await reg(loadWallet);
     await reg(loadHelper);
     await reg(loadMenubar);
@@ -717,6 +762,7 @@ async function registerAllEagerCommands() {
     await reg(loadOutput);
     await reg(loadBudget);
     await reg(loadAlias);
+    await reg(loadMine);
     await reg(loadPty);
     await reg(loadTmux);
     await reg(loadWatchdog);
@@ -728,7 +774,9 @@ async function registerAllEagerCommands() {
     await reg(loadAudit);
     await reg(loadWebhook);
     await reg(loadFunnel);
+    await reg(loadHq);
     await reg(loadFeed);
+    await reg(loadActivity);
     await reg(loadMailboxes);
     await reg(loadSsh);
     registerJobsCronAliasCommand(program, 'jobs');
@@ -738,6 +786,7 @@ async function registerAllEagerCommands() {
     await reg(loadPush);
     await reg(loadRepo);
     await reg(loadSetup);
+    await reg(loadUninstall);
 }
 /** Calculate the Levenshtein edit distance between two strings. */
 function levenshtein(a, b) {
@@ -794,13 +843,19 @@ const verboseStartup = passedArgs.includes('--verbose');
 // Help and version output are pure documentation — they must never gate on
 // setup, otherwise `agents <cmd> --help` becomes useless on a fresh box.
 const helpOrVersionRequested = passedArgs.some((arg) => arg === '--help' || arg === '-h' || arg === '--version' || arg === '-V');
+// White-label: a brand can hide built-in top-level commands. A hidden command
+// must behave as if it doesn't exist under this brand (unknown-command +
+// spellcheck), while `agents` itself is unaffected. `brandDisabled` is empty for
+// the unbranded CLI, so all of this is a no-op there.
+const brandDisabled = disabledCommandsForActiveBrand();
+const requestedIsDisabled = requestedCommand !== undefined && brandDisabled.has(requestedCommand);
 // `--host` passthrough: run this invocation on a remote machine over SSH instead
 // of locally. Handled before any local command registration / update check /
 // background sync — a remote run needs none of that. Only the allowlisted
 // read-only + config + teams commands route here; `run`/`sessions` are absent
 // from the table and fall through to their own richer `--host` handling below.
 // `--help`/`--version` stay local (docs must work without a reachable host).
-if (requestedCommand !== undefined && !helpOrVersionRequested) {
+if (requestedCommand !== undefined && !helpOrVersionRequested && !requestedIsDisabled) {
     const { maybeRunOnHost } = await import('./lib/hosts/passthrough.js');
     if (await maybeRunOnHost(requestedCommand, passedArgs)) {
         process.exit(process.exitCode ?? 0);
@@ -809,7 +864,13 @@ if (requestedCommand !== undefined && !helpOrVersionRequested) {
 // Register only the command(s) this invocation actually uses. Lazy commands
 // (sessions/teams/cloud) are handled after applyGlobalHelpConventions below.
 const isLazyRequest = requestedCommand !== undefined && LAZY_COMMAND_NAMES.has(requestedCommand);
-if (requestedCommand !== undefined && !isLazyRequest) {
+if (requestedIsDisabled) {
+    // The brand turned this command off: register the full tree so the "did you
+    // mean" picker still works, then strip the disabled commands below so the
+    // request resolves as unknown.
+    await registerAllEagerCommands();
+}
+else if (requestedCommand !== undefined && !isLazyRequest) {
     const known = await registerEagerForRequest(requestedCommand);
     if (!known) {
         // Unknown top-level command: register the full tree so the "did you mean"
@@ -827,10 +888,19 @@ if (requestedCommand !== undefined && !isLazyRequest) {
 applyGlobalHelpConventions(program);
 // Lazy commands pull in the SQLite-backed session/cloud stack; register them
 // only when explicitly requested, keeping lightweight commands off that path.
-if (isLazyRequest) {
+if (isLazyRequest && !requestedIsDisabled) {
     for (const loader of COMMAND_LOADERS[requestedCommand])
         await reg(loader);
 }
+// White-label: remove any commands this brand disabled so they resolve as
+// unknown (the command:* handler then reports "unknown command"). Unbranded or
+// nothing-disabled → no-op. Done after all registration paths above.
+if (brandDisabled.size > 0) {
+    const kept = program.commands.filter((c) => !brandDisabled.has(c.name()));
+    if (kept.length !== program.commands.length) {
+        program.commands = kept;
+    }
+}
 // Pure documentation paths (--version / --help / -h) return immediately: skip
 // the update check (PATH scan + cache read) and the detached background sync
 // (spawns a child process) that every other invocation runs.
@@ -865,8 +935,9 @@ if (firstRun) {
     process.exit(0);
 }
 // Every command requires the system repo to be cloned first. `setup` is the
-// only exemption — it's the command that does the cloning.
-const SETUP_EXEMPT_COMMANDS = new Set(['setup', 'help']);
+// command that does the cloning; `uninstall` is its reverse and must run even
+// from a broken/half-setup state (that is exactly when you want to tear down).
+const SETUP_EXEMPT_COMMANDS = new Set(['setup', 'help', 'uninstall']);
 // Fold legacy ~/.agents-system/ into ~/.agents/.system/ BEFORE ensureInitialized
 // runs. ensureInitialized checks for .git inside the new path; if the user is
 // upgrading from a layout where .git lives under the legacy path, the check