agentic-qe 3.14.5 → 3.14.7

package/dist/integrations/vibium/runtime.js

@@ -0,0 +1,94 @@
+/** Resolve the opt-in Vibium runtime for both local and global AQE installs. */
+import { createRequire } from 'node:module';
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+export const VIBIUM_SETUP = 'aqe init --browser-engine (or npm install vibium@^26.8.21)';
+const requireFromHere = createRequire(import.meta.url);
+/**
+ * How to run npm without a shell. On Windows `npm` is an `npm.cmd` shim, which
+ * execFile cannot start without `shell: true` (EINVAL/ENOENT since the
+ * CVE-2024-27980 fix), so run the npm CLI bundled next to node.exe instead.
+ * Falls back to plain `npm` when that layout is absent.
+ */
+export function npmInvocation(platform = process.platform, execPath = process.execPath, exists = existsSync) {
+    if (platform === 'win32') {
+        const npmCli = join(dirname(execPath), 'node_modules', 'npm', 'bin', 'npm-cli.js');
+        if (exists(npmCli))
+            return [execPath, [npmCli]];
+    }
+    return ['npm', []];
+}
+/** Never install or download anything while probing availability. */
+function resolveRuntime() {
+    try {
+        return requireFromHere.resolve('vibium');
+    }
+    catch {
+        try {
+            return createRequire(join(process.cwd(), 'package.json')).resolve('vibium');
+        }
+        catch { /* No project-local opt-in runtime. Try global setup below. */ }
+        // A global CLI installation is not on Node's normal module search path.
+        // npm root is read-only and honors the same npm prefix as explicit setup.
+        const [npmBin, npmPrefixArgs] = npmInvocation();
+        const root = execFileSync(npmBin, [...npmPrefixArgs, 'root', '-g'], {
+            encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'pipe'],
+        }).trim();
+        return requireFromHere.resolve(join(root, 'vibium'));
+    }
+}
+/**
+ * Accept the modern API from the namespace itself or from its `default`
+ * export. CJS interop and bundler createRequire shims expose the package
+ * object only as `default`, so checking the namespace alone rejects a
+ * correctly installed runtime.
+ */
+function selectBrowserApi(loaded) {
+    if (typeof loaded?.browser?.start === 'function')
+        return loaded;
+    if (typeof loaded?.default?.browser?.start === 'function')
+        return loaded.default;
+    return null;
+}
+export async function loadVibium() {
+    let loaded;
+    try {
+        loaded = await import('vibium');
+    }
+    catch (error) {
+        // Only a missing local package permits global resolution. A broken local
+        // installation must not be silently replaced by an unrelated runtime.
+        if (error.code !== 'ERR_MODULE_NOT_FOUND' &&
+            error.code !== 'MODULE_NOT_FOUND')
+            throw error;
+        let entry;
+        try {
+            entry = resolveRuntime();
+        }
+        catch (cause) {
+            throw new Error(`Vibium is not installed; run ${VIBIUM_SETUP}`, { cause });
+        }
+        loaded = requireFromHere(entry);
+    }
+    const runtime = selectBrowserApi(loaded);
+    if (!runtime) {
+        throw new Error('Unsupported Vibium API: the installed package exposes no browser.start() ' +
+            `(neither as a named nor a default export); run ${VIBIUM_SETUP}`);
+    }
+    return runtime;
+}
+/** Check the payload belonging to the resolved library, not a different PATH CLI. */
+export function isVibiumReady() {
+    try {
+        const cli = join(dirname(resolveRuntime()), '..', 'bin', 'cli.js');
+        execFileSync(process.execPath, [cli, 'is-installed'], {
+            timeout: 5000, stdio: 'ignore',
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=runtime.js.map

package/dist/kernel/kernel.js

@@ -7,6 +7,7 @@ import { ALL_DOMAINS } from '../shared/types/index.js';
 import { InMemoryEventBus } from './event-bus.js';
 import { DefaultAgentCoordinator } from './agent-coordinator.js';
 import { DefaultPluginLoader } from './plugin-loader.js';
+import { formatErrorForLog } from '../logging/redaction.js';
 import { InMemoryBackend } from './memory-backend.js';
 import { createKernelMemoryBackend } from './hybrid-backend.js';
 import { SemanticAntiDriftMiddleware, ToolCallSignatureTracker } from './anti-drift-middleware.js';
@@ -488,7 +489,7 @@ export class QEKernelImpl {
                 plugin = await this._plugins.load(domain);
             }
             catch (error) {
-                console.error(`[QEKernel] Failed to lazy load domain ${domain}:`, error);
+                console.error(`[QEKernel] Failed to lazy load domain ${domain}:`, formatErrorForLog(error));
                 return undefined;
             }
         }
@@ -511,7 +512,7 @@ export class QEKernelImpl {
             return true;
         }
         catch (error) {
-            console.error(`[QEKernel] Failed to load domain ${domain}:`, error);
+            console.error(`[QEKernel] Failed to load domain ${domain}:`, formatErrorForLog(error));
             return false;
         }
     }

package/dist/kernel/pattern-fts-self-heal.d.ts

@@ -0,0 +1,63 @@
+/**
+ * qe_patterns FTS5 self-heal (runs on every open, not gated on schema version)
+ *
+ * `qe_patterns_fts` is an FTS5 *external-content* table: it stores only the
+ * inverted index, and the three AFTER INSERT/UPDATE/DELETE triggers on
+ * qe_patterns are the ONLY thing keeping it in sync. Migration v9 creates them
+ * once (`currentVersion < 9`), so a database whose triggers were lost later
+ * (older code, a `.recover`, a copy/restore, a manual drop...) never heals:
+ * new patterns are invisible to keyword search and deleted ones linger as
+ * stale entries that skew BM25. Since hybrid FTS5+vector retrieval (#780/#796)
+ * keyword search is part of production ranking, so drift silently degrades
+ * retrieval and anything that locates a pattern through FTS.
+ *
+ * This module detects that state cheaply and repairs it idempotently:
+ *   1. qe_patterns exists but qe_patterns_fts doesn't  -> create the table
+ *   2. any sync trigger missing                         -> recreate it (shared DDL)
+ *   3. a sync trigger whose body differs from the shared DDL -> drop + recreate
+ *      (CREATE TRIGGER IF NOT EXISTS never replaces a same-named trigger)
+ *   4. any of the above OR index rowids != content rowids -> FTS5 'rebuild'
+ *
+ * Detection is read-only (counts + one anti-join on the docsize PK); the write
+ * transaction (BEGIN IMMEDIATE) is taken only when a repair is needed. It never
+ * throws: failures are logged and the caller continues (FTS search already
+ * degrades to vector-only). Read-only connections are skipped entirely.
+ *
+ * The 'rebuild' command reconstructs the index from the content table and
+ * never modifies qe_patterns rows.
+ */
+import type { Database as DatabaseType } from 'better-sqlite3';
+/** Names of the triggers that keep qe_patterns_fts in sync. */
+export declare const QE_PATTERNS_FTS_TRIGGERS: string[];
+export type PatternFtsHealStatus = 'healthy' | 'healed' | 'no-patterns' | 'readonly' | 'failed';
+export interface PatternFtsHealResult {
+    status: PatternFtsHealStatus;
+    /** True when qe_patterns_fts had to be created. */
+    createdTable: boolean;
+    /** Triggers that were missing and have been recreated. */
+    recreatedTriggers: string[];
+    /** Triggers whose body differed from the shared DDL and have been replaced. */
+    replacedTriggers: string[];
+    /** True when the FTS5 'rebuild' command ran. */
+    rebuilt: boolean;
+    /** qe_patterns row count observed before repair (-1 if unknown). */
+    patternsBefore: number;
+    /** Indexed document count before repair (-1 if unknown / no table). */
+    indexedBefore: number;
+    /** Indexed document count after repair (-1 if not repaired). */
+    indexedAfter: number;
+    error?: string;
+}
+export interface PatternFtsHealOptions {
+    /** Log sink for the single heal/failure line. Defaults to console.warn. */
+    log?: (message: string) => void;
+    /** Prefix for the log line, e.g. "[UnifiedMemory]". */
+    logPrefix?: string;
+}
+/**
+ * Ensure qe_patterns_fts exists, has its three sync triggers, and indexes
+ * exactly the rows of qe_patterns. Idempotent and silent when healthy; logs
+ * one line when it repairs something; never throws.
+ */
+export declare function ensurePatternFtsInSync(db: DatabaseType, options?: PatternFtsHealOptions): PatternFtsHealResult;
+//# sourceMappingURL=pattern-fts-self-heal.d.ts.map

package/dist/kernel/pattern-fts-self-heal.js

@@ -0,0 +1,193 @@
+/**
+ * qe_patterns FTS5 self-heal (runs on every open, not gated on schema version)
+ *
+ * `qe_patterns_fts` is an FTS5 *external-content* table: it stores only the
+ * inverted index, and the three AFTER INSERT/UPDATE/DELETE triggers on
+ * qe_patterns are the ONLY thing keeping it in sync. Migration v9 creates them
+ * once (`currentVersion < 9`), so a database whose triggers were lost later
+ * (older code, a `.recover`, a copy/restore, a manual drop...) never heals:
+ * new patterns are invisible to keyword search and deleted ones linger as
+ * stale entries that skew BM25. Since hybrid FTS5+vector retrieval (#780/#796)
+ * keyword search is part of production ranking, so drift silently degrades
+ * retrieval and anything that locates a pattern through FTS.
+ *
+ * This module detects that state cheaply and repairs it idempotently:
+ *   1. qe_patterns exists but qe_patterns_fts doesn't  -> create the table
+ *   2. any sync trigger missing                         -> recreate it (shared DDL)
+ *   3. a sync trigger whose body differs from the shared DDL -> drop + recreate
+ *      (CREATE TRIGGER IF NOT EXISTS never replaces a same-named trigger)
+ *   4. any of the above OR index rowids != content rowids -> FTS5 'rebuild'
+ *
+ * Detection is read-only (counts + one anti-join on the docsize PK); the write
+ * transaction (BEGIN IMMEDIATE) is taken only when a repair is needed. It never
+ * throws: failures are logged and the caller continues (FTS search already
+ * degrades to vector-only). Read-only connections are skipped entirely.
+ *
+ * The 'rebuild' command reconstructs the index from the content table and
+ * never modifies qe_patterns rows.
+ */
+import { toErrorMessage } from '../shared/error-utils.js';
+import { QE_PATTERNS_FTS_TABLE_DDL, QE_PATTERNS_FTS_TRIGGER_DDL, } from './unified-memory-schemas.js';
+/** Names of the triggers that keep qe_patterns_fts in sync. */
+export const QE_PATTERNS_FTS_TRIGGERS = Object.keys(QE_PATTERNS_FTS_TRIGGER_DDL);
+function objectExists(db, type, name) {
+    return db.prepare('SELECT 1 FROM sqlite_master WHERE type = ? AND name = ?').get(type, name) !== undefined;
+}
+/**
+ * Canonical form of a CREATE TRIGGER statement for comparison: sqlite_master
+ * stores the text as written minus IF NOT EXISTS, and older code paths used
+ * different indentation, so collapse whitespace and drop the clause/semicolon.
+ */
+function normalizeTriggerSql(sql) {
+    return sql
+        .replace(/\s+/g, ' ')
+        .trim()
+        .replace(/^CREATE TRIGGER IF NOT EXISTS /i, 'CREATE TRIGGER ')
+        .replace(/ ?;$/, '')
+        .toLowerCase();
+}
+const CANONICAL_TRIGGER_SQL = Object.freeze(Object.fromEntries(Object.entries(QE_PATTERNS_FTS_TRIGGER_DDL).map(([name, ddl]) => [name, normalizeTriggerSql(ddl)])));
+function count(db, sql) {
+    const row = db.prepare(sql).get();
+    return row?.n ?? 0;
+}
+/**
+ * Read-only inspection. `qe_patterns_fts_docsize` holds exactly one row per
+ * indexed document (id = content rowid; columnsize defaults to on), so
+ * comparing it with qe_patterns detects both unindexed and stale entries
+ * without scanning the index itself. `SELECT count(*) FROM qe_patterns_fts`
+ * is NOT usable: for an external-content table it reads the content table.
+ */
+function inspect(db) {
+    const hasTable = objectExists(db, 'table', 'qe_patterns_fts');
+    const hasDocsize = hasTable && objectExists(db, 'table', 'qe_patterns_fts_docsize');
+    const missingTriggers = [];
+    const mismatchedTriggers = [];
+    const triggerSql = db.prepare("SELECT sql FROM sqlite_master WHERE type = 'trigger' AND name = ?");
+    for (const name of QE_PATTERNS_FTS_TRIGGERS) {
+        const row = triggerSql.get(name);
+        if (row === undefined)
+            missingTriggers.push(name);
+        else if (normalizeTriggerSql(row.sql ?? '') !== CANONICAL_TRIGGER_SQL[name])
+            mismatchedTriggers.push(name);
+    }
+    const patterns = count(db, 'SELECT count(*) AS n FROM qe_patterns');
+    const indexed = hasDocsize ? count(db, 'SELECT count(*) AS n FROM qe_patterns_fts_docsize') : -1;
+    // Equal counts + every content rowid indexed => identical rowid sets (both
+    // sides are unique), so one anti-join over the docsize PK suffices.
+    const unindexed = hasDocsize && indexed === patterns
+        ? count(db, `SELECT count(*) AS n FROM qe_patterns p
+                 WHERE NOT EXISTS (SELECT 1 FROM qe_patterns_fts_docsize d WHERE d.id = p.rowid)`)
+        : 0;
+    return { hasTable, hasDocsize, missingTriggers, mismatchedTriggers, patterns, indexed, unindexed };
+}
+function needsRepair(s) {
+    if (!s.hasTable || s.missingTriggers.length > 0 || s.mismatchedTriggers.length > 0)
+        return true;
+    // Without a docsize table (non-default FTS options) drift can't be measured
+    // cheaply; trust the triggers rather than rebuilding on every open.
+    if (!s.hasDocsize)
+        return false;
+    return s.indexed !== s.patterns || s.unindexed > 0;
+}
+function isReadOnly(db) {
+    if (db.readonly)
+        return true;
+    try {
+        return Number(db.pragma('query_only', { simple: true })) === 1;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Ensure qe_patterns_fts exists, has its three sync triggers, and indexes
+ * exactly the rows of qe_patterns. Idempotent and silent when healthy; logs
+ * one line when it repairs something; never throws.
+ */
+export function ensurePatternFtsInSync(db, options = {}) {
+    const log = options.log ?? ((m) => console.warn(m));
+    const prefix = options.logPrefix ?? '[PatternFTS]';
+    const result = {
+        status: 'healthy',
+        createdTable: false,
+        recreatedTriggers: [],
+        replacedTriggers: [],
+        rebuilt: false,
+        patternsBefore: -1,
+        indexedBefore: -1,
+        indexedAfter: -1,
+    };
+    try {
+        if (!objectExists(db, 'table', 'qe_patterns')) {
+            result.status = 'no-patterns';
+            return result;
+        }
+        if (isReadOnly(db)) {
+            result.status = 'readonly';
+            return result;
+        }
+        const before = inspect(db);
+        result.patternsBefore = before.patterns;
+        result.indexedBefore = before.indexed;
+        if (!needsRepair(before))
+            return result;
+        // Re-inspect inside BEGIN IMMEDIATE so a concurrent opener that already
+        // healed (or is mid-write) is observed under the write lock. Results are
+        // only published after COMMIT succeeds: a failed commit rolls everything
+        // back and must not be reported as a repair.
+        const repaired = db.transaction(() => {
+            const s = inspect(db);
+            if (!needsRepair(s))
+                return null;
+            if (!s.hasTable)
+                db.exec(QE_PATTERNS_FTS_TABLE_DDL);
+            for (const name of s.missingTriggers)
+                db.exec(QE_PATTERNS_FTS_TRIGGER_DDL[name]);
+            for (const name of s.mismatchedTriggers) {
+                db.exec(`DROP TRIGGER IF EXISTS ${name}`);
+                db.exec(QE_PATTERNS_FTS_TRIGGER_DDL[name]);
+            }
+            // Rebuild from the content table: clears stale entries and indexes rows
+            // inserted/updated while triggers were absent. Never touches qe_patterns.
+            db.exec("INSERT INTO qe_patterns_fts(qe_patterns_fts) VALUES('rebuild')");
+            return { s, indexedAfter: count(db, 'SELECT count(*) AS n FROM qe_patterns_fts_docsize') };
+        }).immediate();
+        if (repaired) {
+            const { s } = repaired;
+            result.createdTable = !s.hasTable;
+            result.recreatedTriggers = [...s.missingTriggers];
+            result.replacedTriggers = [...s.mismatchedTriggers];
+            result.patternsBefore = s.patterns;
+            result.indexedBefore = s.indexed;
+            result.indexedAfter = repaired.indexedAfter;
+            result.rebuilt = true;
+        }
+        if (result.rebuilt) {
+            result.status = 'healed';
+            const parts = [];
+            if (result.createdTable)
+                parts.push('created qe_patterns_fts');
+            if (result.recreatedTriggers.length > 0) {
+                parts.push(`recreated triggers [${result.recreatedTriggers.join(', ')}]`);
+            }
+            if (result.replacedTriggers.length > 0) {
+                parts.push(`replaced triggers [${result.replacedTriggers.join(', ')}]`);
+            }
+            const indexedBefore = result.indexedBefore < 0 ? 'n/a' : String(result.indexedBefore);
+            parts.push(`rebuilt index (indexed ${indexedBefore} -> ${result.indexedAfter}, qe_patterns ${result.patternsBefore})`);
+            log(`${prefix} Healed qe_patterns FTS5 index: ${parts.join('; ')}`);
+        }
+        return result;
+    }
+    catch (error) {
+        result.status = 'failed';
+        result.error = toErrorMessage(error);
+        try {
+            log(`${prefix} qe_patterns FTS5 self-heal skipped: ${result.error} (keyword search may be degraded; vector search unaffected)`);
+        }
+        catch { /* logging must never break open */ }
+        return result;
+    }
+}
+//# sourceMappingURL=pattern-fts-self-heal.js.map

package/dist/kernel/process-lifecycle.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Agentic QE v3 - Process lifecycle ownership (#801)
+ *
+ * A long-running entry point (the MCP server) owns process shutdown: before it
+ * exits it must drain in-flight work and release native handles. The shared
+ * patterns RVF adapter, for example, holds a `patterns.rvf.lock` marker that
+ * only its own close() removes.
+ *
+ * Module-level signal handlers elsewhere (the kernel stores, the CLI wrapper)
+ * used to call `process.exit(0)` synchronously. Node runs signal listeners one
+ * after another in the same tick, so that exit pre-empted the owner's async
+ * graceful shutdown and leaked the marker. Those handlers now route the
+ * request to the claimed owner and do not exit themselves.
+ *
+ * With no owner claimed (every non-MCP CLI command), nothing changes and
+ * callers keep their own exit behaviour.
+ *
+ * The owner lives on `globalThis` under a registry symbol because `aqe mcp`
+ * loads the MCP bundle into the CLI bundle's process. Each bundle has its own
+ * copy of this module, and both copies must see the same owner.
+ */
+export interface ProcessLifecycleOwner {
+    /** Diagnostic name, e.g. `mcp`. */
+    readonly name: string;
+    /**
+     * Start the owner's graceful shutdown. Must be idempotent, must not throw,
+     * and must eventually exit the process (e.g. guarded by a watchdog). Before
+     * exiting, on every path, it must call `closeRegisteredStores()`.
+     */
+    shutdown(reason: string): void;
+}
+/**
+ * Register a synchronous, idempotent close for a process-wide store (the
+ * kernel's unified memory/persistence singletons). A claimed owner closes
+ * every registered store at the end of its shutdown, so stores are closed on
+ * every termination path, not only the signal ones. Returns an unregister
+ * function. Shared across bundle copies through the registry symbol.
+ */
+export declare function registerStoreCloser(close: () => void): () => void;
+/**
+ * Close every registered store, most recently registered first (a facade is
+ * registered after the store it wraps, so it closes first). Synchronous so it
+ * also works from a process 'exit' listener; never throws. Closers must be
+ * idempotent: this may run from both the shutdown and an exit backstop.
+ */
+export declare function closeRegisteredStores(): void;
+/** Make `owner` responsible for every graceful shutdown in this process. */
+export declare function claimProcessLifecycle(owner: ProcessLifecycleOwner): void;
+/** Remove the current owner (only if it is still `owner`, when given). Test seam. */
+export declare function releaseProcessLifecycle(owner?: ProcessLifecycleOwner): void;
+export declare function getProcessLifecycleOwner(): ProcessLifecycleOwner | undefined;
+/**
+ * Hand a termination request to the claimed owner.
+ *
+ * Returns true when an owner accepted it: the caller must then NOT exit the
+ * process itself. Returns false when no owner is claimed: the caller keeps its
+ * own behaviour.
+ */
+export declare function requestOwnedShutdown(reason: string): boolean;
+//# sourceMappingURL=process-lifecycle.d.ts.map

package/dist/kernel/process-lifecycle.js

@@ -0,0 +1,91 @@
+/**
+ * Agentic QE v3 - Process lifecycle ownership (#801)
+ *
+ * A long-running entry point (the MCP server) owns process shutdown: before it
+ * exits it must drain in-flight work and release native handles. The shared
+ * patterns RVF adapter, for example, holds a `patterns.rvf.lock` marker that
+ * only its own close() removes.
+ *
+ * Module-level signal handlers elsewhere (the kernel stores, the CLI wrapper)
+ * used to call `process.exit(0)` synchronously. Node runs signal listeners one
+ * after another in the same tick, so that exit pre-empted the owner's async
+ * graceful shutdown and leaked the marker. Those handlers now route the
+ * request to the claimed owner and do not exit themselves.
+ *
+ * With no owner claimed (every non-MCP CLI command), nothing changes and
+ * callers keep their own exit behaviour.
+ *
+ * The owner lives on `globalThis` under a registry symbol because `aqe mcp`
+ * loads the MCP bundle into the CLI bundle's process. Each bundle has its own
+ * copy of this module, and both copies must see the same owner.
+ */
+const OWNER_KEY = Symbol.for('agentic-qe.process-lifecycle-owner');
+const CLOSERS_KEY = Symbol.for('agentic-qe.process-lifecycle-store-closers');
+function closers() {
+    const g = globalThis;
+    return (g[CLOSERS_KEY] ??= []);
+}
+/**
+ * Register a synchronous, idempotent close for a process-wide store (the
+ * kernel's unified memory/persistence singletons). A claimed owner closes
+ * every registered store at the end of its shutdown, so stores are closed on
+ * every termination path, not only the signal ones. Returns an unregister
+ * function. Shared across bundle copies through the registry symbol.
+ */
+export function registerStoreCloser(close) {
+    closers().push(close);
+    return () => {
+        const list = closers();
+        const at = list.indexOf(close);
+        if (at >= 0)
+            list.splice(at, 1);
+    };
+}
+/**
+ * Close every registered store, most recently registered first (a facade is
+ * registered after the store it wraps, so it closes first). Synchronous so it
+ * also works from a process 'exit' listener; never throws. Closers must be
+ * idempotent: this may run from both the shutdown and an exit backstop.
+ */
+export function closeRegisteredStores() {
+    for (const close of [...closers()].reverse()) {
+        try {
+            close();
+        }
+        catch { /* best effort: keep closing the rest */ }
+    }
+}
+/** Make `owner` responsible for every graceful shutdown in this process. */
+export function claimProcessLifecycle(owner) {
+    globalThis[OWNER_KEY] = owner;
+}
+/** Remove the current owner (only if it is still `owner`, when given). Test seam. */
+export function releaseProcessLifecycle(owner) {
+    const g = globalThis;
+    if (!owner || g[OWNER_KEY] === owner)
+        delete g[OWNER_KEY];
+}
+export function getProcessLifecycleOwner() {
+    return globalThis[OWNER_KEY];
+}
+/**
+ * Hand a termination request to the claimed owner.
+ *
+ * Returns true when an owner accepted it: the caller must then NOT exit the
+ * process itself. Returns false when no owner is claimed: the caller keeps its
+ * own behaviour.
+ */
+export function requestOwnedShutdown(reason) {
+    const owner = getProcessLifecycleOwner();
+    if (!owner)
+        return false;
+    try {
+        owner.shutdown(reason);
+        return true;
+    }
+    catch {
+        // A broken owner must not leave the process running: let the caller exit.
+        return false;
+    }
+}
+//# sourceMappingURL=process-lifecycle.js.map

package/dist/kernel/unified-memory-schemas.d.ts

@@ -15,7 +15,21 @@ export declare const VECTORS_SCHEMA = "\n  -- Vector Embeddings (new in v3 - rep
 export declare const RL_QVALUES_SCHEMA = "\n  -- Q-Values for RL algorithms (ADR-046)\n  CREATE TABLE IF NOT EXISTS rl_q_values (\n    id TEXT PRIMARY KEY,\n    algorithm TEXT NOT NULL,\n    agent_id TEXT NOT NULL,\n    state_key TEXT NOT NULL,\n    action_key TEXT NOT NULL,\n    q_value REAL NOT NULL DEFAULT 0.0,\n    visits INTEGER NOT NULL DEFAULT 0,\n    last_reward REAL,\n    domain TEXT,\n    created_at TEXT DEFAULT (datetime('now')),\n    updated_at TEXT DEFAULT (datetime('now')),\n    UNIQUE(algorithm, agent_id, state_key, action_key)\n  );\n  CREATE INDEX IF NOT EXISTS idx_qvalues_agent ON rl_q_values(agent_id);\n  CREATE INDEX IF NOT EXISTS idx_qvalues_algorithm ON rl_q_values(algorithm);\n  CREATE INDEX IF NOT EXISTS idx_qvalues_state ON rl_q_values(agent_id, state_key);\n  CREATE INDEX IF NOT EXISTS idx_qvalues_domain ON rl_q_values(domain);\n  CREATE INDEX IF NOT EXISTS idx_qvalues_updated ON rl_q_values(updated_at);\n";
 export declare const GOAP_SCHEMA = "\n  -- GOAP Goals\n  CREATE TABLE IF NOT EXISTS goap_goals (\n    id TEXT PRIMARY KEY,\n    name TEXT NOT NULL,\n    description TEXT,\n    conditions TEXT NOT NULL,\n    priority INTEGER DEFAULT 3,\n    qe_domain TEXT,\n    created_at TEXT DEFAULT (datetime('now'))\n  );\n\n  -- GOAP Actions\n  CREATE TABLE IF NOT EXISTS goap_actions (\n    id TEXT PRIMARY KEY,\n    name TEXT NOT NULL,\n    description TEXT,\n    agent_type TEXT NOT NULL,\n    preconditions TEXT NOT NULL,\n    effects TEXT NOT NULL,\n    cost REAL DEFAULT 1.0,\n    estimated_duration_ms INTEGER,\n    success_rate REAL DEFAULT 1.0,\n    execution_count INTEGER DEFAULT 0,\n    category TEXT NOT NULL,\n    qe_domain TEXT,\n    created_at TEXT DEFAULT (datetime('now')),\n    updated_at TEXT DEFAULT (datetime('now')),\n    -- A14: real domain API method binding (kernel.getDomainAPI(qe_domain)[method](params)).\n    -- method/implemented are NULL/0 for actions with no real backing yet \u2014\n    -- GOAPExecutor must report those as \"not implemented\", never simulate them.\n    method TEXT,\n    params TEXT,\n    implemented INTEGER DEFAULT 0\n  );\n\n  -- GOAP Plans\n  CREATE TABLE IF NOT EXISTS goap_plans (\n    id TEXT PRIMARY KEY,\n    goal_id TEXT,\n    initial_state TEXT NOT NULL,\n    goal_state TEXT NOT NULL,\n    action_sequence TEXT NOT NULL,\n    total_cost REAL,\n    estimated_duration_ms INTEGER,\n    status TEXT DEFAULT 'pending',\n    reused_from TEXT,\n    similarity_score REAL,\n    created_at TEXT DEFAULT (datetime('now')),\n    executed_at TEXT,\n    completed_at TEXT,\n    FOREIGN KEY (goal_id) REFERENCES goap_goals(id)\n  );\n\n  -- Plan Signatures (for similarity matching)\n  CREATE TABLE IF NOT EXISTS goap_plan_signatures (\n    id TEXT PRIMARY KEY,\n    plan_id TEXT NOT NULL UNIQUE,\n    goal_hash TEXT NOT NULL,\n    state_vector TEXT NOT NULL,\n    action_sequence TEXT NOT NULL,\n    total_cost REAL NOT NULL,\n    success_rate REAL DEFAULT 1.0,\n    usage_count INTEGER DEFAULT 0,\n    created_at TEXT DEFAULT (datetime('now'))\n  );\n\n  -- A14: canonical per-step execution history (was previously undefined in\n  -- this schema \u2014 plan-executor.ts invented its own parallel\n  -- execution_results/executed_steps tables instead). One row per action\n  -- step per execution attempt (execution_id groups steps from the same\n  -- plan.execute() call, since a plan can be executed/retried more than\n  -- once). Aggregate per-execution stats (steps completed/failed, total\n  -- duration, final world state) are derived by querying this table rather\n  -- than maintained in a separate denormalized summary table.\n  CREATE TABLE IF NOT EXISTS goap_execution_steps (\n    id TEXT PRIMARY KEY,\n    plan_id TEXT NOT NULL,\n    execution_id TEXT NOT NULL,\n    action_id TEXT NOT NULL,\n    step_order INTEGER NOT NULL,\n    world_state_before TEXT,\n    world_state_after TEXT,\n    status TEXT NOT NULL DEFAULT 'pending',\n    retries INTEGER DEFAULT 0,\n    started_at TEXT,\n    duration_ms INTEGER,\n    agent_id TEXT,\n    agent_output TEXT,\n    error_message TEXT,\n    created_at TEXT DEFAULT (datetime('now'))\n    -- Deliberately no FK to goap_plans/goap_actions: PlanExecutor.execute()\n    -- can legitimately run an ad-hoc GOAPPlan/GOAPAction that was never\n    -- saved via savePlan()/addAction() (e.g. programmatic orchestration\n    -- bypassing the A* planner). unified-memory.ts enables the\n    -- foreign_keys pragma, so an enforced FK here would reject that\n    -- entirely legitimate usage, not just catch real corruption.\n  );\n\n  -- GOAP Indexes\n  CREATE INDEX IF NOT EXISTS idx_goap_actions_category ON goap_actions(category);\n  CREATE INDEX IF NOT EXISTS idx_goap_actions_agent ON goap_actions(agent_type);\n  CREATE INDEX IF NOT EXISTS idx_goap_plans_status ON goap_plans(status);\n  CREATE INDEX IF NOT EXISTS idx_goap_sig_goal ON goap_plan_signatures(goal_hash);\n  CREATE INDEX IF NOT EXISTS idx_goap_exec_steps_plan ON goap_execution_steps(plan_id);\n  CREATE INDEX IF NOT EXISTS idx_goap_exec_steps_action ON goap_execution_steps(action_id);\n  -- idx_goap_exec_steps_execution is NOT created here: databases with a\n  -- pre-existing narrower goap_execution_steps table (missing execution_id)\n  -- would fail on \"no such column\" since CREATE TABLE IF NOT EXISTS above\n  -- silently no-ops against them. unified-memory.ts's v11 migration creates\n  -- this index only after confirming/backfilling the column.\n";
 export declare const DREAM_SCHEMA = "\n  -- Concept Graph Nodes (Dream Engine)\n  CREATE TABLE IF NOT EXISTS concept_nodes (\n    id TEXT PRIMARY KEY,\n    concept_type TEXT NOT NULL,\n    content TEXT NOT NULL,\n    embedding BLOB,\n    activation_level REAL DEFAULT 0.0,\n    last_activated TEXT,\n    pattern_id TEXT,\n    metadata TEXT,\n    created_at TEXT DEFAULT (datetime('now'))\n  );\n\n  -- Concept Edges\n  CREATE TABLE IF NOT EXISTS concept_edges (\n    id TEXT PRIMARY KEY,\n    source TEXT NOT NULL,\n    target TEXT NOT NULL,\n    weight REAL NOT NULL DEFAULT 1.0,\n    edge_type TEXT NOT NULL,\n    evidence INTEGER DEFAULT 1,\n    created_at TEXT DEFAULT (datetime('now')),\n    updated_at TEXT DEFAULT (datetime('now')),\n    FOREIGN KEY (source) REFERENCES concept_nodes(id) ON DELETE CASCADE,\n    FOREIGN KEY (target) REFERENCES concept_nodes(id) ON DELETE CASCADE\n  );\n\n  -- Dream Cycles\n  CREATE TABLE IF NOT EXISTS dream_cycles (\n    id TEXT PRIMARY KEY,\n    start_time TEXT NOT NULL,\n    end_time TEXT,\n    duration_ms INTEGER,\n    concepts_processed INTEGER DEFAULT 0,\n    associations_found INTEGER DEFAULT 0,\n    insights_generated INTEGER DEFAULT 0,\n    status TEXT DEFAULT 'running',\n    error TEXT,\n    created_at TEXT DEFAULT (datetime('now'))\n  );\n\n  -- Dream Insights\n  CREATE TABLE IF NOT EXISTS dream_insights (\n    id TEXT PRIMARY KEY,\n    cycle_id TEXT NOT NULL,\n    insight_type TEXT NOT NULL,\n    source_concepts TEXT NOT NULL,\n    description TEXT NOT NULL,\n    novelty_score REAL DEFAULT 0.5,\n    confidence_score REAL DEFAULT 0.5,\n    actionable INTEGER DEFAULT 0,\n    applied INTEGER DEFAULT 0,\n    suggested_action TEXT,\n    pattern_id TEXT,\n    created_at TEXT DEFAULT (datetime('now')),\n    FOREIGN KEY (cycle_id) REFERENCES dream_cycles(id) ON DELETE CASCADE\n  );\n\n  -- Dream Indexes\n  CREATE INDEX IF NOT EXISTS idx_concept_type ON concept_nodes(concept_type);\n  CREATE INDEX IF NOT EXISTS idx_concept_activation ON concept_nodes(activation_level);\n  CREATE INDEX IF NOT EXISTS idx_concept_pattern ON concept_nodes(pattern_id);\n  CREATE INDEX IF NOT EXISTS idx_edge_source ON concept_edges(source);\n  CREATE INDEX IF NOT EXISTS idx_edge_target ON concept_edges(target);\n  CREATE INDEX IF NOT EXISTS idx_edge_type ON concept_edges(edge_type);\n  CREATE INDEX IF NOT EXISTS idx_edge_weight ON concept_edges(weight DESC);\n  CREATE INDEX IF NOT EXISTS idx_insight_cycle ON dream_insights(cycle_id);\n  CREATE INDEX IF NOT EXISTS idx_dream_status ON dream_cycles(status);\n";
-export declare const QE_PATTERNS_SCHEMA = "\n  -- QE Patterns table (unified from sqlite-persistence.ts)\n  CREATE TABLE IF NOT EXISTS qe_patterns (\n    id TEXT PRIMARY KEY,\n    pattern_type TEXT NOT NULL,\n    qe_domain TEXT NOT NULL,\n    domain TEXT NOT NULL,\n    name TEXT NOT NULL,\n    description TEXT,\n    confidence REAL DEFAULT 0.5,\n    usage_count INTEGER DEFAULT 0,\n    success_rate REAL DEFAULT 0.0,\n    quality_score REAL DEFAULT 0.0,\n    tier TEXT DEFAULT 'short-term',\n    template_json TEXT,\n    context_json TEXT,\n    created_at TEXT DEFAULT (datetime('now')),\n    updated_at TEXT DEFAULT (datetime('now')),\n    last_used_at TEXT,\n    successful_uses INTEGER DEFAULT 0,\n    tokens_used INTEGER,\n    input_tokens INTEGER,\n    output_tokens INTEGER,\n    latency_ms REAL,\n    reusable INTEGER DEFAULT 0,\n    reuse_count INTEGER DEFAULT 0,\n    average_token_savings REAL DEFAULT 0,\n    total_tokens_saved INTEGER\n  );\n\n  -- Pattern embeddings table (BLOB storage for vectors)\n  CREATE TABLE IF NOT EXISTS qe_pattern_embeddings (\n    pattern_id TEXT PRIMARY KEY,\n    embedding BLOB NOT NULL,\n    dimension INTEGER NOT NULL,\n    model TEXT DEFAULT 'all-MiniLM-L6-v2',\n    space_id TEXT,\n    created_at TEXT DEFAULT (datetime('now')),\n    FOREIGN KEY (pattern_id) REFERENCES qe_patterns(id) ON DELETE CASCADE\n  );\n\n  -- Pattern usage history (no FK -- used as analytics log by hooks with synthetic IDs)\n  CREATE TABLE IF NOT EXISTS qe_pattern_usage (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    pattern_id TEXT NOT NULL,\n    success INTEGER NOT NULL,\n    metrics_json TEXT,\n    feedback TEXT,\n    created_at TEXT DEFAULT (datetime('now'))\n  );\n\n  -- Learning trajectories\n  CREATE TABLE IF NOT EXISTS qe_trajectories (\n    id TEXT PRIMARY KEY,\n    task TEXT NOT NULL,\n    agent TEXT,\n    domain TEXT,\n    started_at TEXT DEFAULT (datetime('now')),\n    ended_at TEXT,\n    success INTEGER,\n    steps_json TEXT,\n    metadata_json TEXT\n  );\n\n  -- Embeddings table (unified from EmbeddingCache.ts)\n  -- Renamed from 'embedding_cache' to 'embeddings' to match existing code\n  CREATE TABLE IF NOT EXISTS embeddings (\n    key TEXT NOT NULL,\n    namespace TEXT NOT NULL,\n    vector BLOB NOT NULL,\n    dimension INTEGER NOT NULL,\n    text TEXT NOT NULL,\n    timestamp INTEGER NOT NULL,\n    quantization TEXT NOT NULL,\n    metadata TEXT,\n    access_count INTEGER DEFAULT 1,\n    last_access INTEGER NOT NULL,\n    PRIMARY KEY (key, namespace)\n  );\n\n  -- Execution results table (unified from plan-executor.ts)\n  CREATE TABLE IF NOT EXISTS execution_results (\n    id TEXT PRIMARY KEY,\n    plan_id TEXT NOT NULL,\n    status TEXT NOT NULL,\n    steps_completed INTEGER DEFAULT 0,\n    steps_failed INTEGER DEFAULT 0,\n    total_duration_ms INTEGER DEFAULT 0,\n    final_world_state TEXT,\n    error_message TEXT,\n    created_at TEXT DEFAULT (datetime('now'))\n  );\n\n  -- Executed steps table (unified from plan-executor.ts)\n  CREATE TABLE IF NOT EXISTS executed_steps (\n    id TEXT PRIMARY KEY,\n    execution_id TEXT NOT NULL,\n    plan_id TEXT NOT NULL,\n    action_id TEXT NOT NULL,\n    step_order INTEGER NOT NULL,\n    status TEXT NOT NULL,\n    retries INTEGER DEFAULT 0,\n    started_at TEXT NOT NULL,\n    completed_at TEXT,\n    duration_ms INTEGER,\n    agent_id TEXT,\n    agent_output TEXT,\n    world_state_before TEXT,\n    world_state_after TEXT,\n    error_message TEXT,\n    FOREIGN KEY (execution_id) REFERENCES execution_results(id)\n  );\n\n  -- FTS5 full-text search index for hybrid vector/text search\n  CREATE VIRTUAL TABLE IF NOT EXISTS qe_patterns_fts USING fts5(\n    name, description, pattern_type, qe_domain,\n    content='qe_patterns',\n    content_rowid='rowid'\n  );\n\n  -- FTS5 triggers to keep index in sync\n  CREATE TRIGGER IF NOT EXISTS qe_patterns_fts_insert AFTER INSERT ON qe_patterns BEGIN\n    INSERT INTO qe_patterns_fts(rowid, name, description, pattern_type, qe_domain)\n    VALUES (new.rowid, new.name, new.description, new.pattern_type, new.qe_domain);\n  END;\n\n  CREATE TRIGGER IF NOT EXISTS qe_patterns_fts_delete AFTER DELETE ON qe_patterns BEGIN\n    INSERT INTO qe_patterns_fts(qe_patterns_fts, rowid, name, description, pattern_type, qe_domain)\n    VALUES ('delete', old.rowid, old.name, old.description, old.pattern_type, old.qe_domain);\n  END;\n\n  CREATE TRIGGER IF NOT EXISTS qe_patterns_fts_update AFTER UPDATE ON qe_patterns BEGIN\n    INSERT INTO qe_patterns_fts(qe_patterns_fts, rowid, name, description, pattern_type, qe_domain)\n    VALUES ('delete', old.rowid, old.name, old.description, old.pattern_type, old.qe_domain);\n    INSERT INTO qe_patterns_fts(rowid, name, description, pattern_type, qe_domain)\n    VALUES (new.rowid, new.name, new.description, new.pattern_type, new.qe_domain);\n  END;\n\n  -- QE Patterns indexes\n  CREATE INDEX IF NOT EXISTS idx_qe_patterns_domain ON qe_patterns(qe_domain);\n  CREATE INDEX IF NOT EXISTS idx_qe_patterns_type ON qe_patterns(pattern_type);\n  CREATE INDEX IF NOT EXISTS idx_qe_patterns_tier ON qe_patterns(tier);\n  CREATE INDEX IF NOT EXISTS idx_qe_patterns_quality ON qe_patterns(quality_score DESC);\n  CREATE INDEX IF NOT EXISTS idx_qe_pattern_embeddings_space ON qe_pattern_embeddings(space_id);\n  CREATE INDEX IF NOT EXISTS idx_qe_usage_pattern ON qe_pattern_usage(pattern_id);\n  CREATE INDEX IF NOT EXISTS idx_qe_trajectories_domain ON qe_trajectories(domain);\n  CREATE INDEX IF NOT EXISTS idx_embeddings_namespace ON embeddings(namespace);\n  CREATE INDEX IF NOT EXISTS idx_embeddings_timestamp ON embeddings(timestamp);\n  CREATE INDEX IF NOT EXISTS idx_execution_results_plan ON execution_results(plan_id);\n  CREATE INDEX IF NOT EXISTS idx_execution_results_status ON execution_results(status);\n  CREATE INDEX IF NOT EXISTS idx_executed_steps_execution ON executed_steps(execution_id);\n  CREATE INDEX IF NOT EXISTS idx_executed_steps_action ON executed_steps(action_id);\n";
+/** FTS5 external-content index over qe_patterns (hybrid vector/text search). */
+export declare const QE_PATTERNS_FTS_TABLE_DDL = "\n  CREATE VIRTUAL TABLE IF NOT EXISTS qe_patterns_fts USING fts5(\n    name, description, pattern_type, qe_domain,\n    content='qe_patterns',\n    content_rowid='rowid'\n  );\n";
+/** Sync triggers keeping qe_patterns_fts in step with qe_patterns, keyed by name. */
+export declare const QE_PATTERNS_FTS_TRIGGER_DDL: Readonly<Record<string, string>>;
+/** FTS5 table plus all sync triggers (idempotent). Requires qe_patterns to exist. */
+export declare const QE_PATTERNS_FTS_SCHEMA: string;
+export declare const QE_PATTERNS_SCHEMA: string;
+/**
+ * QE_PATTERNS_SCHEMA without the FTS5 table/triggers, for migrations that run
+ * after v9 on an existing DB. Re-creating the sync triggers there (with
+ * CREATE TRIGGER IF NOT EXISTS, no rebuild) would hide "triggers were missing"
+ * from the on-open self-heal, leaving UPDATE-only drift unrepaired; the heal
+ * creates any missing FTS objects and rebuilds instead.
+ */
+export declare const QE_PATTERNS_SCHEMA_WITHOUT_FTS: string;
 export declare const MINCUT_SCHEMA = "\n  -- MinCut Graph Snapshots (ADR-047)\n  CREATE TABLE IF NOT EXISTS mincut_snapshots (\n    id TEXT PRIMARY KEY,\n    timestamp TEXT NOT NULL DEFAULT (datetime('now')),\n    vertex_count INTEGER NOT NULL,\n    edge_count INTEGER NOT NULL,\n    total_weight REAL NOT NULL DEFAULT 0.0,\n    is_connected INTEGER NOT NULL DEFAULT 1,\n    component_count INTEGER NOT NULL DEFAULT 1,\n    vertices_json TEXT NOT NULL,\n    edges_json TEXT NOT NULL,\n    created_at TEXT DEFAULT (datetime('now'))\n  );\n\n  -- MinCut History (time-series MinCut values)\n  CREATE TABLE IF NOT EXISTS mincut_history (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    timestamp TEXT NOT NULL DEFAULT (datetime('now')),\n    mincut_value REAL NOT NULL,\n    vertex_count INTEGER NOT NULL,\n    edge_count INTEGER NOT NULL,\n    algorithm TEXT NOT NULL DEFAULT 'weighted-degree',\n    duration_ms INTEGER,\n    snapshot_id TEXT,\n    created_at TEXT DEFAULT (datetime('now')),\n    FOREIGN KEY (snapshot_id) REFERENCES mincut_snapshots(id) ON DELETE SET NULL\n  );\n\n  -- MinCut Weak Vertices (detected bottlenecks)\n  CREATE TABLE IF NOT EXISTS mincut_weak_vertices (\n    id TEXT PRIMARY KEY,\n    vertex_id TEXT NOT NULL,\n    weighted_degree REAL NOT NULL,\n    risk_score REAL NOT NULL,\n    reason TEXT NOT NULL,\n    domain TEXT,\n    vertex_type TEXT NOT NULL,\n    suggestions_json TEXT,\n    detected_at TEXT NOT NULL DEFAULT (datetime('now')),\n    resolved_at TEXT,\n    snapshot_id TEXT,\n    created_at TEXT DEFAULT (datetime('now')),\n    FOREIGN KEY (snapshot_id) REFERENCES mincut_snapshots(id) ON DELETE SET NULL\n  );\n\n  -- MinCut Alerts\n  CREATE TABLE IF NOT EXISTS mincut_alerts (\n    id TEXT PRIMARY KEY,\n    severity TEXT NOT NULL,\n    message TEXT NOT NULL,\n    mincut_value REAL NOT NULL,\n    threshold REAL NOT NULL,\n    affected_vertices_json TEXT,\n    remediations_json TEXT,\n    acknowledged INTEGER DEFAULT 0,\n    acknowledged_at TEXT,\n    acknowledged_by TEXT,\n    timestamp TEXT NOT NULL DEFAULT (datetime('now')),\n    created_at TEXT DEFAULT (datetime('now'))\n  );\n\n  -- MinCut Healing Actions (self-healing history)\n  CREATE TABLE IF NOT EXISTS mincut_healing_actions (\n    id TEXT PRIMARY KEY,\n    action_type TEXT NOT NULL,\n    action_params_json TEXT NOT NULL,\n    success INTEGER NOT NULL,\n    mincut_before REAL NOT NULL,\n    mincut_after REAL NOT NULL,\n    improvement REAL NOT NULL DEFAULT 0.0,\n    error_message TEXT,\n    duration_ms INTEGER NOT NULL,\n    triggered_by TEXT,\n    snapshot_before_id TEXT,\n    snapshot_after_id TEXT,\n    created_at TEXT DEFAULT (datetime('now')),\n    FOREIGN KEY (snapshot_before_id) REFERENCES mincut_snapshots(id) ON DELETE SET NULL,\n    FOREIGN KEY (snapshot_after_id) REFERENCES mincut_snapshots(id) ON DELETE SET NULL\n  );\n\n  -- MinCut Strange Loop Observations (P1: self-organizing)\n  CREATE TABLE IF NOT EXISTS mincut_observations (\n    id TEXT PRIMARY KEY,\n    iteration INTEGER NOT NULL,\n    mincut_value REAL NOT NULL,\n    weak_vertex_count INTEGER NOT NULL DEFAULT 0,\n    weak_vertices_json TEXT,\n    snapshot_id TEXT,\n    prediction_json TEXT,\n    actual_vs_predicted_diff REAL,\n    timestamp TEXT NOT NULL DEFAULT (datetime('now')),\n    FOREIGN KEY (snapshot_id) REFERENCES mincut_snapshots(id) ON DELETE SET NULL\n  );\n\n  -- MinCut Indexes\n  CREATE INDEX IF NOT EXISTS idx_mincut_history_timestamp ON mincut_history(timestamp DESC);\n  CREATE INDEX IF NOT EXISTS idx_mincut_history_value ON mincut_history(mincut_value);\n  CREATE INDEX IF NOT EXISTS idx_mincut_weak_vertex ON mincut_weak_vertices(vertex_id);\n  CREATE INDEX IF NOT EXISTS idx_mincut_weak_risk ON mincut_weak_vertices(risk_score DESC);\n  CREATE INDEX IF NOT EXISTS idx_mincut_weak_resolved ON mincut_weak_vertices(resolved_at);\n  CREATE INDEX IF NOT EXISTS idx_mincut_alerts_severity ON mincut_alerts(severity);\n  CREATE INDEX IF NOT EXISTS idx_mincut_alerts_ack ON mincut_alerts(acknowledged);\n  CREATE INDEX IF NOT EXISTS idx_mincut_healing_type ON mincut_healing_actions(action_type);\n  CREATE INDEX IF NOT EXISTS idx_mincut_healing_success ON mincut_healing_actions(success);\n  CREATE INDEX IF NOT EXISTS idx_mincut_observations_iter ON mincut_observations(iteration);\n";
 export declare const SONA_PATTERNS_SCHEMA = "\n  -- SONA Patterns table (ADR-046: Pattern Persistence for Neural Backbone)\n  CREATE TABLE IF NOT EXISTS sona_patterns (\n    id TEXT PRIMARY KEY,\n    type TEXT NOT NULL,\n    domain TEXT NOT NULL,\n    state_embedding BLOB,\n    action_embedding BLOB,\n    action_type TEXT NOT NULL,\n    action_value TEXT,\n    outcome_reward REAL NOT NULL DEFAULT 0.0,\n    outcome_success INTEGER NOT NULL DEFAULT 0,\n    outcome_quality REAL NOT NULL DEFAULT 0.0,\n    confidence REAL DEFAULT 0.5,\n    usage_count INTEGER DEFAULT 0,\n    success_count INTEGER DEFAULT 0,\n    failure_count INTEGER DEFAULT 0,\n    metadata TEXT,\n    created_at TEXT DEFAULT (datetime('now')),\n    updated_at TEXT DEFAULT (datetime('now')),\n    last_used_at TEXT\n  );\n  CREATE INDEX IF NOT EXISTS idx_sona_patterns_type ON sona_patterns(type);\n  CREATE INDEX IF NOT EXISTS idx_sona_patterns_domain ON sona_patterns(domain);\n  CREATE INDEX IF NOT EXISTS idx_sona_patterns_confidence ON sona_patterns(confidence DESC);\n  CREATE INDEX IF NOT EXISTS idx_sona_patterns_updated ON sona_patterns(updated_at DESC);\n";
 export declare const WITNESS_CHAIN_SCHEMA = "\n  -- Witness Chain (ADR-070: Cryptographic audit trail for QE decisions)\n  CREATE TABLE IF NOT EXISTS witness_chain (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    prev_hash TEXT NOT NULL,\n    action_hash TEXT NOT NULL,\n    action_type TEXT NOT NULL,\n    action_data TEXT,\n    timestamp TEXT NOT NULL,\n    actor TEXT NOT NULL\n  );\n  CREATE INDEX IF NOT EXISTS idx_witness_action_type ON witness_chain(action_type);\n  CREATE INDEX IF NOT EXISTS idx_witness_timestamp ON witness_chain(timestamp);\n";