@phnx-labs/agents-cli 1.21.1 → 1.21.3

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';
@@ -56,10 +57,24 @@ function parseContextFlag(raw) {
         return { path: raw.trim(), purpose: '' };
     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) {
+/**
+ * Best-effort `owner/repo` from a repo's origin remote.
+ *
+ * `stderr: 'ignore'` is load-bearing, not tidiness. A checkout with no origin
+ * makes git print `error: No such remote 'origin'` on ITS stderr, which is the
+ * terminal's — the catch below never sees it. That was invisible while this was
+ * called once from `add` inside a real repo, and became noise the moment
+ * `import --from-factory` started calling it per row: importing 12 registry
+ * rows printed two raw git errors between the progress lines. Absence of a
+ * remote is an expected answer here (`undefined`), not something to report.
+ */
+export function originSlug(cwd) {
     try {
-        const url = execFileSync('git', ['remote', 'get-url', 'origin'], { cwd, encoding: 'utf8' }).trim();
+        const url = execFileSync('git', ['remote', 'get-url', 'origin'], {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
         return parseOwnerRepoFromRemote(url) ?? undefined;
     }
     catch {
@@ -94,7 +109,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 +200,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 +257,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 +301,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 +323,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 +454,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 +490,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 +612,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 +676,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/sessions-picker.js

@@ -374,6 +374,13 @@ function formatCompactPreview(events, session) {
     let latestTodos;
     let subAgentCount = 0;
     const toolTags = new Set();
+    // usedBrowser/usedComputer are computed at scan time from a sessionId-scoped
+    // events-log read (session/db.ts detectToolUsage), NOT a transcript regex —
+    // undefined means a legacy row this scanner hasn't computed the field for
+    // yet, so only THEN does classifySessionTool's transcript-derived guess run
+    // below (mirrors directoriesTouched's prefer-persisted/fall-back-to-derived
+    // pattern for recentDirectoriesTouched).
+    const knownToolUsage = session.usedBrowser !== undefined;
     for (const event of events) {
         if (event.type === 'message') {
             if (event.role === 'user' && !firstUser && event.content) {
@@ -388,8 +395,10 @@ function formatCompactPreview(events, session) {
         else if (event.type === 'tool_use' && !event._local) {
             const tool = event.tool || '';
             const command = event.command || '';
-            for (const tag of classifySessionTool(tool, command))
-                toolTags.add(tag);
+            if (!knownToolUsage) {
+                for (const tag of classifySessionTool(tool, command))
+                    toolTags.add(tag);
+            }
             if (isSubAgentTool(tool, command))
                 subAgentCount++;
             const p = event.path || event.args?.file_path || event.args?.path || '';
@@ -412,6 +421,12 @@ function formatCompactPreview(events, session) {
             toolCalls++;
         }
     }
+    // Persisted field wins when computed — it comes from real browser.navigate/
+    // browser.screenshot/computer.action events, not a fuzzy tool-name regex.
+    if (session.usedBrowser)
+        toolTags.add('browser');
+    if (session.usedComputer)
+        toolTags.add('computer');
     // Prefer the transcript-derived list when we just re-parsed the file (freshest
     // checklist write); fall back to SessionMeta.todos for rows where the scan/
     // fan-out attached progress but the event stream has no TodoWrite yet.

package/dist/commands/sessions.d.ts

@@ -70,6 +70,11 @@ interface SessionsOptions extends SessionFilterOptions {
     printCmd?: boolean;
     /** Print a compact preview of the matched session and exit (no pager). */
     preview?: boolean;
+    /** Only sessions that invoked this skill (#12) — matches a bare name or a
+     * namespaced plugin skill's short name (`--skill design` finds `rush:design`). */
+    skill?: string;
+    /** Only sessions that used a skill/command owned by this plugin (#12). */
+    plugin?: string;
 }
 /**
  * Strip terminal/harness noise from a preview so the column stays a single line

package/dist/commands/sessions.js

@@ -1172,6 +1172,12 @@ export function hasNoBrowserDisqualifyingFlags(options, query) {
         !options.markdown &&
         !options.until &&
         !options.project &&
+        // The interactive browser picker is a fuzzy-search TUI over the discovered
+        // pool, not a SQL-filtered listing — it cannot represent a skill/plugin
+        // scope. Falling through to it here would silently drop the filter and
+        // show the unfiltered pool instead (same reasoning as --project/--sort).
+        !options.skill &&
+        !options.plugin &&
         !options.sort &&
         !options.artifacts &&
         options.artifact === undefined &&
@@ -1202,6 +1208,10 @@ function canonicalSessionsCommand(query, options) {
         a.push('--device', h);
     if (options.project)
         a.push('--project', options.project);
+    if (options.skill)
+        a.push('--skill', options.skill);
+    if (options.plugin)
+        a.push('--plugin', options.plugin);
     if (options.all)
         a.push('--all');
     if (options.since)
@@ -1557,6 +1567,8 @@ limitSource) {
             until: options.until,
             sortBy,
             origin: options.routine ? 'routine' : undefined,
+            skill: options.skill,
+            plugin: options.plugin,
         };
         let hiddenUnmanaged = 0;
         let sessions = await discoverSessions({
@@ -3306,6 +3318,8 @@ export function registerSessionsCommands(program) {
         .option('--in-team <name>', "Only this team: the session that spawned it plus (with --teams) its teammates. Spans every directory and all time, since a team's worktrees and history sit outside the default window.")
         .option('--routine', 'Show only sessions archived from routine runs')
         .option('-p, --project <name>', 'Filter by project name (searches across all directories)')
+        .option('--skill <name>', 'Only sessions that invoked this skill (matches a bare name or a namespaced plugin skill\'s short name, e.g. --skill design finds rush:design)')
+        .option('--plugin <name>', 'Only sessions that used a skill/command owned by this plugin')
         .option('--since <time>', 'Only sessions newer than this (e.g., 2h, 7d, 4w, or ISO date)')
         .option('--until <time>', 'Only sessions older than this (ISO timestamp)')
         .option('-n, --limit <n>', 'Maximum number of sessions to return', DEFAULT_LIMIT)

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;