@phnx-labs/agents-cli 1.21.2 → 1.21.3

package/dist/lib/session/db.js

@@ -12,14 +12,18 @@ import Database from '../sqlite.js';
 import { parseSession } from './parse.js';
 import { extractRecentDirectoriesTouched, extractTodoProgressFromEvents } from './state.js';
 import { getSessionsDir, getSessionsDbPath } from '../state.js';
+import { query as queryEvents } from '../events.js';
 import { machineForSessionFile } from './origin-machine.js';
 import { loadSessionActorIndex, readSessionActorRecord } from './actor-sidecar.js';
+import { extractSkills, extractSlashCommands } from './highlights.js';
+import { resolveResource } from '../resources.js';
+import { discoverPlugins } from '../plugins.js';
 const SESSIONS_DIR = getSessionsDir();
 const DB_PATH = getSessionsDbPath();
 /** Current schema version; bumped when migrations are added. Exported so tests
  * assert against the constant instead of hardcoding a number that every bump
  * then has to chase (docs/05-sessions.md calls the constant the source of truth). */
-export const SCHEMA_VERSION = 22;
+export const SCHEMA_VERSION = 24;
 /**
  * Canonicalize a file path for use as a scan_ledger key. The same physical
  * session file is reachable via multiple aliases — `~/.claude/projects/x.jsonl`
@@ -85,7 +89,9 @@ CREATE TABLE IF NOT EXISTS sessions (
   linear_project TEXT,
   linear_project_url TEXT,
   actor TEXT,
-  initiated_by TEXT
+  initiated_by TEXT,
+  used_browser INTEGER,
+  used_computer INTEGER
 );
 CREATE INDEX IF NOT EXISTS idx_sessions_timestamp ON sessions(timestamp DESC);
 CREATE INDEX IF NOT EXISTS idx_sessions_cwd ON sessions(cwd);
@@ -140,6 +146,29 @@ CREATE TABLE IF NOT EXISTS dir_ledger (
   entry_count INTEGER NOT NULL,
   scanned_at INTEGER NOT NULL
 );
+
+-- Skill/slash-command usage per session (#12), computed from a session's
+-- parsed transcript (extractSkills / extractSlashCommands, session/highlights.ts)
+-- and joined at write time against the currently-installed resource/plugin
+-- (resolveResource / discoverPlugins) for provenance — repo_root + snapshot_sha
+-- answer "which repo, which commit installed this skill/command", plugin/source
+-- answer "which plugin, which DotAgents layer". A resource renamed or uninstalled
+-- since the session ran leaves plugin/source/repo_root/snapshot_sha NULL rather
+-- than a stale guess. One row per (session, kind, name); count is how many
+-- times that skill/command fired in the session.
+CREATE TABLE IF NOT EXISTS session_resource_usage (
+  session_id TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  name TEXT NOT NULL,
+  plugin TEXT,
+  source TEXT,
+  repo_root TEXT,
+  snapshot_sha TEXT,
+  count INTEGER NOT NULL DEFAULT 1,
+  PRIMARY KEY (session_id, kind, name)
+);
+CREATE INDEX IF NOT EXISTS idx_session_resource_usage_kind_name ON session_resource_usage(kind, name);
+CREATE INDEX IF NOT EXISTS idx_session_resource_usage_plugin ON session_resource_usage(plugin);
 `;
 let dbInstance = null;
 /**
@@ -401,11 +430,56 @@ function migrateSchema(db, fromVersion) {
         db.exec(`DELETE FROM scan_ledger; DELETE FROM dir_ledger;`);
     }
     if (fromVersion < 22) {
+        // v21 → v22 (main): persist the transcript's tool-call count.
         const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
         if (!cols.some(c => c.name === 'tool_call_count'))
             db.exec(`ALTER TABLE sessions ADD COLUMN tool_call_count INTEGER`);
         db.exec(`DELETE FROM scan_ledger; DELETE FROM dir_ledger;`);
     }
+    if (fromVersion < 23) {
+        // v22 → v23: persist usedBrowser/usedComputer (#11) so the sessions picker
+        // preview can trust a positive detection instead of re-deriving it from a
+        // transcript regex on every render. Computed from a sessionId-scoped read
+        // of the events log (see detectToolUsage), not from the parsed transcript,
+        // so no ledger wipe is needed here — a rescan re-derives them regardless.
+        //
+        // Deliberately NO DEFAULT (NULL on ALTER, for every pre-existing row):
+        // NULL means "not yet computed by this scanner" (a legacy row), distinct
+        // from a real, computed 0/false. Collapsing that into a DEFAULT 0 would
+        // make every un-rescanned row look like a definite "never used
+        // browser/computer" and permanently blind the picker's fallback path for
+        // any row that isn't rescanned before it's next viewed.
+        const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
+        if (!cols.some(c => c.name === 'used_browser'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN used_browser INTEGER`);
+        if (!cols.some(c => c.name === 'used_computer'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN used_computer INTEGER`);
+    }
+    if (fromVersion < 24) {
+        // v23 → v24: session_resource_usage (#12) — skill/slash-command usage per
+        // session, joined against the currently-installed resource/plugin for
+        // provenance (repo_root/snapshot_sha/plugin/source). A brand-new table
+        // needs only CREATE TABLE IF NOT EXISTS, already present in SCHEMA for a
+        // fresh DB — this repeats it for an existing DB whose SCHEMA exec ran
+        // before the table definition was added. No ledger wipe: this table is
+        // populated by writeResourceUsage() at upsert time, independent of the
+        // scan ledgers.
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS session_resource_usage (
+        session_id TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        name TEXT NOT NULL,
+        plugin TEXT,
+        source TEXT,
+        repo_root TEXT,
+        snapshot_sha TEXT,
+        count INTEGER NOT NULL DEFAULT 1,
+        PRIMARY KEY (session_id, kind, name)
+      );
+      CREATE INDEX IF NOT EXISTS idx_session_resource_usage_kind_name ON session_resource_usage(kind, name);
+      CREATE INDEX IF NOT EXISTS idx_session_resource_usage_plugin ON session_resource_usage(plugin);
+    `);
+    }
 }
 /** Open (or return the cached) sessions database, applying migrations as needed. */
 export function getDB() {
@@ -769,7 +843,7 @@ const upsertSessionStmt = (db) => db.prepare(`
     file_path, file_mtime_ms, file_size, scanned_at, is_team_origin,
     pr_url, pr_number, worktree_slug, ticket_id, spawned_team, plan, todos,
     recent_directories_touched, linear_project, linear_project_url, machine,
-    actor, initiated_by
+    actor, initiated_by, used_browser, used_computer
   ) VALUES (
     @id, @short_id, @agent, @origin, @routine_name, @routine_run_id,
     @version, @account, @timestamp, @last_activity,
@@ -778,7 +852,7 @@ const upsertSessionStmt = (db) => db.prepare(`
     @file_path, @file_mtime_ms, @file_size, @scanned_at, @is_team_origin,
     @pr_url, @pr_number, @worktree_slug, @ticket_id, @spawned_team, @plan, @todos,
     @recent_directories_touched, @linear_project, @linear_project_url, @machine,
-    @actor, @initiated_by
+    @actor, @initiated_by, @used_browser, @used_computer
   )
   ON CONFLICT(id) DO UPDATE SET
     short_id = excluded.short_id,
@@ -823,6 +897,8 @@ const upsertSessionStmt = (db) => db.prepare(`
     plan = excluded.plan,
     todos = excluded.todos,
     recent_directories_touched = excluded.recent_directories_touched,
+    used_browser = excluded.used_browser,
+    used_computer = excluded.used_computer,
     linear_project = CASE
       WHEN excluded.ticket_id IS NOT sessions.ticket_id THEN excluded.linear_project
       ELSE COALESCE(excluded.linear_project, sessions.linear_project)
@@ -841,11 +917,124 @@ const upsertSessionStmt = (db) => db.prepare(`
     actor = COALESCE(sessions.actor, excluded.actor),
     initiated_by = COALESCE(sessions.initiated_by, excluded.initiated_by)
 `);
+/**
+ * Did this session emit at least one browser/computer-automation event?
+ * A scoped, sessionId-filtered read of the events log — NOT a re-scan of the
+ * (potentially huge) transcript — since browser.navigate / browser.screenshot
+ * / computer.action are recorded there via events.ts's emit(), keyed by the
+ * same session id that is this row's `meta.id` (the provenance floor stamps
+ * AGENT_SESSION_ID/AGENTS_SESSION_ID on every such event at emit time).
+ *
+ * Called independently of {@link enrichCachedSessionMeta} (which SKIPS
+ * claude/codex entries in the batch path because their caller already parsed
+ * the transcript for todos/recentDirectoriesTouched) — this never touches the
+ * transcript, so it must run for every agent, every time.
+ */
+function detectToolUsage(sessionId) {
+    const usedBrowser = queryEvents({ sessionId, eventTypes: ['browser.navigate', 'browser.screenshot'], limit: 1 }).length > 0;
+    const usedComputer = queryEvents({ sessionId, eventTypes: ['computer.action'], limit: 1 }).length > 0;
+    return { usedBrowser, usedComputer };
+}
+const deleteResourceUsageStmt = (db) => db.prepare(`DELETE FROM session_resource_usage WHERE session_id = ?`);
+const insertResourceUsageStmt = (db) => db.prepare(`
+  INSERT INTO session_resource_usage (session_id, kind, name, plugin, source, repo_root, snapshot_sha, count)
+  VALUES (@session_id, @kind, @name, @plugin, @source, @repo_root, @snapshot_sha, @count)
+`);
+/**
+ * Resolve a skill/slash-command's provenance for `session_resource_usage`
+ * (#12). A flat (non-namespaced) resource resolves via resolveResource()'s
+ * project/user/system/extra-repo scan. A namespaced one (`plugin:name`, e.g.
+ * `rush:design` — the shape both a plugin skill's `args.skill` and a plugin
+ * command's SessionEvent.slashCommand carry) is plugin-owned and lives under
+ * the plugin's own directory, invisible to resolveResource()'s flat scan —
+ * resolved instead against the already-discovered plugin list. Neither found
+ * (renamed or uninstalled since the session ran) returns all-undefined
+ * rather than a stale guess.
+ */
+function resolveResourceProvenance(kind, name, cwd, plugins) {
+    const listOf = (p) => (kind === 'skills' ? p.skills : p.commands);
+    const colonIdx = name.indexOf(':');
+    if (colonIdx > 0) {
+        const pluginName = name.slice(0, colonIdx);
+        const shortName = name.slice(colonIdx + 1);
+        const plugin = plugins.find((p) => p.name === pluginName && listOf(p).includes(shortName));
+        if (!plugin)
+            return {};
+        return { plugin: plugin.name, source: plugin.marketplace, repoRoot: plugin.repoRoot, snapshotSha: plugin.snapshotSha };
+    }
+    const resolved = resolveResource(kind, name, cwd);
+    if (resolved)
+        return { source: resolved.source, repoRoot: resolved.repoRoot, snapshotSha: resolved.snapshotSha };
+    const plugin = plugins.find((p) => listOf(p).includes(name));
+    if (!plugin)
+        return {};
+    return { plugin: plugin.name, source: plugin.marketplace, repoRoot: plugin.repoRoot, snapshotSha: plugin.snapshotSha };
+}
+/**
+ * Persist already-computed skill/slash-command tallies for a session (#12)
+ * into `session_resource_usage`, replacing any prior rows for it (a rescan's
+ * usage supersedes the old — same replace-on-upsert shape as the FTS text
+ * below). `discoverPlugins()` (real I/O: manifest + directory reads) only
+ * runs when there is actually a skill/command to resolve, so a session with
+ * neither pays nothing beyond the DELETE.
+ *
+ * Split from {@link writeResourceUsage} so a caller that already has the
+ * tallies (claude/codex's incremental accumulator — see
+ * ClaudeParseState.skillEvents/slashCommandEvents, threaded onto
+ * SessionMeta.skillsUsed/slashCommandsUsed) can write without re-parsing the
+ * transcript to re-derive them.
+ *
+ * Deliberately NOT wrapped in its own `db.transaction()`: better-sqlite3
+ * (this repo's wrapper included) does not support nested transactions, and
+ * `upsertSessionsBatch` calls this from INSIDE its own outer transaction. A
+ * standalone caller (enrichCachedSessionMeta, outside any transaction) still
+ * gets each statement committed individually — a crash between the DELETE
+ * and an INSERT self-heals on the next rescan, the same risk profile as any
+ * other un-batched write in this file.
+ */
+function writeResourceUsageFromTallies(sessionId, skills, commands, cwd) {
+    const db = getDB();
+    const del = deleteResourceUsageStmt(db);
+    const ins = insertResourceUsageStmt(db);
+    del.run(sessionId);
+    if (skills.length === 0 && commands.length === 0)
+        return;
+    const plugins = discoverPlugins({ cwd });
+    for (const { name, count } of skills) {
+        const prov = resolveResourceProvenance('skills', name, cwd, plugins);
+        ins.run({
+            session_id: sessionId, kind: 'skill', name, count,
+            plugin: prov.plugin ?? null, source: prov.source ?? null,
+            repo_root: prov.repoRoot ?? null, snapshot_sha: prov.snapshotSha ?? null,
+        });
+    }
+    for (const { name, count } of commands) {
+        const bare = name.replace(/^\//, '');
+        const prov = resolveResourceProvenance('commands', bare, cwd, plugins);
+        ins.run({
+            session_id: sessionId, kind: 'command', name: bare, count,
+            plugin: prov.plugin ?? null, source: prov.source ?? null,
+            repo_root: prov.repoRoot ?? null, snapshot_sha: prov.snapshotSha ?? null,
+        });
+    }
+}
+/**
+ * Persist skill/slash-command usage for a session (#12) by deriving the
+ * tallies from a full parsed transcript. Used by {@link enrichCachedSessionMeta}
+ * (every `upsertSession()` call, and `upsertSessionsBatch` for every harness
+ * EXCEPT claude/codex, which pre-compute skillsUsed/slashCommandsUsed via
+ * their incremental accumulator instead — see writeResourceUsageFromTallies
+ * and the call site in upsertSessionsBatch).
+ */
+function writeResourceUsage(sessionId, events, cwd) {
+    writeResourceUsageFromTallies(sessionId, extractSkills(events), extractSlashCommands(events), cwd);
+}
 function enrichCachedSessionMeta(meta) {
     if (!meta.filePath)
         return meta;
     try {
         const events = parseSession(meta.filePath, meta.agent);
+        writeResourceUsage(meta.id, events, meta.cwd);
         return {
             ...meta,
             todos: extractTodoProgressFromEvents(events),
@@ -903,6 +1092,7 @@ export function upsertSession(meta, content, scan) {
     // row AND backfills one indexed null-first (before its sidecar existed), while a
     // rescan carrying no actor still keeps the stored owner.
     const actorRec = meta.actor ? undefined : readSessionActorRecord(meta.id);
+    const toolUsage = detectToolUsage(meta.id);
     const db = getDB();
     const { upsert, delText, insText, readLabel } = stmts(db);
     const row = {
@@ -946,6 +1136,8 @@ export function upsertSession(meta, content, scan) {
         machine: resolveMachine(meta),
         actor: meta.actor ?? actorRec?.actor ?? null,
         initiated_by: meta.initiatedBy ?? actorRec?.initiatedBy ?? null,
+        used_browser: toolUsage.usedBrowser ? 1 : 0,
+        used_computer: toolUsage.usedComputer ? 1 : 0,
     };
     const txn = db.transaction(() => {
         upsert.run(row);
@@ -1026,6 +1218,15 @@ export function upsertSessionsBatch(entries) {
             // back when the error escapes `fn`, so catching + skipping here leaves the txn valid
             // and committable. We deliberately do NOT stamp the ledger for a skipped row, so the
             // next scan re-tries it (self-healing once the underlying parser is fixed).
+            const toolUsage = detectToolUsage(meta.id);
+            // claude/codex skip enrichCachedSessionMeta above (preserving their
+            // resumable-parse optimization) — write their pre-computed
+            // skillsUsed/slashCommandsUsed (folded incrementally by discover.ts's
+            // accumulator) here instead. Every other harness already got this
+            // write from enrichCachedSessionMeta() in the .map() above.
+            if (meta.agent === 'claude' || meta.agent === 'codex') {
+                writeResourceUsageFromTallies(meta.id, meta.skillsUsed ?? [], meta.slashCommandsUsed ?? [], meta.cwd);
+            }
             try {
                 upsert.run({
                     id: meta.id,
@@ -1068,6 +1269,8 @@ export function upsertSessionsBatch(entries) {
                     machine: resolveMachine(meta),
                     actor: meta.actor ?? actorIndex.get(meta.id)?.actor ?? null,
                     initiated_by: meta.initiatedBy ?? actorIndex.get(meta.id)?.initiatedBy ?? null,
+                    used_browser: toolUsage.usedBrowser ? 1 : 0,
+                    used_computer: toolUsage.usedComputer ? 1 : 0,
                 });
                 delText.run(meta.id);
                 insText.run(meta.id, 
@@ -1260,6 +1463,11 @@ function rowToMeta(row) {
         // Narrow the free-text column to the known kinds; an unexpected value maps
         // to undefined rather than being asserted as a valid kind.
         initiatedBy: row.initiated_by === 'human' || row.initiated_by === 'agent' ? row.initiated_by : undefined,
+        // NULL = never computed by this scanner (legacy row) — leave undefined so
+        // the sessions picker knows to fall back to the transcript-regex detection
+        // instead of trusting a false "never used browser/computer".
+        usedBrowser: row.used_browser === null ? undefined : row.used_browser === 1,
+        usedComputer: row.used_computer === null ? undefined : row.used_computer === 1,
     };
 }
 function parseJsonColumn(value) {
@@ -1392,6 +1600,21 @@ function buildSessionWhere(options) {
     if (options.onlyTeamOrigin) {
         where.push('IFNULL(is_team_origin, 0) = 1');
     }
+    // #12: join against session_resource_usage. A subquery IN, not a real JOIN
+    // on the base SELECT, keeps `SELECT * FROM sessions` untouched for every
+    // other caller of buildSessionWhere() (countSessions, the usage rollup, …)
+    // that never wants a skill/plugin filter.
+    if (options.skill) {
+        where.push(`id IN (
+      SELECT session_id FROM session_resource_usage
+      WHERE kind = 'skill' AND (name = ? COLLATE NOCASE OR name LIKE ? COLLATE NOCASE)
+    )`);
+        params.push(options.skill, `%:${options.skill}`);
+    }
+    if (options.plugin) {
+        where.push(`id IN (SELECT session_id FROM session_resource_usage WHERE plugin = ? COLLATE NOCASE)`);
+        params.push(options.plugin);
+    }
     const clause = where.length > 0 ? `WHERE ${where.join(' AND ')}` : '';
     return { clause, params };
 }

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

@@ -41,6 +41,10 @@ export interface DiscoverOptions {
     sortBy?: 'timestamp' | 'cost' | 'duration';
     /** Called as each agent makes parsing progress. Totals count only files that need re-parsing (cache misses). */
     onProgress?: (progress: ScanProgress) => void;
+    /** Only sessions that invoked this skill (#12) — see QueryOptions.skill in session/db.ts. */
+    skill?: string;
+    /** Only sessions that used a skill/command owned by this plugin (#12) — see QueryOptions.plugin. */
+    plugin?: string;
 }
 /** Progress report emitted during incremental scanning. */
 export interface ScanProgress {
@@ -87,6 +91,16 @@ interface ClaudeSessionScan {
     plan?: string;
     todos?: TodoProgress;
     recentDirectoriesTouched?: string[];
+    /** Skills invoked (#12) — see SessionMeta.skillsUsed. */
+    skillsUsed?: Array<{
+        name: string;
+        count: number;
+    }>;
+    /** Slash commands invoked (#12) — see SessionMeta.slashCommandsUsed. */
+    slashCommandsUsed?: Array<{
+        name: string;
+        count: number;
+    }>;
 }
 /** Lightweight metadata extracted from a Codex JSONL file during incremental scan. */
 interface CodexSessionScan {
@@ -394,6 +408,11 @@ export interface ClaudeParseState {
     plan?: string;
     checklistEvents: SessionEvent[];
     recentDirectoriesTouched: string[];
+    /** Skill-invocation tool_use events, held for extractSkills() at finalize (#12). */
+    skillEvents: SessionEvent[];
+    /** Slash-command events (user-typed <command-name> wrapper OR a SlashCommand
+     *  tool_use), held for extractSlashCommands() at finalize (#12). */
+    slashCommandEvents: SessionEvent[];
 }
 /** Zero-value accumulator for a fresh (from-byte-0) Claude parse. */
 export declare function initClaudeParseState(): ClaudeParseState;
@@ -456,6 +475,9 @@ export interface ClaudeParserState {
     contentText?: string;
     checklistEvents: SessionEvent[];
     recentDirectoriesTouched: string[];
+    /** #12: see ClaudeParseState.skillEvents/slashCommandEvents. */
+    skillEvents: SessionEvent[];
+    slashCommandEvents: SessionEvent[];
 }
 /**
  * Snapshot a live {@link ClaudeParseState} into its serializable form at
@@ -531,6 +553,12 @@ export interface CodexParseState {
     spawnedTeam?: string;
     checklistEvents: SessionEvent[];
     recentDirectoriesTouched: string[];
+    /** #12: see ClaudeParseState.skillEvents. Empty in practice today — no
+     *  verified Codex skill-invocation tool name — but wired for parity so a
+     *  future confirmed tool name (or a literal 'SlashCommand' function_call)
+     *  is picked up with no further plumbing. */
+    skillEvents: SessionEvent[];
+    slashCommandEvents: SessionEvent[];
 }
 /** Zero-value accumulator for a fresh (from-byte-0) Codex parse. */
 export declare function initCodexParseState(): CodexParseState;

package/dist/lib/session/discover.js

@@ -23,7 +23,8 @@ import { walkForFilesWithStat } from '../fs-walk.js';
 import { getConfigSymlinkVersion } from '../shims.js';
 import { SESSION_AGENTS } from './types.js';
 import { deriveShortId } from './short-id.js';
-import { extractSessionTopic } from './prompt.js';
+import { extractSessionTopic, extractSlashCommandName, extractSlashCommandFromToolInput } from './prompt.js';
+import { isSkillInvocation, extractSkills, extractSlashCommands } from './highlights.js';
 import { parseAntigravity, parseCursor } from './parse.js';
 import { extractPrUrl, detectWorktree, detectTicket, isPrCreateCommand, detectSpawnedTeam, isTicketCreateTool, extractCreatedTicket, extractRecentDirectoriesTouched, extractTodoProgressFromEvents } from './state.js';
 import { costOfUsage } from '../pricing/index.js';
@@ -310,6 +311,8 @@ function buildQueryOptions(options, agents, opts) {
         onlyTeamOrigin: options?.onlyTeamOrigin,
         origin: options?.origin,
         sortBy: options?.sortBy,
+        skill: options?.skill,
+        plugin: options?.plugin,
     };
 }
 /**
@@ -1030,6 +1033,8 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, account,
             plan: scan.plan,
             todos: scan.todos,
             recentDirectoriesTouched: scan.recentDirectoriesTouched,
+            skillsUsed: scan.skillsUsed,
+            slashCommandsUsed: scan.slashCommandsUsed,
         };
     }
     else {
@@ -1061,6 +1066,8 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, account,
             plan: scan.plan,
             todos: scan.todos,
             recentDirectoriesTouched: scan.recentDirectoriesTouched,
+            skillsUsed: scan.skillsUsed,
+            slashCommandsUsed: scan.slashCommandsUsed,
         };
     }
     return {
@@ -2446,6 +2453,8 @@ export function initClaudeParseState() {
         plan: undefined,
         checklistEvents: [],
         recentDirectoriesTouched: [],
+        skillEvents: [],
+        slashCommandEvents: [],
     };
 }
 const CHECKLIST_TOOLS = new Set(['TodoWrite', 'todo_write', 'update_plan', 'TaskCreate', 'TaskUpdate']);
@@ -2453,6 +2462,16 @@ const DIRECTORY_TOOLS = new Set(['Edit', 'Write', 'edit_file', 'write_file', 'cr
 function foldDerivedToolState(state, event) {
     if (CHECKLIST_TOOLS.has(event.tool ?? ''))
         state.checklistEvents.push(event);
+    // #12: skill/slash-command usage, held here instead of re-parsed later — the
+    // same reason checklistEvents is folded incrementally rather than recomputed
+    // from a full re-parse (see session/db.ts's writeResourceUsage doc comment).
+    if (isSkillInvocation(event))
+        state.skillEvents.push(event);
+    if (event.tool === 'SlashCommand') {
+        const slashCommand = extractSlashCommandFromToolInput(event.args);
+        if (slashCommand)
+            state.slashCommandEvents.push({ ...event, slashCommand });
+    }
     if (!DIRECTORY_TOOLS.has(event.tool ?? ''))
         return;
     const next = extractRecentDirectoriesTouched([event], state.cwd);
@@ -2582,6 +2601,15 @@ export function applyClaudeLine(state, parsed) {
             state.userTexts.push(text);
             if (!state.topic)
                 state.topic = extractSessionTopic(text);
+            // #12: the USER typing a slash command — Claude injects a <command-name>
+            // wrapper as the message content (extractClaudeUserText returns it
+            // un-stripped; isLocalCommandMessage only filters bash-echo wrappers).
+            const slashCommand = extractSlashCommandName(text);
+            if (slashCommand) {
+                state.slashCommandEvents.push({
+                    type: 'message', agent: 'claude', timestamp: parsed.timestamp || '', role: 'user', content: text, slashCommand,
+                });
+            }
         }
         return;
     }
@@ -2662,6 +2690,8 @@ export function finalizeClaudeScan(state) {
         plan: state.plan,
         todos: extractTodoProgressFromEvents(state.checklistEvents),
         recentDirectoriesTouched: state.recentDirectoriesTouched.length ? state.recentDirectoriesTouched : undefined,
+        skillsUsed: state.skillEvents.length ? extractSkills(state.skillEvents) : undefined,
+        slashCommandsUsed: state.slashCommandEvents.length ? extractSlashCommands(state.slashCommandEvents) : undefined,
     };
 }
 /** Stream a Claude JSONL file and extract scan-level metadata (timestamp, cwd, topic, tokens). */
@@ -2740,6 +2770,8 @@ export function serializeClaudeParserState(state, offset) {
         contentText: state.userTexts.length > 0 ? state.userTexts.join('\n') : undefined,
         checklistEvents: state.checklistEvents,
         recentDirectoriesTouched: state.recentDirectoriesTouched,
+        skillEvents: state.skillEvents,
+        slashCommandEvents: state.slashCommandEvents,
     };
 }
 /**
@@ -2796,6 +2828,8 @@ export function hydrateClaudeParseState(prior) {
         plan: prior.plan,
         checklistEvents: prior.checklistEvents ?? [],
         recentDirectoriesTouched: prior.recentDirectoriesTouched ?? [],
+        skillEvents: prior.skillEvents ?? [],
+        slashCommandEvents: prior.slashCommandEvents ?? [],
     };
 }
 /**
@@ -2997,6 +3031,8 @@ export function initCodexParseState() {
         spawnedTeam: undefined,
         checklistEvents: [],
         recentDirectoriesTouched: [],
+        skillEvents: [],
+        slashCommandEvents: [],
     };
 }
 /**
@@ -3244,6 +3280,11 @@ export function hydrateCodexParseState(prior) {
         spawnedTeam: prior.spawnedTeam,
         checklistEvents: prior.checklistEvents ?? [],
         recentDirectoriesTouched: prior.recentDirectoriesTouched ?? [],
+        // Not persisted in CodexParserState (always empty for Codex today — see
+        // CodexParseState.skillEvents) — a resume starts fresh rather than
+        // round-tripping an always-empty array through the continuation blob.
+        skillEvents: [],
+        slashCommandEvents: [],
     };
 }
 /**

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

@@ -17,12 +17,32 @@ export interface SkillUse {
     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.
+ * True for a tool_use event that is that harness's skill-invocation call (see
+ * {@link SKILL_TOOL_NAME_BY_AGENT}). Exported so an INCREMENTAL parser
+ * (discover.ts's ClaudeParseState/foldDerivedToolState) can select matching
+ * events into a small held array as it streams, then run {@link extractSkills}
+ * over just that subset at finalize — without re-parsing the whole transcript.
+ */
+export declare function isSkillInvocation(e: SessionEvent): boolean;
+/**
+ * Skills invoked during the session, from that harness's skill-invocation
+ * tool calls (see {@link SKILL_TOOL_NAME_BY_AGENT}). Carries the skill id in
+ * `args.skill` (or `args.name`). Sorted by count desc, then name.
  */
 export declare function extractSkills(events: SessionEvent[]): SkillUse[];
+export interface SlashCommandUse {
+    /** WITH the leading slash, e.g. `/recap`, `/code:commit` — matches SessionEvent.slashCommand's shape. */
+    name: string;
+    count: number;
+}
+/**
+ * Slash commands invoked during the session — either the user typing one
+ * (Claude's `<command-name>` wrapper) or the model invoking one via the
+ * `SlashCommand` tool (`SessionEvent.slashCommand`, populated by
+ * `parseClaudeContent` for both sources — see session/prompt.ts). Sorted by
+ * count desc, then name.
+ */
+export declare function extractSlashCommands(events: SessionEvent[]): SlashCommandUse[];
 export interface HookUse {
     /** Hook name as configured, e.g. `SessionStart:startup`. */
     name: string;

package/dist/lib/session/highlights.js

@@ -15,17 +15,44 @@ 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.
+ * The tool name a harness uses to invoke a skill, keyed by `SessionAgentId` —
+ * a registry, not a single hardcoded string, so a harness whose transcript
+ * names the tool differently is one table row away from support instead of a
+ * near-identical `if` arm (see CLAUDE.md's registry-over-if-chain convention).
+ *
+ * Verified entries only: Claude and Kimi both empirically name the tool
+ * `Skill` (a plugin-provided skill rides the same tool). No other harness has
+ * a confirmed skill-invocation tool name in this codebase's fixtures — an
+ * absent entry means "we don't know yet", not "this harness has no skills";
+ * extractSkills yields `[]` for it rather than guessing a name and silently
+ * mismatching (or worse, matching a coincidental tool with the same name).
+ */
+const SKILL_TOOL_NAME_BY_AGENT = {
+    claude: 'Skill',
+    kimi: 'Skill',
+};
+/**
+ * True for a tool_use event that is that harness's skill-invocation call (see
+ * {@link SKILL_TOOL_NAME_BY_AGENT}). Exported so an INCREMENTAL parser
+ * (discover.ts's ClaudeParseState/foldDerivedToolState) can select matching
+ * events into a small held array as it streams, then run {@link extractSkills}
+ * over just that subset at finalize — without re-parsing the whole transcript.
+ */
+export function isSkillInvocation(e) {
+    if (e.type !== 'tool_use' || e._local)
+        return false;
+    const skillTool = SKILL_TOOL_NAME_BY_AGENT[e.agent];
+    return !!skillTool && e.tool === skillTool;
+}
+/**
+ * Skills invoked during the session, from that harness's skill-invocation
+ * tool calls (see {@link SKILL_TOOL_NAME_BY_AGENT}). Carries the skill id in
+ * `args.skill` (or `args.name`). 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')
+        if (!isSkillInvocation(e))
             continue;
         const name = e.args?.skill ?? e.args?.name;
         if (typeof name !== 'string' || !name.trim())
@@ -37,6 +64,24 @@ export function extractSkills(events) {
         .map(([name, count]) => ({ name, count }))
         .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
 }
+/**
+ * Slash commands invoked during the session — either the user typing one
+ * (Claude's `<command-name>` wrapper) or the model invoking one via the
+ * `SlashCommand` tool (`SessionEvent.slashCommand`, populated by
+ * `parseClaudeContent` for both sources — see session/prompt.ts). Sorted by
+ * count desc, then name.
+ */
+export function extractSlashCommands(events) {
+    const counts = new Map();
+    for (const e of events) {
+        if (!e.slashCommand)
+            continue;
+        counts.set(e.slashCommand, (counts.get(e.slashCommand) ?? 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