@phnx-labs/agents-cli 1.21.1 → 1.21.2

package/dist/lib/routines.js

@@ -964,6 +964,45 @@ export function getLatestCompletedRun(jobName) {
     }
     return null;
 }
+/** Percentile of a sorted-ascending array (linear interpolation). p in [0,100]. */
+function percentile(sorted, p) {
+    if (sorted.length === 0)
+        return 0;
+    if (sorted.length === 1)
+        return sorted[0];
+    const rank = (p / 100) * (sorted.length - 1);
+    const lo = Math.floor(rank);
+    const hi = Math.ceil(rank);
+    if (lo === hi)
+        return sorted[lo];
+    const frac = rank - lo;
+    return sorted[lo] * (1 - frac) + sorted[hi] * frac;
+}
+/**
+ * Fold a job's run history (`listRuns`) into a duration + outcome summary.
+ * `missed` fires (no process ever ran) carry no `duration` and are excluded
+ * from the latency percentiles but still counted in `count`/`missed`.
+ */
+export function routineStats(jobName) {
+    const runs = listRuns(jobName);
+    const failed = runs.filter((r) => r.status === 'failed' || r.status === 'timeout').length;
+    const missed = runs.filter((r) => r.status === 'missed').length;
+    const durations = runs
+        .map((r) => r.duration)
+        .filter((d) => typeof d === 'number' && Number.isFinite(d))
+        .sort((a, b) => a - b);
+    const avgMs = durations.length > 0
+        ? Math.round(durations.reduce((sum, d) => sum + d, 0) / durations.length)
+        : 0;
+    return {
+        count: runs.length,
+        failed,
+        missed,
+        avgMs,
+        p50: Math.round(percentile(durations, 50)),
+        p95: Math.round(percentile(durations, 95)),
+    };
+}
 /** Persist run metadata to its run directory as meta.json. */
 export function writeRunMeta(meta) {
     ensureAgentsDir();

package/dist/lib/runner.js

@@ -46,10 +46,28 @@ const AGENT_COMMANDS = {
 /** Agents the daemon can actually run, derived from the command table above
  * so the `--agent` help and any validation can never drift from it. */
 export const ROUTINE_AGENT_IDS = Object.freeze(Object.keys(AGENT_COMMANDS));
+/**
+ * Where each agent's transcript files live under an overlay HOME, mirroring
+ * `SESSION_ROOT_SPECS` (session/discover.ts) — the CLI's own source of truth
+ * for which on-disk trees hold live session files. Kept in this shape (not a
+ * shared import) because `archiveRoutineTranscripts` only needs a flat
+ * root+ext pair to `walkForFiles`, not the version-home/backup fan-out
+ * `getAgentSessionDirs` does for live discovery.
+ *
+ * `opencode` is deliberately absent: `SESSION_ROOT_SPECS` itself has no entry
+ * for it — its transcripts live in one incrementally-scanned SQLite db
+ * (`scanOpenCodeIncremental`), not a per-session file tree — so there is
+ * nothing here to mirror without inventing a new discovery path.
+ */
 const ROUTINE_TRANSCRIPT_SPECS = {
     claude: [{ root: ['.claude', 'projects'], ext: '.jsonl' }],
     codex: [{ root: ['.codex', 'sessions'], ext: '.jsonl' }],
     cursor: [{ root: ['.cursor', 'projects'], ext: '.jsonl' }],
+    gemini: [{ root: ['.gemini', 'tmp'], ext: '.json' }],
+    antigravity: [{ root: ['.gemini', 'antigravity-cli', 'conversations'], ext: '.db' }],
+    droid: [{ root: ['.factory', 'sessions'], ext: '.jsonl' }],
+    kimi: [{ root: ['.kimi-code', 'sessions'], ext: '.json' }],
+    grok: [{ root: ['.grok', 'sessions'], ext: '.json' }],
 };
 /** Stable working directory for routine children, independent of the daemon's launch cwd. */
 export function routineSpawnCwd(config, configuredRoot = getProjectRoot()) {
@@ -1080,6 +1098,14 @@ export async function executeJobDetached(config, hooks) {
     // wait); the next schedule tick re-selects if this attempt still fails.
     const launch = await resolveRoutineLaunch(config);
     const version = launch.chain[0]?.version ?? config.version;
+    const timer = createTimer('agent.run', {
+        agent: config.agent,
+        version,
+        jobName: config.name,
+        mode: config.mode,
+        ...redactPrompt(config.prompt),
+        schedule: config.schedule,
+    });
     const resolvedPrompt = resolveJobPrompt(config);
     let cmd = buildJobCommand(config, resolvedPrompt);
     // workflow AND resume dispatch through `agents run` — never binary-pin them (pinning
@@ -1143,6 +1169,7 @@ export async function executeJobDetached(config, hooks) {
             finalizeRunMeta(meta, 'failed', 1, { errorMessage: reason });
             writeRunMeta(meta);
             archiveRoutineTranscripts(meta, runDir, overlayHome);
+            timer.end({ status: 'failed', exitCode: 1, runId, error: reason });
             return meta;
         }
     }
@@ -1164,6 +1191,7 @@ export async function executeJobDetached(config, hooks) {
         const isAuthFailure = !!errorMessage && errorMessage.startsWith('auth_failed:');
         if (status !== 'timeout' && !isAuthFailure)
             extractAndSaveReport(stdoutPath, effectiveAgent, runDir);
+        timer.end({ status, exitCode: exitCode ?? undefined, runId, ...(errorMessage ? { error: errorMessage } : {}) });
         // Fire the finish/output notification AFTER the report is written so the hook
         // can read report.md (RUSH-2030). Best-effort; never breaks finalization.
         safeHook(hooks?.onFinish ? () => hooks.onFinish(meta) : undefined);
@@ -1214,6 +1242,11 @@ export async function executeJobDetached(config, hooks) {
  * `monitorRunningJobs` reaps the record on the next tick.
  */
 function executeCommandJobDetached(config, hooks) {
+    const timer = createTimer('agent.run', {
+        jobName: config.name,
+        mode: config.mode,
+        schedule: config.schedule,
+    });
     const runId = generateRunId();
     const runDir = getRunDir(config.name, runId);
     fs.mkdirSync(runDir, { recursive: true });
@@ -1259,6 +1292,7 @@ function executeCommandJobDetached(config, hooks) {
         settled = true;
         finalizeRunMeta(meta, status, exitCode, errorMessage ? { errorMessage } : undefined);
         writeRunMeta(meta);
+        timer.end({ status, exitCode, runId, ...(errorMessage ? { error: errorMessage } : {}) });
         // Finish notification (RUSH-2030). For command routines the threshold only
         // surfaces failures, decided in routine-notify.ts. Best-effort.
         safeHook(hooks?.onFinish ? () => hooks.onFinish(meta) : undefined);

package/dist/lib/secrets/usage-db.d.ts

@@ -1,69 +1,34 @@
 /**
- * SQLite-backed usage read-model for `agents secrets`.
- *
- * A small local database at ~/.agents/secrets/secrets.db that records one
- * value-free row for every secret lifecycle/access event a bundle accrues over
- * its life — created, imported, exported, viewed, accessed (read for injection),
- * unlocked. It is the queryable, per-bundle counterpart to the append-only
- * ~/.agents/events.jsonl audit log: the SAME chokepoint (`emitSecretAudit`,
- * lib/secrets/audit.ts) feeds both, and this store answers "how often / how
- * recently / by whom was THIS bundle used?" without scanning the whole event
- * stream. It is a DERIVED index fed off the real access flow — the way
- * sessions.db indexes session metadata — never a second write path an operation
- * has to remember to call.
- *
- * Contract, mirroring the audit log: NEVER a secret value. Only metadata — the
- * bundle name, the event kind, key counts, the resolving agent/host, a status.
- *
- * Every write is best-effort: a failure here (missing runtime SQLite, a locked
- * db, a read-only fs) is swallowed so usage telemetry can never break secret
- * resolution. Set AGENTS_NO_USAGE_TRACK=1 to disable recording entirely (used by
- * tests and by callers that must stay perfectly silent).
+ * Secrets usage read-model — thin adapter over the analytics usage warehouse
+ * (`kind=secret`). Kept so `secrets view` / `list` / `activity` keep their API
+ * while the durable store lives at ~/.agents/.history/analytics/usage.db.
  */
-/** The lifecycle/access events a bundle accrues over its life. */
 export type SecretUsageEvent = 'access' | 'unlock' | 'import' | 'export' | 'create' | 'view';
-/** All event kinds, in the order `view` prints them. */
 export declare const SECRET_USAGE_EVENTS: readonly SecretUsageEvent[];
 export interface RecordUsageParams {
-    /** Bundle the event applies to (required — usage is always per-bundle). */
     bundle: string;
-    /** What happened. */
     event: SecretUsageEvent;
-    /** Resolving agent/harness identity, when known (`*` = a global grant). */
     agent?: string;
-    /** Remote host the value was pulled from / pushed to, when applicable. */
     host?: string;
-    /** Free-form origin label, e.g. 'agent', 'reveal', 'ssh', '1password'. */
     source?: string;
-    /** Outcome; defaults to 'success'. */
     status?: 'success' | 'error';
-    /** How many keys the event touched (names only are ever known here). */
     keyCount?: number;
 }
-/** One event kind's rollup for a bundle. */
 export interface UsageStat {
     count: number;
-    /** ISO 8601 timestamp of the most recent occurrence, or null if never. */
     last: string | null;
 }
-/** Per-bundle usage summary for the `view` / `list` surfaces. */
 export interface BundleUsageSummary {
     bundle: string;
-    /** Every recorded event, all kinds. */
     total: number;
-    /** Rollup per event kind (every kind present, zeroed when unused). */
     events: Record<SecretUsageEvent, UsageStat>;
-    /** Most recent event across all kinds, or null. */
     lastUsedAt: string | null;
-    /** Earliest event across all kinds, or null. */
     firstUsedAt: string | null;
-    /** Event count grouped by resolving agent, most-first. `*` = a global grant. */
     byAgent: Array<{
         agent: string;
         count: number;
     }>;
 }
-/** One recorded event, for the `secrets activity` timeline. */
 export interface SecretUsageHistoryEntry {
     ts: string;
     bundle: string;
@@ -74,33 +39,8 @@ export interface SecretUsageHistoryEntry {
     status: string | null;
     keyCount: number | null;
 }
-/**
- * Record one usage event. Best-effort and value-free — swallows every error and
- * honors AGENTS_NO_USAGE_TRACK so telemetry never blocks or slows a read. Rows
- * with an empty bundle name are ignored (usage is per-bundle by definition).
- *
- * This is called from ONE place only — `emitSecretAudit` (lib/secrets/audit.ts)
- * — so every recorded event has already been written to the events.jsonl audit
- * log through the same chokepoint. Do not call it from a command handler; emit
- * the audit event instead.
- */
 export declare function recordSecretUsage(p: RecordUsageParams): void;
-/**
- * Usage summary for one bundle, or undefined when nothing has ever been
- * recorded (or the DB is unavailable). Never throws.
- */
 export declare function getBundleUsage(bundle: string): BundleUsageSummary | undefined;
-/**
- * Usage summaries for every bundle that has any recorded event, keyed by bundle
- * name. Powers `secrets list --sort uses|used`. Empty map when the DB is
- * unavailable or has no rows. Never throws.
- */
 export declare function getAllBundleUsage(): Map<string, BundleUsageSummary>;
-/**
- * Recent events for the `secrets activity` timeline — one bundle when named,
- * else across all bundles — newest first. Empty when the DB is unavailable.
- * Never throws.
- */
 export declare function getUsageHistory(bundle: string | undefined, limit?: number): SecretUsageHistoryEntry[];
-/** Close the cached handle. Used by tests between temp-db swaps. */
 export declare function closeSecretsUsageDb(): void;

package/dist/lib/secrets/usage-db.js

@@ -1,30 +1,9 @@
 /**
- * SQLite-backed usage read-model for `agents secrets`.
- *
- * A small local database at ~/.agents/secrets/secrets.db that records one
- * value-free row for every secret lifecycle/access event a bundle accrues over
- * its life — created, imported, exported, viewed, accessed (read for injection),
- * unlocked. It is the queryable, per-bundle counterpart to the append-only
- * ~/.agents/events.jsonl audit log: the SAME chokepoint (`emitSecretAudit`,
- * lib/secrets/audit.ts) feeds both, and this store answers "how often / how
- * recently / by whom was THIS bundle used?" without scanning the whole event
- * stream. It is a DERIVED index fed off the real access flow — the way
- * sessions.db indexes session metadata — never a second write path an operation
- * has to remember to call.
- *
- * Contract, mirroring the audit log: NEVER a secret value. Only metadata — the
- * bundle name, the event kind, key counts, the resolving agent/host, a status.
- *
- * Every write is best-effort: a failure here (missing runtime SQLite, a locked
- * db, a read-only fs) is swallowed so usage telemetry can never break secret
- * resolution. Set AGENTS_NO_USAGE_TRACK=1 to disable recording entirely (used by
- * tests and by callers that must stay perfectly silent).
+ * Secrets usage read-model — thin adapter over the analytics usage warehouse
+ * (`kind=secret`). Kept so `secrets view` / `list` / `activity` keep their API
+ * while the durable store lives at ~/.agents/.history/analytics/usage.db.
  */
-import * as fs from 'fs';
-import * as path from 'path';
-import Database from '../sqlite.js';
-import { getSecretsDbPath } from '../state.js';
-/** All event kinds, in the order `view` prints them. */
+import { recordUsage, getSecretBundleRollup, getSecretBundleAgents, getAllSecretBundleRollups, getSecretHistory, closeUsageDb, } from '../analytics/usage-db.js';
 export const SECRET_USAGE_EVENTS = [
     'access',
     'unlock',
@@ -33,28 +12,6 @@ export const SECRET_USAGE_EVENTS = [
     'create',
     'view',
 ];
-/** Events older than this are pruned on open so the history table stays bounded. */
-const EVENT_RETENTION_MS = 90 * 24 * 60 * 60 * 1000;
-const SCHEMA = `
-CREATE TABLE IF NOT EXISTS usage_events (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  ts TEXT NOT NULL,
-  bundle TEXT NOT NULL,
-  event TEXT NOT NULL,
-  agent TEXT,
-  host TEXT,
-  source TEXT,
-  status TEXT,
-  key_count INTEGER
-);
-CREATE INDEX IF NOT EXISTS idx_usage_bundle ON usage_events(bundle);
-CREATE INDEX IF NOT EXISTS idx_usage_bundle_event ON usage_events(bundle, event);
-CREATE INDEX IF NOT EXISTS idx_usage_ts ON usage_events(ts DESC);
-`;
-// Cached handle keyed by the resolved path, so a test that redirects
-// AGENTS_SECRETS_DB to a fresh temp file transparently reopens instead of
-// reusing a stale handle pointed at the previous path.
-let cached = null;
 function emptyEvents() {
     return {
         access: { count: 0, last: null },
@@ -65,68 +22,6 @@ function emptyEvents() {
         view: { count: 0, last: null },
     };
 }
-/**
- * Open (creating if needed) the usage DB, returning null on any failure so
- * every caller degrades to a no-op rather than throwing into secret resolution.
- */
-function open() {
-    const dbPath = getSecretsDbPath();
-    if (cached && cached.path === dbPath)
-        return cached.db;
-    if (cached) {
-        try {
-            cached.db.close();
-        }
-        catch { /* ignore */ }
-        cached = null;
-    }
-    try {
-        fs.mkdirSync(path.dirname(dbPath), { recursive: true });
-        const db = new Database(dbPath);
-        // WAL + a busy timeout so concurrent agent runs writing usage rows don't
-        // fail each other under load; every write is still best-effort besides.
-        db.pragma('journal_mode = WAL');
-        db.pragma('busy_timeout = 2000');
-        db.exec(SCHEMA);
-        // Bounded retention: this is a usage history for operators, not a compliance
-        // log (that is events.jsonl). Prune once per open on a 90-day window.
-        try {
-            db.prepare(`DELETE FROM usage_events WHERE ts < ?`).run(new Date(Date.now() - EVENT_RETENTION_MS).toISOString());
-        }
-        catch { /* prune is best-effort */ }
-        cached = { path: dbPath, db };
-        return db;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Record one usage event. Best-effort and value-free — swallows every error and
- * honors AGENTS_NO_USAGE_TRACK so telemetry never blocks or slows a read. Rows
- * with an empty bundle name are ignored (usage is per-bundle by definition).
- *
- * This is called from ONE place only — `emitSecretAudit` (lib/secrets/audit.ts)
- * — so every recorded event has already been written to the events.jsonl audit
- * log through the same chokepoint. Do not call it from a command handler; emit
- * the audit event instead.
- */
-export function recordSecretUsage(p) {
-    if (process.env.AGENTS_NO_USAGE_TRACK)
-        return;
-    if (!p.bundle)
-        return;
-    const db = open();
-    if (!db)
-        return;
-    try {
-        db.prepare(`INSERT INTO usage_events (ts, bundle, event, agent, host, source, status, key_count)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(new Date().toISOString(), p.bundle, p.event, p.agent ?? null, p.host ?? null, p.source ?? null, p.status ?? 'success', p.keyCount ?? null);
-    }
-    catch {
-        // Telemetry must never break secret resolution.
-    }
-}
 function toSummary(bundle, rows, byAgent) {
     const events = emptyEvents();
     let total = 0;
@@ -146,91 +41,56 @@ function toSummary(bundle, rows, byAgent) {
     }
     return { bundle, total, events, lastUsedAt, firstUsedAt, byAgent };
 }
-/**
- * Usage summary for one bundle, or undefined when nothing has ever been
- * recorded (or the DB is unavailable). Never throws.
- */
+export function recordSecretUsage(p) {
+    if (!p.bundle)
+        return;
+    const meta = {};
+    if (p.keyCount != null)
+        meta.keyCount = p.keyCount;
+    if (p.host)
+        meta.host = p.host;
+    recordUsage({
+        kind: 'secret',
+        name: p.bundle,
+        event: p.event,
+        agent: p.agent,
+        source: p.source,
+        status: p.status,
+        meta: Object.keys(meta).length ? meta : undefined,
+    });
+}
 export function getBundleUsage(bundle) {
-    const db = open();
-    if (!db)
+    const rows = getSecretBundleRollup(bundle);
+    if (rows.length === 0)
         return undefined;
-    try {
-        const rows = db
-            .prepare(`SELECT event, COUNT(*) AS n, MAX(ts) AS last, MIN(ts) AS first
-           FROM usage_events WHERE bundle = ? GROUP BY event`)
-            .all(bundle);
-        if (rows.length === 0)
-            return undefined;
-        const agents = db
-            .prepare(`SELECT agent, COUNT(*) AS n FROM usage_events
-           WHERE bundle = ? AND agent IS NOT NULL GROUP BY agent ORDER BY n DESC`)
-            .all(bundle);
-        return toSummary(bundle, rows, agents.map((a) => ({ agent: a.agent, count: a.n })));
-    }
-    catch {
-        return undefined;
-    }
+    const agents = getSecretBundleAgents(bundle);
+    return toSummary(bundle, rows, agents.map((a) => ({ agent: a.agent, count: a.n })));
 }
-/**
- * Usage summaries for every bundle that has any recorded event, keyed by bundle
- * name. Powers `secrets list --sort uses|used`. Empty map when the DB is
- * unavailable or has no rows. Never throws.
- */
 export function getAllBundleUsage() {
     const out = new Map();
-    const db = open();
-    if (!db)
-        return out;
-    try {
-        const rows = db
-            .prepare(`SELECT bundle, event, COUNT(*) AS n, MAX(ts) AS last, MIN(ts) AS first
-           FROM usage_events GROUP BY bundle, event`)
-            .all();
-        const byBundle = new Map();
-        for (const r of rows) {
-            const list = byBundle.get(r.bundle) ?? [];
-            list.push(r);
-            byBundle.set(r.bundle, list);
-        }
-        for (const [bundle, list] of byBundle)
-            out.set(bundle, toSummary(bundle, list, []));
-        return out;
-    }
-    catch {
-        return out;
+    const rows = getAllSecretBundleRollups();
+    const byBundle = new Map();
+    for (const r of rows) {
+        const list = byBundle.get(r.name) ?? [];
+        list.push(r);
+        byBundle.set(r.name, list);
     }
+    for (const [bundle, list] of byBundle)
+        out.set(bundle, toSummary(bundle, list, []));
+    return out;
 }
-/**
- * Recent events for the `secrets activity` timeline — one bundle when named,
- * else across all bundles — newest first. Empty when the DB is unavailable.
- * Never throws.
- */
 export function getUsageHistory(bundle, limit = 20) {
-    const db = open();
-    if (!db)
-        return [];
-    try {
-        const sql = bundle
-            ? `SELECT ts, bundle, event, agent, host, source, status, key_count AS keyCount
-           FROM usage_events WHERE bundle = ? ORDER BY ts DESC, id DESC LIMIT ?`
-            : `SELECT ts, bundle, event, agent, host, source, status, key_count AS keyCount
-           FROM usage_events ORDER BY ts DESC, id DESC LIMIT ?`;
-        const rows = bundle
-            ? db.prepare(sql).all(bundle, limit)
-            : db.prepare(sql).all(limit);
-        return rows;
-    }
-    catch {
-        return [];
-    }
+    return getSecretHistory(bundle, limit).map((r) => ({
+        ts: r.ts,
+        bundle: r.bundle,
+        event: r.event,
+        agent: r.agent,
+        host: r.host,
+        source: r.source,
+        status: r.status,
+        keyCount: r.keyCount,
+    }));
 }
-/** Close the cached handle. Used by tests between temp-db swaps. */
 export function closeSecretsUsageDb() {
-    if (cached) {
-        try {
-            cached.db.close();
-        }
-        catch { /* ignore */ }
-        cached = null;
-    }
+    closeUsageDb();
 }

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

@@ -11,7 +11,7 @@ import type { SessionAgentId, SessionMeta } from './types.js';
 /** 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 declare const SCHEMA_VERSION = 21;
+export declare const SCHEMA_VERSION = 22;
 /** Raw row shape returned from the sessions table. */
 export interface SessionRow {
     id: string;
@@ -35,6 +35,7 @@ export interface SessionRow {
     cost_usd: number | null;
     duration_ms: number | null;
     model: string | null;
+    tool_call_count: number | null;
     file_path: string;
     file_mtime_ms: number | null;
     file_size: number | null;

package/dist/lib/session/db.js

@@ -19,7 +19,7 @@ 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 = 22;
 /**
  * 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 +67,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,
@@ -399,6 +400,12 @@ 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) {
+        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;`);
+    }
 }
 /** Open (or return the cached) sessions database, applying migrations as needed. */
 export function getDB() {
@@ -758,7 +765,7 @@ 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,
@@ -767,7 +774,7 @@ 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,
@@ -802,6 +809,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,
@@ -919,6 +927,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,
@@ -1040,6 +1049,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,
@@ -1229,6 +1239,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,

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

@@ -66,6 +66,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.
@@ -374,6 +375,7 @@ export interface ClaudeParseState {
     aiTitle?: string;
     entrypoint?: string;
     messageCount: number;
+    toolCallCount: number;
     tokenCount: number;
     outputTokens: number;
     sawTokenCount: boolean;
@@ -436,6 +438,7 @@ export interface ClaudeParserState {
     plan?: string;
     lastTsMs?: number;
     messageCount: number;
+    toolCallCount: number;
     tokenCount: number;
     outputTokens: number;
     sawTokenCount: boolean;