@pella-labs/pinakes 0.1.0

package/dist/db/schema.d.ts

@@ -0,0 +1,990 @@
+/**
+ * KG-MCP Drizzle schema (presearch.md §2.3, CLAUDE.md §Database Rules).
+ *
+ * 8 logical tables + `kg_meta` for schema versioning. Two of the eight are
+ * virtual tables (`kg_chunks_fts`, `kg_chunks_vec`) that drizzle-kit can't
+ * model — they're created via raw SQL appended to the initial migration in
+ * src/db/migrations. The drizzle code below covers the 7 regular tables
+ * plus kg_meta.
+ *
+ * Invariants this schema MUST preserve:
+ *
+ * - `kg_nodes.id` is `sha1(scope + ':' + source_uri + ':' + section_path)`,
+ *   set by the ingester (NOT auto-generated). Re-ingesting the same
+ *   markdown produces identical ids — Phase 2's idempotent upsert relies
+ *   on this. The DB never sees the hashing logic; it just stores the value
+ *   and enforces uniqueness via the PK.
+ *
+ * - `kg_chunks.id` is `sha1(node_id + ':' + chunk_index)`, same idea.
+ *
+ * - `chunk_sha = sha1(chunk_text)` is the LOAD-BEARING field for the
+ *   per-chunk skip-unchanged optimization (CLAUDE.md §Database Rules #3,
+ *   Loop 6.5 A4). On a Pharos wiki-updater whole-file rewrite we look up
+ *   the existing chunk_shas for the file's nodes and only re-embed chunks
+ *   whose sha changed. Without this, every turn re-embeds 60 chunks ×
+ *   ~50ms = 3s of blocking work that competes with the active coding LLM
+ *   for Ollama. Do not remove this column.
+ *
+ * - `last_accessed_at` on `kg_nodes` exists for the Phase 5 personal-KG
+ *   LRU eviction (Loop 6.5 A2). Phase 2 just stamps it on insert/update.
+ *
+ * - `source_sha` on `kg_nodes` is the file-level hash; staleness detection
+ *   on the query path compares this against the current on-disk hash.
+ *
+ * - All FK relationships use `ON DELETE CASCADE` so deleting a node cleans
+ *   up its chunks and edges in one statement (verified by schema test #5).
+ *   Foreign keys are enforced via PRAGMA foreign_keys=ON, mandatory on
+ *   every connection in client.ts.
+ */
+/**
+ * Tiny key/value table holding `schema_version`, `last_full_rebuild`, and
+ * any other one-off bookkeeping. Sized for handfuls of rows.
+ *
+ * Stamped at first openDb() call by client.ts if absent. The schema_version
+ * value lets us detect drift on startup and either run new migrations or
+ * (in the worst case for sqlite-vec breaking changes) drop + rebuild the
+ * vec virtual table from markdown.
+ */
+export declare const kgMeta: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "kg_meta";
+    schema: undefined;
+    columns: {
+        key: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "key";
+            tableName: "kg_meta";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        value: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "value";
+            tableName: "kg_meta";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+/**
+ * One row per markdown section. The "primary unit" of the KG — chunks belong
+ * to nodes, edges connect nodes.
+ *
+ * `kind` is open-ended for forward compatibility:
+ *   - `'section'` — the only kind Phase 2 writes; one per ATX heading
+ *   - `'entity' | 'concept' | 'decision' | 'log_entry' | 'gap'` — Phase 4-6
+ *
+ * `section_path` is the ATX heading hierarchy joined by ` / ` (e.g.
+ * `"Authentication / Login flow"` for an `## Login flow` under `# Authentication`).
+ * Empty string for top-of-file content above any heading.
+ *
+ * `content` stores the full section markdown (heading + body). Chunks are
+ * derived from this and stored separately in kg_chunks. We keep both because
+ * `kg_execute` callers may want the whole section (`kg.get(node_id)`) instead
+ * of paragraph-sized chunks.
+ */
+export declare const kgNodes: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "kg_nodes";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "kg_nodes";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        scope: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "scope";
+            tableName: "kg_nodes";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        sourceUri: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "source_uri";
+            tableName: "kg_nodes";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        sectionPath: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "section_path";
+            tableName: "kg_nodes";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        kind: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "kind";
+            tableName: "kg_nodes";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        title: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "title";
+            tableName: "kg_nodes";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        content: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "content";
+            tableName: "kg_nodes";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        sourceSha: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "source_sha";
+            tableName: "kg_nodes";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        tokenCount: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "token_count";
+            tableName: "kg_nodes";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        confidence: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "confidence";
+            tableName: "kg_nodes";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "kg_nodes";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "kg_nodes";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastAccessedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "last_accessed_at";
+            tableName: "kg_nodes";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+/**
+ * Directed edges between nodes. Composite primary key on
+ * `(src_id, dst_id, edge_kind)` so the same pair can have multiple edge
+ * kinds (e.g. one node both `cites` and `supersedes` another).
+ *
+ * Phase 2 doesn't populate this table — Phase 4 extracts wikilinks during
+ * markdown parsing. The table exists now so the migration is complete and
+ * Phase 4 doesn't have to add it as a separate migration.
+ */
+export declare const kgEdges: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "kg_edges";
+    schema: undefined;
+    columns: {
+        srcId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "src_id";
+            tableName: "kg_edges";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        dstId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "dst_id";
+            tableName: "kg_edges";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        edgeKind: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "edge_kind";
+            tableName: "kg_edges";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+/**
+ * One row per ~500-token chunk derived from a node's `content`. The
+ * chunker (src/ingest/parse/chunk.ts) splits on paragraph boundaries and
+ * accumulates until adding the next paragraph would exceed `target_tokens`.
+ *
+ * The implicit SQLite `rowid` (auto-assigned for tables without
+ * INTEGER PRIMARY KEY) is what FTS5 and sqlite-vec join on:
+ *   - `kg_chunks_fts` is `content='kg_chunks', content_rowid='rowid'`
+ *   - `kg_chunks_vec.rowid` matches `kg_chunks.rowid`
+ *
+ * `chunk_sha = sha1(text)` is the per-chunk skip-unchanged key. On a
+ * file rewrite, the ingester compares each new chunk's chunk_sha against
+ * the existing chunk_shas for the file's nodes; matching chunks reuse
+ * the existing embedding (no embedder call), only changed chunks get
+ * re-embedded. This is the load-bearing optimization for Pharos's
+ * whole-file-rewrite-per-turn pattern (CLAUDE.md §Database Rules #3).
+ */
+export declare const kgChunks: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "kg_chunks";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "kg_chunks";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        nodeId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "node_id";
+            tableName: "kg_chunks";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        chunkIndex: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "chunk_index";
+            tableName: "kg_chunks";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        text: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "text";
+            tableName: "kg_chunks";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        chunkSha: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "chunk_sha";
+            tableName: "kg_chunks";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        tokenCount: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "token_count";
+            tableName: "kg_chunks";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "kg_chunks";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+/**
+ * Append-only event stream. Phase 2 writes:
+ *   - `'ingest:done'` — successful file ingest
+ *   - `'ingest:error'` — failed file ingest
+ *   - `'rebuild:start' | 'rebuild:done'` — full-rebuild markers
+ *
+ * `payload` is opaque JSON shaped per `kind`. The reader is the LLM via
+ * `kg.log.recent(n, opts)` in Phase 4+; Phase 2 just appends.
+ */
+export declare const kgLog: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "kg_log";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "kg_log";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        ts: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "ts";
+            tableName: "kg_log";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        scope: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "scope";
+            tableName: "kg_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        kind: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "kind";
+            tableName: "kg_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        sourceUri: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "source_uri";
+            tableName: "kg_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        payload: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "payload";
+            tableName: "kg_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+/**
+ * Concept gaps detected by the Phase 6 gap-detection sub-agent. Phase 2
+ * creates the table; Phase 6 wires the writes.
+ *
+ * `mentions_count` lets the dashboard prioritize gaps that appear across
+ * multiple turns. `resolved_at` is set when a gap is closed (either by
+ * the LLM writing about the topic or by a manual dismissal).
+ */
+export declare const kgGaps: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "kg_gaps";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "kg_gaps";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        scope: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "scope";
+            tableName: "kg_gaps";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        topic: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "topic";
+            tableName: "kg_gaps";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        firstSeenAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "first_seen_at";
+            tableName: "kg_gaps";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        mentionsCount: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "mentions_count";
+            tableName: "kg_gaps";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        resolvedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "resolved_at";
+            tableName: "kg_gaps";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+/**
+ * Audit log of every MCP tool call. Phase 5 wires the dispatcher to write
+ * one row per call as part of the privacy invariant verification surface
+ * (CLAUDE.md §Security #7). Phase 2 creates the table.
+ *
+ * NB: per CLAUDE.md §Security #7, the JSONL mirror path differs by scope —
+ * project rows mirror to `.pharos/kg-audit.jsonl` (in the repo, safe for
+ * `git add .`), personal/both rows mirror to `~/.pharos/profile/kg-audit.jsonl`.
+ * Personal-scope audit rows go to a separate kg_audit table in the personal
+ * DB, never the project DB. This split is enforced at the app layer.
+ */
+export declare const kgAudit: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "kg_audit";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "kg_audit";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        ts: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "ts";
+            tableName: "kg_audit";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        toolName: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "tool_name";
+            tableName: "kg_audit";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        scopeRequested: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "scope_requested";
+            tableName: "kg_audit";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        callerCtx: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "caller_ctx";
+            tableName: "kg_audit";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        responseTokens: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "response_tokens";
+            tableName: "kg_audit";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        error: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "error";
+            tableName: "kg_audit";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+export type KgNode = typeof kgNodes.$inferSelect;
+export type NewKgNode = typeof kgNodes.$inferInsert;
+export type KgChunk = typeof kgChunks.$inferSelect;
+export type NewKgChunk = typeof kgChunks.$inferInsert;
+export type KgEdge = typeof kgEdges.$inferSelect;
+export type NewKgEdge = typeof kgEdges.$inferInsert;
+export type KgLogRow = typeof kgLog.$inferSelect;
+export type NewKgLogRow = typeof kgLog.$inferInsert;
+/**
+ * The list of all schema-managed tables, useful for the schema test that
+ * verifies the migration creates every expected table.
+ */
+export declare const KG_TABLES: readonly ["kg_meta", "kg_nodes", "kg_edges", "kg_chunks", "kg_log", "kg_gaps", "kg_audit"];
+/**
+ * The two virtual tables created via raw SQL in the migration (drizzle-kit
+ * doesn't emit virtual table DDL). Schema test verifies they exist.
+ */
+export declare const KG_VIRTUAL_TABLES: readonly ["kg_chunks_fts", "kg_chunks_vec"];
+//# sourceMappingURL=schema.d.ts.map