wyrm-mcp 7.3.2 → 7.3.3

package/dist/database.js

@@ -1,11 +1,264 @@
-import k from"better-sqlite3";import{existsSync as u,mkdirSync as b,readdirSync as D,statSync as L,writeFileSync as I}from"fs";import{homedir as O}from"os";import{join as d,basename as A,resolve as M,normalize as w}from"path";import{spawnSync as R}from"child_process";import{getResilienceManager as v}from"./resilience.js";import{WyrmLogger as j}from"./logger.js";import{runMigrations as H,getSchemaVersion as F}from"./migrations.js";import{validateProjectPath as N,buildFtsMatchQuery as h}from"./security.js";import{emitEvent as m,eventsSince as W,subscribeEvents as U,isLiveMemoryEnabled as x,ingestRemoteEvent as P,eventsForPush as B,pruneEvents as q,getMeta as Y,setMeta as $}from"./events.js";import{getActor as C}from"./handlers/boundary.js";import{readSkillContent as y,slugify as G,skillContentSha as V}from"./skill-author.js";function ae(){return process.env.WYRM_DB_PATH??process.env.WYRM_DB??d(O(),".wyrm","wyrm.db")}class ce{db;BATCH_SIZE=1e3;resilience;logger;dbPath;constructor(t){const e=d(O(),".wyrm");u(e)||b(e,{recursive:!0}),this.dbPath=t||d(e,"wyrm.db"),this.logger=new j,this.resilience=v(),this.db=this.initializeDatabase(this.dbPath),this.db.pragma("journal_mode = WAL"),this.db.pragma("synchronous = NORMAL"),this.db.pragma("cache_size = -64000"),this.db.pragma("temp_store = MEMORY"),this.db.pragma("busy_timeout = 5000"),this.db.pragma("mmap_size = 268435456"),this.db.pragma("page_size = 4096"),this.db.pragma("foreign_keys = ON");const s=H(this.db);s.length>0&&this.logger.info(`Applied ${s.length} migration(s), now at v${F(this.db)}`),this.recoverIncompleteOperations()}getDatabase(){return this.db}getDatabasePath(){return this.dbPath}initializeDatabase(t){const e=this.resilience.withRetrySync(()=>new k(t),"database_init",{maxAttempts:3,baseDelayMs:500});if(!e.success)throw this.logger.error("Failed to initialize database",{path:t,error:e.error?.message}),e.error||new Error("Database initialization failed");return e.data}recoverIncompleteOperations(){const t=this.resilience.getIncompleteOperations();for(const e of t)this.logger.warn("Found incomplete operation from previous session",{operation:e.operation,stage:e.stage,id:e.id}),e.operation==="batch_insert"&&this.logger.info("Batch insert was incomplete - data may need re-import"),this.resilience.completeCheckpoint(e.id)}addWatchDir(t,e=!0){return N(t),this.db.prepare(`
+/**
+ * Wyrm Database - SQLite storage for infinite memory with data lake support
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ *
+ * Features:
+ * - Auto-discovers projects in configured directories
+ * - Handles large datasets with pagination and streaming
+ * - Write-Ahead Logging (WAL) for concurrent performance
+ * - Full-text search for fast context retrieval
+ * - Batch operations for bulk imports
+ * - Resilient operations with automatic recovery
+ */
+import Database from 'better-sqlite3';
+import { existsSync, mkdirSync, readdirSync, statSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join, basename, resolve, normalize } from 'path';
+import { spawnSync } from 'child_process';
+import { getResilienceManager } from './resilience.js';
+import { WyrmLogger } from './logger.js';
+import { runMigrations, getSchemaVersion } from './migrations.js';
+import { validateProjectPath, buildFtsMatchQuery } from './security.js';
+import { emitEvent, eventsSince, subscribeEvents, isLiveMemoryEnabled, ingestRemoteEvent, eventsForPush, pruneEvents, getMeta, setMeta } from './events.js';
+import { getActor } from './handlers/boundary.js';
+import { readSkillContent, slugify as slugifySkillName, skillContentSha } from './skill-author.js';
+/**
+ * Canonical DB-path resolution for every bare WyrmDB consumer (the stdio MCP
+ * server, statusline, cloud sync). Honors WYRM_DB_PATH (canonical — what the
+ * CLI, HTTP server and docs already use); accepts the legacy WYRM_DB that
+ * autoconfig historically wrote, for back-compat; otherwise the default store.
+ * The constructor itself stays env-free, so an explicit path (e.g. a test
+ * sandbox) always wins.
+ */
+export function resolveDbPath() {
+    return process.env.WYRM_DB_PATH ?? process.env.WYRM_DB ?? join(homedir(), '.wyrm', 'wyrm.db');
+}
+export class WyrmDB {
+    db;
+    BATCH_SIZE = 1000;
+    resilience;
+    logger;
+    dbPath;
+    constructor(dbPath) {
+        const wyrmDir = join(homedir(), '.wyrm');
+        if (!existsSync(wyrmDir)) {
+            mkdirSync(wyrmDir, { recursive: true });
+        }
+        this.dbPath = dbPath || join(wyrmDir, 'wyrm.db');
+        this.logger = new WyrmLogger();
+        this.resilience = getResilienceManager();
+        // Initialize database with resilience
+        this.db = this.initializeDatabase(this.dbPath);
+        // Enable WAL mode for better concurrent performance and crash recovery
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('synchronous = NORMAL');
+        this.db.pragma('cache_size = -64000'); // 64MB cache
+        this.db.pragma('temp_store = MEMORY');
+        // busy_timeout = 5000 — the documented multi-process choice (v7 F2, T011).
+        // Under WAL there is exactly ONE writer at a time across ALL processes
+        // sharing this file; a contended writer spins inside SQLite for up to 5s
+        // before SQLITE_BUSY surfaces. Typical Wyrm row writes are sub-millisecond,
+        // so 5s absorbs entire bursts of concurrent fleet writers; anything still
+        // BUSY after 5s means a genuinely long-held lock (bulk import / vacuum),
+        // which the MCP dispatcher surfaces as the structured WYRM_BUSY retry body
+        // (sqlite-busy.ts) instead of an opaque error string.
+        this.db.pragma('busy_timeout = 5000');
+        this.db.pragma('mmap_size = 268435456'); // 256MB memory-mapped I/O
+        this.db.pragma('page_size = 4096'); // Optimal page size
+        this.db.pragma('foreign_keys = ON'); // Enforce referential integrity
+        // Run versioned migrations
+        const applied = runMigrations(this.db);
+        if (applied.length > 0) {
+            this.logger.info(`Applied ${applied.length} migration(s), now at v${getSchemaVersion(this.db)}`);
+        }
+        // Recover any incomplete operations from previous session
+        this.recoverIncompleteOperations();
+    }
+    /** Expose the raw database instance for analytics and other modules */
+    getDatabase() {
+        return this.db;
+    }
+    /** Get the database file path */
+    getDatabasePath() {
+        return this.dbPath;
+    }
+    /**
+     * Initialize database with retry logic for handling corruption/locks
+     */
+    initializeDatabase(path) {
+        const result = this.resilience.withRetrySync(() => new Database(path), 'database_init', { maxAttempts: 3, baseDelayMs: 500 });
+        if (!result.success) {
+            this.logger.error('Failed to initialize database', { path, error: result.error?.message });
+            throw result.error || new Error('Database initialization failed');
+        }
+        return result.data;
+    }
+    /**
+     * Recover incomplete operations from previous session
+     */
+    recoverIncompleteOperations() {
+        const incomplete = this.resilience.getIncompleteOperations();
+        for (const op of incomplete) {
+            this.logger.warn('Found incomplete operation from previous session', {
+                operation: op.operation,
+                stage: op.stage,
+                id: op.id,
+            });
+            // For now, just log - specific recovery logic can be added
+            // based on operation type
+            if (op.operation === 'batch_insert') {
+                this.logger.info('Batch insert was incomplete - data may need re-import');
+            }
+            // Mark as handled
+            this.resilience.completeCheckpoint(op.id);
+        }
+    }
+    // ==================== WATCH DIRECTORIES ====================
+    addWatchDir(path, recursive = true) {
+        // Validate path is within allowed directories to prevent directory traversal
+        validateProjectPath(path);
+        return this.db.prepare(`
       INSERT INTO watch_dirs (path, recursive)
       VALUES (?, ?)
       ON CONFLICT(path) DO UPDATE SET recursive = excluded.recursive
       RETURNING *
-    `).get(t,e?1:0)}getWatchDirs(){return this.db.prepare("SELECT * FROM watch_dirs").all()}removeWatchDir(t){this.db.prepare("DELETE FROM watch_dirs WHERE path = ?").run(t)}scanForProjects(t,e=!0){N(t);const s=[],r=(n,i=0)=>{if(!(i>3&&e))try{const a=D(n,{withFileTypes:!0});for(const o of a){if(!o.isDirectory()||o.name.startsWith(".")&&o.name!==".git")continue;const c=d(n,o.name),l=d(c,".git");if(u(l)){const p=this.registerProjectFromPath(c);p&&s.push(p)}else e&&i<3&&r(c,i+1)}}catch{}};return r(t),this.db.prepare(`
+    `).get(path, recursive ? 1 : 0);
+    }
+    getWatchDirs() {
+        return this.db.prepare('SELECT * FROM watch_dirs').all();
+    }
+    removeWatchDir(path) {
+        this.db.prepare('DELETE FROM watch_dirs WHERE path = ?').run(path);
+    }
+    // ==================== AUTO-DISCOVERY ====================
+    scanForProjects(rootPath, recursive = true) {
+        // Validate path is within allowed directories to prevent directory traversal
+        validateProjectPath(rootPath);
+        const discovered = [];
+        const scan = (dir, depth = 0) => {
+            if (depth > 3 && recursive)
+                return; // Max 3 levels deep
+            try {
+                const entries = readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    if (entry.name.startsWith('.') && entry.name !== '.git')
+                        continue;
+                    const fullPath = join(dir, entry.name);
+                    // Check if it's a git repo
+                    const gitDir = join(fullPath, '.git');
+                    if (existsSync(gitDir)) {
+                        const project = this.registerProjectFromPath(fullPath);
+                        if (project)
+                            discovered.push(project);
+                    }
+                    else if (recursive && depth < 3) {
+                        scan(fullPath, depth + 1);
+                    }
+                }
+            }
+            catch {
+                // Skip inaccessible directories
+            }
+        };
+        scan(rootPath);
+        // Update last scan time
+        this.db.prepare(`
       UPDATE watch_dirs SET last_scan = datetime('now') WHERE path = ?
-    `).run(t),s}scanAllWatchDirs(){const t=this.getWatchDirs(),e=[];for(const s of t){const r=this.scanForProjects(s.path,!!s.recursive);e.push(...r)}return e}registerProjectFromPath(t){try{const e=w(M(t));if(!u(e)||!L(e).isDirectory())return null;const s=A(e);let r,n,i,a;try{const o=R("git",["config","--get","remote.origin.url"],{cwd:e,encoding:"utf-8",timeout:5e3,shell:!1});o.status===0&&(r=o.stdout.trim());const c=R("git",["rev-parse","--abbrev-ref","HEAD"],{cwd:e,encoding:"utf-8",timeout:5e3,shell:!1});c.status===0&&(n=c.stdout.trim());const l=R("git",["log","-1","--format=%h %s"],{cwd:e,encoding:"utf-8",timeout:5e3,shell:!1});l.status===0&&(i=l.stdout.trim())}catch{}return u(d(e,"package.json"))?(a="Node.js",u(d(e,"next.config.js"))||u(d(e,"next.config.ts"))||u(d(e,"next.config.mjs"))?a="Next.js":u(d(e,"vite.config.ts"))&&(a="Vite")):u(d(e,"requirements.txt"))||u(d(e,"pyproject.toml"))?a="Python":u(d(e,"composer.json"))?a="PHP":u(d(e,"Cargo.toml"))?a="Rust":u(d(e,"go.mod"))&&(a="Go"),this.registerProject(s,e,r,a,i,n)}catch{return null}}registerProject(t,e,s,r,n,i){return this.db.prepare(`
+    `).run(rootPath);
+        return discovered;
+    }
+    scanAllWatchDirs() {
+        const dirs = this.getWatchDirs();
+        const all = [];
+        for (const dir of dirs) {
+            const found = this.scanForProjects(dir.path, !!dir.recursive);
+            all.push(...found);
+        }
+        return all;
+    }
+    registerProjectFromPath(projectPath) {
+        try {
+            // SECURITY: Validate path is a real directory before any operations
+            const normalizedPath = normalize(resolve(projectPath));
+            if (!existsSync(normalizedPath) || !statSync(normalizedPath).isDirectory()) {
+                return null;
+            }
+            const name = basename(normalizedPath);
+            let repo;
+            let branch;
+            let lastCommit;
+            let stack;
+            try {
+                // SECURITY: Use spawnSync with shell: false to prevent command injection
+                const repoResult = spawnSync('git', ['config', '--get', 'remote.origin.url'], {
+                    cwd: normalizedPath,
+                    encoding: 'utf-8',
+                    timeout: 5000,
+                    shell: false // CRITICAL: No shell interpretation
+                });
+                if (repoResult.status === 0) {
+                    repo = repoResult.stdout.trim();
+                }
+                const branchResult = spawnSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+                    cwd: normalizedPath,
+                    encoding: 'utf-8',
+                    timeout: 5000,
+                    shell: false
+                });
+                if (branchResult.status === 0) {
+                    branch = branchResult.stdout.trim();
+                }
+                const commitResult = spawnSync('git', ['log', '-1', '--format=%h %s'], {
+                    cwd: normalizedPath,
+                    encoding: 'utf-8',
+                    timeout: 5000,
+                    shell: false
+                });
+                if (commitResult.status === 0) {
+                    lastCommit = commitResult.stdout.trim();
+                }
+            }
+            catch {
+                // Not a git repo or git not available
+            }
+            // Detect stack
+            if (existsSync(join(normalizedPath, 'package.json'))) {
+                stack = 'Node.js';
+                if (existsSync(join(normalizedPath, 'next.config.js')) ||
+                    existsSync(join(normalizedPath, 'next.config.ts')) ||
+                    existsSync(join(normalizedPath, 'next.config.mjs'))) {
+                    stack = 'Next.js';
+                }
+                else if (existsSync(join(normalizedPath, 'vite.config.ts'))) {
+                    stack = 'Vite';
+                }
+            }
+            else if (existsSync(join(normalizedPath, 'requirements.txt')) ||
+                existsSync(join(normalizedPath, 'pyproject.toml'))) {
+                stack = 'Python';
+            }
+            else if (existsSync(join(normalizedPath, 'composer.json'))) {
+                stack = 'PHP';
+            }
+            else if (existsSync(join(normalizedPath, 'Cargo.toml'))) {
+                stack = 'Rust';
+            }
+            else if (existsSync(join(normalizedPath, 'go.mod'))) {
+                stack = 'Go';
+            }
+            return this.registerProject(name, normalizedPath, repo, stack, lastCommit, branch);
+        }
+        catch {
+            return null;
+        }
+    }
+    // ==================== PROJECTS ====================
+    registerProject(name, path, repo, stack, lastCommit, branch) {
+        const stmt = this.db.prepare(`
       INSERT INTO projects (name, path, repo, stack, last_commit, branch)
       VALUES (?, ?, ?, ?, ?, ?)
       ON CONFLICT(path) DO UPDATE SET
@@ -16,33 +269,214 @@ import k from"better-sqlite3";import{existsSync as u,mkdirSync as b,readdirSync
         branch = COALESCE(excluded.branch, projects.branch),
         updated_at = datetime('now')
       RETURNING *
-    `).get(t,e,s||null,r||null,n||null,i||null)}getProject(t){return this.db.prepare("SELECT * FROM projects WHERE path = ?").get(t)}getProjectById(t){return this.db.prepare("SELECT * FROM projects WHERE id = ?").get(t)}getProjectByName(t){return this.db.prepare("SELECT * FROM projects WHERE name = ?").get(t)}getAllProjects(t=100,e=0){return this.db.prepare(`
+    `);
+        return stmt.get(name, path, repo || null, stack || null, lastCommit || null, branch || null);
+    }
+    getProject(path) {
+        return this.db.prepare('SELECT * FROM projects WHERE path = ?').get(path);
+    }
+    getProjectById(id) {
+        return this.db.prepare('SELECT * FROM projects WHERE id = ?').get(id);
+    }
+    getProjectByName(name) {
+        return this.db.prepare('SELECT * FROM projects WHERE name = ?').get(name);
+    }
+    getAllProjects(limit = 100, offset = 0) {
+        return this.db.prepare(`
       SELECT * FROM projects ORDER BY updated_at DESC LIMIT ? OFFSET ?
-    `).all(t,e)}searchProjects(t){const e=`%${t}%`;return this.db.prepare(`
+    `).all(limit, offset);
+    }
+    searchProjects(query) {
+        const pattern = `%${query}%`;
+        return this.db.prepare(`
       SELECT * FROM projects 
       WHERE name LIKE ? OR stack LIKE ? OR repo LIKE ?
       ORDER BY updated_at DESC
       LIMIT 50
-    `).all(e,e,e)}createSession(t,e){const s=this.estimateTokens((e.objectives||"")+(e.completed||"")+(e.issues||"")+(e.notes||"")),r=C(),n=this.resilience.withRetrySync(()=>this.db.prepare(`
+    `).all(pattern, pattern, pattern);
+    }
+    // ==================== SESSIONS ====================
+    createSession(projectId, data) {
+        const tokensEstimate = this.estimateTokens((data.objectives || '') + (data.completed || '') + (data.issues || '') + (data.notes || ''));
+        // v7 F2 (T009): stamp the writing actor (NULL outside a fleet context).
+        const ambient = getActor();
+        const result = this.resilience.withRetrySync(() => {
+            const stmt = this.db.prepare(`
           INSERT INTO sessions (project_id, date, objectives, completed, issues, commits, files_changed, notes, tokens_estimate, agent_id, run_id)
           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
           RETURNING *
-        `).get(t,e.date||new Date().toISOString().split("T")[0],e.objectives||"",e.completed||"",e.issues||"",e.commits||"",e.files_changed||"",e.notes||"",s,r.agent_id,r.run_id),"createSession");if(!n.success)throw n.error||new Error("Failed to create session");return m(this.db,{projectId:t,kind:"session_update",refTable:"sessions",refId:n.data.id}),n.data}updateSession(t,e){const s=[],r=[],n=new Set(["objectives","completed","issues","commits","files_changed","notes","summary","is_archived"]);for(const[a,o]of Object.entries(e))n.has(a)&&(s.push(`${a} = ?`),r.push(o));if(s.length===0)return this.getSession(t);if(e.objectives||e.completed||e.issues||e.notes){const a=this.getSession(t);if(a){const o=this.estimateTokens((e.objectives||a.objectives)+(e.completed||a.completed)+(e.issues||a.issues)+(e.notes||a.notes));s.push("tokens_estimate = ?"),r.push(o)}}r.push(t);const i=this.resilience.withRetrySync(()=>this.db.prepare(`
-          UPDATE sessions SET ${s.join(", ")} WHERE id = ? RETURNING *
-        `).get(...r),"updateSession");if(!i.success)throw i.error||new Error("Failed to update session");return m(this.db,{projectId:i.data.project_id,kind:"session_update",refTable:"sessions",refId:t}),i.data}getSession(t){return this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(t)}updateContinuity(t,e,s){const r=e.trim();if(!r)return;const n=12e3,i=this.db.prepare("SELECT thread, turn_count FROM project_continuity WHERE project_id = ?").get(t),a=new Date().toISOString(),o=`[${a}${s?" \xB7 "+s:""}] ${r}`;let c=i?.thread?i.thread+`
-
-`+o:o;c.length>n&&(c=`[\u2026earlier continuity trimmed \u2014 gist retained below\u2026]
-
-`+c.slice(c.length-n));const l=(i?.turn_count??0)+1;this.resilience.withRetrySync(()=>(this.db.prepare(`
+        `);
+            return stmt.get(projectId, data.date || new Date().toISOString().split('T')[0], data.objectives || '', data.completed || '', data.issues || '', data.commits || '', data.files_changed || '', data.notes || '', tokensEstimate, ambient.agent_id, ambient.run_id);
+        }, 'createSession');
+        if (!result.success) {
+            throw result.error || new Error('Failed to create session');
+        }
+        // Live Memory v6.4: failure-isolated event emit (never throws, never rolls back).
+        emitEvent(this.db, { projectId, kind: 'session_update', refTable: 'sessions', refId: result.data.id });
+        return result.data;
+    }
+    updateSession(id, data) {
+        const updates = [];
+        const values = [];
+        // Allowlist column names to prevent SQL injection via crafted key names
+        const ALLOWED_COLUMNS = new Set(['objectives', 'completed', 'issues', 'commits',
+            'files_changed', 'notes', 'summary', 'is_archived']);
+        for (const [key, value] of Object.entries(data)) {
+            if (ALLOWED_COLUMNS.has(key)) {
+                updates.push(`${key} = ?`);
+                values.push(value);
+            }
+        }
+        if (updates.length === 0)
+            return this.getSession(id);
+        // Recalculate tokens if content changed
+        if (data.objectives || data.completed || data.issues || data.notes) {
+            const session = this.getSession(id);
+            if (session) {
+                const newTokens = this.estimateTokens((data.objectives || session.objectives) +
+                    (data.completed || session.completed) +
+                    (data.issues || session.issues) +
+                    (data.notes || session.notes));
+                updates.push('tokens_estimate = ?');
+                values.push(newTokens);
+            }
+        }
+        values.push(id);
+        const result = this.resilience.withRetrySync(() => {
+            const stmt = this.db.prepare(`
+          UPDATE sessions SET ${updates.join(', ')} WHERE id = ? RETURNING *
+        `);
+            return stmt.get(...values);
+        }, 'updateSession');
+        if (!result.success) {
+            throw result.error || new Error('Failed to update session');
+        }
+        emitEvent(this.db, { projectId: result.data.project_id, kind: 'session_update', refTable: 'sessions', refId: id });
+        return result.data;
+    }
+    getSession(id) {
+        return this.db.prepare('SELECT * FROM sessions WHERE id = ?').get(id);
+    }
+    // ── Continuity Layer (migration 27): the rolling per-project living thread ──
+    /**
+     * Append [note] to the project's continuity thread — the running narrative of what we're working
+     * on / talking / thinking about. Bounded (oldest trimmed with a marker) so it never grows
+     * unbounded yet never loses the gist. This is what lets a fresh chat — or a different surface
+     * (phone, Hermes, Ember, Gemini) — re-open already knowing where we left off.
+     */
+    updateContinuity(projectId, note, by) {
+        const trimmed = note.trim();
+        if (!trimmed)
+            return;
+        const CAP = 12000;
+        const row = this.db
+            .prepare('SELECT thread, turn_count FROM project_continuity WHERE project_id = ?')
+            .get(projectId);
+        const stamp = new Date().toISOString();
+        const entry = `[${stamp}${by ? ' · ' + by : ''}] ${trimmed}`;
+        let thread = row?.thread ? row.thread + '\n\n' + entry : entry;
+        if (thread.length > CAP) {
+            thread = '[…earlier continuity trimmed — gist retained below…]\n\n' + thread.slice(thread.length - CAP);
+        }
+        const turns = (row?.turn_count ?? 0) + 1;
+        this.resilience.withRetrySync(() => {
+            this.db
+                .prepare(`
           INSERT INTO project_continuity (project_id, thread, updated_at, updated_by, turn_count)
           VALUES (?, ?, ?, ?, ?)
           ON CONFLICT(project_id) DO UPDATE SET
             thread = excluded.thread, updated_at = excluded.updated_at,
             updated_by = excluded.updated_by, turn_count = excluded.turn_count
-        `).run(t,c,a,s??null,l),!0),"updateContinuity")}getContinuity(t){return this.db.prepare("SELECT thread, updated_at, updated_by, turn_count FROM project_continuity WHERE project_id = ?").get(t)??null}recordRouting(t){const e=t.projectId==null?-1:t.projectId,s=(t.taskType??"").trim(),r=(t.modelId??"").trim();if(!s)throw new Error("recordRouting: taskType is required");if(!r)throw new Error("recordRouting: modelId is required");let n=null;if(Array.isArray(t.toolNames)){const o=[...new Set(t.toolNames.map(c=>String(c).trim()).filter(Boolean))];n=o.length?o.join(","):null}else if(typeof t.toolNames=="string"){const o=[...new Set(t.toolNames.split(",").map(c=>c.trim()).filter(Boolean))];n=o.length?o.join(","):null}const i=t.latencyMs==null||!Number.isFinite(t.latencyMs)?null:Math.max(0,Math.round(t.latencyMs));let a=-1;return this.resilience.withRetrySync(()=>{const o=this.db.prepare(`
+        `)
+                .run(projectId, thread, stamp, by ?? null, turns);
+            return true;
+        }, 'updateContinuity');
+    }
+    /** The project's current continuity thread (the living "where we left off"), or null if none yet. */
+    getContinuity(projectId) {
+        const row = this.db
+            .prepare('SELECT thread, updated_at, updated_by, turn_count FROM project_continuity WHERE project_id = ?')
+            .get(projectId);
+        return row ?? null;
+    }
+    // ==================== ROUTING MEMORY (migration 28) ====================
+    //
+    // The durable, queryable home for the dragon-cli multi-model router's
+    // decision+outcome log. recordRouting() appends one row per delegated run;
+    // recallRouting() aggregates per (model, tool-set) candidate so the router
+    // can steer toward proven winners and away from past failures (negative
+    // learning) for a given task_type.
+    /** Append one routing decision+outcome. Append-only (an event log); never
+     *  updates a prior row. project_id defaults to -1 (global/unscoped). */
+    recordRouting(rec) {
+        const projectId = rec.projectId == null ? -1 : rec.projectId;
+        const taskType = (rec.taskType ?? '').trim();
+        const modelId = (rec.modelId ?? '').trim();
+        if (!taskType)
+            throw new Error('recordRouting: taskType is required');
+        if (!modelId)
+            throw new Error('recordRouting: modelId is required');
+        // Normalize tool_names to a comma-joined string (or null). Accepts an
+        // array (preferred) or a pre-joined string; blanks/dupes are dropped so
+        // the recall GROUP BY treats the same tool-set as one candidate.
+        let toolNames = null;
+        if (Array.isArray(rec.toolNames)) {
+            const cleaned = [...new Set(rec.toolNames.map((t) => String(t).trim()).filter(Boolean))];
+            toolNames = cleaned.length ? cleaned.join(',') : null;
+        }
+        else if (typeof rec.toolNames === 'string') {
+            const cleaned = [...new Set(rec.toolNames.split(',').map((t) => t.trim()).filter(Boolean))];
+            toolNames = cleaned.length ? cleaned.join(',') : null;
+        }
+        const latencyMs = rec.latencyMs == null || !Number.isFinite(rec.latencyMs)
+            ? null
+            : Math.max(0, Math.round(rec.latencyMs));
+        let id = -1;
+        this.resilience.withRetrySync(() => {
+            const info = this.db
+                .prepare(`
           INSERT INTO routing_memory (project_id, task_type, model_id, tool_names, success, latency_ms)
           VALUES (?, ?, ?, ?, ?, ?)
-        `).run(e,s,r,n,t.success?1:0,i);return a=Number(o.lastInsertRowid),!0},"recordRouting"),a}recallRouting(t,e={}){const s=(t??"").trim();if(!s)return[];const r=Math.min(100,Math.max(1,e.limit??10)),n=["task_type = ?"],i=[s];e.projectId!=null&&(n.push("(project_id = ? OR project_id = -1)"),i.push(e.projectId)),e.sinceDays!=null&&Number.isFinite(e.sinceDays)&&e.sinceDays>0&&(n.push("ts >= datetime('now', ?)"),i.push(`-${Math.round(e.sinceDays)} days`)),i.push(r);try{return this.db.prepare(`
+        `)
+                .run(projectId, taskType, modelId, toolNames, rec.success ? 1 : 0, latencyMs);
+            id = Number(info.lastInsertRowid);
+            return true;
+        }, 'recordRouting');
+        return id;
+    }
+    /**
+     * Recall the routing candidates for a task_type, aggregated per
+     * (model_id, tool-set) and ranked for negative learning: highest success
+     * rate first, then most runs (more evidence), then most recent. Scoped to
+     * `projectId` when given (and ALWAYS includes global/-1 rows so a router
+     * that never registered a project still benefits); global across all
+     * projects when omitted.
+     *
+     * @param taskType   the router's task classification (the recall key)
+     * @param opts.projectId  scope to this project (+ global -1 rows); omit for global
+     * @param opts.limit      max candidates returned (default 10, cap 100)
+     * @param opts.sinceDays  only consider runs within this recency window (optional)
+     */
+    recallRouting(taskType, opts = {}) {
+        const tt = (taskType ?? '').trim();
+        if (!tt)
+            return [];
+        const limit = Math.min(100, Math.max(1, opts.limit ?? 10));
+        const where = ['task_type = ?'];
+        const params = [tt];
+        if (opts.projectId != null) {
+            // Always fold in global/-1 rows alongside the project's own.
+            where.push('(project_id = ? OR project_id = -1)');
+            params.push(opts.projectId);
+        }
+        if (opts.sinceDays != null && Number.isFinite(opts.sinceDays) && opts.sinceDays > 0) {
+            where.push(`ts >= datetime('now', ?)`);
+            params.push(`-${Math.round(opts.sinceDays)} days`);
+        }
+        params.push(limit);
+        try {
+            const rows = this.db
+                .prepare(`
           SELECT
             model_id,
             COALESCE(tool_names, '')                       AS tool_names,
@@ -52,30 +486,69 @@ import k from"better-sqlite3";import{existsSync as u,mkdirSync as b,readdirSync
             AVG(CASE WHEN latency_ms IS NOT NULL THEN latency_ms END) AS avg_latency_ms,
             MAX(ts)                                        AS last_ts
           FROM routing_memory
-          WHERE ${n.join(" AND ")}
+          WHERE ${where.join(' AND ')}
           GROUP BY model_id, COALESCE(tool_names, '')
           ORDER BY (CAST(SUM(success) AS REAL) / COUNT(*)) DESC, runs DESC, last_ts DESC
           LIMIT ?
-        `).all(...i).map(o=>({model_id:o.model_id,tool_names:o.tool_names,runs:o.runs,successes:o.successes,failures:o.failures,success_rate:o.runs>0?o.successes/o.runs:0,avg_latency_ms:o.avg_latency_ms==null?null:Math.round(o.avg_latency_ms),last_ts:o.last_ts}))}catch{return[]}}getRecentSessions(t,e=5){return this.db.prepare(`
+        `)
+                .all(...params);
+            return rows.map((r) => ({
+                model_id: r.model_id,
+                tool_names: r.tool_names,
+                runs: r.runs,
+                successes: r.successes,
+                failures: r.failures,
+                success_rate: r.runs > 0 ? r.successes / r.runs : 0,
+                avg_latency_ms: r.avg_latency_ms == null ? null : Math.round(r.avg_latency_ms),
+                last_ts: r.last_ts,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    getRecentSessions(projectId, limit = 5) {
+        return this.db.prepare(`
       SELECT * FROM sessions 
       WHERE project_id = ? AND is_archived = 0
       ORDER BY date DESC, id DESC
       LIMIT ?
-    `).all(t,e)}getTodaySession(t){const e=new Date().toISOString().split("T")[0];return this.db.prepare(`
+    `).all(projectId, limit);
+    }
+    getTodaySession(projectId) {
+        const today = new Date().toISOString().split('T')[0];
+        return this.db.prepare(`
       SELECT * FROM sessions WHERE project_id = ? AND date = ?
-    `).get(t,e)}searchSessions(t,e){const s=h(t);if(!s)return[];try{return e?this.db.prepare(`
+    `).get(projectId, today);
+    }
+    searchSessions(query, projectId) {
+        const match = buildFtsMatchQuery(query);
+        if (!match)
+            return [];
+        try {
+            if (projectId) {
+                return this.db.prepare(`
           SELECT s.* FROM sessions s
           JOIN sessions_fts fts ON s.id = fts.rowid
           WHERE sessions_fts MATCH ? AND s.project_id = ?
           ORDER BY bm25(sessions_fts), s.date DESC
           LIMIT 50
-        `).all(s,e):this.db.prepare(`
+        `).all(match, projectId);
+            }
+            return this.db.prepare(`
         SELECT s.* FROM sessions s
         JOIN sessions_fts fts ON s.id = fts.rowid
         WHERE sessions_fts MATCH ?
         ORDER BY bm25(sessions_fts), s.date DESC
         LIMIT 50
-      `).all(s)}catch{return[]}}archiveOldSessions(t,e=10){return this.db.prepare(`
+      `).all(match);
+        }
+        catch {
+            return [];
+        }
+    }
+    archiveOldSessions(projectId, keepRecent = 10) {
+        const result = this.db.prepare(`
       UPDATE sessions 
       SET is_archived = 1
       WHERE project_id = ? 
@@ -86,16 +559,39 @@ import k from"better-sqlite3";import{existsSync as u,mkdirSync as b,readdirSync
           ORDER BY date DESC, id DESC 
           LIMIT ?
         )
-    `).run(t,t,e).changes}getSessionTokenUsage(t){return this.db.prepare(`
+    `).run(projectId, projectId, keepRecent);
+        return result.changes;
+    }
+    getSessionTokenUsage(projectId) {
+        const result = this.db.prepare(`
       SELECT COALESCE(SUM(tokens_estimate), 0) as total
       FROM sessions WHERE project_id = ? AND is_archived = 0
-    `).get(t).total}addQuest(t,e,s,r="medium",n){const i=C(),a=this.db.prepare(`
+    `).get(projectId);
+        return result.total;
+    }
+    // ==================== QUESTS ====================
+    addQuest(projectId, title, description, priority = 'medium', tags) {
+        // v7 F2 (T009): stamp the writing actor (NULL outside a fleet context).
+        const ambient = getActor();
+        const quest = this.db.prepare(`
       INSERT INTO quests (project_id, title, description, priority, tags, agent_id, run_id)
       VALUES (?, ?, ?, ?, ?, ?, ?)
       RETURNING *
-    `).get(t,e,s||"",r,n||null,i.agent_id,i.run_id);return m(this.db,{projectId:t,kind:"quest",refTable:"quests",refId:a.id}),a}updateQuest(t,e){const s=e==="completed"?new Date().toISOString():null,r=this.db.prepare(`
+    `).get(projectId, title, description || '', priority, tags || null, ambient.agent_id, ambient.run_id);
+        emitEvent(this.db, { projectId, kind: 'quest', refTable: 'quests', refId: quest.id });
+        return quest;
+    }
+    updateQuest(id, status) {
+        const completedAt = status === 'completed' ? new Date().toISOString() : null;
+        const quest = this.db.prepare(`
       UPDATE quests SET status = ?, completed_at = ? WHERE id = ? RETURNING *
-    `).get(e,s,t);return r&&m(this.db,{projectId:r.project_id,kind:"quest",refTable:"quests",refId:t}),r}getPendingQuests(t){return this.db.prepare(`
+    `).get(status, completedAt, id);
+        if (quest)
+            emitEvent(this.db, { projectId: quest.project_id, kind: 'quest', refTable: 'quests', refId: id });
+        return quest;
+    }
+    getPendingQuests(projectId) {
+        return this.db.prepare(`
       SELECT * FROM quests 
       WHERE project_id = ? AND status IN ('pending', 'in_progress')
       ORDER BY 
@@ -106,7 +602,10 @@ import k from"better-sqlite3";import{existsSync as u,mkdirSync as b,readdirSync
           WHEN 'low' THEN 4 
         END,
         created_at ASC
-    `).all(t)}getAllPendingQuests(){return this.db.prepare(`
+    `).all(projectId);
+    }
+    getAllPendingQuests() {
+        return this.db.prepare(`
       SELECT q.*, p.name as project_name FROM quests q
       JOIN projects p ON q.project_id = p.id
       WHERE q.status IN ('pending', 'in_progress')
@@ -118,36 +617,136 @@ import k from"better-sqlite3";import{existsSync as u,mkdirSync as b,readdirSync
           WHEN 'low' THEN 4 
         END,
         q.created_at ASC
-    `).all()}searchQuests(t){const e=h(t);if(!e)return[];try{return this.db.prepare(`
+    `).all();
+    }
+    searchQuests(query) {
+        const match = buildFtsMatchQuery(query);
+        if (!match)
+            return [];
+        try {
+            return this.db.prepare(`
         SELECT q.* FROM quests q
         JOIN quests_fts fts ON q.id = fts.rowid
         WHERE quests_fts MATCH ?
         ORDER BY bm25(quests_fts), q.created_at DESC
         LIMIT 50
-      `).all(e)}catch{return[]}}getRecentlyCompleted(t,e=5){return this.db.prepare(`
+      `).all(match);
+        }
+        catch {
+            return [];
+        } // defense-in-depth: a malformed MATCH yields [], never throws
+    }
+    getRecentlyCompleted(projectId, limit = 5) {
+        return this.db.prepare(`
       SELECT * FROM quests 
       WHERE project_id = ? AND status = 'completed'
       ORDER BY completed_at DESC
       LIMIT ?
-    `).all(t,e)}setContext(t,e,s){this.db.prepare(`
+    `).all(projectId, limit);
+    }
+    // ==================== CONTEXT ====================
+    setContext(projectId, key, value) {
+        this.db.prepare(`
       INSERT INTO context (project_id, key, value)
       VALUES (?, ?, ?)
       ON CONFLICT(project_id, key) DO UPDATE SET
         value = excluded.value,
         updated_at = datetime('now')
-    `).run(t,e,s)}getContext(t,e){return this.db.prepare(`
+    `).run(projectId, key, value);
+    }
+    getContext(projectId, key) {
+        const row = this.db.prepare(`
       SELECT value FROM context WHERE project_id = ? AND key = ?
-    `).get(t,e)?.value}getAllContext(t){const e=this.db.prepare(`
+    `).get(projectId, key);
+        return row?.value;
+    }
+    getAllContext(projectId) {
+        const rows = this.db.prepare(`
       SELECT key, value FROM context WHERE project_id = ?
-    `).all(t),s={};for(const r of e)s[r.key]=r.value;return s}liveMemoryEnabled(){return x()}eventsSince(t,e=0,s=100){return W(this.db,t,e,s)}subscribeEvents(t,e=20){return U(this.db,t,e)}publishEvent(t){m(this.db,t)}pruneEvents(t={}){return q(this.db,t)}ingestRemoteEvent(t,e){return P(this.db,t,e)}eventsForPush(t,e=0,s=200){return B(this.db,t,e,s)}getMeta(t){return Y(this.db,t)}setMeta(t,e){$(this.db,t,e)}setGlobalContext(t,e){this.db.prepare(`
+    `).all(projectId);
+        const result = {};
+        for (const row of rows) {
+            result[row.key] = row.value;
+        }
+        return result;
+    }
+    // ==================== LIVE MEMORY (v6.4) ====================
+    /** Is the Live Memory event log active? (WYRM_LIVE_MEMORY, default ON.) */
+    liveMemoryEnabled() {
+        return isLiveMemoryEnabled();
+    }
+    /** Pull events newer than a cursor for a project (one-shot, idempotent). */
+    eventsSince(projectId, sinceCursor = 0, limit = 100) {
+        return eventsSince(this.db, projectId, sinceCursor, limit);
+    }
+    /** Initial subscribe: current head cursor + a recent chronological window. */
+    subscribeEvents(projectId, window = 20) {
+        return subscribeEvents(this.db, projectId, window);
+    }
+    /** Manually publish an event (e.g. a tool_call marker). Failure-isolated. */
+    publishEvent(input) {
+        emitEvent(this.db, input);
+    }
+    /** Retention sweep for the Live Memory event log. Bounded + failure-isolated. */
+    pruneEvents(opts = {}) {
+        return pruneEvents(this.db, opts);
+    }
+    // Phase 3 — cross-device replication primitives.
+    /** Ingest a peer's event (PULL). Echo-suppressed + idempotent. */
+    ingestRemoteEvent(localProjectId, ev) {
+        return ingestRemoteEvent(this.db, localProjectId, ev);
+    }
+    /** Shared events past a watermark, for PUSH up to a peer (privacy-gated). */
+    eventsForPush(projectId, sinceCursor = 0, limit = 200) {
+        return eventsForPush(this.db, projectId, sinceCursor, limit);
+    }
+    /** Persistent KV in wyrm_meta — replication watermarks live here. */
+    getMeta(key) { return getMeta(this.db, key); }
+    setMeta(key, value) { setMeta(this.db, key, value); }
+    // ==================== GLOBAL CONTEXT ====================
+    setGlobalContext(key, value) {
+        this.db.prepare(`
       INSERT INTO global_context (key, value)
       VALUES (?, ?)
       ON CONFLICT(key) DO UPDATE SET
         value = excluded.value,
         updated_at = datetime('now')
-    `).run(t,e)}getGlobalContext(t){return this.db.prepare(`
+    `).run(key, value);
+    }
+    getGlobalContext(key) {
+        const row = this.db.prepare(`
       SELECT value FROM global_context WHERE key = ?
-    `).get(t)?.value}getAllGlobalContext(){const t=this.db.prepare("SELECT key, value FROM global_context").all(),e={};for(const s of t)e[s.key]=s.value;return e}registerSkill(t,e,s,r,n,i,a,o){const c=o?.tier??"atomic",l=JSON.stringify(Array.isArray(o?.governs)?o.governs:[]),p=JSON.stringify(Array.isArray(o?.composes)?o.composes:[]),_=y({skillPath:s,name:t}),g=_?.content??null,S=_?.sha256??null,f=_?new Date().toISOString():null,E=this.resilience.withRetrySync(()=>this.db.prepare(`
+    `).get(key);
+        return row?.value;
+    }
+    getAllGlobalContext() {
+        const rows = this.db.prepare('SELECT key, value FROM global_context').all();
+        const result = {};
+        for (const row of rows) {
+            result[row.key] = row.value;
+        }
+        return result;
+    }
+    // ==================== SKILLS MANAGEMENT ====================
+    registerSkill(name, description, skillPath, category, author, version, tags, governance) {
+        // Normalize governance to safe defaults so existing callers (no 8th arg)
+        // keep producing 'atomic' / '[]' / '[]' — fully backward-compatible.
+        const tier = governance?.tier ?? 'atomic';
+        const governsJson = JSON.stringify(Array.isArray(governance?.governs) ? governance.governs : []);
+        const composesJson = JSON.stringify(Array.isArray(governance?.composes) ? governance.composes : []);
+        // Migration 25: capture the SKILL.md body so the skill is portable across
+        // machines. Best-effort — an unreadable/missing file stores NULL and never
+        // blocks registration. On re-register we only OVERWRITE stored content when
+        // the file is freshly readable (excluded.content IS NOT NULL); otherwise we
+        // KEEP whatever was backfilled so a transient bad path can't wipe it.
+        // `cross_project_visibility`/`is_shared` are deliberately NOT touched here:
+        // they keep their private-by-default value across re-registrations (the
+        // egress gate must never silently flip on a routine re-register).
+        const captured = readSkillContent({ skillPath, name });
+        const content = captured?.content ?? null;
+        const contentSha = captured?.sha256 ?? null;
+        const contentUpdatedAt = captured ? new Date().toISOString() : null;
+        const result = this.resilience.withRetrySync(() => this.db.prepare(`
         INSERT INTO skills (name, description, skill_path, category, author, version, tags, tier, governs, composes, content, content_sha256, content_updated_at, is_active, usage_count)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, 0)
         ON CONFLICT(name) DO UPDATE SET
@@ -169,17 +768,299 @@ import k from"better-sqlite3";import{existsSync as u,mkdirSync as b,readdirSync
           updated_at = datetime('now'),
           is_active = 1
         RETURNING *
-      `).get(t,e,s,r||null,n||null,i||null,a||null,c,l,p,g,S,f),"registerSkill");if(!E.success)throw E.error||new Error("Failed to register skill");return E.data}getSkill(t){const e=this.db.prepare("SELECT * FROM skills WHERE name = ?").get(t);return e&&this.db.prepare("UPDATE skills SET last_used = datetime('now'), usage_count = usage_count + 1 WHERE id = ?").run(e.id),e}backfillSkillContent(t={}){const e=t.read??y,s=this.db.prepare("SELECT id, name, skill_path, content_sha256 FROM skills").all();let r=0,n=0,i=0;const a=this.db.prepare("UPDATE skills SET content = ?, content_sha256 = ?, content_updated_at = ?, updated_at = datetime('now') WHERE id = ?");return this.db.transaction(()=>{for(const c of s){const l=e({skillPath:c.skill_path,name:c.name,skillsDir:t.skillsDir});if(!l){i++;continue}if(c.content_sha256&&c.content_sha256===l.sha256){n++;continue}a.run(l.content,l.sha256,new Date().toISOString(),c.id),r++}})(),{total:s.length,filled:r,unchanged:n,missing:i}}exportSkillContent(t,e={}){const s=e.includeInactive?"":" WHERE is_active = 1",r=this.db.prepare(`SELECT name, content FROM skills${s} ORDER BY name`).all();let n=0,i=0,a=0;const o=new Set;for(const c of r){if(c.content==null){i++;continue}let l=G(c.name);if(!l){i++;continue}o.has(l)&&(l=`${l}-${V(c.name).slice(0,8)}`,a++),o.add(l);const p=d(t,l);b(p,{recursive:!0}),I(d(p,"SKILL.md"),c.content,"utf-8"),n++}return{total:r.length,written:n,skipped_no_content:i,collisions:a}}setSkillVisibility(t,e){return this.db.prepare("UPDATE skills SET cross_project_visibility = ?, updated_at = datetime('now') WHERE name = ? RETURNING *").get(e,t)}setAllSkillsVisibility(t,e={}){const s=[],r=[t];e.includeInactive||s.push("is_active = 1"),e.tier&&(s.push("tier = ?"),r.push(e.tier));const n=s.length?" WHERE "+s.join(" AND "):"";return this.db.prepare(`UPDATE skills SET cross_project_visibility = ?, updated_at = datetime('now')${n}`).run(...r).changes}listSkills(t,e,s,r){let n="SELECT * FROM skills WHERE 1=1";const i=[];if(t!==void 0&&(n+=" AND is_active = ?",i.push(t?1:0)),e&&(n+=" AND category = ?",i.push(e)),r&&(n+=" AND tier = ?",i.push(r)),s){const a=h(s);a&&(n+=" AND id IN (SELECT rowid FROM skills_fts WHERE skills_fts MATCH ?)",i.push(a))}return n+=" ORDER BY updated_at DESC",this.db.prepare(n).all(...i)}searchSkills(t,e=20,s){const r=h(t);if(!r)return[];const n=s?" AND s.tier = ?":"",i=this.db.prepare(`
+      `).get(name, description, skillPath, category || null, author || null, version || null, tags || null, tier, governsJson, composesJson, content, contentSha, contentUpdatedAt), 'registerSkill');
+        if (!result.success) {
+            throw result.error || new Error('Failed to register skill');
+        }
+        return result.data;
+    }
+    getSkill(name) {
+        const skill = this.db.prepare('SELECT * FROM skills WHERE name = ?').get(name);
+        if (skill) {
+            // Update last_used
+            this.db.prepare('UPDATE skills SET last_used = datetime(\'now\'), usage_count = usage_count + 1 WHERE id = ?').run(skill.id);
+        }
+        return skill;
+    }
+    /**
+     * Backfill SKILL.md content into the registry (migration 25). Scans every
+     * registered skill, reads its SKILL.md (skill_path, fallback
+     * <skillsDir>/<slug>/SKILL.md) and stores content + sha. IDEMPOTENT: a skill
+     * whose on-disk sha already matches the stored sha is skipped (unchanged).
+     * Never throws on an unreadable file — that skill is counted `missing`.
+     *
+     * `read` is injected (defaults to readSkillContent) so tests can sandbox the
+     * filesystem; it returns {content, sha256} or null.
+     */
+    backfillSkillContent(opts = {}) {
+        const read = opts.read ?? readSkillContent;
+        const skills = this.db.prepare('SELECT id, name, skill_path, content_sha256 FROM skills')
+            .all();
+        let filled = 0, unchanged = 0, missing = 0;
+        const update = this.db.prepare(`UPDATE skills SET content = ?, content_sha256 = ?, content_updated_at = ?, updated_at = datetime('now') WHERE id = ?`);
+        const tx = this.db.transaction(() => {
+            for (const s of skills) {
+                const got = read({ skillPath: s.skill_path, name: s.name, skillsDir: opts.skillsDir });
+                if (!got) {
+                    missing++;
+                    continue;
+                }
+                if (s.content_sha256 && s.content_sha256 === got.sha256) {
+                    unchanged++;
+                    continue;
+                }
+                update.run(got.content, got.sha256, new Date().toISOString(), s.id);
+                filled++;
+            }
+        });
+        tx();
+        return { total: skills.length, filled, unchanged, missing };
+    }
+    /**
+     * Materialize skills from the registry to disk (migration 25): write
+     * <targetDir>/<slug>/SKILL.md from stored `content` for every skill that has
+     * content. This is how a fresh machine reconstitutes the actual skill files
+     * after pulling the synced DB. Round-trips byte-faithfully (content stored
+     * verbatim, written verbatim). Skills with NULL content are skipped (counted
+     * `skipped_no_content`). `includeInactive=false` exports only active skills.
+     */
+    exportSkillContent(targetDir, opts = {}) {
+        const where = opts.includeInactive ? '' : ' WHERE is_active = 1';
+        // ORDER BY name = deterministic export (which row keeps the bare slug on a
+        // collision no longer depends on rowid/insertion order).
+        const skills = this.db.prepare(`SELECT name, content FROM skills${where} ORDER BY name`)
+            .all();
+        let written = 0, skipped = 0, collisions = 0;
+        const usedSlugs = new Set();
+        for (const s of skills) {
+            if (s.content == null) {
+                skipped++;
+                continue;
+            }
+            let slug = slugifySkillName(s.name);
+            if (!slug) {
+                skipped++;
+                continue;
+            }
+            // skills.name is UNIQUE but slugs are NOT (case/punctuation folding + the
+            // 48-char cap collapse distinct names). Disambiguate deterministically so a
+            // later skill never silently clobbers an earlier one's SKILL.md — the
+            // authoring path (deploySkill) refuses clobber, and export must not lose data.
+            if (usedSlugs.has(slug)) {
+                slug = `${slug}-${skillContentSha(s.name).slice(0, 8)}`;
+                collisions++;
+            }
+            usedSlugs.add(slug);
+            const dir = join(targetDir, slug);
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(join(dir, 'SKILL.md'), s.content, 'utf-8');
+            written++;
+        }
+        return { total: skills.length, written, skipped_no_content: skipped, collisions };
+    }
+    /**
+     * Promote (or re-privatize) a skill's cloud-sync visibility — the egress
+     * gate from migration 25. Default-private skills only leave the machine once
+     * promoted to 'org'/'public'. Returns the updated row, or undefined if the
+     * skill does not exist.
+     */
+    setSkillVisibility(name, visibility) {
+        const row = this.db.prepare(`UPDATE skills SET cross_project_visibility = ?, updated_at = datetime('now') WHERE name = ? RETURNING *`).get(visibility, name);
+        return row;
+    }
+    /**
+     * Bulk visibility set — the egress lever for promoting many skills at once
+     * (e.g. share the whole library to a teammate / another machine). Optional
+     * `tier` filter; active-only unless `includeInactive`. Returns rows changed.
+     * `tier` is bound (never interpolated). Egress still gated downstream by the
+     * per-row visibility the sync engine reads — this is just how the operator
+     * flips many rows in one command instead of one `share <name>` at a time.
+     */
+    setAllSkillsVisibility(visibility, opts = {}) {
+        const conds = [];
+        const params = [visibility];
+        if (!opts.includeInactive)
+            conds.push('is_active = 1');
+        if (opts.tier) {
+            conds.push('tier = ?');
+            params.push(opts.tier);
+        }
+        const where = conds.length ? ' WHERE ' + conds.join(' AND ') : '';
+        const res = this.db.prepare(`UPDATE skills SET cross_project_visibility = ?, updated_at = datetime('now')${where}`).run(...params);
+        return res.changes;
+    }
+    listSkills(active, category, search, tier) {
+        let query = 'SELECT * FROM skills WHERE 1=1';
+        const params = [];
+        if (active !== undefined) {
+            query += ' AND is_active = ?';
+            params.push(active ? 1 : 0);
+        }
+        if (category) {
+            query += ' AND category = ?';
+            params.push(category);
+        }
+        if (tier) {
+            query += ' AND tier = ?';
+            params.push(tier);
+        }
+        if (search) {
+            const match = buildFtsMatchQuery(search);
+            if (match) {
+                query += ' AND id IN (SELECT rowid FROM skills_fts WHERE skills_fts MATCH ?)';
+                params.push(match);
+            }
+        }
+        query += ' ORDER BY updated_at DESC';
+        return this.db.prepare(query).all(...params);
+    }
+    searchSkills(query, limit = 20, tier) {
+        const match = buildFtsMatchQuery(query);
+        if (!match)
+            return [];
+        // Optional tier filter is applied in SQL so the FTS rank ordering is preserved.
+        const tierClause = tier ? ' AND s.tier = ?' : '';
+        const stmt = this.db.prepare(`
       SELECT s.* FROM skills s
       JOIN skills_fts ON s.id = skills_fts.rowid
-      WHERE skills_fts MATCH ?${n}
+      WHERE skills_fts MATCH ?${tierClause}
       ORDER BY rank
       LIMIT ?
-    `);return s?i.all(r,s,e):i.all(r,e)}getSkillGraph(t){const e=this.db.prepare("SELECT * FROM skills").all(),s=new Map;for(const o of e)s.set(o.name,o);const r=o=>{if(!o)return[];try{const c=JSON.parse(o);return Array.isArray(c)?c.filter(l=>typeof l=="string"):[]}catch{return[]}},n=(o,c)=>{const l=s.get(o);if(!l)return null;const p=r(l.governs),_=r(l.composes),g={name:l.name,tier:l.tier??"atomic",description:l.description,governs:p,composes:_,children:[]},S=[];if(!c.has(o)){const f=new Set(c).add(o);for(const E of p){const T=n(E,f);T?g.children.push(T):S.push(E)}}return S.length&&(g.missing=S),g};if(t){const o=n(t,new Set);return o?[o]:[]}const i=e.filter(o=>(o.tier??"atomic")==="god").map(o=>o.name).sort(),a=[];for(const o of i){const c=n(o,new Set);c&&a.push(c)}return a}updateSkill(t,e){const s=[],r=[];return e.description!==void 0&&(s.push("description = ?"),r.push(e.description)),e.skill_path!==void 0&&(s.push("skill_path = ?"),r.push(e.skill_path)),e.category!==void 0&&(s.push("category = ?"),r.push(e.category)),e.is_active!==void 0&&(s.push("is_active = ?"),r.push(e.is_active?1:0)),e.tags!==void 0&&(s.push("tags = ?"),r.push(e.tags)),e.version!==void 0&&(s.push("version = ?"),r.push(e.version)),s.length===0?this.getSkill(t):(s.push("updated_at = datetime('now')"),r.push(t),this.db.prepare(`
-      UPDATE skills SET ${s.join(", ")} WHERE name = ? RETURNING *
-    `).get(...r))}deleteSkill(t){return this.db.prepare("DELETE FROM skills WHERE name = ?").run(t).changes>0}deactivateSkill(t){return this.updateSkill(t,{is_active:!1})}activateSkill(t){return this.updateSkill(t,{is_active:!0})}getSkillStats(){const t=this.db.prepare("SELECT COUNT(*) as count FROM skills").get().count,e=this.db.prepare("SELECT COUNT(*) as count FROM skills WHERE is_active = 1").get().count,s=this.db.prepare(`
+    `);
+        return (tier ? stmt.all(match, tier, limit) : stmt.all(match, limit));
+    }
+    /**
+     * Build the GOD-SKILL SPEC v2 governance graph.
+     *
+     * Walks tier routing edges: a node's `governs` list names the skills it routes
+     * DOWN to (god → mega → atomic). Each node also exposes its `composes` list
+     * (lateral pull-ins). When `root` is given, returns that single tree; otherwise
+     * returns a forest of every 'god' tier skill (the apexes). Cycle-safe.
+     */
+    getSkillGraph(root) {
+        const all = this.db.prepare('SELECT * FROM skills').all();
+        const byName = new Map();
+        for (const s of all)
+            byName.set(s.name, s);
+        const parseArr = (v) => {
+            if (!v)
+                return [];
+            try {
+                const parsed = JSON.parse(v);
+                return Array.isArray(parsed) ? parsed.filter((x) => typeof x === 'string') : [];
+            }
+            catch {
+                return [];
+            }
+        };
+        const build = (name, seen) => {
+            const skill = byName.get(name);
+            if (!skill)
+                return null;
+            const governs = parseArr(skill.governs);
+            const composes = parseArr(skill.composes);
+            const node = {
+                name: skill.name,
+                tier: skill.tier ?? 'atomic',
+                description: skill.description,
+                governs,
+                composes,
+                children: [],
+            };
+            const missing = [];
+            if (!seen.has(name)) {
+                const nextSeen = new Set(seen).add(name);
+                for (const childName of governs) {
+                    const child = build(childName, nextSeen);
+                    if (child)
+                        node.children.push(child);
+                    else
+                        missing.push(childName);
+                }
+            }
+            if (missing.length)
+                node.missing = missing;
+            return node;
+        };
+        if (root) {
+            const node = build(root, new Set());
+            return node ? [node] : [];
+        }
+        // No root → forest of all god-tier apexes (deterministic by name).
+        const gods = all
+            .filter((s) => (s.tier ?? 'atomic') === 'god')
+            .map((s) => s.name)
+            .sort();
+        const forest = [];
+        for (const g of gods) {
+            const node = build(g, new Set());
+            if (node)
+                forest.push(node);
+        }
+        return forest;
+    }
+    updateSkill(name, updates) {
+        const setClauses = [];
+        const values = [];
+        if (updates.description !== undefined) {
+            setClauses.push('description = ?');
+            values.push(updates.description);
+        }
+        if (updates.skill_path !== undefined) {
+            setClauses.push('skill_path = ?');
+            values.push(updates.skill_path);
+        }
+        if (updates.category !== undefined) {
+            setClauses.push('category = ?');
+            values.push(updates.category);
+        }
+        if (updates.is_active !== undefined) {
+            setClauses.push('is_active = ?');
+            values.push(updates.is_active ? 1 : 0);
+        }
+        if (updates.tags !== undefined) {
+            setClauses.push('tags = ?');
+            values.push(updates.tags);
+        }
+        if (updates.version !== undefined) {
+            setClauses.push('version = ?');
+            values.push(updates.version);
+        }
+        if (setClauses.length === 0) {
+            return this.getSkill(name);
+        }
+        setClauses.push('updated_at = datetime(\'now\')');
+        values.push(name);
+        return this.db.prepare(`
+      UPDATE skills SET ${setClauses.join(', ')} WHERE name = ? RETURNING *
+    `).get(...values);
+    }
+    deleteSkill(name) {
+        const result = this.db.prepare('DELETE FROM skills WHERE name = ?').run(name);
+        return result.changes > 0;
+    }
+    deactivateSkill(name) {
+        return this.updateSkill(name, { is_active: false });
+    }
+    activateSkill(name) {
+        return this.updateSkill(name, { is_active: true });
+    }
+    getSkillStats() {
+        const total = this.db.prepare('SELECT COUNT(*) as count FROM skills').get().count;
+        const active = this.db.prepare('SELECT COUNT(*) as count FROM skills WHERE is_active = 1').get().count;
+        const byCategoryRows = this.db.prepare(`
       SELECT category, COUNT(*) as count FROM skills WHERE category IS NOT NULL GROUP BY category
-    `).all(),r={};for(const n of s)r[n.category]=n.count;return{total:t,active:e,byCategory:r}}upsertSpec(t,e,s,r,n=0){return this.db.prepare(`
+    `).all();
+        const byCategory = {};
+        for (const row of byCategoryRows) {
+            byCategory[row.category] = row.count;
+        }
+        return { total, active, byCategory };
+    }
+    // ==================== SPEC-KIT REGISTRY ====================
+    /** Upsert a spec→project link (idempotent by project_id + spec_dir). */
+    upsertSpec(projectId, specDir, title, summary, taskCount = 0) {
+        return this.db.prepare(`
       INSERT INTO specs (project_id, spec_dir, title, summary, task_count)
       VALUES (?, ?, ?, ?, ?)
       ON CONFLICT(project_id, spec_dir) DO UPDATE SET
@@ -188,62 +1069,406 @@ import k from"better-sqlite3";import{existsSync as u,mkdirSync as b,readdirSync
         task_count = excluded.task_count,
         updated_at = datetime('now')
       RETURNING *
-    `).get(t,e,s||null,r||null,n)}getSpec(t,e){return this.db.prepare("SELECT * FROM specs WHERE project_id = ? AND spec_dir = ?").get(t,e)}listSpecs(t){return t!==void 0?this.db.prepare("SELECT * FROM specs WHERE project_id = ? ORDER BY updated_at DESC").all(t):this.db.prepare("SELECT * FROM specs ORDER BY updated_at DESC").all()}findQuestBySpecSignature(t,e){return this.db.prepare(`
+    `).get(projectId, specDir, title || null, summary || null, taskCount);
+    }
+    getSpec(projectId, specDir) {
+        return this.db.prepare('SELECT * FROM specs WHERE project_id = ? AND spec_dir = ?').get(projectId, specDir);
+    }
+    listSpecs(projectId) {
+        if (projectId !== undefined) {
+            return this.db.prepare('SELECT * FROM specs WHERE project_id = ? ORDER BY updated_at DESC').all(projectId);
+        }
+        return this.db.prepare('SELECT * FROM specs ORDER BY updated_at DESC').all();
+    }
+    /**
+     * Find an existing quest for a project carrying a specific spec-task tag
+     * signature. Used by wyrm_spec_register to dedupe (update-not-duplicate) on
+     * re-run. The signature lives in the quest's comma-separated `tags` column.
+     */
+    findQuestBySpecSignature(projectId, signature) {
+        return this.db.prepare(`
       SELECT * FROM quests
       WHERE project_id = ?
         AND (tags = ? OR tags LIKE ? OR tags LIKE ? OR tags LIKE ?)
       LIMIT 1
-    `).get(t,e,`${e},%`,`%,${e}`,`%,${e},%`)}updateQuestFields(t,e){const s=[],r=[];if(e.title!==void 0&&(s.push("title = ?"),r.push(e.title)),e.description!==void 0&&(s.push("description = ?"),r.push(e.description)),e.tags!==void 0&&(s.push("tags = ?"),r.push(e.tags)),s.length===0)return this.db.prepare("SELECT * FROM quests WHERE id = ?").get(t);r.push(t);const n=this.db.prepare(`UPDATE quests SET ${s.join(", ")} WHERE id = ? RETURNING *`).get(...r);return n&&m(this.db,{projectId:n.project_id,kind:"quest",refTable:"quests",refId:t}),n}insertData(t,e,s,r,n){const i=this.resilience.withRetrySync(()=>this.db.prepare(`
+    `).get(projectId, signature, `${signature},%`, `%,${signature}`, `%,${signature},%`);
+    }
+    /** Update a quest's title/description/tags in place (used by spec re-registration). */
+    updateQuestFields(id, fields) {
+        const setClauses = [];
+        const values = [];
+        if (fields.title !== undefined) {
+            setClauses.push('title = ?');
+            values.push(fields.title);
+        }
+        if (fields.description !== undefined) {
+            setClauses.push('description = ?');
+            values.push(fields.description);
+        }
+        if (fields.tags !== undefined) {
+            setClauses.push('tags = ?');
+            values.push(fields.tags);
+        }
+        if (setClauses.length === 0) {
+            return this.db.prepare('SELECT * FROM quests WHERE id = ?').get(id);
+        }
+        values.push(id);
+        const quest = this.db.prepare(`UPDATE quests SET ${setClauses.join(', ')} WHERE id = ? RETURNING *`).get(...values);
+        if (quest)
+            emitEvent(this.db, { projectId: quest.project_id, kind: 'quest', refTable: 'quests', refId: id });
+        return quest;
+    }
+    // ==================== DATA LAKE ====================
+    insertData(projectId, category, key, value, metadata) {
+        const result = this.resilience.withRetrySync(() => this.db.prepare(`
         INSERT INTO data_lake (project_id, category, key, value, metadata)
         VALUES (?, ?, ?, ?, ?)
         RETURNING *
-      `).get(t,e,s,r,n?JSON.stringify(n):null),"insertData");if(!i.success)throw i.error||new Error("Insert data failed");return i.data}batchWrites(t,e){return this.db.transaction(r=>r.map(n=>e(n)))(t)}insertDataBatch(t){const e=this.resilience.generateOperationId("batch_insert"),s=this.BATCH_SIZE;let r=0;this.resilience.createCheckpoint(e,"batch_insert","started",{totalItems:t.length,batchSize:s});const n=this.db.prepare(`
+      `).get(projectId, category, key, value, metadata ? JSON.stringify(metadata) : null), 'insertData');
+        if (!result.success) {
+            throw result.error || new Error('Insert data failed');
+        }
+        return result.data;
+    }
+    /**
+     * v7 F2 (T011): batch N arbitrary writes into ONE better-sqlite3 transaction.
+     *
+     * Cross-process write story — under WAL every transaction takes the single
+     * cross-process write lock; batching N writes into one transaction acquires
+     * it ONCE per batch instead of once per row, so a fleet writer holds the
+     * lock for one short window rather than N tiny contended ones. The whole
+     * batch is atomic: if any `write(item)` throws, better-sqlite3 rolls the
+     * transaction back and NO item persists (the thrown error propagates).
+     *
+     * Why this is a transaction helper and NOT an in-process write queue:
+     * better-sqlite3 is fully synchronous — two writes issued by the SAME
+     * process can never interleave by construction (each statement completes
+     * before the next starts), so an in-process queue would serialize something
+     * that is already serial. The only real contention is CROSS-process, which
+     * is handled by busy_timeout=5000 (constructor above) plus the structured
+     * WYRM_BUSY dispatcher body (sqlite-busy.ts).
+     *
+     * NOTE: `write` runs inside the transaction — keep it to synchronous DB
+     * work (no awaits; better-sqlite3 transactions cannot span async gaps).
+     */
+    batchWrites(items, write) {
+        const tx = this.db.transaction((batch) => batch.map((item) => write(item)));
+        return tx(items);
+    }
+    /**
+     * Batch insert with resilience - uses checkpointing for large batches.
+     *
+     * Contract: returns the inserted count ONLY when every chunk committed.
+     * A failed chunk must surface as a structured retryable error, not a
+     * success-shaped partial count — each chunk commits through one batchWrites
+     * transaction, so a failed chunk rolled back atomically and rethrowing lets
+     * the dispatcher map SQLITE_BUSY to the structured WYRM_BUSY retry body
+     * exactly like every sibling write path (insertData, createSession, ...).
+     * Cross-chunk progress rides on the thrown error as `inserted` so a caller
+     * batching more than one chunk (> BATCH_SIZE items) can surface how many
+     * rows landed in the chunks that DID commit.
+     */
+    insertDataBatch(data) {
+        const operationId = this.resilience.generateOperationId('batch_insert');
+        const batchSize = this.BATCH_SIZE;
+        let totalInserted = 0;
+        // Checkpoint for recovery
+        this.resilience.createCheckpoint(operationId, 'batch_insert', 'started', {
+            totalItems: data.length,
+            batchSize,
+        });
+        const insert = this.db.prepare(`
       INSERT INTO data_lake (project_id, category, key, value, metadata)
       VALUES (?, ?, ?, ?, ?)
-    `);try{for(let i=0;i<t.length;i+=s){const a=t.slice(i,i+s),o=Math.floor(i/s)+1;this.resilience.updateCheckpoint(e,`batch_${o}`,{processed:i,currentBatch:o});const c=this.resilience.withRetrySync(()=>this.batchWrites(a,l=>(n.run(l.projectId,l.category,l.key,l.value,l.metadata?JSON.stringify(l.metadata):null),1)).length,`batch_insert_${o}`,{maxAttempts:3});if(!c.success){this.logger.error("Batch insert failed",{batch:o,processed:r,error:c.error?.message}),this.resilience.updateCheckpoint(e,"partial_failure",{inserted:r,failedAt:i});const l=c.error??new Error(`Batch insert failed at chunk ${o}`);throw l.inserted=r,l}r+=c.data}return this.resilience.completeCheckpoint(e),r}catch(i){throw i!==null&&typeof i=="object"&&"inserted"in i||(this.logger.error("Batch insert exception",{inserted:r,error:i.message}),this.resilience.updateCheckpoint(e,"exception",{inserted:r,error:i.message}),i!==null&&typeof i=="object"&&(i.inserted=r)),i}}queryData(t,e,s=100,r=0){return e?this.db.prepare(`
+    `);
+        try {
+            // Process in batches for large datasets
+            for (let i = 0; i < data.length; i += batchSize) {
+                const batch = data.slice(i, i + batchSize);
+                const batchNum = Math.floor(i / batchSize) + 1;
+                this.resilience.updateCheckpoint(operationId, `batch_${batchNum}`, {
+                    processed: i,
+                    currentBatch: batchNum,
+                });
+                // One transaction per chunk via batchWrites (v7 F2 review fix: this
+                // IS the production call site of the T011 helper — the write lock is
+                // taken once per chunk instead of once per row, the cross-process
+                // story sqlite-busy.ts documents as mitigation (b)).
+                const result = this.resilience.withRetrySync(() => this.batchWrites(batch, (item) => {
+                    insert.run(item.projectId, item.category, item.key, item.value, item.metadata ? JSON.stringify(item.metadata) : null);
+                    return 1;
+                }).length, `batch_insert_${batchNum}`, { maxAttempts: 3 });
+                if (!result.success) {
+                    this.logger.error('Batch insert failed', {
+                        batch: batchNum,
+                        processed: totalInserted,
+                        error: result.error?.message,
+                    });
+                    this.resilience.updateCheckpoint(operationId, 'partial_failure', {
+                        inserted: totalInserted,
+                        failedAt: i,
+                    });
+                    // A failed chunk must surface as a structured retryable error, not
+                    // a success-shaped partial count: the chunk transaction rolled back
+                    // atomically (nothing partial within it), and rethrowing with the
+                    // SQLite code intact is what lets the dispatcher emit the WYRM_BUSY
+                    // retry body. Cross-chunk progress rides on the error (see doc).
+                    const error = result.error ?? new Error(`Batch insert failed at chunk ${batchNum}`);
+                    error.inserted = totalInserted;
+                    throw error;
+                }
+                totalInserted += result.data;
+            }
+            this.resilience.completeCheckpoint(operationId);
+            return totalInserted;
+        }
+        catch (error) {
+            // Same invariant as the chunk-failure branch: swallowing here would
+            // re-shape the failure into a success-looking count. A chunk failure
+            // already logged + checkpointed before throwing (it carries the
+            // cross-chunk progress); anything else is an unexpected exception —
+            // record it, attach progress, and keep it loud either way.
+            const alreadyHandled = error !== null && typeof error === 'object' && 'inserted' in error;
+            if (!alreadyHandled) {
+                this.logger.error('Batch insert exception', {
+                    inserted: totalInserted,
+                    error: error.message,
+                });
+                this.resilience.updateCheckpoint(operationId, 'exception', {
+                    inserted: totalInserted,
+                    error: error.message,
+                });
+                if (error !== null && typeof error === 'object') {
+                    error.inserted = totalInserted;
+                }
+            }
+            throw error;
+        }
+    }
+    queryData(projectId, category, limit = 100, offset = 0) {
+        if (category) {
+            return this.db.prepare(`
         SELECT * FROM data_lake 
         WHERE project_id = ? AND category = ?
         ORDER BY created_at DESC
         LIMIT ? OFFSET ?
-      `).all(t,e,s,r):this.db.prepare(`
+      `).all(projectId, category, limit, offset);
+        }
+        return this.db.prepare(`
       SELECT * FROM data_lake 
       WHERE project_id = ?
       ORDER BY created_at DESC
       LIMIT ? OFFSET ?
-    `).all(t,s,r)}searchData(t,e){const s=h(t);if(!s)return[];try{return e?this.db.prepare(`
+    `).all(projectId, limit, offset);
+    }
+    searchData(query, projectId) {
+        const match = buildFtsMatchQuery(query);
+        if (!match)
+            return [];
+        try {
+            if (projectId) {
+                return this.db.prepare(`
         SELECT d.* FROM data_lake d
         JOIN data_lake_fts fts ON d.id = fts.rowid
         WHERE data_lake_fts MATCH ? AND d.project_id = ?
         ORDER BY bm25(data_lake_fts), d.created_at DESC
         LIMIT 100
-      `).all(s,e):this.db.prepare(`
+      `).all(match, projectId);
+            }
+            return this.db.prepare(`
       SELECT d.* FROM data_lake d
       JOIN data_lake_fts fts ON d.id = fts.rowid
       WHERE data_lake_fts MATCH ?
       ORDER BY bm25(data_lake_fts), d.created_at DESC
       LIMIT 100
-    `).all(s)}catch{return[]}}searchArtifacts(t,e){const s=h(t);if(!s)return[];try{return e?this.db.prepare(`
+    `).all(match);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Lexical (FTS5) search over ACTIVE memory artifacts — the keyword peer of
+     * the vector channel wyrm_search already fuses. Mirrors searchData (OR-
+     * semantics + porter stemming via buildFtsMatchQuery, bm25 ranking). Only
+     * surfaces live artifacts (needs_review = 0, not superseded), matching the
+     * recall contract. Fixes the gap where wyrm_search found artifacts
+     * semantically but never lexically.
+     */
+    searchArtifacts(query, projectId) {
+        const match = buildFtsMatchQuery(query);
+        if (!match)
+            return [];
+        try {
+            if (projectId) {
+                return this.db.prepare(`
           SELECT a.* FROM memory_artifacts a
           JOIN memory_artifacts_fts fts ON a.id = fts.rowid
           WHERE memory_artifacts_fts MATCH ? AND a.project_id = ?
             AND a.needs_review = 0 AND a.supersedes_id IS NULL
           ORDER BY bm25(memory_artifacts_fts), a.confidence DESC
           LIMIT 100
-        `).all(s,e):this.db.prepare(`
+        `).all(match, projectId);
+            }
+            return this.db.prepare(`
         SELECT a.* FROM memory_artifacts a
         JOIN memory_artifacts_fts fts ON a.id = fts.rowid
         WHERE memory_artifacts_fts MATCH ?
           AND a.needs_review = 0 AND a.supersedes_id IS NULL
         ORDER BY bm25(memory_artifacts_fts), a.confidence DESC
         LIMIT 100
-      `).all(s)}catch{return[]}}getDataCategories(t){return this.db.prepare(`
+      `).all(match);
+        }
+        catch {
+            return [];
+        }
+    }
+    getDataCategories(projectId) {
+        return this.db.prepare(`
       SELECT category, COUNT(*) as count 
       FROM data_lake 
       WHERE project_id = ?
       GROUP BY category
       ORDER BY count DESC
-    `).all(t)}deleteDataCategory(t,e){return this.db.prepare(`
+    `).all(projectId);
+    }
+    deleteDataCategory(projectId, category) {
+        const result = this.db.prepare(`
       DELETE FROM data_lake WHERE project_id = ? AND category = ?
-    `).run(t,e).changes}*streamSessions(t){const e=this.db.prepare(`
+    `).run(projectId, category);
+        return result.changes;
+    }
+    // ==================== STREAMING ====================
+    *streamSessions(projectId) {
+        const stmt = this.db.prepare(`
       SELECT * FROM sessions WHERE project_id = ? ORDER BY date DESC
-    `);for(const s of e.iterate(t))yield s}*streamData(t,e){const s=e?this.db.prepare("SELECT * FROM data_lake WHERE project_id = ? AND category = ?"):this.db.prepare("SELECT * FROM data_lake WHERE project_id = ?"),r=e?[t,e]:[t];for(const n of s.iterate(...r))yield n}getStats(){const t=this.db.prepare("SELECT COUNT(*) as count FROM projects").get(),e=this.db.prepare("SELECT COUNT(*) as count FROM sessions").get(),s=this.db.prepare("SELECT COUNT(*) as count FROM quests").get(),r=this.db.prepare("SELECT COUNT(*) as count FROM memory_artifacts").get(),n=this.db.prepare("SELECT COUNT(*) as count FROM data_lake").get(),i=this.db.prepare("SELECT COALESCE(SUM(tokens_estimate), 0) as total FROM sessions WHERE is_archived = 0").get(),a=this.db.pragma("page_count",{simple:!0}),o=this.db.pragma("page_size",{simple:!0}),c=a*o/(1024*1024);return{projects:t.count,sessions:e.count,quests:s.count,artifacts:r.count,dataPoints:n.count,totalTokens:i.total,dbSize:`${c.toFixed(2)} MB`}}getProjectStats(t){const e=this.db.prepare("SELECT COUNT(*) as count FROM sessions WHERE project_id = ?").get(t),s=this.db.prepare("SELECT COUNT(*) as count FROM quests WHERE project_id = ? AND status IN ('pending', 'in_progress')").get(t),r=this.db.prepare("SELECT COUNT(*) as count FROM quests WHERE project_id = ? AND status = 'completed'").get(t),n=this.db.prepare("SELECT COUNT(*) as count FROM data_lake WHERE project_id = ?").get(t),i=this.db.prepare("SELECT COALESCE(SUM(tokens_estimate), 0) as total FROM sessions WHERE project_id = ? AND is_archived = 0").get(t);return{sessions:e.count,quests:{pending:s.count,completed:r.count},dataPoints:n.count,tokens:i.total}}estimateTokens(t){return Math.ceil(t.length/4)}vacuum(){this.db.exec("VACUUM")}checkpoint(){this.db.pragma("wal_checkpoint(TRUNCATE)")}getResilienceStatus(){const t=this.resilience.getCircuitStatus(),e=this.resilience.getIncompleteOperations();return{circuitState:t.state,failures:t.failures,incompleteOps:e.length}}resetCircuitBreaker(){this.resilience.resetCircuit()}close(){try{this.checkpoint(),this.logger.info("Database checkpoint completed")}catch(t){this.logger.error("Checkpoint failed during close",{error:t.message})}try{this.db.close(),this.logger.info("Database closed successfully")}catch(t){this.logger.error("Database close failed",{error:t.message})}}checkIntegrity(){const t=[];try{const e=this.db.pragma("integrity_check",{simple:!0});e!=="ok"&&t.push(`Integrity check failed: ${e}`)}catch(e){t.push(`Integrity check error: ${e.message}`)}try{const e=this.db.pragma("foreign_key_check");e.length>0&&t.push(`Foreign key violations: ${e.length}`)}catch(e){t.push(`FK check error: ${e.message}`)}return{ok:t.length===0,issues:t}}}export{ce as WyrmDB,ae as resolveDbPath};
+    `);
+        for (const row of stmt.iterate(projectId)) {
+            yield row;
+        }
+    }
+    *streamData(projectId, category) {
+        const stmt = category
+            ? this.db.prepare('SELECT * FROM data_lake WHERE project_id = ? AND category = ?')
+            : this.db.prepare('SELECT * FROM data_lake WHERE project_id = ?');
+        const params = category ? [projectId, category] : [projectId];
+        for (const row of stmt.iterate(...params)) {
+            yield row;
+        }
+    }
+    // ==================== STATS & UTILITIES ====================
+    getStats() {
+        const projects = this.db.prepare('SELECT COUNT(*) as count FROM projects').get();
+        const sessions = this.db.prepare('SELECT COUNT(*) as count FROM sessions').get();
+        const quests = this.db.prepare('SELECT COUNT(*) as count FROM quests').get();
+        const artifacts = this.db.prepare('SELECT COUNT(*) as count FROM memory_artifacts').get();
+        const dataPoints = this.db.prepare('SELECT COUNT(*) as count FROM data_lake').get();
+        const tokens = this.db.prepare('SELECT COALESCE(SUM(tokens_estimate), 0) as total FROM sessions WHERE is_archived = 0').get();
+        const pageCount = this.db.pragma('page_count', { simple: true });
+        const pageSize = this.db.pragma('page_size', { simple: true });
+        const dbSize = (pageCount * pageSize) / (1024 * 1024);
+        return {
+            projects: projects.count,
+            sessions: sessions.count,
+            quests: quests.count,
+            artifacts: artifacts.count,
+            dataPoints: dataPoints.count,
+            totalTokens: tokens.total,
+            dbSize: `${dbSize.toFixed(2)} MB`
+        };
+    }
+    getProjectStats(projectId) {
+        const sessions = this.db.prepare('SELECT COUNT(*) as count FROM sessions WHERE project_id = ?').get(projectId);
+        const pendingQuests = this.db.prepare(`SELECT COUNT(*) as count FROM quests WHERE project_id = ? AND status IN ('pending', 'in_progress')`).get(projectId);
+        const completedQuests = this.db.prepare(`SELECT COUNT(*) as count FROM quests WHERE project_id = ? AND status = 'completed'`).get(projectId);
+        const dataPoints = this.db.prepare('SELECT COUNT(*) as count FROM data_lake WHERE project_id = ?').get(projectId);
+        const tokens = this.db.prepare('SELECT COALESCE(SUM(tokens_estimate), 0) as total FROM sessions WHERE project_id = ? AND is_archived = 0').get(projectId);
+        return {
+            sessions: sessions.count,
+            quests: { pending: pendingQuests.count, completed: completedQuests.count },
+            dataPoints: dataPoints.count,
+            tokens: tokens.total
+        };
+    }
+    estimateTokens(text) {
+        // Rough estimate: ~4 chars per token
+        return Math.ceil(text.length / 4);
+    }
+    vacuum() {
+        this.db.exec('VACUUM');
+    }
+    checkpoint() {
+        this.db.pragma('wal_checkpoint(TRUNCATE)');
+    }
+    /**
+     * Get resilience status for monitoring
+     */
+    getResilienceStatus() {
+        const circuit = this.resilience.getCircuitStatus();
+        const incomplete = this.resilience.getIncompleteOperations();
+        return {
+            circuitState: circuit.state,
+            failures: circuit.failures,
+            incompleteOps: incomplete.length,
+        };
+    }
+    /**
+     * Reset circuit breaker (manual recovery)
+     */
+    resetCircuitBreaker() {
+        this.resilience.resetCircuit();
+    }
+    /**
+     * Safe close with WAL checkpoint and cleanup
+     */
+    close() {
+        try {
+            // Checkpoint WAL to ensure all data is persisted
+            this.checkpoint();
+            this.logger.info('Database checkpoint completed');
+        }
+        catch (error) {
+            this.logger.error('Checkpoint failed during close', {
+                error: error.message,
+            });
+        }
+        try {
+            this.db.close();
+            this.logger.info('Database closed successfully');
+        }
+        catch (error) {
+            this.logger.error('Database close failed', {
+                error: error.message,
+            });
+        }
+    }
+    /**
+     * Check database integrity
+     */
+    checkIntegrity() {
+        const issues = [];
+        try {
+            const result = this.db.pragma('integrity_check', { simple: true });
+            if (result !== 'ok') {
+                issues.push(`Integrity check failed: ${result}`);
+            }
+        }
+        catch (error) {
+            issues.push(`Integrity check error: ${error.message}`);
+        }
+        try {
+            const fk = this.db.pragma('foreign_key_check');
+            if (fk.length > 0) {
+                issues.push(`Foreign key violations: ${fk.length}`);
+            }
+        }
+        catch (error) {
+            issues.push(`FK check error: ${error.message}`);
+        }
+        return {
+            ok: issues.length === 0,
+            issues,
+        };
+    }
+}
+//# sourceMappingURL=database.js.map