@phnx-labs/agents-cli 1.22.14 → 1.22.16

package/dist/commands/sessions.js

@@ -814,8 +814,8 @@ export function serializeSessionsJson(sessions) {
     return JSON.stringify(serializable, null, 2) + '\n';
 }
 /** The intentionally small metadata contract emitted by `sessions --resolve`.
- * Transcript locations, extracted plans, account data, costs, and other indexed
- * payload stay local to the machine that owns them. */
+ * It includes only launch identity needed to route/resume. Transcript paths,
+ * extracted plans, costs, and content stay on the machine that owns them. */
 export function serializeResolvedSessionsJson(sessions) {
     const safe = sessions.map((session) => ({
         id: session.id,
@@ -826,6 +826,7 @@ export function serializeResolvedSessionsJson(sessions) {
         lastActivity: session.lastActivity,
         project: session.project,
         version: session.version,
+        mode: session.mode,
         label: session.label,
         topic: session.topic,
         machine: session.machine,
@@ -3447,6 +3448,7 @@ function modeFlag(mode) {
         return '--json';
     return undefined; // summary — the peer's default render
 }
+const FULL_SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 /** Resolve a fleet sweep through the same canonical full-id / prefix resolver as
  * local lookups, then group copies by logical session id. Synced mirrors of one
  * session therefore stay one candidate even when several machines report them;
@@ -3501,19 +3503,46 @@ export function toolSearchForwardedArgs(argv, hosts) {
         args.push('--local');
     return args;
 }
-/** Resolution must fail closed when any selected peer did not answer. Choosing
- * from a partial fleet can turn an unseen candidate into a false unique match. */
+/** Resolution fails closed for prefixes/keywords when a peer did not answer.
+ * A full UUID is globally unique, so one exact hit is sufficient even when an
+ * unrelated registered device is offline. */
 export function metadataResolveOutcome(localMatches, remote, selector) {
-    if (remote.unreachable.length > 0) {
-        return { kind: 'partial', failedPeers: remote.unreachable };
-    }
     const candidates = fleetCandidatesByQuery([...localMatches, ...remote.sessions], selector);
+    if (FULL_SESSION_ID_RE.test(selector) && candidates.length === 1 && candidates[0].id.toLowerCase() === selector.toLowerCase()) {
+        return { kind: 'resolved', session: candidates[0].hits[0].session };
+    }
+    if (remote.unreachable.length > 0)
+        return { kind: 'partial', failedPeers: remote.unreachable };
     if (candidates.length === 0)
         return { kind: 'not-found' };
     if (candidates.length > 1)
         return { kind: 'ambiguous', candidates };
     return { kind: 'resolved', session: candidates[0].hits[0].session };
 }
+/** Reusable local-first resolver for `agents run --resume` and `agents resume`.
+ * Full UUIDs hit the local SQLite index without any SSH fan-out. */
+export async function resolveSessionMetadataValue(selector, scope = {}, deps = { gatherRemoteList }) {
+    const localMachine = machineId();
+    const includeLocal = !scope.hosts?.length || shouldIncludeLocal(scope.hosts, localMachine);
+    const indexed = includeLocal ? applyScopeFilters(querySessions(), scope) : [];
+    const localMatches = resolveIndexedMetadataRows(indexed, selector)
+        .map(session => ({ ...session, machine: session.machine || localMachine }));
+    if (FULL_SESSION_ID_RE.test(selector)) {
+        const localOutcome = metadataResolveOutcome(localMatches, { sessions: [], unreachable: [] }, selector);
+        if (localOutcome.kind === 'resolved')
+            return localOutcome;
+    }
+    if (scope.local === true)
+        return metadataResolveOutcome(localMatches, { sessions: [], unreachable: [] }, selector);
+    try {
+        const forwarded = metadataResolveForwardedArgs(selector, scope);
+        const remote = await deps.gatherRemoteList(forwarded, scope.hosts);
+        return metadataResolveOutcome(localMatches, remote, selector);
+    }
+    catch (error) {
+        return metadataResolveOutcome(localMatches, { sessions: [], unreachable: [error?.message ?? 'fleet fan-out'] }, selector);
+    }
+}
 /** Resolve one selector to indexed metadata across the fleet without reading or
  * rendering transcript events. A peer answering the parent sweep returns every
  * local candidate; the parent performs the one logical-session uniqueness gate. */
@@ -3529,18 +3558,7 @@ async function resolveSessionMetadata(selector, scope, deps = { gatherRemoteList
         process.stdout.write(serializeResolvedSessionsJson(localMatches));
         return;
     }
-    let remoteResult = { sessions: [], unreachable: [] };
-    if (scope.local !== true) {
-        try {
-            const forwarded = metadataResolveForwardedArgs(selector, scope);
-            const result = await deps.gatherRemoteList(forwarded, scope.hosts);
-            remoteResult = { sessions: result.sessions, unreachable: result.unreachable };
-        }
-        catch (error) {
-            remoteResult = { sessions: [], unreachable: [error?.message ?? 'fleet fan-out'] };
-        }
-    }
-    const outcome = metadataResolveOutcome(localMatches, remoteResult, selector);
+    const outcome = await resolveSessionMetadataValue(selector, scope, deps);
     if (outcome.kind === 'partial') {
         console.error(chalk.red(`Partial session resolution: ${outcome.failedPeers.join(', ')} did not answer.`));
         console.error(chalk.gray('No unique/no-match decision was made. Upgrade or reconnect every peer, then retry.'));

package/dist/commands/setup-watchdog.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+export declare function runWatchdogSetupWizard(): Promise<void>;
+export declare function registerSetupWatchdogCommand(setup: Command): void;

package/dist/commands/setup-watchdog.js

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+import { spawnSync } from 'node:child_process';
+import { getCliLaunch } from '../lib/cli-entry.js';
+import { loadDevices } from '../lib/devices/registry.js';
+import { machineId, normalizeHost } from '../lib/machine-id.js';
+import { devicesWithRoutineEnabled } from '../lib/routine-activation.js';
+import { readJob, setJobEnabled } from '../lib/routines.js';
+import { isPromptCancelled, requireInteractiveSelection } from './utils.js';
+const ROUTINE = 'watchdog';
+export async function runWatchdogSetupWizard() {
+    if (!readJob(ROUTINE)) {
+        throw new Error("Built-in routine 'watchdog' is missing. Run: agents repo pull system");
+    }
+    const registry = await loadDevices();
+    const devices = [...new Set([...Object.keys(registry), machineId()].map(normalizeHost))].sort();
+    const enabled = new Set(devicesWithRoutineEnabled(ROUTINE).map(normalizeHost));
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        requireInteractiveSelection('watchdog devices', ['agents watchdog on', 'agents watchdog on --host <device>']);
+    }
+    try {
+        const { checkbox } = await import('@inquirer/prompts');
+        const selected = await checkbox({
+            message: 'Devices where the watchdog should run:',
+            choices: devices.map((device) => ({ name: device, value: device, checked: enabled.has(device) })),
+        });
+        const selectedSet = new Set(selected);
+        for (const device of devices) {
+            const on = selectedSet.has(device);
+            if (device === normalizeHost(machineId())) {
+                setJobEnabled(ROUTINE, on);
+                continue;
+            }
+            const launch = getCliLaunch(['routines', on ? 'resume' : 'pause', ROUTINE, '--host', device]);
+            const result = spawnSync(launch.command, launch.args, { stdio: 'inherit', env: process.env });
+            if ((result.status ?? 1) !== 0)
+                throw new Error(`Could not configure watchdog on ${device}`);
+        }
+        console.log(chalk.green(selected.length === 0
+            ? 'Watchdog disabled on every registered device'
+            : `Watchdog enabled on: ${selected.join(', ')}`));
+    }
+    catch (error) {
+        if (isPromptCancelled(error)) {
+            console.log(chalk.gray('Cancelled'));
+            return;
+        }
+        throw error;
+    }
+}
+export function registerSetupWatchdogCommand(setup) {
+    setup.command('watchdog')
+        .description('Choose the devices where the built-in watchdog routine runs.')
+        .action(runWatchdogSetupWizard);
+}

package/dist/commands/setup.js

@@ -24,6 +24,7 @@ import { registerSetupShareCommand, runShareWizard } from './setup-share.js';
 import { registerSetupMineCommand } from './setup-mine.js';
 import { registerSetupSecretsCommand } from './setup-secrets.js';
 import { registerSetupFleetCommand } from './setup-fleet.js';
+import { registerSetupWatchdogCommand, runWatchdogSetupWizard } from './setup-watchdog.js';
 import { runPreferencesStep } from './setup-preferences.js';
 const HOME = os.homedir();
 /**
@@ -247,6 +248,7 @@ async function runSetupHub() {
                 { name: 'share    — publish shareable links (Cloudflare R2 + Worker)', value: 'share' },
                 { name: 'secrets  — choose storage defaults and import existing credentials', value: 'secrets' },
                 { name: 'fleet    — discover Tailscale devices and configure SSH access', value: 'fleet' },
+                { name: 'watchdog — resume stalled agent sessions on selected devices', value: 'watchdog' },
             ],
         });
         for (const pick of picks) {
@@ -261,6 +263,8 @@ async function runSetupHub() {
                 await import('./setup-secrets.js').then((m) => m.runSecretsSetupWizard());
             else if (pick === 'fleet')
                 await import('./setup-fleet.js').then((m) => m.runFleetSetupWizard());
+            else if (pick === 'watchdog')
+                await runWatchdogSetupWizard();
         }
     }
     catch (err) {
@@ -283,6 +287,7 @@ export function registerSetupCommand(program) {
     registerSetupMineCommand(setupCmd);
     registerSetupSecretsCommand(setupCmd);
     registerSetupFleetCommand(setupCmd);
+    registerSetupWatchdogCommand(setupCmd);
     setHelpSections(setupCmd, {
         examples: `
       # First-time setup (clones the system repo into ~/.agents/.system/)
@@ -297,12 +302,13 @@ export function registerSetupCommand(program) {
       agents setup share
       agents setup secrets
       agents setup fleet
+      agents setup watchdog
     `,
         notes: `
       What it does:
         1. Clones the system repo into ~/.agents/.system/
         2. Imports any unmanaged agent installations it finds
-        3. On a TTY, offers to set up optional capabilities (browser/computer/share/secrets/fleet)
+        3. On a TTY, offers to set up optional capabilities (browser/computer/share/secrets/fleet/watchdog)
         4. On a TTY, asks preferences: which machine you sit at (interactive host)
            and which browser agents drive here — both skippable, both the same
            keys 'agents devices set-interactive' / 'browser profiles set-default' write
@@ -313,6 +319,7 @@ export function registerSetupCommand(program) {
         agents setup share       # provision or join a Cloudflare share endpoint
         agents setup secrets     # choose secrets backend/policy defaults + import
         agents setup fleet       # discover Tailscale devices + configure SSH access
+        agents setup watchdog    # choose which devices run the watchdog routine
 
       To install CLIs from agents.yaml and sync resources into version homes:
         agents sync --local -y

package/dist/commands/ssh.d.ts

@@ -20,6 +20,17 @@ import { type CrabboxBox } from '../lib/crabbox/cli.js';
  * the row formatting is deterministic in tests.
  */
 export declare function renderLeasedBoxesSection(boxes: CrabboxBox[], nowSecs: number): string[];
+/**
+ * Whether `agents devices list` shows the "Leased boxes" section (RUSH-2190).
+ * Opt-in via --all only: loading it scans the keychain for bundle credentials
+ * and can raise a Touch ID sheet after the table has printed, so the default
+ * list must never reach for it. --no-stats stays the hard "instant, no provider
+ * calls" opt-out even when --all is passed.
+ */
+export declare function showLeasedBoxesSection(opts: {
+    all?: boolean;
+    stats?: boolean;
+}): boolean;
 /**
  * Race `fanOut` against an overall wall-clock deadline (RUSH-2041).
  *

package/dist/commands/ssh.js

@@ -191,6 +191,16 @@ function loadLeasedBoxesSection() {
         return []; // crabbox not installed / no provider creds — omit the section
     }
 }
+/**
+ * Whether `agents devices list` shows the "Leased boxes" section (RUSH-2190).
+ * Opt-in via --all only: loading it scans the keychain for bundle credentials
+ * and can raise a Touch ID sheet after the table has printed, so the default
+ * list must never reach for it. --no-stats stays the hard "instant, no provider
+ * calls" opt-out even when --all is passed.
+ */
+export function showLeasedBoxesSection(opts) {
+    return opts.all === true && opts.stats !== false;
+}
 /**
  * `agents ssh <slug>` targeting a leased crabbox box. crabbox provisions a
  * per-lease identity key, so we ssh via crabbox's OWN emitted invocation
@@ -1152,10 +1162,13 @@ Typical workflow:
             console.log(chalk.gray(`  updated ${formatCheckedAge(freshness.oldestFetchedAt)} — pass --refresh (--live) for a live probe`));
         }
         // Ephemeral crabbox leases live alongside the registered fleet but are never
-        // written into the registry — surface them as their own live section. This is
-        // a live provider call, so honor --no-stats (the explicit "instant, no probes"
-        // opt-out) and bound it so a slow provider can't hang `agents devices`.
-        if (opts.stats !== false) {
+        // written into the registry — surface them as their own live section, but only
+        // behind --all (RUSH-2190). Reading them routes through crabboxEnv, whose
+        // bundle auto-detect scans the keychain and can raise a Touch ID sheet AFTER
+        // the table has printed — unacceptable for the default list, which hooks and
+        // other non-interactive callers rely on. The predicate is exported so the
+        // gate itself is unit-tested; keep it the ONLY condition guarding this call.
+        if (showLeasedBoxesSection(opts)) {
             for (const line of loadLeasedBoxesSection())
                 console.log(line);
         }
@@ -1170,6 +1183,7 @@ Typical workflow:
         .option('--refresh', 'force a live probe of every device, bypassing the cache')
         .option('--live', 'alias of --refresh (shorter to type)')
         .option('-f, --full', 'full mode: add per-device core count and free/total memory')
+        .option('--all', 'also show ephemeral leased boxes (live crabbox call; may need bundle secrets)')
         .action(runList);
     devicesCmd
         .command('status')

package/dist/commands/watchdog.d.ts

@@ -10,13 +10,12 @@
  *   agents watchdog --nudge            one tick, actually injects (explicit opt-in)
  *   agents watchdog --watch            manual poll loop (dry unless --nudge)
  *   agents watchdog --json             machine-readable tick output (for the menu-bar)
- *   agents watchdog enable|disable     turn the always-on watchdog routine on/off
+ *   agents watchdog on|off             turn the always-on watchdog routine on/off
  *   agents watchdog policy <id> <p>    per-session policy: off | keep | handsoff
  *
  * The always-on watchdog is a daemon-fired ROUTINE, not a private sentinel + a
- * hand-rolled loop: `enable` creates/enables a `watchdog` command routine
- * (`agents watchdog --nudge` every couple of minutes) and reloads the daemon;
- * `disable` pauses it. See ../lib/watchdog/routine.ts.
+ * hand-rolled loop. Its immutable definition comes from the system DotAgents
+ * repo; on/off only changes this device's routine membership.
  */
 import type { Command } from 'commander';
 /** Register the `agents watchdog` command tree. */

package/dist/commands/watchdog.js

@@ -10,26 +10,26 @@
  *   agents watchdog --nudge            one tick, actually injects (explicit opt-in)
  *   agents watchdog --watch            manual poll loop (dry unless --nudge)
  *   agents watchdog --json             machine-readable tick output (for the menu-bar)
- *   agents watchdog enable|disable     turn the always-on watchdog routine on/off
+ *   agents watchdog on|off             turn the always-on watchdog routine on/off
  *   agents watchdog policy <id> <p>    per-session policy: off | keep | handsoff
  *
  * The always-on watchdog is a daemon-fired ROUTINE, not a private sentinel + a
- * hand-rolled loop: `enable` creates/enables a `watchdog` command routine
- * (`agents watchdog --nudge` every couple of minutes) and reloads the daemon;
- * `disable` pauses it. See ../lib/watchdog/routine.ts.
+ * hand-rolled loop. Its immutable definition comes from the system DotAgents
+ * repo; on/off only changes this device's routine membership.
  */
 import chalk from 'chalk';
 import * as path from 'path';
 import { setHelpSections } from '../lib/help.js';
 import { parseDuration } from '../lib/hooks/cache.js';
 import { getRuntimeStateDir } from '../lib/state.js';
-import { setJobEnabled } from '../lib/routines.js';
+import { readJob, setJobEnabled } from '../lib/routines.js';
 import { getActiveSessions } from '../lib/session/active.js';
 import { mailboxIdForActiveSession } from '../lib/mailbox-target.js';
 import { gcMailbox } from '../lib/mailbox-gc.js';
-import { ensureWatchdogRoutine, isWatchdogRoutineEnabled, watchdogRoutineExists, WATCHDOG_ROUTINE_NAME, WATCHDOG_ROUTINE_SCHEDULE, } from '../lib/watchdog/routine.js';
+import { devicesWithRoutineEnabled, routineEnabledOnThisDevice } from '../lib/routine-activation.js';
 import { runWatchdogTick, writePolicySentinel, DEFAULT_THRESHOLDS, } from '../lib/watchdog/runner.js';
 import { isWatchdogRotateEnabled, listRotateStates, setWatchdogRotateEnabled } from '../lib/watchdog/rotate.js';
+const WATCHDOG_ROUTINE_NAME = 'watchdog';
 /** Default state dir the runner and these subcommands share. */
 function stateDir() {
     return path.join(getRuntimeStateDir(), 'watchdog');
@@ -120,7 +120,7 @@ export function registerWatchdogCommand(program) {
         .command('watchdog')
         .description('Auto-nudge stalled agent terminals: detect stalls, resolve the exact split, inject "Continue." — no menu-bar needed.')
         .option('--nudge', 'Actually inject (default is a dry run that only reports what it would do)')
-        .option('--watch', 'Manual poll loop: run a tick every --interval (dry unless --nudge; the always-on path is `watchdog enable`)')
+        .option('--watch', 'Manual poll loop: run a tick every --interval (dry unless --nudge; the always-on path is `watchdog on`)')
         .option('--interval <dur>', 'Poll interval in --watch mode (e.g. 30s, 1m)', '30s')
         .option('--stall <dur>', 'Idle time before a session counts as stalled', humanMs(DEFAULT_THRESHOLDS.stallMs))
         .option('--cooldown <dur>', 'Minimum time between nudges to the same session', humanMs(DEFAULT_THRESHOLDS.cooldownMs))
@@ -166,7 +166,7 @@ export function registerWatchdogCommand(program) {
         const intervalMs = durationMsOr(opts.interval, 30_000);
         if (!computeWillInject() && !opts.json) {
             console.log(chalk.yellow(`watchdog --watch is DETECT-ONLY. Pass --nudge to inject, ` +
-                `or run 'agents watchdog enable' for the always-on daemon routine.`));
+                `or run 'agents watchdog on' for the always-on daemon routine.`));
         }
         // eslint-disable-next-line no-constant-condition
         while (true) {
@@ -197,7 +197,7 @@ export function registerWatchdogCommand(program) {
       agents watchdog --json
 
       # Turn on the ALWAYS-ON watchdog (a daemon-fired routine)
-      agents watchdog enable
+      agents watchdog on
 
       # Show the routine, rotate config, and any in-flight in-place rotates
       agents watchdog status
@@ -242,36 +242,45 @@ export function registerWatchdogCommand(program) {
       'watchdog.rotate: off' to ~/.agents/agents.yaml; nudging stays on).
       State machine: ~/.agents/.cache/state/watchdog/rotate/<sessionId>.json.
 
-      Always-on: 'agents watchdog enable' creates + enables a 'watchdog' command
-      routine ('${WATCHDOG_ROUTINE_SCHEDULE}' -> agents watchdog --nudge) and reloads the
-      daemon; 'disable' pauses it. Inspect it with 'agents routines list'. Defaults
+      Always-on: 'agents watchdog on' enables the system-defined 'watchdog' routine
+      on this device and reloads the daemon; 'off' disables it here. Inspect it with
+      'agents routines list'. Defaults
       OFF. Per-session policy: off (ignore), keep (default), handsoff (detect + flag).
 
       State (tray-readable): ${path.join('~/.agents/.cache/state/watchdog', '{nudges,flags,last-tick}.json')}
     `,
     });
     // --- always-on enable/disable/status (backed by the daemon routine) --------
-    cmd.command('enable')
-        .description('Turn ON the always-on watchdog: create/enable the `watchdog` routine and (re)load the daemon.')
-        .action(async () => {
-        ensureWatchdogRoutine(true);
+    const turnOn = async () => {
+        const routine = readJob(WATCHDOG_ROUTINE_NAME);
+        if (!routine)
+            throw new Error("Built-in routine 'watchdog' is missing. Run: agents repo pull system");
+        setJobEnabled(WATCHDOG_ROUTINE_NAME, true);
         await reloadDaemonForRoutine(true);
-        console.log(chalk.green(`watchdog: ENABLED — routine '${WATCHDOG_ROUTINE_NAME}' fires ${WATCHDOG_ROUTINE_SCHEDULE} (agents watchdog --nudge)`));
-    });
-    cmd.command('disable')
-        .description('Turn OFF the always-on watchdog (pause the `watchdog` routine).')
-        .action(async () => {
-        if (!watchdogRoutineExists()) {
-            console.log(chalk.dim('watchdog: already off (no routine)'));
-            return;
-        }
+        console.log(chalk.green(`watchdog: ON on this device (${routine.schedule ?? 'event-triggered'})`));
+    };
+    const turnOff = async () => {
+        if (!readJob(WATCHDOG_ROUTINE_NAME))
+            throw new Error("Built-in routine 'watchdog' is missing. Run: agents repo pull system");
         setJobEnabled(WATCHDOG_ROUTINE_NAME, false);
         await reloadDaemonForRoutine(false);
-        console.log(chalk.yellow('watchdog: DISABLED (routine paused)'));
+        console.log(chalk.yellow('watchdog: OFF on this device'));
+    };
+    cmd.command('on')
+        .description('Enable the built-in watchdog routine on this device.')
+        .action(async () => {
+        await turnOn();
+    });
+    cmd.command('off')
+        .description('Disable the built-in watchdog routine on this device.')
+        .action(async () => {
+        await turnOff();
     });
+    cmd.command('enable', { hidden: true }).action(turnOn);
+    cmd.command('disable', { hidden: true }).action(turnOff);
     cmd.command('rotate <state>')
         .description('Turn in-place rotate of rate-limited sessions on|off (watchdog.rotate in agents.yaml). ' +
-        'Rotate-only: nudging stays on — unlike `watchdog disable`, which pauses the whole watchdog.')
+        'Rotate-only: nudging stays on — unlike `watchdog off`, which disables the whole watchdog on this device.')
         .action((state) => {
         const s = state.toLowerCase();
         if (s !== 'on' && s !== 'off') {
@@ -292,13 +301,15 @@ export function registerWatchdogCommand(program) {
         // parent, not this subcommand. optsWithGlobals() merges both levels, so we
         // read it correctly regardless of which command commander bound it to.
         const json = command.optsWithGlobals().json === true;
-        const on = isWatchdogRoutineEnabled();
+        const on = routineEnabledOnThisDevice(WATCHDOG_ROUTINE_NAME) === true;
+        const enabledDevices = devicesWithRoutineEnabled(WATCHDOG_ROUTINE_NAME);
         const rotate = isWatchdogRotateEnabled() ? 'on' : 'off';
         const rotates = listRotateStates(stateDir());
         const inflight = rotates.filter((r) => r.phase !== 'done' && r.phase !== 'failed');
         if (json) {
             console.log(JSON.stringify({
                 enabled: on,
+                enabledDevices,
                 routine: WATCHDOG_ROUTINE_NAME,
                 stateDir: stateDir(),
                 rotate,
@@ -314,6 +325,7 @@ export function registerWatchdogCommand(program) {
             return;
         }
         console.log(`always-on watchdog: ${on ? chalk.green('ON') : chalk.dim('off')} (routine '${WATCHDOG_ROUTINE_NAME}')`);
+        console.log(`enabled devices: ${enabledDevices.length > 0 ? enabledDevices.join(', ') : chalk.dim('none')}`);
         console.log(`rotate: ${rotate === 'on' ? chalk.green('on') : chalk.yellow('off')} (watchdog.rotate in agents.yaml) · ${inflight.length} in-flight`);
         for (const r of inflight) {
             console.log(`  ${chalk.magenta(r.phase.padEnd(12))} ${chalk.bold(r.sessionId.slice(0, 8))} → ${r.newSessionId.slice(0, 8)}${r.error ? chalk.red(`  ${r.error}`) : ''}`);

package/dist/index.js

@@ -94,7 +94,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, loadExport, loadPackages, loadRoutines, loadMonitors, loadProjects, loadRun, loadFork, loadDefaults, loadSet, loadModels, loadPrune, loadTrash, loadRestore, loadDoctor, loadApply, loadStatus, loadSnapshot, loadProfiles, loadHarness, loadSecrets, loadLogin, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadFactory, loadUsage, loadCost, loadPerf, loadTrends, loadOutput, loadBudget, loadAlias, loadMine, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadUninstall, loadShare, loadSend, loadFeed, loadMailboxes, } from './lib/startup/command-registry.js';
+import { COMMAND_LOADERS, LAZY_COMMAND_NAMES, loadView, loadInspect, loadFeedback, loadCommands, loadHooks, loadSkills, loadRules, loadMemory, loadPermissions, loadMcp, loadCli, loadSubagents, loadPlugins, loadWorkflows, loadWorktree, loadVersions, loadImport, loadExport, loadPackages, loadRoutines, loadMonitors, loadProjects, loadRun, loadFork, loadDefaults, loadSet, loadModels, loadPrune, loadTrash, loadRestore, loadDoctor, loadApply, loadStatus, loadSnapshot, loadProfiles, loadHarness, loadSecrets, loadLogin, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadFactory, loadUsage, loadCost, loadPerf, loadTrends, loadOutput, loadBudget, loadAlias, loadMine, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadHumans, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadUninstall, loadShare, loadSend, loadFeed, loadMailboxes, } from './lib/startup/command-registry.js';
 import { applyGlobalHelpConventions } from './lib/help.js';
 import { renderWhatsNew } from './lib/whats-new.js';
 import { getCliLaunch } from './lib/cli-entry.js';
@@ -980,6 +980,7 @@ async function registerAllEagerCommands() {
     await reg(loadAudit);
     await reg(loadWebhook);
     await reg(loadFunnel);
+    await reg(loadHumans);
     registerHqTombstoneCommand(program);
     await reg(loadFeed);
     await reg(loadMailboxes);
@@ -1177,7 +1178,7 @@ if (process.env.AGENTS_SKIP_MIGRATION !== '1') {
         // Bumping the suffix re-runs migrations for every user; binary releases that
         // don't change the schema must NOT re-run (they would destroy user content
         // when migration steps overlap with user-authored paths). See issue #20.
-        const sentinelValue = 'v14';
+        const sentinelValue = 'v15';
         let needRun = true;
         try {
             if (fs.existsSync(sentinel) && fs.readFileSync(sentinel, 'utf-8').trim() === sentinelValue) {

package/dist/lib/auto-dispatch.d.ts

@@ -8,12 +8,13 @@
  *
  * The dispatch goes through the same provider layer as `agents cloud run`, so Rush
  * (Prix) is just one provider among rush/codex/factory — NOT a hidden requirement.
- * A project may pin its provider via `provider` in ~/.agents/factory/projects.json.
+ * A project pins its provider via `dispatch.provider` in its
+ * ~/.agents/projects/<name>.yaml definition.
  *
- * OPT-IN: a project auto-dispatches ONLY when `autoDispatch: true` AND `maxAgents > 0`.
- * Nothing global is on by default.
+ * OPT-IN: a project auto-dispatches ONLY when `dispatch.enabled: true` AND
+ * `dispatch.maxAgents > 0` AND it has a `linear.projectId`. Nothing is on by default.
  */
-/** The subset of a managed project this module needs (mirror of the shared JSON). */
+/** The subset of a project definition this module needs. */
 export interface AutoDispatchProject {
     id: string;
     name: string;
@@ -44,13 +45,10 @@ export interface PlannedDispatch {
     delegateName: string;
 }
 /**
- * Path to the shared factory project registry (written by the factory UI).
- * `AGENTS_FACTORY_PROJECTS_PATH` overrides it, mirroring `AGENTS_PROJECTS_DIR`
- * (`state.ts`) — that seam is what lets `projects import --from-factory` be
- * tested end-to-end against a real fixture file instead of a mock.
+ * Read auto-dispatch candidates from canonical project YAML definitions
+ * (~/.agents/projects/<name>.yaml). Only projects with `dispatch.enabled: true`
+ * are returned; the caller's `isEligible` gate then checks the cap and Linear id.
  */
-export declare function factoryProjectsPath(): string;
-/** Read the project registry rows this module cares about. */
 export declare function readAutoDispatchProjects(): AutoDispatchProject[];
 /** A project is eligible only when it has explicitly opted in with a positive cap. */
 export declare function isEligible(p: AutoDispatchProject): boolean;

package/dist/lib/auto-dispatch.js

@@ -8,53 +8,31 @@
  *
  * The dispatch goes through the same provider layer as `agents cloud run`, so Rush
  * (Prix) is just one provider among rush/codex/factory — NOT a hidden requirement.
- * A project may pin its provider via `provider` in ~/.agents/factory/projects.json.
+ * A project pins its provider via `dispatch.provider` in its
+ * ~/.agents/projects/<name>.yaml definition.
  *
- * OPT-IN: a project auto-dispatches ONLY when `autoDispatch: true` AND `maxAgents > 0`.
- * Nothing global is on by default.
+ * OPT-IN: a project auto-dispatches ONLY when `dispatch.enabled: true` AND
+ * `dispatch.maxAgents > 0` AND it has a `linear.projectId`. Nothing is on by default.
  */
-import * as fs from 'fs';
-import * as path from 'path';
-import { homedir } from 'os';
+import { listProjectDefs } from './projects.js';
 /**
- * Path to the shared factory project registry (written by the factory UI).
- * `AGENTS_FACTORY_PROJECTS_PATH` overrides it, mirroring `AGENTS_PROJECTS_DIR`
- * (`state.ts`) — that seam is what lets `projects import --from-factory` be
- * tested end-to-end against a real fixture file instead of a mock.
+ * Read auto-dispatch candidates from canonical project YAML definitions
+ * (~/.agents/projects/<name>.yaml). Only projects with `dispatch.enabled: true`
+ * are returned; the caller's `isEligible` gate then checks the cap and Linear id.
  */
-export function factoryProjectsPath() {
-    return process.env.AGENTS_FACTORY_PROJECTS_PATH ?? path.join(homedir(), '.agents', 'factory', 'projects.json');
-}
-/** Read the project registry rows this module cares about. */
 export function readAutoDispatchProjects() {
-    let raw;
-    try {
-        raw = JSON.parse(fs.readFileSync(factoryProjectsPath(), 'utf-8'));
-    }
-    catch {
-        return [];
-    }
-    if (!Array.isArray(raw))
-        return [];
-    const out = [];
-    for (const r of raw) {
-        if (!r || typeof r !== 'object')
-            continue;
-        const o = r;
-        if (typeof o.id !== 'string' || typeof o.name !== 'string')
-            continue;
-        out.push({
-            id: o.id,
-            name: o.name,
-            linearProjectId: typeof o.linearProjectId === 'string' ? o.linearProjectId : undefined,
-            repoSlug: typeof o.repoSlug === 'string' ? o.repoSlug : undefined,
-            autoDispatch: o.autoDispatch === true,
-            maxAgents: typeof o.maxAgents === 'number' ? o.maxAgents : undefined,
-            provider: typeof o.provider === 'string' ? o.provider : undefined,
-            host: typeof o.host === 'string' ? o.host : undefined,
-        });
-    }
-    return out;
+    return listProjectDefs()
+        .filter((d) => d.dispatch?.enabled === true)
+        .map((d) => ({
+        id: d.name,
+        name: d.name,
+        linearProjectId: d.linear?.projectId,
+        repoSlug: d.repo ?? d.repos?.[0]?.slug,
+        autoDispatch: d.dispatch?.enabled ?? false,
+        maxAgents: d.dispatch?.maxAgents,
+        provider: d.dispatch?.provider,
+        host: d.dispatch?.host,
+    }));
 }
 /** A project is eligible only when it has explicitly opted in with a positive cap. */
 export function isEligible(p) {

package/dist/lib/channels/send.d.ts

@@ -59,7 +59,10 @@ export type ResolveSendResult = {
 export declare function isOwnerAlias(to: string | undefined): boolean;
 /** Compose body + optional URL lines (skip urls already present in the body). */
 export declare function composeSendText(text: string, urls?: string[]): string;
-/** Read notify.owner; null when either field is missing. */
+/**
+ * Read the owner destination; humans.yaml is the primary source, agents.yaml
+ * notify.owner is the fallback. Returns null when neither is set.
+ */
 export declare function readOwnerDest(meta: Meta): {
     channel: string;
     to: string;