@phnx-labs/agents-cli 1.21.1 → 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 = 21;
+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`
@@ -67,6 +71,7 @@ CREATE TABLE IF NOT EXISTS sessions (
   cost_usd REAL,
   duration_ms INTEGER,
   model TEXT,
+  tool_call_count INTEGER,
   file_path TEXT NOT NULL,
   file_mtime_ms INTEGER,
   file_size INTEGER,
@@ -84,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);
@@ -139,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;
 /**
@@ -399,6 +429,57 @@ function migrateSchema(db, fromVersion) {
             db.exec(`ALTER TABLE sessions ADD COLUMN spawned_team TEXT`);
         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() {
@@ -758,20 +839,20 @@ const upsertSessionStmt = (db) => db.prepare(`
     id, short_id, agent, origin, routine_name, routine_run_id,
     version, account, timestamp, last_activity,
     project, cwd, git_branch, topic, label, message_count, token_count,
-    output_tokens, cost_usd, duration_ms, model,
+    output_tokens, cost_usd, duration_ms, model, tool_call_count,
     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,
     @project, @cwd, @git_branch, @topic, @label, @message_count, @token_count,
-    @output_tokens, @cost_usd, @duration_ms, @model,
+    @output_tokens, @cost_usd, @duration_ms, @model, @tool_call_count,
     @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,
@@ -802,6 +883,7 @@ const upsertSessionStmt = (db) => db.prepare(`
     cost_usd = excluded.cost_usd,
     duration_ms = excluded.duration_ms,
     model = excluded.model,
+    tool_call_count = excluded.tool_call_count,
     file_path = excluded.file_path,
     file_mtime_ms = excluded.file_mtime_ms,
     file_size = excluded.file_size,
@@ -815,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)
@@ -833,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),
@@ -895,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 = {
@@ -919,6 +1117,7 @@ export function upsertSession(meta, content, scan) {
         cost_usd: meta.costUsd ?? null,
         duration_ms: meta.durationMs ?? null,
         model: meta.model ?? null,
+        tool_call_count: meta.toolCallCount ?? null,
         file_path: meta.filePath,
         file_mtime_ms: scan?.fileMtimeMs ?? null,
         file_size: scan?.fileSize ?? null,
@@ -937,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);
@@ -1017,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,
@@ -1040,6 +1250,7 @@ export function upsertSessionsBatch(entries) {
                     cost_usd: meta.costUsd ?? null,
                     duration_ms: meta.durationMs ?? null,
                     model: meta.model ?? null,
+                    tool_call_count: meta.toolCallCount ?? null,
                     file_path: meta.filePath,
                     file_mtime_ms: scan?.fileMtimeMs ?? null,
                     file_size: scan?.fileSize ?? null,
@@ -1058,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, 
@@ -1229,6 +1442,7 @@ function rowToMeta(row) {
         costUsd: row.cost_usd ?? undefined,
         durationMs: row.duration_ms ?? undefined,
         model: row.model ?? undefined,
+        toolCallCount: row.tool_call_count ?? undefined,
         version: row.version ?? undefined,
         account: row.account ?? undefined,
         topic: row.topic ?? undefined,
@@ -1249,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) {
@@ -1381,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 {
@@ -66,6 +70,7 @@ interface ClaudeSessionScan {
     durationMs?: number;
     /** ISO time of the last timestamped event — the session's last activity. */
     lastActivity?: string;
+    toolCallCount?: number;
     /**
      * Value of the JSONL `entrypoint` field on the first event that carries it.
      * 'cli' for real interactive sessions, 'sdk-cli' for team-spawned ones.
@@ -86,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 {
@@ -374,6 +389,7 @@ export interface ClaudeParseState {
     aiTitle?: string;
     entrypoint?: string;
     messageCount: number;
+    toolCallCount: number;
     tokenCount: number;
     outputTokens: number;
     sawTokenCount: boolean;
@@ -392,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;
@@ -436,6 +457,7 @@ export interface ClaudeParserState {
     plan?: string;
     lastTsMs?: number;
     messageCount: number;
+    toolCallCount: number;
     tokenCount: number;
     outputTokens: number;
     sawTokenCount: boolean;
@@ -453,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
@@ -528,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,
     };
 }
 /**
@@ -1015,6 +1018,7 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, account,
             topic: scan.topic,
             label,
             messageCount: scan.messageCount,
+            toolCallCount: scan.toolCallCount,
             tokenCount: scan.tokenCount,
             outputTokens: scan.outputTokens,
             costUsd: scan.costUsd,
@@ -1029,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 {
@@ -1044,6 +1050,7 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, account,
             model: scan.model,
             label,
             messageCount: scan.messageCount,
+            toolCallCount: scan.toolCallCount,
             tokenCount: scan.tokenCount,
             outputTokens: scan.outputTokens,
             costUsd: scan.costUsd,
@@ -1059,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 {
@@ -2425,6 +2434,7 @@ export function initClaudeParseState() {
         aiTitle: undefined,
         entrypoint: undefined,
         messageCount: 0,
+        toolCallCount: 0,
         tokenCount: 0,
         outputTokens: 0,
         sawTokenCount: false,
@@ -2443,6 +2453,8 @@ export function initClaudeParseState() {
         plan: undefined,
         checklistEvents: [],
         recentDirectoriesTouched: [],
+        skillEvents: [],
+        slashCommandEvents: [],
     };
 }
 const CHECKLIST_TOOLS = new Set(['TodoWrite', 'todo_write', 'update_plan', 'TaskCreate', 'TaskUpdate']);
@@ -2450,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);
@@ -2482,6 +2504,7 @@ export function applyClaudeLine(state, parsed) {
         for (const b of parsed.message.content) {
             if (b?.type !== 'tool_use')
                 continue;
+            state.toolCallCount++;
             if (!state.spawnedTeam && typeof b?.input?.command === 'string') {
                 const team = detectSpawnedTeam(b.input.command);
                 if (team)
@@ -2578,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;
     }
@@ -2642,6 +2674,7 @@ export function finalizeClaudeScan(state) {
         topic: resolvedTopic,
         entrypoint: state.entrypoint,
         messageCount: state.messageCount,
+        toolCallCount: state.toolCallCount,
         tokenCount: state.sawTokenCount ? state.tokenCount : undefined,
         outputTokens: state.sawTokenCount ? state.outputTokens : undefined,
         costUsd: state.sawCost ? state.costUsd : undefined,
@@ -2657,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). */
@@ -2713,6 +2748,7 @@ export function serializeClaudeParserState(state, offset) {
         plan: state.plan,
         lastTsMs: state.lastTsMs,
         messageCount: state.messageCount,
+        toolCallCount: state.toolCallCount,
         tokenCount: state.tokenCount,
         outputTokens: state.outputTokens,
         sawTokenCount: state.sawTokenCount,
@@ -2734,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,
     };
 }
 /**
@@ -2771,6 +2809,7 @@ export function hydrateClaudeParseState(prior) {
         aiTitle: prior.aiTitle,
         entrypoint: prior.entrypoint,
         messageCount: prior.messageCount,
+        toolCallCount: prior.toolCallCount ?? 0,
         tokenCount: prior.tokenCount,
         outputTokens: prior.outputTokens,
         sawTokenCount: prior.sawTokenCount,
@@ -2789,6 +2828,8 @@ export function hydrateClaudeParseState(prior) {
         plan: prior.plan,
         checklistEvents: prior.checklistEvents ?? [],
         recentDirectoriesTouched: prior.recentDirectoriesTouched ?? [],
+        skillEvents: prior.skillEvents ?? [],
+        slashCommandEvents: prior.slashCommandEvents ?? [],
     };
 }
 /**
@@ -2990,6 +3031,8 @@ export function initCodexParseState() {
         spawnedTeam: undefined,
         checklistEvents: [],
         recentDirectoriesTouched: [],
+        skillEvents: [],
+        slashCommandEvents: [],
     };
 }
 /**
@@ -3237,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: [],
     };
 }
 /**
@@ -3734,6 +3782,7 @@ export function readCursorMeta(filePath, currentVersion) {
         topic: firstUserText ? extractSessionTopic(firstUserText) : undefined,
         label: title,
         messageCount: events.filter((event) => event.type === 'message').length,
+        todos: extractTodoProgressFromEvents(events),
     };
     return { meta, content: userTexts.join('\n') };
 }