@phnx-labs/agents-cli 1.21.0 → 1.21.2

package/dist/commands/projects.js

@@ -25,9 +25,10 @@ import { gatherRemoteAgentsJson } from '../lib/remote-agents-json.js';
 import { factoryProjectsPath } from '../lib/auto-dispatch.js';
 import { formatFleetWorkspaces, parseRemoteProbe, probeProjectWorkspaces, workspaceTargetsForDef, } from '../lib/project-probe.js';
 import { listProjectDefs, loadProjectDef, writeProjectDef, removeProjectDef, projectDefPath, isSafeProjectName, } from '../lib/projects.js';
-import { rollupSessionsByProject, planPct, enrichProjectSignals, formatProjectMembers, } from '../lib/project-status.js';
+import { rollupSessionsByProject, liveDeadSplit, enrichProjectSignals, formatProjectMembers, } from '../lib/project-status.js';
 import { fetchLinearProjectCounts } from '../lib/linear-project-counts.js';
 import { listLinearProjects, pickLinearProject } from '../lib/linear-projects.js';
+import { checkRepoSlug } from '../lib/project-doctor.js';
 import { buildFactoryImportCandidates, buildLinearImportCandidates, validateImportOpts, } from '../lib/project-import.js';
 /** Recursion guard: a peer answering a probe fan-out never re-fans-out itself. */
 export const PROJECTS_NO_FANOUT_ENV = 'AGENTS_PROJECTS_LOCAL';
@@ -57,7 +58,7 @@ function parseContextFlag(raw) {
     return { path: raw.slice(0, i).trim(), purpose: raw.slice(i + 1).trim() };
 }
 /** Best-effort `owner/repo` from a repo's origin remote. */
-function originSlug(cwd) {
+export function originSlug(cwd) {
     try {
         const url = execFileSync('git', ['remote', 'get-url', 'origin'], { cwd, encoding: 'utf8' }).trim();
         return parseOwnerRepoFromRemote(url) ?? undefined;
@@ -94,7 +95,9 @@ function runFactoryImport(existing, opts) {
         : Array.isArray(parsed?.projects)
             ? parsed.projects
             : [];
-    return buildFactoryImportCandidates(rows, existing, opts);
+    // The checkout's real `origin` overrides the registry's path-derived slug —
+    // see buildFactoryImportCandidates for why the path guess is not trustworthy.
+    return buildFactoryImportCandidates(rows, existing, opts, (root) => originSlug(expandLocalHome(root)));
 }
 /**
  * List the workspace's Linear projects and plan their import, binding each to a
@@ -183,6 +186,40 @@ export function formatMilestoneDue(targetDate, nowMs) {
     });
     return `due ${label}`;
 }
+/**
+ * The milestone block. `status` prints one line — the next checkpoint — because
+ * a roll-up across projects has to stay scannable. `view` prints every declared
+ * milestone, because "how many are there and when are they due" is the shape of
+ * the plan and the reason to open one project.
+ *
+ * Pure (chalk only) so the layout is testable without a Linear account.
+ */
+export function formatMilestoneLines(milestones, next, nowMs, limit) {
+    if (milestones.length === 0) {
+        // `next` without a list only happens on a cached answer written before the
+        // list existed; render what we have rather than dropping the row.
+        return next ? [`  ${chalk.dim('next')}     ${formatNextMilestone(next, nowMs)}`] : [];
+    }
+    // The next milestone leads, always. Linear can flag a LATER-dated milestone
+    // as next, and `milestones` is date-ordered — so slicing the front would show
+    // an earlier one and hide the actual next behind "+N more", which is the one
+    // thing this row exists to say. Identity is name+targetDate: two milestones
+    // can share a name, and matching on name alone labelled the wrong row.
+    const key = (m) => `${m.name}${m.targetDate ?? ''}`;
+    const lead = next ? milestones.filter((m) => key(m) === key(next)).slice(0, 1) : [];
+    const others = next ? milestones.filter((m) => key(m) !== key(next)) : milestones;
+    const ordered = [...lead, ...others];
+    const shown = ordered.slice(0, Math.max(1, limit));
+    const out = shown.map((m, i) => {
+        const label = i === 0 && lead.length > 0 ? 'next' : i === 0 ? 'plan' : '';
+        return `  ${chalk.dim(label.padEnd(4))}     ${formatNextMilestone(m, nowMs)}`;
+    });
+    const rest = milestones.length - shown.length;
+    if (rest > 0) {
+        out.push(`  ${' '.repeat(4)}     ${chalk.dim(`+${rest} more milestone${rest === 1 ? '' : 's'} — agents projects view <name>`)}`);
+    }
+    return out;
+}
 /** The `next` card line: what this project is due to hit, and how far along it is. */
 export function formatNextMilestone(ms, nowMs) {
     const parts = [chalk.bold(ms.name)];
@@ -206,25 +243,39 @@ function statusBar(r) {
     push(r.byStatus.input_required, 'need-input', chalk.yellow);
     push(r.byStatus.queued, 'queued', chalk.gray);
     const shown = (r.byStatus.running ?? 0) + (r.byStatus.idle ?? 0) + (r.byStatus.input_required ?? 0) + (r.byStatus.queued ?? 0);
-    // Sessions in a non-live state (orphaned/crashed/unknown) count toward the
-    // headline — render the remainder so the bar never sums to less than it.
-    if (r.agents > shown)
-        parts.push(chalk.gray(`+${r.agents - shown} other`));
+    // The remainder is the LIVE sessions in a state without its own chip
+    // (orphaned, unknown). Dead ones are on their own row now, so counting them
+    // here made the line disagree with the headline — `19 live` beside
+    // `+24 other`, which invites the reader to trust neither.
+    const live = liveDeadSplit(r.byStatus).live;
+    if (live > shown)
+        parts.push(chalk.gray(`+${live - shown} other`));
     return parts.join(' · ') || chalk.gray('no live agents');
 }
-function renderCard(def, r, remote, fleet, linear, nowMs = Date.now()) {
-    const agents = r?.agents ?? 0;
-    const pct = r ? planPct(r.plan) : undefined;
-    const planStr = pct === undefined ? '' : `  ·  ${chalk.cyan(`${pct}% plan`)}`;
-    console.log(`${chalk.bold(def.name)}  ${chalk.dim('·')}  ${chalk.bold(`${agents} agents`)}${planStr}`);
+function renderCard(def, r, remote, fleet, linear, nowMs = Date.now(), 
+/** How many milestones to print. `status` shows the next one; `view` shows all. */
+milestoneLimit = 1) {
+    // The headline counts LIVE agents. It used to be every matched session, which
+    // read `39 agents` on a project where 19 had crashed. `planPct` used to sit
+    // here too and is gone: it summed each session's latest checklist snapshot,
+    // so one agent opening a fresh 40-item plan rendered the whole project `0%`.
+    const split = r ? liveDeadSplit(r.byStatus) : { live: 0, dead: 0, deadByStatus: [] };
+    console.log(`${chalk.bold(def.name)}  ${chalk.dim('·')}  ${chalk.bold(`${split.live} live`)}`);
     if (def.description)
         console.log(`  ${chalk.dim(def.description)}`);
     console.log(`  ${chalk.dim('live')}     ${r ? statusBar(r) : chalk.gray('no live agents')}`);
+    if (split.dead > 0) {
+        // Wreckage is worth a number of its own — 19 crashed sessions is a thing to
+        // go fix, not a throughput signal to fold into the headline.
+        const detail = split.deadByStatus.map((d) => `${d.n} ${d.status}`).join(', ');
+        console.log(`  ${chalk.dim('dead')}     ${chalk.yellow(`${split.dead} finished or lost`)} ${chalk.dim(`(${detail})`)}`);
+    }
     if (r && r.members.length)
         console.log(`  ${chalk.dim('agents')}   ${formatProjectMembers(r.members)}`);
     const ships = [];
-    if (remote?.mergedPrs)
-        ships.push(chalk.green(`${remote.mergedPrs} merged (${remote.windowDays}d)`));
+    if (remote?.mergedPrs) {
+        ships.push(chalk.green(`${remote.mergedPrs}${remote.mergedPrsTruncated ? '+' : ''} merged (${remote.windowDays}d)`));
+    }
     if (r?.openPrs.length)
         ships.push(`${r.openPrs.length} open PR${r.openPrs.length === 1 ? '' : 's'}`);
     if (r?.worktrees)
@@ -236,8 +287,8 @@ function renderCard(def, r, remote, fleet, linear, nowMs = Date.now()) {
     if (linear) {
         console.log(`  ${chalk.dim('linear')}   ${linear.done}/${linear.total}${linear.truncated ? '+' : ''} done · ${linear.inProgress} in progress`);
     }
-    if (linear?.nextMilestone) {
-        console.log(`  ${chalk.dim('next')}     ${formatNextMilestone(linear.nextMilestone, nowMs)}`);
+    for (const line of formatMilestoneLines(linear?.milestones ?? [], linear?.nextMilestone, nowMs, milestoneLimit)) {
+        console.log(line);
     }
     if (r && r.tickets.length) {
         console.log(`  ${chalk.dim('tickets')}  ${r.tickets.slice(0, 8).join(' · ')}${r.tickets.length > 8 ? ' …' : ''}`);
@@ -258,6 +309,14 @@ function renderCard(def, r, remote, fleet, linear, nowMs = Date.now()) {
     const repos = [def.repo, ...(def.repos ?? []).map((x) => x.slug)].filter(Boolean);
     if (repos.length)
         console.log(`  ${chalk.dim('repos')}    ${[...new Set(repos)].join(' · ')}`);
+    // A def whose `repo` disagrees with the checkout's origin reads PR and release
+    // counts from a DIFFERENT repository — both slugs resolve, so nothing errors
+    // and the wrong numbers look right. Say it here, with the fix attached.
+    const mismatch = def.root ? checkRepoSlug(def, originSlug(expandLocalHome(def.root))) : undefined;
+    if (mismatch) {
+        console.log(`  ${chalk.yellow('!')}        ${chalk.yellow(mismatch.message)}`);
+        console.log(`  ${' '.repeat(8)}${chalk.gray(mismatch.remediation)}`);
+    }
     if (def.contexts?.length) {
         console.log(`  ${chalk.dim('context')}  ${def.contexts.map((c) => c.path).join(' · ')}`);
     }
@@ -381,17 +440,24 @@ export function registerProjectsCommands(program) {
     });
     // ---- show ----
     projects
-        .command('show <name>')
-        .description('Show a project definition, resolved paths, repos, contexts, and links.')
+        .command('view <name>')
+        .alias('show')
+        .description('Show a project definition, resolved paths, repos, contexts, links, and milestones.')
         .option('--json', 'Machine-readable output')
-        .action((name, opts) => {
+        .option('--no-remote', 'Skip the Linear lookup; definition only')
+        .action(async (name, opts) => {
         const def = loadProjectDef(name);
         if (!def) {
             console.error(chalk.red(`No project named "${name}". List them: agents projects list`));
             process.exit(1);
         }
+        // Every milestone the project declares, not just the next one — the whole
+        // point of opening ONE project is to see the shape of its plan.
+        const counts = opts.remote !== false && def.linear?.projectId
+            ? await fetchLinearProjectCounts(def.linear.projectId)
+            : undefined;
         if (opts.json) {
-            console.log(JSON.stringify(def, null, 2));
+            console.log(JSON.stringify({ ...def, linear: { ...def.linear, ...(counts ?? {}) } }, null, 2));
             return;
         }
         console.log(chalk.bold(def.name) + (def.description ? chalk.dim(`  — ${def.description}`) : ''));
@@ -410,6 +476,24 @@ export function registerProjectsCommands(program) {
             console.log(`  linear       ${def.linear.url ?? def.linear.projectId}`);
         for (const d of def.docs ?? [])
             console.log(`  doc          ${d}`);
+        if (counts) {
+            const staleNote = counts.stale ? chalk.dim('  (cached)') : '';
+            console.log(`  issues       ${counts.done}/${counts.total}${counts.truncated ? '+' : ''} done · ${counts.inProgress} in progress${staleNote}`);
+        }
+        const ms = counts?.milestones ?? [];
+        if (ms.length) {
+            console.log(`  ${chalk.bold('milestones')}`);
+            for (const m of ms) {
+                const mark = m.name === counts?.nextMilestone?.name ? chalk.cyan('next') : '';
+                console.log(`    ${mark.padEnd(6)}     ${formatNextMilestone(m, Date.now())}`);
+            }
+            // A milestone nothing is filed against cannot report progress. Say that
+            // once, plainly, rather than printing a row of silent 0%s.
+            const unfiled = ms.filter((m) => m.total === 0).length;
+            if (unfiled === ms.length) {
+                console.log(`    ${chalk.yellow('!')}          ${chalk.yellow(`no issues are assigned to any milestone — progress against them cannot be measured`)}`);
+            }
+        }
         console.log(chalk.gray(`  ${projectDefPath(name)}`));
     });
     // ---- edit ----
@@ -514,7 +598,8 @@ export function registerProjectsCommands(program) {
                     byStatus: r?.byStatus ?? {},
                     members: r?.members ?? [],
                     plan: r?.plan ?? { done: 0, total: 0 },
-                    planPct: r ? planPct(r.plan) ?? null : null,
+                    live: r ? liveDeadSplit(r.byStatus).live : 0,
+                    dead: r ? liveDeadSplit(r.byStatus).dead : 0,
                     openPrs: r?.openPrs ?? [],
                     mergedPrs: rem?.mergedPrs ?? 0,
                     latestRelease: rem?.latestRelease ?? null,
@@ -577,6 +662,53 @@ export function registerProjectsCommands(program) {
             console.log(chalk.gray('  (widen with --min-confidence medium or --all)'));
         }
     });
+    // ---- set ----
+    projects
+        .command('set <name>')
+        .description('Change one field on a project definition, preserving everything else.')
+        .option('--repo <owner/repo>', 'Primary GitHub slug')
+        .option('--root <path>', 'Repo / monorepo root')
+        .option('--path <subdir>', 'Default cwd for agents (a monorepo subdir)')
+        .option('--description <text>', 'One-line description shown on the card')
+        .action((name, opts) => {
+        const def = loadProjectDef(name);
+        if (!def) {
+            console.error(chalk.red(`No project named "${name}". List them: agents projects list`));
+            process.exit(1);
+        }
+        const fields = ['repo', 'root', 'path', 'description'].filter((k) => opts[k] !== undefined);
+        if (fields.length === 0) {
+            console.error(chalk.red('Nothing to set. Pass a field, e.g. --repo <owner/repo>.'));
+            process.exit(1);
+        }
+        // Load, mutate the named fields, write back — the `link` pattern. NEVER
+        // the `add --force` pattern, which rebuilds the def from flags alone and
+        // silently drops linear/contexts/integrations that were not re-passed.
+        if (opts.repo !== undefined)
+            def.repo = opts.repo;
+        if (opts.root !== undefined)
+            def.root = opts.root;
+        if (opts.description !== undefined)
+            def.description = opts.description;
+        if (opts.path !== undefined) {
+            // `--path` is a subdir OF the root, so without one there is nothing to
+            // hang it off. A def imported with `--from-linear` that found no local
+            // checkout carries name + linear and no root — joining against '' there
+            // would silently write `/apps/cli`, an absolute path at the filesystem
+            // root, and the def would resolve somewhere that does not exist.
+            const base = (opts.root ?? def.root ?? '').replace(/\/$/, '');
+            if (!base) {
+                console.error(chalk.red(`"${def.name}" has no root, so --path has nothing to resolve against.`));
+                console.error(chalk.gray(`  Set one first: agents projects set ${def.name} --root <path> --path ${opts.path}`));
+                process.exit(1);
+            }
+            def.defaultPath = `${base}/${opts.path.replace(/^\//, '')}`;
+        }
+        writeProjectDef(def);
+        console.log(chalk.green(`Updated ${def.name}`));
+        for (const f of fields)
+            console.log(chalk.gray(`  ${f}  ${f === 'path' ? def.defaultPath : def[f]}`));
+    });
     // ---- link ----
     projects
         .command('link <name>')

package/dist/commands/routines.js

@@ -14,7 +14,7 @@ import { isDaemonRunning, signalDaemonReload, startDaemon, stopDaemon, readDaemo
 import { assertSchedulerEnabled } from '../lib/device-config.js';
 import { resolveAgentName, isAgentHardDeprecated, hardDeprecationError } from '../lib/agents.js';
 import { humanizeCron, humanizeNextRun, formatRepoLink, REPO_DISPLAY_MAX } from '../lib/routines-format.js';
-import { listJobs as listAllJobs, deleteJob, readJob, validateJob, writeJob, setJobEnabled, listRuns, getLatestRun, getRunDir, getJobPath, parseAtTime, hasCompletedOneShotRun, isOneShotLikeSchedule, isOneShotRoutine, isPastOneShotRoutine, jobRunsOnThisDevice, checkJobDeviceEligibility, normalizeTriggerEvent, parseHostStrategy, resolveHostStrategy, placementRequiresFiringPin, HOST_STRATEGIES, } from '../lib/routines.js';
+import { listJobs as listAllJobs, deleteJob, readJob, validateJob, writeJob, setJobEnabled, listRuns, routineStats, getLatestRun, getRunDir, getJobPath, parseAtTime, hasCompletedOneShotRun, isOneShotLikeSchedule, isOneShotRoutine, isPastOneShotRoutine, jobRunsOnThisDevice, checkJobDeviceEligibility, normalizeTriggerEvent, parseHostStrategy, resolveHostStrategy, placementRequiresFiringPin, HOST_STRATEGIES, } from '../lib/routines.js';
 import { discoverProjectRoutinesAt, enableProjectRoutines, disableProjectRoutines, syncProjectRoutines, syncAllProjectRoutines, listEnabledProjectRoots, resolveProjectRoot, displayProjectPath, listProjectRoutineFiles, } from '../lib/routines-project.js';
 import { fireWebhookJobs, matchJobsToWebhook } from '../lib/triggers/webhook.js';
 import { getRoutinesDir } from '../lib/state.js';
@@ -359,6 +359,7 @@ function runMetaJson(run) {
         completedAt: run.completedAt,
         exitCode: run.exitCode,
         errorMessage: run.errorMessage ?? null,
+        duration: run.duration ?? null,
     };
 }
 export function buildRunsJson(runs) {
@@ -1034,6 +1035,50 @@ export function registerRoutinesCommands(program) {
             console.log(`  ${run.runId}  ${status}  ${run.startedAt}`);
         }
     });
+    routinesCmd
+        .command('stats [name]')
+        .description('Duration + outcome rollup per job: run count, failed, missed, avg/p50/p95 duration')
+        .option('--json', 'Emit machine-readable JSON')
+        .action(async (name, options) => {
+        // No name: summarize every job (like `routines list`). A name narrows to
+        // one job's rollup — no interactive picker, since a bare `stats` already
+        // has a useful all-jobs default.
+        if (!name) {
+            const jobs = listAllJobs();
+            const rows = jobs.map((j) => ({ name: j.name, ...routineStats(j.name) }));
+            if (options.json) {
+                writeJson({ jobs: rows });
+                return;
+            }
+            if (rows.length === 0) {
+                console.log(chalk.gray('No jobs configured'));
+                return;
+            }
+            console.log(chalk.bold('Routine stats\n'));
+            const pad = (s, w) => (s.length >= w ? s.slice(0, w) : s + ' '.repeat(w - s.length));
+            console.log(chalk.gray(`  ${pad('JOB', 28)} ${pad('N', 5)} ${pad('FAILED', 7)} ${pad('MISSED', 7)} ${pad('AVG', 7)} ${pad('P50', 7)} P95`));
+            for (const r of rows) {
+                console.log(`  ${pad(r.name, 28)} ${pad(String(r.count), 5)} ${pad(String(r.failed), 7)} ${pad(String(r.missed), 7)} ${pad(`${r.avgMs}ms`, 7)} ${pad(`${r.p50}ms`, 7)} ${r.p95}ms`);
+            }
+            return;
+        }
+        const stats = routineStats(name);
+        if (options.json) {
+            writeJson({ jobId: name, name, ...stats });
+            return;
+        }
+        if (stats.count === 0) {
+            console.log(chalk.yellow(`No runs found for job '${name}'`));
+            return;
+        }
+        console.log(chalk.bold(`Stats: ${name}\n`));
+        console.log(`  Runs:     ${stats.count}`);
+        console.log(`  Failed:   ${stats.failed}`);
+        console.log(`  Missed:   ${stats.missed}`);
+        console.log(`  Avg:      ${stats.avgMs}ms`);
+        console.log(`  P50:      ${stats.p50}ms`);
+        console.log(`  P95:      ${stats.p95}ms`);
+    });
     routinesCmd
         .command('run [name]')
         .description('Execute a routine right now in the foreground. Ignores the schedule; useful for testing before enabling.')

package/dist/commands/ssh.js

@@ -332,6 +332,20 @@ async function localHealthRow(self, stats) {
         inventory: await collectLocalFleetInventory(process.cwd()),
     };
 }
+/** SSH into a host and read its already-computed fleet-status row (a cheap
+ *  `fleet status --local --json` on the peer — NOT a fresh remote resource probe;
+ *  the peer's daemon keeps that row warm). Bounded + reaped via sshExecAsync's
+ *  timeout (RUSH-2114). */
+async function probeRemoteFleetStatus(target) {
+    const isWin = /^win/i.test((target.platform ?? '').trim());
+    const env = isWin ? undefined : { PATH: '$HOME/.agents/.cache/shims:$HOME/.local/bin:$PATH' };
+    const cmd = buildRemoteAgentsInvocation(['devices', 'status', '--local', '--json'], undefined, isWin ? 'windows' : undefined, env);
+    const res = await sshExecAsync(target.dialTarget, cmd, { timeoutMs: 15000, multiplex: true });
+    if (res.code !== 0) {
+        throw new Error(res.timedOut ? 'timed out' : (res.stderr.trim() || `exit ${res.code ?? 'unknown'}`));
+    }
+    return JSON.parse(res.stdout);
+}
 async function probeRemoteHealth(target) {
     const isWin = /^win/i.test((target.platform ?? '').trim());
     const env = isWin ? undefined : { PATH: '$HOME/.agents/.cache/shims:$HOME/.local/bin:$PATH' };
@@ -363,6 +377,19 @@ async function runFleetStatus(opts) {
     const reg = await loadDevices();
     const self = machineId();
     const forceRefresh = Boolean(opts.refresh || opts.live);
+    // `--local`: the publish endpoint the read-union reads over ssh. Probe THIS
+    // host only (resource stats + live-agent workload, no ssh) and print its row.
+    // Publishes into the local mirror as a side effect so a same-host reader is
+    // instantly warm too.
+    if (opts.local) {
+        const { publishLocalFleetStatus } = await import('../lib/fleet-status.js');
+        const row = await publishLocalFleetStatus(self);
+        if (opts.json)
+            console.log(JSON.stringify(row, null, 2));
+        else
+            console.log(`${self}: ${row.agents.running} running agent(s), ${row.agents.live} live`);
+        return;
+    }
     const planned = planFleetTargets(reg);
     const probeable = planned.filter((t) => !t.skip).map((t) => t.device);
     // Cache-first: serve remote stats from the daemon-warmed cache (instant),
@@ -429,6 +456,47 @@ async function runFleetStatus(opts) {
             row.lastSeen = profile.tailscale?.lastSeen ?? profile.reachability?.checkedAt;
         }
     }
+    // Live-agent workload (RUSH-2061): publish THIS host's row, then union peers'
+    // rows cache-first. The daemon no longer probes the fleet (publish-own /
+    // read-union), so cross-host counts are gathered HERE, on demand — a mirror row
+    // younger than the freshness window is served without ssh; a missing/stale one
+    // is read over ssh via `fleet status --local --json` (bounded + kill-on-timeout
+    // through sshExecAsync/fanOutDevices, RUSH-2114). Best-effort: agent counts are
+    // additive, so a failed gather never breaks the status render.
+    try {
+        const { publishLocalFleetStatus, readFleetStatus, writeFleetStatusRows } = await import('../lib/fleet-status.js');
+        const selfRow = await publishLocalFleetStatus(self);
+        const mirror = readFleetStatus();
+        const now = Date.now();
+        const AGENT_STATUS_STALE_MS = 3 * 60_000;
+        const toRead = remoteTargets.filter((t) => {
+            if (t.skip)
+                return false;
+            if (forceRefresh)
+                return true;
+            const row = mirror[t.name];
+            return !row || now - row.capturedAt > AGENT_STATUS_STALE_MS;
+        });
+        if (toRead.length > 0) {
+            const gathered = await fanOutDevices(toRead, probeRemoteFleetStatus, { perDeviceTimeoutMs: 20_000 });
+            const updates = {};
+            for (const g of gathered) {
+                if (g.status === 'ok' && g.value)
+                    updates[g.name] = { ...g.value, host: g.name };
+            }
+            if (Object.keys(updates).length > 0)
+                writeFleetStatusRows(updates);
+        }
+        const union = readFleetStatus();
+        for (const row of rows) {
+            const r = row.name === self ? selfRow : union[row.name];
+            if (r)
+                row.agents = r.agents;
+        }
+    }
+    catch {
+        // best-effort — agent counts are additive to the health view
+    }
     const report = buildFleetHealthReport(rows, new Date(), { self });
     if (opts.json) {
         console.log(JSON.stringify(report, null, 2));
@@ -1110,6 +1178,7 @@ Typical workflow:
         .option('--no-stats', 'skip the live resource probe')
         .option('--refresh', 'force a live probe of every device, bypassing the cache')
         .option('--live', 'alias of --refresh (shorter to type)')
+        .option('--local', "this machine only: print THIS host's status row (resource stats + live-agent workload). The publish endpoint the fleet-status read-union reads over ssh.")
         .option('--verbose', 'show the full per-device auth/CLI/sync/version grid instead of the summary')
         .action(async (opts, cmd) => {
         // The root program also defines a global `--verbose`; commander binds a

package/dist/commands/trends.d.ts

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

package/dist/commands/trends.js

@@ -0,0 +1,158 @@
+import chalk from 'chalk';
+import { setHelpSections } from '../lib/help.js';
+import { buildTrendsDashboard, trendsWindow, runRecipe, RECIPE_IDS } from '../lib/analytics/dashboard.js';
+import { listRecipes } from '../lib/analytics/recipes.js';
+import { queryUsage, usageDbPath, USAGE_KINDS } from '../lib/analytics/usage-db.js';
+function parseDays(raw) {
+    const n = parseInt(raw ?? '7', 10);
+    return Number.isFinite(n) && n > 0 ? n : 7;
+}
+function parseLimit(raw, fallback) {
+    const n = parseInt(raw ?? String(fallback), 10);
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function printSection(section) {
+    console.log(chalk.bold(section.title));
+    if (section.rows.length === 0) {
+        console.log(chalk.gray('  (no data)'));
+        console.log();
+        return;
+    }
+    const keys = Object.keys(section.rows[0]);
+    const widths = keys.map((k) => Math.max(k.length, ...section.rows.map((r) => String(r[k] ?? '').length), 4));
+    const pad = (s, w) => (s.length >= w ? s.slice(0, w) : s + ' '.repeat(w - s.length));
+    console.log(chalk.gray(keys.map((k, i) => pad(k.toUpperCase(), widths[i])).join('  ')));
+    for (const row of section.rows) {
+        console.log(keys.map((k, i) => pad(String(row[k] ?? ''), widths[i])).join('  '));
+    }
+    console.log();
+}
+function renderDashboard(days, asJson) {
+    const dash = buildTrendsDashboard({ days });
+    if (asJson) {
+        console.log(JSON.stringify(dash, null, 2));
+        return;
+    }
+    console.log(chalk.bold(`agents trends — last ${dash.window.days} days`));
+    console.log(chalk.gray(`compute ${dash.durationMs}ms · usage ${usageDbPath()}`));
+    console.log();
+    if (dash.sections.length === 0) {
+        console.log(chalk.gray('No session or usage data in this window yet.'));
+        return;
+    }
+    for (const section of dash.sections)
+        printSection(section);
+}
+export function registerTrendsCommand(program) {
+    const trends = program
+        .command('trends')
+        .description('Usage analytics — harness/model mix, token ratios, resource frequency')
+        .option('--days <n>', 'Days of history to include', '7')
+        .option('--json', 'Emit JSON instead of tables')
+        .action(function summary() {
+        const opts = this.opts();
+        renderDashboard(parseDays(opts.days), Boolean(opts.json));
+    });
+    setHelpSections(trends, {
+        examples: `
+      # Auto recipe dashboard (7d)
+      agents trends
+
+      # Last 30 days
+      agents trends --days 30
+
+      # One recipe as JSON
+      agents trends harness-mix --json
+
+      # Raw usage events
+      agents trends query --kind secret --days 7
+
+      # List baked recipe ids
+      agents trends recipes
+    `,
+        notes: `
+      Session recipes read sessions.db; resource recipes read ~/.agents/.history/analytics/usage.db.
+      Empty recipes are skipped on the default dashboard.
+      Quota / rate-limits remain on \`agents usage\`; latency on \`agents perf\`.
+    `,
+    });
+    trends.command('recipes')
+        .description('List baked recipe ids')
+        .option('--json', 'Emit JSON')
+        .action((opts) => {
+        const list = listRecipes();
+        if (opts.json) {
+            console.log(JSON.stringify(list, null, 2));
+            return;
+        }
+        for (const r of list) {
+            console.log(`${r.id.padEnd(22)} ${r.store.padEnd(10)} ${r.title}`);
+        }
+    });
+    trends.command('query')
+        .description('Raw usage-event query')
+        .option('--kind <kind>', `One of: ${USAGE_KINDS.join(', ')}`)
+        .option('--name <name>', 'Resource name filter')
+        .option('--event <event>', 'Event name filter')
+        .option('--days <n>', 'Days of history', '7')
+        .option('--limit <n>', 'Max rows', '40')
+        .option('--json', 'Emit JSON')
+        .action((opts) => {
+        const win = trendsWindow(parseDays(opts.days));
+        const kind = opts.kind && USAGE_KINDS.includes(opts.kind)
+            ? opts.kind
+            : undefined;
+        if (opts.kind && !kind) {
+            console.error(`Unknown kind '${opts.kind}'. Expected: ${USAGE_KINDS.join(', ')}`);
+            process.exitCode = 1;
+            return;
+        }
+        const rows = queryUsage({
+            kind,
+            name: opts.name,
+            event: opts.event,
+            sinceIso: win.sinceIso,
+            limit: parseLimit(opts.limit, 40),
+        });
+        if (opts.json) {
+            console.log(JSON.stringify({ window: win, rows }, null, 2));
+            return;
+        }
+        if (rows.length === 0) {
+            console.log(chalk.gray('No usage events.'));
+            return;
+        }
+        printSection({
+            id: 'query',
+            title: 'Usage events',
+            rows: rows.map((r) => ({
+                ts: r.ts,
+                kind: r.kind,
+                name: r.name,
+                event: r.event,
+                agent: r.agent,
+            })),
+        });
+    });
+    for (const id of RECIPE_IDS) {
+        trends.command(id)
+            .description(`Recipe: ${id}`)
+            .option('--days <n>', 'Days of history', '7')
+            .option('--json', 'Emit JSON')
+            .action(function recipeAction() {
+            const parent = this.parent?.opts?.();
+            const opts = { ...parent, ...this.opts() };
+            const win = trendsWindow(parseDays(opts.days));
+            const section = runRecipe(id, win);
+            if (opts.json) {
+                console.log(JSON.stringify({ window: win, section }, null, 2));
+                return;
+            }
+            if (section.empty) {
+                console.log(chalk.gray(`No data for recipe '${id}' in the last ${win.days} days.`));
+                return;
+            }
+            printSection(section);
+        });
+    }
+}

package/dist/commands/usage.d.ts

@@ -2,12 +2,12 @@
  * Usage command -- show rate-limit / quota status for each installed agent.
  *
  * Lists every installed agent with the best available usage snapshot:
- *   - claude: live OAuth API call (cached for 2 minutes)
+ *   - claude: live OAuth API call (cached for 5 minutes)
  *   - codex:  parsed from latest session log's rate_limits event
- *   - kimi:   live Kimi Code /usages API call (cached for 2 minutes)
- *   - droid:  live Factory billing/limits API call (cached for 2 minutes)
+ *   - kimi:   live Kimi Code /usages API call (cached for 5 minutes)
+ *   - droid:  live Factory billing/limits API call (cached for 5 minutes)
  *   - grok:   parsed from the latest local usage event
- *   - cursor: live Cursor usage API call (cached for 2 minutes)
+ *   - cursor: live Cursor usage API call (cached for 5 minutes)
  *   - others: marked as "not exposed by CLI"
  */
 import type { Command } from 'commander';

package/dist/commands/view.d.ts

@@ -14,6 +14,12 @@ import { type ConfiguredModelSource } from '../lib/models.js';
 import { type ProfileSummary } from '../lib/profiles.js';
 /** Shared account identity formatter, re-exported for the view-specific tests. */
 export declare const accountColumnLabel: typeof accountDisplayLabel;
+/**
+ * Join fixed view columns with a consistent two-space gutter. Empty trailing
+ * columns are dropped so a row without an auth chip does not grow a dangling
+ * gutter, but interior empties stay padded so later columns stay aligned.
+ */
+export declare function joinViewColumns(cols: string[]): string;
 type SyncState = 'synced' | 'new' | 'modified' | 'deleted';
 /** Per-section filter flags. When any are true, only those sections render. */
 export interface ViewSectionFilter {