@lmctl-ai/lmctl 0.1.342 → 0.2.2

package/dist/providers/passive-readers/opencode.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Passive (read-only, bounded, certified) reader for OpenCode sessions.
+ *
+ * ## Relationship to lmplayer (the investigated finding, from real stores)
+ *
+ * lmplayer IS an opencode fork/wrapper, and the two share the opencode SQLite
+ * schema EXACTLY: `message(id,session_id,time_created,time_updated,data)`,
+ * `part(id,message_id,session_id,time_created,time_updated,data)`,
+ * `session(id,project_id,…)`, with the per-row `data` column holding JSON. Verified
+ * on this box: an opencode assistant `message.data` is
+ * `{parentID, role:"assistant", tokens:{input,output,reasoning,cache:{read,write}},
+ * modelID, providerID, time:{created,completed}}` and a tool `part.data` is
+ * `{type:"tool", tool, callID, state:{status,input,output,metadata:{display}}}` —
+ * byte-for-byte the shapes the dispatcher's lmplayer reader already handles.
+ *
+ * What DIFFERS is ONLY the store location and the label:
+ *  - opencode canonical store: `$XDG_DATA_HOME/opencode/opencode.db` (large, live)
+ *    and `…/opencode/opencode-local.db`, plus `$XDG_CONFIG_HOME/opencode/opencode.db`.
+ *  - lmplayer store: `$XDG_DATA_HOME/lmplayer/opencode*.db` (with extra
+ *    lmplayer-only `session_job*` tables — the source of the
+ *    `session-job-notification` synthetic part type, filtered here too).
+ *
+ * So this reader reuses the lmplayer extraction verbatim but labels every source
+ * `provider:"opencode"` — NEVER "lmplayer", even though the SQLite shape is
+ * identical (lmbi's explicit "no cross-provider mislabeling" requirement). The
+ * label flows from `source.provider`, which discovery sets to `"opencode"`.
+ *
+ * LANDMINE for wiring: the `OPENCODE_DB` env var currently routes the dispatcher's
+ * LMPLAYER default paths — pointing it at the opencode store would label opencode
+ * data as `lmplayer`. This reader deliberately does NOT read that env; an explicit
+ * store override goes through `OpencodePassiveReaderOptions.dbPaths`.
+ *
+ * De-duplicate the mirrored helpers (parseApplyPatch / classifyTool / firstPath /
+ * writeInputBytes / sqliteRevision / the row reader) against the dispatcher's own
+ * copies at wiring time.
+ */
+import type { ReadLimits, Snapshot, Source, SourceState } from "../passive-session-reader.js";
+export declare const OPENCODE_PROVIDER = "opencode";
+/** opencode's own canonical stores (NOT lmplayer's, NOT the OPENCODE_DB env). */
+export declare function defaultOpencodeDbPaths(): string[];
+interface OpencodeMessageRow extends Record<string, unknown> {
+    id: string;
+    time_created: number;
+    time_updated: number;
+    data: string;
+}
+interface OpencodePartRow extends Record<string, unknown> {
+    id: string;
+    message_id: string;
+    time_created: number;
+    time_updated: number;
+    data: string;
+}
+/** Extract per-response metadata from an opencode session's rows. Verbatim
+ * lmplayer logic, labeled through `source.provider` (= "opencode"). */
+export declare function readOpencodeRows(source: Source, revision: string, rows: {
+    messages: OpencodeMessageRow[];
+    parts: OpencodePartRow[];
+}, limits: ReadLimits): Snapshot;
+export interface OpencodePassiveReaderOptions {
+    /** Overrides the default opencode store paths (does NOT read `OPENCODE_DB`). */
+    dbPaths?: string[];
+    sqliteBusyTimeoutMs?: number;
+}
+/** Keyset watermark for cross-DB discovery (one page continues after this key). */
+export interface OpencodeDiscoveryCursor {
+    source_id: string;
+    sessionid: string;
+}
+export declare class OpencodePassiveReader {
+    private readonly dbPaths;
+    private readonly sqliteBusyTimeoutMs;
+    constructor(options?: OpencodePassiveReaderOptions);
+    private openDb;
+    /**
+     * Enumerate up to `cap` sources ordered by `source_id\0sessionid`, deduped by
+     * session id (the first configured DB that holds it is canonical). `after`
+     * continues a previous page. Bounded SQL (`LIMIT`) — no traversal budget, so
+     * `truncated` is always false.
+     */
+    discover(limits: ReadLimits, cap: number, after?: OpencodeDiscoveryCursor | null): Promise<{
+        sources: Source[];
+        truncated: boolean;
+    }>;
+    inspect(source: Source, limits: ReadLimits): SourceState;
+    read(source: Source, revision: string, limits: ReadLimits): Snapshot;
+}
+export declare function createOpencodePassiveReader(options?: OpencodePassiveReaderOptions): OpencodePassiveReader;
+export {};

package/dist/providers/passive-readers/qwen.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Passive (read-only, bounded, certified) reader for Qwen Code sessions.
+ *
+ * ## Why this reader does not follow either of qwen.ts's own headers
+ *
+ * `src/providers/qwen.ts` carries two conflicting claims: its file header says
+ * "Qwen Code is a Claude Code fork — same JSONL session format", while its
+ * `QwenUsageMetadata` comment says "Qwen Code is a Gemini CLI fork; usageMetadata
+ * follows Gemini API semantics". Neither label alone describes the records on
+ * disk, so this reader was written from the records instead. What a census of
+ * every `*.jsonl` under the local projects store actually shows (1155 records,
+ * 0 parse failures):
+ *
+ * - The ENVELOPE is Claude-shaped: `uuid`, `parentUuid`, `sessionId`,
+ *   `timestamp`, `type`, `cwd`, `version`, `gitBranch` on 1155/1155 records.
+ * - The record TYPES diverge from Claude: `system` (592), `assistant` (276),
+ *   `tool_result` (238), `user` (49). Claude folds tool results into `user`
+ *   rows; qwen gives them their own type. That makes a `user` row an
+ *   unambiguous external prompt admission here — no tool_result sniffing.
+ * - Usage exists in TWO shapes simultaneously, so "which fork" is the wrong
+ *   question:
+ *     1. `assistant.usageMetadata` — Gemini camelCase
+ *        (`promptTokenCount` / `candidatesTokenCount` / `thoughtsTokenCount` /
+ *        `totalTokenCount` / `cachedContentTokenCount`), on 276 records, with
+ *        NO per-response identity of any kind.
+ *     2. `system` rows with `subtype:"ui_telemetry"` and
+ *        `systemPayload.uiEvent["event.name"] === "qwen-code.api_response"` —
+ *        snake_case (`input_token_count` / `output_token_count` /
+ *        `cached_content_token_count` / `thoughts_token_count` /
+ *        `total_token_count`), on 289 records, each carrying a native
+ *        `response_id` (`chatcmpl-…`).
+ *
+ * This reader treats shape (2) as authoritative, because it is the ONLY source
+ * with a native per-response id — the contract forbids fabricating a
+ * `response_id` out of an envelope uuid — and it strictly covers shape (1)
+ * (289 ≥ 276; the extra 13 are `subagent_name` responses that have no
+ * top-level assistant row at all).
+ *
+ * ## Token semantics: measured, not assumed
+ *
+ * All 289 local api_response records satisfy, with zero violations:
+ *   input_token_count + output_token_count === total_token_count
+ *   cached_content_token_count <= input_token_count
+ *   thoughts_token_count       <= output_token_count
+ *
+ * i.e. cached is a SUBSET of input and thoughts a SUBSET of output — Gemini
+ * semantics, now verified on real records rather than inherited from a comment.
+ * The three invariants are re-checked at read time; a violation makes the whole
+ * snapshot `partial` rather than emitting numbers whose meaning we cannot stand
+ * behind.
+ *
+ * `input_cache_write` is NULL, not 0: no cache-write counter exists anywhere in
+ * this wire (no such key on any of the 289 records), so its value is unrecorded,
+ * not known-zero.
+ *
+ * `model_provider` is NULL. The nearest native field is `auth_type`
+ * (`openai` / `qwen-oauth` locally), which is an AUTHENTICATION method, not a
+ * model-provider identity; reporting `qwen-oauth` as a provider would be a
+ * mislabel. See the note in the owner report.
+ */
+import type { ReadLimits, Snapshot, Source, SourceState } from "../passive-session-reader.js";
+import { type TokenValues } from "./shared.js";
+export declare const QWEN_PROVIDER = "qwen";
+/** One raw line of a qwen chat transcript. Only fields this reader reads. */
+interface QwenLine {
+    uuid?: unknown;
+    parentUuid?: unknown;
+    sessionId?: unknown;
+    type?: unknown;
+    subtype?: unknown;
+    timestamp?: unknown;
+    message?: unknown;
+    systemPayload?: unknown;
+}
+export interface QwenPassiveReaderOptions {
+    /**
+     * Discovery roots, in the caller's preferred order. Defaults to the live store
+     * plus every retained backup store (see `defaultQwenProjectRoots`).
+     */
+    qwenProjectsDirs?: string[];
+    maxDiscoveryTraversalVisits?: number;
+}
+/**
+ * Default qwen discovery roots.
+ *
+ * `~/.qwen.bk1/projects` is a RETAINED ACCOUNT HISTORY store, not a redundant
+ * copy to skip. Verified on this box: 30 transcripts there against 27 in the
+ * live root, with **zero identity overlap** — 0 shared file names, 0 shared
+ * in-record `sessionId`s and 0 shared `response_id`s — over disjoint telemetry
+ * spans (backup 2026-03-14 → 04-12, live 2026-04-14 → 07-02). Excluding it
+ * would silently drop 89 real responses from any cost total.
+ */
+export declare function defaultQwenProjectRoots(): string[];
+/**
+ * Map one api_response telemetry event onto the contract's four token slots.
+ * Returns null when a required counter is missing/not a non-negative integer, or
+ * when any of the three measured invariants fails — the caller turns that into a
+ * `partial` snapshot rather than guessing.
+ */
+export declare function qwenTokens(event: Record<string, unknown>): TokenValues | null;
+export declare function readQwen(lines: QwenLine[], source: Source, revision: string, limits: ReadLimits): Snapshot;
+/**
+ * Do the records agree with the session id the caller asked for? True when no
+ * record names a session at all (nothing to contradict) or when every named
+ * session equals `sessionid`. False on any disagreement, including a transcript
+ * that names two different sessions.
+ */
+export declare function qwenRecordsMatchSession(lines: QwenLine[], sessionid: string): boolean;
+export declare class QwenPassiveReader {
+    /**
+     * Resolved discovery roots, in configured order. Exposed so a caller can map a
+     * `source_id` back to the root it came from without re-deriving the defaults.
+     */
+    readonly roots: readonly string[];
+    private readonly maxDiscoveryTraversalVisits;
+    constructor(options?: QwenPassiveReaderOptions);
+    /**
+     * Enumerate up to `cap` sources across EVERY configured root, ordered by real
+     * path. `afterPath` continues a previous page; real-path order is total, so one
+     * cursor resumes the merged stream correctly.
+     *
+     * ## Provenance and cross-root identity
+     *
+     * `source_id` is the file's absolute real path, so it names the root a session
+     * came from (`…/.qwen/projects/…` vs `…/.qwen.bk1/projects/…`) without any
+     * extra field on the shared `Source` shape. Two sessions that happen to share a
+     * `sessionid` across roots therefore stay two DISTINCT sources with distinct
+     * `source_id`s, and both are read.
+     *
+     * This reader performs **no identity dedup** — that is the consumer's job, on
+     * real ids. The only collapsing done here is by real path, which removes a file
+     * reachable through two configured roots (e.g. one root symlinked inside
+     * another); that is the same physical file, never two sessions that merely look
+     * alike. Nothing is ever dropped because a similarly-named file exists
+     * elsewhere.
+     */
+    discover(limits: ReadLimits, cap: number, afterPath?: string | null): Promise<{
+        sources: Source[];
+        truncated: boolean;
+    }>;
+    /**
+     * A source_id is only ours when it is a real, non-symlink file contained by one
+     * of the configured roots AND its basename is the claimed session id. Both
+     * checks run before any read.
+     */
+    private matches;
+    inspect(source: Source, limits: ReadLimits): Promise<SourceState>;
+    read(source: Source, revision: string, limits: ReadLimits): Promise<Snapshot>;
+}
+export declare function createQwenPassiveReader(options?: QwenPassiveReaderOptions): QwenPassiveReader;
+export {};

package/dist/providers/passive-readers/shared.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Self-contained primitives for the per-provider passive readers that live in
+ * this directory (agy, qwen).
+ *
+ * WHY THIS FILE EXISTS: the equivalent helpers inside
+ * `src/providers/passive-session-reader.ts` are module-private, and that file is
+ * concurrently owned by the discovery-fairness redesign. Re-implementing the
+ * handful we need here keeps this slice landable without touching the shared
+ * dispatcher. Only the PUBLIC contract types are imported from it, so there is
+ * exactly one definition of the wire shape.
+ *
+ * At wiring time these should be de-duplicated against the dispatcher's own
+ * copies (see PASSIVE_EXTRACTION_SEMANTICS below — that constant in particular
+ * MUST stay equal to the dispatcher's `EXTRACTION_SEMANTICS`).
+ */
+import type { ExternalIoEntry, PricingFacts, ReadLimits } from "../passive-session-reader.js";
+/**
+ * Extraction-semantics tag folded into every revision string.
+ *
+ * MUST equal `EXTRACTION_SEMANTICS` in `../passive-session-reader.ts` (currently
+ * "bx3"). A revision is compared by lmbi as a plain string, so a reader emitting
+ * a different tag for the same native bytes would look permanently un-indexed.
+ * Bump both together whenever extraction semantics change — this file's real
+ * de-dup against the dispatcher's copy is still pending (see file header);
+ * until then a bump here is easy to miss, as happened with the bx2→bx3 change.
+ */
+export declare const PASSIVE_EXTRACTION_SEMANTICS = "bx3";
+export type FileDirection = "read" | "written";
+export interface FileObservation {
+    path: string;
+    bytes: number | null;
+}
+export interface TokenValues {
+    input_uncached: number | null;
+    input_cached: number | null;
+    input_cache_write: number | null;
+    output: number | null;
+}
+export declare const EMPTY_TOKENS: TokenValues;
+export declare function record(value: unknown): Record<string, unknown> | null;
+export declare function nonnegativeInteger(value: unknown): number | null;
+/** Non-negative integer counter, or null. Used for pricing_facts counts. */
+export declare function optCount(value: unknown): number | null;
+export declare function canonicalTimestamp(value: unknown): string | null;
+export declare function checkedLimits(limits: ReadLimits): void;
+/**
+ * Deterministic UTF-16 code-unit ordering for opaque identifiers/paths. ICU
+ * collation can differ across Node builds; two processes must agree on cursor
+ * order, so code-unit comparison is the safe primitive.
+ */
+export declare function compareCodeUnits(left: string, right: string): number;
+/**
+ * Per-response file observations keyed by (call id, direction, path) — the
+ * "smallest honest unit". Two DIFFERENT call ids to the same path stay separate;
+ * a replayed record of the SAME call id coalesces (first recorded wins).
+ * `bytes` is UTF-8 content size: a number (including 0), or null when the
+ * content is genuinely unavailable.
+ */
+export declare class ObservationSet {
+    private readonly map;
+    record(callId: string, direction: FileDirection, path: unknown, bytes: number | null): void;
+    files(direction: FileDirection): FileObservation[];
+}
+/**
+ * Collector for non-file external-I/O entries. Deduplicates by native
+ * (id, direction, kind); a MEASURED id-less entry is never deduplicated
+ * (content/byte dedup is forbidden by the contract), while id-less null-byte
+ * coverage markers may merge (one unknown marker forces NULL as well as two).
+ */
+export declare class ExternalIoSet {
+    private readonly map;
+    record(entry: ExternalIoEntry): void;
+    entries(): ExternalIoEntry[];
+}
+/**
+ * Per-direction aggregate: numeric ONLY when the whole direction is known —
+ * `files` non-null with every byte numeric AND every external_io entry in this
+ * direction numeric. ANY null contributor → null (never a partial sum posing as
+ * a total). A fully-classified direction with no contributors → 0.
+ */
+export declare function aggregateDirection(files: FileObservation[] | null, io: ExternalIoEntry[] | null, direction: FileDirection): number | null;
+/**
+ * Build a validated pricing_facts object, dropping fields that are not present
+ * as non-negative integers and enforcing the two invariants: reasoning ≤ output,
+ * and (5m + 1h) cache-write TTL counts ≤ the known cache-write total. Returns
+ * null when nothing valid is present. A recorded 0 is preserved (0 ≠ unknown).
+ */
+export declare function buildPricingFacts(raw: {
+    cacheWrite5m?: unknown;
+    cacheWrite1h?: unknown;
+    reasoning?: unknown;
+    webSearch?: unknown;
+    webFetch?: unknown;
+}, outputTokens: number | null, cacheWriteTotal: number | null): PricingFacts | null;
+export declare function isInternalControlTool(name: unknown): boolean;
+/** Record an opaque/uncertified tool call as unknown in BOTH directions. */
+export declare function recordUnattributedBoth(io: ExternalIoSet, callId: string | null): void;
+/**
+ * UTF-8 byte size of the content WRITTEN by a write call, taken from the call's
+ * OWN input (never the file on disk). Returns 0 for a genuinely empty write,
+ * null when no content field is present.
+ */
+export declare function writeInputBytes(input: unknown): number | null;
+/**
+ * Resolve `path` to its real location and require it to be a regular,
+ * non-symlink file contained by one of `roots`. Returns the real path, or null.
+ */
+export declare function containedRealFile(path: string, roots: string[]): Promise<string | null>;
+/**
+ * Read a JSONL file within the byte budget and hash its exact native bytes.
+ * Returns null when the file is missing, oversized, or changed underneath the
+ * read (dev/ino/size/mtime re-checked after) — a torn read is never reported as
+ * a clean revision.
+ */
+export declare function jsonlRevision(path: string, limits: ReadLimits): Promise<{
+    revision: string;
+    data: Buffer;
+} | null>;
+/**
+ * Parse a complete JSONL buffer. Returns null when the file does not end on a
+ * record boundary (a live append caught mid-line) or any line is not a JSON
+ * object — a torn/partial file is never silently treated as complete.
+ */
+export declare function parseJsonl<T>(data: Buffer, limits: ReadLimits): T[] | null;
+/** Minimal read-only `node:sqlite` surface used by the sqlite-backed readers. */
+export interface SqliteStatement {
+    all(...params: unknown[]): unknown[];
+    get(...params: unknown[]): unknown;
+}
+export interface SqliteDatabase {
+    close(): void;
+    exec(sql: string): void;
+    prepare(sql: string): SqliteStatement;
+}
+export type SqliteDatabaseConstructor = new (path: string, options?: {
+    open?: boolean;
+    readOnly?: boolean;
+}) => SqliteDatabase;

package/dist/providers/passive-session-reader.d.ts

@@ -0,0 +1,188 @@
+import type { CopilotSessionUsage } from "./passive-readers/copilot.js";
+export interface Source {
+    provider: string;
+    sessionid: string;
+    source_id: string;
+}
+export interface ReadLimits {
+    signal: AbortSignal;
+    maxBytes: number;
+    maxRows: number;
+}
+export type SourceState = {
+    status: "ready";
+    revision: string;
+} | {
+    status: "partial" | "unsupported" | "unavailable";
+};
+/** A non-file external-I/O contributor for a response (phase 3 / bx2). File
+ * reads/writes stay in files_read/files_written and are NEVER duplicated here.
+ * An `unattributed` entry is a coverage marker (bytes=null, basis="unknown")
+ * that forces its whole direction's aggregate to NULL. */
+export interface ExternalIoEntry {
+    direction: "read" | "write";
+    kind: "prompt" | "web" | "other" | "unattributed";
+    /** Native admission/call id for dedup; never a content body. */
+    id: string | null;
+    /** Bounded metadata ref (web URL sans credentials/query/fragment); null for
+     * prompt/unattributed; never a raw command/query/prompt body. */
+    ref: string | null;
+    bytes: number | null;
+    basis: "input_text" | "normalized_content" | "certified_counter" | "unknown";
+}
+/** Closed whitelist of native pricing/fidelity facts for an eventual lmprice
+ * join (note 387). Counts only — no rates, service tier/speed, credentials, or
+ * account info. `reasoning_output_tokens` is a subset of `tokens.output`; the
+ * cache-write TTL counts cannot exceed `tokens.input_cache_write`. */
+export interface PricingFacts {
+    cache_write_5m_tokens?: number | null;
+    cache_write_1h_tokens?: number | null;
+    reasoning_output_tokens?: number | null;
+    web_search_requests?: number | null;
+    web_fetch_requests?: number | null;
+}
+export interface NativeResponseMetadata {
+    response_id: string;
+    timestamp: string | null;
+    model: string | null;
+    tokens: {
+        input_uncached: number | null;
+        input_cached: number | null;
+        input_cache_write: number | null;
+        output: number | null;
+    };
+    files_read: Array<{
+        path: string;
+        bytes: number | null;
+    }> | null;
+    files_written: Array<{
+        path: string;
+        bytes: number | null;
+    }> | null;
+    read_bytes?: number | null;
+    write_bytes?: number | null;
+    external_io?: ExternalIoEntry[] | null;
+    model_provider?: string | null;
+    pricing_facts?: PricingFacts | null;
+}
+export interface Discovery {
+    sources: Source[];
+    complete: boolean;
+    cursor: string | null;
+}
+export type Snapshot = {
+    status: "complete";
+    source: Source;
+    revision: string;
+    checkpoint: string | null;
+    responses: NativeResponseMetadata[];
+    /** Native session-scoped usage snapshots (currently: copilot's
+     * `session.shutdown` records) — surfaced BESIDE responses, never
+     * distributed into them, never a synthetic response. `undefined`/absent
+     * for providers with no such native concept; `null` for a provider that
+     * has the concept but this session has none yet (e.g. still live);
+     * present-and-non-empty only when real native snapshots exist. Every
+     * relevant native snapshot is retained (never "last wins") since a
+     * provider's own scope semantics may not cover the whole session. */
+    session_usage?: CopilotSessionUsage[] | null;
+    /** Explicit, additive coverage marker: `responses` above are real,
+     * identified, fully-valid rows — never fabricated or clamped-to-zero —
+     * but a KNOWN native-format gap means some other, uncapturable activity
+     * in this same source could not be attributed to a response (e.g. a
+     * Codex source mixing legacy `event_msg`/`token_count` telemetry
+     * alongside modern `token_usage_record`s: the old-format usage is
+     * conservatively treated as an unresolved gap whenever it co-occurs with
+     * captured rows — matching raw token counts is NOT proof of native
+     * identity, since distinct requests can share identical small integer
+     * counts, so a numeric match never clears this marker). Absent ⇒ legacy
+     * full-coverage semantics (nothing else exists to omit) —
+     * NEVER default a missing marker to "partial" or vice versa. A caller
+     * MUST reject any value other than "partial" here rather than guess a
+     * new meaning for an unrecognized marker. This is a coverage flag only:
+     * it never changes the validity of `responses`, and a caller retains
+     * and journals those rows while simply never advancing its incremental
+     * revision/retention watermark past a snapshot carrying this flag. */
+    capture_status?: "partial";
+} | {
+    status: "partial" | "unsupported" | "unavailable";
+};
+/**
+ * Effective discovery-coverage certification (lmbi backfill-reader-contract.md).
+ * This is an explicit certification of what this reader instance actually
+ * covers, NOT a list inferred from rows already returned — a caller must be
+ * able to tell "no adapter for this provider" apart from "adapter exists, its
+ * store is genuinely empty."
+ */
+export interface PassiveSessionReaderCapabilities {
+    /** All configured native account roots, no team/task/session filter. */
+    scope: "account";
+    /** Changes when extraction semantics OR effective declared root
+     * configuration change, so a caller knows to start a safe new traversal
+     * rather than trust a stale cursor/cache against new coverage. */
+    revision: string;
+    /** Providers this instance can discover/inspect/read at all (certified,
+     * even where token metering itself is only partial — see `metering`). */
+    providers: string[];
+    /** Per-provider metering completeness. Informational only — never an
+     * admission gate; an unlisted provider makes no metering claim either way. */
+    metering: Record<string, "per_response" | "partial" | "unavailable" | "session_only">;
+}
+export interface PassiveSessionReader {
+    discover(limits: ReadLimits & {
+        maxSources: number;
+        after?: string;
+    }): Promise<Discovery>;
+    inspect(source: Source, limits: ReadLimits): Promise<SourceState>;
+    read(source: Source, revision: string, limits: ReadLimits): Promise<Snapshot>;
+    capabilities(): PassiveSessionReaderCapabilities;
+}
+export interface PassiveSessionReaderOptions {
+    claudeProjectsDir?: string;
+    codexSessionDirs?: string[];
+    lmplayerDbPaths?: string[];
+    /** Overrides agy's default `$HOME/.gemini/antigravity-cli/conversations`. */
+    agyConversationsDir?: string;
+    /** Overrides dsh's default `~/.dsh/sessions` (or `$DSH_HOME/sessions`). */
+    dshHome?: string;
+    /** Overrides qwen's default live+backup project roots. */
+    qwenProjectsDirs?: string[];
+    /** Overrides opencode's default store paths (does NOT read `OPENCODE_DB`). */
+    opencodeDbPaths?: string[];
+    /** Overrides copilot's default `$HOME/.copilot/session-state`. */
+    copilotSessionStateDir?: string;
+    /** Overrides kimi's default `$KIMI_CODE_HOME`/`~/.kimi-code`. */
+    kimiHome?: string;
+    sqliteBusyTimeoutMs?: number;
+    /** Directory-traversal visit budget for discovery (see
+     * MAX_DISCOVERY_TRAVERSAL_VISITS). Overridable mainly so tests can exercise
+     * the truncation path without a pathological tree. */
+    maxDiscoveryTraversalVisits?: number;
+}
+export declare class NativePassiveSessionReader implements PassiveSessionReader {
+    private readonly claudeProjectsDir;
+    private readonly codexSessionDirs;
+    private readonly lmplayerDbPaths;
+    private readonly sqliteBusyTimeoutMs;
+    private readonly maxDiscoveryTraversalVisits;
+    private readonly agyReader;
+    private readonly dshReader;
+    private readonly qwenReader;
+    private readonly opencodeReader;
+    private readonly copilotReader;
+    private readonly kimiReader;
+    constructor(options?: PassiveSessionReaderOptions);
+    capabilities(): PassiveSessionReaderCapabilities;
+    discover(limits: ReadLimits & {
+        maxSources: number;
+        after?: string;
+    }): Promise<Discovery>;
+    inspect(source: Source, limits: ReadLimits): Promise<SourceState>;
+    read(source: Source, revision: string, limits: ReadLimits): Promise<Snapshot>;
+    private discoverProvider;
+    private jsonlSourceMatches;
+    private openLmplayer;
+    private discoverLmplayer;
+    private inspectLmplayer;
+    private readLmplayer;
+}
+export declare function createPassiveSessionReader(options?: PassiveSessionReaderOptions): PassiveSessionReader;

package/dist/providers/path-utils.d.ts

@@ -0,0 +1 @@
+export declare function canonicalPath(path: string): string;

package/dist/providers/pi.d.ts

@@ -0,0 +1,32 @@
+/**
+ * pi coding agent session provider.
+ *
+ * pi stores sessions as JSONL files under
+ *   ~/.pi/agent/sessions/--<encoded-cwd>--/<timestamp>_<session-id>.jsonl
+ * where <encoded-cwd> is the cwd with the leading separator stripped and
+ * "/", "\\", ":" replaced by "-". The first line is a session header
+ * ({"type":"session","id":...,"cwd":...}); subsequent lines are tree-linked
+ * entries (message / model_change / compaction / ...). File format:
+ * packages/coding-agent/docs/session-format.md in the pi repo.
+ */
+import type { SessionDetail, SessionProvider, SessionSummary } from "./types.js";
+interface PiProviderOptions {
+    piDir?: string;
+}
+export declare class PiProvider implements SessionProvider {
+    name: "pi";
+    private baseDir;
+    constructor(opts?: PiProviderOptions);
+    getWatchPaths(): {
+        directory: string;
+        filePattern: RegExp;
+    }[];
+    discoverSessions(): Promise<SessionSummary[]>;
+    private listSessionFiles;
+    private readHeader;
+    private extractSummary;
+    loadSession(sessionId: string): Promise<SessionDetail | null>;
+    resolveSessionPath(sessionId: string): Promise<string | null>;
+    deleteSession(sessionId: string): Promise<boolean>;
+}
+export {};