@phnx-labs/agents-cli 1.21.2 → 1.22.0

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

@@ -9,6 +9,9 @@
 import type { SessionAgentId, SessionEvent, SessionMeta, TodoProgress } from './types.js';
 export { machineForSessionFile } from './origin-machine.js';
 import { type ScanStamp } from './db.js';
+import { ToolCallCollector, type IndexedToolCall, type ToolCallCollectorSnapshot } from './tool-calls.js';
+/** One JSONL record may not force an unbounded string allocation. */
+export declare const SESSION_JSONL_LINE_MAX_BYTES: number;
 /** Options controlling which sessions to discover and how to report progress. */
 export interface DiscoverOptions {
     agent?: SessionAgentId;
@@ -27,6 +30,8 @@ export interface DiscoverOptions {
     /** Match any session whose cwd equals this or is a descendant. Overrides `cwd`. */
     cwdPrefix?: string;
     limit?: number;
+    /** Internal indexed-query path: return every row in scope instead of the default page. */
+    unbounded?: boolean;
     /** Filter sessions newer than this (ISO timestamp or "7d", "30d", "90d") */
     since?: string;
     /** Filter sessions older than this (ISO timestamp) */
@@ -39,8 +44,14 @@ export interface DiscoverOptions {
     origin?: 'cli' | 'routine';
     /** Column to order results by (all descending): 'timestamp' (default), 'cost', or 'duration'. */
     sortBy?: 'timestamp' | 'cost' | 'duration';
+    /** Trust scan-ledger rows without stat'ing every returned transcript. */
+    skipExistenceCheck?: boolean;
     /** 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 +98,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 {
@@ -125,6 +146,22 @@ interface CodexSessionScan {
  * TTL, no external lock files needed.
  */
 export declare function discoverSessions(options?: DiscoverOptions): Promise<SessionMeta[]>;
+/** Read the current SQLite snapshot without scanning or parsing transcript files. */
+export declare function queryIndexedSessions(options?: DiscoverOptions, indexedOptions?: {
+    resolveLinear?: boolean;
+    skipExistenceCheck?: boolean;
+}): Promise<SessionMeta[]>;
+/**
+ * Drop unmanaged rows for agents that HAVE managed versions.
+ *
+ * Scoping happens here, at query time, rather than by narrowing the scan: the index
+ * stays complete, so `--unmanaged` needs no re-scan and every other consumer of the
+ * DB (watchdog, the Factory watcher, `--roots`) is unaffected.
+ *
+ * An agent with no managed versions is left alone entirely — someone who has never
+ * run `agents add` sees exactly what they saw before.
+ */
+export declare function scopeToManaged(sessions: SessionMeta[], agents: readonly SessionAgentId[], options?: DiscoverOptions): SessionMeta[];
 /**
  * How many agents' dotfile dirs we scan at once, and the minimum spacing between
  * successive scan starts. A small bound + stagger turns a simultaneous bulk
@@ -356,6 +393,8 @@ export declare function readCodexMeta(filePath: string, resolveAccount?: () => s
     content: string;
     parserState?: string;
     contentText?: string;
+    toolCalls?: IndexedToolCall[];
+    toolIndexMode: 'replace' | 'append';
 } | null>;
 /**
  * Mutable accumulator for the Claude transcript reducer. One field per local
@@ -394,6 +433,12 @@ export interface ClaudeParseState {
     plan?: string;
     checklistEvents: SessionEvent[];
     recentDirectoriesTouched: string[];
+    toolCollector: ToolCallCollector;
+    /** 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;
@@ -423,8 +468,9 @@ export declare function scanClaudeSession(filePath: string): Promise<ClaudeSessi
  * exact even when the recent window is smaller than the true count.
  */
 export interface ClaudeParserState {
-    v: 1;
+    v: 2;
     offset: number;
+    jsonlDroppingOversizedLine?: boolean;
     timestamp?: string;
     cwd?: string;
     gitBranch?: string;
@@ -456,13 +502,17 @@ export interface ClaudeParserState {
     contentText?: string;
     checklistEvents: SessionEvent[];
     recentDirectoriesTouched: string[];
+    toolCalls: ToolCallCollectorSnapshot;
+    /** #12: see ClaudeParseState.skillEvents/slashCommandEvents. */
+    skillEvents: SessionEvent[];
+    slashCommandEvents: SessionEvent[];
 }
 /**
  * Snapshot a live {@link ClaudeParseState} into its serializable form at
  * `offset` bytes consumed. Round-trips through {@link hydrateClaudeParseState}
  * so incremental replay equals a full parse.
  */
-export declare function serializeClaudeParserState(state: ClaudeParseState, offset: number): ClaudeParserState;
+export declare function serializeClaudeParserState(state: ClaudeParseState, offset: number, jsonlDroppingOversizedLine?: boolean): ClaudeParserState;
 /**
  * Rebuild a live {@link ClaudeParseState} from a persisted continuation so that
  * applying the appended lines yields the same accumulator a full parse would.
@@ -495,6 +545,7 @@ export declare function scanClaudeSessionIncremental(filePath: string, fromOffse
     scan: ClaudeSessionScan;
     newState: ClaudeParserState;
     newOffset: number;
+    toolCalls: IndexedToolCall[];
 }>;
 /** Test seam: read the (incremental, full) Claude parse counters. */
 export declare function __claudeScanBranchCountsForTest(): {
@@ -531,6 +582,13 @@ export interface CodexParseState {
     spawnedTeam?: string;
     checklistEvents: SessionEvent[];
     recentDirectoriesTouched: string[];
+    toolCollector: ToolCallCollector;
+    /** #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;
@@ -558,8 +616,9 @@ export declare function finalizeCodexScan(state: CodexParseState): CodexSessionS
  * finalize is identical after a resume.
  */
 export interface CodexParserState {
-    v: 1;
+    v: 2;
     offset: number;
+    jsonlDroppingOversizedLine?: boolean;
     sessionId?: string;
     timestamp?: string;
     cwd?: string;
@@ -582,13 +641,14 @@ export interface CodexParserState {
     contentText?: string;
     checklistEvents: SessionEvent[];
     recentDirectoriesTouched: string[];
+    toolCalls: ToolCallCollectorSnapshot;
 }
 /**
  * Snapshot a live {@link CodexParseState} into its serializable form at `offset`
  * bytes consumed. Round-trips through {@link hydrateCodexParseState} so
  * incremental replay equals a full parse.
  */
-export declare function serializeCodexParserState(state: CodexParseState, offset: number): CodexParserState;
+export declare function serializeCodexParserState(state: CodexParseState, offset: number, jsonlDroppingOversizedLine?: boolean): CodexParserState;
 /**
  * Rebuild a live {@link CodexParseState} from a persisted continuation so that
  * applying the appended lines yields the same accumulator a full parse would.
@@ -607,9 +667,9 @@ export declare function hydrateCodexParseState(prior: CodexParserState): CodexPa
  *
  * Same trailing-line discipline as {@link scanClaudeSessionIncremental}: apply
  * ONLY the run of newline-terminated lines (slice at the last `'\n'`), and set
- * `newOffset = fromOffset + consumedBytes`. Any tail after the last `'\n'` —
- * syntactically broken OR a complete-but-not-yet-terminated record — is DEFERRED
- * to the next pass once its `'\n'` lands. Codex `messageCount` is additive with
+ * `newOffset = fromOffset + consumedBytes`. An ordinary tail after the last
+ * `'\n'` is deferred; an oversized one advances under a persisted discard bit.
+ * Codex `messageCount` is additive with
  * NO dedup, so re-reading a still-unterminated complete line would double-count
  * it; deferring prevents that (the bug class prix-cloud caught for Claude).
  */
@@ -617,6 +677,7 @@ export declare function scanCodexSessionIncremental(filePath: string, fromOffset
     scan: CodexSessionScan;
     newState: CodexParserState;
     newOffset: number;
+    toolCalls: IndexedToolCall[];
 }>;
 /** Test seam: read the (incremental, full) Codex parse counters. */
 export declare function __codexScanBranchCountsForTest(): {