@phnx-labs/agents-cli 1.21.1 → 1.21.2

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 {

package/dist/commands/view.js

@@ -1,6 +1,6 @@
 import { addHostOption } from '../lib/hosts/option.js';
 import chalk from 'chalk';
-import { visibleWidth, termLink } from '../lib/format.js';
+import { termLink } from '../lib/format.js';
 import ora from 'ora';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -31,9 +31,31 @@ import { renderHarnessDetail } from './harness.js';
 import { loadManifest, isStale } from '../lib/staleness/index.js';
 import { confirm } from '@inquirer/prompts';
 import { formatPath, isInteractiveTerminal, isPromptCancelled } from './utils.js';
-import { terminalWidth, truncateToWidth, stringWidth } from '../lib/session/width.js';
+import { terminalWidth, truncateToWidth, stringWidth, padToWidth } from '../lib/session/width.js';
 /** Shared account identity formatter, re-exported for the view-specific tests. */
 export const accountColumnLabel = accountDisplayLabel;
+/**
+ * Overview (`agents view` with no agent filter) caps compact usage windows so
+ * multi-meter agents (Antigravity's four model quotas, Droid's three buckets)
+ * cannot force every row to pad past the terminal width and wrap. Single-agent
+ * views leave the cap unset and show every blocking window.
+ */
+const OVERVIEW_MAX_USAGE_WINDOWS = 2;
+/** Fixed width for the last-active column ("just now", "8h ago", "2d ago"). */
+const LAST_ACTIVE_COL_WIDTH = 10;
+/**
+ * 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 function joinViewColumns(cols) {
+    // Trim only pure-trailing empty strings so auth/status can be absent without
+    // shifting earlier columns for rows that do carry them.
+    let end = cols.length;
+    while (end > 0 && cols[end - 1] === '')
+        end--;
+    return cols.slice(0, end).join('  ');
+}
 /**
  * Custom harnesses (the `~/.agents/profiles/*.yml` bundles), sorted by name and
  * optionally narrowed to the ones that run on one host agent. YAMLs that fail
@@ -246,6 +268,8 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
         : 'Checking installed agents...';
     const spinner = ora({ text: spinnerText, isSilent: !process.stdout.isTTY }).start();
     const agentsToShow = filterAgentId ? [filterAgentId] : ALL_AGENT_IDS;
+    // Overview caps meter count; single-agent view shows every blocking window.
+    const usageWindowCap = filterAgentId ? undefined : OVERVIEW_MAX_USAGE_WINDOWS;
     // A globally-installed CLI is superseded only by a NORMAL managed version — that
     // is when agents-cli owns the launcher and a "global" row would just be our own
     // shim reported back. `--isolated` promises the opposite: no default, no bare
@@ -265,7 +289,6 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
     const cliStates = Object.fromEntries(await Promise.all(agentsToShow
         .filter((agentId) => !hasNonIsolatedVersion(agentId))
         .map(async (agentId) => [agentId, await getUnmanagedCliState(agentId)])));
-    spinner.stop();
     const showPaths = !!filterAgentId;
     const harnesses = getHarnesses(filterAgentId);
     // Auto-heal stale versioned aliases. Pre-v2 aliases (e.g. pre-CLAUDE_CONFIG_DIR
@@ -287,11 +310,15 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
         }
     }
     // Shim healing is silent — users don't need to know about internal repairs
-    console.log(chalk.bold('Installed Agent CLIs\n'));
     const selfHost = machineId();
     // Read the auth-health cache once (not per version row — see the batching note above).
     const authCache = readAuthHealthCache();
-    // Pre-fetch account info for all versions in parallel
+    // Pre-fetch account info for all versions in parallel. Spinner stays up through
+    // account + usage so a multi-account cold path doesn't leave a blank terminal
+    // after "Checking…" vanishes (the hang the screenshots caught).
+    spinner.text = filterAgentId
+        ? `Loading ${agentLabel(filterAgentId)} accounts...`
+        : 'Loading accounts and usage...';
     const infoFetches = [];
     const globalInfoFetches = [];
     for (const agentId of agentsToShow) {
@@ -329,6 +356,7 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
     // or org scope, not a specific installed version. Version homes cache those
     // values independently, so older installs can show stale values. Reuse the
     // freshest cache entry per stable usage identity and keep lastActive per version.
+    // Goes through the unified usage core (SWR cache + concurrency cap + timeout).
     const { canonicalByUsageKey, usageByKey } = await getUsageInfoByIdentity([
         ...infoResults.map(({ agentId, home, version, info }) => ({
             agentId,
@@ -342,6 +370,8 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
             info,
         })),
     ], { forceRefresh: viewOpts?.forceRefresh });
+    spinner.stop();
+    console.log(chalk.bold('Installed Agent CLIs\n'));
     const mergeCanonical = (info) => {
         const key = getUsageLookupKey(info);
         if (!key)
@@ -441,7 +471,8 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
                 }
             }
         }
-        // Second pass: compute max visible usage + status widths (now that maxPlanWidth is settled)
+        // Second pass: compute max visible usage + status widths (now that maxPlanWidth is settled).
+        // stringWidth (not String.length) so chalk + block-bar glyphs pad correctly.
         for (const agentId of versionManaged) {
             const versions = listInstalledVersions(agentId);
             for (const v of versions) {
@@ -451,10 +482,14 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
                 const usageInfo = usageKey ? usageByKey.get(usageKey) : undefined;
                 const usageUnavailable = agentReportsUsage(agentId) && !!info?.signedIn && !usageInfo?.snapshot;
                 const usageUnverified = !!usageInfo?.snapshot && !!usageInfo.error;
-                const usageStr = formatUsageSummary(info?.plan || null, usageInfo?.snapshot || null, maxPlanWidth, { unavailable: usageUnavailable, unverified: usageUnverified });
-                maxUsageWidth = Math.max(maxUsageWidth, visibleWidth(usageStr));
+                const usageStr = formatUsageSummary(info?.plan || null, usageInfo?.snapshot || null, maxPlanWidth, {
+                    unavailable: usageUnavailable,
+                    unverified: usageUnverified,
+                    maxWindows: usageWindowCap,
+                });
+                maxUsageWidth = Math.max(maxUsageWidth, stringWidth(usageStr));
                 const statusStr = formatUsageStatusBadge(info?.usageStatus);
-                maxStatusWidth = Math.max(maxStatusWidth, visibleWidth(statusStr));
+                maxStatusWidth = Math.max(maxStatusWidth, stringWidth(statusStr));
             }
         }
         for (const agentId of versionManaged) {
@@ -496,18 +531,26 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
                 const vInfo = rawInfo ? mergeCanonical(rawInfo) : undefined;
                 const usageKey = getUsageLookupKey(vInfo);
                 const usageInfo = usageKey ? usageByKey.get(usageKey) : undefined;
-                // Build columns, trimming trailing whitespace when columns are empty
+                // Fixed columns for every signed-in row so status / lastActive / auth
+                // stay vertically aligned across agents — even when this row has no
+                // usage bars or no rate-limit badge. Skipping empty columns mid-table
+                // was what made the multi-agent view look unjustified next to
+                // `agents view claude`.
                 const parts = [`    ${label}`];
                 // Configured model — same priority as the version, right beside it.
                 if (maxModelWidth > 0) {
                     const model = modelByKey.get(`${agentId}:${version}`) ?? '';
-                    parts.push(chalk.yellow(model.padEnd(maxModelWidth)));
+                    parts.push(chalk.yellow(padToWidth(model, maxModelWidth)));
                 }
                 const hasEmail = !!vInfo?.email;
                 const signedIn = !!vInfo?.signedIn;
                 const usageUnavailable = agentReportsUsage(agentId) && signedIn && !usageInfo?.snapshot;
                 const usageUnverified = !!usageInfo?.snapshot && !!usageInfo.error;
-                const usageStr = formatUsageSummary(vInfo?.plan || null, usageInfo?.snapshot || null, maxPlanWidth, { unavailable: usageUnavailable, unverified: usageUnverified });
+                const usageStr = formatUsageSummary(vInfo?.plan || null, usageInfo?.snapshot || null, maxPlanWidth, {
+                    unavailable: usageUnavailable,
+                    unverified: usageUnverified,
+                    maxWindows: usageWindowCap,
+                });
                 const hasUsage = usageStr.length > 0;
                 // Only show lastActive for versions with an actual logged-in account.
                 // Otherwise it reflects install time (misleading "just now" for fresh installs).
@@ -534,25 +577,21 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
                         : '(logged out — log in with: ' + loginHint(agentId) + ')'));
                 }
                 else {
-                    if (hasEmail || hasUsage || hasActive || signedIn) {
-                        // Signed-in agents without a local email show their account id
-                        // (Kimi's user_id) or a "signed in" placeholder (Antigravity) so they
-                        // read as logged in, not blank.
-                        const display = accountColumnLabel(vInfo);
-                        const emailCol = display.padEnd(maxEmail);
-                        parts.push(display ? chalk.cyan(emailCol) : ' '.repeat(maxEmail));
-                    }
-                    if (hasUsage || hasActive) {
-                        const usagePad = ' '.repeat(Math.max(0, maxUsageWidth - visibleWidth(usageStr)));
-                        parts.push(usageStr + usagePad);
+                    // Always emit account / usage / status / lastActive columns once any
+                    // signed-in row exists in the table (widths are global). Empty cells
+                    // are space-padded so later columns do not drift left.
+                    const display = accountColumnLabel(vInfo);
+                    parts.push(display ? chalk.cyan(padToWidth(display, maxEmail)) : ' '.repeat(maxEmail));
+                    if (maxUsageWidth > 0) {
+                        parts.push(padToWidth(usageStr, maxUsageWidth));
                     }
-                    const statusStr = formatUsageStatusBadge(vInfo?.usageStatus);
                     if (maxStatusWidth > 0) {
-                        const statusPad = ' '.repeat(Math.max(0, maxStatusWidth - visibleWidth(statusStr)));
-                        parts.push(statusStr + statusPad);
+                        const statusStr = formatUsageStatusBadge(vInfo?.usageStatus);
+                        parts.push(padToWidth(statusStr, maxStatusWidth));
                     }
-                    if (hasActive)
-                        parts.push(activeStr);
+                    // Fixed-width lastActive so the auth chip (●/○/◐) lines up even when
+                    // some rows have no email-derived lastActive.
+                    parts.push(hasActive ? padToWidth(activeStr, LAST_ACTIVE_COL_WIDTH) : ' '.repeat(LAST_ACTIVE_COL_WIDTH));
                 }
                 if (runDefaultBits.length > 0) {
                     parts.push(chalk.gray(`run ${runDefaultBits.join(' ')}`));
@@ -560,7 +599,7 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
                 const authChip = liveAuthChip(authCache, selfHost, agentId, version);
                 if (authChip)
                     parts.push(authChip);
-                console.log(parts.join('  '));
+                console.log(joinViewColumns(parts));
                 if (showPaths) {
                     const versionDir = getVersionDir(agentId, version);
                     console.log(chalk.gray(`      ${versionDir}`));
@@ -586,18 +625,25 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
             const cliState = cliStates[agentId];
             return `${cliState?.version || 'installed'} (global)`.length;
         }));
-        // Pre-pass: max badge width so rows with `lastActive` line up whether or
-        // not THIS row carries a throttle badge. Without this, the row that DOES
-        // have "out of credits" shifts every other row's `lastActive` left by
-        // ~16 chars, exactly what the version-managed block at maxStatusWidth
-        // already solves above.
+        // Pre-pass: max badge/usage/email widths so columns line up the same way
+        // the version-managed block does (stringWidth for chalk-aware padding).
         let gMaxStatusWidth = 0;
+        let gMaxUsageWidth = 0;
+        let gMaxEmail = 0;
         for (const agentId of globallyInstalled) {
             const gInfoRaw = globalInfoMap.get(agentId);
             const gInfo = gInfoRaw ? mergeCanonical(gInfoRaw) : undefined;
-            const w = visibleWidth(formatUsageStatusBadge(gInfo?.usageStatus));
-            if (w > gMaxStatusWidth)
-                gMaxStatusWidth = w;
+            gMaxStatusWidth = Math.max(gMaxStatusWidth, stringWidth(formatUsageStatusBadge(gInfo?.usageStatus)));
+            const gUsageKey = getUsageLookupKey(gInfo);
+            const gUsage = gUsageKey ? usageByKey.get(gUsageKey) : undefined;
+            const gUsageStr = formatUsageSummary(gInfo?.plan || null, gUsage?.snapshot || null, 3, {
+                unverified: !!gUsage?.snapshot && !!gUsage.error,
+                maxWindows: usageWindowCap,
+            });
+            gMaxUsageWidth = Math.max(gMaxUsageWidth, stringWidth(gUsageStr));
+            const gDisplay = accountColumnLabel(gInfo);
+            if (gDisplay)
+                gMaxEmail = Math.max(gMaxEmail, gDisplay.length);
         }
         for (const agentId of globallyInstalled) {
             const agent = AGENTS[agentId];
@@ -613,22 +659,21 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
             const gUsage = gUsageKey ? usageByKey.get(gUsageKey) : undefined;
             const gUsageStr = formatUsageSummary(gInfo?.plan || null, gUsage?.snapshot || null, 3, {
                 unverified: !!gUsage?.snapshot && !!gUsage.error,
+                maxWindows: usageWindowCap,
             });
             const gActiveStr = gInfo ? formatLastActive(gInfo.lastActive) : '';
             if (gInfo?.email || gUsageStr || gActiveStr || gInfo?.signedIn) {
                 const gDisplay = accountColumnLabel(gInfo);
-                parts.push(gDisplay ? chalk.cyan(gDisplay) : '');
+                parts.push(gDisplay ? chalk.cyan(padToWidth(gDisplay, gMaxEmail)) : ' '.repeat(gMaxEmail));
             }
-            if (gUsageStr || gActiveStr)
-                parts.push(gUsageStr);
-            const gStatusStr = formatUsageStatusBadge(gInfo?.usageStatus);
+            if (gMaxUsageWidth > 0)
+                parts.push(padToWidth(gUsageStr, gMaxUsageWidth));
             if (gMaxStatusWidth > 0) {
-                const statusPad = ' '.repeat(Math.max(0, gMaxStatusWidth - visibleWidth(gStatusStr)));
-                parts.push(gStatusStr + statusPad);
+                parts.push(padToWidth(formatUsageStatusBadge(gInfo?.usageStatus), gMaxStatusWidth));
             }
             if (gActiveStr)
-                parts.push(gActiveStr);
-            console.log(parts.join('  '));
+                parts.push(padToWidth(gActiveStr, LAST_ACTIVE_COL_WIDTH));
+            console.log(joinViewColumns(parts));
             if (showPaths && cliState?.path) {
                 console.log(chalk.gray(`      ${cliState.path}`));
             }

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, loadProfiles, loadHarness, loadSecrets, loadLogin, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadFactory, loadUsage, loadCost, loadPerf, loadOutput, loadBudget, loadAlias, loadMine, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadUninstall, loadShare, loadSend, loadFeed, loadActivity, 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, 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, loadActivity, 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';
@@ -197,6 +197,18 @@ program.hook('postAction', (_thisCommand, actionCommand) => {
             command,
             ...(durationMs !== undefined ? { durationMs } : {}),
         });
+        if (parts[0] === 'run') {
+            const agentName = actionCommand.args?.[0] ? String(actionCommand.args[0]).split('@')[0] : 'run';
+            void import('./lib/analytics/usage-db.js').then(({ recordUsage }) => {
+                recordUsage({
+                    kind: 'agent',
+                    name: agentName || 'run',
+                    event: 'invoke',
+                    source: 'cli',
+                    meta: durationMs !== undefined ? { durationMs } : undefined,
+                });
+            }).catch(() => { });
+        }
         // Disposable perf warehouse — fail-soft spool append (no SQLite on this path).
         if (durationMs !== undefined && parts[0] !== 'perf') {
             void import('./lib/perf/spool.js').then(({ recordSample }) => {
@@ -933,6 +945,7 @@ async function registerAllEagerCommands() {
     await reg(loadUsage);
     await reg(loadCost);
     await reg(loadPerf);
+    await reg(loadTrends);
     await reg(loadOutput);
     await reg(loadBudget);
     await reg(loadAlias);

package/dist/lib/agents.js

@@ -1754,8 +1754,8 @@ export async function getAccountInfo(agentId, home) {
     }
 }
 // Fresh window for the cached session walk. Matches USAGE_CACHE_FRESH_MS in
-// usage.ts so a launch storm reuses both probes for the same period.
-const LAST_ACTIVE_CACHE_FRESH_MS = 2 * 60 * 1000;
+// usage.ts (5 minutes) so a launch storm reuses both probes for the same period.
+const LAST_ACTIVE_CACHE_FRESH_MS = 5 * 60 * 1000;
 const getLastActiveCachePath = () => path.join(getCacheDir(), 'last-active.json');
 /**
  * Determine when the agent was last used by checking session file mtimes,

package/dist/lib/analytics/dashboard.d.ts

@@ -0,0 +1,11 @@
+import { RECIPE_IDS, runRecipe, trendsWindow, type RecipeId, type RecipeSection, type TrendsWindow } from './recipes.js';
+export interface TrendsDashboard {
+    window: TrendsWindow;
+    durationMs: number;
+    sections: RecipeSection[];
+}
+export declare function buildTrendsDashboard(opts?: {
+    days?: number;
+    ids?: RecipeId[];
+}): TrendsDashboard;
+export { trendsWindow, runRecipe, RECIPE_IDS, type RecipeId, type RecipeSection };

package/dist/lib/analytics/dashboard.js

@@ -0,0 +1,31 @@
+import { RECIPE_IDS, runRecipe, trendsWindow, } from './recipes.js';
+const DEFAULT_ORDER = [
+    'harness-mix',
+    'model-mix',
+    'session-volume',
+    'token-ratio',
+    'tools-per-session',
+    'secrets-hot',
+    'browser-activity',
+    'resource-mix',
+];
+export function buildTrendsDashboard(opts = {}) {
+    const t0 = Date.now();
+    const win = trendsWindow(opts.days ?? 7);
+    const ids = opts.ids ?? DEFAULT_ORDER;
+    const sections = [];
+    for (const id of ids) {
+        if (!RECIPE_IDS.includes(id))
+            continue;
+        const section = runRecipe(id, win);
+        if (section.empty)
+            continue;
+        sections.push(section);
+    }
+    return {
+        window: win,
+        durationMs: Date.now() - t0,
+        sections,
+    };
+}
+export { trendsWindow, runRecipe, RECIPE_IDS };