@lemoncat7/dsh-knowledge 0.6.0-alpha.6

package/lib/local-provider.js

@@ -0,0 +1,1096 @@
+import { dirname } from 'node:path';
+import { createHash, randomBytes } from 'node:crypto';
+import { mkdirSync } from 'node:fs';
+import { DatabaseSync } from 'node:sqlite';
+import { contentHash, DEFAULT_KNOWLEDGE_BASE_ID, newId, normalizeDraft, normalizeKnowledgeBaseDraft, normalizeKnowledgeMountDraft, nowIso, } from './domain.js';
+const ENTRY_COLUMNS = `
+  id, knowledge_base_id, title, body, type, tags_json, scope_kind, scope_id, confidence,
+  status, version, source_json, created_at, updated_at
+`;
+const JOINED_ENTRY_COLUMNS = `
+  e.id AS id, e.knowledge_base_id AS knowledge_base_id, e.title AS title, e.body AS body, e.type AS type,
+  e.tags_json AS tags_json, e.scope_kind AS scope_kind, e.scope_id AS scope_id,
+  e.confidence AS confidence, e.status AS status, e.version AS version,
+  e.source_json AS source_json, e.created_at AS created_at, e.updated_at AS updated_at
+`;
+export class LocalKnowledgeProvider {
+    mode = 'local';
+    db;
+    closed = false;
+    constructor(path) {
+        if (path !== ':memory:')
+            mkdirSync(dirname(path), { recursive: true });
+        this.db = new DatabaseSync(path);
+        this.db.exec('PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 5000;');
+        this.migrate();
+    }
+    migrate() {
+        let version = Number(this.db.prepare('PRAGMA user_version').get().user_version ?? 0);
+        if (version > 4)
+            throw new Error(`knowledge database schema ${version} is newer than this plugin supports`);
+        if (version === 0)
+            this.db.exec(`
+      BEGIN IMMEDIATE;
+      CREATE TABLE knowledge_entries (
+        id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        body TEXT NOT NULL,
+        type TEXT NOT NULL CHECK(type IN ('preference','fact','decision','procedure','lesson')),
+        tags_json TEXT NOT NULL,
+        scope_kind TEXT NOT NULL CHECK(scope_kind IN ('global','project')),
+        scope_id TEXT,
+        confidence REAL NOT NULL CHECK(confidence >= 0 AND confidence <= 1),
+        status TEXT NOT NULL CHECK(status IN ('active','archived')),
+        version INTEGER NOT NULL,
+        content_hash TEXT NOT NULL,
+        source_json TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        CHECK((scope_kind = 'global' AND scope_id IS NULL) OR (scope_kind = 'project' AND length(scope_id) > 0))
+      );
+      CREATE INDEX knowledge_entries_scope_status ON knowledge_entries(status, scope_kind, scope_id, updated_at DESC);
+      CREATE INDEX knowledge_entries_type ON knowledge_entries(type, status);
+      CREATE UNIQUE INDEX knowledge_entries_active_hash ON knowledge_entries(content_hash) WHERE status = 'active';
+
+      CREATE TABLE knowledge_versions (
+        id TEXT PRIMARY KEY,
+        knowledge_id TEXT NOT NULL REFERENCES knowledge_entries(id) ON DELETE CASCADE,
+        version INTEGER NOT NULL,
+        snapshot_json TEXT NOT NULL,
+        change_kind TEXT NOT NULL CHECK(change_kind IN ('create','update','archive','restore')),
+        created_at TEXT NOT NULL,
+        UNIQUE(knowledge_id, version)
+      );
+
+      CREATE TABLE knowledge_candidates (
+        id TEXT PRIMARY KEY,
+        action TEXT NOT NULL CHECK(action IN ('create','update','conflict')),
+        target_id TEXT,
+        draft_json TEXT NOT NULL,
+        reason TEXT NOT NULL,
+        status TEXT NOT NULL CHECK(status IN ('pending','approved','rejected')),
+        source_key TEXT,
+        proposal_hash TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        reviewed_at TEXT,
+        review_note TEXT
+      );
+      CREATE UNIQUE INDEX knowledge_candidates_dedupe ON knowledge_candidates(source_key, proposal_hash) WHERE source_key IS NOT NULL;
+      CREATE INDEX knowledge_candidates_status ON knowledge_candidates(status, created_at DESC);
+
+      CREATE TABLE extraction_jobs (
+        source_key TEXT PRIMARY KEY,
+        status TEXT NOT NULL CHECK(status IN ('running','completed','failed')),
+        attempts INTEGER NOT NULL,
+        candidate_count INTEGER NOT NULL DEFAULT 0,
+        last_error TEXT,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE api_tokens (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        token_hash TEXT NOT NULL UNIQUE,
+        permissions_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        last_used_at TEXT,
+        revoked_at TEXT
+      );
+
+      CREATE VIRTUAL TABLE knowledge_fts USING fts5(
+        knowledge_id UNINDEXED,
+        title,
+        body,
+        tags,
+        tokenize = 'unicode61 remove_diacritics 2'
+      );
+      PRAGMA user_version = 1;
+      COMMIT;
+    `);
+        if (version === 0)
+            version = 1;
+        if (version === 1)
+            this.db.exec(`
+      BEGIN IMMEDIATE;
+      CREATE TABLE knowledge_bases (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT NOT NULL,
+        default_tags_json TEXT NOT NULL,
+        extraction_instructions TEXT NOT NULL,
+        status TEXT NOT NULL CHECK(status IN ('active','archived')),
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      INSERT INTO knowledge_bases(
+        id,name,description,default_tags_json,extraction_instructions,status,created_at,updated_at
+      ) VALUES(
+        'default','默认知识库','','[]','仅收录可跨会话复用、且与当前挂载范围相关的知识。','active',datetime('now'),datetime('now')
+      );
+      ALTER TABLE knowledge_entries ADD COLUMN knowledge_base_id TEXT NOT NULL DEFAULT 'default';
+      CREATE INDEX knowledge_entries_base_status ON knowledge_entries(knowledge_base_id, status, updated_at DESC);
+      CREATE TABLE knowledge_mounts (
+        id TEXT PRIMARY KEY,
+        target_kind TEXT NOT NULL CHECK(target_kind IN ('project','session')),
+        target_id TEXT NOT NULL,
+        knowledge_base_id TEXT NOT NULL REFERENCES knowledge_bases(id) ON DELETE CASCADE,
+        enabled INTEGER NOT NULL CHECK(enabled IN (0,1)),
+        recall_enabled INTEGER NOT NULL CHECK(recall_enabled IN (0,1)),
+        write_mode TEXT NOT NULL CHECK(write_mode IN ('none','audit','direct')),
+        include_tags_json TEXT NOT NULL,
+        exclude_tags_json TEXT NOT NULL,
+        extraction_instructions TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(target_kind, target_id, knowledge_base_id)
+      );
+      CREATE INDEX knowledge_mounts_target ON knowledge_mounts(target_kind, target_id, enabled);
+      PRAGMA user_version = 2;
+      COMMIT;
+    `);
+        if (version <= 1)
+            version = 2;
+        if (version === 2)
+            this.db.exec(`
+      BEGIN IMMEDIATE;
+      ALTER TABLE knowledge_bases ADD COLUMN writeback_provider TEXT;
+      ALTER TABLE knowledge_bases ADD COLUMN writeback_model TEXT;
+      PRAGMA user_version = 3;
+      COMMIT;
+    `);
+        if (version <= 2)
+            version = 3;
+        if (version === 3)
+            this.db.exec(`
+      BEGIN IMMEDIATE;
+      CREATE TABLE knowledge_documents (
+        id TEXT PRIMARY KEY,
+        knowledge_base_id TEXT NOT NULL REFERENCES knowledge_bases(id) ON DELETE CASCADE,
+        rel_path TEXT NOT NULL,
+        title TEXT NOT NULL,
+        content TEXT NOT NULL,
+        entry_count INTEGER NOT NULL CHECK(entry_count >= 0),
+        content_hash TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(knowledge_base_id, rel_path)
+      );
+      CREATE INDEX knowledge_documents_base_updated ON knowledge_documents(knowledge_base_id, updated_at DESC);
+      PRAGMA user_version = 4;
+      COMMIT;
+    `);
+        // Alpha v2 used a migration note as the default base's routing description.
+        // Clear only that exact placeholder so existing user-authored descriptions stay untouched.
+        this.db.prepare("UPDATE knowledge_bases SET description='' WHERE id=? AND description=?")
+            .run(DEFAULT_KNOWLEDGE_BASE_ID, '由 0.2 版本迁移的知识。');
+        this.syncAllDocuments();
+    }
+    assertOpen() {
+        if (this.closed)
+            throw new Error('knowledge provider is closed');
+    }
+    async listKnowledgeBases() {
+        this.assertOpen();
+        return this.db.prepare('SELECT * FROM knowledge_bases ORDER BY status, updated_at DESC, id').all()
+            .map(rowToKnowledgeBase);
+    }
+    async getKnowledgeBase(id) {
+        this.assertOpen();
+        const row = this.db.prepare('SELECT * FROM knowledge_bases WHERE id = ?').get(id);
+        return row === undefined ? undefined : rowToKnowledgeBase(row);
+    }
+    async createKnowledgeBase(input) {
+        this.assertOpen();
+        const draft = normalizeKnowledgeBaseDraft(input);
+        const timestamp = nowIso();
+        const base = { ...draft, id: newId(), status: 'active', createdAt: timestamp, updatedAt: timestamp };
+        this.db.prepare(`
+      INSERT INTO knowledge_bases(
+        id,name,description,default_tags_json,extraction_instructions,writeback_provider,writeback_model,status,created_at,updated_at
+      ) VALUES(?,?,?,?,?,?,?,'active',?,?)
+    `).run(base.id, base.name, base.description, JSON.stringify(base.defaultTags), base.extractionInstructions, base.writebackProvider ?? null, base.writebackModel ?? null, timestamp, timestamp);
+        this.syncKnowledgeDocuments(base.id);
+        return base;
+    }
+    async updateKnowledgeBase(id, input) {
+        this.assertOpen();
+        const current = await this.getKnowledgeBase(id);
+        if (current === undefined)
+            throw notFound('knowledge base', id);
+        const draft = normalizeKnowledgeBaseDraft(input);
+        const updated = { ...current, ...draft, updatedAt: nowIso() };
+        this.db.prepare(`
+      UPDATE knowledge_bases SET
+        name=?,description=?,default_tags_json=?,extraction_instructions=?,writeback_provider=?,writeback_model=?,updated_at=?
+      WHERE id=?
+    `).run(updated.name, updated.description, JSON.stringify(updated.defaultTags), updated.extractionInstructions, updated.writebackProvider ?? null, updated.writebackModel ?? null, updated.updatedAt, id);
+        this.syncKnowledgeDocuments(id);
+        return updated;
+    }
+    async patchKnowledgeBase(id, patch) {
+        this.assertOpen();
+        const current = await this.getKnowledgeBase(id);
+        if (current === undefined)
+            throw notFound('knowledge base', id);
+        const clearRoute = patch.writebackProvider === null || patch.writebackModel === null;
+        const provider = typeof patch.writebackProvider === 'string' ? patch.writebackProvider : current.writebackProvider;
+        const model = typeof patch.writebackModel === 'string' ? patch.writebackModel : current.writebackModel;
+        return this.updateKnowledgeBase(id, {
+            name: patch.name ?? current.name,
+            description: patch.description ?? current.description,
+            defaultTags: patch.defaultTags ?? current.defaultTags,
+            extractionInstructions: patch.extractionInstructions ?? current.extractionInstructions,
+            ...clearRoute || provider === undefined || model === undefined ? {} : { writebackProvider: provider, writebackModel: model },
+        });
+    }
+    async archiveKnowledgeBase(id) {
+        this.assertOpen();
+        if (id === DEFAULT_KNOWLEDGE_BASE_ID)
+            throw conflict('the default knowledge base cannot be archived');
+        const current = await this.getKnowledgeBase(id);
+        if (current === undefined)
+            throw notFound('knowledge base', id);
+        if (current.status === 'archived')
+            return current;
+        const updated = { ...current, status: 'archived', updatedAt: nowIso() };
+        this.db.prepare("UPDATE knowledge_bases SET status='archived',updated_at=? WHERE id=?").run(updated.updatedAt, id);
+        this.db.prepare('UPDATE knowledge_mounts SET enabled=0,updated_at=? WHERE knowledge_base_id=?').run(updated.updatedAt, id);
+        return updated;
+    }
+    async restoreKnowledgeBase(id) {
+        this.assertOpen();
+        const current = await this.getKnowledgeBase(id);
+        if (current === undefined)
+            throw notFound('knowledge base', id);
+        if (current.status === 'active')
+            return current;
+        const updated = { ...current, status: 'active', updatedAt: nowIso() };
+        this.db.prepare("UPDATE knowledge_bases SET status='active',updated_at=? WHERE id=?").run(updated.updatedAt, id);
+        return updated;
+    }
+    async deleteKnowledgeBase(id) {
+        this.assertOpen();
+        if (id === DEFAULT_KNOWLEDGE_BASE_ID)
+            throw conflict('the default knowledge base cannot be deleted');
+        this.transaction(() => {
+            const row = this.db.prepare('SELECT status FROM knowledge_bases WHERE id=?').get(id);
+            if (row === undefined)
+                throw notFound('knowledge base', id);
+            if (row.status !== 'archived')
+                throw conflict('knowledge base must be archived before deletion');
+            this.db.prepare(`
+        DELETE FROM knowledge_candidates
+        WHERE json_extract(draft_json, '$.knowledgeBaseId')=?
+           OR target_id IN (SELECT id FROM knowledge_entries WHERE knowledge_base_id=?)
+      `).run(id, id);
+            this.db.prepare(`
+        DELETE FROM knowledge_fts
+        WHERE knowledge_id IN (SELECT id FROM knowledge_entries WHERE knowledge_base_id=?)
+      `).run(id);
+            this.db.prepare('DELETE FROM knowledge_entries WHERE knowledge_base_id=?').run(id);
+            this.db.prepare('DELETE FROM knowledge_mounts WHERE knowledge_base_id=?').run(id);
+            this.db.prepare('DELETE FROM knowledge_documents WHERE knowledge_base_id=?').run(id);
+            this.db.prepare('DELETE FROM knowledge_bases WHERE id=?').run(id);
+        });
+    }
+    async listDocuments(knowledgeBaseId, query) {
+        this.assertOpen();
+        const where = [];
+        const args = [];
+        if (knowledgeBaseId !== undefined) {
+            where.push('knowledge_base_id=?');
+            args.push(knowledgeBaseId);
+        }
+        const text = query?.trim();
+        if (text) {
+            where.push('(title LIKE ? ESCAPE \'\\\' OR rel_path LIKE ? ESCAPE \'\\\' OR content LIKE ? ESCAPE \'\\\')');
+            const like = `%${text.replaceAll('\\', '\\\\').replaceAll('%', '\\%').replaceAll('_', '\\_')}%`;
+            args.push(like, like, like);
+        }
+        const sql = `SELECT * FROM knowledge_documents${where.length === 0 ? '' : ` WHERE ${where.join(' AND ')}`} ORDER BY knowledge_base_id, CASE WHEN rel_path='README.md' THEN 0 ELSE 1 END, rel_path`;
+        return this.db.prepare(sql).all(...args).map(rowToDocument);
+    }
+    async getDocument(id) {
+        this.assertOpen();
+        const row = this.db.prepare('SELECT * FROM knowledge_documents WHERE id=?').get(id);
+        return row === undefined ? undefined : rowToDocument(row);
+    }
+    async listMounts(targetKind, targetId) {
+        this.assertOpen();
+        const where = [];
+        const args = [];
+        if (targetKind !== undefined) {
+            where.push('target_kind=?');
+            args.push(targetKind);
+        }
+        if (targetId !== undefined) {
+            where.push('target_id=?');
+            args.push(targetId);
+        }
+        return this.db.prepare(`SELECT * FROM knowledge_mounts${where.length === 0 ? '' : ` WHERE ${where.join(' AND ')}`} ORDER BY updated_at DESC`)
+            .all(...args).map(rowToMount);
+    }
+    async upsertMount(input) {
+        this.assertOpen();
+        return this.upsertMountRow(input);
+    }
+    async applyMountBatch(batch) {
+        this.assertOpen();
+        if (batch.upserts.length + batch.deleteIds.length > 500)
+            throw new Error('mount batch must contain at most 500 operations');
+        const deleteIds = [...new Set(batch.deleteIds.map(id => id.trim()).filter(Boolean))];
+        return this.transaction(() => {
+            const mounts = batch.upserts.map(input => this.upsertMountRow(input));
+            for (const id of deleteIds) {
+                const result = this.db.prepare('DELETE FROM knowledge_mounts WHERE id=?').run(id);
+                if (result.changes === 0)
+                    throw notFound('knowledge mount', id);
+            }
+            return { mounts, deletedIds: deleteIds };
+        });
+    }
+    upsertMountRow(input) {
+        const draft = normalizeKnowledgeMountDraft(input);
+        const base = this.db.prepare('SELECT status FROM knowledge_bases WHERE id=?').get(draft.knowledgeBaseId);
+        if (base === undefined)
+            throw notFound('knowledge base', draft.knowledgeBaseId);
+        if (base.status !== 'active')
+            throw conflict(`knowledge base "${draft.knowledgeBaseId}" is archived`);
+        const previous = this.db.prepare(`
+      SELECT * FROM knowledge_mounts WHERE target_kind=? AND target_id=? AND knowledge_base_id=?
+    `).get(draft.targetKind, draft.targetId, draft.knowledgeBaseId);
+        const timestamp = nowIso();
+        const mount = {
+            ...draft,
+            id: previous === undefined ? newId() : String(previous.id),
+            createdAt: previous === undefined ? timestamp : String(previous.created_at),
+            updatedAt: timestamp,
+        };
+        this.db.prepare(`
+      INSERT INTO knowledge_mounts(
+        id,target_kind,target_id,knowledge_base_id,enabled,recall_enabled,write_mode,
+        include_tags_json,exclude_tags_json,extraction_instructions,created_at,updated_at
+      ) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)
+      ON CONFLICT(target_kind,target_id,knowledge_base_id) DO UPDATE SET
+        enabled=excluded.enabled,recall_enabled=excluded.recall_enabled,write_mode=excluded.write_mode,
+        include_tags_json=excluded.include_tags_json,exclude_tags_json=excluded.exclude_tags_json,
+        extraction_instructions=excluded.extraction_instructions,updated_at=excluded.updated_at
+    `).run(mount.id, mount.targetKind, mount.targetId, mount.knowledgeBaseId, mount.enabled ? 1 : 0, mount.recallEnabled ? 1 : 0, mount.writeMode, JSON.stringify(mount.includeTags), JSON.stringify(mount.excludeTags), mount.extractionInstructions, mount.createdAt, mount.updatedAt);
+        return mount;
+    }
+    async deleteMount(id) {
+        this.assertOpen();
+        const result = this.db.prepare('DELETE FROM knowledge_mounts WHERE id=?').run(id);
+        if (result.changes === 0)
+            throw notFound('knowledge mount', id);
+    }
+    async resolveMounts(sessionId, projectId) {
+        this.assertOpen();
+        const project = projectId === undefined ? [] : await this.listMounts('project', projectId);
+        const session = await this.listMounts('session', sessionId);
+        const resolved = new Map();
+        for (const mount of project)
+            resolved.set(mount.knowledgeBaseId, { mount, inheritedFrom: 'project' });
+        for (const mount of session)
+            resolved.set(mount.knowledgeBaseId, { mount });
+        const output = [];
+        for (const { mount, inheritedFrom } of resolved.values()) {
+            if (!mount.enabled)
+                continue;
+            const base = await this.getKnowledgeBase(mount.knowledgeBaseId);
+            if (base === undefined || base.status !== 'active')
+                continue;
+            output.push({ ...mount, base, ...inheritedFrom === undefined ? {} : { inheritedFrom } });
+        }
+        return output.sort((left, right) => left.base.name.localeCompare(right.base.name, 'zh-CN'));
+    }
+    async stats() {
+        this.assertOpen();
+        const entryRows = this.db.prepare('SELECT status, type, COUNT(*) AS count FROM knowledge_entries GROUP BY status, type').all();
+        const candidateRows = this.db.prepare('SELECT status, COUNT(*) AS count FROM knowledge_candidates GROUP BY status').all();
+        const jobRows = this.db.prepare('SELECT status, COUNT(*) AS count FROM extraction_jobs GROUP BY status').all();
+        const baseRows = this.db.prepare('SELECT status, COUNT(*) AS count FROM knowledge_bases GROUP BY status').all();
+        const byType = {
+            preference: 0,
+            fact: 0,
+            decision: 0,
+            procedure: 0,
+            lesson: 0,
+        };
+        let active = 0;
+        let archived = 0;
+        for (const row of entryRows) {
+            const count = Number(row.count);
+            byType[String(row.type)] += count;
+            if (row.status === 'active')
+                active += count;
+            if (row.status === 'archived')
+                archived += count;
+        }
+        const candidates = { pending: 0, approved: 0, rejected: 0 };
+        for (const row of candidateRows)
+            candidates[String(row.status)] = Number(row.count);
+        const extractionJobs = { running: 0, completed: 0, failed: 0 };
+        for (const row of jobRows)
+            extractionJobs[String(row.status)] = Number(row.count);
+        const knowledgeBases = { active: 0, archived: 0 };
+        for (const row of baseRows)
+            knowledgeBases[String(row.status)] = Number(row.count);
+        return {
+            knowledgeBases: { total: knowledgeBases.active + knowledgeBases.archived, ...knowledgeBases },
+            entries: { total: active + archived, active, archived, byType },
+            candidates: { total: candidates.pending + candidates.approved + candidates.rejected, ...candidates },
+            extractionJobs: { total: extractionJobs.running + extractionJobs.completed + extractionJobs.failed, ...extractionJobs },
+        };
+    }
+    transaction(operation) {
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            const result = operation();
+            this.db.exec('COMMIT');
+            return result;
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    async search(request) {
+        this.assertOpen();
+        const limit = Math.max(0, Math.min(request.limit, 100));
+        if (limit === 0)
+            return [];
+        const scopeSql = request.projectId === undefined
+            ? `e.scope_kind = 'global'`
+            : `(e.scope_kind = 'global' OR (e.scope_kind = 'project' AND e.scope_id = ?))`;
+        const scopeArgs = request.projectId === undefined ? [] : [request.projectId];
+        const typeSql = request.types === undefined || request.types.length === 0
+            ? ''
+            : ` AND e.type IN (${request.types.map(() => '?').join(',')})`;
+        const typeArgs = request.types ?? [];
+        const baseIds = [...new Set(request.knowledgeBaseIds ?? [])].filter(Boolean);
+        const baseSql = baseIds.length === 0 ? '' : ` AND e.knowledge_base_id IN (${baseIds.map(() => '?').join(',')})`;
+        const includeTags = [...new Set(request.includeTags ?? [])].filter(Boolean);
+        const includeSql = includeTags.length === 0 ? '' : ` AND EXISTS (
+      SELECT 1 FROM json_each(e.tags_json) tags WHERE tags.value IN (${includeTags.map(() => '?').join(',')})
+    )`;
+        const excludeTags = [...new Set(request.excludeTags ?? [])].filter(Boolean);
+        const excludeSql = excludeTags.length === 0 ? '' : ` AND NOT EXISTS (
+      SELECT 1 FROM json_each(e.tags_json) tags WHERE tags.value IN (${excludeTags.map(() => '?').join(',')})
+    )`;
+        const filterSql = `${typeSql}${baseSql}${includeSql}${excludeSql}`;
+        const filterArgs = [...typeArgs, ...baseIds, ...includeTags, ...excludeTags];
+        const text = request.text.trim();
+        let rows;
+        if (text.length === 0) {
+            rows = this.db.prepare(`
+        SELECT ${ENTRY_COLUMNS}, 0.0 AS rank
+        FROM knowledge_entries e
+        WHERE e.status = 'active' AND ${scopeSql}${filterSql}
+        ORDER BY CASE WHEN e.scope_kind = 'project' THEN 0 ELSE 1 END, e.updated_at DESC
+        LIMIT ?
+      `).all(...scopeArgs, ...filterArgs, limit);
+        }
+        else {
+            const ftsQuery = toFtsQuery(text);
+            try {
+                rows = this.db.prepare(`
+          SELECT ${JOINED_ENTRY_COLUMNS}, bm25(knowledge_fts, 0.0, 4.0, 1.0, 0.5) AS rank
+          FROM knowledge_fts
+          JOIN knowledge_entries e ON e.id = knowledge_fts.knowledge_id
+          WHERE knowledge_fts MATCH ? AND e.status = 'active' AND ${scopeSql}${filterSql}
+          ORDER BY CASE WHEN e.scope_kind = 'project' THEN 0 ELSE 1 END, rank, e.updated_at DESC
+          LIMIT ?
+        `).all(ftsQuery, ...scopeArgs, ...filterArgs, limit);
+            }
+            catch {
+                rows = [];
+            }
+            if (rows.length < limit) {
+                const supplements = this.searchByTerms(text, scopeSql, scopeArgs, filterSql, filterArgs, limit);
+                const seen = new Set(rows.map(row => String(row.id)));
+                rows.push(...supplements.filter(row => !seen.has(String(row.id))).slice(0, limit - rows.length));
+            }
+        }
+        return rows.map(row => ({ entry: rowToEntry(row), score: rankToScore(Number(row.rank ?? 0)) }));
+    }
+    searchByTerms(text, scopeSql, scopeArgs, filterSql, filterArgs, limit) {
+        const terms = fallbackTerms(text);
+        if (terms.length === 0)
+            return [];
+        const clauses = terms.map(() => `(e.title LIKE ? ESCAPE '\\' OR e.body LIKE ? ESCAPE '\\' OR e.tags_json LIKE ? ESCAPE '\\')`);
+        const args = terms.flatMap((term) => {
+            const like = `%${term.replaceAll('\\', '\\\\').replaceAll('%', '\\%').replaceAll('_', '\\_')}%`;
+            return [like, like, like];
+        });
+        return this.db.prepare(`
+      SELECT ${ENTRY_COLUMNS}, 3.0 AS rank
+      FROM knowledge_entries e
+      WHERE e.status = 'active' AND ${scopeSql}${filterSql} AND (${clauses.join(' OR ')})
+      ORDER BY CASE WHEN e.scope_kind = 'project' THEN 0 ELSE 1 END, e.updated_at DESC
+      LIMIT ?
+    `).all(...scopeArgs, ...filterArgs, ...args, limit);
+    }
+    async list(request) {
+        this.assertOpen();
+        const limit = Math.max(1, Math.min(request.limit, 100));
+        const where = [];
+        const args = [];
+        if (request.status !== undefined) {
+            where.push('status = ?');
+            args.push(request.status);
+        }
+        if (request.type !== undefined) {
+            where.push('type = ?');
+            args.push(request.type);
+        }
+        if (request.knowledgeBaseId !== undefined) {
+            where.push('knowledge_base_id = ?');
+            args.push(request.knowledgeBaseId);
+        }
+        if (request.projectId !== undefined) {
+            where.push(`(scope_kind = 'global' OR (scope_kind = 'project' AND scope_id = ?))`);
+            args.push(request.projectId);
+        }
+        if (request.cursor !== undefined) {
+            const cursor = decodeCursor(request.cursor);
+            where.push('(updated_at < ? OR (updated_at = ? AND id < ?))');
+            args.push(cursor.updatedAt, cursor.updatedAt, cursor.id);
+        }
+        const sql = `SELECT ${ENTRY_COLUMNS} FROM knowledge_entries${where.length === 0 ? '' : ` WHERE ${where.join(' AND ')}`} ORDER BY updated_at DESC, id DESC LIMIT ?`;
+        const rows = this.db.prepare(sql).all(...args, limit + 1);
+        const page = rows.slice(0, limit).map(rowToEntry);
+        const last = page.at(-1);
+        return {
+            items: page,
+            ...rows.length <= limit || last === undefined ? {} : { nextCursor: encodeCursor(last.updatedAt, last.id) },
+        };
+    }
+    async get(id) {
+        this.assertOpen();
+        const row = this.db.prepare(`SELECT ${ENTRY_COLUMNS} FROM knowledge_entries WHERE id = ?`).get(id);
+        return row === undefined ? undefined : rowToEntry(row);
+    }
+    async versions(id) {
+        this.assertOpen();
+        const rows = this.db.prepare('SELECT * FROM knowledge_versions WHERE knowledge_id = ? ORDER BY version DESC').all(id);
+        return rows.map(rowToVersion);
+    }
+    async create(draft) {
+        this.assertOpen();
+        const entry = this.transaction(() => this.insertEntry(draft));
+        this.syncKnowledgeDocuments(entry.knowledgeBaseId);
+        return entry;
+    }
+    insertEntry(input) {
+        const draft = normalizeDraft(input);
+        if (this.db.prepare("SELECT id FROM knowledge_bases WHERE id=? AND status='active'").get(draft.knowledgeBaseId) === undefined) {
+            throw notFound('active knowledge base', draft.knowledgeBaseId);
+        }
+        const id = newId();
+        const timestamp = nowIso();
+        const entry = { ...draft, id, status: 'active', version: 1, createdAt: timestamp, updatedAt: timestamp };
+        this.db.prepare(`
+      INSERT INTO knowledge_entries (
+        id,knowledge_base_id,title,body,type,tags_json,scope_kind,scope_id,confidence,status,version,content_hash,source_json,created_at,updated_at
+      ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+    `).run(id, draft.knowledgeBaseId, draft.title, draft.body, draft.type, JSON.stringify(draft.tags), draft.scope.kind, draft.scope.kind === 'project' ? draft.scope.id : null, draft.confidence, 'active', 1, contentHash(draft), draft.source === undefined ? null : JSON.stringify(draft.source), timestamp, timestamp);
+        this.writeVersion(entry, 'create');
+        this.upsertFts(entry);
+        return entry;
+    }
+    async update(id, draft) {
+        this.assertOpen();
+        const current = await this.get(id);
+        const entry = this.transaction(() => this.updateEntry(id, draft, 'update'));
+        if (current !== undefined && current.knowledgeBaseId !== entry.knowledgeBaseId)
+            this.syncKnowledgeDocuments(current.knowledgeBaseId);
+        this.syncKnowledgeDocuments(entry.knowledgeBaseId);
+        return entry;
+    }
+    updateEntry(id, input, changeKind) {
+        const currentRow = this.db.prepare(`SELECT ${ENTRY_COLUMNS} FROM knowledge_entries WHERE id = ?`).get(id);
+        if (currentRow === undefined)
+            throw notFound('knowledge entry', id);
+        const current = rowToEntry(currentRow);
+        const draft = normalizeDraft(input);
+        if (this.db.prepare("SELECT id FROM knowledge_bases WHERE id=? AND status='active'").get(draft.knowledgeBaseId) === undefined) {
+            throw notFound('active knowledge base', draft.knowledgeBaseId);
+        }
+        const timestamp = nowIso();
+        const entry = {
+            ...draft,
+            id,
+            status: 'active',
+            version: current.version + 1,
+            createdAt: current.createdAt,
+            updatedAt: timestamp,
+        };
+        this.db.prepare(`
+      UPDATE knowledge_entries SET
+        knowledge_base_id=?,title=?,body=?,type=?,tags_json=?,scope_kind=?,scope_id=?,confidence=?,status='active',
+        version=?,content_hash=?,source_json=?,updated_at=?
+      WHERE id=?
+    `).run(draft.knowledgeBaseId, draft.title, draft.body, draft.type, JSON.stringify(draft.tags), draft.scope.kind, draft.scope.kind === 'project' ? draft.scope.id : null, draft.confidence, entry.version, contentHash(draft), draft.source === undefined ? null : JSON.stringify(draft.source), timestamp, id);
+        this.writeVersion(entry, changeKind);
+        this.upsertFts(entry);
+        return entry;
+    }
+    async archive(id) {
+        this.assertOpen();
+        const entry = this.transaction(() => {
+            const row = this.db.prepare(`SELECT ${ENTRY_COLUMNS} FROM knowledge_entries WHERE id = ?`).get(id);
+            if (row === undefined)
+                throw notFound('knowledge entry', id);
+            const current = rowToEntry(row);
+            if (current.status === 'archived')
+                return current;
+            const updated = { ...current, status: 'archived', version: current.version + 1, updatedAt: nowIso() };
+            this.db.prepare(`UPDATE knowledge_entries SET status='archived', version=?, updated_at=? WHERE id=?`).run(updated.version, updated.updatedAt, id);
+            this.writeVersion(updated, 'archive');
+            this.db.prepare('DELETE FROM knowledge_fts WHERE knowledge_id = ?').run(id);
+            return updated;
+        });
+        this.syncKnowledgeDocuments(entry.knowledgeBaseId);
+        return entry;
+    }
+    async delete(id) {
+        this.assertOpen();
+        const current = await this.get(id);
+        this.transaction(() => {
+            this.db.prepare('DELETE FROM knowledge_fts WHERE knowledge_id = ?').run(id);
+            const result = this.db.prepare('DELETE FROM knowledge_entries WHERE id = ?').run(id);
+            if (result.changes === 0)
+                throw notFound('knowledge entry', id);
+        });
+        if (current !== undefined)
+            this.syncKnowledgeDocuments(current.knowledgeBaseId);
+    }
+    async propose(input, sourceKey) {
+        this.assertOpen();
+        const proposal = {
+            action: input.action,
+            ...input.targetId === undefined ? {} : { targetId: input.targetId },
+            draft: normalizeDraft(input.draft),
+            reason: input.reason.trim().slice(0, 2000),
+        };
+        if (proposal.action !== 'create' && proposal.targetId === undefined) {
+            throw new Error(`${proposal.action} candidate requires targetId`);
+        }
+        const hash = contentHash(proposal.draft) + `:${proposal.action}:${proposal.targetId ?? ''}`;
+        if (sourceKey !== undefined) {
+            const existing = this.db.prepare('SELECT * FROM knowledge_candidates WHERE source_key = ? AND proposal_hash = ?').get(sourceKey, hash);
+            if (existing !== undefined)
+                return rowToCandidate(existing);
+        }
+        const candidate = {
+            ...proposal,
+            id: newId(),
+            status: 'pending',
+            ...sourceKey === undefined ? {} : { sourceKey },
+            createdAt: nowIso(),
+        };
+        this.db.prepare(`
+      INSERT INTO knowledge_candidates(id,action,target_id,draft_json,reason,status,source_key,proposal_hash,created_at)
+      VALUES(?,?,?,?,?,'pending',?,?,?)
+    `).run(candidate.id, candidate.action, candidate.targetId ?? null, JSON.stringify(candidate.draft), candidate.reason, sourceKey ?? null, hash, candidate.createdAt);
+        return candidate;
+    }
+    async listCandidates(status, limit) {
+        this.assertOpen();
+        return this.db.prepare('SELECT * FROM knowledge_candidates WHERE status = ? ORDER BY created_at DESC LIMIT ?')
+            .all(status, Math.max(1, Math.min(limit, 100))).map(rowToCandidate);
+    }
+    async review(id, decision) {
+        this.assertOpen();
+        const reviewed = this.transaction(() => {
+            const row = this.db.prepare('SELECT * FROM knowledge_candidates WHERE id = ?').get(id);
+            if (row === undefined)
+                throw notFound('knowledge candidate', id);
+            const candidate = rowToCandidate(row);
+            if (candidate.status !== 'pending')
+                throw conflict(`candidate ${id} was already ${candidate.status}`);
+            let draft = decision.draft === undefined ? candidate.draft : normalizeDraft(decision.draft);
+            if (decision.decision === 'approve') {
+                if (candidate.action === 'create') {
+                    this.insertEntry(draft);
+                }
+                else {
+                    if (candidate.targetId === undefined)
+                        throw new Error('candidate target is missing');
+                    const target = this.db.prepare(`SELECT ${ENTRY_COLUMNS} FROM knowledge_entries WHERE id = ?`).get(candidate.targetId);
+                    if (target === undefined)
+                        throw notFound('candidate target', candidate.targetId);
+                    if (decision.draft === undefined)
+                        draft = candidate.draft;
+                    this.updateEntry(candidate.targetId, draft, 'update');
+                }
+            }
+            const status = decision.decision === 'approve' ? 'approved' : 'rejected';
+            const reviewedAt = nowIso();
+            const note = decision.note?.trim().slice(0, 2000);
+            this.db.prepare('UPDATE knowledge_candidates SET status=?, reviewed_at=?, review_note=? WHERE id=?')
+                .run(status, reviewedAt, note ?? null, id);
+            return { ...candidate, status, reviewedAt, ...note === undefined ? {} : { reviewNote: note } };
+        });
+        if (decision.decision === 'approve')
+            this.syncKnowledgeDocuments(reviewed.draft.knowledgeBaseId);
+        return reviewed;
+    }
+    async claimExtraction(sourceKey) {
+        this.assertOpen();
+        const result = this.db.prepare(`
+      INSERT INTO extraction_jobs(source_key,status,attempts,candidate_count,updated_at)
+      VALUES(?,'running',1,0,?)
+      ON CONFLICT(source_key) DO UPDATE SET
+        status='running', attempts=extraction_jobs.attempts+1, candidate_count=0,
+        last_error=NULL, updated_at=excluded.updated_at
+      WHERE extraction_jobs.status='failed' AND extraction_jobs.attempts < 3
+    `).run(sourceKey, nowIso());
+        return result.changes === 1;
+    }
+    async completeExtraction(sourceKey, candidateCount) {
+        this.assertOpen();
+        this.db.prepare(`UPDATE extraction_jobs SET status='completed', candidate_count=?, last_error=NULL, updated_at=? WHERE source_key=?`)
+            .run(candidateCount, nowIso(), sourceKey);
+    }
+    async failExtraction(sourceKey, error) {
+        this.assertOpen();
+        this.db.prepare(`UPDATE extraction_jobs SET status='failed', last_error=?, updated_at=? WHERE source_key=?`)
+            .run(error.slice(0, 4000), nowIso(), sourceKey);
+    }
+    async extractionJob(sourceKey) {
+        this.assertOpen();
+        const row = this.db.prepare('SELECT * FROM extraction_jobs WHERE source_key = ?').get(sourceKey);
+        return row === undefined ? undefined : rowToExtractionJob(row);
+    }
+    ensureBootstrapToken(token) {
+        this.assertOpen();
+        const value = token.trim();
+        if (value.length < 24)
+            throw new Error('knowledge API token must contain at least 24 characters');
+        const hash = tokenHash(value);
+        const existing = this.db.prepare('SELECT id FROM api_tokens WHERE token_hash = ?').get(hash);
+        if (existing !== undefined)
+            return;
+        this.db.prepare(`INSERT INTO api_tokens(id,name,token_hash,permissions_json,created_at) VALUES(?,?,?,?,?)`)
+            .run(newId(), 'bootstrap-admin', hash, JSON.stringify(['read', 'propose', 'write', 'admin']), nowIso());
+    }
+    authenticate(token) {
+        this.assertOpen();
+        const row = this.db.prepare('SELECT * FROM api_tokens WHERE token_hash = ? AND revoked_at IS NULL')
+            .get(tokenHash(token));
+        if (row === undefined)
+            return undefined;
+        const usedAt = nowIso();
+        this.db.prepare('UPDATE api_tokens SET last_used_at = ? WHERE id = ?').run(usedAt, String(row.id));
+        return rowToToken({ ...row, last_used_at: usedAt });
+    }
+    createApiToken(name, permissions) {
+        this.assertOpen();
+        const cleanName = name.trim();
+        if (cleanName.length === 0 || cleanName.length > 100)
+            throw new Error('token name must contain 1-100 characters');
+        const allowed = new Set(['read', 'propose', 'write', 'admin']);
+        const normalized = [...new Set(permissions)];
+        if (normalized.length === 0 || normalized.some(permission => !allowed.has(permission))) {
+            throw new Error('token permissions must contain read, propose, write, or admin');
+        }
+        const token = `dshk_${randomBytes(32).toString('base64url')}`;
+        const record = { id: newId(), name: cleanName, permissions: normalized, createdAt: nowIso() };
+        this.db.prepare(`INSERT INTO api_tokens(id,name,token_hash,permissions_json,created_at) VALUES(?,?,?,?,?)`)
+            .run(record.id, record.name, tokenHash(token), JSON.stringify(record.permissions), record.createdAt);
+        return { record, token };
+    }
+    listApiTokens() {
+        this.assertOpen();
+        return this.db.prepare('SELECT * FROM api_tokens ORDER BY created_at DESC').all().map(rowToToken);
+    }
+    revokeApiToken(id) {
+        this.assertOpen();
+        const result = this.db.prepare('UPDATE api_tokens SET revoked_at = ? WHERE id = ? AND revoked_at IS NULL').run(nowIso(), id);
+        if (result.changes === 0)
+            throw notFound('API token', id);
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.db.close();
+    }
+    writeVersion(entry, changeKind) {
+        const snapshot = {
+            knowledgeBaseId: entry.knowledgeBaseId,
+            title: entry.title,
+            body: entry.body,
+            type: entry.type,
+            tags: entry.tags,
+            scope: entry.scope,
+            confidence: entry.confidence,
+            ...entry.source === undefined ? {} : { source: entry.source },
+            status: entry.status,
+        };
+        this.db.prepare(`INSERT INTO knowledge_versions(id,knowledge_id,version,snapshot_json,change_kind,created_at) VALUES(?,?,?,?,?,?)`)
+            .run(newId(), entry.id, entry.version, JSON.stringify(snapshot), changeKind, nowIso());
+    }
+    upsertFts(entry) {
+        this.db.prepare('DELETE FROM knowledge_fts WHERE knowledge_id = ?').run(entry.id);
+        if (entry.status === 'active') {
+            this.db.prepare('INSERT INTO knowledge_fts(knowledge_id,title,body,tags) VALUES(?,?,?,?)')
+                .run(entry.id, entry.title, entry.body, entry.tags.join(' '));
+        }
+    }
+    syncAllDocuments() {
+        const bases = this.db.prepare('SELECT id FROM knowledge_bases').all();
+        for (const base of bases)
+            this.syncKnowledgeDocuments(String(base.id));
+    }
+    syncKnowledgeDocuments(knowledgeBaseId) {
+        const baseRow = this.db.prepare('SELECT * FROM knowledge_bases WHERE id=?').get(knowledgeBaseId);
+        if (baseRow === undefined)
+            return;
+        const base = rowToKnowledgeBase(baseRow);
+        const entries = this.db.prepare(`
+      SELECT ${ENTRY_COLUMNS} FROM knowledge_entries
+      WHERE knowledge_base_id=? AND status='active'
+      ORDER BY type, updated_at DESC, id
+    `).all(knowledgeBaseId).map(rowToEntry);
+        const desired = new Map();
+        desired.set('README.md', {
+            title: base.name,
+            content: renderKnowledgeBaseReadme(base, entries.length),
+            entryCount: entries.length,
+        });
+        for (const [type, meta] of Object.entries(DOCUMENT_TYPES)) {
+            const typed = entries.filter(entry => entry.type === type);
+            if (typed.length === 0)
+                continue;
+            desired.set(meta.relPath, {
+                title: meta.title,
+                content: renderEntryDocument(base, meta.title, typed),
+                entryCount: typed.length,
+            });
+        }
+        const timestamp = nowIso();
+        const existing = this.db.prepare('SELECT id,rel_path,created_at FROM knowledge_documents WHERE knowledge_base_id=?')
+            .all(knowledgeBaseId);
+        const byPath = new Map(existing.map(row => [String(row.rel_path), row]));
+        for (const [relPath, document] of desired) {
+            const previous = byPath.get(relPath);
+            const hash = createHash('sha256').update(document.content).digest('hex');
+            this.db.prepare(`
+        INSERT INTO knowledge_documents(
+          id,knowledge_base_id,rel_path,title,content,entry_count,content_hash,created_at,updated_at
+        ) VALUES(?,?,?,?,?,?,?,?,?)
+        ON CONFLICT(knowledge_base_id,rel_path) DO UPDATE SET
+          title=excluded.title,content=excluded.content,entry_count=excluded.entry_count,
+          content_hash=excluded.content_hash,updated_at=excluded.updated_at
+        WHERE knowledge_documents.content_hash<>excluded.content_hash
+           OR knowledge_documents.title<>excluded.title
+           OR knowledge_documents.entry_count<>excluded.entry_count
+      `).run(previous === undefined ? newId() : String(previous.id), knowledgeBaseId, relPath, document.title, document.content, document.entryCount, hash, previous === undefined ? timestamp : String(previous.created_at), timestamp);
+        }
+        for (const row of existing) {
+            if (!desired.has(String(row.rel_path)))
+                this.db.prepare('DELETE FROM knowledge_documents WHERE id=?').run(String(row.id));
+        }
+    }
+}
+const DOCUMENT_TYPES = {
+    preference: { relPath: 'preferences.md', title: '偏好' },
+    fact: { relPath: 'facts.md', title: '事实' },
+    decision: { relPath: 'decisions.md', title: '决策' },
+    procedure: { relPath: 'procedures.md', title: '流程' },
+    lesson: { relPath: 'lessons.md', title: '经验' },
+};
+function renderKnowledgeBaseReadme(base, entryCount) {
+    const lines = [`# ${markdownHeading(base.name)}`, ''];
+    if (base.description)
+        lines.push(base.description, '');
+    lines.push(`> 当前包含 ${entryCount} 条已生效知识，由 DSH Knowledge 自动整理为 Markdown 文档。`, '');
+    if (base.defaultTags.length > 0)
+        lines.push(`默认标签：${base.defaultTags.map(tag => `#${tag}`).join(' ')}`, '');
+    lines.push(`回写模型：${base.writebackProvider && base.writebackModel ? `${base.writebackProvider} / ${base.writebackModel}` : '跟随当前会话模型'}`, '');
+    if (base.extractionInstructions)
+        lines.push('## 提取要求', '', base.extractionInstructions, '');
+    return `${lines.join('\n').trim()}\n`;
+}
+function renderEntryDocument(base, title, entries) {
+    const lines = [`# ${title}`, '', `> ${base.name} · ${entries.length} 条知识`, ''];
+    for (const entry of entries) {
+        lines.push(`## ${markdownHeading(entry.title)}`, '', entry.body.trim(), '');
+        const scope = entry.scope.kind === 'global' ? '全局' : `项目：${entry.scope.id}`;
+        const metadata = [scope, ...entry.tags.map(tag => `#${tag}`), `置信度 ${Math.round(entry.confidence * 100)}%`];
+        lines.push(`<small>${metadata.join(' · ')}</small>`, '');
+    }
+    return `${lines.join('\n').trim()}\n`;
+}
+function markdownHeading(value) {
+    return value.replace(/[\r\n]+/g, ' ').replace(/^#+\s*/, '').trim();
+}
+function rowToEntry(row) {
+    const source = row.source_json == null ? undefined : JSON.parse(String(row.source_json));
+    return {
+        id: String(row.id),
+        knowledgeBaseId: row.knowledge_base_id == null ? DEFAULT_KNOWLEDGE_BASE_ID : String(row.knowledge_base_id),
+        title: String(row.title),
+        body: String(row.body),
+        type: String(row.type),
+        tags: JSON.parse(String(row.tags_json)),
+        scope: String(row.scope_kind) === 'global'
+            ? { kind: 'global' }
+            : { kind: 'project', id: String(row.scope_id) },
+        confidence: Number(row.confidence),
+        status: String(row.status),
+        version: Number(row.version),
+        ...source === undefined ? {} : { source },
+        createdAt: String(row.created_at),
+        updatedAt: String(row.updated_at),
+    };
+}
+function rowToDocument(row) {
+    return {
+        id: String(row.id),
+        knowledgeBaseId: String(row.knowledge_base_id),
+        relPath: String(row.rel_path),
+        title: String(row.title),
+        content: String(row.content),
+        entryCount: Number(row.entry_count),
+        contentHash: String(row.content_hash),
+        createdAt: String(row.created_at),
+        updatedAt: String(row.updated_at),
+    };
+}
+function rowToVersion(row) {
+    const snapshot = JSON.parse(String(row.snapshot_json));
+    if (snapshot.knowledgeBaseId === undefined)
+        snapshot.knowledgeBaseId = DEFAULT_KNOWLEDGE_BASE_ID;
+    return {
+        id: String(row.id),
+        knowledgeId: String(row.knowledge_id),
+        version: Number(row.version),
+        snapshot,
+        changeKind: String(row.change_kind),
+        createdAt: String(row.created_at),
+    };
+}
+function rowToCandidate(row) {
+    const targetId = row.target_id == null ? undefined : String(row.target_id);
+    const sourceKey = row.source_key == null ? undefined : String(row.source_key);
+    const reviewedAt = row.reviewed_at == null ? undefined : String(row.reviewed_at);
+    const reviewNote = row.review_note == null ? undefined : String(row.review_note);
+    const draft = JSON.parse(String(row.draft_json));
+    if (draft.knowledgeBaseId === undefined)
+        draft.knowledgeBaseId = DEFAULT_KNOWLEDGE_BASE_ID;
+    return {
+        id: String(row.id),
+        action: String(row.action),
+        ...targetId === undefined ? {} : { targetId },
+        draft,
+        reason: String(row.reason),
+        status: String(row.status),
+        ...sourceKey === undefined ? {} : { sourceKey },
+        createdAt: String(row.created_at),
+        ...reviewedAt === undefined ? {} : { reviewedAt },
+        ...reviewNote === undefined ? {} : { reviewNote },
+    };
+}
+function rowToKnowledgeBase(row) {
+    const writebackProvider = row.writeback_provider == null ? undefined : String(row.writeback_provider);
+    const writebackModel = row.writeback_model == null ? undefined : String(row.writeback_model);
+    return {
+        id: String(row.id),
+        name: String(row.name),
+        description: String(row.description),
+        defaultTags: JSON.parse(String(row.default_tags_json)),
+        extractionInstructions: String(row.extraction_instructions),
+        ...writebackProvider === undefined || writebackModel === undefined ? {} : { writebackProvider, writebackModel },
+        status: String(row.status),
+        createdAt: String(row.created_at),
+        updatedAt: String(row.updated_at),
+    };
+}
+function rowToMount(row) {
+    return {
+        id: String(row.id),
+        targetKind: String(row.target_kind),
+        targetId: String(row.target_id),
+        knowledgeBaseId: String(row.knowledge_base_id),
+        enabled: Number(row.enabled) === 1,
+        recallEnabled: Number(row.recall_enabled) === 1,
+        writeMode: String(row.write_mode),
+        includeTags: JSON.parse(String(row.include_tags_json)),
+        excludeTags: JSON.parse(String(row.exclude_tags_json)),
+        extractionInstructions: String(row.extraction_instructions),
+        createdAt: String(row.created_at),
+        updatedAt: String(row.updated_at),
+    };
+}
+function rowToExtractionJob(row) {
+    const lastError = row.last_error == null ? undefined : String(row.last_error);
+    return {
+        sourceKey: String(row.source_key),
+        status: String(row.status),
+        attempts: Number(row.attempts),
+        candidateCount: Number(row.candidate_count),
+        ...lastError === undefined ? {} : { lastError },
+        updatedAt: String(row.updated_at),
+    };
+}
+function rowToToken(row) {
+    const lastUsedAt = row.last_used_at == null ? undefined : String(row.last_used_at);
+    const revokedAt = row.revoked_at == null ? undefined : String(row.revoked_at);
+    return {
+        id: String(row.id),
+        name: String(row.name),
+        permissions: JSON.parse(String(row.permissions_json)),
+        createdAt: String(row.created_at),
+        ...lastUsedAt === undefined ? {} : { lastUsedAt },
+        ...revokedAt === undefined ? {} : { revokedAt },
+    };
+}
+function tokenHash(token) {
+    return createHash('sha256').update(token).digest('hex');
+}
+function toFtsQuery(text) {
+    const terms = text.split(/\s+/u).map(term => term.trim()).filter(Boolean).slice(0, 20);
+    return terms.map(term => `"${term.replaceAll('"', '""')}"`).join(' OR ');
+}
+function fallbackTerms(text) {
+    const terms = new Set();
+    for (const word of text.toLowerCase().match(/[a-z0-9][a-z0-9_.-]{1,}/g) ?? [])
+        terms.add(word);
+    for (const sequence of text.match(/\p{Script=Han}+/gu) ?? []) {
+        const chars = [...sequence];
+        if (chars.length === 1)
+            terms.add(chars[0]);
+        for (let index = 0; index < chars.length - 1; index += 1) {
+            terms.add(`${chars[index]}${chars[index + 1]}`);
+        }
+    }
+    return [...terms].slice(0, 20);
+}
+function rankToScore(rank) {
+    return 1 / (1 + Math.max(0, rank));
+}
+function encodeCursor(updatedAt, id) {
+    return Buffer.from(JSON.stringify({ updatedAt, id })).toString('base64url');
+}
+function decodeCursor(cursor) {
+    try {
+        const value = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+        if (typeof value.updatedAt !== 'string' || typeof value.id !== 'string')
+            throw new Error();
+        return { updatedAt: value.updatedAt, id: value.id };
+    }
+    catch {
+        throw Object.assign(new Error('invalid pagination cursor'), { code: 'BAD_REQUEST' });
+    }
+}
+function notFound(kind, id) {
+    return Object.assign(new Error(`${kind} "${id}" was not found`), { code: 'NOT_FOUND' });
+}
+function conflict(message) {
+    return Object.assign(new Error(message), { code: 'CONFLICT' });
+}
+//# sourceMappingURL=local-provider.js.map