@phnx-labs/agents-cli 1.20.92 → 1.21.0

package/dist/lib/teams/agents.js

@@ -34,7 +34,9 @@ import { resolveRemoteOsSync } from '../hosts/remote-os.js';
 import { pullRemoteLogDelta, REMOTE_MIRROR_MAX_BYTES } from '../hosts/progress.js';
 import { createRemoteWorktree, ensureRemoteRepo } from './remoteWorktree.js';
 import { getTeam } from './registry.js';
-import { resolvePlacement } from './scheduler.js';
+import { resolvePlacement, cappedDevices } from './scheduler.js';
+import { readMaxConcurrentCaps } from '../device-config.js';
+import chalk from 'chalk';
 let lastMemoryWarnAt = 0;
 // On macOS, os.freemem() returns only the truly-free pool and ignores the
 // large inactive+purgeable cache the kernel will reclaim under pressure, so
@@ -669,10 +671,21 @@ export class AgentProcess {
      * Uses a per-wave batched snapshot (remotePollSnapshot) when the supervisor's
      * one-ssh-per-host pre-pass populated it; otherwise falls back to its own
      * round-trips so a bare `teams status`/`teams logs` is still correct.
+     *
+     * Only polls a teammate that is plausibly still RUNNING (RUSH-2118). Once a
+     * remote teammate reaches a terminal status, the poll that resolved it already
+     * mirrored the final log bytes and read the `.exit` sentinel in this SAME
+     * function (delta pulled before the exit check below) — the underlying process
+     * is gone and can never write more, so there is nothing left to fetch. Without
+     * this guard every finished remote teammate still cost one ssh round-trip on
+     * EVERY `--active`/`listAll` poll forever, which is what made `agents sessions
+     * --active --local` take ~4.3s on a box with 30 completed teammates.
      */
     async syncRemoteMirror() {
         if (!this.hostName || !this.hostTarget || !this.remoteLog)
             return;
+        if (this.status !== AgentStatus.RUNNING)
+            return;
         // Pull the new remote bytes and append them to the local mirror the parser
         // reads. One offset-tail round-trip; nothing to write when the log is quiet.
         const delta = pullRemoteLogDelta(this.hostTarget, {
@@ -729,7 +742,15 @@ export class AgentProcess {
     restoreLogReadPosition(position) {
         this.lastReadPos = position;
     }
-    async readNewEvents() {
+    /**
+     * @param opts.skipRemote A `--local` caller (RUSH-2118): never dial a
+     *   remote-host teammate, not even a still-RUNNING one — report its
+     *   last-persisted meta.json state as-is. A local-only query is by definition
+     *   this-machine-only, so it must not issue an ssh round-trip at all.
+     */
+    async readNewEvents(opts = {}) {
+        if (this.hostName && opts.skipRemote)
+            return;
         // Distributed teammate: mirror the host's new log bytes locally first, then
         // fall through to the identical local read+parse below.
         if (this.hostName) {
@@ -984,7 +1005,12 @@ export class AgentProcess {
         }
         return true;
     }
-    async updateStatusFromProcess() {
+    /**
+     * @param opts.skipRemote A `--local` caller (RUSH-2118): a distributed
+     *   teammate is never dialed — its in-memory state (already loaded from
+     *   meta.json) stands as-is, no ssh, no re-save.
+     */
+    async updateStatusFromProcess(opts = {}) {
         if (!this.pid) {
             // Distributed (remote-host) teammates have no local PID by design; their
             // lifecycle lives on the host. readNewEvents() mirrors the remote log and
@@ -992,6 +1018,8 @@ export class AgentProcess {
             // syncRemoteMirror), so we just persist and return — never the local
             // "RUNNING without a PID is impossible" fail path below.
             if (this.hostName) {
+                if (opts.skipRemote)
+                    return;
                 await this.readNewEvents();
                 if (this.status !== AgentStatus.RUNNING && !this.completedAt) {
                     this.completedAt = this.getLatestEventTime() || this.startedAt || new Date();
@@ -1160,12 +1188,21 @@ export class AgentManager {
     defaultMode;
     initPromise = null;
     cloudDispatcher = null;
+    /**
+     * A `--local` caller (RUSH-2118): every poll this manager issues skips the
+     * ssh round-trip for a distributed (remote-host) teammate, reporting its
+     * last-persisted meta.json state instead. Set once at construction so the
+     * INITIAL load in doInitialize()/loadExistingAgents() — which polls every
+     * teammate before listRunning()/listAll() ever run — honors it too.
+     */
+    localOnly;
     constructorAgentsDir = null;
-    constructor(maxAgents = 50, agentsDir = null, defaultMode = null, filterByCwd = null, cleanupAgeDays = 7) {
+    constructor(maxAgents = 50, agentsDir = null, defaultMode = null, filterByCwd = null, cleanupAgeDays = 7, localOnly = false) {
         this.maxAgents = maxAgents;
         this.constructorAgentsDir = agentsDir;
         this.filterByCwd = filterByCwd;
         this.cleanupAgeDays = cleanupAgeDays;
+        this.localOnly = localOnly;
         const resolvedDefaultMode = defaultMode ? normalizeModeValue(defaultMode) : defaultModeFromEnv();
         if (!resolvedDefaultMode) {
             throw new Error(`Invalid default_mode '${defaultMode}'. Use plan, edit, auto, or skip.`);
@@ -1272,7 +1309,7 @@ export class AgentManager {
                     continue;
                 }
             }
-            await agent.updateStatusFromProcess();
+            await agent.updateStatusFromProcess({ skipRemote: this.localOnly });
             this.agents.set(agentId, agent);
             loadedCount++;
         }
@@ -1726,7 +1763,14 @@ export class AgentManager {
         if (!teamMeta)
             return;
         const roster = await this.listByTask(taskName);
-        const { device } = resolvePlacement(teamMeta, null, roster);
+        const pool = teamMeta.devices ?? [];
+        const maxConcurrent = pool.length > 1 ? readMaxConcurrentCaps(pool) : undefined;
+        if (maxConcurrent) {
+            for (const c of cappedDevices(pool, roster, maxConcurrent)) {
+                console.error(chalk.dim(`[placement] '${c.device}' excluded from auto-pick — at its agents.max-concurrent cap (${c.running}/${c.cap} running)`));
+            }
+        }
+        const { device } = resolvePlacement(teamMeta, null, roster, { maxConcurrent });
         if (device)
             await this.resolveScheduledPlacement(agent, device, taskName);
     }
@@ -1990,8 +2034,8 @@ export class AgentManager {
         await this.initialize();
         const agents = Array.from(this.agents.values());
         for (const agent of agents) {
-            await agent.readNewEvents();
-            await agent.updateStatusFromProcess();
+            await agent.readNewEvents({ skipRemote: this.localOnly });
+            await agent.updateStatusFromProcess({ skipRemote: this.localOnly });
         }
         return agents;
     }

package/dist/lib/teams/scheduler.d.ts

@@ -2,6 +2,19 @@
 export interface PlacementTeam {
     devices?: string[];
 }
+/**
+ * Optional placement inputs beyond the team + roster. `maxConcurrent` maps a
+ * device name to its `agents.max-concurrent` cap (from the device doc — read
+ * locally via `readMaxConcurrentCaps`, never probed over SSH). Teams counts
+ * the team's OWN roster against the cap (device-global counting would need an
+ * SSH probe per candidate — out of the hot path; Factory auto-launch is the
+ * device-wide counter). Only the least-loaded AUTO-PICK (cascade step 3)
+ * honors caps: an explicit pin or a pool of one is the user's own choice and
+ * is never second-guessed.
+ */
+export interface PlacementOptions {
+    maxConcurrent?: Record<string, number>;
+}
 /**
  * A roster entry the load counter reads — the shape any teammate satisfies
  * (AgentProcess included). `status` is compared against `'running'` (the
@@ -11,19 +24,33 @@ export interface RosterEntry {
     hostName: string | null;
     status: string;
 }
+/**
+ * Pool devices excluded from auto-pick because they are at (or over) their
+ * `agents.max-concurrent` cap. Returned with the live counts so the caller can
+ * state the reason to the user instead of the device silently never winning.
+ */
+export declare function cappedDevices(devices: string[], roster: RosterEntry[], maxConcurrent: Record<string, number>): Array<{
+    device: string;
+    running: number;
+    cap: number;
+}>;
 /**
  * Pick the least-loaded device from the pool — the one with the fewest RUNNING
  * teammates currently assigned to it. Ties break by pool order (first wins), so
  * an empty pool fills round-robin-ish as teammates launch. Pure: counts the
  * roster, no I/O.
+ *
+ * With `maxConcurrent`, devices at their cap are excluded; if EVERY device is
+ * capped this throws naming each cap and the fix — a loud failure beats a
+ * teammate silently landing on a machine its operator capped.
  */
-export declare function pickLeastLoaded(devices: string[], roster: RosterEntry[]): string;
+export declare function pickLeastLoaded(devices: string[], roster: RosterEntry[], maxConcurrent?: Record<string, number>): string;
 /**
  * Resolve where a teammate runs. Returns `{ device: null }` for a local run
  * (no pin, no pool, or the chosen device is the local machine) and
  * `{ device: <name> }` for a remote placement. See the cascade in the module
  * header.
  */
-export declare function resolvePlacement(team: PlacementTeam, explicitDevice: string | null, roster: RosterEntry[]): {
+export declare function resolvePlacement(team: PlacementTeam, explicitDevice: string | null, roster: RosterEntry[], opts?: PlacementOptions): {
     device: string | null;
 };

package/dist/lib/teams/scheduler.js

@@ -11,6 +11,11 @@
  *   3. else the team pool has many devices           → least-loaded pick
  *   4. else (no pin, no pool)                         → null == run local
  *
+ * Step 3 is cap-aware: a device at its `agents.max-concurrent` cap (from the
+ * device doc, passed in via PlacementOptions) is excluded from the auto-pick,
+ * and an all-capped pool fails loud. Pins and pools of one are the user's own
+ * choice and are never second-guessed.
+ *
  * A device whose name equals the local machine id is treated as "local" — it
  * resolves to a null placement so the existing local spawn path runs unchanged,
  * letting the local machine participate in a pool as just another member.
@@ -20,31 +25,70 @@ import { machineId } from '../session/sync/config.js';
 function isLocalDevice(device) {
     return device.toLowerCase() === machineId();
 }
+/** Count RUNNING teammates per pool device. Pure. A null/empty hostName is a
+ * LOCAL teammate — it counts against the pool member that is this machine,
+ * otherwise a cap on the local device could never engage. */
+function loadByDevice(devices, roster) {
+    const load = new Map();
+    for (const d of devices)
+        load.set(d, 0);
+    for (const r of roster) {
+        if (r.status !== 'running')
+            continue;
+        const host = r.hostName ? r.hostName : devices.find((d) => isLocalDevice(d));
+        if (!host)
+            continue; // local teammate but this machine is not in the pool
+        if (load.has(host))
+            load.set(host, (load.get(host) ?? 0) + 1);
+    }
+    return load;
+}
+/**
+ * Pool devices excluded from auto-pick because they are at (or over) their
+ * `agents.max-concurrent` cap. Returned with the live counts so the caller can
+ * state the reason to the user instead of the device silently never winning.
+ */
+export function cappedDevices(devices, roster, maxConcurrent) {
+    const load = loadByDevice(devices, roster);
+    const capped = [];
+    for (const d of devices) {
+        const cap = maxConcurrent[d];
+        if (cap === undefined)
+            continue;
+        const running = load.get(d) ?? 0;
+        if (running >= cap)
+            capped.push({ device: d, running, cap });
+    }
+    return capped;
+}
 /**
  * Pick the least-loaded device from the pool — the one with the fewest RUNNING
  * teammates currently assigned to it. Ties break by pool order (first wins), so
  * an empty pool fills round-robin-ish as teammates launch. Pure: counts the
  * roster, no I/O.
+ *
+ * With `maxConcurrent`, devices at their cap are excluded; if EVERY device is
+ * capped this throws naming each cap and the fix — a loud failure beats a
+ * teammate silently landing on a machine its operator capped.
  */
-export function pickLeastLoaded(devices, roster) {
+export function pickLeastLoaded(devices, roster, maxConcurrent) {
     if (devices.length === 0) {
         throw new Error('pickLeastLoaded called with an empty device pool');
     }
-    const load = new Map();
-    for (const d of devices)
-        load.set(d, 0);
-    for (const r of roster) {
-        if (!r.hostName)
-            continue;
-        if (r.status !== 'running')
-            continue;
-        if (load.has(r.hostName))
-            load.set(r.hostName, (load.get(r.hostName) ?? 0) + 1);
+    const load = loadByDevice(devices, roster);
+    const capped = new Set(maxConcurrent ? cappedDevices(devices, roster, maxConcurrent).map((c) => c.device) : []);
+    const eligible = devices.filter((d) => !capped.has(d));
+    if (eligible.length === 0) {
+        const detail = devices
+            .map((d) => `${d} (${load.get(d) ?? 0}/${maxConcurrent[d]})`)
+            .join(', ');
+        throw new Error(`Every device in the pool is at its agents.max-concurrent cap: ${detail}. ` +
+            `Raise a cap with 'agents devices configure <name> --max-agents N' or add a device to the pool.`);
     }
     // Iterate the pool in declared order so the first device wins ties.
-    let best = devices[0];
+    let best = eligible[0];
     let bestLoad = load.get(best) ?? 0;
-    for (const d of devices) {
+    for (const d of eligible) {
         const l = load.get(d) ?? 0;
         if (l < bestLoad) {
             best = d;
@@ -59,7 +103,7 @@ export function pickLeastLoaded(devices, roster) {
  * `{ device: <name> }` for a remote placement. See the cascade in the module
  * header.
  */
-export function resolvePlacement(team, explicitDevice, roster) {
+export function resolvePlacement(team, explicitDevice, roster, opts) {
     // 1. Explicit pin wins — even without a pool.
     if (explicitDevice) {
         return { device: isLocalDevice(explicitDevice) ? null : explicitDevice };
@@ -72,7 +116,7 @@ export function resolvePlacement(team, explicitDevice, roster) {
     if (pool.length === 1) {
         return { device: isLocalDevice(pool[0]) ? null : pool[0] };
     }
-    // 3. Many → least-loaded across the pool.
-    const picked = pickLeastLoaded(pool, roster);
+    // 3. Many → least-loaded across the pool (cap-aware when caps are provided).
+    const picked = pickLeastLoaded(pool, roster, opts?.maxConcurrent);
     return { device: isLocalDevice(picked) ? null : picked };
 }

package/dist/lib/types.d.ts

@@ -62,7 +62,7 @@ export interface BudgetConfig {
     require_confirm_over?: number;
 }
 /** Preview features that users can opt into via `agents beta`. */
-export type BetaFeatureName = 'drive' | 'factory' | 'session-sync' | 'projects';
+export type BetaFeatureName = 'factory' | 'projects';
 /** Subset of chalk color names used for agent-specific terminal output. */
 export type ChalkColor = 'magenta' | 'green' | 'blue' | 'cyan' | 'yellowBright' | 'redBright' | 'whiteBright' | 'blueBright' | 'greenBright' | 'magentaBright' | 'cyanBright';
 /** Static configuration for a single agent -- paths, capabilities, and format conventions. */
@@ -845,6 +845,22 @@ export interface Meta {
      * `agents browser profiles set-default <name>`.
      */
     defaultBrowserProfile?: string;
+    /**
+     * User-scope config block (`config:` in central agents.yaml). Holds the
+     * user-scope keys from the device-config registry (`lib/device-config.ts`) —
+     * today just `interactiveHost`. Syncs fleet-wide via `agents repo push/pull`.
+     * Device-scope keys live in {@link Meta.deviceConfig} instead.
+     */
+    config?: Record<string, unknown>;
+    /**
+     * Device-scope config block, carried in memory under a distinct field so it
+     * can never leak into the central (synced) agents.yaml: `writeMetaUnlocked`
+     * routes it to `~/.agents/devices/<machine>/agents.yaml` under the `config:`
+     * key (mirroring how `defaultBrowserProfile` is routed), and
+     * `overlayMachineLocal` reads it back. Holds the device-scope keys from the
+     * device-config registry (`maxAgents`, `schedulerEnabled`, `notes`). Per-machine by design — unset = today's behavior.
+     */
+    deviceConfig?: Record<string, unknown>;
     /**
      * Agent-host registry keyed by host name (`agents hosts`). Portable user
      * config synced with `agents repo push/pull`. For `ssh-config` hosts this is
@@ -873,10 +889,11 @@ export interface Meta {
     };
     /**
      * Owner/channel notification config for `agents send` / `agents notify`.
-     * `owner` is the default recipient for `agents notify` (channel + target).
-     * `transports` maps a user-facing channel name to the provider that actually
-     * delivers it — explicit, one provider per channel, no fallback. Omitted keys
-     * default to name-identity (channel `slack` -> provider `slack`).
+     * `owner` is the address expanded by `--to owner` and by `agents notify`
+     * (channel + target). `transports` maps a user-facing channel name to the
+     * provider that actually delivers it — explicit, one provider per channel,
+     * no fallback. Omitted keys default to name-identity (channel `slack` ->
+     * provider `slack`).
      */
     notify?: {
         owner?: {

package/dist/lib/versions.d.ts

@@ -464,6 +464,12 @@ export interface SyncResult {
     subagents: string[];
     plugins: string[];
     workflows: string[];
+    /**
+     * Project files the sync left alone because the workspace already has them
+     * (repo-relative). Reported once, grouped, by the command that rendered the
+     * sync — never one line per file from down here.
+     */
+    projectSkipped: string[];
 }
 /**
  * Enumerate the DotAgent repo names that resources can be scoped to:

package/dist/lib/versions.js

@@ -2420,7 +2420,7 @@ export function mergeRepoScopedSelections(repos, cwd = process.cwd()) {
  */
 export function syncResourcesToVersion(agent, version, selection, options = {}) {
     if (isAgentHardDeprecated(agent)) {
-        return { commands: false, skills: false, hooks: false, memory: [], permissions: false, mcp: [], subagents: [], plugins: [], workflows: [] };
+        return { commands: false, skills: false, hooks: false, memory: [], permissions: false, mcp: [], subagents: [], plugins: [], workflows: [], projectSkipped: [] };
     }
     const agentConfig = AGENTS[agent];
     const versionHome = getVersionHomePath(agent, version);
@@ -2431,7 +2431,7 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
     // care about the ORIGINAL intent: a caller passing no selection means
     // "full sync; persist the staleness manifest after."
     const userPassedSelection = selection !== undefined;
-    const result = { commands: false, skills: false, hooks: false, memory: [], permissions: false, mcp: [], subagents: [], plugins: [], workflows: [] };
+    const result = { commands: false, skills: false, hooks: false, memory: [], permissions: false, mcp: [], subagents: [], plugins: [], workflows: [], projectSkipped: [] };
     const cwd = options.cwd || process.cwd();
     const projectAgentsDir = options.projectDir || getProjectAgentsDir(cwd);
     const userAgentsDir = getUserAgentsDir();
@@ -2499,7 +2499,7 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
         }
     }
     if (projectAgentsDir) {
-        syncProjectResourcesToAgent(agent, version, projectAgentsDir);
+        result.projectSkipped = syncProjectResourcesToAgent(agent, version, projectAgentsDir).skipped;
     }
     // Fast guard: skip the entire sync when the caller requested a full sync and
     // nothing has changed since the last full sync. Pattern-derived selections
@@ -2508,7 +2508,9 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
     if (!userPassedSelection && !options.force) {
         const manifest = loadManifest(agent, version);
         if (manifest && !isStale(manifest, agent, version, cwd)) {
-            return { commands: false, skills: false, hooks: false, memory: [], permissions: false, mcp: [], subagents: [], plugins: [], workflows: [] };
+            // Nothing synced, but the project sync above already ran — carry its
+            // skipped files out so the caller can still report them.
+            return { ...result };
         }
     }
     // Helper: remove a path (symlink or real) if it exists

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.92",
+  "version": "1.21.0",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",
@@ -90,7 +90,6 @@
     "@xterm/headless": "6.0.0",
     "@zed-industries/agent-client-protocol": "0.4.5",
     "age-encryption": "0.3.0",
-    "aws4fetch": "1.0.20",
     "chalk": "5.6.2",
     "commander": "15.0.0",
     "croner": "10.0.1",

package/dist/commands/drive.d.ts

@@ -1,10 +0,0 @@
-/**
- * Drive sync commands.
- *
- * Registers the `agents drive` command tree for syncing agent session
- * history across machines via rsync. Supports pull, push, attach
- * (redirect agent homes to drive), and detach operations.
- */
-import type { Command } from 'commander';
-/** Register the `agents drive` command tree. */
-export declare function registerDriveCommands(program: Command): void;

package/dist/commands/drive.js

@@ -1,183 +0,0 @@
-/**
- * Drive sync commands.
- *
- * Registers the `agents drive` command tree for syncing agent session
- * history across machines via rsync. Supports pull, push, attach
- * (redirect agent homes to drive), and detach operations.
- */
-import chalk from 'chalk';
-import ora from 'ora';
-import { betaEnableHint, isBetaEnabled } from '../lib/beta.js';
-import { setRemote, pull, push, attach, detach, getDriveStatus, } from '../lib/drive-sync.js';
-/** Register the `agents drive` command tree. */
-export function registerDriveCommands(program) {
-    const enabled = isBetaEnabled('drive');
-    const driveCmd = program
-        .command('drive', { hidden: !enabled })
-        .description('Sync agent session history across machines via rsync. Set up once, then pull/push to keep sessions in sync.')
-        .addHelpText('after', `
-Typical workflow:
-  # One-time setup: point to your remote machine
-  agents drive remote user@hostname
-
-  # Pull sessions from remote to local
-  agents drive pull
-
-  # Work locally with your agents...
-
-  # Push your new sessions back to remote
-  agents drive push
-
-  # Check sync state
-  agents drive status
-
-Use case: Keep session history consistent across your laptop and desktop,
-or back up sessions to a server you control.
-`);
-    driveCmd.hook('preAction', () => {
-        if (enabled)
-            return;
-        console.error(chalk.red('agents drive is in beta.'));
-        console.error(chalk.gray(betaEnableHint('drive')));
-        process.exit(1);
-    });
-    driveCmd
-        .command('remote <target>')
-        .description('Set the rsync remote target (e.g., user@hostname). Sessions sync to <target>:~/.agents/drive/')
-        .addHelpText('after', `
-Examples:
-  # Set remote to a server
-  agents drive remote user@server
-
-  # Set remote to a local machine on your network
-  agents drive remote macbook.local
-`)
-        .action((target) => {
-        try {
-            setRemote(target);
-            console.log(chalk.green(`Remote set to ${target}`));
-            console.log(chalk.gray(`Syncs to ${target}:~/.agents/drive/`));
-        }
-        catch (err) {
-            console.error(chalk.red(err.message));
-            process.exit(1);
-        }
-    });
-    driveCmd
-        .command('pull')
-        .description('Fetch sessions from the remote and merge them into your local ~/.agents/drive/.')
-        .addHelpText('after', `
-Example:
-  agents drive pull
-
-Run this when you switch machines to get the latest session history.
-`)
-        .action(async () => {
-        const spinner = ora('Pulling from remote...').start();
-        try {
-            await pull();
-            spinner.succeed('Pull complete');
-        }
-        catch (err) {
-            spinner.fail(err.message);
-            process.exit(1);
-        }
-    });
-    driveCmd
-        .command('push')
-        .description('Upload your local sessions to the remote so other machines can pull them.')
-        .addHelpText('after', `
-Example:
-  agents drive push
-
-Run this after working locally to share your new sessions with other machines.
-`)
-        .action(async () => {
-        const spinner = ora('Pushing to remote...').start();
-        try {
-            await push();
-            spinner.succeed('Push complete');
-        }
-        catch (err) {
-            spinner.fail(err.message);
-            process.exit(1);
-        }
-    });
-    driveCmd
-        .command('attach')
-        .description('Point your agent homes (~/.claude, etc.) at drive so sessions write directly to the synced location.')
-        .addHelpText('after', `
-Example:
-  agents drive attach
-
-After attach, agent sessions are saved to ~/.agents/drive/ instead of version homes.
-Use 'detach' to switch back to version-specific homes.
-`)
-        .action(() => {
-        try {
-            attach();
-            console.log(chalk.green('Drive attached'));
-        }
-        catch (err) {
-            console.error(chalk.red(err.message));
-            process.exit(1);
-        }
-    });
-    driveCmd
-        .command('detach')
-        .description('Restore agent homes back to their version-specific directories (undo attach).')
-        .addHelpText('after', `
-Example:
-  agents drive detach
-`)
-        .action(() => {
-        try {
-            detach();
-            console.log(chalk.green('Drive detached'));
-        }
-        catch (err) {
-            console.error(chalk.red(err.message));
-            process.exit(1);
-        }
-    });
-    driveCmd
-        .command('status')
-        .description('Show current drive configuration, attach state, and last sync times.')
-        .addHelpText('after', `
-Example:
-  agents drive status
-`)
-        .action(() => {
-        const status = getDriveStatus();
-        console.log(chalk.bold('Drive'));
-        console.log(`  Remote:     ${status.remote || chalk.gray('not set')}`);
-        console.log(`  Attached:   ${status.attached ? chalk.green('yes') : chalk.gray('no')}`);
-        console.log(`  Last pull:  ${status.lastPull ? formatTime(status.lastPull) : chalk.gray('never')}`);
-        console.log(`  Last push:  ${status.lastPush ? formatTime(status.lastPush) : chalk.gray('never')}`);
-        console.log(`  Path:       ${chalk.gray(status.driveDir)}`);
-        console.log('');
-        console.log(chalk.bold('Symlinks'));
-        console.log(`  ~/.claude       -> ${status.configDirTarget || chalk.gray('not a symlink')}`);
-        for (const [hf, target] of Object.entries(status.homeFileTargets)) {
-            console.log(`  ~/${hf}  -> ${target || chalk.gray('not a symlink')}`);
-        }
-    });
-}
-/** Format an ISO timestamp as a human-readable relative time (e.g. "5 min ago"). */
-function formatTime(iso) {
-    const d = new Date(iso);
-    const now = Date.now();
-    const diffMin = Math.floor((now - d.getTime()) / 60_000);
-    if (diffMin < 1)
-        return 'just now';
-    if (diffMin < 60)
-        return `${diffMin} min ago`;
-    const diffHrs = Math.floor(diffMin / 60);
-    if (diffHrs < 24)
-        return `${diffHrs} hour${diffHrs === 1 ? '' : 's'} ago`;
-    const diffDays = Math.floor(diffHrs / 24);
-    if (diffDays < 7)
-        return `${diffDays} day${diffDays === 1 ? '' : 's'} ago`;
-    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-    return `${months[d.getMonth()]} ${d.getDate()}`;
-}

package/dist/commands/hq.d.ts

@@ -1,2 +0,0 @@
-import type { Command } from 'commander';
-export declare function registerHqCommand(program: Command): void;