@jungjaehoon/mama-core 1.4.2 → 1.6.0

package/dist/cases/types.d.ts

@@ -0,0 +1,244 @@
+export declare const CASE_TRUTH_STATUSES: readonly ["active", "blocked", "resolved", "stale", "archived", "merged", "split"];
+export type CaseTruthStatus = (typeof CASE_TRUTH_STATUSES)[number];
+export declare const CASE_FAST_WRITE_STATUSES: readonly ["active", "blocked", "resolved", "stale"];
+export type CaseFastWriteStatus = (typeof CASE_FAST_WRITE_STATUSES)[number];
+export declare const CASE_MEMBERSHIP_SOURCE_TYPES: readonly ["decision", "event", "observation", "artifact"];
+export type CaseMembershipSourceType = (typeof CASE_MEMBERSHIP_SOURCE_TYPES)[number];
+export declare const CASE_MEMBERSHIP_STATUSES: readonly ["active", "candidate", "removed", "excluded", "stale"];
+export type CaseMembershipStatus = (typeof CASE_MEMBERSHIP_STATUSES)[number];
+export declare const CASE_MEMBERSHIP_ADDED_BY: readonly ["wiki-compiler", "memory-agent", "user-correction"];
+export type CaseMembershipAddedBy = (typeof CASE_MEMBERSHIP_ADDED_BY)[number];
+export declare const CASE_CORRECTION_TARGET_KINDS: readonly ["case_field", "membership", "wiki_section"];
+export type CaseCorrectionTargetKind = (typeof CASE_CORRECTION_TARGET_KINDS)[number];
+export declare const CASE_PROPOSAL_KINDS: readonly ["ambiguous_slug", "duplicate_frontmatter", "missing_frontmatter", "unknown_case_id", "stale_case_id", "merged_target", "archived_target", "lock_conflict", "corrupt_frontmatter", "quarantined_accepted_case"];
+export type CaseProposalKind = (typeof CASE_PROPOSAL_KINDS)[number];
+export declare const CASE_PROPOSAL_RESOLUTIONS: readonly ["accepted", "rejected", "modified", "merged"];
+export type CaseProposalResolution = (typeof CASE_PROPOSAL_RESOLUTIONS)[number];
+export declare const CASE_CONFIDENCE_LEVELS: readonly ["high", "medium", "low"];
+export type CaseConfidence = (typeof CASE_CONFIDENCE_LEVELS)[number];
+export interface CaseTruthRecord {
+    case_id: string;
+    current_wiki_path: string | null;
+    title: string;
+    status: CaseTruthStatus;
+    status_reason: string | null;
+    primary_actors: string | null;
+    blockers: string | null;
+    last_activity_at: string | null;
+    canonical_case_id?: string | null;
+    split_from_case_id?: string | null;
+    wiki_path_history: string | null;
+    scope_refs: string | null;
+    confidence: CaseConfidence | null;
+    compiled_at: string | null;
+    state_updated_at: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface CaseMembershipRecord {
+    case_id: string;
+    source_type: CaseMembershipSourceType;
+    source_id: string;
+    role: string | null;
+    confidence: number | null;
+    reason: string | null;
+    status: CaseMembershipStatus;
+    added_by: CaseMembershipAddedBy;
+    added_at: string;
+    updated_at: string;
+    user_locked: 0 | 1;
+}
+export interface CaseCorrectionRecord {
+    correction_id: string;
+    case_id: string;
+    target_kind: CaseCorrectionTargetKind;
+    target_ref_json: string;
+    target_ref_hash: Buffer;
+    field_name: string | null;
+    old_value_json: string | null;
+    new_value_json: string;
+    reason: string;
+    is_lock_active: 0 | 1;
+    superseded_by: string | null;
+    reverted_at: string | null;
+    applied_by: string;
+    applied_at: string;
+}
+export interface CaseCorrectionRequiresReconfirmResult {
+    kind: 'requires_reconfirm';
+    code: 'case.correction_requires_reconfirm';
+    case_id: string;
+    target_kind: CaseCorrectionTargetKind;
+    target_ref_json: string;
+    current_value_json: string;
+    old_value_json: string | null;
+    proposed_new_value_json: string;
+    reconfirm_token: string;
+    reconfirm_token_expires_at: string;
+    message: string;
+}
+export interface CaseProposalQueueRecord {
+    proposal_id: string;
+    project: string;
+    proposal_kind: CaseProposalKind;
+    proposed_payload: string;
+    payload_fingerprint: Buffer;
+    conflicting_case_id: string | null;
+    detected_at: string;
+    resolved_at: string | null;
+    resolution: CaseProposalResolution | null;
+    resolution_note: string | null;
+}
+export interface CasePrimaryActor {
+    entity_id: string;
+    role: string;
+}
+export interface CaseBlocker {
+    text: string;
+    source_decision_id?: string;
+    source_event_id?: string;
+}
+export interface CaseAssemblyMembership {
+    source_type: CaseMembershipSourceType;
+    source_id: string;
+    role: string | null;
+    confidence: number | null;
+    reason: string | null;
+    user_locked: boolean;
+}
+export interface CaseAssemblyDecision {
+    id: string;
+    topic: string;
+    decision: string;
+    reasoning: string | null;
+    confidence: number | null;
+    event_date: string | null;
+}
+export interface CaseAssemblyTimelineEvent {
+    event_id: string;
+    event_type: string;
+    entity_id: string;
+    role: string | null;
+    observed_at: string;
+    summary: string;
+    details: string | null;
+}
+export interface CaseAssemblyObservation {
+    observation_id: string;
+    surface_form: string;
+    source_locator: string;
+    timestamp_observed: string;
+}
+export interface CaseAssemblyCorrection {
+    correction_id: string;
+    target_kind: CaseCorrectionTargetKind;
+    target_ref: Record<string, unknown>;
+    new_value_json: string;
+    reason: string;
+    applied_at: string;
+}
+export interface CaseAssemblyLinkedCase {
+    case_id: string;
+    relation: 'merged_from' | 'split_into' | 'wikilink';
+}
+export interface WikiPageAssemblySnapshot {
+    title: string | null;
+    content: string | null;
+    confidence: CaseConfidence | null;
+    compiled_at: string | null;
+}
+export interface CaseAssembly {
+    case_id: string;
+    current_wiki_path: string | null;
+    wiki_page: WikiPageAssemblySnapshot | null;
+    case_truth: {
+        title: string;
+        status: CaseTruthStatus;
+        status_reason: string | null;
+        primary_actors: CasePrimaryActor[];
+        blockers: CaseBlocker[];
+        last_activity_at: string | null;
+        confidence: CaseConfidence | null;
+        canonical_case_id: string | null;
+        split_from_case_id: string | null;
+    } | null;
+    memberships: CaseAssemblyMembership[];
+    timeline_events: CaseAssemblyTimelineEvent[];
+    decisions: CaseAssemblyDecision[];
+    recent_evidence: CaseAssemblyObservation[];
+    active_corrections: CaseAssemblyCorrection[];
+    linked_cases: CaseAssemblyLinkedCase[];
+    resolved_via_case_id?: string;
+    case_links?: Array<{
+        link_id: string;
+        case_id_from: string;
+        case_id_to: string;
+        link_type: string;
+        created_at: string;
+        created_by: string;
+        confidence: number | null;
+        reason_json: string | null;
+        source_kind: string;
+        source_ref: string | null;
+    }>;
+    promoted_sources?: {
+        canonical_decision_id: string | null;
+        canonical_event_id: string | null;
+        promoted_at: string | null;
+        promoted_by: string | null;
+        promotion_reason: string | null;
+    } | null;
+    freshness?: {
+        freshness_score: number | null;
+        freshness_state: string | null;
+        freshness_score_is_drifted: 0 | 1;
+        freshness_drift_threshold: number | null;
+        freshness_checked_at: string | null;
+        freshness_reason_json: string | null;
+    } | null;
+    membership_explanations?: Record<string, Record<string, unknown>>;
+}
+export interface CanonicalCaseResolution {
+    terminal_case_id: string;
+    chain: string[];
+    resolved_via_case_id: string | null;
+}
+export interface CaseTimelineRangeInput {
+    case_id: string;
+    from?: string | number;
+    to?: string | number;
+    order?: 'asc' | 'desc';
+    limit?: number;
+    include_connector_enrichments?: boolean;
+}
+export interface CaseTimelineRangeItem {
+    item_type: CaseMembershipSourceType;
+    source_type: CaseMembershipSourceType;
+    source_id: string;
+    source_locator: string | null;
+    event_datetime: number | null;
+    event_date: string | null;
+    title: string | null;
+    summary: string | null;
+    role: string | null;
+    confidence: number | null;
+    membership_reason: string | null;
+    connector_event?: {
+        event_index_id: string;
+        source_connector: string;
+        source_id: string;
+        source_locator: string | null;
+        artifact_locator: string | null;
+        title: string | null;
+        content: string;
+        event_datetime: number | null;
+        event_date: string | null;
+    } | null;
+}
+export interface CaseTimelineRangeResult {
+    terminal_case_id: string;
+    resolved_via_case_id: string | null;
+    chain: string[];
+    items: CaseTimelineRangeItem[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/cases/types.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CASE_CONFIDENCE_LEVELS = exports.CASE_PROPOSAL_RESOLUTIONS = exports.CASE_PROPOSAL_KINDS = exports.CASE_CORRECTION_TARGET_KINDS = exports.CASE_MEMBERSHIP_ADDED_BY = exports.CASE_MEMBERSHIP_STATUSES = exports.CASE_MEMBERSHIP_SOURCE_TYPES = exports.CASE_FAST_WRITE_STATUSES = exports.CASE_TRUTH_STATUSES = void 0;
+exports.CASE_TRUTH_STATUSES = [
+    'active',
+    'blocked',
+    'resolved',
+    'stale',
+    'archived',
+    'merged',
+    'split',
+];
+exports.CASE_FAST_WRITE_STATUSES = ['active', 'blocked', 'resolved', 'stale'];
+exports.CASE_MEMBERSHIP_SOURCE_TYPES = [
+    'decision',
+    'event',
+    'observation',
+    'artifact',
+];
+exports.CASE_MEMBERSHIP_STATUSES = [
+    'active',
+    'candidate',
+    'removed',
+    'excluded',
+    'stale',
+];
+exports.CASE_MEMBERSHIP_ADDED_BY = [
+    'wiki-compiler',
+    'memory-agent',
+    'user-correction',
+];
+exports.CASE_CORRECTION_TARGET_KINDS = ['case_field', 'membership', 'wiki_section'];
+exports.CASE_PROPOSAL_KINDS = [
+    'ambiguous_slug',
+    'duplicate_frontmatter',
+    'missing_frontmatter',
+    'unknown_case_id',
+    'stale_case_id',
+    'merged_target',
+    'archived_target',
+    'lock_conflict',
+    'corrupt_frontmatter',
+    'quarantined_accepted_case',
+];
+exports.CASE_PROPOSAL_RESOLUTIONS = ['accepted', 'rejected', 'modified', 'merged'];
+exports.CASE_CONFIDENCE_LEVELS = ['high', 'medium', 'low'];
+//# sourceMappingURL=types.js.map

package/dist/cases/wiki-page-index.d.ts

@@ -0,0 +1,50 @@
+import type { DatabaseAdapter as DBManagerAdapter } from '../db-manager.js';
+export type AdapterLike = Pick<DBManagerAdapter, 'prepare' | 'transaction'>;
+export interface WikiPageIndexRecord {
+    id: number;
+    source_locator: string;
+    page_type: 'entity' | 'lesson' | 'synthesis' | 'process' | 'case';
+    title: string;
+    content: string;
+    case_id: string | null;
+    source_ids: string[];
+    entity_refs: string[];
+    confidence: 'high' | 'medium' | 'low' | null;
+    compiled_at: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface WikiPageSearchHit {
+    record: WikiPageIndexRecord;
+    rank: number;
+    raw_score: number;
+}
+export interface UpsertWikiPageIndexInput {
+    source_locator: string;
+    page_type: WikiPageIndexRecord['page_type'];
+    title: string;
+    content: string;
+    case_id?: string | null;
+    source_ids: string[];
+    entity_refs: string[];
+    confidence: WikiPageIndexRecord['confidence'];
+    compiled_at: string;
+    embedding?: Float32Array | null;
+    embedding_model?: string;
+}
+export declare function upsertWikiPageIndexEntry(adapter: AdapterLike, input: UpsertWikiPageIndexInput): {
+    id: number;
+    created: boolean;
+};
+export declare function deleteWikiPageIndexEntry(adapter: AdapterLike, source_locator: string): {
+    deleted: boolean;
+};
+export declare function ftsSearchWikiPages(adapter: AdapterLike, query: string, limit: number): WikiPageSearchHit[];
+export declare function vectorSearchWikiPages(adapter: AdapterLike, queryEmbedding: Float32Array, limit: number): WikiPageSearchHit[];
+export declare function searchWikiPages(input: {
+    adapter: AdapterLike;
+    query: string;
+    queryEmbedding?: Float32Array | null;
+    limit: number;
+}): WikiPageSearchHit[];
+//# sourceMappingURL=wiki-page-index.d.ts.map

package/dist/cases/wiki-page-index.js

@@ -0,0 +1,350 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertWikiPageIndexEntry = upsertWikiPageIndexEntry;
+exports.deleteWikiPageIndexEntry = deleteWikiPageIndexEntry;
+exports.ftsSearchWikiPages = ftsSearchWikiPages;
+exports.vectorSearchWikiPages = vectorSearchWikiPages;
+exports.searchWikiPages = searchWikiPages;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const embeddings_js_1 = require("../embeddings.js");
+function tableColumns(adapter, tableName) {
+    const rows = adapter.prepare(`PRAGMA table_info(${tableName})`).all();
+    return new Set(rows.map((row) => row.name));
+}
+function readSchema(adapter) {
+    const indexColumns = tableColumns(adapter, 'wiki_page_index');
+    const embeddingColumns = tableColumns(adapter, 'wiki_page_embeddings');
+    if (!indexColumns.has('id') && !indexColumns.has('page_id')) {
+        throw new Error('wiki_page_index schema is missing both id and page_id columns.');
+    }
+    return {
+        hasIdColumn: indexColumns.has('id'),
+        hasPageIdColumn: indexColumns.has('page_id'),
+        hasSourceTypeColumn: indexColumns.has('source_type'),
+        hasSourceIdsColumn: indexColumns.has('source_ids'),
+        hasEntityRefsColumn: indexColumns.has('entity_refs'),
+        hasCreatedAtColumn: indexColumns.has('created_at'),
+        embeddingUsesWikiPageId: embeddingColumns.has('wiki_page_id'),
+        embeddingUsesVector: embeddingColumns.has('vector'),
+        embeddingHasModel: embeddingColumns.has('model'),
+        embeddingHasDim: embeddingColumns.has('dim'),
+        embeddingHasCreatedAt: embeddingColumns.has('created_at'),
+    };
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+function normalizeLimit(limit) {
+    if (!Number.isFinite(limit)) {
+        return 10;
+    }
+    return Math.max(0, Math.floor(limit));
+}
+function pageIdForSourceLocator(sourceLocator) {
+    const digest = node_crypto_1.default.createHash('sha256').update(sourceLocator).digest('hex').slice(0, 24);
+    return `wiki_page_${digest}`;
+}
+function parseJsonArray(value) {
+    if (value === null || value === undefined || value === '') {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value.map(String);
+    }
+    if (typeof value !== 'string') {
+        return [];
+    }
+    const parsed = JSON.parse(value);
+    if (!Array.isArray(parsed)) {
+        throw new Error('wiki_page_index JSON array column decoded to a non-array value.');
+    }
+    return parsed.map(String);
+}
+function normalizeConfidence(value) {
+    if (value === 'high' || value === 'medium' || value === 'low') {
+        return value;
+    }
+    return null;
+}
+function rowToRecord(row) {
+    const id = Number(row.id);
+    if (!Number.isFinite(id)) {
+        throw new Error('wiki_page_index row is missing a numeric id/rowid.');
+    }
+    return {
+        id,
+        source_locator: String(row.source_locator ?? ''),
+        page_type: row.page_type,
+        title: String(row.title ?? ''),
+        content: String(row.content ?? ''),
+        case_id: row.case_id === null || row.case_id === undefined ? null : String(row.case_id),
+        source_ids: parseJsonArray(row.source_ids),
+        entity_refs: parseJsonArray(row.entity_refs),
+        confidence: normalizeConfidence(row.confidence),
+        compiled_at: String(row.compiled_at ?? ''),
+        created_at: String(row.created_at ?? row.updated_at ?? row.compiled_at ?? ''),
+        updated_at: String(row.updated_at ?? row.created_at ?? row.compiled_at ?? ''),
+    };
+}
+function selectByLocator(adapter, schema, sourceLocator) {
+    const sql = schema.hasIdColumn
+        ? 'SELECT * FROM wiki_page_index WHERE source_locator = ?'
+        : 'SELECT rowid AS id, * FROM wiki_page_index WHERE source_locator = ?';
+    const row = adapter.prepare(sql).get(sourceLocator);
+    return row ? rowToRecord(row) : null;
+}
+function selectByFtsPageId(adapter, schema, pageId) {
+    const sql = schema.hasIdColumn
+        ? 'SELECT * FROM wiki_page_index WHERE id = ?'
+        : 'SELECT rowid AS id, * FROM wiki_page_index WHERE page_id = ?';
+    const lookup = schema.hasIdColumn ? Number(pageId) : String(pageId);
+    const row = adapter.prepare(sql).get(lookup);
+    return row ? rowToRecord(row) : null;
+}
+function vectorToBuffer(embedding) {
+    return Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+}
+function blobToVector(value) {
+    if (!(value instanceof Uint8Array)) {
+        return null;
+    }
+    if (value.byteLength % 4 !== 0) {
+        return null;
+    }
+    const buffer = Buffer.isBuffer(value) ? value : Buffer.from(value);
+    const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    return new Float32Array(arrayBuffer);
+}
+function upsertEmbedding(adapter, schema, record, input) {
+    if (!input.embedding) {
+        return;
+    }
+    const vector = vectorToBuffer(input.embedding);
+    const model = input.embedding_model ?? embeddings_js_1.MODEL_NAME;
+    const dim = input.embedding.length;
+    if (schema.embeddingUsesWikiPageId && schema.embeddingUsesVector) {
+        adapter
+            .prepare(`
+          INSERT INTO wiki_page_embeddings(wiki_page_id, vector, model, dim, created_at)
+          VALUES (?, ?, ?, ?, ?)
+          ON CONFLICT(wiki_page_id) DO UPDATE SET
+            vector = excluded.vector,
+            model = excluded.model,
+            dim = excluded.dim
+        `)
+            .run(record.id, vector, model, dim, nowIso());
+        return;
+    }
+    adapter
+        .prepare(`
+        INSERT INTO wiki_page_embeddings(page_id, embedding)
+        VALUES (?, ?)
+        ON CONFLICT(page_id) DO UPDATE SET
+          embedding = excluded.embedding
+      `)
+        .run(pageIdForSourceLocator(record.source_locator), vector);
+}
+function buildFtsQuery(query) {
+    const tokens = query
+        .toLowerCase()
+        .match(/[\p{L}\p{N}_]+/gu)
+        ?.filter((token) => token.length > 0);
+    if (!tokens || tokens.length === 0) {
+        return query;
+    }
+    return tokens.map((token) => `"${token.replace(/"/g, '""')}"`).join(' OR ');
+}
+function normalizeBm25Score(raw) {
+    const value = Number(raw);
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    if (value < 0) {
+        return 1 + Math.abs(value);
+    }
+    return 1 / (1 + value);
+}
+function searchTableExists(adapter, tableName) {
+    const row = adapter
+        .prepare("SELECT name FROM sqlite_master WHERE name = ? AND type IN ('table','virtual table')")
+        .get(tableName);
+    return row !== undefined;
+}
+function upsertWikiPageIndexEntry(adapter, input) {
+    const schema = readSchema(adapter);
+    const existing = selectByLocator(adapter, schema, input.source_locator);
+    const updatedAt = nowIso();
+    return adapter.transaction(() => {
+        if (schema.hasIdColumn) {
+            adapter
+                .prepare(`
+            INSERT INTO wiki_page_index (
+              source_locator, page_type, title, content, case_id, source_ids,
+              confidence, entity_refs, compiled_at, created_at, updated_at
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(source_locator) DO UPDATE SET
+              page_type = excluded.page_type,
+              title = excluded.title,
+              content = excluded.content,
+              case_id = excluded.case_id,
+              source_ids = excluded.source_ids,
+              confidence = excluded.confidence,
+              entity_refs = excluded.entity_refs,
+              compiled_at = excluded.compiled_at,
+              updated_at = excluded.updated_at
+          `)
+                .run(input.source_locator, input.page_type, input.title, input.content, input.case_id ?? null, JSON.stringify(input.source_ids), input.confidence, JSON.stringify(input.entity_refs), input.compiled_at, updatedAt, updatedAt);
+        }
+        else if (schema.hasSourceIdsColumn && schema.hasEntityRefsColumn) {
+            adapter
+                .prepare(`
+            INSERT INTO wiki_page_index (
+              page_id, source_type, source_locator, case_id, title, page_type,
+              content, confidence, source_ids, entity_refs, compiled_at, updated_at
+            )
+            VALUES (?, 'wiki_page', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(source_type, source_locator) DO UPDATE SET
+              case_id = excluded.case_id,
+              title = excluded.title,
+              page_type = excluded.page_type,
+              content = excluded.content,
+              confidence = excluded.confidence,
+              source_ids = excluded.source_ids,
+              entity_refs = excluded.entity_refs,
+              compiled_at = excluded.compiled_at,
+              updated_at = excluded.updated_at
+          `)
+                .run(pageIdForSourceLocator(input.source_locator), input.source_locator, input.case_id ?? null, input.title, input.page_type, input.content, input.confidence, JSON.stringify(input.source_ids), JSON.stringify(input.entity_refs), input.compiled_at, updatedAt);
+        }
+        else {
+            adapter
+                .prepare(`
+            INSERT INTO wiki_page_index (
+              page_id, source_type, source_locator, case_id, title, page_type,
+              content, confidence, compiled_at, updated_at
+            )
+            VALUES (?, 'wiki_page', ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(source_type, source_locator) DO UPDATE SET
+              case_id = excluded.case_id,
+              title = excluded.title,
+              page_type = excluded.page_type,
+              content = excluded.content,
+              confidence = excluded.confidence,
+              compiled_at = excluded.compiled_at,
+              updated_at = excluded.updated_at
+          `)
+                .run(pageIdForSourceLocator(input.source_locator), input.source_locator, input.case_id ?? null, input.title, input.page_type, input.content, input.confidence, input.compiled_at, updatedAt);
+        }
+        const saved = selectByLocator(adapter, schema, input.source_locator);
+        if (!saved) {
+            throw new Error(`Failed to load wiki_page_index row for ${input.source_locator}.`);
+        }
+        upsertEmbedding(adapter, schema, saved, input);
+        return {
+            id: saved.id,
+            created: existing === null,
+        };
+    });
+}
+function deleteWikiPageIndexEntry(adapter, source_locator) {
+    const result = adapter
+        .prepare('DELETE FROM wiki_page_index WHERE source_locator = ?')
+        .run(source_locator);
+    return { deleted: result.changes > 0 };
+}
+function ftsSearchWikiPages(adapter, query, limit) {
+    const boundedLimit = normalizeLimit(limit);
+    if (boundedLimit === 0 || !query.trim()) {
+        return [];
+    }
+    if (!searchTableExists(adapter, 'wiki_pages_fts')) {
+        return [];
+    }
+    const schema = readSchema(adapter);
+    const rows = adapter
+        .prepare(`
+        SELECT page_id, bm25(wiki_pages_fts) AS raw
+        FROM wiki_pages_fts
+        WHERE wiki_pages_fts MATCH ?
+        ORDER BY raw
+        LIMIT ?
+      `)
+        .all(buildFtsQuery(query), boundedLimit);
+    const hits = [];
+    for (const row of rows) {
+        const record = selectByFtsPageId(adapter, schema, row.page_id);
+        if (!record) {
+            continue;
+        }
+        hits.push({
+            record,
+            rank: hits.length,
+            raw_score: normalizeBm25Score(row.raw),
+        });
+    }
+    return hits;
+}
+function vectorSearchWikiPages(adapter, queryEmbedding, limit) {
+    const boundedLimit = normalizeLimit(limit);
+    if (boundedLimit === 0) {
+        return [];
+    }
+    const schema = readSchema(adapter);
+    const rows = schema.embeddingUsesWikiPageId
+        ? adapter
+            .prepare(`
+            SELECT i.*, e.vector
+            FROM wiki_page_embeddings e
+            JOIN wiki_page_index i ON i.id = e.wiki_page_id
+          `)
+            .all()
+        : adapter
+            .prepare(`
+            SELECT i.rowid AS id, i.*, e.embedding
+            FROM wiki_page_embeddings e
+            JOIN wiki_page_index i ON i.page_id = e.page_id
+          `)
+            .all();
+    const scored = [];
+    for (const row of rows) {
+        const candidate = blobToVector(schema.embeddingUsesVector ? row.vector : row.embedding);
+        if (!candidate || candidate.length !== queryEmbedding.length) {
+            continue;
+        }
+        const score = (0, embeddings_js_1.cosineSimilarity)(candidate, queryEmbedding);
+        if (!Number.isFinite(score)) {
+            continue;
+        }
+        scored.push({ record: rowToRecord(row), score });
+    }
+    return scored
+        .sort((left, right) => right.score - left.score)
+        .slice(0, boundedLimit)
+        .map((entry, rank) => ({
+        record: entry.record,
+        rank,
+        raw_score: entry.score,
+    }));
+}
+function searchWikiPages(input) {
+    const ftsHits = ftsSearchWikiPages(input.adapter, input.query, input.limit);
+    const vectorHits = input.queryEmbedding
+        ? vectorSearchWikiPages(input.adapter, input.queryEmbedding, input.limit)
+        : [];
+    const merged = new Map();
+    for (const hit of [...ftsHits, ...vectorHits]) {
+        const existing = merged.get(hit.record.id);
+        if (!existing || hit.raw_score > existing.raw_score) {
+            merged.set(hit.record.id, hit);
+        }
+    }
+    return Array.from(merged.values())
+        .sort((left, right) => right.raw_score - left.raw_score)
+        .slice(0, normalizeLimit(input.limit))
+        .map((hit, rank) => ({ ...hit, rank }));
+}
+//# sourceMappingURL=wiki-page-index.js.map