@pella-labs/pinakes 0.1.0

package/dist/ingest/memory-store.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Phase 1 in-memory document store.
+ *
+ * This is the spike's substitute for the real SQLite + FTS + vector stack
+ * that Phase 2-4 will land. It loads every `*.md` file under a given root
+ * directory once at startup, splits each file on blank lines into paragraph
+ * chunks, and exposes a substring-based `search()` + id-based `get()`.
+ *
+ * The store is intentionally dumb — no ranking, no stemming, no tokenizing,
+ * no caching beyond the initial load. The whole point of Phase 1 is to
+ * prove that the markdown → chunks → tool response round-trip works without
+ * getting distracted by retrieval quality. Phase 2 replaces this with the
+ * drizzle schema + FTS5 + sqlite-vec layered stack.
+ *
+ * The only non-trivial contract: chunk ids must be deterministic. Given the
+ * same root directory contents, loading the store twice must produce
+ * identical ids. Phase 2's ingester relies on this for idempotent upsert.
+ */
+export interface Chunk {
+    /** Deterministic sha1(`relative_path:index`) — stable across reloads. */
+    id: string;
+    /** Paragraph text, trimmed. Never empty. */
+    text: string;
+    /** `file://` URL of the source file. */
+    source_uri: string;
+    /** Position of this chunk within its source file, 0-based. */
+    chunk_index: number;
+}
+export declare class MemoryStore {
+    private readonly rootDir;
+    private chunks;
+    private byId;
+    private constructor();
+    /**
+     * Construct and populate a store from the given wiki root directory.
+     * Reads every `*.md` file recursively, splits on blank lines, and
+     * indexes into a flat chunks array + id lookup map.
+     */
+    static load(rootDir: string): Promise<MemoryStore>;
+    /**
+     * Case-insensitive substring filter over every chunk's text. Returns all
+     * matches in insertion order (file order, then chunk order within file).
+     *
+     * Phase 1 does no ranking — the spike only needs to prove the bindings
+     * pipeline. Phase 4 replaces this with FTS5 + RRF.
+     */
+    search(query: string): Chunk[];
+    /** Exact lookup by id. Returns `null` if not found (never throws). */
+    get(id: string): Chunk | null;
+    /** Total number of indexed chunks. */
+    size(): number;
+    /** The resolved absolute path this store was loaded from. */
+    root(): string;
+}
+//# sourceMappingURL=memory-store.d.ts.map

package/dist/ingest/memory-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-store.d.ts","sourceRoot":"","sources":["../../src/ingest/memory-store.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,WAAW,KAAK;IACpB,yEAAyE;IACzE,EAAE,EAAE,MAAM,CAAC;IACX,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,wCAAwC;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,8DAA8D;IAC9D,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,WAAW;IAIF,OAAO,CAAC,QAAQ,CAAC,OAAO;IAH5C,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,IAAI,CAA4B;IAExC,OAAO;IAEP;;;;OAIG;WACU,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAuBxD;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE;IAM9B,sEAAsE;IACtE,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI;IAI7B,sCAAsC;IACtC,IAAI,IAAI,MAAM;IAId,6DAA6D;IAC7D,IAAI,IAAI,MAAM;CAGf"}

package/dist/ingest/memory-store.js

@@ -0,0 +1,94 @@
+import { createHash } from 'node:crypto';
+import { readdir, readFile } from 'node:fs/promises';
+import { resolve, relative } from 'node:path';
+import { pathToFileURL } from 'node:url';
+export class MemoryStore {
+    rootDir;
+    chunks = [];
+    byId = new Map();
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+    }
+    /**
+     * Construct and populate a store from the given wiki root directory.
+     * Reads every `*.md` file recursively, splits on blank lines, and
+     * indexes into a flat chunks array + id lookup map.
+     */
+    static async load(rootDir) {
+        const abs = resolve(rootDir);
+        const store = new MemoryStore(abs);
+        const files = await collectMarkdownFiles(abs);
+        for (const file of files) {
+            const text = await readFile(file, 'utf8');
+            const rel = relative(abs, file);
+            const uri = pathToFileURL(file).href;
+            const paragraphs = splitParagraphs(text);
+            for (let i = 0; i < paragraphs.length; i++) {
+                const chunk = {
+                    id: sha1(`${rel}:${i}`),
+                    text: paragraphs[i],
+                    source_uri: uri,
+                    chunk_index: i,
+                };
+                store.chunks.push(chunk);
+                store.byId.set(chunk.id, chunk);
+            }
+        }
+        return store;
+    }
+    /**
+     * Case-insensitive substring filter over every chunk's text. Returns all
+     * matches in insertion order (file order, then chunk order within file).
+     *
+     * Phase 1 does no ranking — the spike only needs to prove the bindings
+     * pipeline. Phase 4 replaces this with FTS5 + RRF.
+     */
+    search(query) {
+        const q = query.toLowerCase();
+        if (!q)
+            return [];
+        return this.chunks.filter((c) => c.text.toLowerCase().includes(q));
+    }
+    /** Exact lookup by id. Returns `null` if not found (never throws). */
+    get(id) {
+        return this.byId.get(id) ?? null;
+    }
+    /** Total number of indexed chunks. */
+    size() {
+        return this.chunks.length;
+    }
+    /** The resolved absolute path this store was loaded from. */
+    root() {
+        return this.rootDir;
+    }
+}
+// ============================================================================
+// helpers
+// ============================================================================
+async function collectMarkdownFiles(root) {
+    const out = [];
+    const entries = await readdir(root, { withFileTypes: true, recursive: true });
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        if (!entry.name.toLowerCase().endsWith('.md'))
+            continue;
+        // Node 20+ recursive readdir provides parentPath on each entry
+        const parent = entry.parentPath
+            ?? entry.path
+            ?? root;
+        out.push(resolve(parent, entry.name));
+    }
+    out.sort(); // deterministic order across filesystems
+    return out;
+}
+function splitParagraphs(source) {
+    return source
+        .split(/\r?\n\r?\n+/)
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0);
+}
+function sha1(input) {
+    return createHash('sha1').update(input).digest('hex');
+}
+//# sourceMappingURL=memory-store.js.map

package/dist/ingest/memory-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-store.js","sourceRoot":"","sources":["../../src/ingest/memory-store.ts"],"names":[],"mappings":"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"}

package/dist/ingest/parse/chunk.d.ts

@@ -0,0 +1,15 @@
+export interface Chunk {
+    /** Chunk text — paragraphs joined by blank lines, original whitespace preserved */
+    text: string;
+    /** Cached token count — exposed so the ingester doesn't need to recount */
+    token_count: number;
+}
+/**
+ * Split a section's content into ~target_tokens-sized chunks on paragraph
+ * boundaries. Returns an empty array for input with no non-whitespace content.
+ *
+ * `targetTokens` defaults to 500. Pass a smaller value in tests if you want
+ * to force a section to chunk at a predictable boundary.
+ */
+export declare function chunkSection(content: string, targetTokens?: number): Chunk[];
+//# sourceMappingURL=chunk.d.ts.map

package/dist/ingest/parse/chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.d.ts","sourceRoot":"","sources":["../../../src/ingest/parse/chunk.ts"],"names":[],"mappings":"AAoCA,MAAM,WAAW,KAAK;IACpB,mFAAmF;IACnF,IAAI,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,GAAE,MAA8B,GAAG,KAAK,EAAE,CAyCnG"}

package/dist/ingest/parse/chunk.js

@@ -0,0 +1,88 @@
+import { countTokens } from '../../gate/budget.js';
+/**
+ * Paragraph-aware chunker for KG-MCP Phase 2.
+ *
+ * Splits a section's body into chunks of approximately `targetTokens` tokens,
+ * never breaking a paragraph in half. Tokens are counted via the existing
+ * `countTokens()` from `gate/budget.ts`, which uses `js-tiktoken p50k_base`
+ * with the long-string fast path (D32 — see CLAUDE.md §API Rules #6 budget math).
+ *
+ * **Algorithm**:
+ *   1. Split the input on blank lines (`\n\n+`) into paragraphs
+ *   2. Iterate paragraphs left to right, accumulating into a current chunk
+ *   3. If adding the next paragraph would push the chunk past `targetTokens`,
+ *      flush the current chunk and start a new one with that paragraph
+ *   4. A single oversize paragraph that ALONE exceeds `targetTokens` gets
+ *      its own chunk (rather than being split mid-sentence — the LLM can
+ *      still query it via FTS5, just slower)
+ *
+ * **Determinism**: same input → same output. The chunker is pure: no random
+ * tie-breaking, no time-based decisions, no environment lookups. The
+ * downstream `chunk_sha = sha1(chunk_text)` therefore stays stable across
+ * runs, which is the load-bearing assumption for the per-chunk skip-unchanged
+ * optimization (CLAUDE.md §Database Rules #3, Loop 6.5 A4).
+ *
+ * **Why ~500 tokens?** Empirical sweet spot for retrieval: small enough that
+ * each chunk is a focused topic, large enough that 1-2 chunks usually answer
+ * a query without needing to fetch a whole node. Phase 4's RRF + budget gate
+ * tunes around this size; deviating significantly will affect retrieval
+ * quality. The actual chunk sizes will fluctuate around this target since
+ * we won't break a paragraph — chunks may be smaller (single short paragraph)
+ * or larger (single long paragraph).
+ */
+const DEFAULT_TARGET_TOKENS = 500;
+/**
+ * Split a section's content into ~target_tokens-sized chunks on paragraph
+ * boundaries. Returns an empty array for input with no non-whitespace content.
+ *
+ * `targetTokens` defaults to 500. Pass a smaller value in tests if you want
+ * to force a section to chunk at a predictable boundary.
+ */
+export function chunkSection(content, targetTokens = DEFAULT_TARGET_TOKENS) {
+    const paragraphs = splitParagraphs(content);
+    if (paragraphs.length === 0)
+        return [];
+    const chunks = [];
+    let current = [];
+    let currentTokens = 0;
+    for (const para of paragraphs) {
+        const paraTokens = countTokens(para);
+        // Edge case: paragraph alone exceeds target — emit it as its own chunk
+        // (rather than splitting mid-sentence, which would hurt retrieval and
+        // also break round-trip determinism).
+        if (paraTokens > targetTokens) {
+            if (current.length > 0) {
+                chunks.push({ text: current.join('\n\n'), token_count: currentTokens });
+                current = [];
+                currentTokens = 0;
+            }
+            chunks.push({ text: para, token_count: paraTokens });
+            continue;
+        }
+        // If adding this paragraph would exceed target, flush current and start fresh.
+        if (currentTokens + paraTokens > targetTokens && current.length > 0) {
+            chunks.push({ text: current.join('\n\n'), token_count: currentTokens });
+            current = [];
+            currentTokens = 0;
+        }
+        current.push(para);
+        currentTokens += paraTokens;
+    }
+    // Flush the trailing chunk.
+    if (current.length > 0) {
+        chunks.push({ text: current.join('\n\n'), token_count: currentTokens });
+    }
+    return chunks;
+}
+/**
+ * Split a string on blank lines, trimming each paragraph and dropping empty
+ * ones. Mirrors the Phase 1 splitParagraphs in memory-store.ts so chunking
+ * behavior stays consistent across the swap.
+ */
+function splitParagraphs(source) {
+    return source
+        .split(/\r?\n\r?\n+/)
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0);
+}
+//# sourceMappingURL=chunk.js.map

package/dist/ingest/parse/chunk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.js","sourceRoot":"","sources":["../../../src/ingest/parse/chunk.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,MAAM,qBAAqB,GAAG,GAAG,CAAC;AASlC;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,OAAe,EAAE,eAAuB,qBAAqB;IACxF,MAAM,UAAU,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC;IAC5C,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAEvC,MAAM,MAAM,GAAY,EAAE,CAAC;IAC3B,IAAI,OAAO,GAAa,EAAE,CAAC;IAC3B,IAAI,aAAa,GAAG,CAAC,CAAC;IAEtB,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;QAC9B,MAAM,UAAU,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;QAErC,uEAAuE;QACvE,sEAAsE;QACtE,sCAAsC;QACtC,IAAI,UAAU,GAAG,YAAY,EAAE,CAAC;YAC9B,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACvB,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC,CAAC;gBACxE,OAAO,GAAG,EAAE,CAAC;gBACb,aAAa,GAAG,CAAC,CAAC;YACpB,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC;YACrD,SAAS;QACX,CAAC;QAED,+EAA+E;QAC/E,IAAI,aAAa,GAAG,UAAU,GAAG,YAAY,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpE,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC,CAAC;YACxE,OAAO,GAAG,EAAE,CAAC;YACb,aAAa,GAAG,CAAC,CAAC;QACpB,CAAC;QAED,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnB,aAAa,IAAI,UAAU,CAAC;IAC9B,CAAC;IAED,4BAA4B;IAC5B,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC,CAAC;IAC1E,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;GAIG;AACH,SAAS,eAAe,CAAC,MAAc;IACrC,OAAO,MAAM;SACV,KAAK,CAAC,aAAa,CAAC;SACpB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;SACpB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACjC,CAAC"}

package/dist/ingest/parse/markdown.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Markdown → section parser for KG-MCP Phase 2.
+ *
+ * Parses a markdown file into a flat array of `SectionNode` objects, one
+ * per ATX heading (`#`, `##`, …) plus an optional pre-heading section for
+ * any content above the first heading. The chunker (chunk.ts) then splits
+ * each section's `content` into ~500-token chunks.
+ *
+ * **Why mdast?** Phase 1 used a `\n\n` regex split that lost all heading
+ * structure. The Karpathy two-level wiki has nested H1/H2/H3 sections, and
+ * the LLM querying via `kg.search` benefits from being able to identify
+ * "this chunk lives under H2 'Login flow' which lives under H1 'Authentication'".
+ * The `section_path` field captures that hierarchy.
+ *
+ * **Section content slicing**: we use mdast `position.start.offset` to slice
+ * the original source for each section, so the stored content includes the
+ * exact original markdown (whitespace, formatting, code fences) — not a
+ * re-rendered approximation. This makes round-trip tests trivial: rebuild a
+ * file by joining all section contents and you should get back something
+ * structurally identical to the input.
+ *
+ * **Determinism**: same input → same output. Pinned `mdast-util-from-markdown@^2.0.0`
+ * + no plugins = stable mdast tree, stable section list, stable downstream
+ * chunk ids. Tests verify this by parsing twice and deep-equal-ing the result.
+ */
+/**
+ * One section of a markdown file. Sections are derived from ATX headings;
+ * a `SectionNode { depth: 0 }` is the optional pre-heading content above
+ * the first heading.
+ */
+export interface SectionNode {
+    /** ATX heading hierarchy joined by ` / ` (e.g. `"Authentication / Login flow"`); empty for pre-heading content */
+    section_path: string;
+    /** The heading text itself (or empty string for pre-heading content) */
+    title: string;
+    /** Original markdown source for this section (heading + body), preserving whitespace */
+    content: string;
+    /** Always `'section'` for Phase 2 — Phase 4 may add other kinds (entity, decision) */
+    kind: 'section';
+    /** ATX depth: 0 = pre-heading, 1 = `#`, 2 = `##`, …, 6 = `######` */
+    depth: number;
+}
+/** Confidence level for provenance tracking (Phase 6). */
+export type Confidence = 'extracted' | 'inferred' | 'ambiguous';
+/**
+ * Detect confidence from YAML frontmatter in a markdown file.
+ *
+ * Rules:
+ * - `source: haiku` or `source: ai` or `source: ai-generated` → `'inferred'`
+ * - `status: ambiguous` or `status: needs-review` or `confidence: ambiguous` → `'ambiguous'`
+ * - `confidence: inferred` → `'inferred'`
+ * - Otherwise → `'extracted'`
+ */
+export declare function detectConfidence(source: string): Confidence;
+/**
+ * Parse a markdown source string into a flat list of sections.
+ *
+ * Sections are emitted in source order (top-to-bottom). Empty pre-heading
+ * content (whitespace only) is skipped. Sections with no body (just a
+ * heading and nothing after) are still emitted — the chunker handles them
+ * by producing zero chunks for that section.
+ */
+export declare function parseMarkdown(source: string): SectionNode[];
+//# sourceMappingURL=markdown.d.ts.map

package/dist/ingest/parse/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../src/ingest/parse/markdown.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,kHAAkH;IAClH,YAAY,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACxE,KAAK,EAAE,MAAM,CAAC;IACd,wFAAwF;IACxF,OAAO,EAAE,MAAM,CAAC;IAChB,sFAAsF;IACtF,IAAI,EAAE,SAAS,CAAC;IAChB,qEAAqE;IACrE,KAAK,EAAE,MAAM,CAAC;CACf;AAED,0DAA0D;AAC1D,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,CAAC;AAEhE;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAiB3D;AAuBD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,EAAE,CAuF3D"}

package/dist/ingest/parse/markdown.js

@@ -0,0 +1,152 @@
+import { fromMarkdown } from 'mdast-util-from-markdown';
+/**
+ * Detect confidence from YAML frontmatter in a markdown file.
+ *
+ * Rules:
+ * - `source: haiku` or `source: ai` or `source: ai-generated` → `'inferred'`
+ * - `status: ambiguous` or `status: needs-review` or `confidence: ambiguous` → `'ambiguous'`
+ * - `confidence: inferred` → `'inferred'`
+ * - Otherwise → `'extracted'`
+ */
+export function detectConfidence(source) {
+    const fm = parseFrontmatter(source);
+    if (!fm)
+        return 'extracted';
+    // Check explicit confidence field first
+    if (fm.confidence === 'inferred')
+        return 'inferred';
+    if (fm.confidence === 'ambiguous')
+        return 'ambiguous';
+    // Check source field
+    const src = typeof fm.source === 'string' ? fm.source.toLowerCase() : '';
+    if (src === 'haiku' || src === 'ai' || src === 'ai-generated')
+        return 'inferred';
+    // Check status field
+    const status = typeof fm.status === 'string' ? fm.status.toLowerCase() : '';
+    if (status === 'ambiguous' || status === 'needs-review')
+        return 'ambiguous';
+    return 'extracted';
+}
+/**
+ * Minimal YAML frontmatter parser. Extracts key: value pairs from
+ * `---\n...\n---` blocks at the start of a file. No dependency needed.
+ */
+function parseFrontmatter(source) {
+    if (!source.startsWith('---'))
+        return null;
+    const endIdx = source.indexOf('\n---', 3);
+    if (endIdx === -1)
+        return null;
+    const block = source.slice(4, endIdx);
+    const result = {};
+    for (const line of block.split('\n')) {
+        const colon = line.indexOf(':');
+        if (colon === -1)
+            continue;
+        const key = line.slice(0, colon).trim();
+        const val = line.slice(colon + 1).trim();
+        if (key)
+            result[key] = val;
+    }
+    return result;
+}
+/**
+ * Parse a markdown source string into a flat list of sections.
+ *
+ * Sections are emitted in source order (top-to-bottom). Empty pre-heading
+ * content (whitespace only) is skipped. Sections with no body (just a
+ * heading and nothing after) are still emitted — the chunker handles them
+ * by producing zero chunks for that section.
+ */
+export function parseMarkdown(source) {
+    const tree = fromMarkdown(source);
+    const sections = [];
+    const rootChildren = tree.children ?? [];
+    // Pass 1: collect every top-level heading with its source offset.
+    // We only care about headings at the root of the mdast tree — nested
+    // headings inside blockquotes or lists are unusual and we treat them
+    // as part of the surrounding section's body.
+    const headings = [];
+    for (const child of rootChildren) {
+        if (child.type !== 'heading')
+            continue;
+        const start = child.position?.start.offset;
+        if (typeof start !== 'number')
+            continue; // defensive: should always be present
+        headings.push({
+            depth: child.depth ?? 1,
+            title: mdastNodeText(child).trim(),
+            startOffset: start,
+        });
+    }
+    // Edge case: no headings at all → one big pre-heading section (if non-empty).
+    if (headings.length === 0) {
+        if (source.trim().length > 0) {
+            sections.push({
+                section_path: '',
+                title: '',
+                content: source,
+                kind: 'section',
+                depth: 0,
+            });
+        }
+        return sections;
+    }
+    // Pre-heading content: anything before the first heading.
+    const firstStart = headings[0].startOffset;
+    if (firstStart > 0) {
+        const preContent = source.slice(0, firstStart);
+        if (preContent.trim().length > 0) {
+            sections.push({
+                section_path: '',
+                title: '',
+                content: preContent,
+                kind: 'section',
+                depth: 0,
+            });
+        }
+    }
+    // Pass 2: walk the heading list, building section_path via a depth stack
+    // and slicing content from this heading's offset to the next heading's
+    // offset (or EOF for the final section).
+    const stack = [];
+    for (let i = 0; i < headings.length; i++) {
+        const h = headings[i];
+        // Pop the stack until the top is a strict ancestor of `h`.
+        // This handles unusual cases like H1 → H3 → H2 (the H2 pops the H3
+        // but keeps the H1 ancestor).
+        while (stack.length > 0 && stack[stack.length - 1].depth >= h.depth) {
+            stack.pop();
+        }
+        stack.push({ depth: h.depth, title: h.title });
+        const sectionPath = stack.map((s) => s.title).join(' / ');
+        const startOffset = h.startOffset;
+        const endOffset = i + 1 < headings.length ? headings[i + 1].startOffset : source.length;
+        const content = source.slice(startOffset, endOffset);
+        sections.push({
+            section_path: sectionPath,
+            title: h.title,
+            content,
+            kind: 'section',
+            depth: h.depth,
+        });
+    }
+    return sections;
+}
+/**
+ * Recursively concatenate the text content of an mdast node, ignoring
+ * formatting. Equivalent to mdast-util-to-string but inlined to avoid the
+ * transitive-dep import issue.
+ */
+function mdastNodeText(node) {
+    if (typeof node.value === 'string')
+        return node.value;
+    if (!node.children)
+        return '';
+    let out = '';
+    for (const child of node.children) {
+        out += mdastNodeText(child);
+    }
+    return out;
+}
+//# sourceMappingURL=markdown.js.map

package/dist/ingest/parse/markdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.js","sourceRoot":"","sources":["../../../src/ingest/parse/markdown.ts"],"names":[],"mappings":"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"}

package/dist/ingest/queue.d.ts

@@ -0,0 +1,21 @@
+import type { IngestEvent, IngestSource } from './source.js';
+/**
+ * `QueueSubscriber` — placeholder for the Phase 5+ orchestrator contract.
+ *
+ * The orchestration engineer (per the project memory) is separately
+ * building a message-queue contract that will feed events into KG-MCP.
+ * When that lands, this class becomes a real subscriber. Until then it
+ * exists so:
+ *   1. The `IngestSource` interface has both implementations the codebase
+ *      expects, exercising the contract in type-check
+ *   2. `serve.ts` can document the swap-in seam (commented `// const source = new QueueSubscriber(...)`)
+ *   3. Phase 5 doesn't have to add a new file — only fill this one in
+ *
+ * Both methods throw `not implemented` — calling them is a programming
+ * error in Phase 2.
+ */
+export declare class QueueSubscriber implements IngestSource {
+    start(_onEvent: (ev: IngestEvent) => Promise<void>): Promise<void>;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=queue.d.ts.map

package/dist/ingest/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../src/ingest/queue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE7D;;;;;;;;;;;;;;GAcG;AACH,qBAAa,eAAgB,YAAW,YAAY;IAC5C,KAAK,CAAC,QAAQ,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAMlE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAK5B"}

package/dist/ingest/queue.js

@@ -0,0 +1,24 @@
+/**
+ * `QueueSubscriber` — placeholder for the Phase 5+ orchestrator contract.
+ *
+ * The orchestration engineer (per the project memory) is separately
+ * building a message-queue contract that will feed events into KG-MCP.
+ * When that lands, this class becomes a real subscriber. Until then it
+ * exists so:
+ *   1. The `IngestSource` interface has both implementations the codebase
+ *      expects, exercising the contract in type-check
+ *   2. `serve.ts` can document the swap-in seam (commented `// const source = new QueueSubscriber(...)`)
+ *   3. Phase 5 doesn't have to add a new file — only fill this one in
+ *
+ * Both methods throw `not implemented` — calling them is a programming
+ * error in Phase 2.
+ */
+export class QueueSubscriber {
+    async start(_onEvent) {
+        throw new Error('QueueSubscriber.start() not implemented — pending orchestrator message-queue contract');
+    }
+    async stop() {
+        throw new Error('QueueSubscriber.stop() not implemented — pending orchestrator message-queue contract');
+    }
+}
+//# sourceMappingURL=queue.js.map

package/dist/ingest/queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.js","sourceRoot":"","sources":["../../src/ingest/queue.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,eAAe;IAC1B,KAAK,CAAC,KAAK,CAAC,QAA4C;QACtD,MAAM,IAAI,KAAK,CACb,uFAAuF,CACxF,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,IAAI;QACR,MAAM,IAAI,KAAK,CACb,sFAAsF,CACvF,CAAC;IACJ,CAAC;CACF"}

package/dist/ingest/source.d.ts

@@ -0,0 +1,42 @@
+/**
+ * `IngestSource` interface for KG-MCP Phase 2.
+ *
+ * The data-plane seam between the file-system watcher (chokidar today,
+ * orchestrator message queue tomorrow) and the `IngesterService`.
+ *
+ * Phase 2 ships two implementations:
+ *   - `ChokidarWatcher` (src/ingest/chokidar.ts) — watches a directory,
+ *     emits events on file changes, with the mandatory 2-second debounce
+ *     and per-path drop-oldest queue
+ *   - `QueueSubscriber` (src/ingest/queue.ts) — stub that throws
+ *     `not implemented`. Phase 5+ wires it to the orchestrator contract
+ *     when that lands.
+ *
+ * The `ChokidarWatcher` ↔ `QueueSubscriber` swap is one line in
+ * `src/cli/serve.ts`. Per presearch.md §2.5 / D19.
+ */
+export type IngestEventKind = 'file:added' | 'file:changed' | 'file:removed';
+export type Scope = 'project' | 'personal';
+export interface IngestEvent {
+    /** What happened */
+    kind: IngestEventKind;
+    /** Absolute path to the markdown file */
+    path: string;
+    /** Which KG this event belongs to */
+    scope: Scope;
+}
+/**
+ * The interface that `serve.ts` programs against. The watcher (or queue
+ * subscriber) calls `start(onEvent)` and pumps events into the callback;
+ * `stop()` cleans up.
+ *
+ * Errors thrown by the `onEvent` callback are caught by the source and
+ * logged — the source MUST NOT crash on a single failing event, since
+ * a single corrupt file shouldn't bring down the watcher for an entire
+ * wiki dir.
+ */
+export interface IngestSource {
+    start(onEvent: (ev: IngestEvent) => Promise<void>): Promise<void>;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=source.d.ts.map

package/dist/ingest/source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../src/ingest/source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG,cAAc,GAAG,cAAc,CAAC;AAE7E,MAAM,MAAM,KAAK,GAAG,SAAS,GAAG,UAAU,CAAC;AAE3C,MAAM,WAAW,WAAW;IAC1B,oBAAoB;IACpB,IAAI,EAAE,eAAe,CAAC;IACtB,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,qCAAqC;IACrC,KAAK,EAAE,KAAK,CAAC;CACd;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,OAAO,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB"}

package/dist/ingest/source.js

@@ -0,0 +1,19 @@
+/**
+ * `IngestSource` interface for KG-MCP Phase 2.
+ *
+ * The data-plane seam between the file-system watcher (chokidar today,
+ * orchestrator message queue tomorrow) and the `IngesterService`.
+ *
+ * Phase 2 ships two implementations:
+ *   - `ChokidarWatcher` (src/ingest/chokidar.ts) — watches a directory,
+ *     emits events on file changes, with the mandatory 2-second debounce
+ *     and per-path drop-oldest queue
+ *   - `QueueSubscriber` (src/ingest/queue.ts) — stub that throws
+ *     `not implemented`. Phase 5+ wires it to the orchestrator contract
+ *     when that lands.
+ *
+ * The `ChokidarWatcher` ↔ `QueueSubscriber` swap is one line in
+ * `src/cli/serve.ts`. Per presearch.md §2.5 / D19.
+ */
+export {};
+//# sourceMappingURL=source.js.map

package/dist/ingest/source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.js","sourceRoot":"","sources":["../../src/ingest/source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG"}