@phnx-labs/agents-cli 1.14.7 → 1.16.0

package/dist/commands/prune.js

@@ -1,14 +1,44 @@
+/**
+ * Top-level `agents prune` — destructive cleanup across the install.
+ *
+ * Cleanup targets:
+ *   - Resource orphans: command/skill/hook files inside a version home that no
+ *     longer come from any source (deleted from ~/.agents/ but never reconciled
+ *     into the version install).
+ *   - Version duplicates: older installed versions of an agent that share an
+ *     account with a newer installed version of the same agent.
+ *   - Trash: soft-deleted resources in ~/.agents/.trash/ older than N days.
+ *   - Sessions: session records in sessions.db older than N days.
+ *   - Runs: routine execution logs, keeping only the last N per job.
+ *
+ * Sync (additive: copy missing/changed files into version homes) is no longer
+ * a user-facing verb — `syncResourcesToVersion` runs at agent launch and
+ * applies adds/updates automatically. Pruning, however, is destructive, so it
+ * stays explicit.
+ *
+ * Default scope: each agent's currently-pinned default version for orphan
+ * cleanup, plus the standard cross-agent version-dedup pass. Pass `--all`
+ * to widen orphan cleanup to every installed version.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
 import chalk from 'chalk';
 import { confirm } from '@inquirer/prompts';
 import { diffVersionCommands, iterCommandsCapableVersions, removeCommandFromVersion, } from '../lib/commands.js';
 import { diffVersionSkills, iterSkillsCapableVersions, removeSkillFromVersion, } from '../lib/skills.js';
 import { diffVersionHooks, iterHooksCapableVersions, removeHookFromVersion, } from '../lib/hooks.js';
+import { diffVersionPlugins, iterPluginsCapableVersions, removePluginSkillFromVersion, } from '../lib/plugins.js';
+import { diffVersionSubagents, iterSubagentsCapableVersions, removeSubagentFromVersion, } from '../lib/subagents.js';
 import { getGlobalDefault } from '../lib/versions.js';
 import { resolveAgentName, formatAgentError } from '../lib/agents.js';
 import { pruneDuplicates } from './view.js';
 import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
-const RESOURCE_TYPES = ['commands', 'skills', 'hooks'];
-const ALL_TYPES = [...RESOURCE_TYPES, 'versions'];
+import { getTrashDir } from '../lib/state.js';
+import { countSessionsOlderThan, deleteSessionsOlderThan } from '../lib/session/db.js';
+import { previewRunsPrune, pruneRuns, countAllRuns } from '../lib/routines.js';
+const RESOURCE_TYPES = ['commands', 'skills', 'hooks', 'plugins', 'subagents'];
+const STATE_TYPES = ['trash', 'sessions', 'runs'];
+const ALL_TYPES = [...RESOURCE_TYPES, 'versions', ...STATE_TYPES];
 function scopePairs(pairs, all) {
     if (all)
         return pairs;
@@ -40,6 +70,22 @@ function collectOrphans(types, all) {
             }
         }
     }
+    if (types.includes('plugins')) {
+        for (const { agent, version } of scopePairs(iterPluginsCapableVersions(), all)) {
+            const diff = diffVersionPlugins(agent, version);
+            if (diff.orphans.length > 0) {
+                groups.push({ type: 'plugins', agent, version, orphans: diff.orphans });
+            }
+        }
+    }
+    if (types.includes('subagents')) {
+        for (const { agent, version } of scopePairs(iterSubagentsCapableVersions(), all)) {
+            const diff = diffVersionSubagents(agent, version);
+            if (diff.orphans.length > 0) {
+                groups.push({ type: 'subagents', agent, version, orphans: diff.orphans });
+            }
+        }
+    }
     return groups;
 }
 function removeOne(group, name) {
@@ -50,6 +96,10 @@ function removeOne(group, name) {
             return removeSkillFromVersion(group.agent, group.version, name);
         case 'hooks':
             return removeHookFromVersion(group.agent, group.version, name);
+        case 'plugins':
+            return removePluginSkillFromVersion(group.agent, group.version, name);
+        case 'subagents':
+            return removeSubagentFromVersion(group.agent, group.version, name);
     }
 }
 function parseTarget(arg) {
@@ -59,6 +109,9 @@ function parseTarget(arg) {
     if (RESOURCE_TYPES.includes(arg)) {
         return { resourceTypes: [arg], includeVersions: false };
     }
+    if (STATE_TYPES.includes(arg)) {
+        return { resourceTypes: [], includeVersions: false, stateType: arg };
+    }
     if (arg === 'versions') {
         return { resourceTypes: [], includeVersions: true };
     }
@@ -72,6 +125,202 @@ function parseTarget(arg) {
     console.log(chalk.gray(formatAgentError(arg)));
     process.exit(1);
 }
+function parseDays(value, defaultDays) {
+    const match = value.match(/^(\d+)d?$/);
+    if (match)
+        return parseInt(match[1], 10);
+    return defaultDays;
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+function getDirSize(dirPath) {
+    if (!fs.existsSync(dirPath))
+        return 0;
+    let size = 0;
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            size += getDirSize(fullPath);
+        }
+        else {
+            try {
+                size += fs.statSync(fullPath).size;
+            }
+            catch { /* ignore */ }
+        }
+    }
+    return size;
+}
+async function runTrashPrune(options) {
+    const trashDir = getTrashDir();
+    if (!fs.existsSync(trashDir)) {
+        console.log(chalk.green('Trash is empty.'));
+        return;
+    }
+    const days = parseDays(options.olderThan || '30d', 30);
+    const cutoffMs = Date.now() - days * 24 * 60 * 60 * 1000;
+    const toPrune = [];
+    function scanDir(dir) {
+        if (!fs.existsSync(dir))
+            return;
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const fullPath = path.join(dir, entry.name);
+            try {
+                const stat = fs.statSync(fullPath);
+                if (stat.mtimeMs < cutoffMs) {
+                    toPrune.push({ path: fullPath, mtime: stat.mtimeMs, size: entry.isDirectory() ? getDirSize(fullPath) : stat.size });
+                }
+                else if (entry.isDirectory()) {
+                    scanDir(fullPath);
+                }
+            }
+            catch { /* skip inaccessible */ }
+        }
+    }
+    scanDir(trashDir);
+    if (toPrune.length === 0) {
+        console.log(chalk.green(`No trash entries older than ${days} days.`));
+        return;
+    }
+    const totalSize = toPrune.reduce((sum, e) => sum + e.size, 0);
+    console.log(chalk.bold(`Trash entries older than ${days} days\n`));
+    for (const entry of toPrune.slice(0, 20)) {
+        const age = Math.floor((Date.now() - entry.mtime) / (24 * 60 * 60 * 1000));
+        console.log(`  ${chalk.gray(`${age}d ago`)}  ${path.relative(trashDir, entry.path)}`);
+    }
+    if (toPrune.length > 20) {
+        console.log(chalk.gray(`  ... and ${toPrune.length - 20} more`));
+    }
+    console.log();
+    if (options.dryRun) {
+        console.log(chalk.gray(`${toPrune.length} entries (${formatBytes(totalSize)}). Run without --dry-run to delete.`));
+        return;
+    }
+    if (!options.yes) {
+        if (!isInteractiveTerminal()) {
+            console.log(chalk.yellow('Non-interactive shell: pass -y to confirm, or --dry-run to preview.'));
+            process.exit(1);
+        }
+        let ok = false;
+        try {
+            ok = await confirm({ message: `Delete ${toPrune.length} entries (${formatBytes(totalSize)})?`, default: false });
+        }
+        catch (err) {
+            if (isPromptCancelled(err)) {
+                console.log(chalk.gray('Cancelled'));
+                return;
+            }
+            throw err;
+        }
+        if (!ok) {
+            console.log(chalk.gray('Cancelled'));
+            return;
+        }
+    }
+    let deleted = 0;
+    for (const entry of toPrune) {
+        try {
+            fs.rmSync(entry.path, { recursive: true, force: true });
+            deleted++;
+        }
+        catch { /* ignore */ }
+    }
+    console.log(chalk.green(`Pruned ${deleted} trash entries (${formatBytes(totalSize)}).`));
+}
+async function runSessionsPrune(options) {
+    const days = parseDays(options.olderThan || '90d', 90);
+    const cutoffMs = Date.now() - days * 24 * 60 * 60 * 1000;
+    const count = countSessionsOlderThan(cutoffMs);
+    if (count === 0) {
+        console.log(chalk.green(`No sessions older than ${days} days.`));
+        return;
+    }
+    console.log(chalk.bold(`Sessions older than ${days} days: ${count}\n`));
+    if (options.dryRun) {
+        console.log(chalk.gray(`${count} session(s). Run without --dry-run to delete.`));
+        return;
+    }
+    if (!options.yes) {
+        if (!isInteractiveTerminal()) {
+            console.log(chalk.yellow('Non-interactive shell: pass -y to confirm, or --dry-run to preview.'));
+            process.exit(1);
+        }
+        let ok = false;
+        try {
+            ok = await confirm({ message: `Delete ${count} session records?`, default: false });
+        }
+        catch (err) {
+            if (isPromptCancelled(err)) {
+                console.log(chalk.gray('Cancelled'));
+                return;
+            }
+            throw err;
+        }
+        if (!ok) {
+            console.log(chalk.gray('Cancelled'));
+            return;
+        }
+    }
+    const deleted = deleteSessionsOlderThan(cutoffMs);
+    console.log(chalk.green(`Pruned ${deleted} session records.`));
+}
+async function runRunsPrune(options) {
+    const keep = options.keep ? parseInt(options.keep, 10) : 10;
+    if (isNaN(keep) || keep < 0) {
+        console.log(chalk.red('--keep must be a non-negative integer'));
+        process.exit(1);
+    }
+    const preview = previewRunsPrune(keep);
+    const total = countAllRuns();
+    if (preview.length === 0) {
+        console.log(chalk.green(`All jobs have ${keep} or fewer runs. Nothing to prune.`));
+        return;
+    }
+    console.log(chalk.bold(`Routine runs to prune (keeping last ${keep} per job)\n`));
+    const byJob = new Map();
+    for (const run of preview) {
+        byJob.set(run.jobName, (byJob.get(run.jobName) || 0) + 1);
+    }
+    for (const [job, count] of byJob) {
+        console.log(`  ${chalk.cyan(job)}: ${count} old runs`);
+    }
+    console.log();
+    if (options.dryRun) {
+        console.log(chalk.gray(`${preview.length} of ${total} runs would be deleted. Run without --dry-run to delete.`));
+        return;
+    }
+    if (!options.yes) {
+        if (!isInteractiveTerminal()) {
+            console.log(chalk.yellow('Non-interactive shell: pass -y to confirm, or --dry-run to preview.'));
+            process.exit(1);
+        }
+        let ok = false;
+        try {
+            ok = await confirm({ message: `Delete ${preview.length} old runs?`, default: false });
+        }
+        catch (err) {
+            if (isPromptCancelled(err)) {
+                console.log(chalk.gray('Cancelled'));
+                return;
+            }
+            throw err;
+        }
+        if (!ok) {
+            console.log(chalk.gray('Cancelled'));
+            return;
+        }
+    }
+    const { deleted, bytesFreed } = pruneRuns(keep);
+    console.log(chalk.green(`Pruned ${deleted} runs (${formatBytes(bytesFreed)}).`));
+}
 async function runOrphanPrune(resourceTypes, options) {
     const groups = collectOrphans(resourceTypes, options.all === true);
     if (groups.length === 0) {
@@ -133,10 +382,12 @@ async function runOrphanPrune(resourceTypes, options) {
 export function registerPruneCommand(program) {
     program
         .command('prune [target]')
-        .description('Remove orphan resources (commands/skills/hooks) and/or older duplicate version installs (versions soft-deleted to ~/.agents-system/trash/)')
+        .description('Remove orphan resources, old versions, trash, sessions, or routine runs')
         .option('--all', 'For orphan cleanup: sweep every installed version (default: current default version per agent)')
-        .option('--dry-run', 'Show what would be removed without deleting')
+        .option('--dry-run', 'Show what would be removed without deleting (default for state targets)')
         .option('-y, --yes', 'Skip confirmation prompt')
+        .option('--older-than <days>', 'For trash/sessions: delete entries older than N days (default: 30d for trash, 90d for sessions)')
+        .option('--keep <n>', 'For runs: keep the last N runs per job (default: 10)')
         .addHelpText('after', `
 Targets:
   (none)     Orphans across commands, skills, hooks + duplicate versions
@@ -145,6 +396,9 @@ Targets:
   hooks      Orphan hook scripts only
   versions   Older duplicate version installs only
   <agent>    Older duplicate versions for one agent (e.g. 'claude')
+  trash      Soft-deleted resources older than --older-than days (default 30)
+  sessions   Session records in sessions.db older than --older-than days (default 90)
+  runs       Routine execution logs, keeping only --keep per job (default 10)
 
 Examples:
   # Full sweep: orphan resources + duplicate versions for current defaults
@@ -156,14 +410,26 @@ Examples:
   # Just version dedup
   agents prune versions
 
-  # Just version dedup for one agent
-  agents prune claude
-
   # Sweep every installed version's orphans, not only the defaults
   agents prune --all
 
-  # Preview without deleting
-  agents prune --dry-run
+  # Preview trash entries older than 30 days
+  agents prune trash --dry-run
+
+  # Delete trash entries older than 60 days
+  agents prune trash --older-than 60 -y
+
+  # Preview session cleanup (90+ days old)
+  agents prune sessions --dry-run
+
+  # Delete sessions older than 180 days
+  agents prune sessions --older-than 180 -y
+
+  # Preview runs cleanup (keeping last 10)
+  agents prune runs --dry-run
+
+  # Keep only the last 5 runs per job
+  agents prune runs --keep 5 -y
 
 What's an orphan?
   A command, skill, or hook present inside a version home but missing from every
@@ -171,18 +437,27 @@ What's an orphan?
   repos). Usually leftovers from a resource that was deleted or moved but never
   reconciled into the version install.
 
-What this does NOT do:
-  Adds and updates flow through the auto-sync that runs when you launch the
-  agent — there is no manual sync verb.
-
 Soft-delete:
   Version directories are NEVER hard-deleted. \`prune\` moves them to
-  ~/.agents-system/trash/versions/<agent>/<version>/<timestamp>/. Recover
-  with \`agents trash list\` and \`agents trash restore <agent>@<version>\`.
-  The trash never auto-expires; \`rm -rf\` it manually when you're sure.
+  ~/.agents/.trash/versions/<agent>/<version>/<timestamp>/. Use
+  \`agents prune trash\` to expire old trash entries.
 `)
         .action(async (target, options) => {
         const parsed = parseTarget(target);
+        if (parsed.stateType) {
+            switch (parsed.stateType) {
+                case 'trash':
+                    await runTrashPrune(options);
+                    break;
+                case 'sessions':
+                    await runSessionsPrune(options);
+                    break;
+                case 'runs':
+                    await runRunsPrune(options);
+                    break;
+            }
+            return;
+        }
         if (parsed.resourceTypes.length > 0) {
             await runOrphanPrune(parsed.resourceTypes, options);
             if (parsed.includeVersions)

package/dist/commands/pull.js

@@ -80,12 +80,12 @@ Skip CLI installs with --skip-clis when you only want config updates, not versio
         // auto-syncs the system repo in the background and surfaces upstream
         // changes for user/extra repos as one-line notices. Repo lifecycle is
         // managed under `agents repo`. We keep this command functional today
-        // because `agents init` still invokes it for first-time setup; once
-        // init is refactored to call the bootstrap helpers directly, this
+        // because `agents setup` still invokes it for first-time setup; once
+        // setup is refactored to call the bootstrap helpers directly, this
         // command will hard-error like `agents memory` does.
         if (!options.yes && process.argv[2] === 'pull') {
             process.stderr.write('agents-cli: "agents pull" is deprecated.\n' +
-                '            First-time setup:  agents init\n' +
+                '            First-time setup:  agents setup\n' +
                 '            Force a sync now:  agents repo pull\n' +
                 '            Push your repo:    agents repo push\n\n');
         }

package/dist/commands/repo.js

@@ -257,7 +257,7 @@ Examples:
         const systemStatus = !systemOnDisk
             ? chalk.red('missing')
             : !systemIsGit
-                ? chalk.yellow('not a git repo — run: agents init')
+                ? chalk.yellow('not a git repo — run: agents setup')
                 : chalk.green('cloned');
         const systemCommitLabel = systemCommit ? chalk.gray(`(${systemCommit})`) : '';
         console.log(chalk.bold('System  (~/.agents-system/)'));

package/dist/commands/routines.js

@@ -571,8 +571,8 @@ Examples:
         .action(async (options) => {
         if (options.follow) {
             const { exec: execCb } = await import('child_process');
-            const { getAgentsDir } = await import('../lib/state.js');
-            const logPath = path.join(getAgentsDir(), 'helpers/daemon/logs.jsonl');
+            const { getDaemonDir } = await import('../lib/state.js');
+            const logPath = path.join(getDaemonDir(), 'logs.jsonl');
             const child = execCb(`tail -f "${logPath}"`);
             child.stdout?.pipe(process.stdout);
             child.stderr?.pipe(process.stderr);

package/dist/commands/secrets.js

@@ -280,6 +280,10 @@ Examples:
   # Eval the bundle into your current shell
   eval "$(agents secrets export prod --plaintext)"
 
+  # Run a command with secrets injected
+  agents secrets exec prod -- ./deploy.sh
+  agents secrets exec hetzner.com -- crabbox list
+
   # Remove one key (purges the keychain item by default)
   agents secrets remove prod STRIPE_API_KEY
 
@@ -297,7 +301,7 @@ Examples:
     registerCommandGroups(cmd, [
         { title: 'Bundle commands', names: ['list', 'view', 'create', 'delete'] },
         { title: 'Secret commands', names: ['add', 'rotate', 'remove', 'import', 'export'] },
-        { title: 'Utilities', names: ['generate'] },
+        { title: 'Utilities', names: ['exec', 'generate'] },
     ]);
     cmd
         .command('list')
@@ -711,6 +715,38 @@ Examples:
             process.exit(1);
         }
     });
+    cmd
+        .command('exec <bundle> [command...]')
+        .description('Run a command with the bundle\'s secrets injected into the environment')
+        .allowUnknownOption()
+        .action(async (bundleName, commandParts) => {
+        try {
+            if (commandParts.length === 0) {
+                console.error(chalk.red('Usage: agents secrets exec <bundle> -- <command...>'));
+                process.exit(1);
+            }
+            const { resolveBundleEnv } = await import('../lib/secrets/bundles.js');
+            const bundle = readBundle(bundleName);
+            const secretEnv = resolveBundleEnv(bundle);
+            const { spawn } = await import('child_process');
+            const [cmd, ...args] = commandParts;
+            const proc = spawn(cmd, args, {
+                stdio: 'inherit',
+                env: { ...process.env, ...secretEnv },
+            });
+            proc.on('close', (code) => process.exit(code ?? 0));
+            proc.on('error', (err) => {
+                console.error(chalk.red(`Failed to run '${cmd}': ${err.message}`));
+                process.exit(1);
+            });
+        }
+        catch (err) {
+            if (isPromptCancelled(err))
+                return;
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
     cmd
         .command('generate [length]')
         .description('Generate a random password')

package/dist/commands/sessions.js

@@ -160,6 +160,26 @@ function formatStartedAt(startedAtMs) {
         return '-';
     return formatRelativeTime(new Date(startedAtMs).toISOString());
 }
+/** Build a display-friendly description for an active session (label or topic). */
+function buildSessionDescription(s) {
+    if (s.context === 'cloud') {
+        return `${s.cloudProvider ?? ''}${s.cloudTaskId ? ` · ${s.cloudTaskId.slice(0, 12)}` : ''}`;
+    }
+    if (s.context === 'teams') {
+        const parts = [s.teamName];
+        if (s.label)
+            parts.push(s.label);
+        else if (s.topic)
+            parts.push(s.topic);
+        return parts.filter(Boolean).join(' · ');
+    }
+    // Terminal or headless: prefer label, then topic
+    if (s.label)
+        return s.label;
+    if (s.topic)
+        return s.topic;
+    return '';
+}
 /** Render the unified active-session view. */
 async function renderActiveSessions(asJson) {
     const sessions = await getActiveSessions();
@@ -171,26 +191,49 @@ async function renderActiveSessions(asJson) {
         console.log(chalk.gray('No active agent sessions.'));
         return;
     }
+    // Group sessions by workspace (cwd), with cloud/undefined grouped separately
+    const byWorkspace = new Map();
     for (const s of sessions) {
-        const kindCol = colorAgent(s.kind)(padRight(truncate(s.kind, 8), 9));
-        const ctxCol = contextColor(s.context)(padRight(truncate(s.context, 8), 9));
-        const hostCol = chalk.gray(padRight(truncate(s.host ?? '-', 8), 9));
-        const statusCol = statusColor(s.status)(padRight(truncate(s.status, 8), 9));
-        const pidCol = chalk.yellow(padRight(s.pid ? String(s.pid) : '-', 7));
-        const idCol = chalk.white(padRight(s.sessionId ? s.sessionId.slice(0, 8) : '-', 10));
-        const detail = s.context === 'cloud'
-            ? `${s.cloudProvider ?? ''}${s.cloudTaskId ? ` · ${s.cloudTaskId.slice(0, 12)}` : ''}`
-            : s.context === 'teams'
-                ? `${s.teamName ?? ''}${s.label ? ` · ${s.label}` : ''}`
-                : s.label ?? shortCwd(s.cwd);
-        console.log(pidCol +
-            kindCol +
-            ctxCol +
-            hostCol +
-            statusCol +
-            idCol +
-            chalk.cyan(padRight(truncate(detail || '-', 30), 32)) +
-            chalk.gray(formatStartedAt(s.startedAtMs)));
+        const key = s.cwd ?? (s.context === 'cloud' ? '__cloud__' : '__unknown__');
+        const list = byWorkspace.get(key) || [];
+        list.push(s);
+        byWorkspace.set(key, list);
+    }
+    // Sort workspaces: most sessions first, then alphabetically
+    const sortedKeys = Array.from(byWorkspace.keys()).sort((a, b) => {
+        const aCount = byWorkspace.get(a).length;
+        const bCount = byWorkspace.get(b).length;
+        if (aCount !== bCount)
+            return bCount - aCount;
+        return a.localeCompare(b);
+    });
+    let first = true;
+    for (const key of sortedKeys) {
+        const group = byWorkspace.get(key);
+        if (!first)
+            console.log();
+        first = false;
+        // Print workspace header
+        const header = key === '__cloud__'
+            ? chalk.magenta.bold('cloud')
+            : key === '__unknown__'
+                ? chalk.gray.bold('unknown')
+                : chalk.cyan.bold(shortCwd(key));
+        console.log(`${header} ${chalk.gray(`(${group.length})`)}`);
+        // Print each session in this workspace
+        for (const s of group) {
+            const kindCol = colorAgent(s.kind)(padRight(truncate(s.kind, 8), 9));
+            const hostCol = chalk.gray(padRight(truncate(s.host ?? '-', 8), 9));
+            const statusCol = statusColor(s.status)(padRight(truncate(s.status, 7), 8));
+            const pidCol = chalk.yellow(padRight(s.pid ? String(s.pid) : '-', 7));
+            const desc = buildSessionDescription(s);
+            console.log('  ' +
+                pidCol +
+                kindCol +
+                hostCol +
+                statusCol +
+                chalk.white(truncate(desc || '-', 50)));
+        }
     }
     const runningCount = sessions.filter(s => s.status === 'running').length;
     const idleCount = sessions.filter(s => s.status === 'idle').length;

package/dist/commands/{init.d.ts → setup.d.ts}

@@ -1,20 +1,21 @@
 /**
- * First-run initialization command.
+ * First-run setup command.
  *
- * Registers the `agents init` command which clones the system repo into
+ * Registers the `agents setup` command which clones the system repo into
  * ~/.agents-system/ and installs agent CLIs with resource syncing.
  */
 import type { Command } from 'commander';
 /** First-run setup. Clones ~/.agents-system/ from the system repo if needed. */
-export declare function runInit(program: Command, options?: {
+export declare function runSetup(program: Command, options?: {
     force?: boolean;
+    suppressFooter?: boolean;
 }): Promise<void>;
 /**
  * Ensure the system repo exists before running a command that needs it.
  * If ~/.agents-system/ is not a git repo AND we're in an interactive TTY,
- * prompt the user to run init now. In non-interactive mode, print a clear
+ * prompt the user to run setup now. In non-interactive mode, print a clear
  * error and exit.
  */
 export declare function ensureInitialized(program: Command): Promise<void>;
-/** Register the `agents init` command. */
-export declare function registerInitCommand(program: Command): void;
+/** Register the `agents setup` command. */
+export declare function registerSetupCommand(program: Command): void;