chapterhouse 0.7.0 → 0.8.1

package/dist/wiki/index-manager.js

@@ -1,90 +1,266 @@
 // ---------------------------------------------------------------------------
-// Wiki index.md manager — parse, update, and search the page catalog
+// Wiki index manager — SQLite FTS5-backed wiki page catalog
 // ---------------------------------------------------------------------------
-import { existsSync, statSync } from "fs";
-import { join } from "path";
-import { WIKI_DIR } from "../paths.js";
-import { readIndexFile, writeIndexFile, listPages, readPage } from "./fs.js";
+import { getDb, isFts5Available } from "../store/db.js";
+import { childLogger } from "../util/logger.js";
+import { listPages, readPage } from "./fs.js";
 import { parseWikiFrontmatter } from "./frontmatter.js";
 import { normalizeWikiPath } from "./path-utils.js";
-import { entityCategories, FLAT_CATEGORIES } from "./topic-structure.js";
-const INDEX_PATH = join(WIKI_DIR, "index.md");
+import { updateLinks } from "./links.js";
 const ACTION_LOG_PAGE_RE = /^pages\/_meta\/log(?:-\d{4})?\.md$/;
-// mtime-based cache so per-message context injection doesn't re-parse on every turn.
-let cache;
-function invalidateCache() {
-    cache = undefined;
+const LEGACY_INDEX_PAGE = "pages/index.md";
+const log = childLogger("wiki-index");
+function isIgnoredIndexPage(path) {
+    return path === LEGACY_INDEX_PAGE || ACTION_LOG_PAGE_RE.test(path);
 }
+function getIndexablePages() {
+    return listPages().filter((p) => !isIgnoredIndexPage(p));
+}
+function getWikiPageCount() {
+    const db = getDb();
+    return db.prepare(`SELECT COUNT(*) as c FROM wiki_pages`).get().c;
+}
+function getErrorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function buildPageSummary(summary, body) {
+    let nextSummary = summary?.trim() ?? "";
+    if (!nextSummary) {
+        for (const raw of body.split("\n")) {
+            const line = raw.trim();
+            if (!line || line.startsWith("#") || line.startsWith("<!--"))
+                continue;
+            nextSummary = line.replace(/^[-*]\s+/, "").replace(/_\(\d{4}-\d{2}-\d{2}\)_$/, "").trim();
+            if (!nextSummary)
+                continue;
+            break;
+        }
+    }
+    if (nextSummary.length > 160)
+        nextSummary = nextSummary.slice(0, 157) + "…";
+    return nextSummary;
+}
+function categoryOfPath(path) {
+    const rest = path.startsWith("pages/") ? path.slice("pages/".length) : path;
+    const segs = rest.split("/").filter(Boolean);
+    if (segs.length <= 1)
+        return (segs[0] || "pages").replace(/\.md$/i, "");
+    return segs[0];
+}
+function basenameTitle(path) {
+    const normalizedPath = normalizeWikiPath(path);
+    const segs = normalizedPath.split("/").filter(Boolean);
+    const file = segs[segs.length - 1] || normalizedPath;
+    const base = file.replace(/\.md$/, "");
+    const titleBase = base === "index" && segs.length >= 2 ? segs[segs.length - 2] : base;
+    return titleBase.split(/[-_]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function quoteFts5Terms(query) {
+    return query
+        .trim()
+        .split(/\s+/)
+        .filter((term) => term.length > 0)
+        .map((term) => {
+        const unquoted = term.replace(/^["']|["']$/g, "");
+        return `"${unquoted.replace(/"/g, '""')}"`;
+    })
+        .join(" ");
+}
+// ---------------------------------------------------------------------------
+// New SQLite-backed API
+// ---------------------------------------------------------------------------
 /**
- * Parse index.md into structured entries.
- * Expected format (new):
- *   ## Section Name
- *   - [Title](path) — Summary text | tags: tag1, tag2 | updated: 2026-04-17
- * Also supports legacy format without tags/updated.
+ * Upsert a single wiki page into wiki_pages (and FTS via trigger).
+ * entity_type is read from frontmatter.metadata.entity_type if present.
  */
-export function parseIndex() {
-    let mtimeMs = 0, size = 0;
-    if (existsSync(INDEX_PATH)) {
-        const st = statSync(INDEX_PATH);
-        mtimeMs = st.mtimeMs;
-        size = st.size;
-        if (cache && cache.mtimeMs === mtimeMs && cache.size === size) {
-            return cache.entries;
+export function upsertWikiPage(path, frontmatter, summary) {
+    const db = getDb();
+    const normalizedPath = normalizeWikiPath(path);
+    const title = frontmatter.title ?? basenameTitle(normalizedPath);
+    const entityType = frontmatter.metadata?.["entity_type"] ?? null;
+    const tags = JSON.stringify(frontmatter.tags ?? []);
+    const lastUpdated = frontmatter.updated ?? new Date().toISOString();
+    db.prepare(`
+    INSERT INTO wiki_pages (path, title, entity_type, tags, summary, last_updated)
+    VALUES (?, ?, ?, ?, ?, ?)
+    ON CONFLICT(path) DO UPDATE SET
+      title        = excluded.title,
+      entity_type  = excluded.entity_type,
+      tags         = excluded.tags,
+      summary      = excluded.summary,
+      last_updated = excluded.last_updated,
+      version      = wiki_pages.version + 1
+  `).run(normalizedPath, title, entityType, tags, summary || null, lastUpdated);
+}
+/** Remove a page from wiki_pages (and FTS via trigger). */
+export function removeWikiPage(path) {
+    const db = getDb();
+    db.prepare(`DELETE FROM wiki_pages WHERE path = ?`).run(normalizeWikiPath(path));
+}
+/**
+ * Rebuild the wiki_pages SQLite index from the filesystem.
+ * Filesystem is the source of truth: insert missing pages, remove stale entries.
+ */
+function runWikiReindex() {
+    const pages = getIndexablePages();
+    const db = getDb();
+    const onDisk = new Set(pages.map(normalizeWikiPath));
+    db.transaction(() => {
+        const inDb = db.prepare(`SELECT path FROM wiki_pages`).all();
+        for (const { path } of inDb) {
+            if (!onDisk.has(path)) {
+                db.prepare(`DELETE FROM wiki_pages WHERE path = ?`).run(path);
+                db.prepare(`DELETE FROM wiki_links WHERE from_page = ? OR to_page = ?`).run(path, path);
+            }
         }
-    }
-    const content = readIndexFile();
-    const entries = [];
-    let currentSection = "Uncategorized";
-    for (const line of content.split("\n")) {
-        // Section headers
-        const sectionMatch = line.match(/^##\s+(.+)/);
-        if (sectionMatch) {
-            currentSection = sectionMatch[1].trim();
+    })();
+    let indexedPageCount = 0;
+    let skippedPageCount = 0;
+    for (const p of pages) {
+        try {
+            const content = readPage(p);
+            if (!content)
+                continue;
+            const { parsed: fm, body } = parseWikiFrontmatter(content);
+            const summary = buildPageSummary(fm.summary, body);
+            upsertWikiPage(p, fm, summary);
+            updateLinks(p);
+            indexedPageCount++;
+        }
+        catch (err) {
+            skippedPageCount++;
+            log.warn({ path: p, err: getErrorMessage(err) }, "Skipping wiki page during reindex");
             continue;
         }
-        // Entry lines (possibly indented sub-bullets):
-        //   - [Title](path) — Summary | tags: t1, t2 | updated: YYYY-MM-DD
-        const entryMatch = line.match(/^\s*-\s+\[(.+?)\]\((.+?)\)\s*[—–-]\s*(.+)/);
-        if (entryMatch) {
-            const rawSummary = entryMatch[3].trim();
-            // Parse optional | tags: ... | updated: ... suffixes
-            let summary = rawSummary;
-            let tags = [];
-            let updated = "";
-            const tagsMatch = rawSummary.match(/\|\s*tags:\s*([^|]+)/);
-            if (tagsMatch) {
-                tags = tagsMatch[1].split(",").map((t) => t.trim()).filter(Boolean);
-                summary = summary.replace(tagsMatch[0], "").trim();
-            }
-            const updatedMatch = rawSummary.match(/\|\s*updated:\s*(\S+)/);
-            if (updatedMatch) {
-                updated = updatedMatch[1].trim();
-                summary = summary.replace(updatedMatch[0], "").trim();
+    }
+    log.info({ indexedPageCount, skippedPageCount }, `Reindexed ${indexedPageCount} pages, skipped ${skippedPageCount} pages (errors)`);
+    return {
+        diskPageCount: pages.length,
+        indexedPageCount,
+        skippedPageCount,
+    };
+}
+export function rebuildWikiIndex() {
+    runWikiReindex();
+}
+/**
+ * Search wiki pages using FTS5 BM25 ranking.
+ * Falls back to LIKE query if FTS5 unavailable.
+ * Empty query returns most-recently-updated pages.
+ * Each direct result includes 1-hop neighbors from wiki_links in `related`.
+ * Neighbor pages not already in direct results are appended (deduplicated).
+ */
+export function ensureWikiIndexPopulated() {
+    const pages = getIndexablePages();
+    const indexedPageCount = getWikiPageCount();
+    if (indexedPageCount === 0 && pages.length > 0) {
+        log.warn({ diskPageCount: pages.length }, "wiki_pages empty while wiki files exist; rebuilding from disk");
+        const result = runWikiReindex();
+        return {
+            reindexed: true,
+            diskPageCount: result.diskPageCount,
+            indexedPageCount: result.indexedPageCount,
+            skippedPageCount: result.skippedPageCount,
+        };
+    }
+    return {
+        reindexed: false,
+        diskPageCount: pages.length,
+        indexedPageCount,
+        skippedPageCount: 0,
+    };
+}
+export function reindexWikiPages() {
+    const result = runWikiReindex();
+    return {
+        reindexed: true,
+        diskPageCount: result.diskPageCount,
+        indexedPageCount: result.indexedPageCount,
+        skippedPageCount: result.skippedPageCount,
+    };
+}
+export function wikiSearch(query, limit = 20) {
+    const db = getDb();
+    const trimmed = query.trim();
+    let directRows;
+    if (!trimmed) {
+        directRows = db.prepare(`
+      SELECT path, title, entity_type, summary, 0 as rank
+      FROM wiki_pages
+      ORDER BY last_updated DESC
+      LIMIT ?
+    `).all(limit);
+    }
+    else if (isFts5Available()) {
+        const ftsQuery = quoteFts5Terms(trimmed);
+        try {
+            directRows = db.prepare(`
+        SELECT w.path, w.title, w.entity_type, w.summary, bm25(wiki_pages_fts) as rank
+        FROM wiki_pages_fts
+        JOIN wiki_pages w ON wiki_pages_fts.rowid = w.rowid
+        WHERE wiki_pages_fts MATCH ?
+        ORDER BY bm25(wiki_pages_fts)
+        LIMIT ?
+      `).all(ftsQuery, limit);
+        }
+        catch {
+            directRows = [];
+        }
+    }
+    else {
+        directRows = [];
+    }
+    // LIKE fallback when no FTS5 results
+    if (directRows.length === 0 && trimmed) {
+        const pattern = `%${trimmed}%`;
+        directRows = db.prepare(`
+      SELECT path, title, entity_type, summary, 0 as rank
+      FROM wiki_pages
+      WHERE title LIKE ? OR summary LIKE ? OR tags LIKE ?
+      ORDER BY last_updated DESC
+      LIMIT ?
+    `).all(pattern, pattern, pattern, limit);
+    }
+    // Enrich direct results with 1-hop neighbors and collect neighbor paths
+    const seenPaths = new Set(directRows.map((r) => r.path));
+    const neighborPaths = new Map();
+    for (const row of directRows) {
+        const outbound = db.prepare(`SELECT to_page, link_type FROM wiki_links WHERE from_page = ?`).all(row.path);
+        const inbound = db.prepare(`SELECT from_page, link_type FROM wiki_links WHERE to_page = ?`).all(row.path);
+        const related = [
+            ...outbound.map((r) => ({ page: r.to_page, link_type: r.link_type, direction: "outbound" })),
+            ...inbound.map((r) => ({ page: r.from_page, link_type: r.link_type, direction: "inbound" })),
+        ];
+        row.related = related;
+        for (const rel of related) {
+            if (!seenPaths.has(rel.page)) {
+                seenPaths.add(rel.page);
+                if (!neighborPaths.has(rel.page)) {
+                    neighborPaths.set(rel.page, []);
+                }
+                neighborPaths.get(rel.page).push({ page: row.path, link_type: rel.link_type, direction: rel.direction === "outbound" ? "inbound" : "outbound" });
             }
-            // Clean trailing pipe if any
-            summary = summary.replace(/\|?\s*$/, "").trim();
-            entries.push({
-                title: entryMatch[1].trim(),
-                path: normalizeWikiPath(entryMatch[2].trim()),
-                summary,
-                section: currentSection,
-                tags: tags.length > 0 ? tags : undefined,
-                updated: updated || undefined,
-            });
         }
     }
-    // Self-heal: if index is empty/corrupted but pages exist on disk, rebuild from disk.
-    if (entries.length === 0) {
-        const pages = listPages().filter((path) => !isActionLogPage(path));
-        if (pages.length > 0) {
-            const rebuilt = rebuildIndexFromPages();
-            cache = { mtimeMs, size, entries: rebuilt };
-            return rebuilt;
+    // Append neighbor pages as extra results (ranked after direct matches)
+    if (neighborPaths.size > 0) {
+        const neighborPathList = [...neighborPaths.keys()];
+        const placeholders = neighborPathList.map(() => "?").join(",");
+        const neighborRows = db.prepare(`
+      SELECT path, title, entity_type, summary, 0 as rank
+      FROM wiki_pages
+      WHERE path IN (${placeholders})
+    `).all(...neighborPathList);
+        for (const row of neighborRows) {
+            row.related = neighborPaths.get(row.path) ?? [];
+            directRows.push(row);
         }
     }
-    cache = { mtimeMs, size, entries };
-    return entries;
+    return directRows;
 }
+// ---------------------------------------------------------------------------
+// Backward-compatible API (delegates to SQLite)
+// ---------------------------------------------------------------------------
 /** Build (or refresh) an IndexEntry by reading the page from disk. */
 export function buildIndexEntryForPage(path, fallback) {
     const normalizedPath = normalizeWikiPath(path);
@@ -95,8 +271,6 @@ export function buildIndexEntryForPage(path, fallback) {
     const title = fm.title || fallback?.title || basenameTitle(normalizedPath);
     const tags = fm.tags ?? fallback?.tags ?? [];
     const updated = fm.updated || fallback?.updated;
-    // Compliant pages treat frontmatter summary as canonical. Legacy pages fall back
-    // to the first non-frontmatter, non-heading content line.
     let summary = fm.summary?.trim() || fallback?.summary?.trim() || "";
     if (!summary) {
         for (const raw of body.split("\n")) {
@@ -115,283 +289,84 @@ export function buildIndexEntryForPage(path, fallback) {
         path: normalizedPath,
         title,
         summary: summary || title,
-        section: fallback?.section || "Knowledge",
+        section: fallback?.section || categoryOfPath(normalizedPath) || "Knowledge",
         tags: tags.length ? tags : undefined,
         updated,
     };
 }
-function basenameTitle(path) {
-    const normalizedPath = normalizeWikiPath(path);
-    const file = normalizedPath.split("/").pop() || normalizedPath;
-    const base = file.replace(/\.md$/, "");
-    return base.split(/[-_]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
-}
-/** Rebuild every index entry from on-disk pages. Preserves section if known. */
-export function rebuildIndexFromPages() {
-    const pages = listPages().filter((path) => !isActionLogPage(path));
-    const previous = new Map();
-    // Try to keep section assignments by re-parsing the (possibly-corrupted) index without recursion.
-    try {
-        const raw = readIndexFile();
-        let section = "Knowledge";
-        for (const line of raw.split("\n")) {
-            const sm = line.match(/^##\s+(.+)/);
-            if (sm) {
-                section = sm[1].trim();
-                continue;
-            }
-            const em = line.match(/^\s*-\s+\[.+?\]\((.+?)\)/);
-            if (em) {
-                const normalizedPath = normalizeWikiPath(em[1].trim());
-                previous.set(normalizedPath, { path: normalizedPath, title: "", summary: "", section });
-            }
-        }
-    }
-    catch { /* ignore */ }
-    const entries = [];
-    for (const p of pages) {
-        const entry = buildIndexEntryForPage(p, previous.get(p));
-        if (entry)
-            entries.push(entry);
-    }
-    // Write directly without recursion through addToIndex.
-    writeIndexInternal(entries);
-    invalidateCache();
-    return entries;
-}
-/** Regenerate index.md from a list of entries, grouped by section. */
-export function writeIndex(entries) {
-    writeIndexInternal(entries);
-    invalidateCache();
-}
-/** Derive the top-level category of a page from its path under pages/. */
-function categoryOfPath(path) {
-    const rest = path.startsWith("pages/") ? path.slice("pages/".length) : path;
-    const segs = rest.split("/").filter(Boolean);
-    if (segs.length <= 1)
-        return (segs[0] || "pages").replace(/\.md$/i, "");
-    return segs[0];
-}
-/** Derive the topic slug of an entity-category page (pages/<cat>/<topic>/<file>), if any. */
-function topicOfPath(path) {
-    const rest = path.startsWith("pages/") ? path.slice("pages/".length) : path;
-    const segs = rest.split("/").filter(Boolean);
-    return segs.length >= 3 ? segs[1] : undefined;
-}
-function isTopicIndexFile(path) {
-    return /\/index\.md$/i.test(path);
-}
-function humanize(slug) {
-    return slug.split(/[-_]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
-}
-function renderEntryLine(item, indent = "") {
-    let line = `${indent}- [${item.title}](${item.path}) — ${item.summary}`;
-    if (item.tags?.length)
-        line += ` | tags: ${item.tags.join(", ")}`;
-    if (item.updated)
-        line += ` | updated: ${item.updated}`;
-    return line;
-}
-function writeIndexInternal(entries) {
-    // Group by top-level category derived from the page path (not the stored
-    // `section`, which is no longer authoritative).
-    const byCategory = new Map();
-    for (const entry of entries) {
-        const cat = categoryOfPath(entry.path);
-        const list = byCategory.get(cat) || [];
-        list.push(entry);
-        byCategory.set(cat, list);
-    }
-    const entityCats = entityCategories();
-    const entityCatSet = new Set(entityCats);
-    const known = [...entityCats, ...FLAT_CATEGORIES];
-    const orderedCategories = [
-        ...known.filter((c) => byCategory.has(c)),
-        ...[...byCategory.keys()].filter((c) => !known.includes(c)).sort(),
-    ];
-    const lines = [
-        "# Wiki Index",
-        "",
-        "_Max's knowledge base. This file is maintained automatically._",
-        "",
-        `Last updated: ${new Date().toISOString().slice(0, 10)}`,
-        "",
-    ];
-    for (const cat of orderedCategories) {
-        const items = byCategory.get(cat);
-        lines.push(`## ${humanize(cat)}`, "");
-        if (entityCatSet.has(cat)) {
-            // Two-level layout: topic directory -> overview (index.md) + facet pages.
-            // Pages not yet in canonical <category>/<topic>/<file> shape are listed as
-            // plain bullets (they'll be relocated by the topic-structure migration).
-            const byTopic = new Map();
-            const ungrouped = [];
-            for (const entry of items) {
-                const topic = topicOfPath(entry.path);
-                if (!topic) {
-                    ungrouped.push(entry);
-                    continue;
-                }
-                const list = byTopic.get(topic) || [];
-                list.push(entry);
-                byTopic.set(topic, list);
-            }
-            for (const topic of [...byTopic.keys()].sort()) {
-                const topicItems = byTopic.get(topic);
-                const overview = topicItems.find((e) => isTopicIndexFile(e.path));
-                const facets = topicItems
-                    .filter((e) => !isTopicIndexFile(e.path))
-                    .sort((a, b) => a.path.localeCompare(b.path));
-                if (overview) {
-                    lines.push(renderEntryLine(overview));
-                }
-                else {
-                    lines.push(`- **${humanize(topic)}** _(no overview page)_`);
-                }
-                for (const facet of facets)
-                    lines.push(renderEntryLine(facet, "  "));
-            }
-            for (const entry of ungrouped.sort((a, b) => a.path.localeCompare(b.path))) {
-                lines.push(renderEntryLine(entry));
-            }
+/** Parse the wiki_pages DB into IndexEntry array (replaces reading index.md). */
+export function parseIndex() {
+    const db = getDb();
+    const rows = db.prepare(`
+    SELECT path, title, tags, summary, last_updated
+    FROM wiki_pages
+    ORDER BY path
+  `).all();
+    return rows.map((row) => {
+        let tags;
+        try {
+            const parsed = JSON.parse(row.tags || "[]");
+            tags = Array.isArray(parsed) && parsed.length > 0 ? parsed : undefined;
         }
-        else {
-            for (const entry of [...items].sort((a, b) => a.path.localeCompare(b.path))) {
-                lines.push(renderEntryLine(entry));
-            }
+        catch {
+            tags = undefined;
         }
-        lines.push("");
-    }
-    if (orderedCategories.length === 0) {
-        lines.push("## Pages", "", "_(No pages yet.)_", "");
-    }
-    writeIndexFile(lines.join("\n"));
-}
-function isActionLogPage(path) {
-    return ACTION_LOG_PAGE_RE.test(path);
+        return {
+            path: row.path,
+            title: row.title,
+            summary: row.summary || row.title,
+            section: categoryOfPath(row.path),
+            tags,
+            updated: row.last_updated?.slice(0, 10) || undefined,
+        };
+    });
 }
-/** Add or update an entry in the index. Upserts by path. */
+/** Add or update a page in the index. Delegates to upsertWikiPage. */
 export function addToIndex(entry) {
-    const normalizedEntry = { ...entry, path: normalizeWikiPath(entry.path) };
-    const entries = parseIndex();
-    const existing = entries.findIndex((e) => e.path === normalizedEntry.path);
-    if (existing >= 0) {
-        entries[existing] = normalizedEntry;
-    }
-    else {
-        entries.push(normalizedEntry);
-    }
-    writeIndex(entries);
+    const fm = {
+        title: entry.title,
+        summary: entry.summary,
+        updated: entry.updated,
+        tags: entry.tags ?? [],
+        metadata: {},
+    };
+    upsertWikiPage(entry.path, fm, entry.summary);
 }
-/** Remove an entry from the index by path. */
+/** Remove an entry from the index by path. Returns true if found. */
 export function removeFromIndex(path) {
+    const db = getDb();
     const normalizedPath = normalizeWikiPath(path);
-    const entries = parseIndex();
-    const filtered = entries.filter((e) => e.path !== normalizedPath);
-    if (filtered.length === entries.length)
+    const existing = db.prepare(`SELECT 1 FROM wiki_pages WHERE path = ?`).get(normalizedPath);
+    if (!existing)
         return false;
-    writeIndex(filtered);
+    removeWikiPage(normalizedPath);
     return true;
 }
 /**
  * Search the index for entries matching a query.
- * Matches against title, summary, section, path, and tags using keyword overlap.
- * Boosts recently updated pages as a tiebreaker.
- *
- * - Short tokens (>=2 chars) are kept so acronyms like "AI"/"UI"/"JS" work.
- * - Single-letter tokens are dropped to avoid noise.
- * - Tag/title exact matches and prefix matches get a strong score boost.
- * - Falls back to scanning page bodies when index search returns nothing.
+ * Delegates to wikiSearch and maps back to IndexEntry shape.
  */
 export function searchIndex(query, limit = 10) {
-    const entries = parseIndex();
-    if (entries.length === 0)
-        return [];
-    const queryWords = new Set(query.toLowerCase().split(/\s+/).filter((w) => w.length >= 2));
-    if (queryWords.size === 0) {
-        return entries.slice(0, limit);
-    }
-    const now = Date.now();
-    const scored = entries.map((entry) => {
-        const titleLc = entry.title.toLowerCase();
-        const summaryLc = entry.summary.toLowerCase();
-        const sectionLc = entry.section.toLowerCase();
-        const pathLc = entry.path.toLowerCase();
-        const tagSet = new Set((entry.tags || []).map((t) => t.toLowerCase()));
-        let hits = 0;
-        for (const q of queryWords) {
-            // Strongest signals: exact tag or exact title
-            if (tagSet.has(q)) {
-                hits += 5;
-                continue;
-            }
-            if (titleLc === q) {
-                hits += 5;
-                continue;
-            }
-            // Strong: title starts with token, or path basename equals token
-            if (titleLc.startsWith(q)) {
-                hits += 3;
-                continue;
-            }
-            const base = pathLc.split("/").pop()?.replace(/\.md$/, "") || "";
-            if (base === q) {
-                hits += 3;
-                continue;
-            }
-            // Medium: substring in title/summary/section
-            if (titleLc.includes(q) || summaryLc.includes(q) || sectionLc.includes(q)) {
-                hits += 2;
-                continue;
-            }
-            // Weak: substring in path or any tag
-            if (pathLc.includes(q)) {
-                hits += 1;
-                continue;
-            }
-            for (const tag of tagSet) {
-                if (tag.includes(q)) {
-                    hits += 1;
-                    break;
-                }
-            }
-        }
-        let recencyBoost = 0;
-        if (entry.updated) {
-            const daysSince = (now - new Date(entry.updated).getTime()) / (1000 * 60 * 60 * 24);
-            if (daysSince < 7)
-                recencyBoost = 0.5;
-            else if (daysSince < 30)
-                recencyBoost = 0.2;
-        }
-        return { entry, score: hits + recencyBoost };
-    })
-        .filter((s) => s.score > 0)
-        .sort((a, b) => b.score - a.score)
-        .slice(0, limit);
-    if (scored.length > 0) {
-        return scored.map((s) => s.entry);
-    }
-    // Fallback: scan page bodies (bounded to avoid O(N*size) blowup).
-    const MAX_BODY_SCAN = 50;
-    const bodyHits = [];
-    for (const entry of entries.slice(0, MAX_BODY_SCAN)) {
-        const body = readPage(entry.path);
-        if (!body)
-            continue;
-        const bodyLc = body.toLowerCase();
-        let bodyScore = 0;
-        for (const q of queryWords) {
-            if (bodyLc.includes(q))
-                bodyScore += 1;
-        }
-        if (bodyScore > 0)
-            bodyHits.push({ entry, score: bodyScore });
-    }
-    bodyHits.sort((a, b) => b.score - a.score);
-    return bodyHits.slice(0, limit).map((s) => s.entry);
+    const results = wikiSearch(query, limit);
+    return results.map((r) => ({
+        path: r.path,
+        title: r.title,
+        summary: r.summary || r.title,
+        section: categoryOfPath(r.path),
+        updated: undefined,
+    }));
+}
+/** Rebuild wiki_pages from disk. Delegates to rebuildWikiIndex. Returns entries. */
+export function rebuildIndexFromPages() {
+    rebuildWikiIndex();
+    return parseIndex();
+}
+/** No-op: pages/index.md is no longer written. Kept for backward compat. */
+export function writeIndex(_entries) {
+    // File-based index.md writes removed in Sprint 1 Track B (PKB Foundation).
+    // The SQLite wiki_pages table is the authoritative index.
 }
-/** Get a compact text summary of the index for injection into context. */
+/** Get a compact text summary of the index for context injection. */
 export function getIndexSummary() {
     const entries = parseIndex();
     if (entries.length === 0)