@phnx-labs/agents-cli 1.20.90 → 1.20.92

package/dist/lib/session/relative-time.js

@@ -4,6 +4,19 @@
  * offline-cache banner (`remote.ts`) share one formatter — `sessions.ts` imports
  * `remote.ts`, so a back-import would cycle.
  */
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+/**
+ * Calendar label for a timestamp older than the relative window. A 2-digit year
+ * is appended outside the current year so "Jun 28" is never ambiguous across
+ * years (e.g. "Jun 28 '25").
+ */
+function calendarLabel(thenMs, nowMs) {
+    const d = new Date(thenMs);
+    const label = `${MONTHS[d.getMonth()]} ${d.getDate()}`;
+    return d.getFullYear() === new Date(nowMs).getFullYear()
+        ? label
+        : `${label} '${String(d.getFullYear()).slice(-2)}`;
+}
 export function formatRelativeTime(isoTimestamp) {
     const now = Date.now();
     const then = new Date(isoTimestamp).getTime();
@@ -21,12 +34,87 @@ export function formatRelativeTime(isoTimestamp) {
         return `${diffHrs} hour${diffHrs === 1 ? '' : 's'} ago`;
     if (diffDays < 7)
         return `${diffDays} day${diffDays === 1 ? '' : 's'} ago`;
-    // Older: show the date. Append a 2-digit year for anything outside the current
-    // year so "Jun 28" is never ambiguous across years (e.g. "Jun 28 '25").
-    const d = new Date(then);
-    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-    const label = `${months[d.getMonth()]} ${d.getDate()}`;
-    return d.getFullYear() === new Date(now).getFullYear()
-        ? label
-        : `${label} '${String(d.getFullYear()).slice(-2)}`;
+    // Older: show the date.
+    return calendarLabel(then, now);
+}
+/**
+ * Compact age — `now`, `45m`, `3h`, `2d`, then the calendar date. This is the
+ * *creation* half of a session's time cell: it renders right next to the long
+ * last-activity label, and one row can afford one long form, not two.
+ */
+export function formatCompactAge(isoTimestamp) {
+    const now = Date.now();
+    const then = new Date(isoTimestamp).getTime();
+    if (isNaN(then))
+        return isoTimestamp;
+    const diffMs = now - then;
+    const diffMin = Math.floor(diffMs / 60_000);
+    const diffHrs = Math.floor(diffMs / 3_600_000);
+    const diffDays = Math.floor(diffMs / 86_400_000);
+    if (diffMin < 1)
+        return 'now';
+    if (diffMin < 60)
+        return `${diffMin}m`;
+    if (diffHrs < 24)
+        return `${diffHrs}h`;
+    if (diffDays < 7)
+        return `${diffDays}d`;
+    return calendarLabel(then, now);
+}
+/**
+ * Shortest creation→last-activity gap worth rendering as two fields. Below it
+ * both halves name the same minute, so the row would carry a duplicate instead
+ * of information.
+ */
+const SPAN_MIN_MS = 60_000;
+/**
+ * Split a session's timestamps into the two fields a listing renders: when it
+ * was created and when it was last active. One last-activity label answers
+ * neither "is this the old session I'm looking for" nor "how long did it run" —
+ * a session touched an hour ago may have started last week.
+ */
+export function sessionAgeParts(createdIso, lastActivityIso) {
+    const lastIso = lastActivityIso ?? createdIso;
+    const last = formatRelativeTime(lastIso);
+    const createdMs = new Date(createdIso).getTime();
+    const lastMs = new Date(lastIso).getTime();
+    if (isNaN(createdMs) || isNaN(lastMs) || lastMs - createdMs < SPAN_MIN_MS)
+        return { last };
+    return { created: formatCompactAge(createdIso), last };
+}
+/**
+ * Parse a time filter string (relative like '7d' or an ISO timestamp) into epoch
+ * milliseconds. Backs `--since` on `sessions`, `cost`, `teams`, and `output`, and
+ * `--unused` on `secrets list`.
+ *
+ * It lives here, in a module with no imports, rather than in `discover.ts` where
+ * it started: `discover.ts` loads `../sqlite.js`, so importing this one function
+ * from there pulls `node:sqlite` into the caller's module graph and Node prints
+ * `ExperimentalWarning: SQLite …` on stderr. That is invisible in a command that
+ * already touches the session DB, and a broken contract in one that doesn't —
+ * `monitors --json` asserts a clean stderr. `discover.ts` re-exports it, so
+ * existing importers are unaffected.
+ */
+export function parseTimeFilter(input) {
+    // Units: m=minute, h=hour, d=day, w=week, mo=month(30d), y=year(365d). `mo`
+    // must precede the single-letter alternatives so "1mo" isn't read as "1m"+"o".
+    const relativeMatch = input.match(/^(\d+)(mo|[mhdwy])$/i);
+    if (relativeMatch) {
+        const value = parseInt(relativeMatch[1], 10);
+        const unit = relativeMatch[2].toLowerCase();
+        if (unit === 'm')
+            return Date.now() - value * 60_000;
+        if (unit === 'h')
+            return Date.now() - value * 3_600_000;
+        if (unit === 'd')
+            return Date.now() - value * 86_400_000;
+        if (unit === 'w')
+            return Date.now() - value * 7 * 86_400_000;
+        if (unit === 'mo')
+            return Date.now() - value * 30 * 86_400_000;
+        if (unit === 'y')
+            return Date.now() - value * 365 * 86_400_000;
+    }
+    const ts = new Date(input).getTime();
+    return Number.isNaN(ts) ? 0 : ts;
 }

package/dist/lib/session/remote-list.js

@@ -18,7 +18,7 @@ import chalk from 'chalk';
 import { SSH_OPTS, controlOpts, assertValidSshTarget, shellQuote } from '../ssh-exec.js';
 import { sshTargetFor } from '../devices/connect.js';
 import { resolveExplicitTargets } from '../devices/resolve-target.js';
-import { loadDevices, isControlDevice } from '../devices/registry.js';
+import { loadDevices, isControlDevice, isDialableDevice } from '../devices/registry.js';
 import { remoteShellFor, buildWindowsAgentsCommand } from '../hosts/remote-cmd.js';
 import { machineId, normalizeHost } from './sync/config.js';
 import { NO_FANOUT_ENV } from './remote-active.js';
@@ -163,7 +163,10 @@ export async function gatherRemoteList(forwardedArgs, hosts) {
             return { sessions: [], deviceCount: 0, unreachable: ['device registry'] };
         }
         for (const d of Object.values(reg)) {
-            if (d.tailscale?.online !== true)
+            // Live SSH-probe verdict first, cached tailscale snapshot only as a
+            // fallback — see isDialableDevice. A manually-registered device has no
+            // tailscale peer entry, so gating on `online` alone hid its sessions.
+            if (!isDialableDevice(d))
                 continue;
             if (normalizeHost(d.name) === self)
                 continue;

package/dist/lib/session/render.d.ts

@@ -7,10 +7,18 @@
  * transcript. Filtering by role and turn slicing is handled here as well.
  */
 import type { SessionEvent, SessionMeta } from './types.js';
+import { unwrapCommand, bucketKey } from './bash-command.js';
 /**
  * Return absPath relative to cwd; fall back to ~/… then absolute.
  */
 export declare function relativeToCwd(absPath: string, cwd?: string): string;
+/**
+ * Display form for a touched path: cwd-relative first; then collapse any
+ * `.agents/worktrees/<slug>` segment (in-cwd OR outside) to `⧉ <slug>/…` so
+ * group labels stay on one line instead of `~/src/…/.agents/worktrees/<slug>/…`;
+ * else home-collapse.
+ */
+export declare function displayPath(absPath: string, cwd?: string): string;
 /**
  * Wrap a filesystem path label in an OSC 8 `file://` hyperlink when the terminal
  * supports it. Degrades to the plain label otherwise.
@@ -21,18 +29,11 @@ export declare function linkPath(absPath: string, label: string): string;
  * issue, …) when the terminal supports it. Degrades to the plain label otherwise.
  */
 export declare function linkUrl(url: string, label: string): string;
-/**
- * Unwrap wrapper prefixes to find the actual executable.
- */
-export declare function unwrapCommand(cmd: string): string;
 /**
  * Normalize a command so trivial flag/pipe variations collapse to the same key.
  */
 export declare function normalizeForDedup(cmd: string): string;
-/**
- * Return the bucket key for a command (used for grouping within a category).
- */
-export declare function bucketKey(cmd: string): string;
+export { unwrapCommand, bucketKey };
 interface CmdRun {
     normalized: string;
     raw: string;
@@ -125,4 +126,3 @@ export declare function renderConversationMarkdown(events: SessionEvent[], opts?
 export declare function renderJson(events: SessionEvent[], meta?: SessionMeta, opts?: {
     redact?: boolean;
 }): string;
-export {};

package/dist/lib/session/render.js

@@ -13,6 +13,8 @@ import { cleanSessionPrompt, extractSessionTopic } from './prompt.js';
 import { renderMarkdown } from '../markdown.js';
 import { redactSecrets } from '../redact.js';
 import { classifyFileChanges, changeCounts, toolHistogram, detectTestResult } from './digest.js';
+import { classifyBashCommand, unwrapCommand, bucketKey } from './bash-command.js';
+import { extractArtifacts, extractHooks, extractLinks, extractSkills } from './highlights.js';
 import { extractTodoProgressFromEvents } from './state.js';
 // ── Path helpers ──────────────────────────────────────────────────────────────
 /**
@@ -29,6 +31,31 @@ export function relativeToCwd(absPath, cwd) {
     }
     return absPath;
 }
+/**
+ * Display form for a touched path: cwd-relative first; then collapse any
+ * `.agents/worktrees/<slug>` segment (in-cwd OR outside) to `⧉ <slug>/…` so
+ * group labels stay on one line instead of `~/src/…/.agents/worktrees/<slug>/…`;
+ * else home-collapse.
+ */
+export function displayPath(absPath, cwd) {
+    const rel = relativeToCwd(absPath, cwd);
+    const norm = rel.replace(/\\/g, '/');
+    const wt = norm.match(/(^|\/)\.agents\/worktrees\/([^/]+)/);
+    if (wt) {
+        const after = norm.slice(norm.indexOf(wt[0]) + wt[0].length).replace(/^\//, '');
+        return after ? `⧉ ${wt[2]}/${after}` : `⧉ ${wt[2]}`;
+    }
+    return rel;
+}
+/** One checklist line with a status marker: `[x] done` / `[>] doing` / `[ ] todo`. */
+function renderTodoMarker(item) {
+    const text = item.content;
+    if (item.status === 'completed')
+        return chalk.green('[x]') + ' ' + chalk.gray(text);
+    if (item.status === 'in_progress')
+        return chalk.yellow('[>]') + ' ' + chalk.white(text);
+    return chalk.gray('[ ]') + ' ' + chalk.white(text);
+}
 /** Best-effort feature-detect for OSC 8 hyperlink support in the current TTY. */
 function supportsHyperlinks() {
     return Boolean(process.stdout.isTTY &&
@@ -56,28 +83,6 @@ export function linkUrl(url, label) {
     return supportsHyperlinks() ? osc8(url, label) : label;
 }
 // ── Command grouping ──────────────────────────────────────────────────────────
-/**
- * Unwrap wrapper prefixes to find the actual executable.
- */
-export function unwrapCommand(cmd) {
-    const ssh = cmd.match(/^ssh\s+\S+\s+"(.+)"\s*(?:\|.*)?$/);
-    if (ssh)
-        return unwrapCommand(ssh[1]);
-    const lead = cmd.match(/^(?:sudo|env\s+\S+=\S+|time)\s+(.+)/);
-    if (lead)
-        return unwrapCommand(lead[1]);
-    // Strip shell-style leading env assignments: `PATH=/x CMD ...`, `FOO=bar BAR=baz CMD ...`
-    const shellEnv = cmd.match(/^(?:[A-Z_][A-Z0-9_]*=\S+\s+)+(\S.*)$/);
-    if (shellEnv)
-        return unwrapCommand(shellEnv[1]);
-    const cd = cmd.match(/^cd\s+\S+\s*&&\s*(.+)/);
-    if (cd)
-        return unwrapCommand(cd[1]);
-    const npx = cmd.match(/^npx\s+(.+)/);
-    if (npx)
-        return unwrapCommand(npx[1]);
-    return cmd;
-}
 /**
  * Normalize a command so trivial flag/pipe variations collapse to the same key.
  */
@@ -94,45 +99,35 @@ export function normalizeForDedup(cmd) {
     }
     return s.trim();
 }
-/** Command classification categories with signal levels for summary rendering. */
-const CATEGORIES = [
-    { name: 'Probes', match: t => ['ls', 'cat', 'head', 'tail', 'wc', 'stat', 'file', 'which', 'tree', 'pwd'].includes(t), signal: 'low' },
-    { name: 'Search', match: t => ['grep', 'rg', 'ag', 'fd', 'find'].includes(t), signal: 'low' },
-    { name: 'Build/test', match: t => ['make', 'cargo', 'pytest', 'go', 'bun', 'npm', 'pnpm', 'yarn', 'tsc', 'vitest', 'tsx', 'node', 'python', 'python3', 'jest'].includes(t), signal: 'high' },
-    { name: 'Install', match: t => ['brew', 'pip', 'apt', 'apk'].includes(t), signal: 'high' },
-    { name: 'VCS', match: t => ['git', 'gh'].includes(t), signal: 'mid' },
-    { name: 'HTTP', match: t => ['curl', 'wget', 'rush', 'http'].includes(t), signal: 'mid' },
-    { name: 'Remote', match: t => ['ssh', 'scp', 'rsync'].includes(t), signal: 'mid' },
-    { name: 'Shell', match: t => ['rm', 'mv', 'cp', 'mkdir', 'touch', 'echo', 'printf', 'chmod', 'ln', 'awk', 'sed', 'tee', 'xargs', 'for'].includes(t), signal: 'low' },
-    { name: 'Wait', match: t => ['sleep', 'wait'].includes(t), signal: 'low' },
-];
-/** CLI tools whose subcommand (second token) is included in the bucket key. */
-const TWO_LEVEL_TOKENS = new Set([
-    'git', 'gh', 'bun', 'npm', 'cargo', 'docker', 'kubectl', 'rush', 'openclaw', 'pnpm', 'yarn',
-]);
-/**
- * Return the bucket key for a command (used for grouping within a category).
- */
-export function bucketKey(cmd) {
-    const unwrapped = unwrapCommand(cmd);
-    const tokens = unwrapped.trim().split(/\s+/);
-    const first = tokens[0] ?? 'other';
-    const isRemote = cmd.trim().startsWith('ssh ') || cmd.trim().startsWith('scp ');
-    if (TWO_LEVEL_TOKENS.has(first) && tokens[1]) {
-        const key = `${first} ${tokens[1]}`;
-        return isRemote ? `ssh\u2192${key}` : key;
-    }
-    return isRemote ? `ssh\u2192${first}` : first;
-}
+// Re-export the shared classifier/bucketing for callers in this module's surface.
+// `bucketKey` is the single source of truth in bash-command.ts (correct subcommand
+// scan + `ssh\u2192` remote prefix); render must not keep a divergent copy.
+export { unwrapCommand, bucketKey };
+const CATEGORY_NAMES = {
+    vcs: 'VCS',
+    'build-test': 'Build/test',
+    install: 'Install',
+    remote: 'Remote',
+    http: 'HTTP',
+    media: 'Media',
+    upscaling: 'Upscaling',
+    metadata: 'Metadata',
+    probe: 'Probes',
+    search: 'Search',
+    shell: 'Shell',
+    wait: 'Wait',
+    other: 'Other',
+};
 function categoryOf(cmd) {
     const rawFirst = cmd.trim().split(/\s+/)[0]?.toLowerCase() ?? '';
     // Remote wrappers: classify as Remote regardless of inner command.
     if (['ssh', 'scp', 'rsync'].includes(rawFirst)) {
-        return CATEGORIES.find(c => c.name === 'Remote') ?? null;
+        return { name: 'Remote', signal: 'mid' };
     }
-    const unwrapped = unwrapCommand(cmd);
-    const first = unwrapped.trim().split(/\s+/)[0]?.toLowerCase() ?? '';
-    return CATEGORIES.find(c => c.match(first)) ?? null;
+    const info = classifyBashCommand(cmd);
+    if (info.category === 'other')
+        return null;
+    return { name: CATEGORY_NAMES[info.category], signal: info.signal };
 }
 /**
  * Collapse consecutive same-normalized commands within a 60-second window
@@ -387,11 +382,12 @@ function pickDistinct(samples, max) {
     return result.length > 0 ? result : samples.slice(0, max);
 }
 // ── File grouping ─────────────────────────────────────────────────────────────
-/** Group file paths by their parent directory, relative to cwd. */
+/** Group file paths by their parent directory, in display form (cwd-relative,
+ * worktree-collapsed, home-collapsed). */
 function groupByParentDir(paths, cwd) {
     const groups = new Map();
     for (const p of paths) {
-        const rel = relativeToCwd(p, cwd);
+        const rel = displayPath(p, cwd);
         const slashIdx = rel.lastIndexOf('/');
         const dir = slashIdx >= 0 ? rel.slice(0, slashIdx) : '.';
         const base = slashIdx >= 0 ? rel.slice(slashIdx + 1) : rel;
@@ -454,17 +450,17 @@ const OP_MARK = { created: '+', modified: '~', deleted: '−' };
  * create/modify/delete lifecycle, plus a `+N ~N −N` summary. Replaces the old
  * flat "Modified" list. Returns true if anything was rendered.
  */
-function renderChangesSection(lines, events, cwd) {
+function renderChangesSection(lines, allChanges, cwd) {
     // In-project changes only; edits outside cwd (e.g. /tmp) keep their own
     // "External edits" section so they don't clutter the project's changeset.
     const inCwd = (p) => !cwd || !p.startsWith('/') || p.startsWith(cwd + '/');
-    const changes = classifyFileChanges(events).filter(ch => inCwd(ch.path));
+    const changes = allChanges.filter(ch => inCwd(ch.path));
     if (changes.length === 0)
         return false;
     const c = changeCounts(changes);
     const opByRel = new Map();
     for (const ch of changes)
-        opByRel.set(relativeToCwd(ch.path, cwd), ch.op);
+        opByRel.set(displayPath(ch.path, cwd), ch.op);
     const summary = [
         c.created ? chalk.green(`+${c.created}`) : '',
         c.modified ? chalk.yellow(`~${c.modified}`) : '',
@@ -528,8 +524,8 @@ export function renderSummary(events, cwd) {
     const filesModifiedExternal = new Set();
     // Commands with timestamps
     const cmdList = [];
-    // Plan items
-    const todoItems = extractTodoProgressFromEvents(events)?.items.map(item => item.content) ?? [];
+    // Plan items (checklist entries keep their status for [x]/[>]/[ ] markers)
+    const todoItems = extractTodoProgressFromEvents(events)?.items ?? [];
     let exitPlanContent = null;
     let planFilePath = null;
     // Subagent spawns
@@ -559,7 +555,7 @@ export function renderSummary(events, cwd) {
                     }
                     else {
                         (isInsideCwd(p) || !cwd ? filesModifiedAbs : filesModifiedExternal).add(p);
-                        recentActivity.push({ kind: 'edit', label: relativeToCwd(p, cwd), ts, absPath: p });
+                        recentActivity.push({ kind: 'edit', label: displayPath(p, cwd), ts, absPath: p });
                     }
                 }
             }
@@ -624,11 +620,11 @@ export function renderSummary(events, cwd) {
         filesReadAbs.delete(p);
     for (const p of filesModifiedExternal)
         filesReadAbs.delete(p);
-    // Build abs→rel mapping for linkPath
+    // Build abs→display mapping for linkPath
     const buildAbsMap = (absSet) => {
         const m = new Map();
         for (const abs of absSet) {
-            const rel = relativeToCwd(abs, cwd);
+            const rel = displayPath(abs, cwd);
             m.set(rel, abs);
         }
         return m;
@@ -668,22 +664,27 @@ export function renderSummary(events, cwd) {
         }
         lines.push('');
     }
-    // 3. Plan
+    // 3. Plan — the plan document (ExitPlanMode text / plan file) AND the live
+    // checklist. Both render: the checklist used to be hidden whenever plan text
+    // existed, which read as "this session had no todos".
     if (todoItems.length > 0 || exitPlanContent || planFilePath) {
         lines.push(chalk.bold('Plan'));
         if (planFilePath) {
             const home = process.env.HOME ?? '';
-            const displayPath = home && planFilePath.startsWith(home) ? planFilePath.replace(home, '~') : planFilePath;
-            lines.push('  ' + chalk.cyan(displayPath));
+            const planPathDisplay = home && planFilePath.startsWith(home) ? planFilePath.replace(home, '~') : planFilePath;
+            lines.push('  ' + chalk.cyan(planPathDisplay));
         }
         if (exitPlanContent) {
             const planLines = exitPlanContent.split('\n').slice(0, 10);
             for (const l of planLines)
                 lines.push('  ' + l);
         }
-        else if (todoItems.length > 0) {
+        if (todoItems.length > 0) {
             for (const item of todoItems.slice(0, 20)) {
-                lines.push('  · ' + item);
+                lines.push('  ' + renderTodoMarker(item));
+            }
+            if (todoItems.length > 20) {
+                lines.push('  ' + chalk.gray(`… (${todoItems.length - 20} more)`));
             }
         }
         lines.push('');
@@ -698,6 +699,30 @@ export function renderSummary(events, cwd) {
         }
         lines.push('');
     }
+    // 4b. Highlights — what the session USED (skills, hooks) and the references
+    // it mentioned (links). Shared extraction with the picker preview so the two
+    // renders never disagree.
+    const skills = extractSkills(events);
+    if (skills.length > 0) {
+        const shown = skills.map(s => chalk.white(s.name) + (s.count > 1 ? chalk.gray(` ×${s.count}`) : ''));
+        lines.push(chalk.bold('Skills') + chalk.gray(` (${skills.length})`) + '  ' + shown.join(chalk.gray(' · ')));
+        lines.push('');
+    }
+    const hooks = extractHooks(events);
+    if (hooks.length > 0) {
+        const shown = hooks.map(h => chalk.white(h.name) + (h.count > 1 ? chalk.gray(` ×${h.count}`) : '') + (h.failed ? chalk.red(` (${h.failed} failed)`) : ''));
+        lines.push(chalk.bold('Hooks') + chalk.gray(` (${hooks.length})`) + '  ' + shown.join(chalk.gray(' · ')));
+        lines.push('');
+    }
+    const links = extractLinks(events);
+    if (links.length > 0) {
+        // Width-capped like the picker's Dirs line: a link-heavy session must not
+        // wrap the summary pane.
+        const shown = links.slice(0, 6).map(l => chalk.blue(linkUrl(l.url, l.label)));
+        const more = links.length > 6 ? chalk.gray(` · +${links.length - 6} more`) : '';
+        lines.push(chalk.bold('Links') + chalk.gray(` (${links.length})`) + '  ' + shown.join(chalk.gray(' · ')) + more);
+        lines.push('');
+    }
     // 5. Errors (moved up from the bottom: it describes failed attempts, not the
     // session's final state. Sitting at the bottom previously made early errors
     // look recent, which confused readers.)
@@ -713,8 +738,22 @@ export function renderSummary(events, cwd) {
         lines.push('');
     }
     // 6. Changes — files grouped by directory with create/modify/delete lifecycle
-    // (replaces the old flat "Modified" + "External edits" lists).
-    renderChangesSection(lines, events, cwd);
+    // (replaces the old flat "Modified" + "External edits" lists). Classified
+    // once here and shared with the Artifacts section below.
+    const allChanges = classifyFileChanges(events);
+    renderChangesSection(lines, allChanges, cwd);
+    // 6a. Artifacts — documents the session PRODUCED (`.agents/artifacts|plans|
+    // reports`, other *.md/*.html creations), named and clickable. These drown in
+    // the Changeset's source churn, so they get their own section.
+    const artifacts = extractArtifacts(allChanges);
+    if (artifacts.length > 0) {
+        lines.push(chalk.bold('Artifacts') + chalk.gray(` (${artifacts.length})`));
+        for (const a of artifacts) {
+            const tag = a.bucket === 'docs' ? '' : chalk.gray(` (${a.bucket})`);
+            lines.push('  ' + chalk.green('+') + ' ' + chalk.cyan(linkPath(a.path, a.basename)) + tag);
+        }
+        lines.push('');
+    }
     // 6b. Catch-up signals: last test/build verdict, then the tool histogram.
     renderTestsLine(lines, events);
     renderToolsSection(lines, computeSummaryStats(events));

package/dist/lib/session/types.d.ts

@@ -18,7 +18,7 @@ export declare const SESSION_AGENTS: SessionAgentId[];
 export declare function isSessionTrackedAgent(agent: string): agent is SessionAgentId;
 /** A single normalized event within a session (message, tool call, thinking, etc.). */
 export interface SessionEvent {
-    type: 'message' | 'tool_use' | 'tool_result' | 'thinking' | 'error' | 'init' | 'result' | 'usage' | 'attachment';
+    type: 'message' | 'tool_use' | 'tool_result' | 'thinking' | 'error' | 'init' | 'result' | 'usage' | 'attachment' | 'hook';
     agent: SessionAgentId;
     timestamp: string;
     role?: 'user' | 'assistant';
@@ -49,6 +49,9 @@ export interface SessionEvent {
     name?: string;
     mediaType?: string;
     sizeBytes?: number;
+    hookName?: string;
+    /** Lifecycle event the hook fired on (SessionStart, PreToolUse, …). */
+    hookEvent?: string;
 }
 /** A displayable file attachment discovered in a session transcript. */
 export interface SessionAttachment {

package/dist/lib/ssh-exec.d.ts

@@ -73,6 +73,12 @@ export declare function sshExec(target: string, remoteCmd: string, opts?: SshExe
 /**
  * Async variant of {@link sshExec}. Same hardened argv composition, but uses
  * child_process.spawn so fleet fan-outs can probe multiple hosts concurrently.
+ *
+ * A timeout-bearing call uses a fresh ssh connection (`multiplex: false`) even
+ * when the caller requests multiplexing: a control-master outlives the local
+ * client, so killing the local ssh process on timeout would leave the remote
+ * command running. With a direct connection, terminating the local child tears
+ * down the remote side (RUSH-2114).
  */
 export declare function sshExecAsync(target: string, remoteCmd: string, opts?: SshExecOptions): Promise<SshExecResult>;
 export interface SshExecRawResult {

package/dist/lib/ssh-exec.js

@@ -128,10 +128,19 @@ export function sshExec(target, remoteCmd, opts = {}) {
 /**
  * Async variant of {@link sshExec}. Same hardened argv composition, but uses
  * child_process.spawn so fleet fan-outs can probe multiple hosts concurrently.
+ *
+ * A timeout-bearing call uses a fresh ssh connection (`multiplex: false`) even
+ * when the caller requests multiplexing: a control-master outlives the local
+ * client, so killing the local ssh process on timeout would leave the remote
+ * command running. With a direct connection, terminating the local child tears
+ * down the remote side (RUSH-2114).
  */
 export function sshExecAsync(target, remoteCmd, opts = {}) {
     assertValidSshTarget(target);
-    const mux = opts.multiplex === false ? [] : controlOpts();
+    // Control-master connections defeat local timeouts — the master keeps the
+    // remote command alive after we kill the client. Force a fresh connection
+    // whenever the caller asked for a timeout so the timeout actually stops work.
+    const mux = opts.multiplex === false || opts.timeoutMs ? [] : controlOpts();
     const args = [...sshConnectOpts(mux, opts.hostKeyOpts), ...(opts.extraSshArgs ?? []), target, remoteCmd];
     return new Promise((resolve) => {
         const child = spawn('ssh', args, {

package/dist/lib/startup/command-registry.d.ts

@@ -44,6 +44,7 @@ export declare const loadExport: ModuleLoader;
 export declare const loadPackages: ModuleLoader;
 export declare const loadRoutines: ModuleLoader;
 export declare const loadMonitors: ModuleLoader;
+export declare const loadProjects: ModuleLoader;
 export declare const loadRun: ModuleLoader;
 export declare const loadFork: ModuleLoader;
 export declare const loadDefaults: ModuleLoader;
@@ -70,6 +71,7 @@ export declare const loadDrive: ModuleLoader;
 export declare const loadFactory: ModuleLoader;
 export declare const loadUsage: ModuleLoader;
 export declare const loadCost: ModuleLoader;
+export declare const loadPerf: ModuleLoader;
 export declare const loadOutput: ModuleLoader;
 export declare const loadBudget: ModuleLoader;
 export declare const loadAlias: ModuleLoader;

package/dist/lib/startup/command-registry.js

@@ -22,6 +22,7 @@ export const loadExport = async () => (await import('../../commands/export.js'))
 export const loadPackages = async () => (await import('../../commands/packages.js')).registerPackagesCommands;
 export const loadRoutines = async () => (await import('../../commands/routines.js')).registerRoutinesCommands;
 export const loadMonitors = async () => (await import('../../commands/monitors.js')).registerMonitorsCommands;
+export const loadProjects = async () => (await import('../../commands/projects.js')).registerProjectsCommands;
 export const loadRun = async () => (await import('../../commands/exec.js')).registerRunCommand;
 export const loadFork = async () => (await import('../../commands/fork.js')).registerForkCommand;
 export const loadDefaults = async () => (await import('../../commands/defaults.js')).registerDefaultsCommands;
@@ -48,6 +49,7 @@ export const loadDrive = async () => (await import('../../commands/drive.js')).r
 export const loadFactory = async () => (await import('../../commands/factory.js')).registerFactoryCommands;
 export const loadUsage = async () => (await import('../../commands/usage.js')).registerUsageCommand;
 export const loadCost = async () => (await import('../../commands/cost.js')).registerCostCommand;
+export const loadPerf = async () => (await import('../../commands/perf.js')).registerPerfCommand;
 export const loadOutput = async () => (await import('../../commands/output.js')).registerOutputCommand;
 export const loadBudget = async () => (await import('../../commands/budget.js')).registerBudgetCommand;
 export const loadAlias = async () => (await import('../../commands/alias.js')).registerAliasCommand;
@@ -133,6 +135,7 @@ export const COMMAND_LOADERS = {
     install: [loadPackages],
     routines: [loadRoutines],
     monitors: [loadMonitors],
+    projects: [loadProjects],
     run: [loadRun],
     fork: [loadFork],
     defaults: [loadDefaults],
@@ -162,6 +165,7 @@ export const COMMAND_LOADERS = {
     factory: [loadFactory],
     usage: [loadUsage],
     cost: [loadCost],
+    perf: [loadPerf],
     output: [loadOutput],
     budget: [loadBudget],
     alias: [loadAlias],

package/dist/lib/state.d.ts

@@ -109,6 +109,8 @@ export declare function getCacheDir(): string;
 export declare function getPackagesDir(): string;
 /** Path to routine YAML definitions (~/.agents/routines/). */
 export declare function getRoutinesDir(): string;
+/** Path to named project definitions (~/.agents/projects/). */
+export declare function getProjectsDir(): string;
 /**
  * Path to webhook handler YAML definitions (~/.agents/webhooks/). Handlers are
  * one-off triggers for agents/workflows/commands/routines, layered the same way
@@ -208,6 +210,15 @@ export declare function getCloudDir(): string;
 export declare function getTerminalsDir(): string;
 /** Path to runtime logs (~/.agents/.cache/logs/). */
 export declare function getLogsDir(): string;
+/**
+ * Path to disposable performance samples (~/.agents/.cache/perf/).
+ * Holds `perf.db` + a hook-shim spool. Loss is acceptable — wipe freely.
+ */
+export declare function getPerfDir(): string;
+/** Path to the perf SQLite warehouse (~/.agents/.cache/perf/perf.db). */
+export declare function getPerfDbPath(): string;
+/** Path to the hook-shim NDJSON spool drained into perf.db on open. */
+export declare function getPerfSpoolPath(): string;
 /** Path to per-process runtime state (~/.agents/.cache/state/). */
 export declare function getRuntimeStateDir(): string;
 /** Path to companion-extension scratch (~/.agents/.cache/companion/). */