@c3-oss/prosa-core 0.8.0

package/dist/index.d.ts

@@ -0,0 +1,1185 @@
+import { Database } from 'better-sqlite3';
+import { Logger } from 'pino';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+/**
+ * Synchronous better-sqlite3 database handle used throughout core.
+ */
+type Db = Database;
+
+/**
+ * Durable metadata written to `manifest.json` at the root of a bundle.
+ *
+ * The manifest records the store format and the parser/schema versions that
+ * last opened the bundle. SQLite remains the authoritative schema source after
+ * migrations; `openBundle` refreshes the version stamps when they drift.
+ */
+interface BundleManifest {
+    /** Manifest file format version. */
+    version: 1;
+    /** Parser version that last initialized or opened the bundle. */
+    parser_version: string;
+    /** SQLite schema version expected by the last opener. */
+    schema_version: number;
+    /** ISO timestamp for bundle creation. */
+    created_at: string;
+    /** Hash algorithm used for content-addressed object IDs. */
+    hash_alg: 'blake3';
+    /** Default compression used for stored CAS payloads. */
+    default_compression: 'zstd';
+}
+/**
+ * Open bundle handle shared by core services.
+ *
+ * `path` is the resolved bundle root. `paths` contains all managed locations
+ * under that root, including SQLite, CAS/object storage, raw source copies,
+ * search indexes, and generated exports.
+ */
+interface Bundle {
+    /** Absolute bundle root path. */
+    path: string;
+    /** Open better-sqlite3 database handle for `prosa.sqlite`. */
+    db: Db;
+    /** Parsed bundle manifest metadata. */
+    manifest: BundleManifest;
+    /** Canonical absolute paths for bundle-managed files and directories. */
+    paths: {
+        /** SQLite database file. */
+        db: string;
+        /** Manifest JSON file. */
+        manifest: string;
+        /** Main CAS fanout directory. */
+        objects: string;
+        /** Raw preserved source-file directory. */
+        rawSources: string;
+        /** Search-related sidecar root. */
+        search: string;
+        /** Tantivy index directory. */
+        tantivy: string;
+        /** Generated export root. */
+        exports: string;
+        /** Default Parquet export directory. */
+        parquet: string;
+        /** Reserved lock-file path for future single-writer coordination. */
+        lock: string;
+    };
+}
+/** Store path exists or was requested, but no initialized bundle is available. */
+declare class BundleNotInitializedError extends Error {
+    readonly bundlePath: string;
+    readonly reason: 'missing-directory' | 'missing-manifest';
+    constructor(bundlePath: string, reason: 'missing-directory' | 'missing-manifest');
+}
+/**
+ * Resolve the default bundle root.
+ *
+ * `PROSA_STORE` wins when set; otherwise the local-first store lives in
+ * `~/.prosa`. The return value is absolute in both cases.
+ */
+declare function defaultBundlePath(): string;
+/**
+ * Create a fresh bundle at `rootPath`. Fails if the directory already contains
+ * a manifest (use openBundle for that case).
+ *
+ * Side effects: creates the bundle directory tree, writes `manifest.json`,
+ * opens `prosa.sqlite`, and applies all schema migrations. The caller owns the
+ * returned database handle and must close it via `closeBundle`.
+ */
+declare function initBundle(rootPath: string): Promise<Bundle>;
+/**
+ * Open an existing bundle. Applies pending migrations if the schema is older
+ * than the current code expects.
+ *
+ * Fails when the root is missing, lacks a manifest, or the migrated database
+ * version still does not match the code-time schema version. On success it may
+ * rewrite only manifest version metadata.
+ */
+declare function openBundle(rootPath: string): Promise<Bundle>;
+/**
+ * Open an existing bundle or transparently initialize one if the store path is
+ * missing or has not been initialized yet.
+ *
+ * Fails when `rootPath` exists but is not a directory. This is the CLI-friendly
+ * entrypoint for commands that should create the store on first use.
+ */
+declare function openOrInitBundle(rootPath: string): Promise<Bundle>;
+/**
+ * Close the SQLite handle associated with a bundle.
+ */
+declare function closeBundle(bundle: Bundle): void;
+
+/** Result returned after running schema migrations. */
+interface MigrationResult {
+    /** Migration versions applied during this call. */
+    applied: number[];
+}
+/**
+ * Apply all unapplied schema migrations and return the versions newly applied.
+ *
+ * The migrations table is created on demand. Each migration either fully
+ * applies with its bookkeeping row or rolls back through SQLite's transaction
+ * machinery; errors propagate to the caller.
+ */
+declare function runMigrations(db: Db): MigrationResult;
+/**
+ * Read the highest applied schema version from the database.
+ *
+ * Returns 0 for an uninitialized database or if migration metadata cannot be
+ * queried yet.
+ */
+declare function currentSchemaVersion(db: Db): number;
+
+/**
+ * Parser/projection version for normalized importer output.
+ *
+ * Bump when importer or normalizer semantics change in a way that can make
+ * existing canonical rows stale relative to preserved raw records. Stored on
+ * every `import_batches` row for future re-projection decisions.
+ */
+declare const PROSA_PARSER_VERSION: string;
+/**
+ * Current SQLite schema version, matching the highest migration in
+ * `src/core/schema`.
+ */
+declare const PROSA_SCHEMA_VERSION = 5;
+
+/**
+ * Source tools that have first-class importer support and stable schema
+ * semantics.
+ */
+declare const SOURCE_TOOLS: readonly ["cursor", "codex", "claude", "gemini", "hermes"];
+/**
+ * Normalized source-tool discriminator stored on source files, raw records,
+ * sessions, and analytics views.
+ */
+type SourceTool = (typeof SOURCE_TOOLS)[number];
+/**
+ * Confidence level for inferred timeline positions and recovered relations.
+ */
+type Confidence = 'high' | 'medium' | 'low';
+/**
+ * Canonical message role vocabulary used by the `messages.role` CHECK
+ * constraint. `operational` is reserved for runtime/system events that are not
+ * user-visible system prompts.
+ */
+type MessageRole = 'system_prompt' | 'developer' | 'user' | 'assistant' | 'tool' | 'operational';
+/**
+ * Coarse tool categories used for cross-importer aggregation while preserving
+ * the native tool name separately.
+ */
+type CanonicalToolType = 'shell' | 'read_file' | 'write_file' | 'edit_file' | 'search_file' | 'web_search' | 'mcp' | 'subagent' | 'patch' | 'other';
+/**
+ * Directed graph relationship vocabulary for `edges`, covering conversation
+ * lineage, tool call/result links, artifacts, and recovered equivalence.
+ */
+type EdgeType = 'parent_of' | 'calls' | 'returns' | 'spawned' | 'contains' | 'produced' | 'consumed' | 'derived_from' | 'summarizes' | 'compacts' | 'same_as' | 'refers_to';
+/**
+ * Importer-normalized lifecycle state for tool calls when the source format
+ * provides enough evidence to distinguish outcomes.
+ */
+type ToolCallStatus = 'started' | 'success' | 'error' | 'cancelled' | 'unknown';
+/**
+ * Complete row projection for the `sessions` table.
+ *
+ * Boolean flags are represented as SQLite integers and absent values are
+ * represented as `null` so callers can bind/read rows without conversion.
+ */
+interface SessionRowFull {
+    /** Canonical prosa session identifier. */
+    session_id: string;
+    /** Source tool that produced the session. */
+    source_tool: SourceTool;
+    /** Native session identifier from the source tool. */
+    source_session_id: string;
+    /** Canonical project identifier, when recovered. */
+    project_id: string | null;
+    /** Parent session identifier for subagent sessions. */
+    parent_session_id: string | null;
+    /** SQLite boolean indicating whether this session is a subagent. */
+    is_subagent: 0 | 1;
+    /** Source-specific role for a subagent. */
+    agent_role: string | null;
+    /** Display nickname for a subagent. */
+    agent_nickname: string | null;
+    /** Best recovered session title. */
+    title: string | null;
+    /** Best recovered session summary. */
+    summary: string | null;
+    /** Earliest recovered session timestamp. */
+    start_ts: string | null;
+    /** Latest recovered session timestamp. */
+    end_ts: string | null;
+    /** Initial working directory, when available. */
+    cwd_initial: string | null;
+    /** Initial git branch, when available. */
+    git_branch_initial: string | null;
+    /** First observed model name. */
+    model_first: string | null;
+    /** Last observed model name. */
+    model_last: string | null;
+    /** Source or importer session status. */
+    status: string | null;
+    /** Confidence in recovered timeline ordering. */
+    timeline_confidence: Confidence;
+    /** Raw record that introduced the session, when applicable. */
+    raw_record_id: string | null;
+}
+
+/**
+ * Stored object compression marker persisted in the `objects` table.
+ */
+type Compression = 'zstd' | 'none';
+
+/**
+ * Content-addressed object identifier stored as `blake3:<hex>`.
+ */
+type ObjectId = string;
+/**
+ * Complete metadata row for one object stored in the CAS.
+ *
+ * `storage_path` is relative to the bundle root and points at compressed or
+ * raw bytes depending on `compression`.
+ */
+interface ObjectMeta {
+    /** Canonical object identifier, formatted as `blake3:<hex>`. */
+    object_id: ObjectId;
+    /** Hash algorithm used to derive `hash` and `object_id`. */
+    hash_alg: 'blake3';
+    /** Raw BLAKE3 hex digest without the `blake3:` prefix. */
+    hash: string;
+    /** Original uncompressed payload size in bytes. */
+    size_bytes: number;
+    /** Stored compressed payload size, or null when stored uncompressed. */
+    compressed_size_bytes: number | null;
+    /** Compression algorithm used for the stored payload. */
+    compression: Compression;
+    /** Optional media type supplied by the writer. */
+    mime_type: string | null;
+    /** Optional text encoding supplied by the writer. */
+    encoding: string | null;
+    /** Bundle-relative path to the stored bytes. */
+    storage_path: string;
+    /** BLAKE3 hex digest of the bytes stored on disk and uploaded over sync. */
+    transport_hash: string | null;
+    /** ISO timestamp for the metadata row insertion. */
+    created_at: string;
+}
+/**
+ * Optional MIME and text-encoding metadata for newly stored CAS objects.
+ */
+interface PutOptions {
+    /** Optional media type to persist on the object metadata row. */
+    mimeType?: string;
+    /** Optional text encoding to persist on the object metadata row. */
+    encoding?: string;
+}
+/**
+ * Store raw bytes in the CAS. Returns the object_id. Idempotent: if the same
+ * content already exists, returns the existing object_id without rewriting.
+ *
+ * Bytes are compressed with zstd when worth it (see compress.ts threshold).
+ * The on-disk path is `<bundle>/objects/blake3/ab/cd/<hash>.zst`.
+ */
+declare function putBytes(bundle: Bundle, bytes: Uint8Array, options?: PutOptions): Promise<ObjectId>;
+/**
+ * Store UTF-8 text in the CAS with text metadata.
+ */
+declare function putText(bundle: Bundle, text: string, options?: {
+    mimeType?: string;
+}): Promise<ObjectId>;
+/**
+ * Store a JSON-serialized value in the CAS.
+ *
+ * Serialization is compact but not canonicalized; callers should not rely on
+ * object key ordering for cross-process identity unless the input itself is
+ * produced deterministically.
+ */
+declare function putJson(bundle: Bundle, value: unknown): Promise<ObjectId>;
+/**
+ * Read and decompress object bytes from the CAS.
+ *
+ * Throws when `objectId` is absent from the `objects` table; filesystem read or
+ * decompression errors also propagate because they indicate bundle corruption
+ * or inaccessible storage.
+ */
+declare function getBytes(bundle: Bundle, objectId: ObjectId): Promise<Buffer>;
+/**
+ * Read an object as UTF-8 text.
+ */
+declare function getText(bundle: Bundle, objectId: ObjectId): Promise<string>;
+/**
+ * Read an object as UTF-8 JSON and parse it as `T`.
+ */
+declare function getJson<T = unknown>(bundle: Bundle, objectId: ObjectId): Promise<T>;
+/**
+ * Look up object metadata without reading object bytes.
+ */
+declare function getObjectMeta(bundle: Bundle, objectId: ObjectId): ObjectMeta | null;
+
+/**
+ * In-memory representation of an `import_batches` row while a compile/import
+ * run is active.
+ *
+ * `finished_at` is populated only after `finishBatch` persists terminal status.
+ */
+interface ImportBatch {
+    /** Stable batch identifier derived from source and start time. */
+    batch_id: string;
+    /** Source importer for this batch, or null for multi-source orchestration. */
+    source_tool: SourceTool | null;
+    /** Parser version that produced this batch. */
+    parser_version: string;
+    /** Source roots or files covered by the batch. */
+    paths: string[];
+    /** ISO timestamp when the batch was created. */
+    started_at: string;
+    /** ISO timestamp set after terminal status is persisted. */
+    finished_at?: string;
+}
+/**
+ * Per-batch counters serialized into `import_batches.counts_json`.
+ *
+ * Counts describe importer work, not necessarily net-new durable rows; skipped
+ * source files and idempotent inserts are tracked explicitly.
+ */
+interface ImportCounts {
+    /** Source files discovered by the importer. */
+    source_files_seen: number;
+    /** Source files parsed and imported. */
+    source_files_imported: number;
+    /** Source files skipped by idempotency checks. */
+    source_files_skipped: number;
+    /** Raw source records preserved. */
+    raw_records: number;
+    /** Session rows inserted or updated. */
+    sessions: number;
+    /** Turn rows inserted or updated. */
+    turns: number;
+    /** Timeline event rows inserted or updated. */
+    events: number;
+    /** Message rows inserted or updated. */
+    messages: number;
+    /** Content block rows inserted or updated. */
+    content_blocks: number;
+    /** Tool call rows inserted or updated. */
+    tool_calls: number;
+    /** Tool result rows inserted or updated. */
+    tool_results: number;
+    /** Artifact rows inserted or updated. */
+    artifacts: number;
+    /** Edge rows inserted or updated. */
+    edges: number;
+    /** Import errors recorded for the batch. */
+    errors: number;
+}
+/**
+ * Create a zeroed counter object for a new import batch.
+ */
+declare function emptyCounts(): ImportCounts;
+/**
+ * Insert a running import batch and return its process-local handle.
+ *
+ * Batch IDs are intentionally unique per run so repeated compiles preserve
+ * their own audit trail even when all source rows are skipped idempotently.
+ */
+declare function startBatch(bundle: Bundle, sourceTool: SourceTool | null, paths: string[]): ImportBatch;
+/**
+ * Mark an import batch completed or failed and persist final counts.
+ */
+declare function finishBatch(bundle: Bundle, batch: ImportBatch, counts: ImportCounts, status: 'completed' | 'failed'): void;
+/**
+ * Record an importer error tied to an optional source file or raw record.
+ *
+ * Non-string payloads are preserved in the CAS as JSON and referenced from the
+ * error row; this keeps diagnostic detail out of inline SQLite columns while
+ * preserving it for later inspection.
+ */
+declare function recordError(bundle: Bundle, batchId: string, args: {
+    sourceFileId?: string | null;
+    rawRecordId?: string | null;
+    kind: string;
+    message: string;
+    payload?: unknown;
+}): Promise<void>;
+
+/**
+ * Complete `source_files` row used by source discovery and importer idempotency.
+ *
+ * Paths are absolute source paths. `object_id` points at preserved raw source
+ * bytes and may be backfilled for rows created before raw preservation existed.
+ */
+interface SourceFileRow {
+    /** Stable source file identifier. */
+    source_file_id: string;
+    /** Importer that discovered the file. */
+    source_tool: SourceTool;
+    /** Absolute path to the native source file. */
+    path: string;
+    /** Importer-specific file kind. */
+    file_kind: string;
+    /** File size observed during discovery. */
+    size_bytes: number;
+    /** Filesystem modification time as ISO text, when available. */
+    mtime: string | null;
+    /** SHA-256 content hash used for idempotency. */
+    content_hash: string;
+    /** CAS object ID for preserved raw bytes, if available. */
+    object_id: string | null;
+    /** ISO timestamp when the file was first registered. */
+    discovered_at: string;
+    /** Optional project/workspace hint derived during discovery. */
+    workspace_hint: string | null;
+}
+/**
+ * Result of source-file registration.
+ *
+ * `alreadyKnown` means the same path/content tuple was already registered and
+ * the caller can usually skip parsing/importing the file.
+ */
+interface RegisterResult {
+    /** Registered source file row. */
+    row: SourceFileRow;
+    /** True when the caller can usually skip parsing the file. */
+    alreadyKnown: boolean;
+}
+/**
+ * Idempotent registration of a source file. The natural key is
+ * (source_tool, path, size, mtime, content_hash). If a row with the same
+ * tuple already exists we return it untouched and the caller can skip
+ * re-importing. Otherwise we insert a new row.
+ *
+ * This is the cheapest form of idempotency: re-running `prosa compile` over
+ * the same Codex tree is a no-op (no rehash unless the file changed).
+ */
+declare function registerSourceFile(bundle: Bundle, args: {
+    sourceTool: SourceTool;
+    absolutePath: string;
+    fileKind: string;
+    workspaceHint?: string | null;
+}): Promise<RegisterResult>;
+
+/** Filters applied consistently to session list and count queries. */
+interface SessionListFilters {
+    /** Restrict results to one source tool. */
+    sourceTool?: SourceTool;
+    /** Inclusive lower bound for `start_ts`; unknown timestamps are retained. */
+    sinceIso?: string;
+    /** Exclusive upper bound for `start_ts`; unknown timestamps are retained. */
+    untilIso?: string;
+    /** Maximum rows to return, clamped by service limits. */
+    limit?: number;
+}
+/** Summary row returned by session listing surfaces. */
+interface SessionRow {
+    /** Canonical prosa session identifier. */
+    session_id: string;
+    /** Source tool that produced the session. */
+    source_tool: SourceTool;
+    /** Native source session identifier. */
+    source_session_id: string;
+    /** Canonical project identifier this session belongs to, when one was recovered. */
+    project_id: string | null;
+    /** Parent session for subagent sessions. */
+    parent_session_id: string | null;
+    /** SQLite boolean indicating whether this is a subagent session. */
+    is_subagent: 0 | 1;
+    /** Best recovered title. */
+    title: string | null;
+    /** Earliest recovered timestamp. */
+    start_ts: string | null;
+    /** Latest recovered timestamp. */
+    end_ts: string | null;
+    /** Initial working directory. */
+    cwd_initial: string | null;
+    /** Initial git branch. */
+    git_branch_initial: string | null;
+    /** First observed model. */
+    model_first: string | null;
+    /** Last observed model. */
+    model_last: string | null;
+    /** Source or importer status. */
+    status: string | null;
+    /** Confidence in recovered timeline ordering. */
+    timeline_confidence: Confidence;
+    /** Number of messages attached to the session. */
+    message_count: number;
+    /** Number of tool calls attached to the session. */
+    tool_call_count: number;
+}
+/** Lists sessions newest-first, preserving rows with unknown timestamps at the end. */
+declare function listSessions(bundle: Bundle, filters?: SessionListFilters): SessionRow[];
+/** Counts sessions using the same filter policy as {@link listSessions}. */
+declare function countSessions(bundle: Bundle, filters?: SessionListFilters): number;
+/** Timeline event row used by session detail views. */
+interface SessionDetailEvent {
+    /** Timeline ordinal within the session. */
+    ordinal: number;
+    /** Event timestamp when known. */
+    timestamp: string | null;
+    /** Canonical event type. */
+    event_type: string;
+    /** Native source event type, when retained. */
+    source_type: string | null;
+    /** Source-specific event subtype. */
+    subtype: string | null;
+    /** Actor associated with the event. */
+    actor: string | null;
+    /** Message row attached to the event. */
+    message_id: string | null;
+    /** Message role attached to the event. */
+    role: string | null;
+    /** Tool name attached to the event. */
+    tool_name: string | null;
+    /** SQLite boolean indicating a failed tool result. */
+    is_error: 0 | 1 | null;
+    /** Human-sized preview for detail rendering. */
+    preview: string | null;
+}
+/** Full session detail with summary metadata and ordered timeline events. */
+interface SessionDetail {
+    /** Session summary row. */
+    session: SessionRow;
+    /** Ordered timeline events. */
+    events: SessionDetailEvent[];
+}
+/** Returns a single session with its event timeline, or null when absent. */
+declare function getSession(bundle: Bundle, sessionId: string): SessionDetail | null;
+
+/** Supported search backends tracked by the bundle. */
+type SearchEngine = 'fts5' | 'tantivy';
+/** Persisted status row for a search index sidecar. */
+interface SearchIndexStatus {
+    /** Search backend represented by this status row. */
+    engine: SearchEngine;
+    /** Current index lifecycle state. */
+    status: 'missing' | 'ready' | 'stale' | 'building' | 'failed';
+    /** Number of canonical search_docs rows available to index. */
+    source_doc_count: number;
+    /** Number of documents known to be present in the index. */
+    indexed_doc_count: number;
+    /** ISO timestamp for the last status update. */
+    updated_at: string;
+    /** Last build error message, if the index failed. */
+    error_message: string | null;
+    /** Last indexed SQLite rowid for incremental sidecars. */
+    last_indexed_rowid: number | null;
+    /** Schema fingerprint used to decide whether incremental rebuild is valid. */
+    schema_fingerprint: string | null;
+}
+/** Enables incremental FTS5 maintenance after bulk rebuilds or imports. */
+declare function enableFts5Triggers(bundle: Bundle): void;
+/** Disables FTS5 maintenance triggers while import code performs bulk writes. */
+declare function disableFts5Triggers(bundle: Bundle): void;
+/** Returns status rows for all known search engines, creating defaults if absent. */
+declare function getSearchIndexStatuses(bundle: Bundle): SearchIndexStatus[];
+/** Returns the status row for one search engine, or null only if initialization failed. */
+declare function getSearchIndexStatus(bundle: Bundle, engine: SearchEngine): SearchIndexStatus | null;
+/** Marks derived search indexes stale after canonical search_docs changed. */
+declare function markIndexesAfterImport(bundle: Bundle, options: {
+    changed: boolean;
+}): void;
+/** Fully rebuilds the SQLite FTS5 index from search_docs and records status. */
+declare function rebuildFts5Index(bundle: Bundle): SearchIndexStatus;
+/** Options controlling Tantivy sidecar rebuild behavior. */
+interface RebuildTantivyOptions {
+    /**
+     * Force a full re-index even when an incremental run would be valid.
+     * Surfaced by the `--overwrite` flag on `prosa index tantivy` and on
+     * `prosa compile`.
+     */
+    overwrite?: boolean;
+}
+/** Rebuilds the Tantivy sidecar, using an incremental append path when valid. */
+declare function rebuildTantivyIndex(bundle: Bundle, options?: RebuildTantivyOptions): Promise<SearchIndexStatus>;
+
+/** Search result projected from either FTS5 or Tantivy into the common service shape. */
+interface SearchHit {
+    /** Search document identifier. */
+    doc_id: string;
+    /** Indexed entity kind. */
+    entity_type: string;
+    /** Identifier of the indexed entity. */
+    entity_id: string;
+    /** Session that owns the document, when applicable. */
+    session_id: string | null;
+    /** Timestamp used for result ordering. */
+    timestamp: string | null;
+    /** Message role associated with the document. */
+    role: string | null;
+    /** Tool name associated with the document. */
+    tool_name: string | null;
+    /** Indexed text field category. */
+    field_kind: string;
+    /** Highlighted or truncated result snippet. */
+    snippet: string;
+}
+/** Options for full-text search across indexed conversation and tool evidence. */
+interface SearchOptions {
+    /** Query text, interpreted by the selected engine. */
+    query: string;
+    /** Maximum hit count, clamped by service limits. */
+    limit?: number;
+    /** Search backend to query; defaults to FTS5. */
+    engine?: SearchEngine;
+    /**
+     * When true, pass `query` straight to FTS5 (MATCH expression). When false
+     * (default), each whitespace-delimited token is wrapped in double quotes so
+     * punctuation like `package.json` doesn't trip the FTS5 parser. Set true if
+     * you want to use FTS5 operators like `OR`, `NEAR`, prefixes, etc.
+     */
+    raw?: boolean;
+}
+/** Runs full-text search with FTS5 by default, or Tantivy when requested. */
+declare function searchFullText(bundle: Bundle, options: SearchOptions): SearchHit[];
+
+/** Minimal structured logger surface used by importers while compiling source files. */
+type CompileLogger = Pick<Logger, 'child' | 'debug' | 'error' | 'info' | 'warn'>;
+/** Shared options accepted by every importer compile entrypoint. */
+interface CompileOptions {
+    /** Optional logger for batch, file discovery, skip, and per-file failure events. */
+    logger?: CompileLogger;
+}
+
+/** Importer result shape normalized for compile orchestration. */
+interface CompileResult$4 {
+    /** Import batch created by the provider. */
+    batch: ImportBatch;
+    /** Final provider import counts. */
+    counts: ImportCounts;
+}
+/** Configures one source-tool importer for the compile service. */
+interface CompileProviderConfig {
+    /** Source tool handled by this provider. */
+    name: SourceTool;
+    /** Human-readable provider description. */
+    description: string;
+    /** Help text describing the expected root path. */
+    pathHelp: string;
+    /** Default native history location for this provider. */
+    defaultSessionsPath: () => string;
+    /** Provider compile implementation. */
+    compile: (bundle: Bundle, root: string, options?: CompileOptions) => Promise<CompileResult$4>;
+}
+/** Per-provider summary emitted after an importer finishes. */
+interface ProviderCompileSummary {
+    /** Source tool that completed. */
+    source: SourceTool;
+    /** Resolved source path compiled by the provider. */
+    sourcePath: string;
+    /** Batch identifier for this provider run. */
+    batchId: string;
+    /** Import batch metadata. */
+    batch: ImportBatch;
+    /** Final import counts. */
+    counts: ImportCounts;
+}
+/** Summary emitted after a Tantivy rebuild completes during compile. */
+interface TantivyCompileSummary {
+    /** Documents present in the rebuilt Tantivy index. */
+    indexedDocCount: number;
+}
+/** Aggregate result for a compile import run across one or more providers. */
+interface CompileImportSummary {
+    /** Per-provider summaries in execution order. */
+    providers: ProviderCompileSummary[];
+    /** True when at least one source file was imported. */
+    importedAny: boolean;
+    /** Tantivy rebuild summary, if it completed. */
+    tantivy: TantivyCompileSummary | null;
+    /** Tantivy rebuild error message, if rebuild failed but compile continued. */
+    tantivyError: string | null;
+    /** FTS5 rebuild error message, if rebuild failed but compile continued. */
+    fts5Error: string | null;
+}
+/** Summary returned after compile-triggered Parquet export. */
+interface ParquetCompileSummary {
+    /** Directory containing generated Parquet files. */
+    outDir: string;
+    /** Path to the generated export manifest. */
+    manifestPath: string;
+    /** Number of exported canonical tables. */
+    tableCount: number;
+    /** Absolute output file path by table. */
+    files: Record<string, string>;
+    /** Row count by table. */
+    counts: Record<string, number>;
+}
+/** Options for running compile imports across configured providers. */
+interface CompileImportOptions {
+    /** Open bundle to import into. */
+    bundle: Bundle;
+    /** Providers to run in order. */
+    providers: CompileProviderConfig[];
+    /** Optional override for every provider's default source path. */
+    sessionsPath?: string;
+    /**
+     * Force a full rebuild of derived indexes after import. Tantivy is the
+     * only sidecar with an incremental path today, so this currently flips
+     * Tantivy to a from-scratch rebuild; FTS5 and Parquet are always
+     * full-rewrite. Surfaced by `prosa compile … --overwrite`.
+     */
+    overwrite?: boolean;
+    /** Optional structured logger. */
+    logger?: CompileLogger;
+    /** Callback invoked after each provider completes. */
+    onProviderComplete?: (summary: ProviderCompileSummary) => void;
+    /** Callback invoked after Tantivy rebuild completes. */
+    onTantivyComplete?: (summary: TantivyCompileSummary) => void;
+}
+/** Options for compile's Parquet export step. */
+interface ExportCompileParquetOptions {
+    /** Bundle root whose canonical tables should be exported. */
+    storePath: string;
+    /** Optional structured logger. */
+    logger?: CompileLogger;
+}
+/** Built-in compile providers and their default history locations. */
+declare const COMPILE_PROVIDERS: CompileProviderConfig[];
+/** Resolves a compile provider by source tool, throwing for unsupported names. */
+declare function getCompileProvider(source: SourceTool): CompileProviderConfig;
+/** Expands shell-style home paths and resolves compile paths to absolutes. */
+declare function resolveCompilePath(p: string, basePath?: string): string;
+/** Runs provider imports and refreshes derived search indexes when data changed. */
+declare function runCompileImports(options: CompileImportOptions): Promise<CompileImportSummary>;
+/** Exports the compiled bundle to Parquet using compile command path semantics. */
+declare function exportCompileParquet(options: ExportCompileParquetOptions): Promise<ParquetCompileSummary>;
+
+/** Canonical SQLite tables exported as one Parquet file per table. */
+declare const PARQUET_TABLES: readonly ["objects", "source_files", "import_batches", "raw_records", "import_errors", "uncertainties", "projects", "sessions", "turns", "events", "messages", "content_blocks", "tool_calls", "tool_results", "artifacts", "edges", "search_docs"];
+/** Derived analytics views recreated in DuckDB alongside exported tables. */
+declare const ANALYTICS_VIEWS: readonly ["session_facts", "tool_usage_facts", "error_facts", "model_usage", "project_activity"];
+/** Exportable canonical table name. */
+type ParquetTable = (typeof PARQUET_TABLES)[number];
+/** DuckDB analytics view name exposed over exported Parquet data. */
+type AnalyticsView = (typeof ANALYTICS_VIEWS)[number];
+/** Options for exporting a bundle's canonical tables to Parquet. */
+interface ParquetExportOptions {
+    /** Bundle root to open and export. */
+    bundlePath: string;
+    /** Output directory; defaults to the bundle's parquet directory. */
+    outDir?: string;
+}
+/** Result metadata for a Parquet export operation. */
+interface ParquetExportResult {
+    /** Directory containing generated Parquet files. */
+    outDir: string;
+    /** Path to the generated manifest JSON. */
+    manifestPath: string;
+    /** Absolute Parquet file path by canonical table. */
+    files: Record<ParquetTable, string>;
+    /** Exported row count by canonical table. */
+    counts: Record<ParquetTable, number>;
+}
+/** Options for querying exported Parquet files through DuckDB. */
+interface DuckDbQueryOptions {
+    /** Directory containing exported Parquet files. */
+    parquetDir: string;
+    /** SQL query to run after table and analytics views are created. */
+    sql: string;
+}
+/** Column-oriented query result shape returned by analytics services. */
+interface DuckDbQueryResult {
+    /** Result column names in DuckDB output order. */
+    columns: string[];
+    /** Result rows as plain JSON-compatible objects. */
+    rows: Record<string, unknown>[];
+}
+/** Exports canonical bundle tables to Parquet and writes a manifest. */
+declare function exportBundleParquet(options: ParquetExportOptions): Promise<ParquetExportResult>;
+/** Queries Parquet exports after creating table and analytics views in DuckDB. */
+declare function queryDuckDbParquet(options: DuckDbQueryOptions): Promise<DuckDbQueryResult>;
+
+/** Stable report names exposed by CLI and MCP analytics surfaces. */
+declare const ANALYTICS_REPORTS: readonly ["sessions", "tools", "errors", "models", "projects"];
+/** Analytics report identifier. */
+type AnalyticsReport = (typeof ANALYTICS_REPORTS)[number];
+/** SQL dialects supported by the analytics query builder. */
+type AnalyticsDialect = 'sqlite' | 'duckdb';
+/** Cross-report filters accepted by analytics read surfaces. */
+interface AnalyticsReportFilters {
+    /** Source tool filter. */
+    source?: string;
+    /** Inclusive lower time bound for report-specific timestamps. */
+    since?: string;
+    /** Exclusive upper time bound for report-specific timestamps. */
+    until?: string;
+    /** Maximum row count, clamped by service limits. */
+    limit?: number;
+    /** Native tool name filter for tool/error reports. */
+    toolName?: string;
+    /** Canonical tool category filter. */
+    canonicalType?: string;
+    /** Restrict tool/error reports to failed operations. */
+    errorsOnly?: boolean;
+    /** Error category filter. */
+    category?: string;
+    /** Model name filter. */
+    model?: string;
+    /** Project name filter. */
+    project?: string;
+    /** Canonical session identifier filter. */
+    sessionId?: string;
+    /** Source file path substring filter. */
+    sourcePathSubstring?: string;
+}
+/** Options for running an analytics report against exported Parquet files. */
+interface AnalyticsReportOptions {
+    /** Directory containing exported Parquet tables. */
+    parquetDir: string;
+    /** Report to run. */
+    report: AnalyticsReport;
+    /** Optional report filters. */
+    filters?: AnalyticsReportFilters;
+}
+/** Options for running an analytics report directly against a SQLite bundle. */
+interface AnalyticsBundleReportOptions {
+    /** Open bundle queried through SQLite analytics views. */
+    bundle: Bundle;
+    /** Report to run. */
+    report: AnalyticsReport;
+    /** Optional report filters. */
+    filters?: AnalyticsReportFilters;
+}
+/** Runs a fixed analytics report over DuckDB views backed by Parquet exports. */
+declare function runAnalyticsReport(options: AnalyticsReportOptions): Promise<DuckDbQueryResult>;
+/** Runs the same fixed analytics reports against SQLite analytics views. */
+declare function runAnalyticsReportFromBundle(options: AnalyticsBundleReportOptions): DuckDbQueryResult;
+
+/** Severity/status emitted by an individual doctor check. */
+type CheckStatus = 'pass' | 'info' | 'warn' | 'fail' | 'skipped';
+/** One diagnostic result produced by doctor. */
+interface CheckResult {
+    check: string;
+    status: CheckStatus;
+    message: string;
+    hint?: string;
+    details?: Record<string, unknown>;
+}
+/** Complete doctor run result, including filtered checks and status counts. */
+interface DoctorReport {
+    storePath: string;
+    bundleOpened: boolean;
+    checks: CheckResult[];
+    summary: {
+        pass: number;
+        info: number;
+        warn: number;
+        fail: number;
+        skipped: number;
+        duration_ms: number;
+    };
+}
+/** Options controlling bundle selection, deep checks, and check filtering. */
+interface DoctorOptions {
+    storePath?: string;
+    deep?: boolean;
+    deepSample?: number;
+    /** Dotted prefixes or exact check names to include. Empty/undefined = all. */
+    checks?: string[];
+}
+/**
+ * Return true when freelist waste crosses the vacuum-recommendation threshold.
+ * Pure so the threshold logic is unit-testable without a fixture bundle.
+ */
+declare function shouldRecommendVacuum(freelistCount: number, pageCount: number, thresholdPct?: number): boolean;
+/**
+ * Audit a bundle's health. Tolerates open failures: when `openBundle` throws
+ * (missing manifest, schema mismatch, corrupt sqlite), doctor still produces
+ * a report — the bundle-layout / schema checks fire and the rest are marked
+ * `skipped`. Doctor never throws on bundle problems; only catastrophic errors
+ * inside the check engine propagate.
+ */
+declare function runDoctor(opts?: DoctorOptions): Promise<DoctorReport>;
+
+/** Entity kinds surfaced by tool-call history queries. */
+type ToolCallEntity = 'tool_call' | 'artifact';
+/** Tool-call or artifact evidence row returned by file and command history queries. */
+interface ToolCallEvidence {
+    /** Whether this row describes a tool call or a matching artifact. */
+    entity_type: ToolCallEntity;
+    /** Session that owns the evidence. */
+    session_id: string | null;
+    /** Tool call identifier when `entity_type` is `tool_call`. */
+    tool_call_id: string | null;
+    /** Artifact identifier when `entity_type` is `artifact`. */
+    artifact_id: string | null;
+    /** Native tool name. */
+    tool_name: string | null;
+    /** Canonical tool category. */
+    canonical_tool_type: string | null;
+    /** Command text, when the tool represents shell execution. */
+    command: string | null;
+    /** File path associated with the tool call or artifact. */
+    path: string | null;
+    /** Normalized tool call status. */
+    status: string | null;
+    /** Tool call start timestamp or artifact creation timestamp. */
+    timestamp_start: string | null;
+    /** SQLite boolean indicating an error result. */
+    is_error: 0 | 1 | null;
+    /** Process exit code when available. */
+    exit_code: number | null;
+    /** Human-sized result preview. */
+    preview: string | null;
+}
+/** Filters for tool-call history and file-history queries. */
+interface ToolCallFilters {
+    /** Restrict evidence to one session. */
+    sessionId?: string;
+    /** Restrict evidence to a native tool name. */
+    toolName?: string;
+    /** Restrict evidence to a canonical tool category. */
+    canonicalType?: string;
+    /** Match paths on tool calls and artifacts. */
+    pathSubstring?: string;
+    /** Include only tool calls with error evidence. */
+    errorsOnly?: boolean;
+    /** Inclusive lower bound for tool timestamps. */
+    sinceIso?: string;
+    /** Exclusive upper bound for tool timestamps. */
+    untilIso?: string;
+    /** Maximum rows to return, clamped by service limits. */
+    limit?: number;
+}
+/** Lists tool-call evidence, including artifacts when filtering by path substring. */
+declare function listToolCalls(bundle: Bundle, filters?: ToolCallFilters): ToolCallEvidence[];
+
+/**
+ * Render a session into Markdown. Big tool outputs aren't dumped inline:
+ * we show a preview line plus a `[object: blake3:…]` reference, leaving the
+ * raw bytes in the CAS for downstream tools.
+ *
+ * Built on top of {@link loadTranscript} so the CLI's `session show --format
+ * markdown` path and `prosa export session --format markdown` share one
+ * resolution pipeline (inline + CAS text + tool result preview).
+ */
+declare function exportSessionMarkdown(bundle: Bundle, sessionId: string): Promise<string>;
+
+/** Matched `tool_results` row attached to its owning `TranscriptToolCall`. */
+interface TranscriptToolResult {
+    toolResultId: string;
+    status: string | null;
+    isError: boolean;
+    exitCode: number | null;
+    durationMs: number | null;
+    preview: string | null;
+    /** Full stdout, if any, is in CAS; pass-through id so renderers can fetch on demand. */
+    stdoutObjectId: string | null;
+    /** Full stderr, if any, is in CAS; pass-through id so renderers can fetch on demand. */
+    stderrObjectId: string | null;
+    /** Full output, if any, is in CAS; pass-through id so renderers can fetch on demand. */
+    outputObjectId: string | null;
+}
+/** Tool invocation rendered alongside its owning turn (or as unattached). */
+interface TranscriptToolCall {
+    toolCallId: string;
+    toolName: string;
+    canonicalToolType: string | null;
+    /** Resolved args JSON text when ≤ maxArgsInlineBytes; otherwise null. */
+    argsInline: string | null;
+    /** Source CAS id for args. Kept so renderers can fetch on demand. */
+    argsObjectId: string | null;
+    command: string | null;
+    path: string | null;
+    status: string | null;
+    timestampStart: string | null;
+    result: TranscriptToolResult | null;
+}
+/** One content block in a message: text, thinking, tool_use, tool_result, etc. */
+interface TranscriptBlock {
+    blockId: string;
+    blockType: 'text' | 'thinking' | 'tool_use' | 'tool_result' | string;
+    /** Resolved inline OR fetched from CAS when ≤ maxInlineBytes. Null for oversize. */
+    text: string | null;
+    /** Source CAS id for text. Kept so renderers can fetch oversized blobs on demand. */
+    textObjectId: string | null;
+    /** Mirrors `content_blocks.visibility = 'hidden_by_default'`. */
+    hidden: boolean;
+    mimeType: string | null;
+    isError: boolean;
+}
+/** One conversational turn: a message plus its blocks and outbound tool calls. */
+interface TranscriptTurn {
+    messageId: string;
+    ordinal: number;
+    role: 'system_prompt' | 'developer' | 'user' | 'assistant' | 'tool' | 'operational';
+    model: string | null;
+    timestamp: string | null;
+    blocks: TranscriptBlock[];
+    toolCalls: TranscriptToolCall[];
+}
+/** Full structured transcript for one session. */
+interface SessionTranscript {
+    session: SessionRow;
+    turns: TranscriptTurn[];
+    /** Tool calls whose `message_id` is NULL (legacy / event-only imports). */
+    unattachedToolCalls: TranscriptToolCall[];
+}
+/** Options controlling how aggressively the loader inlines CAS-backed text. */
+interface LoadTranscriptOptions {
+    /** Maximum UTF-8 byte size to inline a block's text. Default 64KB. */
+    maxInlineBytes?: number;
+    /** Maximum UTF-8 byte size to inline a tool-call's args JSON. Default 8KB. */
+    maxArgsInlineBytes?: number;
+}
+/**
+ * Assemble a session's full conversation — messages, content blocks, and tool
+ * calls with matched results — from the local bundle SQLite. Returns null
+ * when the session is absent (callers handle "not found" themselves).
+ *
+ * Text bodies are resolved inline when small enough; oversize bodies surface
+ * only as `textObjectId`/`argsObjectId` so renderers can fetch on demand.
+ */
+declare function loadTranscript(bundle: Bundle, sessionId: string, options?: LoadTranscriptOptions): Promise<SessionTranscript | null>;
+/**
+ * Resolve a block's printable text. Returns null when neither inline nor CAS
+ * has a body; returns null `text` (but keeps `textObjectId`) when the CAS
+ * blob exceeds `maxInlineBytes` so renderers can fetch on demand.
+ *
+ * Exported so the markdown exporter can share the same resolution path.
+ */
+declare function resolveBlockText(bundle: Bundle, block: {
+    text_inline: string | null;
+    text_object_id: string | null;
+}, maxInlineBytes?: number): Promise<{
+    text: string | null;
+    textObjectId: string | null;
+    unavailable: boolean;
+}>;
+/**
+ * Resolve a tool call's args JSON. Returns null when the blob is missing or
+ * exceeds `maxBytes`; the caller keeps the object id for "show full" UX.
+ *
+ * Exported so the markdown exporter can share the same resolution path.
+ */
+declare function resolveArgsText(bundle: Bundle, argsObjectId: ObjectId | null, maxBytes?: number): Promise<string | null>;
+
+/** Options controlling the textual transcript rendering. */
+interface FormatTranscriptTextOptions {
+    /** When true, thinking blocks are rendered in full. Default false. */
+    showThinking?: boolean;
+    /** Max preview/output lines to keep per tool result; over-long output is truncated. */
+    maxOutputLines?: number;
+    /**
+     * Accepted for source-compat with prior releases. Ignored: this formatter
+     * always emits plain text (no ANSI escapes) so piped output stays clean.
+     * Callers that want colored interactive output should use Ink directly
+     * (apps/cli ships `renderTranscriptInk`).
+     */
+    color?: boolean;
+}
+/**
+ * Render a `SessionTranscript` as plaintext. Output is always ANSI-free so it
+ * round-trips through pipes (`prosa session show --format text > file.txt`).
+ *
+ * Layout: a metadata header (title, ids, models, confidence), then one section
+ * per turn with a role header and inline blocks/tool-call summaries. Thinking
+ * blocks collapse to one line by default; tool outputs truncate at
+ * `maxOutputLines` and surface CAS object ids for full retrieval downstream.
+ */
+declare function formatTranscriptText(transcript: SessionTranscript, options?: FormatTranscriptTextOptions): string;
+
+/** Result returned after a Codex compile batch finishes or records a failed batch. */
+interface CompileResult$3 {
+    /** Import batch created for this Codex run. */
+    batch: ImportBatch;
+    /** Final counts accumulated while importing Codex files. */
+    counts: ImportCounts;
+}
+/** Compile Codex JSONL session files under `root` into the bundle. */
+declare function compileCodex(bundle: Bundle, root: string, options?: CompileOptions): Promise<CompileResult$3>;
+
+/** Result returned after a Claude compile batch finishes or records a failed batch. */
+interface CompileResult$2 {
+    /** Import batch created for this Claude run. */
+    batch: ImportBatch;
+    /** Final counts accumulated while importing Claude files. */
+    counts: ImportCounts;
+}
+/** Compile Claude Code JSONL files under `root` into the bundle. */
+declare function compileClaude(bundle: Bundle, root: string, options?: CompileOptions): Promise<CompileResult$2>;
+
+/** Result returned after a Gemini compile batch finishes or records a failed batch. */
+interface CompileResult$1 {
+    /** Import batch created for this Gemini run. */
+    batch: ImportBatch;
+    /** Final counts accumulated while importing Gemini files. */
+    counts: ImportCounts;
+}
+/** Compile Gemini CLI chat snapshot files under `root` into the bundle. */
+declare function compileGemini(bundle: Bundle, root: string, options?: CompileOptions): Promise<CompileResult$1>;
+
+/** Result returned after a Cursor compile batch finishes or records a failed batch. */
+interface CompileResult {
+    /** Import batch created for this Cursor run. */
+    batch: ImportBatch;
+    /** Final counts accumulated while importing Cursor stores. */
+    counts: ImportCounts;
+}
+/** Compile Cursor `store.db` files under `root` into the bundle. */
+declare function compileCursor(bundle: Bundle, root: string, options?: CompileOptions): Promise<CompileResult>;
+
+/** System instructions advertised by the MCP server to guide evidence-first use of prosa tools. */
+declare const PROSA_MCP_INSTRUCTIONS: string;
+
+/** HTTP transport options for exposing a prosa bundle as an MCP server. */
+interface McpServerOptions {
+    /** Hostname or IP address to bind. */
+    host: string;
+    /** TCP port to bind. */
+    port: number;
+    /** HTTP path that receives MCP Streamable HTTP requests. Defaults to `/mcp`. */
+    path?: string;
+    /** Default search engine passed to MCP search tools. */
+    searchEngine?: SearchEngine;
+    /** Bundle path reopened by long-lived tool handlers. Defaults to `bundle.path`. */
+    storePath?: string;
+}
+/** Handle returned by the HTTP MCP server listener. */
+interface RunningServer {
+    /** Full URL clients should use for Streamable HTTP requests. */
+    url: string;
+    /** Stop the HTTP listener and close all active MCP sessions. */
+    close(): Promise<void>;
+}
+/** Handle returned by the stdio MCP server listener. */
+interface RunningStdioServer {
+    /** Close the MCP server and stdio transport. */
+    close(): Promise<void>;
+}
+/** Stdio transport options for exposing a prosa bundle as an MCP server. */
+interface McpStdioServerOptions {
+    /** Default search engine passed to MCP search tools. */
+    searchEngine?: SearchEngine;
+    /** Bundle path reopened by long-lived tool handlers. Defaults to `bundle.path`. */
+    storePath?: string;
+}
+/** Start a stdio MCP server backed by an already-open prosa bundle. */
+declare function listenMcpStdioServer(bundle: Bundle, options?: McpStdioServerOptions): Promise<RunningStdioServer>;
+/**
+ * Bind an HTTP MCP server on `host:port` backed by `bundle`. Implements the
+ * Streamable HTTP transport with stateful sessions (one McpServer per
+ * `MCP-Session-Id`).
+ *
+ * - POST /mcp   — JSON-RPC requests; opens a session if `MCP-Session-Id` is missing
+ * - DELETE /mcp — close an existing session by header
+ * - GET /mcp    — 405 (we don't expose server-initiated SSE streams)
+ */
+declare function listenMcpServer(bundle: Bundle, options: McpServerOptions): Promise<RunningServer>;
+
+/** Options that tune how registered MCP tools open bundles and choose search backends. */
+interface ProsaToolOptions {
+    /** Default search engine used when a `search` tool call does not specify one. */
+    searchEngine?: SearchEngine;
+    /** Store path to reopen for each tool call when `ensureStore` is enabled. */
+    storePath?: string;
+    /** Reopen or initialize the bundle per call instead of reusing the startup handle. */
+    ensureStore?: boolean;
+}
+/**
+ * Register the six prosa MCP tools on `server`. Five are read-only; `compile`
+ * is dual-mode (no args = bundle status snapshot, with args = mutating import).
+ */
+declare function registerProsaTools(server: McpServer, bundle: Bundle, options?: ProsaToolOptions): void;
+
+export { ANALYTICS_REPORTS, ANALYTICS_VIEWS, type AnalyticsBundleReportOptions, type AnalyticsDialect, type AnalyticsReport, type AnalyticsReportFilters, type AnalyticsReportOptions, type AnalyticsView, type Bundle, type BundleManifest, BundleNotInitializedError, COMPILE_PROVIDERS, type CanonicalToolType, type CheckResult, type CheckStatus, type CompileResult$2 as ClaudeCompileResult, type CompileResult$3 as CodexCompileResult, type CompileImportOptions, type CompileImportSummary, type CompileLogger, type CompileOptions, type CompileProviderConfig, type CompileResult$4 as CompileResult, type Compression, type Confidence, type CompileResult as CursorCompileResult, type DoctorOptions, type DoctorReport, type DuckDbQueryOptions, type DuckDbQueryResult, type EdgeType, type ExportCompileParquetOptions, type FormatTranscriptTextOptions, type CompileResult$1 as GeminiCompileResult, type ImportBatch, type ImportCounts, type LoadTranscriptOptions, type McpServerOptions, type McpStdioServerOptions, type MessageRole, type MigrationResult, type ObjectId, type ObjectMeta, PARQUET_TABLES, PROSA_MCP_INSTRUCTIONS, PROSA_PARSER_VERSION, PROSA_SCHEMA_VERSION, type ParquetCompileSummary, type ParquetExportOptions, type ParquetExportResult, type ParquetTable, type ProsaToolOptions, type ProviderCompileSummary, type PutOptions, type RebuildTantivyOptions, type RegisterResult, type RunningServer, type RunningStdioServer, SOURCE_TOOLS, type SearchEngine, type SearchHit, type SearchIndexStatus, type SearchOptions, type SessionDetail, type SessionDetailEvent, type SessionListFilters, type SessionRow, type SessionRowFull, type SessionTranscript, type SourceFileRow, type SourceTool, type TantivyCompileSummary, type ToolCallEntity, type ToolCallEvidence, type ToolCallFilters, type ToolCallStatus, type TranscriptBlock, type TranscriptToolCall, type TranscriptToolResult, type TranscriptTurn, closeBundle, compileClaude, compileCodex, compileCursor, compileGemini, countSessions, currentSchemaVersion, defaultBundlePath, disableFts5Triggers, emptyCounts, enableFts5Triggers, exportBundleParquet, exportCompileParquet, exportSessionMarkdown, finishBatch, formatTranscriptText, getBytes, getCompileProvider, getJson, getObjectMeta, getSearchIndexStatus, getSearchIndexStatuses, getSession, getText, initBundle, listSessions, listToolCalls, listenMcpServer, listenMcpStdioServer, loadTranscript, markIndexesAfterImport, openBundle, openOrInitBundle, putBytes, putJson, putText, queryDuckDbParquet, rebuildFts5Index, rebuildTantivyIndex, recordError, registerProsaTools, registerSourceFile, resolveArgsText, resolveBlockText, resolveCompilePath, runAnalyticsReport, runAnalyticsReportFromBundle, runCompileImports, runDoctor, runMigrations, searchFullText, shouldRecommendVacuum, startBatch };