@phnx-labs/agents-cli 1.22.43 → 1.22.45

package/dist/commands/insights.js

@@ -31,7 +31,7 @@
  * the coaching prose by piping the AGGREGATE (never raw transcripts) through a headless
  * `claude -p`.
  *
- * `agents trends` is a thin deprecated alias of the mix tree only (see commands/trends.ts).
+ * Former top-level `agents trends` is `agents insights mix` / `agents insights trends`.
  */
 import * as fs from 'fs';
 import chalk from 'chalk';
@@ -49,24 +49,7 @@ import { terminalWidth, truncateToWidth, stringWidth, padToWidth } from '../lib/
 import { registerMixCommands } from '../lib/analytics/mix-commands.js';
 import { registerCostCommand } from './cost.js';
 import { registerOutputCommand } from './output.js';
-import { getTier } from '../lib/entitlement.js';
 const execFileAsync = promisify(execFile);
-/**
- * Plan-tier gate for the behavioural report (RUSH-2424). Free keeps top-line
- * counts and the harness mix (and `insights mix` / `agents perf`, which never
- * enter this file's gating since they're separate command trees); the
- * friction/correction-signal sections, grouping `--by account`, and
- * `--narrative` are paid. `insights mix`/`cost`/`output` are unaffected — this
- * gate applies only to the default behavioural report.
- */
-const PAID_PLAN_NOTICE = 'Friction and account-split analysis are on the paid plan.';
-function resolveInsightsGate(tier, dim) {
-    return {
-        tier,
-        groupGated: !tier.isPaid && dim === 'account',
-        frictionGated: !tier.isPaid,
-    };
-}
 function collectAgent(value, previous) {
     return [...previous, value];
 }
@@ -225,7 +208,7 @@ function renderHours(hours, out) {
     out.push(`  ${chalk.cyan(spark)}`);
     out.push(`  ${chalk.gray('0h'.padEnd(6))}${chalk.gray('6h'.padEnd(6))}${chalk.gray('12h'.padEnd(6))}${chalk.gray('18h'.padEnd(5))}${chalk.gray('23h')}`);
 }
-function renderReport(groups, dim, meta, actions, harnesses, gate) {
+function renderReport(groups, dim, meta, actions, harnesses) {
     const out = [];
     const scope = meta.since ? `last ${meta.since}` : 'all time';
     out.push(chalk.bold('Insights') + chalk.gray(`  ${scope} · ${meta.analyzed} of ${meta.scanned} sessions`));
@@ -235,44 +218,28 @@ function renderReport(groups, dim, meta, actions, harnesses, gate) {
         console.log(out.join('\n'));
         return;
     }
-    let noticePrinted = false;
-    const printPlanNotice = () => {
-        if (noticePrinted)
-            return;
-        noticePrinted = true;
-        out.push('');
-        out.push(chalk.gray(`  ${PAID_PLAN_NOTICE}`));
-    };
     // Per-group table — the headline, and the thing no sibling command produces.
     // Includes silent-stall counts so harness/account laziness is visible without --json.
-    // Gated on the free plan when grouped `--by account` (the default) — see resolveInsightsGate.
-    if (gate.groupGated) {
-        printPlanNotice();
-    }
-    else {
-        out.push('');
-        out.push(chalk.bold(`By ${dim}`));
-        const labelW = Math.min(Math.max(...groups.map((g) => stringWidth(g.label)), 5), Math.max(16, terminalWidth() - 58));
-        const sessW = Math.max(...groups.map((g) => String(g.sessions).length), 3);
-        // Friction-derived — never shown on the free plan, even when grouping by
-        // something other than account (gate.groupGated only covers `--by account`).
-        const stallOf = (g) => Object.entries(g.facets.frictionSignals)
-            .filter(([k]) => k.startsWith('silent stall:'))
-            .reduce((n, [, c]) => n + c, 0);
-        const resumeOf = (g) => g.facets.correctionSignals['resume after silent stall'] ?? 0;
-        const stallW = gate.frictionGated ? 6 : Math.max(...groups.map((g) => String(stallOf(g)).length), 5);
-        out.push(chalk.gray(`  ${padToWidth('', labelW)}  ${''.padStart(sessW)}       ` +
-            `${''.padStart(9)}  ${''.padStart(8)}  ${gate.frictionGated ? ''.padStart(stallW) : 'stalls'.padStart(stallW)}  ${gate.frictionGated ? '' : 'resume'}`));
-        for (const g of groups) {
-            const cost = g.costUsd > 0 ? formatUsd(g.costUsd) : '—';
-            const dur = g.durationMs > 0 ? formatDuration(g.durationMs) : '—';
-            const stalls = gate.frictionGated ? '—' : String(stallOf(g));
-            const resumes = gate.frictionGated ? '' : String(resumeOf(g));
-            out.push(`  ${padToWidth(truncateToWidth(g.label, labelW), labelW)}  ` +
-                `${chalk.gray(String(g.sessions).padStart(sessW))} ${chalk.gray('sess')}  ` +
-                `${chalk.green(padToWidth(cost, 9))}  ${chalk.gray(padToWidth(dur, 8))}  ` +
-                `${chalk.cyan(stalls.padStart(stallW))}  ${chalk.cyan(resumes)}`);
-        }
+    out.push('');
+    out.push(chalk.bold(`By ${dim}`));
+    const labelW = Math.min(Math.max(...groups.map((g) => stringWidth(g.label)), 5), Math.max(16, terminalWidth() - 58));
+    const sessW = Math.max(...groups.map((g) => String(g.sessions).length), 3);
+    const stallOf = (g) => Object.entries(g.facets.frictionSignals)
+        .filter(([k]) => k.startsWith('silent stall:'))
+        .reduce((n, [, c]) => n + c, 0);
+    const resumeOf = (g) => g.facets.correctionSignals['resume after silent stall'] ?? 0;
+    const stallW = Math.max(...groups.map((g) => String(stallOf(g)).length), 5);
+    out.push(chalk.gray(`  ${padToWidth('', labelW)}  ${''.padStart(sessW)}       ` +
+        `${''.padStart(9)}  ${''.padStart(8)}  ${'stalls'.padStart(stallW)}  resume`));
+    for (const g of groups) {
+        const cost = g.costUsd > 0 ? formatUsd(g.costUsd) : '—';
+        const dur = g.durationMs > 0 ? formatDuration(g.durationMs) : '—';
+        const stalls = String(stallOf(g));
+        const resumes = String(resumeOf(g));
+        out.push(`  ${padToWidth(truncateToWidth(g.label, labelW), labelW)}  ` +
+            `${chalk.gray(String(g.sessions).padStart(sessW))} ${chalk.gray('sess')}  ` +
+            `${chalk.green(padToWidth(cost, 9))}  ${chalk.gray(padToWidth(dur, 8))}  ` +
+            `${chalk.cyan(stalls.padStart(stallW))}  ${chalk.cyan(resumes)}`);
     }
     // Everything below is the whole scope folded together; per-group detail is in --json.
     const all = newFacetAccumulator();
@@ -281,64 +248,54 @@ function renderReport(groups, dim, meta, actions, harnesses, gate) {
     renderCounts('Top tools', topEntries(all.toolCounts, 8), out);
     renderCounts('Languages', topEntries(all.languages, 6), out);
     renderCounts('Models', topEntries(all.models, 6), out);
-    // Friction — the section that earns the command. Paid plan only (RUSH-2424);
-    // top-line counts and harness mix above/below stay free.
-    if (gate.frictionGated) {
-        printPlanNotice();
+    // Friction — the section that earns the command.
+    renderCounts('Silent stalls by model', topEntries(all.silentStallsByModel ?? {}, 8), out);
+    const gaps = all.responseGaps;
+    const silentStalls = Object.entries(all.frictionSignals)
+        .filter(([k]) => k.startsWith('silent stall:'))
+        .reduce((n, [, c]) => n + c, 0);
+    const resumeNudges = all.correctionSignals['resume after silent stall'] ?? 0;
+    out.push('');
+    out.push(chalk.bold('Friction'));
+    out.push(`  ${padToWidth('interruptions', 18)}  ${chalk.cyan(String(all.interruptions))}` +
+        chalk.gray('   turns you cut short'));
+    out.push(`  ${padToWidth('tool errors', 18)}  ${chalk.cyan(String(all.errorCount))}`);
+    if (gaps.length > 0) {
+        // Same timestamps as silent stalls; this line is the distribution. Silent
+        // stalls (below) are the agent-attributed long gaps after the model stopped.
+        out.push(`  ${padToWidth('gap until next msg', 18)}  ` +
+            chalk.cyan(`p50 ${Math.round(percentile(gaps, 50))}s`) + chalk.gray(` · p90 ${Math.round(percentile(gaps, 90))}s`) +
+            chalk.gray('   after assistant last spoke'));
     }
-    else {
-        renderCounts('Silent stalls by model', topEntries(all.silentStallsByModel ?? {}, 8), out);
-        const gaps = all.responseGaps;
-        const silentStalls = Object.entries(all.frictionSignals)
-            .filter(([k]) => k.startsWith('silent stall:'))
-            .reduce((n, [, c]) => n + c, 0);
-        const resumeNudges = all.correctionSignals['resume after silent stall'] ?? 0;
-        out.push('');
-        out.push(chalk.bold('Friction'));
-        out.push(`  ${padToWidth('interruptions', 18)}  ${chalk.cyan(String(all.interruptions))}` +
-            chalk.gray('   turns you cut short'));
-        out.push(`  ${padToWidth('tool errors', 18)}  ${chalk.cyan(String(all.errorCount))}`);
-        if (gaps.length > 0) {
-            // Same timestamps as silent stalls; this line is the distribution. Silent
-            // stalls (below) are the agent-attributed long gaps after the model stopped.
-            out.push(`  ${padToWidth('gap until next msg', 18)}  ` +
-                chalk.cyan(`p50 ${Math.round(percentile(gaps, 50))}s`) + chalk.gray(` · p90 ${Math.round(percentile(gaps, 90))}s`) +
-                chalk.gray('   after assistant last spoke'));
-        }
-        if (silentStalls > 0) {
-            out.push(`  ${padToWidth('silent stalls', 18)}  ${chalk.cyan(String(silentStalls))}` +
-                chalk.gray('   agent idle ≥5m until you resumed (also in By ' + dim + ' table)'));
-        }
-        if (resumeNudges > 0) {
-            out.push(`  ${padToWidth('resume nudges', 18)}  ${chalk.cyan(String(resumeNudges))}` +
-                chalk.gray('   "continue"/"keep going" after a silent stall'));
-        }
-        const errs = topEntries(all.errorCategories, 6);
-        if (errs.length > 0) {
-            for (const e of errs)
-                out.push(`    ${chalk.gray('·')} ${padToWidth(e.name, 16)} ${chalk.gray(String(e.count))}`);
-        }
-        renderCounts('Friction / thrash', topEntries(all.frictionSignals, 10), out);
-        renderCounts('Dissatisfaction / corrections', topEntries(all.correctionSignals, 10), out);
+    if (silentStalls > 0) {
+        out.push(`  ${padToWidth('silent stalls', 18)}  ${chalk.cyan(String(silentStalls))}` +
+            chalk.gray('   agent idle ≥5m until you resumed (also in By ' + dim + ' table)'));
+    }
+    if (resumeNudges > 0) {
+        out.push(`  ${padToWidth('resume nudges', 18)}  ${chalk.cyan(String(resumeNudges))}` +
+            chalk.gray('   "continue"/"keep going" after a silent stall'));
+    }
+    const errs = topEntries(all.errorCategories, 6);
+    if (errs.length > 0) {
+        for (const e of errs)
+            out.push(`    ${chalk.gray('·')} ${padToWidth(e.name, 16)} ${chalk.gray(String(e.count))}`);
     }
+    renderCounts('Friction / thrash', topEntries(all.frictionSignals, 10), out);
+    renderCounts('Dissatisfaction / corrections', topEntries(all.correctionSignals, 10), out);
     renderCounts('Automatable repeats', topEntries(all.automationSignals, 10), out);
     renderCounts('Harness split', harnesses, out);
     // Actions are built from frictionSignals/correctionSignals/automationSignals
-    // together (buildInsightActions) — evidence counts, sample session ids, and
-    // the action text itself describe the same paid friction/correction
-    // categories gated above, so the whole section is paid too (RUSH-2424).
-    if (!gate.frictionGated) {
-        out.push('');
-        out.push(chalk.bold('Actions'));
-        if (actions.length === 0) {
-            out.push(chalk.gray('  No repeated action pattern met the evidence threshold in this window.'));
-        }
-        else {
-            out.push(chalk.gray('  pri     category    evidence  sample sessions  action'));
-            for (const action of actions.slice(0, 12)) {
-                out.push(`  ${padToWidth(action.priority, 7)} ${padToWidth(action.category, 11)} ` +
-                    `${String(action.evidenceCount).padStart(8)}  ${padToWidth(action.sampleSessionIds.join(', '), 25)} ${action.action}`);
-            }
+    // together (buildInsightActions).
+    out.push('');
+    out.push(chalk.bold('Actions'));
+    if (actions.length === 0) {
+        out.push(chalk.gray('  No repeated action pattern met the evidence threshold in this window.'));
+    }
+    else {
+        out.push(chalk.gray('  pri     category    evidence  sample sessions  action'));
+        for (const action of actions.slice(0, 12)) {
+            out.push(`  ${padToWidth(action.priority, 7)} ${padToWidth(action.category, 11)} ` +
+                `${String(action.evidenceCount).padStart(8)}  ${padToWidth(action.sampleSessionIds.join(', '), 25)} ${action.action}`);
         }
     }
     // Output
@@ -394,9 +351,7 @@ function renderReport(groups, dim, meta, actions, harnesses, gate) {
             out.push('');
         out.push(chalk.yellow(`  ${meta.unreadable} transcripts could not be read; their behaviour is missing from these totals.`));
     }
-    // Friction-derived (gapsOverCeiling is a PAID_FACET_KEYS entry) and names
-    // "silent stall" outright — must not render on the free plan.
-    if (!gate.frictionGated && all.gapsOverCeiling > 0) {
+    if (all.gapsOverCeiling > 0) {
         out.push(chalk.gray(`  ${all.gapsOverCeiling} gaps over an hour excluded from p50/p90 (still counted as silent stall: 1h+ when the assistant last spoke).`));
     }
     out.push('');
@@ -451,23 +406,8 @@ async function renderNarrative(payload) {
         process.exitCode = 1;
     }
 }
-/** Facet keys that belong to the paid friction/correction sections — stripped from `--json` on free (RUSH-2424). */
-const PAID_FACET_KEYS = new Set([
-    'frictionSignals', 'correctionSignals', 'silentStallsByModel',
-    'interruptions', 'errorCount', 'errorCategories', 'responseGaps', 'gapsOverCeiling',
-]);
-function freeFacetSubset(facets) {
-    const out = {};
-    for (const [key, value] of Object.entries(facets)) {
-        if (!PAID_FACET_KEYS.has(key))
-            out[key] = value;
-    }
-    return out;
-}
 async function insightsAction(options) {
     const dim = resolveGroup(options.by);
-    const tier = await getTier();
-    const gate = resolveInsightsGate(tier, dim);
     const minMessages = Number.parseInt(options.minMessages ?? '2', 10);
     if (!Number.isFinite(minMessages) || minMessages < 0) {
         console.error(chalk.red('error: --min-messages must be a non-negative integer'));
@@ -533,37 +473,31 @@ async function insightsAction(options) {
             unreadable,
             minMessages,
             by: dim,
-            plan: { tierName: tier.tierName, isPaid: tier.isPaid },
-            ...(gate.groupGated || gate.frictionGated ? { notice: PAID_PLAN_NOTICE } : {}),
             overlap,
             // Built from frictionSignals/correctionSignals/automationSignals together
             // (buildInsightActions) — same paid friction/correction data as above.
-            actions: gate.frictionGated ? null : actions,
+            actions,
             harnesses,
-            groups: gate.groupGated ? null : groups.map((g) => ({
+            groups: groups.map((g) => ({
                 key: g.key,
                 label: g.label,
                 sessions: g.sessions,
                 costUsd: g.costUsd,
                 durationMs: g.durationMs,
                 outputTokens: g.outputTokens,
-                ...(gate.frictionGated ? freeFacetSubset(g.facets) : {
+                ...{
                     ...g.facets,
                     responseGapP50: Math.round(percentile(g.facets.responseGaps, 50)),
                     responseGapP90: Math.round(percentile(g.facets.responseGaps, 90)),
                     responseGapBuckets: bucketGaps(g.facets.responseGaps),
                     // The raw sample is large and uninteresting once bucketed.
                     responseGaps: undefined,
-                }),
+                },
             })),
         };
         console.log(JSON.stringify(payload, null, 2));
-        if (options.narrative) {
-            if (!tier.isPaid)
-                console.error(chalk.gray(`  ${PAID_PLAN_NOTICE}`));
-            else
-                await renderNarrative(payload);
-        }
+        if (options.narrative)
+            await renderNarrative(payload);
         return;
     }
     renderReport(groups, dim, {
@@ -574,24 +508,18 @@ async function insightsAction(options) {
         unreadable,
         minMessages,
         overlap,
-    }, actions, harnesses, gate);
+    }, actions, harnesses);
     if (options.narrative) {
-        if (!tier.isPaid) {
-            console.log('');
-            console.log(chalk.gray(`  ${PAID_PLAN_NOTICE}`));
-        }
-        else {
-            await renderNarrative(groups.map((g) => ({
-                account: g.label, sessions: g.sessions, costUsd: g.costUsd,
-                topTools: topEntries(g.facets.toolCounts, 8),
-                languages: topEntries(g.facets.languages, 6),
-                errorCategories: topEntries(g.facets.errorCategories, 6),
-                interruptions: g.facets.interruptions,
-                linesTouchedAfter: g.facets.linesTouchedAfter, linesTouchedBefore: g.facets.linesTouchedBefore,
-                gitCommits: g.facets.gitCommits,
-                replyP50s: Math.round(percentile(g.facets.responseGaps, 50)),
-            })));
-        }
+        await renderNarrative(groups.map((g) => ({
+            account: g.label, sessions: g.sessions, costUsd: g.costUsd,
+            topTools: topEntries(g.facets.toolCounts, 8),
+            languages: topEntries(g.facets.languages, 6),
+            errorCategories: topEntries(g.facets.errorCategories, 6),
+            interruptions: g.facets.interruptions,
+            linesTouchedAfter: g.facets.linesTouchedAfter, linesTouchedBefore: g.facets.linesTouchedBefore,
+            gitCommits: g.facets.gitCommits,
+            replyP50s: Math.round(percentile(g.facets.responseGaps, 50)),
+        })));
     }
 }
 function configureInsightsCommand(cmd) {
@@ -651,7 +579,8 @@ function configureInsightsCommand(cmd) {
         \`agents insights mix\`      — cheap counters from sessions.db + usage.db
       Latency is \`agents perf\` (not mix). Quota is \`agents usage\`. Spend is
       \`agents insights cost\`; shipped output is \`agents insights output\`. Skill/slash popularity
-      is \`agents sessions stats\`. \`agents trends\` is a deprecated alias of the mix tree.
+      is \`agents sessions stats\`. Former top-level \`agents trends\` is \`agents insights mix\`
+      (also \`agents insights trends\`).
 
       The behavioural report parses in-scope transcripts once and caches facets; later runs
       re-read only files that changed. \`--refresh\` forces a full re-read.

package/dist/commands/menubar.js

@@ -8,7 +8,7 @@
  */
 import chalk from 'chalk';
 import { setHelpSections } from '../lib/help.js';
-import { enableMenubarService, disableMenubarService, getMenubarStatus, runMenubarSetup, } from '../lib/menubar/install-menubar.js';
+import { enableMenubarService, disableMenubarService, getMenubarStatus, runMenubarSetup, buildMenubarDoctorReport, } from '../lib/menubar/install-menubar.js';
 function notMac() {
     if (process.platform !== 'darwin') {
         console.log(chalk.yellow('AGI Menu is macOS only.'));
@@ -77,6 +77,32 @@ function printSetupResult(r) {
         console.log(chalk.red('AGI Menu not fully configured.') + chalk.gray('  See the failed step above.'));
     }
 }
+function printDoctorReport(r) {
+    console.log(chalk.bold('AGI Menu doctor\n'));
+    console.log(`  install path       ${r.installPath ? chalk.gray(r.installPath) : chalk.red('not installed')}`);
+    console.log(`  installed version  ${r.installedVersion ? chalk.gray(r.installedVersion) : chalk.gray('unknown')}`);
+    console.log(`  CLI version        ${chalk.gray(r.currentVersion)}${r.versionMatches ? '' : chalk.yellow('  (mismatch — `agents menubar setup` updates it)')}`);
+    const identity = r.signingIdentity === 'developer-id'
+        ? chalk.green('Developer ID (update-stable)')
+        : r.signingIdentity === 'ad-hoc'
+            ? chalk.red('ad-hoc (unstable — Accessibility grant breaks on every update)')
+            : chalk.gray('unknown (nothing installed)');
+    console.log(`  signing identity   ${identity}`);
+    console.log(`  running            ${r.running ? chalk.green('yes') : chalk.gray('no')}`);
+    if (r.staleRunningProcess.length > 0) {
+        for (const p of r.staleRunningProcess) {
+            const mark = p.stale
+                ? chalk.red('started BEFORE the on-disk bundle — running the OLD binary')
+                : chalk.green('matches the on-disk bundle');
+            console.log(`  pid ${String(p.pid).padEnd(10)} ${mark}`);
+        }
+    }
+    if (r.accessibilityHintNeeded) {
+        console.log(chalk.yellow('\n  Accessibility grant may not be trusted for the current binary.'));
+        console.log(chalk.gray('  Run `agents menubar setup` to reinstall + restart the helper, then grant access:'));
+        console.log(chalk.gray('  open "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility"'));
+    }
+}
 export function registerMenubarCommands(program) {
     const menubar = program
         .command('menubar')
@@ -184,6 +210,37 @@ export function registerMenubarCommands(program) {
         }
         printStatus(s);
     });
+    const doctor = menubar
+        .command('doctor')
+        .description('Diagnose AGI Menu: install path, version skew, signing identity, stale process')
+        .option('--json', 'Emit machine-readable JSON')
+        .action((options) => {
+        const r = buildMenubarDoctorReport();
+        if (options.json) {
+            process.stdout.write(JSON.stringify(r) + '\n');
+            return;
+        }
+        if (r.platform !== 'darwin') {
+            console.log(chalk.yellow('AGI Menu is macOS only.'));
+            return;
+        }
+        printDoctorReport(r);
+    });
+    setHelpSections(doctor, {
+        examples: `
+      # Why did Accessibility ask again after an update?
+      agents menubar doctor
+    `,
+        notes: `
+      Read-only — never installs, restarts, or resets anything. Reports the
+      installed bundle's signing identity (ad-hoc signing breaks the
+      Accessibility grant on every update; Developer ID is stable across
+      updates) and whether a live helper pid started before the on-disk
+      bundle's last write — the sign that a running process is still the
+      binary an update just replaced. \`agents menubar setup\` is the fix for
+      anything this flags.
+    `,
+    });
     // Bare `agents menubar` -> status.
     menubar.action(() => {
         const s = getMenubarStatus();

package/dist/commands/output.js

@@ -10,7 +10,7 @@ import { formatUsd, PRICING_VERSION } from '../lib/pricing/index.js';
 import { formatDuration } from '../lib/session/render.js';
 import { terminalWidth, truncateToWidth, padToWidth } from '../lib/session/width.js';
 import { collectGitOutput } from '../lib/output/git-output.js';
-import { loadDevices, isControlDevice } from '../lib/devices/registry.js';
+import { loadDevices } from '../lib/devices/registry.js';
 import { machineId } from '../lib/session/sync/config.js';
 import { stripClixml } from '../lib/hosts/remote-cmd.js';
 const execFileAsync = promisify(execFile);
@@ -189,7 +189,7 @@ async function outputAction(options) {
     const self = machineId();
     const registry = await loadDevices();
     const remotes = Object.values(registry)
-        .filter(d => d.tailscale?.online && d.name !== self && !isControlDevice(d))
+        .filter(d => d.tailscale?.online && d.name !== self)
         .map(d => d.name);
     if (!options.json)
         console.error(chalk.gray(`Folding in ${remotes.length} online device${remotes.length !== 1 ? 's' : ''}…`));

package/dist/commands/prune.js

@@ -12,10 +12,11 @@
  *     agents-cli.
  *   - 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.
+ * Sync (additive: copy missing/changed files into version homes) is the job
+ * of `agents sync` / `agents refresh` — the shim's launch hook
+ * (`agents sync --launch`) is project-scoped only and deliberately skips
+ * version-home reconciliation. 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`

package/dist/commands/routines.test-fixture.d.ts

@@ -0,0 +1,86 @@
+import { describe } from 'vitest';
+import { spawnSync, spawn } from 'child_process';
+/**
+ * Shared fixture for the routines.*.test.ts suite slices (RUSH-2819).
+ *
+ * routines.test.ts was one 2,249-line file measured at ~194s of test time —
+ * one of the slowest files in CI, serializing an entire fork while every
+ * other selected file finished. The suite is split into topical slices so
+ * vitest's per-file fork parallelism can spread the subprocess-heavy tests
+ * across workers; the helpers each slice shares live here.
+ *
+ * Every test spawns the real CLI (`node --import tsx src/index.ts routines ...`)
+ * against an isolated mkdtemp HOME — no live ~/.agents state, no mocks, no
+ * imported writeJob/readJob. Modeled on `routines-webhook.test.ts`.
+ */
+export declare const REPO_ROOT: string;
+export declare const TSX_IMPORT: string;
+export declare const CLI_ENTRYPOINT: string;
+export declare const describeRoutines: typeof describe.skip;
+/** Provision an isolated HOME with agents.yaml, .system/.git, and optional routines + device registry. */
+export declare function makeHome(opts?: {
+    jobs?: Record<string, unknown>[];
+    projectJobs?: Record<string, unknown>[];
+    registry?: Record<string, unknown>;
+    deviceRoutines?: Record<string, string[]>;
+    /** Full mkdtemp prefix override — the daemon harness scopes its leak sweep by it. */
+    tmpPrefix?: string;
+}): string;
+/** Run `agents routines <args>` against an isolated HOME. */
+export declare function run(home: string, args: string[], extraEnv?: Record<string, string>, cwd?: string): ReturnType<typeof spawnSync>;
+export declare function readRoutineYaml(home: string, name: string): Record<string, unknown> | null;
+export declare function writeRunMeta(home: string, jobName: string, runId: string, meta: Record<string, unknown>): void;
+export declare function isProcessAlive(pid: number): boolean;
+/**
+ * Per-file isolated-daemon harness (RUSH-2367, RUSH-2819). Each slice that
+ * spawns a real `__daemon-run` process against an isolated HOME calls this
+ * once at module scope and registers its own leak detector — the tracked pid
+ * set MUST be private to the file that spawned it, since vitest's per-file
+ * fork isolation means the leak sweep only ever needs to answer for what THIS
+ * file started.
+ *
+ * `fileSlug` MUST be unique per test file: it names the mkdtemp prefix
+ * `makeDaemonHome` uses, and the CI leak sweep matches ONLY that prefix.
+ * The suite slices run in parallel forks, so a sweep over the shared
+ * `agents-routines-test-` prefix would catch a sibling file's still-running
+ * daemon and kill it mid-test — exactly what failed the first CI run of the
+ * RUSH-2819 split (run 32552954164: add's sweep killed a live daemon whose
+ * HOME belonged to a concurrently running slice).
+ */
+export declare function createDaemonHarness(fileSlug: string): {
+    startIsolatedDaemon: (home: string) => {
+        child: ReturnType<typeof spawn>;
+        pidPromise: Promise<number | null>;
+    };
+    stopIsolatedDaemon: (child: ReturnType<typeof spawn>) => Promise<void>;
+    registerLeakDetector: () => void;
+    makeDaemonHome: (opts?: Omit<Parameters<typeof makeHome>[0], 'tmpPrefix'>) => string;
+};
+export declare const baseJob: {
+    name: string;
+    schedule: string;
+    agent: string;
+    prompt: string;
+    cwd: string;
+    enabled: boolean;
+};
+export declare const registry: {
+    'yosemite-s0': {
+        name: string;
+        platform: string;
+    };
+    'mac-mini': {
+        name: string;
+        platform: string;
+    };
+    zion: {
+        name: string;
+        platform: string;
+    };
+};
+export declare function readDeviceRoutines(home: string, device: string): string[];
+export declare function writeDeviceRoutines(home: string, device: string, routines: string[]): void;
+/** Write a minimal project YAML so listProjectDefs() sees it. */
+export declare function writeProject(home: string, name: string): void;
+/** Env that points the projects dir at the isolated home. */
+export declare function projectsEnv(home: string): Record<string, string>;