@jagilber-org/index-server 1.19.1

package/dist/services/storage/jsonFileStore.js

@@ -0,0 +1,241 @@
+"use strict";
+/**
+ * JsonFileStore — JSON-file-per-instruction storage backend.
+ *
+ * Wraps the existing file-based storage pattern: each instruction is a
+ * separate .json file in a directory. This is the default backend.
+ *
+ * Implements IInstructionStore for the storage abstraction layer.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonFileStore = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const hashUtils_js_1 = require("./hashUtils.js");
+class JsonFileStore {
+    dir;
+    cache = new Map();
+    loaded = false;
+    /**
+     * @param dir - Directory containing instruction .json files.
+     */
+    constructor(dir) {
+        this.dir = dir;
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+    }
+    // ── Lifecycle ──────────────────────────────────────────────────────
+    load() {
+        const errors = [];
+        const entries = [];
+        let scanned = 0;
+        let skipped = 0;
+        const files = fs_1.default.readdirSync(this.dir).filter(f => f.endsWith('.json') && !f.startsWith('_') && !f.startsWith('.'));
+        scanned = files.length;
+        for (const file of files) {
+            try {
+                const raw = fs_1.default.readFileSync(path_1.default.join(this.dir, file), 'utf-8');
+                const parsed = JSON.parse(raw.replace(/^\uFEFF/, ''));
+                // Handle arrays (some files contain instruction arrays)
+                const items = Array.isArray(parsed) ? parsed : [parsed];
+                for (const item of items) {
+                    const entry = item;
+                    if (!entry.id || !entry.title || !entry.body) {
+                        skipped++;
+                        continue;
+                    }
+                    entries.push(entry);
+                }
+            }
+            catch (err) {
+                skipped++;
+                errors.push({ file, error: err instanceof Error ? err.message : 'Unknown parse error' });
+            }
+        }
+        // Deduplicate by ID (last-write-wins)
+        const byId = new Map();
+        for (const e of entries) {
+            byId.set(e.id, e);
+        }
+        const deduped = Array.from(byId.values());
+        this.cache = byId;
+        this.loaded = true;
+        return {
+            entries: deduped,
+            hash: (0, hashUtils_js_1.computeGovernanceHashFromEntries)(deduped),
+            errors,
+            debug: { scanned, accepted: deduped.length, skipped },
+            summary: {
+                scanned,
+                accepted: deduped.length,
+                skipped,
+                reasons: errors.length > 0 ? { 'parse-error': errors.length } : {},
+            },
+        };
+    }
+    close() {
+        this.cache.clear();
+        this.loaded = false;
+    }
+    // ── CRUD ───────────────────────────────────────────────────────────
+    get(id) {
+        this.ensureLoaded();
+        return this.cache.get(id) ?? null;
+    }
+    write(entry) {
+        // Write to disk
+        const filePath = path_1.default.join(this.dir, `${entry.id}.json`);
+        const tmpPath = `${filePath}.${crypto_1.default.randomBytes(4).toString('hex')}.tmp`;
+        fs_1.default.writeFileSync(tmpPath, JSON.stringify(entry, null, 2), 'utf-8');
+        fs_1.default.renameSync(tmpPath, filePath);
+        // Update in-memory cache
+        this.cache.set(entry.id, entry);
+        this.loaded = true;
+    }
+    remove(id) {
+        const filePath = path_1.default.join(this.dir, `${id}.json`);
+        try {
+            if (fs_1.default.existsSync(filePath)) {
+                fs_1.default.unlinkSync(filePath);
+            }
+        }
+        catch {
+            // No-op on failure (file may already be gone)
+        }
+        this.cache.delete(id);
+    }
+    // ── Queries ────────────────────────────────────────────────────────
+    list(opts) {
+        this.ensureLoaded();
+        let result = Array.from(this.cache.values());
+        if (opts?.category) {
+            result = result.filter(e => e.categories?.includes(opts.category));
+        }
+        if (opts?.contentType) {
+            result = result.filter(e => e.contentType === opts.contentType);
+        }
+        return result;
+    }
+    query(opts) {
+        this.ensureLoaded();
+        let result = Array.from(this.cache.values());
+        if (opts.text) {
+            const lower = opts.text.toLowerCase();
+            result = result.filter(e => e.title.toLowerCase().includes(lower) ||
+                e.body.toLowerCase().includes(lower) ||
+                (e.semanticSummary && e.semanticSummary.toLowerCase().includes(lower)));
+        }
+        if (opts.categoriesAny?.length) {
+            const set = new Set(opts.categoriesAny);
+            result = result.filter(e => e.categories?.some(c => set.has(c)));
+        }
+        if (opts.categoriesAll?.length) {
+            result = result.filter(e => opts.categoriesAll.every(c => e.categories?.includes(c)));
+        }
+        if (opts.excludeCategories?.length) {
+            const excl = new Set(opts.excludeCategories);
+            result = result.filter(e => !e.categories?.some(c => excl.has(c)));
+        }
+        if (opts.contentType) {
+            result = result.filter(e => e.contentType === opts.contentType);
+        }
+        if (opts.priorityMin !== undefined) {
+            result = result.filter(e => e.priority >= opts.priorityMin);
+        }
+        if (opts.priorityMax !== undefined) {
+            result = result.filter(e => e.priority <= opts.priorityMax);
+        }
+        if (opts.priorityTiers?.length) {
+            const tiers = new Set(opts.priorityTiers);
+            result = result.filter(e => e.priorityTier && tiers.has(e.priorityTier));
+        }
+        if (opts.requirements?.length) {
+            const reqs = new Set(opts.requirements);
+            result = result.filter(e => reqs.has(e.requirement));
+        }
+        // Pagination
+        if (opts.offset) {
+            result = result.slice(opts.offset);
+        }
+        if (opts.limit) {
+            result = result.slice(0, opts.limit);
+        }
+        return result;
+    }
+    listScoped(opts) {
+        this.ensureLoaded();
+        let result = Array.from(this.cache.values());
+        if (opts.userId) {
+            result = result.filter(e => e.userId === opts.userId || e.audience === 'all');
+        }
+        if (opts.workspaceId) {
+            result = result.filter(e => e.workspaceId === opts.workspaceId || e.audience === 'all');
+        }
+        if (opts.teamIds?.length) {
+            const teams = new Set(opts.teamIds);
+            result = result.filter(e => e.audience === 'all' ||
+                e.teamIds?.some(t => teams.has(t)));
+        }
+        return result;
+    }
+    search(opts) {
+        this.ensureLoaded();
+        const results = [];
+        for (const entry of this.cache.values()) {
+            let score = 0;
+            const titleLower = entry.title.toLowerCase();
+            const bodyLower = entry.body.toLowerCase();
+            const catStr = (entry.categories ?? []).join(' ').toLowerCase();
+            for (const kw of opts.keywords) {
+                const kwLower = opts.caseSensitive ? kw : kw.toLowerCase();
+                const title = opts.caseSensitive ? entry.title : titleLower;
+                const body = opts.caseSensitive ? entry.body : bodyLower;
+                if (title.includes(kwLower))
+                    score += 3;
+                if (body.includes(kwLower))
+                    score += 1;
+                if (opts.includeCategories && catStr.includes(kwLower))
+                    score += 2;
+            }
+            if (score > 0) {
+                results.push({ id: entry.id, score });
+            }
+        }
+        results.sort((a, b) => b.score - a.score);
+        if (opts.limit) {
+            return results.slice(0, opts.limit);
+        }
+        return results;
+    }
+    categories() {
+        this.ensureLoaded();
+        const counts = new Map();
+        for (const entry of this.cache.values()) {
+            for (const cat of entry.categories ?? []) {
+                counts.set(cat, (counts.get(cat) ?? 0) + 1);
+            }
+        }
+        return counts;
+    }
+    // ── Integrity ──────────────────────────────────────────────────────
+    computeHash() {
+        this.ensureLoaded();
+        return (0, hashUtils_js_1.computeGovernanceHashFromEntries)(Array.from(this.cache.values()));
+    }
+    count() {
+        this.ensureLoaded();
+        return this.cache.size;
+    }
+    // ── Internal ───────────────────────────────────────────────────────
+    ensureLoaded() {
+        if (!this.loaded) {
+            this.load();
+        }
+    }
+}
+exports.JsonFileStore = JsonFileStore;

package/dist/services/storage/migrationEngine.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Migration engine — bidirectional JSON ↔ SQLite migration.
+ *
+ * Uses Node.js built-in node:sqlite. Zero third-party dependencies.
+ */
+export interface MigrationOptions {
+    onProgress?: (current: number, total: number) => void;
+}
+export interface MigrationResult {
+    migrated: number;
+    errors: {
+        file: string;
+        error: string;
+    }[];
+}
+export interface ExportResult {
+    exported: number;
+    errors: {
+        id: string;
+        error: string;
+    }[];
+}
+/**
+ * Migrate all instructions from JSON files to a SQLite database.
+ *
+ * Idempotent: uses INSERT OR REPLACE so re-running is safe.
+ * Atomic: all writes happen via SqliteStore (individual INSERT OR REPLACE).
+ */
+export declare function migrateJsonToSqlite(jsonDir: string, dbPath: string, opts?: MigrationOptions): MigrationResult;
+/**
+ * Export all instructions from a SQLite database to JSON files.
+ *
+ * Each entry becomes a separate .json file named by ID.
+ */
+export declare function migrateSqliteToJson(dbPath: string, jsonDir: string, opts?: MigrationOptions): ExportResult;

package/dist/services/storage/migrationEngine.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Migration engine — bidirectional JSON ↔ SQLite migration.
+ *
+ * Uses Node.js built-in node:sqlite. Zero third-party dependencies.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateJsonToSqlite = migrateJsonToSqlite;
+exports.migrateSqliteToJson = migrateSqliteToJson;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const jsonFileStore_js_1 = require("./jsonFileStore.js");
+const sqliteStore_js_1 = require("./sqliteStore.js");
+/**
+ * Migrate all instructions from JSON files to a SQLite database.
+ *
+ * Idempotent: uses INSERT OR REPLACE so re-running is safe.
+ * Atomic: all writes happen via SqliteStore (individual INSERT OR REPLACE).
+ */
+function migrateJsonToSqlite(jsonDir, dbPath, opts) {
+    const jsonStore = new jsonFileStore_js_1.JsonFileStore(jsonDir);
+    const loadResult = jsonStore.load();
+    const entries = loadResult.entries;
+    const total = entries.length;
+    const errors = [...loadResult.errors];
+    // Ensure DB directory exists
+    const dbDir = path_1.default.dirname(dbPath);
+    if (!fs_1.default.existsSync(dbDir)) {
+        fs_1.default.mkdirSync(dbDir, { recursive: true });
+    }
+    const sqliteStore = new sqliteStore_js_1.SqliteStore(dbPath);
+    let migrated = 0;
+    try {
+        for (let i = 0; i < entries.length; i++) {
+            try {
+                sqliteStore.write(entries[i]);
+                migrated++;
+            }
+            catch (err) {
+                errors.push({
+                    file: entries[i].id,
+                    error: err instanceof Error ? err.message : 'Write failed',
+                });
+            }
+            opts?.onProgress?.(i + 1, total);
+        }
+    }
+    finally {
+        sqliteStore.close();
+        jsonStore.close();
+    }
+    return { migrated, errors };
+}
+/**
+ * Export all instructions from a SQLite database to JSON files.
+ *
+ * Each entry becomes a separate .json file named by ID.
+ */
+function migrateSqliteToJson(dbPath, jsonDir, opts) {
+    if (!fs_1.default.existsSync(jsonDir)) {
+        fs_1.default.mkdirSync(jsonDir, { recursive: true });
+    }
+    const sqliteStore = new sqliteStore_js_1.SqliteStore(dbPath);
+    const loadResult = sqliteStore.load();
+    const entries = loadResult.entries;
+    const total = entries.length;
+    const errors = [];
+    const jsonStore = new jsonFileStore_js_1.JsonFileStore(jsonDir);
+    let exported = 0;
+    try {
+        for (let i = 0; i < entries.length; i++) {
+            try {
+                jsonStore.write(entries[i]);
+                exported++;
+            }
+            catch (err) {
+                errors.push({
+                    id: entries[i].id,
+                    error: err instanceof Error ? err.message : 'Write failed',
+                });
+            }
+            opts?.onProgress?.(i + 1, total);
+        }
+    }
+    finally {
+        sqliteStore.close();
+        jsonStore.close();
+    }
+    return { exported, errors };
+}

package/dist/services/storage/sqliteMessageStore.d.ts

@@ -0,0 +1,53 @@
+/**
+ * SqliteMessageStore — Message persistence backed by node:sqlite.
+ *
+ * Stores agent messages in the messages table with indexing on
+ * channel, sender, parent_id, and created_at for efficient queries.
+ */
+export interface StoredMessage {
+    id: string;
+    channel: string;
+    sender: string;
+    recipients: string[];
+    body: string;
+    priority: string;
+    tags: string[];
+    parentId: string | null;
+    persistent: boolean;
+    ttlSeconds: number | null;
+    requiresAck: boolean;
+    ackBySeconds: number | null;
+    readBy: string[];
+    payload: unknown;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface MessageQuery {
+    channel?: string;
+    sender?: string;
+    tags?: string[];
+    parentId?: string;
+    limit?: number;
+    offset?: number;
+}
+export declare class SqliteMessageStore {
+    private db;
+    constructor(dbPath: string);
+    /** Store a message. */
+    write(msg: StoredMessage): void;
+    /** Get a message by ID. */
+    get(id: string): StoredMessage | null;
+    /** Query messages with filters. */
+    query(opts: MessageQuery): StoredMessage[];
+    /** Get thread (parent + all descendants). */
+    getThread(parentId: string): StoredMessage[];
+    /** List distinct channels. */
+    channels(): string[];
+    /** Delete a message by ID. */
+    remove(id: string): void;
+    /** Purge all messages in a channel. */
+    purgeChannel(channel: string): number;
+    /** Count messages. */
+    count(channel?: string): number;
+    close(): void;
+}

package/dist/services/storage/sqliteMessageStore.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * SqliteMessageStore — Message persistence backed by node:sqlite.
+ *
+ * Stores agent messages in the messages table with indexing on
+ * channel, sender, parent_id, and created_at for efficient queries.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteMessageStore = void 0;
+const node_sqlite_1 = require("node:sqlite");
+const sqliteSchema_js_1 = require("./sqliteSchema.js");
+function safeJsonParse(raw, fallback) {
+    if (raw == null)
+        return fallback;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return fallback;
+    }
+}
+function rowToMessage(row) {
+    return {
+        id: row.id,
+        channel: row.channel,
+        sender: row.sender,
+        recipients: safeJsonParse(row.recipients, []),
+        body: row.body,
+        priority: row.priority ?? 'normal',
+        tags: safeJsonParse(row.tags, []),
+        parentId: row.parent_id,
+        persistent: !!row.persistent,
+        ttlSeconds: row.ttl_seconds,
+        requiresAck: !!row.requires_ack,
+        ackBySeconds: row.ack_by_seconds,
+        readBy: safeJsonParse(row.read_by, []),
+        payload: safeJsonParse(row.payload, null),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+class SqliteMessageStore {
+    db;
+    constructor(dbPath) {
+        this.db = new node_sqlite_1.DatabaseSync(dbPath);
+        this.db.exec(sqliteSchema_js_1.PRAGMAS);
+        this.db.exec(sqliteSchema_js_1.INSTRUCTIONS_DDL);
+    }
+    /** Store a message. */
+    write(msg) {
+        this.db.prepare(`
+      INSERT OR REPLACE INTO messages (
+        id, channel, sender, recipients, body, priority, tags,
+        parent_id, persistent, ttl_seconds, requires_ack, ack_by_seconds,
+        read_by, payload, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(msg.id, msg.channel, msg.sender, JSON.stringify(msg.recipients), msg.body, msg.priority, JSON.stringify(msg.tags), msg.parentId, msg.persistent ? 1 : 0, msg.ttlSeconds, msg.requiresAck ? 1 : 0, msg.ackBySeconds, JSON.stringify(msg.readBy), JSON.stringify(msg.payload), msg.createdAt, msg.updatedAt);
+    }
+    /** Get a message by ID. */
+    get(id) {
+        const row = this.db.prepare('SELECT * FROM messages WHERE id = ?').get(id);
+        return row ? rowToMessage(row) : null;
+    }
+    /** Query messages with filters. */
+    query(opts) {
+        const conditions = [];
+        const params = [];
+        if (opts.channel) {
+            conditions.push('channel = ?');
+            params.push(opts.channel);
+        }
+        if (opts.sender) {
+            conditions.push('sender = ?');
+            params.push(opts.sender);
+        }
+        if (opts.parentId) {
+            conditions.push('parent_id = ?');
+            params.push(opts.parentId);
+        }
+        let sql = 'SELECT * FROM messages';
+        if (conditions.length > 0)
+            sql += ' WHERE ' + conditions.join(' AND ');
+        sql += ' ORDER BY created_at DESC';
+        if (opts.limit) {
+            sql += ' LIMIT ?';
+            params.push(opts.limit);
+        }
+        if (opts.offset) {
+            sql += ' OFFSET ?';
+            params.push(opts.offset);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        let results = rows.map(r => rowToMessage(r));
+        // Tag filtering (post-query since tags are JSON arrays)
+        if (opts.tags?.length) {
+            const tagSet = new Set(opts.tags);
+            results = results.filter(m => m.tags.some(t => tagSet.has(t)));
+        }
+        return results;
+    }
+    /** Get thread (parent + all descendants). */
+    getThread(parentId) {
+        const results = [];
+        const parent = this.get(parentId);
+        if (parent)
+            results.push(parent);
+        // Recursive CTE would be ideal but simple BFS for now
+        const children = this.db.prepare('SELECT * FROM messages WHERE parent_id = ? ORDER BY created_at ASC').all(parentId);
+        for (const row of children) {
+            const msg = rowToMessage(row);
+            results.push(msg);
+            // Recursively get children of children
+            const descendants = this.getThread(msg.id);
+            // Skip the first element (which is msg itself from the recursive call's parent lookup)
+            results.push(...descendants.slice(1));
+        }
+        return results;
+    }
+    /** List distinct channels. */
+    channels() {
+        const rows = this.db.prepare('SELECT DISTINCT channel FROM messages ORDER BY channel').all();
+        return rows.map(r => r.channel);
+    }
+    /** Delete a message by ID. */
+    remove(id) {
+        this.db.prepare('DELETE FROM messages WHERE id = ?').run(id);
+    }
+    /** Purge all messages in a channel. */
+    purgeChannel(channel) {
+        const result = this.db.prepare('DELETE FROM messages WHERE channel = ?').run(channel);
+        return result.changes;
+    }
+    /** Count messages. */
+    count(channel) {
+        if (channel) {
+            const row = this.db.prepare('SELECT COUNT(*) as cnt FROM messages WHERE channel = ?').get(channel);
+            return row?.cnt ?? 0;
+        }
+        const row = this.db.prepare('SELECT COUNT(*) as cnt FROM messages').get();
+        return row?.cnt ?? 0;
+    }
+    close() {
+        this.db.close();
+    }
+}
+exports.SqliteMessageStore = SqliteMessageStore;

package/dist/services/storage/sqliteSchema.d.ts

@@ -0,0 +1,12 @@
+/**
+ * SQLite schema DDL for instruction storage.
+ *
+ * Uses Node.js built-in node:sqlite (DatabaseSync). No third-party packages.
+ * WAL mode enabled for concurrent read performance.
+ */
+export declare const SCHEMA_VERSION = "1";
+export declare const INSTRUCTIONS_DDL = "\nCREATE TABLE IF NOT EXISTS instructions (\n  id TEXT PRIMARY KEY,\n  title TEXT NOT NULL,\n  body TEXT NOT NULL,\n  rationale TEXT,\n  priority INTEGER NOT NULL DEFAULT 50,\n  audience TEXT NOT NULL DEFAULT 'all',\n  requirement TEXT NOT NULL DEFAULT 'recommended',\n  categories TEXT NOT NULL DEFAULT '[]',\n  content_type TEXT NOT NULL DEFAULT 'instruction',\n  primary_category TEXT,\n  source_hash TEXT NOT NULL DEFAULT '',\n  schema_version TEXT NOT NULL DEFAULT '4',\n  deprecated_by TEXT,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  version TEXT DEFAULT '1.0.0',\n  status TEXT DEFAULT 'approved',\n  owner TEXT,\n  priority_tier TEXT,\n  classification TEXT DEFAULT 'public',\n  last_reviewed_at TEXT,\n  next_review_due TEXT,\n  review_interval_days INTEGER,\n  change_log TEXT DEFAULT '[]',\n  supersedes TEXT,\n  archived_at TEXT,\n  workspace_id TEXT,\n  user_id TEXT,\n  team_ids TEXT DEFAULT '[]',\n  semantic_summary TEXT,\n  created_by_agent TEXT,\n  source_workspace TEXT,\n  risk_score REAL,\n  usage_count INTEGER DEFAULT 0,\n  first_seen_ts TEXT,\n  last_used_at TEXT\n);\n\nCREATE INDEX IF NOT EXISTS idx_instructions_content_type ON instructions(content_type);\nCREATE INDEX IF NOT EXISTS idx_instructions_status ON instructions(status);\nCREATE INDEX IF NOT EXISTS idx_instructions_priority ON instructions(priority);\nCREATE INDEX IF NOT EXISTS idx_instructions_priority_tier ON instructions(priority_tier);\nCREATE INDEX IF NOT EXISTS idx_instructions_audience ON instructions(audience);\n\nCREATE TABLE IF NOT EXISTS usage (\n  instruction_id TEXT PRIMARY KEY,\n  usage_count INTEGER DEFAULT 0,\n  first_seen_ts TEXT,\n  last_used_at TEXT,\n  last_action TEXT,\n  last_signal TEXT,\n  last_comment TEXT\n);\n\nCREATE TABLE IF NOT EXISTS messages (\n  id TEXT PRIMARY KEY,\n  channel TEXT NOT NULL,\n  sender TEXT NOT NULL,\n  recipients TEXT NOT NULL DEFAULT '[]',\n  body TEXT NOT NULL,\n  priority TEXT DEFAULT 'normal',\n  tags TEXT DEFAULT '[]',\n  parent_id TEXT,\n  persistent INTEGER DEFAULT 0,\n  ttl_seconds INTEGER,\n  requires_ack INTEGER DEFAULT 0,\n  ack_by_seconds INTEGER,\n  read_by TEXT DEFAULT '[]',\n  payload TEXT,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_messages_channel ON messages(channel);\nCREATE INDEX IF NOT EXISTS idx_messages_sender ON messages(sender);\nCREATE INDEX IF NOT EXISTS idx_messages_parent_id ON messages(parent_id);\nCREATE INDEX IF NOT EXISTS idx_messages_created_at ON messages(created_at);\n\nCREATE TABLE IF NOT EXISTS metadata (\n  key TEXT PRIMARY KEY,\n  value TEXT\n);\n";
+/** FTS5 virtual table for full-text search. Created separately since it needs content sync. */
+export declare const FTS5_DDL = "\nCREATE VIRTUAL TABLE IF NOT EXISTS instructions_fts USING fts5(\n  id, title, body, categories,\n  content='instructions',\n  content_rowid='rowid'\n);\n\n-- Triggers to keep FTS5 in sync with instructions table\nCREATE TRIGGER IF NOT EXISTS instructions_ai AFTER INSERT ON instructions BEGIN\n  INSERT INTO instructions_fts(rowid, id, title, body, categories) VALUES (new.rowid, new.id, new.title, new.body, new.categories);\nEND;\nCREATE TRIGGER IF NOT EXISTS instructions_ad AFTER DELETE ON instructions BEGIN\n  INSERT INTO instructions_fts(instructions_fts, rowid, id, title, body, categories) VALUES('delete', old.rowid, old.id, old.title, old.body, old.categories);\nEND;\nCREATE TRIGGER IF NOT EXISTS instructions_au AFTER UPDATE ON instructions BEGIN\n  INSERT INTO instructions_fts(instructions_fts, rowid, id, title, body, categories) VALUES('delete', old.rowid, old.id, old.title, old.body, old.categories);\n  INSERT INTO instructions_fts(rowid, id, title, body, categories) VALUES (new.rowid, new.id, new.title, new.body, new.categories);\nEND;\n";
+/** Enable WAL mode and recommended pragmas. */
+export declare const PRAGMAS = "\nPRAGMA journal_mode=WAL;\nPRAGMA busy_timeout=5000;\nPRAGMA synchronous=NORMAL;\nPRAGMA foreign_keys=ON;\n";