@phnx-labs/agents-cli 1.20.90 → 1.20.92

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

@@ -13,6 +13,13 @@ export interface FileChange {
     path: string;
     op: FileOp;
 }
+/**
+ * Path-shaped noise that must never surface as a session "change": shell
+ * redirect tokens (`2>&1`), unexpanded env-var prefixes (`$WT/...`), dependency
+ * dirs (`node_modules`), and agents-cli's internal `.system` marker. Filtered at
+ * the source so every consumer (summary, picker, digest counts) agrees.
+ */
+export declare function isNoisePath(p: string): boolean;
 /** Extract file paths deleted by a shell command (rm / git rm / unlink). Conservative. */
 export declare function extractDeletedPaths(command: string): string[];
 /**
@@ -35,6 +42,12 @@ export declare function toolHistogram(toolCounts: Record<string, number>, top?:
     tool: string;
     count: number;
 }>;
+/**
+ * Aggregate recognized external tools invoked via Bash across a session.
+ * Unknown one-off commands are bucketed as `other` so the ranking surface
+ * (e.g. `agents activity --tools`) only surfaces repeatable tools.
+ */
+export declare function bashToolCounts(events: SessionEvent[]): Record<string, number>;
 export interface TestResult {
     runner: string;
     passed?: number;

package/dist/lib/session/digest.js

@@ -7,11 +7,35 @@
  * last test/build result. Consumed by the single-session view and the picker
  * preview. No I/O — fully unit-testable.
  */
+import { bucketKey, classifyBashCommand } from './bash-command.js';
 // Tool vocab mirrors parse.ts / render.ts so classification matches what those
 // modules already recognize across Claude/Codex/others.
 const READ_TOOLS = new Set(['Read', 'read_file', 'view_file', 'cat_file', 'get_file']);
 const WRITE_TOOLS = new Set(['Write', 'write_file', 'create_file']);
 const EDIT_TOOLS = new Set(['Edit', 'edit_file', 'replace', 'patch', 'MultiEdit', 'apply_patch']);
+/**
+ * Path-shaped noise that must never surface as a session "change": shell
+ * redirect tokens (`2>&1`), unexpanded env-var prefixes (`$WT/...`), dependency
+ * dirs (`node_modules`), and agents-cli's internal `.system` marker. Filtered at
+ * the source so every consumer (summary, picker, digest counts) agrees.
+ */
+export function isNoisePath(p) {
+    if (!p)
+        return true;
+    if (/^\d+>[&/]?/.test(p))
+        return true; // 2>&1, 1>&2, 2>/dev/null
+    if (p.includes('>&'))
+        return true;
+    if (p.startsWith('$') || p.startsWith('"$') || p.startsWith("'$"))
+        return true; // unexpanded $VAR
+    if (/(^|\/)node_modules(\/|$)/.test(p))
+        return true;
+    if (/(^|\/)\.system$/.test(p))
+        return true;
+    if (p.includes('/.agents/.history/'))
+        return true; // agents-cli internal archives
+    return false;
+}
 /** Extract file paths deleted by a shell command (rm / git rm / unlink). Conservative. */
 export function extractDeletedPaths(command) {
     const out = [];
@@ -25,7 +49,10 @@ export function extractDeletedPaths(command) {
                 continue; // flags (-r, -f, --force)
             if (/[*?{}]/.test(tok))
                 continue; // globs — too imprecise to attribute
-            out.push(tok.replace(/^['"]|['"]$/g, '')); // unquote
+            const p = tok.replace(/^['"]|['"]$/g, ''); // unquote
+            if (isNoisePath(p))
+                continue;
+            out.push(p);
         }
     }
     return out;
@@ -57,6 +84,8 @@ export function classifyFileChanges(events) {
             continue;
         if (p.includes('.claude/plans/') && p.endsWith('.md'))
             continue;
+        if (isNoisePath(p))
+            continue;
         if (READ_TOOLS.has(tool)) {
             readBefore.add(p);
         }
@@ -99,6 +128,24 @@ export function toolHistogram(toolCounts, top = 8) {
         .sort((a, b) => b.count - a.count || a.tool.localeCompare(b.tool))
         .slice(0, top);
 }
+/**
+ * Aggregate recognized external tools invoked via Bash across a session.
+ * Unknown one-off commands are bucketed as `other` so the ranking surface
+ * (e.g. `agents activity --tools`) only surfaces repeatable tools.
+ */
+export function bashToolCounts(events) {
+    const counts = {};
+    for (const e of events) {
+        if (e.type !== 'tool_use' || e._local)
+            continue;
+        if (e.tool !== 'Bash' || !e.command)
+            continue;
+        const info = classifyBashCommand(e.command);
+        const key = info.category === 'other' ? 'other' : bucketKey(e.command);
+        counts[key] = (counts[key] || 0) + 1;
+    }
+    return counts;
+}
 /**
  * Recognized test/build runners → the label we show.
  *

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

@@ -674,5 +674,4 @@ export declare function readGrokMeta(filePath: string, currentVersion?: string):
     meta: SessionMeta;
     content: string;
 } | null;
-/** Parse a time filter string (relative like '7d' or ISO timestamp) into epoch milliseconds. */
-export declare function parseTimeFilter(input: string): number;
+export { parseTimeFilter } from './relative-time.js';

package/dist/lib/session/discover.js

@@ -16,6 +16,7 @@ import { promisify } from 'util';
 import Database from '../sqlite.js';
 import { getAgentsDir, getUserAgentsDir, getHistoryDir, getRunsDir } from '../state.js';
 import { shortCodexHome } from '../codex-home.js';
+import { parseTimeFilter } from './relative-time.js';
 const execFileAsync = promisify(execFile);
 import { AGENTS, agentConfigDirName, getCliVersion } from '../agents.js';
 import { walkForFilesWithStat } from '../fs-walk.js';
@@ -4117,27 +4118,9 @@ export function readGrokMeta(filePath, currentVersion) {
     };
     return { meta, content: topic || '' };
 }
-/** Parse a time filter string (relative like '7d' or ISO timestamp) into epoch milliseconds. */
-export function parseTimeFilter(input) {
-    // Units: m=minute, h=hour, d=day, w=week, mo=month(30d), y=year(365d). `mo`
-    // must precede the single-letter alternatives so "1mo" isn't read as "1m"+"o".
-    const relativeMatch = input.match(/^(\d+)(mo|[mhdwy])$/i);
-    if (relativeMatch) {
-        const value = parseInt(relativeMatch[1], 10);
-        const unit = relativeMatch[2].toLowerCase();
-        if (unit === 'm')
-            return Date.now() - value * 60_000;
-        if (unit === 'h')
-            return Date.now() - value * 3_600_000;
-        if (unit === 'd')
-            return Date.now() - value * 86_400_000;
-        if (unit === 'w')
-            return Date.now() - value * 7 * 86_400_000;
-        if (unit === 'mo')
-            return Date.now() - value * 30 * 86_400_000;
-        if (unit === 'y')
-            return Date.now() - value * 365 * 86_400_000;
-    }
-    const ts = new Date(input).getTime();
-    return Number.isNaN(ts) ? 0 : ts;
-}
+// parseTimeFilter moved to ./relative-time.js — a leaf module — so a caller that
+// only needs the duration parser does not pull this file's `../sqlite.js` import
+// (and Node's SQLite ExperimentalWarning on stderr) into its module graph.
+// Re-exported so every existing importer keeps working unchanged. Imported too,
+// because a bare re-export does not bind the name for this file's own callers.
+export { parseTimeFilter } from './relative-time.js';

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

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

package/dist/lib/session/highlights.js

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

package/dist/lib/session/parse.js

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

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

@@ -5,3 +5,40 @@
  * `remote.ts`, so a back-import would cycle.
  */
 export declare function formatRelativeTime(isoTimestamp: string): string;
+/**
+ * Compact age — `now`, `45m`, `3h`, `2d`, then the calendar date. This is the
+ * *creation* half of a session's time cell: it renders right next to the long
+ * last-activity label, and one row can afford one long form, not two.
+ */
+export declare function formatCompactAge(isoTimestamp: string): string;
+/** The two time fields a session listing shows for one row. */
+export interface SessionAgeParts {
+    /**
+     * Compact age of the session's creation, set only when the session ran long
+     * enough (>= a minute) for it to say something `last` does not.
+     */
+    created?: string;
+    /** Last-activity label — the long relative form the listing sorts by. */
+    last: string;
+}
+/**
+ * Split a session's timestamps into the two fields a listing renders: when it
+ * was created and when it was last active. One last-activity label answers
+ * neither "is this the old session I'm looking for" nor "how long did it run" —
+ * a session touched an hour ago may have started last week.
+ */
+export declare function sessionAgeParts(createdIso: string, lastActivityIso?: string): SessionAgeParts;
+/**
+ * Parse a time filter string (relative like '7d' or an ISO timestamp) into epoch
+ * milliseconds. Backs `--since` on `sessions`, `cost`, `teams`, and `output`, and
+ * `--unused` on `secrets list`.
+ *
+ * It lives here, in a module with no imports, rather than in `discover.ts` where
+ * it started: `discover.ts` loads `../sqlite.js`, so importing this one function
+ * from there pulls `node:sqlite` into the caller's module graph and Node prints
+ * `ExperimentalWarning: SQLite …` on stderr. That is invisible in a command that
+ * already touches the session DB, and a broken contract in one that doesn't —
+ * `monitors --json` asserts a clean stderr. `discover.ts` re-exports it, so
+ * existing importers are unaffected.
+ */
+export declare function parseTimeFilter(input: string): number;