@phnx-labs/agents-cli 1.20.90 → 1.20.91

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

@@ -0,0 +1,82 @@
+/**
+ * Session highlight extractors.
+ *
+ * Pure derivations over a session's `SessionEvent[]` that power the "what did
+ * this session use and produce" sections of both renders of a session — the
+ * picker quick preview (`sessions-picker.ts`) and the full summary
+ * (`render.ts`). One module, two consumers, so the panes never drift.
+ *
+ * Skills/hooks/links are no-I/O. `extractRepos` touches the filesystem (a
+ * bounded `.git` walk over a handful of candidate dirs) and is the only
+ * non-pure function here.
+ */
+import type { SessionEvent } from './types.js';
+import { type FileChange } from './digest.js';
+export interface SkillUse {
+    name: string;
+    count: number;
+}
+/**
+ * Skills invoked during the session, from `Skill` tool calls. Claude and Kimi
+ * both name the tool `Skill` and carry the skill id in `args.skill` (plugin
+ * skills surface here too — a plugin-provided skill is invoked through the
+ * same tool). Sorted by count desc, then name.
+ */
+export declare function extractSkills(events: SessionEvent[]): SkillUse[];
+export interface HookUse {
+    /** Hook name as configured, e.g. `SessionStart:startup`. */
+    name: string;
+    /** Lifecycle event, e.g. `SessionStart`. */
+    event?: string;
+    /** How many times it fired. */
+    count: number;
+    /** How many firings failed (non-`hook_success` records). */
+    failed: number;
+}
+/**
+ * Hooks that fired during the session, folded from `hook` events (parsed from
+ * Claude's `hook_success`/`hook_error`/… attachment records; other harnesses
+ * don't record firings in their transcripts, so they yield an empty list).
+ * Sorted by count desc, then name.
+ */
+export declare function extractHooks(events: SessionEvent[]): HookUse[];
+export type LinkKind = 'linear' | 'jira' | 'github' | 'gitlab' | 'other';
+export interface SessionLink {
+    kind: LinkKind;
+    url: string;
+    /** Short display label: `RUSH-2076`, `PR#1755`, `owner/repo#123`, host. */
+    label: string;
+}
+/**
+ * Links mentioned in user/assistant messages, classified (Linear/Jira/GitHub/
+ * GitLab), deduped by URL AND by label (a session that quotes the same PR in
+ * five messages shows it once), first-seen order. Capped so a link-heavy
+ * session can't flood the pane.
+ */
+export declare function extractLinks(events: SessionEvent[]): SessionLink[];
+export type ArtifactBucket = 'artifacts' | 'plans' | 'reports' | 'docs';
+export interface ProducedArtifact {
+    /** Absolute (or session-relative) path of the created file. */
+    path: string;
+    basename: string;
+    bucket: ArtifactBucket;
+}
+/**
+ * Documents/files the session CREATED, from the already-classified changes
+ * (callers classify once — this never re-derives). Keeps the ones a human
+ * browses later: anything under `.agents/artifacts|plans|reports/`, plus other
+ * `*.md`/`*.html` creations. Source/config churn (the bulk of `+N`) stays in
+ * the Changes line.
+ */
+export declare function extractArtifacts(changes: FileChange[]): ProducedArtifact[];
+/**
+ * Repos the session worked in, from the directories its file paths live under
+ * (a bounded `.git` walk-up; a `.git` FILE counts too — that's the worktree
+ * layout). Names are repo dir basenames, first-seen order, capped.
+ *
+ * Relative paths resolve against the SESSION's cwd only — when it is unknown
+ * (e.g. kimi rows carry no cwd today) they are skipped: resolving them against
+ * the viewer's process cwd attributes the session to whatever repo the CLI
+ * happens to run in, which is a wrong answer, not a degraded one.
+ */
+export declare function extractRepos(events: SessionEvent[], cwd?: string): string[];

package/dist/lib/session/highlights.js

@@ -0,0 +1,251 @@
+/**
+ * Session highlight extractors.
+ *
+ * Pure derivations over a session's `SessionEvent[]` that power the "what did
+ * this session use and produce" sections of both renders of a session — the
+ * picker quick preview (`sessions-picker.ts`) and the full summary
+ * (`render.ts`). One module, two consumers, so the panes never drift.
+ *
+ * Skills/hooks/links are no-I/O. `extractRepos` touches the filesystem (a
+ * bounded `.git` walk over a handful of candidate dirs) and is the only
+ * non-pure function here.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { isNoisePath } from './digest.js';
+/**
+ * Skills invoked during the session, from `Skill` tool calls. Claude and Kimi
+ * both name the tool `Skill` and carry the skill id in `args.skill` (plugin
+ * skills surface here too — a plugin-provided skill is invoked through the
+ * same tool). Sorted by count desc, then name.
+ */
+export function extractSkills(events) {
+    const counts = new Map();
+    for (const e of events) {
+        if (e.type !== 'tool_use' || e._local)
+            continue;
+        if (e.tool !== 'Skill')
+            continue;
+        const name = e.args?.skill ?? e.args?.name;
+        if (typeof name !== 'string' || !name.trim())
+            continue;
+        const key = name.trim();
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .map(([name, count]) => ({ name, count }))
+        .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+}
+/**
+ * Hooks that fired during the session, folded from `hook` events (parsed from
+ * Claude's `hook_success`/`hook_error`/… attachment records; other harnesses
+ * don't record firings in their transcripts, so they yield an empty list).
+ * Sorted by count desc, then name.
+ */
+export function extractHooks(events) {
+    const byName = new Map();
+    for (const e of events) {
+        if (e.type !== 'hook')
+            continue;
+        const name = e.hookName?.trim() || e.hookEvent?.trim() || 'hook';
+        const existing = byName.get(name);
+        if (existing) {
+            existing.count++;
+            if (e.success === false)
+                existing.failed++;
+        }
+        else {
+            byName.set(name, {
+                name,
+                event: e.hookEvent,
+                count: 1,
+                failed: e.success === false ? 1 : 0,
+            });
+        }
+    }
+    return [...byName.values()].sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+}
+/** Bare URL scan over message text; trailing punctuation stripped. Backticks
+ * and ellipses excluded so markdown-wrapped or truncated URLs don't leak in. */
+const URL_RE = /https?:\/\/[^\s"'`()<>\]\\…]+/g;
+/** A routable host: dotted domain (optionally :port). localhost/IPs-of-one-segment
+ * and markdown garbage (`…`) are not Links-section material. */
+const HOST_RE = /^[a-z0-9][a-z0-9.-]*\.[a-z]{2,}(:\d+)?$/i;
+function classifyLink(url) {
+    let m;
+    // Linear: https://linear.app/<workspace>/issue/RUSH-2076/slug
+    if ((m = url.match(/https?:\/\/linear\.app\/[\w-]+\/issue\/([A-Z]{2,6}-\d+)/))) {
+        return { kind: 'linear', url, label: m[1] };
+    }
+    // Jira: https://<host>.atlassian.net/browse/PROJ-123 (or /jira/browse/)
+    if ((m = url.match(/https?:\/\/[\w.-]*(?:atlassian\.net|jira[\w.-]*)\/browse\/([A-Z]{2,10}-\d+)/))) {
+        return { kind: 'jira', url, label: m[1] };
+    }
+    // GitHub: PR / issue / repo
+    if ((m = url.match(/https?:\/\/github\.com\/([\w.-]+\/[\w.-]+)\/pull\/(\d+)/))) {
+        return { kind: 'github', url, label: `PR#${m[2]}` };
+    }
+    if ((m = url.match(/https?:\/\/github\.com\/([\w.-]+\/[\w.-]+)\/issues\/(\d+)/))) {
+        return { kind: 'github', url, label: `${m[1]}#${m[2]}` };
+    }
+    if ((m = url.match(/https?:\/\/github\.com\/([\w.-]+\/[\w.-]+?)(?:\.git)?\/?$/))) {
+        return { kind: 'github', url, label: m[1] };
+    }
+    // GitLab: MR / issue
+    if ((m = url.match(/https?:\/\/(gitlab\.com|[\w.-]*gitlab[\w.-]*)\/(.+?)\/-\/merge_requests\/(\d+)/))) {
+        return { kind: 'gitlab', url, label: `${m[2]}!${m[3]}` };
+    }
+    if ((m = url.match(/https?:\/\/(gitlab\.com|[\w.-]*gitlab[\w.-]*)\/(.+?)\/-\/issues\/(\d+)/))) {
+        return { kind: 'gitlab', url, label: `${m[2]}#${m[3]}` };
+    }
+    const host = url.match(/^https?:\/\/([^/?]+)/)?.[1];
+    if (!host || !HOST_RE.test(host))
+        return undefined;
+    return { kind: 'other', url, label: host };
+}
+const MAX_LINKS = 12;
+/**
+ * Links mentioned in user/assistant messages, classified (Linear/Jira/GitHub/
+ * GitLab), deduped by URL AND by label (a session that quotes the same PR in
+ * five messages shows it once), first-seen order. Capped so a link-heavy
+ * session can't flood the pane.
+ */
+export function extractLinks(events) {
+    const seenUrl = new Set();
+    const seenLabel = new Set();
+    const out = [];
+    for (const e of events) {
+        if (e.type !== 'message' || !e.content)
+            continue;
+        // Harness-injected scaffolding (bash wrappers, system reminders) carries
+        // URLs that aren't conversation references — same exclusion the rest of
+        // the pipeline applies.
+        if (e._synthetic)
+            continue;
+        for (const raw of e.content.match(URL_RE) ?? []) {
+            const url = raw.replace(/[.,;:)\]`]+$/, '');
+            if (seenUrl.has(url))
+                continue;
+            seenUrl.add(url);
+            const link = classifyLink(url);
+            if (!link || seenLabel.has(link.label))
+                continue;
+            seenLabel.add(link.label);
+            out.push(link);
+            if (out.length >= MAX_LINKS)
+                return out;
+        }
+    }
+    return out;
+}
+const ARTIFACT_EXT_RE = /\.(md|markdown|html?)$/i;
+const MAX_ARTIFACTS = 12;
+/**
+ * Documents/files the session CREATED, from the already-classified changes
+ * (callers classify once — this never re-derives). Keeps the ones a human
+ * browses later: anything under `.agents/artifacts|plans|reports/`, plus other
+ * `*.md`/`*.html` creations. Source/config churn (the bulk of `+N`) stays in
+ * the Changes line.
+ */
+export function extractArtifacts(changes) {
+    const out = [];
+    for (const ch of changes) {
+        if (ch.op !== 'created')
+            continue;
+        const p = ch.path;
+        if (isNoisePath(p))
+            continue;
+        const norm = p.replace(/\\/g, '/');
+        let bucket;
+        if (/\/\.agents\/artifacts\//.test(norm))
+            bucket = 'artifacts';
+        else if (/\/\.agents\/plans\//.test(norm) || /\/plans\/[^/]+\.md$/i.test(norm))
+            bucket = 'plans';
+        else if (/\/\.agents\/reports\//.test(norm))
+            bucket = 'reports';
+        else if (ARTIFACT_EXT_RE.test(norm))
+            bucket = 'docs';
+        if (!bucket)
+            continue;
+        out.push({ path: p, basename: path.posix.basename(norm), bucket });
+        if (out.length >= MAX_ARTIFACTS)
+            break;
+    }
+    return out;
+}
+// ── Repos ─────────────────────────────────────────────────────────────────────
+/** Candidate dirs to probe for a `.git` root, and the walk depth per dir. */
+const MAX_REPO_PROBES = 12;
+const REPO_WALK_DEPTH = 6;
+/** A walk-up that lands here overshot the workspace — never a "repo worked in". */
+function isOvershotRoot(dir) {
+    return dir === '/' || dir === os.tmpdir() || dir === os.homedir();
+}
+function repoRootFrom(dir) {
+    let cur = dir;
+    for (let i = 0; i < REPO_WALK_DEPTH; i++) {
+        try {
+            if (fs.existsSync(path.join(cur, '.git'))) {
+                return isOvershotRoot(cur) ? undefined : cur;
+            }
+        }
+        catch {
+            return undefined;
+        }
+        const parent = path.dirname(cur);
+        if (parent === cur)
+            return undefined;
+        cur = parent;
+    }
+    return undefined;
+}
+/**
+ * Repos the session worked in, from the directories its file paths live under
+ * (a bounded `.git` walk-up; a `.git` FILE counts too — that's the worktree
+ * layout). Names are repo dir basenames, first-seen order, capped.
+ *
+ * Relative paths resolve against the SESSION's cwd only — when it is unknown
+ * (e.g. kimi rows carry no cwd today) they are skipped: resolving them against
+ * the viewer's process cwd attributes the session to whatever repo the CLI
+ * happens to run in, which is a wrong answer, not a degraded one.
+ */
+export function extractRepos(events, cwd) {
+    const candidates = [];
+    const seenCand = new Set();
+    const addCandidate = (p) => {
+        if (!p || isNoisePath(p))
+            return;
+        // DotAgents internals (the `.system` registry repo, run archives) are
+        // infrastructure, not "repos the user works in".
+        if (p.includes('/.agents/.system/') || p.includes('/.agents/.history/'))
+            return;
+        if (!path.isAbsolute(p) && !cwd)
+            return;
+        const abs = path.isAbsolute(p) ? p : path.resolve(cwd, p);
+        const dir = path.dirname(abs);
+        if (seenCand.has(dir))
+            return;
+        seenCand.add(dir);
+        candidates.push(dir);
+    };
+    for (const e of events) {
+        if (e.type !== 'tool_use' || e._local)
+            continue;
+        const p = e.path || e.args?.file_path || e.args?.path || '';
+        if (typeof p === 'string' && p)
+            addCandidate(p);
+        if (candidates.length >= MAX_REPO_PROBES)
+            break;
+    }
+    const repos = [];
+    const seenRoot = new Set();
+    for (const dir of candidates) {
+        const root = repoRootFrom(dir);
+        if (!root || seenRoot.has(root))
+            continue;
+        seenRoot.add(root);
+        repos.push(path.basename(root));
+    }
+    return repos;
+}

package/dist/lib/session/parse.js

@@ -66,6 +66,10 @@ function sanitizeEvent(e) {
         e.model = sanitizeForTerminal(e.model);
     if (e.mediaType)
         e.mediaType = sanitizeForTerminal(e.mediaType);
+    if (e.hookName)
+        e.hookName = sanitizeForTerminal(e.hookName);
+    if (e.hookEvent)
+        e.hookEvent = sanitizeForTerminal(e.hookEvent);
     if (e.args)
         e.args = sanitizeArgsDeep(e.args);
 }
@@ -484,7 +488,25 @@ export function parseClaudeContent(content) {
                 content: raw.subtype || 'success',
             });
         }
-        // Skip: permission-mode, attachment, and other line types
+        else if (type === 'attachment') {
+            // Hook firings are recorded as attachments: `hook_success` / `hook_error` /
+            // `hook_blocked` per firing, plus a derivative `hook_additional_context`
+            // record for the SAME firing (shared toolUseID) — skip the derivative or
+            // every firing counts twice.
+            const att = raw.attachment;
+            const attType = att?.type;
+            if (typeof attType === 'string' && attType.startsWith('hook_') && attType !== 'hook_additional_context') {
+                events.push({
+                    type: 'hook',
+                    agent: 'claude',
+                    timestamp,
+                    hookName: typeof att.hookName === 'string' ? att.hookName : undefined,
+                    hookEvent: typeof att.hookEvent === 'string' ? att.hookEvent : undefined,
+                    success: attType === 'hook_success',
+                });
+            }
+        }
+        // Skip: permission-mode, non-hook attachments, and other line types
     }
     return events;
 }

package/dist/lib/session/relative-time.d.ts

@@ -5,3 +5,17 @@
  * `remote.ts`, so a back-import would cycle.
  */
 export declare function formatRelativeTime(isoTimestamp: string): string;
+/**
+ * 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 declare function parseTimeFilter(input: string): number;

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

@@ -30,3 +30,39 @@ export function formatRelativeTime(isoTimestamp) {
         ? label
         : `${label} '${String(d.getFullYear()).slice(-2)}`;
 }
+/**
+ * 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/render.d.ts

@@ -11,6 +11,13 @@ import type { SessionEvent, SessionMeta } from './types.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.

package/dist/lib/session/render.js

@@ -13,6 +13,7 @@ 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 { extractArtifacts, extractHooks, extractLinks, extractSkills } from './highlights.js';
 import { extractTodoProgressFromEvents } from './state.js';
 // ── Path helpers ──────────────────────────────────────────────────────────────
 /**
@@ -29,6 +30,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 &&
@@ -387,11 +413,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 +481,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 +555,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 +586,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 +651,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 +695,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 +730,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 +769,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/startup/command-registry.d.ts

@@ -70,6 +70,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;