@lmctl-ai/lmctl 0.2.37 → 0.2.39

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

@@ -1,173 +0,0 @@
-/**
- * Passive (read-only, bounded, certified) reader for GitHub Copilot CLI sessions.
- *
- * ## What the native store actually is (real records, not assumed)
- *
- * Copilot writes one append-only event log per session:
- *   `$HOME/.copilot/session-state/<uuid>/events.jsonl`  (+ a `workspace.yaml`).
- * Each line is a JSON object `{ type, id, timestamp, data }`. The event TYPES seen
- * locally: `session.start`, `session.model_change`, `session.info`,
- * `system.message`, `user.message`, `assistant.turn_start`, `assistant.message`,
- * `assistant.turn_end`, `tool.execution_start`, `tool.execution_complete`,
- * `session.shutdown`.
- *
- * ## Token semantics — the copilot warning, verified on disk
- *
- * lmbi's directive: "Copilot has cumulative per-model shutdown totals and some
- * per-message usage; NEVER distribute a session total over responses without
- * evidence." Measured against real sessions:
- *
- *  - `assistant.message.outputTokens` IS a genuine PER-RESPONSE count.
- *  - There is NO per-message input / cache / reasoning field anywhere on the wire.
- *    Those counters exist only in `session.shutdown.modelMetrics` snapshots.
- *
- * CORRECTED (real evidence, not the original assumption): `session.shutdown`
- * is NOT a proven session-wide cumulative. A session can carry MANY shutdown
- * events (measured: up to 24 in one real session), and a shutdown's
- * `requests.count`/`outputTokens` can be far smaller than the session's real
- * total turn count/output sum (measured: a 201-turn session's last shutdown
- * reported `requests.count=7`, `outputTokens=1984` against a real per-message
- * sum of 82,375 — a ~97.6% undercount). So each shutdown snapshot's semantics
- * are `"reported_scope_unknown"`, never asserted cumulative.
- *
- * Therefore each response record here carries `tokens.output` (real, per-message)
- * and leaves `input_uncached` / `input_cached` / `input_cache_write` NULL — the
- * shutdown snapshot's input is NEVER divided across responses. Every shutdown
- * snapshot is surfaced SEPARATELY and RAW as `CopilotSessionUsage` (see
- * `readCopilot`/`readWithUsage`) — never spread over the per-response rows,
- * never emitted as a fabricated pseudo-response, and never renamed/normalized
- * into this reader's own canonical token vocabulary (that's lmbi's own
- * downstream decision to make, not this reader's).
- *
- * ## Identity, revision, attribution
- *
- *  - `response_id` = `assistant.message.data.messageId` (a real uuid); never
- *    invented. Repeated events for one messageId sum their `outputTokens`.
- *  - The revision is the sha256 of the exact `events.jsonl` bytes (extraction-
- *    semantics-tagged, see EXTRACTION_SEMANTICS) with
- *    a dev/ino/size/mtime recheck: a live append caught mid-write is `partial`,
- *    never a clean revision, and a file not ending on a record boundary is refused.
- *  - Prompt admission: `user.message.data.content` bytes attach to the FIRST
- *    assistant response of the same `interactionId`; later responses in that
- *    interaction are a real 0 (the prompt was already admitted). A response whose
- *    interaction has no visible user admission (truncated history / system-driven
- *    turn) gets an unknown coverage marker — "no input" cannot be certified.
- *
- * ## File / external-I/O (bx2), conservative by contract
- *
- * `create` ({path,file_text}) and `apply_patch` (<patch string>) are KNOWN writes
- * with measurable added bytes. `view` ({path}) is a KNOWN read whose bytes are
- * NULL — the result content is line-decorated with no clean chunk to count, so the
- * honest size is unavailable (not guessed). `report_intent` is internal control
- * (neither direction). Everything else opaque (`bash`/`read_bash`/`write_bash`/
- * `stop_bash`/`list_bash`/`rg`/`glob`/`sql`/`fetch_*`/…) is unknown in BOTH
- * directions, forcing that direction's aggregate NULL.
- */
-import type { ReadLimits, Snapshot, Source, SourceState } from "../passive-session-reader.js";
-export declare const COPILOT_PROVIDER = "copilot";
-/**
- * One event line of a copilot `events.jsonl`. Only the fields this reader reads.
- */
-interface CopilotEvent {
-    type?: unknown;
-    id?: unknown;
-    timestamp?: unknown;
-    data?: unknown;
-}
-/**
- * One native model's RAW `session.shutdown` counters. Field NAMES are copied
- * directly from the native wire (`usage.inputTokens` -> `input_tokens`,
- * `tokenDetails.input.tokenCount` -> `input_other_tokens`, etc.) — this reader
- * does NOT compute, clamp, infer, or rename a "canonical uncached" figure here.
- * Per lmbi's explicit instruction: raw naming preserves the native facts while
- * this snapshot's own window/scope semantics remain unproven; normalizing
- * (e.g. `input_uncached = input_tokens - cache_read_tokens`) is a downstream
- * decision for the consumer, not this reader's to bake in.
- */
-export interface CopilotModelUsage {
-    model: string;
-    requests_count: number | null;
-    /** `usage.inputTokens`, copied as-is. */
-    input_tokens: number | null;
-    /** `tokenDetails.input.tokenCount`, copied as-is — a real native "fresh"
-     * figure, narrower than `input_tokens`. NOT a canonical uncached total. */
-    input_other_tokens: number | null;
-    cache_read_tokens: number | null;
-    cache_write_tokens: number | null;
-    output_tokens: number | null;
-    reasoning_tokens: number | null;
-}
-/**
- * One native `session.shutdown` EVENT, with every model in its `modelMetrics`
- * grouped underneath (mirrors the native shape: one event, many models) —
- * surfaced beside, never inside, the per-response rows.
- *
- * CORRECTED (real evidence, not assumption): a session can carry MULTIPLE
- * `session.shutdown` events (measured: up to 24 in one real session on this box),
- * and a shutdown's `requests.count`/`usage.outputTokens` can be far smaller than
- * the session's real total turn count/output sum (measured: a 201-turn session's
- * last shutdown reported `requests.count=7`, `outputTokens=1984` against a real
- * per-message sum of 82,375 — a ~97.6% undercount). So this is NOT a proven
- * session-wide cumulative; `semantics: "reported_scope_unknown"` reflects that
- * honestly. Every shutdown event is retained (never "last wins", exact
- * duplicate `native_id` replays coalesce to one), each with its own native
- * event id/timestamp, so later analysis isn't precluded by discarding earlier
- * snapshots.
- */
-export interface CopilotSessionUsage {
-    /** The `session.shutdown` event's own top-level `id` (a real uuid). An event
-     * with no real id is never given a fabricated one — it is excluded from this
-     * array entirely (an explicit capture gap, not silently-fine metadata). */
-    native_id: string;
-    /** The `session.shutdown` event's own top-level `timestamp`, canonicalized. */
-    recorded_at: string | null;
-    kind: "copilot_session_shutdown";
-    semantics: "reported_scope_unknown";
-    models: CopilotModelUsage[];
-}
-export interface CopilotReadResult {
-    snapshot: Snapshot;
-    /** null when the session has no shutdown event with a real id yet (live/torn,
-     * or every shutdown event on this session lacked an id) — normal. */
-    sessionUsage: CopilotSessionUsage[] | null;
-}
-/**
- * Extract the per-response snapshot AND the retained session-usage snapshots
- * (scope-unknown, never asserted cumulative) from a parsed copilot event log.
- * Pure and deterministic. A malformed event never throws; the
- * whole snapshot is only refused (`partial`) when a response row count exceeds the
- * budget — otherwise unrecognized shapes degrade to conservative NULL markers.
- */
-export declare function readCopilot(events: CopilotEvent[], source: Source, revision: string, limits: ReadLimits): CopilotReadResult;
-export interface CopilotPassiveReaderOptions {
-    /** Defaults to `$HOME/.copilot/session-state`. */
-    copilotSessionStateDir?: string;
-}
-export declare class CopilotPassiveReader {
-    private readonly sessionStateDir;
-    constructor(options?: CopilotPassiveReaderOptions);
-    /**
-     * Enumerate up to `cap` sources ordered by real path. `afterKey` (a
-     * `source_id\0sessionid` sourceKey) continues a previous page. Discovery is a
-     * single-level scan of the session-state directory (no deep recursion), so
-     * there is no traversal budget to exhaust — `truncated` is always false.
-     */
-    discover(limits: ReadLimits, cap: number, afterKey?: string | null): Promise<{
-        sources: Source[];
-        truncated: boolean;
-    }>;
-    /**
-     * A source is ours only when its real path is `<dir>/events.jsonl` contained by
-     * the session-state directory AND `<dir>` basename is the claimed session id.
-     */
-    private matches;
-    inspect(source: Source, limits: ReadLimits): Promise<SourceState>;
-    /** Contract-shaped read: per-response Snapshot only. Use `readWithUsage` to also
-     * obtain the retained session-usage snapshots that must not be distributed
-     * over responses (see the module header — their scope is unproven, never
-     * asserted cumulative). */
-    read(source: Source, revision: string, limits: ReadLimits): Promise<Snapshot>;
-    readWithUsage(source: Source, revision: string, limits: ReadLimits): Promise<CopilotReadResult>;
-}
-export declare function createCopilotPassiveReader(options?: CopilotPassiveReaderOptions): CopilotPassiveReader;
-export {};

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

@@ -1,34 +0,0 @@
-import type { ReadLimits, Snapshot, Source, SourceState } from "../passive-session-reader.js";
-export declare const DSH_PROVIDER = "dsh";
-interface DshRecord {
-    type?: unknown;
-    seq?: unknown;
-    time?: unknown;
-    data?: unknown;
-}
-export interface DshPassiveReaderOptions {
-    /** Defaults to `$DSH_HOME/sessions`, then `~/.dsh/sessions`. */
-    dshHome?: string;
-    maxDiscoveryTraversalVisits?: number;
-}
-export declare function readDsh(records: DshRecord[], source: Source, revision: string, limits: ReadLimits): Snapshot;
-export declare class DshPassiveReader {
-    private readonly sessionsDir;
-    private readonly maxDiscoveryTraversalVisits;
-    constructor(options?: DshPassiveReaderOptions);
-    /**
-     * Enumerate up to `cap` sources ordered by real path. `afterPath` continues a
-     * previous page. The caller owns cursor encoding and the cross-provider merge.
-     */
-    discover(limits: ReadLimits, cap: number, afterPath?: string | null): Promise<{
-        sources: Source[];
-        truncated: boolean;
-    }>;
-    /** Ours only when a real, non-symlink `session.jsonl.zstd` whose parent dir name
-     *  is the claimed session id. */
-    private matches;
-    inspect(source: Source, limits: ReadLimits): Promise<SourceState>;
-    read(source: Source, revision: string, limits: ReadLimits): Promise<Snapshot>;
-}
-export declare function createDshPassiveReader(options?: DshPassiveReaderOptions): DshPassiveReader;
-export {};

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

@@ -1,44 +0,0 @@
-import type { ReadLimits, Snapshot, Source, SourceState } from "../passive-session-reader.js";
-export declare const KIMI_PROVIDER = "kimi";
-export interface KimiPassiveReaderOptions {
-    /** Defaults to `$KIMI_CODE_HOME`, then `~/.kimi-code`. */
-    kimiHome?: string;
-    maxDiscoveryTraversalVisits?: number;
-}
-interface WireLine {
-    type?: unknown;
-    agentId?: unknown;
-    event?: unknown;
-    time?: unknown;
-    model?: unknown;
-    modelAlias?: unknown;
-    turnStep?: unknown;
-    input?: unknown;
-    origin?: unknown;
-    promptId?: unknown;
-    protocol_version?: unknown;
-    usage?: unknown;
-}
-export declare function readKimi(lines: WireLine[], source: Source, revision: string, limits: ReadLimits): Snapshot;
-export declare class KimiPassiveReader {
-    private readonly home;
-    private readonly sessionsDir;
-    private readonly indexPath;
-    private readonly maxDiscoveryTraversalVisits;
-    constructor(options?: KimiPassiveReaderOptions);
-    /**
-     * Enumerate up to `cap` agent-wire sources ordered by real path. `afterPath`
-     * continues a previous page. Unions the directory walk with the append-only
-     * index so a missing/damaged index still recovers sessions.
-     */
-    discover(limits: ReadLimits, cap: number, afterPath?: string | null): Promise<{
-        sources: Source[];
-        truncated: boolean;
-    }>;
-    private unionIndex;
-    private matches;
-    inspect(source: Source, limits: ReadLimits): Promise<SourceState>;
-    read(source: Source, revision: string, limits: ReadLimits): Promise<Snapshot>;
-}
-export declare function createKimiPassiveReader(options?: KimiPassiveReaderOptions): KimiPassiveReader;
-export {};

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

@@ -1,89 +0,0 @@
-/**
- * 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

@@ -1,151 +0,0 @@
-/**
- * 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

@@ -1,138 +0,0 @@
-/**
- * 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;