@phnx-labs/agents-cli 1.20.35 → 1.20.36

package/dist/commands/sync.js

@@ -2,10 +2,12 @@
  * `agents sync` — synchronize central resources into an installed agent version.
  *
  * Forms:
- *   agents sync                                         # umbrella: fetch remote (repos+secrets+sessions) -> reconcile all
+ *   agents sync                                         # umbrella: fetch config repos -> reconcile all (secrets/sessions opt-in)
  *   agents sync --repos|--secrets|--sessions            # umbrella: fetch only those, then reconcile
  *   agents sync --cloud                                 # umbrella: fetch all, skip reconcile
  *   agents sync --local                                 # umbrella: reconcile all, no fetch
+ *   agents sync system                                  # one repo: git pull --rebase (pull-only mirror)
+ *   agents sync user                                    # one repo: git pull --rebase + push
  *   agents sync claude                                  # one agent: uses default/sole installed version
  *   agents sync claude@2.1.142                          # one agent: explicit version
  *   agents sync claude@latest                           # one agent: newest installed
@@ -29,18 +31,22 @@
  */
 import * as path from 'path';
 import chalk from 'chalk';
-import { agentLabel, resolveAgentName } from '../lib/agents.js';
-import { isVersionInstalled, syncResourcesToVersion, parseAgentSpec, resolveVersion, resolveVersionAlias, listInstalledVersions, getAvailableResources, getActuallySyncedResources, getProjectOnlyResources, getNewResources, hasNewResources, promptResourceSelection, promptNewResourceSelection, buildRepoScopedSelection, listRepoNames, } from '../lib/versions.js';
+import { agentLabel, resolveAgentName, ALL_AGENT_IDS } from '../lib/agents.js';
+import { isVersionInstalled, syncResourcesToVersion, parseAgentSpec, resolveVersion, resolveVersionAlias, listInstalledVersions, getAvailableResources, getActuallySyncedResources, getProjectOnlyResources, getNewResources, hasNewResources, promptResourceSelection, promptNewResourceSelection, buildRepoScopedSelection, mergeRepoScopedSelections, listRepoNames, getVersionHomePath, } from '../lib/versions.js';
+import { capableAgents } from '../lib/capabilities.js';
+import { parseHookManifest, registerHooksToSettings } from '../lib/hooks.js';
 import { compileRulesForProject } from '../lib/rules/compile.js';
 import { runLaunchSync } from '../lib/project-launch.js';
 import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
 import { runUmbrellaSync } from '../lib/sync-umbrella.js';
 import { addHostOption } from '../lib/hosts/option.js';
+import { syncRepoGit } from '../lib/git.js';
+import { getSystemAgentsDir, getUserAgentsDir, getEnabledExtraRepos } from '../lib/state.js';
 /** Register the `agents sync` command. */
 export function registerSyncCommand(program) {
     addHostOption(program.command('sync [agentSpec] [repo]'))
         .summary('Make this machine current, or sync resources into one agent')
-        .description('With an [agentSpec], syncs resources (commands, skills, hooks, rules, MCPs, plugins, etc.) into that installed agent version — previews changes and lets you pick. e.g. "claude", "claude@2.1.142", a selector: @latest / @oldest / @pinned (= @default), or @all for every installed version.\n\nAppend a [repo] (or pass --repo) to scope the sync to a single DotAgent repo — system / user / project / <alias>. e.g. "agents sync claude@all system" reconciles only the system repo\'s resources into every installed Claude.\n\nWith NO agent, runs the umbrella verb: fetch remote state (config repos + secrets + sessions) then reconcile it into every installed agent. Scope it with --repos / --secrets / --sessions, --cloud (fetch only), or --local (reconcile only).')
+        .description('With an [agentSpec], syncs resources (commands, skills, hooks, rules, MCPs, plugins, etc.) into that installed agent version — previews changes and lets you pick. e.g. "claude", "claude@2.1.142", a selector: @latest / @oldest / @pinned (= @default), or @all for every installed version.\n\nAppend a [repo] (or pass --repo) to scope the sync to a single DotAgent repo — system / user / project / <alias>. e.g. "agents sync claude@all system" reconciles only the system repo\'s resources into every installed Claude.\n\nGive a DotAgent repo name ALONE — "agents sync system" / "agents sync user" / "agents sync <alias>" — to git-sync that one repo: refuse if the tree is dirty, else git pull --rebase against origin. The user repo and extra aliases also push local commits up; the system repo is a pull-only mirror.\n\nWith NO agent, runs the umbrella verb: fetch the config repos then reconcile them into every installed agent. Secrets and sessions are opt-in — add --secrets to pull secret bundles or --sessions to sync transcripts (sessions are also queryable live via "agents sessions --host <machine>"). Also: --cloud (fetch only), --local (reconcile only).')
         .option('--agent <agent>', 'Agent identifier (legacy form; prefer the positional spec)')
         .option('--agent-version <version>', 'Version to sync into (legacy form; prefer "agent@version")')
         .option('--repo <name>', 'Scope the sync to a single DotAgent repo: system / user / project / <alias> (also accepted as a positional)')
@@ -60,6 +66,135 @@ export function registerSyncCommand(program) {
         await runSync(agentSpec, repo, opts);
     });
 }
+/**
+ * Resolve a DotAgent repo name to its git working directory + whether local
+ * commits should be pushed. `system` is a pull-only mirror of the npm-shipped
+ * upstream; `user` and enabled extra aliases are user-owned and push. `project`
+ * (and unknown names) return null — the project `.agents/` lives inside the
+ * user's own project repo and is not independently git-synced here.
+ */
+function resolveRepoGitTarget(repo) {
+    if (repo === 'system')
+        return { dir: getSystemAgentsDir(), push: false };
+    if (repo === 'user')
+        return { dir: getUserAgentsDir(), push: true };
+    const extra = getEnabledExtraRepos().find((e) => e.alias === repo);
+    if (extra)
+        return { dir: extra.dir, push: true };
+    return null;
+}
+/**
+ * `agents sync <repo>` — git-sync a single DotAgent repo: refuse on a dirty
+ * tree, else pull --rebase against origin, pushing local commits for user-owned
+ * repos. Delegates the git work to `syncRepoGit`.
+ */
+async function runRepoGitSync(repo, quiet, outLog, errLog) {
+    const target = resolveRepoGitTarget(repo);
+    if (!target) {
+        errLog(chalk.red(`The '${repo}' repo isn't independently git-synced.`));
+        errLog(chalk.gray('Syncable repos: system (pull-only), user, and enabled extra-repo aliases.'));
+        process.exitCode = 1;
+        return;
+    }
+    if (!quiet)
+        outLog(chalk.bold(`Syncing ${repo} repo…`) + chalk.gray(` (${target.dir})`));
+    const result = await syncRepoGit(target.dir, { push: target.push });
+    if (!result.success) {
+        errLog(chalk.red(`sync ${repo} failed: ${result.error}`));
+        process.exitCode = 1;
+        return;
+    }
+    if (!quiet) {
+        const note = result.pushed ? ' · pushed' : ' · pull-only';
+        outLog(chalk.green(`✓ ${repo} → ${result.commit}${note}`));
+    }
+}
+/** Human label for a repo choice in the interactive picker. */
+function repoChoiceLabel(repo) {
+    switch (repo) {
+        case 'system': return 'system  — shared, npm-shipped defaults';
+        case 'user': return 'user    — your ~/.agents config';
+        case 'project': return "project — this repo's .agents";
+        default: return `${repo}  — extra repo`;
+    }
+}
+/**
+ * Interactive bare `agents sync` (TTY, no flags): two checklists — which
+ * DotAgent repos to sync FROM, and which installed agents to sync INTO. Then
+ * freshen the selected git-syncable repos (pull-only) and reconcile the chosen
+ * repos' resources into each selected agent's default version, registering
+ * hooks so synced hook scripts actually fire.
+ */
+async function runInteractiveReconcile(opts, outLog, errLog) {
+    const { checkbox } = await import('@inquirer/prompts');
+    const cwd = opts.cwd || process.cwd();
+    const installedAgents = ALL_AGENT_IDS.filter((a) => listInstalledVersions(a).length > 0);
+    if (installedAgents.length === 0) {
+        errLog(chalk.red('No agents installed. Install one: agents add claude@latest'));
+        process.exitCode = 1;
+        return;
+    }
+    let repos;
+    let agents;
+    try {
+        repos = await checkbox({
+            message: 'Sync resources FROM which repos?',
+            choices: listRepoNames().map((r) => ({ value: r, name: repoChoiceLabel(r), checked: true })),
+        });
+        if (repos.length === 0) {
+            outLog(chalk.gray('No repos selected. Nothing to do.'));
+            return;
+        }
+        agents = await checkbox({
+            message: 'Sync INTO which agents?',
+            choices: installedAgents.map((a) => ({ value: a, name: agentLabel(a), checked: true })),
+        });
+        if (agents.length === 0) {
+            outLog(chalk.gray('No agents selected. Nothing to do.'));
+            return;
+        }
+    }
+    catch (e) {
+        if (isPromptCancelled(e)) {
+            outLog(chalk.gray('Cancelled. No changes made.'));
+            return;
+        }
+        throw e;
+    }
+    // 1. Freshen the selected git-syncable repos (pull-only; `project` has no
+    //    independent remote). Failures are non-fatal — reconcile still runs.
+    for (const repo of repos) {
+        const target = resolveRepoGitTarget(repo);
+        if (!target)
+            continue;
+        const res = await syncRepoGit(target.dir, { push: false });
+        if (res.success)
+            outLog(chalk.gray(`  pulled ${repo} → ${res.commit}`));
+        else
+            outLog(chalk.yellow(`  ! ${repo}: ${(res.error ?? 'pull failed').split('\n')[0]}`));
+    }
+    // 2. One selection spanning the chosen repos.
+    const selection = mergeRepoScopedSelections(repos, cwd);
+    const hasResources = selection.memory === 'all' || Object.entries(selection).some(([kind, v]) => kind !== 'memory' && Array.isArray(v) && v.length > 0);
+    if (!hasResources) {
+        outLog(chalk.gray(`Nothing from ${repos.join(', ')} to sync.`));
+        return;
+    }
+    // 3. Reconcile into each selected agent's default (or sole) version, then
+    //    register hooks so synced hook scripts fire.
+    const hookManifest = parseHookManifest();
+    const hookCapable = new Set(capableAgents('hooks'));
+    for (const agentId of agents) {
+        const version = resolveVersion(agentId, cwd) || listInstalledVersions(agentId).slice(-1)[0];
+        if (!version)
+            continue;
+        const result = syncResourcesToVersion(agentId, version, selection, { cwd });
+        printSyncDetail(result, agentId, version, cwd);
+        if (result.hooks && hookCapable.has(agentId) && Object.keys(hookManifest).length > 0) {
+            registerHooksToSettings(agentId, getVersionHomePath(agentId, version), hookManifest);
+        }
+    }
+}
 /**
  * The umbrella verb: bare `agents sync` (no agent) makes this machine current.
  * Resolves the flags + a secrets passphrase (env-only for now; tokenized auth
@@ -67,6 +202,14 @@ export function registerSyncCommand(program) {
  * a one-line summary. Stage failures are non-fatal and surfaced as warnings.
  */
 async function runUmbrella(opts, quiet, outLog, errLog) {
+    // Interactive bare `agents sync` (a TTY, no --yes, no scope flag) drops into
+    // the two-checklist picker: which repos to sync from, which agents to sync
+    // into. Any explicit flag or --yes keeps the non-interactive umbrella below.
+    const anyExplicitFlag = !!(opts.repos || opts.secrets || opts.sessions || opts.cloud || opts.local);
+    if (!quiet && !opts.yes && !anyExplicitFlag && isInteractiveTerminal()) {
+        await runInteractiveReconcile(opts, outLog, errLog);
+        return;
+    }
     const flags = {
         repos: opts.repos,
         secrets: opts.secrets,
@@ -126,6 +269,15 @@ async function runSync(agentSpec, repoArg, opts) {
     // when an '@' was actually typed, keeping bare `claude` on the
     // default-version path.
     let selector;
+    // Repo-level git sync: a DotAgent repo name given ALONE (no agent, no second
+    // positional) means "git-sync that repo" — pull --rebase, and push for
+    // user-owned repos. This is distinct from the [repo] resource-scoping arg
+    // below, and it precedes agent-spec parsing because repo names like
+    // "system"/"user" would otherwise fail parseAgentSpec.
+    if (agentSpec && !opts.agent && !repoArg && listRepoNames().includes(agentSpec)) {
+        await runRepoGitSync(agentSpec, quiet, outLog, errLog);
+        return;
+    }
     if (agentSpec) {
         const parsed = parseAgentSpec(agentSpec);
         if (!parsed) {

package/dist/commands/teams.js

@@ -5,6 +5,8 @@ import * as path from 'path';
 import { AgentManager, checkAllClis, checkCliSignedIn, getAgentsDir, resolveSignInAdvisory, VALID_TASK_TYPES, } from '../lib/teams/agents.js';
 import { resolveProvider } from '../lib/cloud/registry.js';
 import { runSupervisor } from '../lib/teams/supervisor.js';
+import { debug } from '../lib/teams/debug.js';
+import { runPrWatch, DEFAULT_MAX_WAVES, } from '../lib/teams/pr-watch.js';
 import { handleSpawn, handleStatus, handleStop, handleTasks, toTaskStatusSummary, } from '../lib/teams/api.js';
 import { createTeam, ensureTeam, getTeam, loadTeams, removeTeam, teamExists, } from '../lib/teams/registry.js';
 import { setHelpSections } from '../lib/help.js';
@@ -243,6 +245,105 @@ async function runOneWave(mgr, team, json) {
         }
     }
 }
+/**
+ * Path to the pr-watch dedupe-state file for a team. Persists the set of
+ * already-handled check/comment dedupe keys so a restart of `teams pr-watch`
+ * never re-spawns a fix wave for a failure it already reacted to. Lives in the
+ * teammate base dir; it's a flat file so loadExistingAgents (dir-only) skips it.
+ */
+async function prWatchStatePath(team) {
+    const safe = team.replace(/[^A-Za-z0-9_-]/g, '_');
+    return path.join(await getAgentsDir(), `pr-watch-${safe}.json`);
+}
+async function loadPrWatchState(team) {
+    try {
+        const raw = await fs.readFile(await prWatchStatePath(team), 'utf-8');
+        const parsed = JSON.parse(raw);
+        const handled = new Set(Array.isArray(parsed?.handled) ? parsed.handled : []);
+        const waves = new Map(parsed?.waves && typeof parsed.waves === 'object'
+            ? Object.entries(parsed.waves).map(([k, v]) => [k, Number(v) || 0])
+            : []);
+        return { handled, waves };
+    }
+    catch {
+        return { handled: new Set(), waves: new Map() };
+    }
+}
+async function savePrWatchState(team, state) {
+    try {
+        await fs.writeFile(await prWatchStatePath(team), JSON.stringify({ handled: [...state.handled], waves: Object.fromEntries(state.waves) }, null, 2));
+    }
+    catch (err) {
+        debug(`Could not persist pr-watch state for ${team}: ${err.message}`);
+    }
+}
+/**
+ * Resolve the PRs opened by a team's teammates, de-duplicated by PR URL. A
+ * teammate's PR URL comes from its own `pr_url` field or, failing that, the
+ * session it ran (detected from the transcript's `gh pr create`). The teammate
+ * name is the `--after` anchor for the fix/bugfix teammate we spawn.
+ */
+async function resolvePrWatchTargets(mgr, team) {
+    const status = await handleStatus(mgr, team, 'all');
+    const sessions = await resolveTeammateSessions(status.agents);
+    const byPr = new Map();
+    for (const a of status.agents) {
+        const prUrl = a.pr_url || sessions.get(a.agent_id)?.prUrl || null;
+        if (!prUrl)
+            continue;
+        if (byPr.has(prUrl))
+            continue; // first teammate to own a PR is its source
+        byPr.set(prUrl, { prUrl, sourceTeammate: a.name ?? null });
+    }
+    return [...byPr.values()];
+}
+/**
+ * React to one decided pr-watch action by spawning a follow-up teammate on the
+ * same PR — a ci-fix teammate on RED CI, or a `bugfix` teammate on a new review
+ * comment — linked `--after` the teammate that opened the PR so it slots into
+ * the same DAG the supervisor already drains. Returns the teammate label.
+ */
+async function reactWithTeammate(mgr, team, action, prompt) {
+    // Unique name per reaction. The dedupe key is stable across waves (keyed on the
+    // check NAME), so the wave number is what keeps successive fixers' names — and
+    // their worktrees — distinct within the team.
+    const uniq = action.dedupeKey.replace(/[^A-Za-z0-9]/g, '').slice(-10) || `${action.wave}`;
+    const slug = `${uniq}-w${action.wave}`;
+    const name = action.kind === 'ci-fix' ? `cifix-${slug}` : `bugfix-${slug}`;
+    const taskType = action.kind === 'review-fix' ? 'bugfix' : null;
+    // Link --after the source teammate when it's a real, resolvable sibling; a
+    // missing source means the PR couldn't be traced to a named teammate, so the
+    // fix runs immediately with no dependency edge.
+    const after = [];
+    if (action.sourceTeammate) {
+        const resolved = await mgr.resolveAgentIdInTask(team, action.sourceTeammate);
+        if (resolved.kind === 'ok')
+            after.push(action.sourceTeammate);
+    }
+    // Isolate each fixer in its own worktree so concurrent `gh pr checkout`s (across
+    // PRs, or across waves) never clash in a shared cwd. Requires a git repo — which
+    // pr-watch always is, since it operates on PRs; fall back to the cwd only when
+    // the checkout somehow isn't a repo.
+    const baseCwd = process.cwd();
+    let worktreeName = null;
+    let worktreePath = null;
+    let cwd = baseCwd;
+    if (await isGitRepo(baseCwd)) {
+        try {
+            worktreeName = `prwatch-${name}`;
+            worktreePath = await createWorktree(baseCwd, worktreeName);
+            cwd = worktreePath;
+        }
+        catch (err) {
+            debug(`pr-watch: could not create worktree for ${name}: ${err.message}`);
+            worktreeName = null;
+            worktreePath = null;
+            cwd = baseCwd;
+        }
+    }
+    const result = await handleSpawn(mgr, team, 'claude', prompt, cwd, 'edit', 'medium', null, cwd, null, name, after, null, null, taskType, null, null, null, null, worktreeName, worktreePath);
+    return result.name ?? shortId(result.agent_id);
+}
 // Pick the display handle for a teammate: explicit teammate name, Claude
 // session label, then the 8-char UUID prefix.
 function handle(a) {
@@ -1193,10 +1294,22 @@ export function registerTeamsCommands(program) {
         const intervalMs = Math.max(1000, Number.parseInt(opts.interval, 10) * 1000 || 8000);
         const maxWaves = Math.max(1, Number.parseInt(opts.maxWaves, 10) || 1000);
         const json = isJsonMode(opts);
+        // Live budget kill-switch (issue #399). Dormant when no caps set — the
+        // factory dropping this in returns null and runSupervisor short-circuits.
+        const { createTeamBudgetWatcher } = await import('../lib/budget/live-team.js');
+        const budgetWatcher = createTeamBudgetWatcher({
+            manager: mgr,
+            team,
+            cwd: process.cwd(),
+            onBreach: (b) => {
+                process.stderr.write(`[budget] cap ${b.cap} exceeded ($${b.spend.toFixed(2)} > $${b.limit.toFixed(2)}) — stopping team ${team}\n`);
+            },
+        });
         const result = await runSupervisor(mgr, {
             team,
             intervalMs,
             maxWaves,
+            budgetWatcher,
             onWave: (s) => {
                 const ts = s.timestamp.slice(11, 19);
                 if (json) {
@@ -1222,6 +1335,110 @@ export function registerTeamsCommands(program) {
         else if (result.stoppedBy === 'signal') {
             console.error(chalk.yellow(`Stopped by signal after ${result.waves} waves.`));
         }
+        else if (result.stoppedBy === 'budget') {
+            const b = result.budgetBreach;
+            console.error(chalk.red(`Budget kill-switch tripped after ${result.waves} waves` +
+                (b ? ` (cap ${b.cap}: $${b.spend.toFixed(2)} > $${b.limit.toFixed(2)})` : '') +
+                `.`));
+            process.exitCode = 7; // Mirrors BUDGET_KILL_EXIT_CODE for CI/headless.
+        }
+    });
+    // pr-watch — autonomous PR lifecycle (issue #338)
+    addHostOption(teams.command('pr-watch [team]'))
+        .description('Watch the PRs a team opened and react autonomously: RED CI -> spawn a fix teammate with the failure logs; new review comment -> route a bugfix teammate. Both slot into the team DAG (visible in `teams status`).')
+        .option('--interval <seconds>', 'Seconds between polls (default 30)', '30')
+        .option('--max-polls <n>', 'Stop after this many polls (default: run until Ctrl-C)', '0')
+        .option('--max-waves <n>', `Fix waves per PR before escalating to a human (default ${DEFAULT_MAX_WAVES})`, String(DEFAULT_MAX_WAVES))
+        .option('--once', 'Poll a single time and exit (equivalent to --max-polls 1)')
+        .option('--json', 'Emit one JSON line per pr-watch event')
+        .action(async (team, opts) => {
+        const mgr = mkManager();
+        if (!team) {
+            const picked = await pickTeamOr(mgr, 'agents teams pr-watch');
+            if (!picked)
+                return;
+            team = picked;
+        }
+        const resolvedTeam = team;
+        const intervalMs = Math.max(1000, (Number.parseInt(opts.interval, 10) || 30) * 1000);
+        const maxPolls = opts.once ? 1 : Math.max(0, Number.parseInt(opts.maxPolls, 10) || 0);
+        const maxWaves = Math.max(1, Number.parseInt(opts.maxWaves, 10) || DEFAULT_MAX_WAVES);
+        const json = isJsonMode(opts);
+        const { handled, waves } = await loadPrWatchState(resolvedTeam);
+        let stopSignal = false;
+        const onSig = () => { stopSignal = true; };
+        process.once('SIGINT', onSig);
+        process.once('SIGTERM', onSig);
+        const emit = (e) => {
+            if (json) {
+                console.log(JSON.stringify(e));
+                return;
+            }
+            const ts = e.timestamp.slice(11, 19);
+            if (e.type === 'poll') {
+                console.log(`[${ts}] polled ${chalk.cyan(resolvedTeam)} — ${e.targets} PR(s) under watch`);
+            }
+            else if (e.type === 'spawned') {
+                const verb = e.action.kind === 'ci-fix' ? 'CI-fix' : 'bugfix';
+                const detail = e.action.kind === 'ci-fix'
+                    ? `check ${chalk.yellow(e.action.check.name)}`
+                    : `comment ${chalk.yellow('#' + e.action.comment.id)}`;
+                console.log(`[${ts}] ${chalk.green('spawned')} ${verb} teammate ${chalk.cyan(e.label ?? '?')} ` +
+                    `(wave ${e.action.wave}/${maxWaves}) for ${detail} on ${e.action.prUrl}`);
+            }
+            else if (e.type === 'needs-human') {
+                console.error(`[${ts}] ${chalk.red('needs human')} — ${e.prUrl} still failing after ${e.waves} wave(s) ` +
+                    `(${e.subject}). Not spawning again; hand it to a human.`);
+            }
+            else if (e.type === 'error') {
+                console.error(`[${ts}] ${chalk.red('error')} on ${e.prUrl}: ${e.message}`);
+            }
+        };
+        // A fixer's dedupe guard clears once it settles, so a still-red check can
+        // spawn its next (budget-bounded) wave. Terminal = completed/failed/stopped.
+        const reactionSettled = async (label) => {
+            const roster = await mgr.listByTask(resolvedTeam);
+            const teammate = roster.find((a) => a.name === label || shortId(a.agentId) === label);
+            if (!teammate)
+                return false;
+            const s = String(teammate.status);
+            return s === 'completed' || s === 'failed' || s === 'stopped';
+        };
+        try {
+            const result = await runPrWatch({
+                resolveTargets: async () => {
+                    // Drive the DAG each pass so fix/bugfix teammates staged --after a
+                    // now-completed source teammate actually launch — no separate
+                    // `teams start --watch` needed.
+                    await mgr.rescanFromDisk();
+                    await mgr.startReady(resolvedTeam);
+                    return resolvePrWatchTargets(mgr, resolvedTeam);
+                },
+                react: (action, prompt) => reactWithTeammate(mgr, resolvedTeam, action, prompt),
+                reactionSettled,
+                onEvent: emit,
+            }, {
+                intervalMs,
+                maxPolls,
+                maxWaves,
+                handled,
+                waves,
+                shouldStop: () => stopSignal,
+            });
+            await savePrWatchState(resolvedTeam, { handled: result.handled, waves: result.waves });
+            if (!json) {
+                const humanNote = result.neededHuman > 0
+                    ? ` ${result.neededHuman} PR(s) escalated to a human.`
+                    : '';
+                console.log(chalk.gray(`pr-watch stopped (${result.stoppedBy}) after ${result.polls} poll(s); ` +
+                    `spawned ${result.spawned} follow-up teammate(s).${humanNote}`));
+                console.log(chalk.gray(`Check the team:  agents teams status ${resolvedTeam}`));
+            }
+        }
+        finally {
+            process.off('SIGINT', onSig);
+            process.off('SIGTERM', onSig);
+        }
     });
     // stop
     addHostOption(teams.command('stop [team] [teammate]'))

package/dist/commands/versions.js

@@ -155,10 +155,8 @@ async function versionPruneAction(specs, options, commandName) {
                     console.log(chalk.green(`Moved ${agentLabel(agentConfig.id)}@${v} to trash`));
                     moved.push({ agent, version: v });
                 }
-                if (globalDefault && toRemove.includes(globalDefault)) {
-                    setGlobalDefault(agent, undefined);
-                    console.log(chalk.yellow(`Default version removed. Run: agents use ${agent}@<version> to set a new default`));
-                }
+                // Default reassignment/clearing is handled at the source in
+                // removeVersion() so it applies to every removal path uniformly.
                 const remaining = listInstalledVersions(agent);
                 if (remaining.length === 0) {
                     removeShim(agent);

package/dist/commands/watchdog.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `agents watchdog` — the watchdog CONSUMER (RUSH-1415).
+ *
+ * Runs the tick loop that ties the merged pieces together: list active sessions,
+ * classify stalls, read the tail, decide (deterministic promise-without-toolcall
+ * by default), run the resolver safety gate, and inject "Continue." into the EXACT
+ * split — all without the Swift menu-bar. See src/lib/watchdog/runner.ts.
+ *
+ *   agents watchdog                    one tick, dry — prints what it WOULD nudge/skip and why
+ *   agents watchdog --nudge            one tick, actually injects (explicit opt-in)
+ *   agents watchdog --watch            daemon loop (poll every --interval)
+ *   agents watchdog --json             machine-readable tick output (for the menu-bar)
+ *   agents watchdog enable|disable     flip the global auto-nudge sentinel (default OFF)
+ *   agents watchdog policy <id> <p>    per-session policy: off | keep | handsoff
+ */
+import type { Command } from 'commander';
+/** Register the `agents watchdog` command tree. */
+export declare function registerWatchdogCommand(program: Command): void;