@jungjaehoon/mama-core 2.4.0 → 4.0.0

package/dist/db-adapter/node-sqlite-adapter.js

@@ -8,17 +8,184 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeSQLiteAdapter = void 0;
+exports.NodeSQLiteAdapter = exports.CORE_MIGRATION_SOURCE = void 0;
 const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
 const fs_1 = __importDefault(require("fs"));
-const base_adapter_js_1 = require("./base-adapter.js");
 const node_sqlite_statement_js_1 = require("./node-sqlite-statement.js");
 const debug_logger_js_1 = require("../debug-logger.js");
-const embeddings_js_1 = require("../embeddings.js");
-const LEGACY_DB_PATH = path_1.default.join(os_1.default.homedir(), '.spinelift', 'memories.db');
-const DEFAULT_DB_PATH = path_1.default.join(os_1.default.homedir(), '.claude', 'mama-memory.db');
+const embedder_js_1 = require("../embedding/embedder.js");
 const SQLITE_IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+// Migration 071 origin invariant, kept in ONE place so the DDL the rebuild
+// writes and the shape verification that admits a table cannot drift. A row is
+// valid only with a model-only origin or a complete operation/actor pair.
+const TOOL_TRACES_ORIGIN_CHECK = `CHECK (
+    (model_run_id IS NOT NULL AND operation_id IS NULL AND actor_principal_id IS NULL)
+    OR (
+      operation_id IS NOT NULL AND length(trim(operation_id)) > 0
+      AND actor_principal_id IS NOT NULL AND length(trim(actor_principal_id)) > 0
+    )
+  )`;
+const TOOL_TRACES_MODEL_FK = 'FOREIGN KEY (model_run_id) REFERENCES model_runs(model_run_id)';
+const WORKFLOW_KIND_MIGRATION_COLUMNS = [
+    'id',
+    'topic',
+    'decision',
+    'reasoning',
+    'outcome',
+    'failure_reason',
+    'limitation',
+    'user_involvement',
+    'session_id',
+    'supersedes',
+    'superseded_by',
+    'refined_from',
+    'confidence',
+    'created_at',
+    'updated_at',
+    'needs_validation',
+    'validation_attempts',
+    'last_validated_at',
+    'usage_count',
+    'trust_context',
+    'usage_success',
+    'usage_failure',
+    'time_saved',
+    'evidence',
+    'alternatives',
+    'risks',
+    'event_date',
+    'kind',
+    'status',
+    'summary',
+    'is_static',
+    'event_datetime',
+    'agent_id',
+    'model_run_id',
+    'envelope_hash',
+    'gateway_call_id',
+    'source_refs_json',
+    'provenance_json',
+    'item_id',
+    'record_kind',
+    'payload_json',
+    'applies_from',
+    'applies_until',
+    'duration_days',
+];
+function normalizeSqlText(sql) {
+    return sql.replace(/\s+/g, '').toLowerCase();
+}
+/**
+ * Split a CREATE TABLE body (the text between the outermost parentheses) into
+ * its top-level column and table-constraint clauses. Respects nested
+ * parentheses (CHECK expressions), and single/double/backtick/bracket quoted
+ * identifiers and string literals. This is a targeted parser for reconstructing
+ * ONE known table, not a general SQL engine.
+ */
+function splitCreateTableClauses(createSql) {
+    const open = createSql.indexOf('(');
+    const close = createSql.lastIndexOf(')');
+    if (open < 0 || close <= open) {
+        return [];
+    }
+    const body = createSql.slice(open + 1, close);
+    const clauses = [];
+    let depth = 0;
+    let current = '';
+    let quote = null;
+    for (let i = 0; i < body.length; i++) {
+        const ch = body[i];
+        if (quote) {
+            current += ch;
+            if (ch === quote) {
+                // Doubled quote is an escaped quote, not a close (SQLite identifier/string rule).
+                if (quote !== ']' && body[i + 1] === quote) {
+                    current += body[++i];
+                }
+                else {
+                    quote = null;
+                }
+            }
+            continue;
+        }
+        if (ch === "'" || ch === '"' || ch === '`') {
+            quote = ch;
+            current += ch;
+            continue;
+        }
+        if (ch === '[') {
+            quote = ']';
+            current += ch;
+            continue;
+        }
+        if (ch === '(') {
+            depth++;
+            current += ch;
+            continue;
+        }
+        if (ch === ')') {
+            depth--;
+            current += ch;
+            continue;
+        }
+        if (ch === ',' && depth === 0) {
+            if (current.trim()) {
+                clauses.push(current.trim());
+            }
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    if (current.trim()) {
+        clauses.push(current.trim());
+    }
+    return clauses;
+}
+const TABLE_CONSTRAINT_KEYWORDS = new Set(['constraint', 'primary', 'unique', 'check', 'foreign']);
+function clauseIsTableConstraint(clause) {
+    const firstToken = clause.trimStart().split(/[\s(]/, 1)[0].toLowerCase();
+    return TABLE_CONSTRAINT_KEYWORDS.has(firstToken);
+}
+/**
+ * Quote a decoded identifier for safe emission in SQL. Any column/table name we
+ * recovered from a CREATE TABLE clause or sqlite_master (possibly containing a
+ * space, an embedded double quote, or a reserved word) is re-quoted with SQLite
+ * double-quote rules: wrap in double quotes and double any embedded double quote.
+ * clauseColumnName strips quoting, so the INSERT/SELECT column list MUST re-quote
+ * or a name like `runtime note` becomes two bare tokens and breaks the migration.
+ */
+function quoteSqlIdentifier(name) {
+    return `"${name.replace(/"/g, '""')}"`;
+}
+/** Column name of a column-definition clause, stripping quotes/brackets. */
+function clauseColumnName(clause) {
+    const trimmed = clause.trimStart();
+    const first = trimmed[0];
+    if (first === '"' || first === '`' || first === "'") {
+        let name = '';
+        for (let i = 1; i < trimmed.length; i++) {
+            if (trimmed[i] === first) {
+                if (trimmed[i + 1] === first) {
+                    name += first;
+                    i++;
+                }
+                else {
+                    break;
+                }
+            }
+            else {
+                name += trimmed[i];
+            }
+        }
+        return name;
+    }
+    if (first === '[') {
+        const end = trimmed.indexOf(']');
+        return end > 0 ? trimmed.slice(1, end) : trimmed.slice(1);
+    }
+    return trimmed.split(/[\s(]/, 1)[0];
+}
 // Prefer better-sqlite3 (includes FTS5) over node:sqlite (lacks FTS5)
 let BetterSQLite3 = null;
 let DatabaseSync = null;
@@ -82,12 +249,15 @@ class NodeSQLiteConnection {
         return this.connected;
     }
 }
-class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
+/** The core is one source among others; it is only first because others build on it. */
+exports.CORE_MIGRATION_SOURCE = 'core';
+class NodeSQLiteAdapter {
+    transactionDepth = 0;
     config;
     db = null;
-    _vectorSearchEnabled = true;
     vectorCache = new Map();
     topicCache = new Map();
+    kindCache = new Map();
     // Effective status (status, falling back to outcome) per decision rowid. Used as a
     // search-time optimization only - recallMemory's post-filter stays the authority
     // (this cache can lag a status UPDATE until the next reloadVectorCache).
@@ -95,23 +265,26 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
     decisionsHasStatusColumns = false;
     decisionsColumnInfoChecked = false;
     constructor(config = {}) {
-        super();
         this.config = config;
     }
-    get vectorSearchEnabled() {
-        return this._vectorSearchEnabled;
-    }
     getDbPath() {
         const envPath = process.env.MAMA_DB_PATH || process.env.MAMA_DATABASE_PATH;
         const configPath = this.config.dbPath;
-        let expandedEnvPath = envPath;
-        if (envPath) {
-            expandedEnvPath = envPath.replace(/\$\{HOME\}/g, os_1.default.homedir()).replace(/^~/, os_1.default.homedir());
-        }
-        const targetPath = configPath || expandedEnvPath || DEFAULT_DB_PATH;
-        if (!configPath && !envPath && fs_1.default.existsSync(LEGACY_DB_PATH)) {
-            (0, debug_logger_js_1.info)('[node-sqlite-adapter] Found legacy database at ~/.spinelift/memories.db, using it for backward compatibility');
-            return LEGACY_DB_PATH;
+        const targetPath = configPath || envPath;
+        // The adapter used to expand `~` and `${HOME}` here, which made a shared library
+        // the thing that decides what home means. Whoever set the variable knows; this
+        // says so rather than guessing on their behalf.
+        if (targetPath &&
+            (targetPath === '~' || targetPath.startsWith('~/') || targetPath.includes('${HOME}'))) {
+            throw new Error(`Database path is not resolved (${targetPath}). ` +
+                'Expand it where the home directory is known and pass the result.');
+        }
+        if (!targetPath) {
+            // There used to be a default here: ~/.claude/mama-memory.db. A shared core that
+            // knows where one product keeps its database is not shared, and a caller who
+            // forgot to say got a database it never named -- which is worse than an error,
+            // because it works.
+            throw new Error('No database path. Pass dbPath, or set MAMA_DB_PATH before opening the database.');
         }
         return targetPath;
     }
@@ -155,19 +328,25 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
         if (!this.isConnected()) {
             throw new Error('Database not connected');
         }
-        if (!this.decisionsColumnInfoChecked) {
-            this.refreshDecisionColumnInfo();
-        }
+        const decisionCols = this.refreshDecisionColumnInfo();
+        const kindSelect = decisionCols.has('kind') ? 'kind' : 'NULL AS kind';
         const cacheSelect = this.decisionsHasStatusColumns
-            ? 'SELECT topic, status, outcome FROM decisions WHERE rowid = ?'
-            : 'SELECT topic, NULL AS status, NULL AS outcome FROM decisions WHERE rowid = ?';
+            ? `SELECT topic, ${kindSelect}, status, outcome FROM decisions WHERE rowid = ?`
+            : `SELECT topic, ${kindSelect}, NULL AS status, NULL AS outcome FROM decisions WHERE rowid = ?`;
         const row = this.prepare(cacheSelect).get(rowid);
         if (!row) {
             this.statusCache.delete(rowid);
             this.topicCache.delete(rowid);
+            this.kindCache.delete(rowid);
             return;
         }
         this.topicCache.set(rowid, row.topic);
+        if (row.kind) {
+            this.kindCache.set(rowid, row.kind);
+        }
+        else {
+            this.kindCache.delete(rowid);
+        }
         const effectiveStatus = row.status || row.outcome;
         if (effectiveStatus) {
             this.statusCache.set(rowid, effectiveStatus);
@@ -195,6 +374,7 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
         if (tableCheck.length === 0) {
             this.vectorCache.clear();
             this.topicCache.clear();
+            this.kindCache.clear();
             this.statusCache.clear();
             return;
         }
@@ -215,15 +395,19 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
         // A missing column just leaves statusCache empty; the api-layer post-filter
         // remains the authority.
         this.topicCache.clear();
+        this.kindCache.clear();
         this.statusCache.clear();
         const decisionCols = this.refreshDecisionColumnInfo();
+        const kindSelect = decisionCols.has('kind') ? 'kind' : 'NULL AS kind';
         const statusSelect = decisionCols.has('status') ? 'status' : 'NULL AS status';
         const outcomeSelect = decisionCols.has('outcome') ? 'outcome' : 'NULL AS outcome';
         const topicRows = this.db
-            .prepare(`SELECT rowid, topic, ${statusSelect}, ${outcomeSelect} FROM decisions`)
+            .prepare(`SELECT rowid, topic, ${kindSelect}, ${statusSelect}, ${outcomeSelect} FROM decisions`)
             .all();
         for (const row of topicRows) {
             this.topicCache.set(row.rowid, row.topic);
+            if (row.kind)
+                this.kindCache.set(row.rowid, row.kind);
             const effectiveStatus = row.status || row.outcome;
             if (effectiveStatus) {
                 this.statusCache.set(row.rowid, effectiveStatus);
@@ -233,7 +417,7 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
         const elapsed = Date.now() - start;
         (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Vector cache loaded: ${count} embeddings in ${elapsed}ms`);
         if (count > CACHE_WARN_THRESHOLD) {
-            (0, debug_logger_js_1.warn)(`[node-sqlite-adapter] Vector cache holds ${count} embeddings — consider LRU eviction or on-demand loading for large datasets`);
+            (0, debug_logger_js_1.warn)(`[node-sqlite-adapter] Vector cache holds ${count} embeddings -- consider LRU eviction or on-demand loading for large datasets`);
         }
     }
     disconnect() {
@@ -259,30 +443,68 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
         this.db.exec(sql);
     }
     transaction(fn) {
+        return this.runTransaction(fn, 'deferred');
+    }
+    transactionImmediate(fn) {
+        return this.runTransaction(fn, 'immediate');
+    }
+    runTransaction(fn, mode) {
         if (!this.isConnected()) {
             throw new Error('Database not connected');
         }
-        this.exec('BEGIN TRANSACTION');
+        const depth = this.transactionDepth;
+        const vectorSnapshot = new Map(this.vectorCache);
+        const topicSnapshot = new Map(this.topicCache);
+        const kindSnapshot = new Map(this.kindCache);
+        const statusSnapshot = new Map(this.statusCache);
+        const savepoint = `mama_nested_${depth}`;
+        this.exec(depth === 0
+            ? mode === 'immediate'
+                ? 'BEGIN IMMEDIATE'
+                : 'BEGIN TRANSACTION'
+            : `SAVEPOINT ${savepoint}`);
+        this.transactionDepth += 1;
         try {
             const result = fn();
             if (((typeof result === 'object' && result !== null) || typeof result === 'function') &&
                 typeof result.then === 'function') {
                 throw new Error('DatabaseAdapter.transaction() callbacks must be synchronous');
             }
-            this.exec('COMMIT');
+            this.exec(depth === 0 ? 'COMMIT' : `RELEASE SAVEPOINT ${savepoint}`);
+            this.transactionDepth = depth;
             return result;
         }
         catch (error) {
+            this.vectorCache = vectorSnapshot;
+            this.topicCache = topicSnapshot;
+            this.kindCache = kindSnapshot;
+            this.statusCache = statusSnapshot;
+            this.transactionDepth = depth;
+            let cleanupError;
             try {
-                this.exec('ROLLBACK');
+                this.exec(depth === 0 ? 'ROLLBACK' : `ROLLBACK TO SAVEPOINT ${savepoint}`);
+                if (depth > 0) {
+                    this.exec(`RELEASE SAVEPOINT ${savepoint}`);
+                }
+            }
+            catch (rollbackError) {
+                cleanupError = rollbackError;
             }
-            catch {
-                // Preserve the original transaction failure when rollback also fails.
+            if (cleanupError !== undefined) {
+                const failures = [error, cleanupError];
+                try {
+                    this.disconnect();
+                }
+                catch (disconnectError) {
+                    failures.push(disconnectError);
+                    this.db = null;
+                }
+                throw new AggregateError(failures, 'Transaction settlement and rollback cleanup both failed; adapter disconnected');
             }
             throw error;
         }
     }
-    vectorSearch(embedding, limit = 5, topicPrefix, excludeStatuses) {
+    vectorSearch(embedding, limit = 5, topicPrefix, excludeStatuses, kind) {
         if (!this.isConnected()) {
             throw new Error('Database not connected');
         }
@@ -300,6 +522,13 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
                 if (!topic || !topic.startsWith(topicPrefix))
                     continue;
             }
+            // Pre-filter by memory kind so unrelated records cannot consume the top-K
+            // candidate slots before the recall layer applies its requested kind.
+            if (kind !== undefined &&
+                (Array.isArray(kind)
+                    ? !kind.some((value) => value === this.kindCache.get(rowid))
+                    : this.kindCache.get(rowid) !== kind))
+                continue;
             // Pre-filter by effective status so superseded history does not occupy
             // top-K slots (the api-layer post-filter remains the authority)
             if (excluded) {
@@ -307,7 +536,7 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
                 if (status && excluded.has(status))
                     continue;
             }
-            const similarity = (0, embeddings_js_1.cosineSimilarity)(candidate, queryVector);
+            const similarity = (0, embedder_js_1.cosineSimilarity)(candidate, queryVector);
             if (bestMatches.length < effectiveLimit) {
                 bestMatches.push({ rowid, similarity, distance: 1 - similarity });
                 if (bestMatches.length === effectiveLimit) {
@@ -349,24 +578,93 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
         const result = this.prepare('SELECT last_insert_rowid() as rowid').get();
         return result.rowid;
     }
-    runMigrations(migrationsDir) {
+    /**
+     * Run migrations from one source, or from several in order.
+     *
+     * A migration belongs to whoever wrote it, and its identity is (source,
+     * version). One author could key on the number alone; a second cannot, because
+     * the next number is already spoken for. Without this there is nowhere for a
+     * package's own table to live except inside the core.
+     *
+     * The core's source runs first and the rest follow, so a later source can
+     * reference what the core declared. A plain directory means the core's own.
+     */
+    /**
+     * Record that one source's migration ran. Before (source, version) there was
+     * one author, so the column did not exist; a database that has not reached 085
+     * yet still has the old shape and is still the core's.
+     */
+    stampMigration(sourceName, version) {
+        if (this.tableColumns('schema_version').has('source')) {
+            this.prepare('INSERT OR IGNORE INTO schema_version (source, version) VALUES (?, ?)').run(sourceName, version);
+            return;
+        }
+        this.prepare('INSERT OR IGNORE INTO schema_version (version) VALUES (?)').run(version);
+    }
+    runMigrations(sources) {
+        const list = typeof sources === 'string' ? [{ name: exports.CORE_MIGRATION_SOURCE, dir: sources }] : sources;
+        for (const source of list) {
+            this.runMigrationSource(source.dir, source.name);
+        }
+    }
+    runMigrationSource(migrationsDir, sourceName) {
         if (!this.isConnected()) {
             throw new Error('Database not connected');
         }
+        const isCore = sourceName === exports.CORE_MIGRATION_SOURCE;
         const tables = this.prepare(`
       SELECT name FROM sqlite_master
       WHERE type='table' AND name='schema_version'
     `).all();
         let currentVersion = 0;
         if (tables.length > 0) {
-            const version = this.prepare('SELECT MAX(version) as version FROM schema_version').get();
+            // Progress is per source. A shared MAX() would let one author's numbering
+            // declare another author's migrations already applied.
+            const hasSource = this.tableColumns('schema_version').has('source');
+            const version = (hasSource
+                ? this.prepare('SELECT MAX(version) as version FROM schema_version WHERE source = ?').get(sourceName)
+                : this.prepare('SELECT MAX(version) as version FROM schema_version').get());
             currentVersion = version?.version || 0;
         }
-        (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Current schema version: ${currentVersion}`);
+        (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Current schema version (${sourceName}): ${currentVersion}`);
         const migrationFiles = fs_1.default
             .readdirSync(migrationsDir)
             .filter((file) => file.endsWith('.sql'))
             .sort();
+        if (isCore &&
+            currentVersion >= 72 &&
+            fs_1.default.existsSync(path_1.default.join(migrationsDir, '072-observation-versions.sql')) &&
+            this.needsObservationVersionsRepair072()) {
+            this.recoverObservationVersionsMigration072();
+        }
+        if (isCore &&
+            currentVersion >= 73 &&
+            this.tableExists('registry_nodes') &&
+            fs_1.default.existsSync(path_1.default.join(migrationsDir, '073-registry-corrections.sql')) &&
+            this.needsRegistryCorrectionsRepair073()) {
+            this.recoverRegistryCorrectionsMigration073(migrationsDir);
+        }
+        if (isCore &&
+            currentVersion >= 74 &&
+            this.tableExists('twin_edges') &&
+            fs_1.default.existsSync(path_1.default.join(migrationsDir, '074-work-graph-ref-kinds.sql')) &&
+            this.needsWorkGraphRefsRepair074()) {
+            this.recoverWorkGraphRefsMigration074();
+        }
+        if (isCore &&
+            currentVersion >= 77 &&
+            this.tableExists('decisions') &&
+            fs_1.default.existsSync(path_1.default.join(migrationsDir, '077-legacy-record-kind.sql')) &&
+            !this.legacyRecordKindShape077()) {
+            this.recoverLegacyRecordKindMigration077();
+        }
+        if (isCore &&
+            currentVersion >= 79 &&
+            this.tableExists('twin_edges') &&
+            fs_1.default.existsSync(path_1.default.join(migrationsDir, '079-twin-edge-relations.sql')) &&
+            this.needsTwinEdgeRelationsRepair079()) {
+            this.recoverTwinEdgeRelationsMigration079();
+        }
         for (const file of migrationFiles) {
             const versionMatch = file.match(/^(\d+)-/);
             if (!versionMatch) {
@@ -376,6 +674,100 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
             if (version <= currentVersion) {
                 continue;
             }
+            if (isCore && version === 98) {
+                const decisionColumns = this.tableColumns('decisions');
+                if (!this.tableExists('decisions_fts') ||
+                    !WORKFLOW_KIND_MIGRATION_COLUMNS.every((column) => decisionColumns.has(column))) {
+                    (0, debug_logger_js_1.warn)(`[node-sqlite-adapter] Migration ${file} deferred: the full decisions projection is not present`);
+                    continue;
+                }
+                this.rebuildWorkflowMemoryKind098(migrationsDir);
+                this.stampMigration(sourceName, version);
+                (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migration ${file} reconciled successfully`);
+                continue;
+            }
+            // Runtime MetricsStore may already own project_id/channel_id. Reconcile
+            // this additive migration atomically instead of accepting a duplicate skip.
+            if (isCore && version === 68) {
+                if (!this.tableExists('tool_traces')) {
+                    // Legacy version ledgers can have skipped 033; the structural repair
+                    // below creates its table before reconciling 068. Do not stamp it yet.
+                    continue;
+                }
+                this.recoverToolTraceDiagnosticsMigration068();
+                (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migration ${file} reconciled successfully`);
+                continue;
+            }
+            // Relaxing tool_traces.model_run_id to nullable and adding the operation
+            // origin CHECK needs a table rebuild that also preserves any extra runtime
+            // columns/indexes a live database carries - more than the static SQL file
+            // can express. Reconcile with a dynamic rebuild instead of exec'ing the SQL.
+            if (isCore && version === 71) {
+                if (!this.tableExists('tool_traces')) {
+                    // A legacy ledger may have skipped 033; the structural repair below
+                    // creates the table first, then this rebuild reconciles it. Do not
+                    // stamp 71 yet.
+                    continue;
+                }
+                this.recoverServiceOperationOriginsMigration071();
+                (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migration ${file} reconciled successfully`);
+                continue;
+            }
+            if (isCore && version === 72) {
+                // `observation_versions` is the core's own table. This used to skip the
+                // migration entirely when `connector_event_index` was absent -- back when
+                // the connector index WAS the substrate -- so a consumer without the
+                // connector package silently got no observations at all, and every later
+                // migration touching them was swallowed as "no such table".
+                if (!this.tableExists('observation_versions')) {
+                    this.exec(fs_1.default.readFileSync(path_1.default.join(migrationsDir, file), 'utf8'));
+                    this.stampMigration(sourceName, version);
+                    (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migration ${file} applied`);
+                    continue;
+                }
+                this.recoverObservationVersionsMigration072();
+                (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migration ${file} reconciled successfully`);
+                continue;
+            }
+            if (isCore && version === 73) {
+                this.recoverRegistryCorrectionsMigration073(migrationsDir);
+                (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migration ${file} reconciled successfully`);
+                continue;
+            }
+            if (isCore && version === 74) {
+                if (!this.tableExists('twin_edges')) {
+                    continue;
+                }
+                this.recoverWorkGraphRefsMigration074();
+                (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migration ${file} reconciled successfully`);
+                continue;
+            }
+            if (isCore && version === 77) {
+                this.recoverLegacyRecordKindMigration077();
+                (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migration ${file} reconciled successfully`);
+                continue;
+            }
+            // Extending the twin_edges relation CHECK needs the same dynamic rebuild
+            // as 074 so custom columns, indexes, triggers, and FK children survive;
+            // the static SQL file cannot express that. Reconcile instead of exec'ing.
+            if (isCore && version === 79) {
+                if (!this.tableExists('twin_edges')) {
+                    continue;
+                }
+                this.recoverTwinEdgeRelationsMigration079();
+                (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migration ${file} reconciled successfully`);
+                continue;
+            }
+            if (isCore && version === 92) {
+                // Legacy high-version stores may carry only a skeletal decisions table.
+                // An external-content FTS rebuild cannot read columns that do not exist;
+                // leave this migration unstamped until the canonical table is present.
+                const columns = this.tableColumns('decisions');
+                if (!['topic', 'decision', 'reasoning'].every((column) => columns.has(column))) {
+                    (0, debug_logger_js_1.warn)(`[node-sqlite-adapter] Migration ${file} deferred: decisions content is incomplete`);
+                    continue;
+                }
+            }
             const migrationPath = path_1.default.join(migrationsDir, file);
             const migrationSQL = fs_1.default.readFileSync(migrationPath, 'utf8');
             (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Applying migration: ${file}`);
@@ -383,7 +775,7 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
                 this.exec('BEGIN TRANSACTION');
                 this.exec(migrationSQL);
                 this.exec('COMMIT');
-                this.prepare('INSERT OR IGNORE INTO schema_version (version) VALUES (?)').run(version);
+                this.stampMigration(sourceName, version);
                 (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migration ${file} applied successfully`);
             }
             catch (err) {
@@ -394,43 +786,9 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
                     (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migration ${file} recovered successfully`);
                     continue;
                 }
-                if (message.includes('duplicate column') && version === 34) {
-                    this.recoverConnectorEventScopeMigration034();
-                    (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migration ${file} recovered successfully`);
-                    continue;
-                }
-                if (message.includes('duplicate column') && version === 39) {
-                    this.recoverConnectorEventOperatorSeqMigration039();
-                    (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migration ${file} recovered successfully`);
-                    continue;
-                }
-                if (message.includes('duplicate column') && version === 62) {
-                    this.recoverConnectorEventSequencesMigration062();
-                    (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migration ${file} recovered successfully`);
-                    continue;
-                }
-                if (message.includes('duplicate column') && version === 67) {
-                    this.recoverConnectorEventSourceEntityIdMigration067();
-                    (0, debug_logger_js_1.info)(`[node-sqlite-adapter] Migration ${file} recovered successfully`);
-                    continue;
-                }
-                if (message.includes('no such column') && version === 62) {
-                    (0, debug_logger_js_1.warn)(`[node-sqlite-adapter] Migration ${file} deferred until connector structure recovery (${message})`);
-                    continue;
-                }
-                if (version === 63 &&
-                    (message.includes('no such column') || message.includes('no such table'))) {
-                    (0, debug_logger_js_1.warn)(`[node-sqlite-adapter] Migration ${file} deferred until connector structure recovery (${message})`);
-                    continue;
-                }
-                if (version === 67 &&
-                    (message.includes('no such column') || message.includes('no such table'))) {
-                    (0, debug_logger_js_1.warn)(`[node-sqlite-adapter] Migration ${file} deferred until connector structure recovery (${message})`);
-                    continue;
-                }
                 if (message.includes('duplicate column')) {
                     (0, debug_logger_js_1.warn)(`[node-sqlite-adapter] Migration ${file} skipped (duplicate column - already applied)`);
-                    this.prepare('INSERT OR IGNORE INTO schema_version (version) VALUES (?)').run(version);
+                    this.stampMigration(sourceName, version);
                     continue;
                 }
                 if (message.includes('no such table')) {
@@ -440,14 +798,16 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
                         throw new Error(`Migration ${file} failed: ${message}`);
                     }
                     (0, debug_logger_js_1.warn)(`[node-sqlite-adapter] Migration ${file} skipped: ALTER TABLE on non-existent table (${message})`);
-                    this.prepare('INSERT OR IGNORE INTO schema_version (version) VALUES (?)').run(version);
+                    this.stampMigration(sourceName, version);
                     continue;
                 }
                 (0, debug_logger_js_1.error)(`[node-sqlite-adapter] Migration ${file} failed:`, err);
                 throw new Error(`Migration ${file} failed: ${message}`);
             }
         }
-        this.repairSkippedFeatureMigrations(migrationsDir);
+        if (isCore) {
+            this.repairSkippedFeatureMigrations(migrationsDir);
+        }
         const embeddingsTables = this.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='embeddings'`).all();
         if (embeddingsTables.length === 0) {
             throw new Error('Embeddings table is missing after migrations. Add the required embeddings migration.');
@@ -455,6 +815,7 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
         this.migrateFromVssMemories();
     }
     repairSkippedFeatureMigrations(migrationsDir) {
+        this.repairRegistryIdentityStructures(migrationsDir);
         if (this.tableExists('decisions')) {
             const decisionColumns = this.tableColumns('decisions');
             const hasMissingMemoryProvenanceColumn = [
@@ -479,66 +840,61 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
         if (!this.tableExists('model_runs') || !this.tableExists('tool_traces')) {
             this.applyRepairMigration(migrationsDir, '033-create-model-runs-and-tool-traces.sql', 'model run provenance');
         }
-        if (this.tableExists('connector_event_index')) {
-            const connectorColumns = this.tableColumns('connector_event_index');
-            const hasMissingConnectorScopeColumn = [
-                'source_cursor',
-                'tenant_id',
-                'project_id',
-                'memory_scope_kind',
-                'memory_scope_id',
-            ].some((column) => !connectorColumns.has(column));
-            if (hasMissingConnectorScopeColumn) {
-                this.recoverConnectorEventScopeMigration034();
-                (0, debug_logger_js_1.info)('[node-sqlite-adapter] Repaired skipped connector event scope migration');
-            }
-            const connectorColumnsAfterScopeRepair = this.tableColumns('connector_event_index');
-            const hasMissingOperatorSeqFeature = !connectorColumnsAfterScopeRepair.has('operator_ingest_seq') ||
-                !this.tableExists('connector_event_index_operator_seq_cursors') ||
-                !this.indexExists('idx_connector_event_index_operator_scope_seq') ||
-                !this.indexExists('idx_connector_event_index_operator_cursor_order') ||
-                !this.triggerExists('trg_connector_event_index_operator_ingest_seq_ai') ||
-                !this.triggerExists('trg_connector_event_index_operator_ingest_seq_explicit_ai') ||
-                !this.schemaVersionExists(39);
-            if (hasMissingOperatorSeqFeature) {
-                this.recoverConnectorEventOperatorSeqMigration039();
-                (0, debug_logger_js_1.info)('[node-sqlite-adapter] Repaired skipped connector event operator sequence migration');
-            }
-            const connectorColumnsAfterOperatorSeqRepair = this.tableColumns('connector_event_index');
-            if (connectorColumnsAfterOperatorSeqRepair.has('source_timestamp_ms')) {
-                const hasMissingObservationSeqFeature = !connectorColumnsAfterOperatorSeqRepair.has('operator_observation_seq') ||
-                    !this.tableExists('connector_event_index_observation_cursors') ||
-                    !this.indexExists('idx_connector_event_index_observation_seq') ||
-                    !this.triggerExists('trg_connector_event_index_operator_ingest_seq_au') ||
-                    !this.triggerExists('trg_connector_event_index_observation_seq_ai') ||
-                    !this.triggerExists('trg_connector_event_index_observation_seq_au') ||
-                    !this.triggerExists('trg_connector_event_index_observation_seq_explicit_ai') ||
-                    !this.schemaVersionExists(62);
-                if (hasMissingObservationSeqFeature) {
-                    this.recoverConnectorEventSequencesMigration062();
-                    (0, debug_logger_js_1.info)('[node-sqlite-adapter] Repaired skipped connector event observation sequence migration');
-                }
-                const hasMissingLegacyRefreshFeature = !this.triggerExists('trg_connector_event_index_legacy_content_refresh_au') ||
-                    !this.schemaVersionExists(63);
-                if (hasMissingLegacyRefreshFeature) {
-                    this.recoverConnectorEventLegacyRefreshMigration063();
-                    (0, debug_logger_js_1.info)('[node-sqlite-adapter] Repaired skipped legacy connector event refresh migration');
-                }
-            }
-            const hasMissingSourceEntityIdFeature = !this.tableColumns('connector_event_index').has('source_entity_id') ||
-                !this.indexExists('idx_connector_event_source_entity') ||
-                !this.schemaVersionExists(67);
-            if (hasMissingSourceEntityIdFeature) {
-                this.recoverConnectorEventSourceEntityIdMigration067();
-                (0, debug_logger_js_1.info)('[node-sqlite-adapter] Repaired skipped connector event source_entity_id migration');
-            }
+        // Also repairs databases already stamped 68 by the former generic duplicate
+        // skip, which rolled back the new columns before advancing schema_version.
+        // Only enter the recovery transaction when something is actually missing --
+        // a complete database must not take the write path on every runMigrations().
+        if (fs_1.default.existsSync(path_1.default.join(migrationsDir, '068-tool-trace-diagnostics.sql')) &&
+            this.needsToolTraceDiagnosticsRepair068()) {
+            this.recoverToolTraceDiagnosticsMigration068();
+        }
+        // Runs after the 068 repair so tool_traces already carries the diagnostic
+        // columns. Only enters the rebuild when the operation-origin shape is
+        // actually missing - a complete database must not rebuild on every open.
+        if (fs_1.default.existsSync(path_1.default.join(migrationsDir, '071-service-operation-origins.sql')) &&
+            this.tableExists('tool_traces') &&
+            this.needsServiceOperationOriginsRepair071()) {
+            this.recoverServiceOperationOriginsMigration071();
+        }
+        if (fs_1.default.existsSync(path_1.default.join(migrationsDir, '072-observation-versions.sql')) &&
+            this.needsObservationVersionsRepair072()) {
+            this.recoverObservationVersionsMigration072();
+            (0, debug_logger_js_1.info)('[node-sqlite-adapter] Repaired skipped observation versions migration');
+        }
+        if (fs_1.default.existsSync(path_1.default.join(migrationsDir, '073-registry-corrections.sql')) &&
+            this.needsRegistryCorrectionsRepair073()) {
+            this.recoverRegistryCorrectionsMigration073(migrationsDir);
+            (0, debug_logger_js_1.info)('[node-sqlite-adapter] Repaired skipped registry corrections migration');
+        }
+        if (fs_1.default.existsSync(path_1.default.join(migrationsDir, '074-work-graph-ref-kinds.sql')) &&
+            this.tableExists('twin_edges') &&
+            this.needsWorkGraphRefsRepair074()) {
+            this.recoverWorkGraphRefsMigration074();
+            (0, debug_logger_js_1.info)('[node-sqlite-adapter] Repaired skipped work graph ref migration');
         }
         if (!this.tableExists('twin_edges')) {
             this.applyRepairMigration(migrationsDir, '035-create-twin-edges.sql', 'twin edge ledger');
         }
-        if (!this.tableExists('agent_situation_packets') ||
-            !this.tableExists('agent_situation_refresh_leases')) {
-            this.applyRepairMigration(migrationsDir, '036-create-agent-situation-packets.sql', 'agent situation packet cache');
+        if (fs_1.default.existsSync(path_1.default.join(migrationsDir, '072-observation-versions.sql')) &&
+            this.needsObservationVersionsRepair072()) {
+            this.recoverObservationVersionsMigration072();
+        }
+        if (fs_1.default.existsSync(path_1.default.join(migrationsDir, '073-registry-corrections.sql')) &&
+            this.needsRegistryCorrectionsRepair073()) {
+            this.recoverRegistryCorrectionsMigration073(migrationsDir);
+        }
+        if (fs_1.default.existsSync(path_1.default.join(migrationsDir, '074-work-graph-ref-kinds.sql')) &&
+            this.needsWorkGraphRefsRepair074()) {
+            this.recoverWorkGraphRefsMigration074();
+        }
+        // A database stamped >= 79 whose twin_edges was rebuilt from 035/074 above
+        // still carries the pre-079 edge_type CHECK; extend it here so the missing
+        // relation list is repaired in the same pass.
+        if (fs_1.default.existsSync(path_1.default.join(migrationsDir, '079-twin-edge-relations.sql')) &&
+            this.tableExists('twin_edges') &&
+            this.needsTwinEdgeRelationsRepair079()) {
+            this.recoverTwinEdgeRelationsMigration079();
+            (0, debug_logger_js_1.info)('[node-sqlite-adapter] Repaired skipped twin edge relations migration');
         }
         if (!this.tableExists('context_packets')) {
             this.applyRepairMigration(migrationsDir, '037-create-context-packets.sql', 'context packet store');
@@ -571,6 +927,391 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
         }
         this.assertMigration041Complete();
     }
+    repairRegistryIdentityStructures(migrationsDir) {
+        const columnsMatch = (table, expected) => {
+            if (!this.tableExists(table)) {
+                return false;
+            }
+            const rows = this.prepare(`PRAGMA table_info("${table}")`).all();
+            return (rows.length === expected.length &&
+                expected.every(([name, type, notnull, dflt, pk]) => {
+                    const row = rows.find((candidate) => candidate.name === name);
+                    return Boolean(row &&
+                        row.type.toUpperCase() === type &&
+                        row.notnull === notnull &&
+                        row.pk === pk &&
+                        row.dflt_value === dflt);
+                }));
+        };
+        const fkMatch = (table, expected) => {
+            if (!this.tableExists(table)) {
+                return false;
+            }
+            const rows = this.prepare(`PRAGMA foreign_key_list("${table}")`).all();
+            return expected.every(([from, target, to, onDelete]) => rows.some((row) => row.from === from &&
+                row.table === target &&
+                row.to === to &&
+                row.on_delete.toUpperCase() === onDelete));
+        };
+        const indexMatch = (name, columns) => {
+            if (!this.indexExists(name)) {
+                return false;
+            }
+            const rows = this.prepare(`PRAGMA index_info("${name}")`).all();
+            return (rows.length === columns.length &&
+                rows.sort((a, b) => a.seqno - b.seqno).every((row, index) => row.name === columns[index]));
+        };
+        const registrySql = this.tableExists('registry_nodes')
+            ? this.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'registry_nodes'").get()
+            : undefined;
+        const aliasSql = this.tableExists('registry_aliases')
+            ? String(this.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'registry_aliases'").get()?.sql ?? '')
+            : '';
+        const scopeSql = this.tableExists('registry_scope_bindings')
+            ? String(this.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'registry_scope_bindings'").get()?.sql ?? '')
+            : '';
+        const registryMalformed = Boolean(registrySql) &&
+            (!columnsMatch('registry_nodes', [
+                ['id', 'TEXT', 0, null, 1],
+                ['kind', 'TEXT', 1, null, 0],
+                ['name', 'TEXT', 1, null, 0],
+                ['parent_id', 'TEXT', 0, null, 0],
+                ['merged_into', 'TEXT', 0, null, 0],
+                ['merge_reason', 'TEXT', 0, null, 0],
+                ['note', 'TEXT', 0, null, 0],
+                ['created_at', 'INTEGER', 1, null, 0],
+                ['updated_at', 'INTEGER', 1, null, 0],
+            ]) ||
+                !columnsMatch('registry_aliases', [
+                    ['node_id', 'TEXT', 1, null, 0],
+                    ['kind', 'TEXT', 1, null, 1],
+                    ['alias', 'TEXT', 1, null, 2],
+                    ['alias_display', 'TEXT', 1, null, 0],
+                    ['scope_kind', 'TEXT', 1, null, 3],
+                    ['scope_id', 'TEXT', 1, null, 4],
+                    ['created_at', 'INTEGER', 1, null, 0],
+                ]) ||
+                !columnsMatch('registry_scope_bindings', [
+                    ['node_id', 'TEXT', 1, null, 1],
+                    ['scope_kind', 'TEXT', 1, null, 2],
+                    ['scope_id', 'TEXT', 1, null, 3],
+                ]) ||
+                !fkMatch('registry_nodes', [
+                    ['parent_id', 'registry_nodes', 'id', 'SET NULL'],
+                    ['merged_into', 'registry_nodes', 'id', 'SET NULL'],
+                ]) ||
+                !fkMatch('registry_aliases', [['node_id', 'registry_nodes', 'id', 'CASCADE']]) ||
+                !fkMatch('registry_scope_bindings', [['node_id', 'registry_nodes', 'id', 'CASCADE']]) ||
+                !normalizeSqlText(String(registrySql.sql ?? '')).includes(normalizeSqlText("CHECK (kind IN ('item', 'person', 'client'))")) ||
+                !normalizeSqlText(aliasSql).includes(normalizeSqlText("CHECK (kind IN ('item', 'person', 'client'))")) ||
+                !normalizeSqlText(scopeSql).includes(normalizeSqlText("CHECK (scope_kind IN ('global', 'user', 'channel', 'project'))")) ||
+                !indexMatch('idx_registry_nodes_kind', ['kind', 'merged_into']) ||
+                !indexMatch('idx_registry_nodes_parent', ['parent_id']) ||
+                !indexMatch('idx_registry_aliases_node', ['node_id']) ||
+                !indexMatch('idx_registry_aliases_scope', ['kind', 'alias', 'scope_kind', 'scope_id']) ||
+                !indexMatch('idx_registry_scope_lookup', ['scope_kind', 'scope_id', 'node_id']));
+        if (registryMalformed) {
+            this.rebuildRegistry069(migrationsDir);
+        }
+        const registryStructureMissing = !this.tableExists('registry_nodes') ||
+            !this.tableExists('registry_aliases') ||
+            !this.tableExists('registry_scope_bindings') ||
+            !this.indexExists('idx_registry_nodes_kind') ||
+            !this.indexExists('idx_registry_nodes_parent') ||
+            !this.indexExists('idx_registry_aliases_node') ||
+            !this.indexExists('idx_registry_scope_lookup');
+        if (registryStructureMissing) {
+            this.applyRepairMigration(migrationsDir, '069-create-registry-nodes.sql', 'registry nodes and aliases');
+        }
+        if (!this.tableExists('decisions')) {
+            return;
+        }
+        if (this.tableColumns('decisions').has('item_id')) {
+            const itemColumn = this.prepare('PRAGMA table_info("decisions")').all().find((column) => column.name === 'item_id');
+            if (!itemColumn ||
+                itemColumn.type.toUpperCase() !== 'TEXT' ||
+                itemColumn.notnull !== 0 ||
+                itemColumn.pk !== 0 ||
+                itemColumn.dflt_value !== null) {
+                throw new Error('Migration 070 cannot safely repair noncanonical decisions.item_id');
+            }
+        }
+        const actorSql = this.tableExists('record_actors')
+            ? this.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'record_actors'").get()
+            : undefined;
+        const actorMalformed = Boolean(actorSql) &&
+            (!columnsMatch('record_actors', [
+                ['record_id', 'TEXT', 1, null, 1],
+                ['person_id', 'TEXT', 1, null, 2],
+                ['role', 'TEXT', 1, null, 3],
+                ['position', 'INTEGER', 1, '0', 0],
+                ['created_at', 'INTEGER', 1, null, 0],
+            ]) ||
+                !fkMatch('record_actors', [['record_id', 'decisions', 'id', 'CASCADE']]) ||
+                !indexMatch('idx_record_actors_person', ['person_id', 'record_id']));
+        if (actorMalformed) {
+            this.rebuildRecordActors070();
+        }
+        const needsRecordIdentityRepair = !this.tableColumns('decisions').has('item_id') ||
+            !this.tableExists('record_actors') ||
+            !this.indexExists('idx_decisions_item') ||
+            !this.indexExists('idx_record_actors_person');
+        if (!needsRecordIdentityRepair) {
+            return;
+        }
+        this.exec('BEGIN TRANSACTION');
+        try {
+            if (!this.tableColumns('decisions').has('item_id')) {
+                this.exec('ALTER TABLE decisions ADD COLUMN item_id TEXT');
+            }
+            this.exec('CREATE INDEX IF NOT EXISTS idx_decisions_item ON decisions(item_id)');
+            this.exec(`CREATE TABLE IF NOT EXISTS record_actors (
+        record_id TEXT NOT NULL REFERENCES decisions(id) ON DELETE CASCADE,
+        person_id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        position INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY (record_id, person_id, role)
+      )`);
+            this.exec('CREATE INDEX IF NOT EXISTS idx_record_actors_person ON record_actors(person_id, record_id)');
+            this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(70, 'Record identity bindings');
+            this.exec('COMMIT');
+            (0, debug_logger_js_1.info)('[node-sqlite-adapter] Repaired skipped record identity migration');
+        }
+        catch (repairError) {
+            this.exec('ROLLBACK');
+            throw repairError;
+        }
+    }
+    rebuildRegistry069(migrationsDir) {
+        const originalTableSql = (table) => String(this.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name = ?").get(table)?.sql ?? '');
+        const extraConstraints = (table, canonicalFragments) => {
+            const clauses = splitCreateTableClauses(originalTableSql(table));
+            if (clauses.length === 0) {
+                throw new Error(`Migration 069 cannot parse ${table} definition`);
+            }
+            for (const clause of clauses.filter((candidate) => !clauseIsTableConstraint(candidate))) {
+                const normalized = normalizeSqlText(clause);
+                const hasInlineConstraint = ['check(', 'unique', 'collate', 'references'].some((token) => normalized.includes(token));
+                const columnName = clauseColumnName(clause);
+                const managedConstraint = (columnName === 'kind' && normalized.includes('check(')) ||
+                    (columnName === 'scope_kind' && normalized.includes('check(')) ||
+                    (['parent_id', 'merged_into', 'node_id'].includes(columnName) &&
+                        normalized.includes('references'));
+                if (hasInlineConstraint &&
+                    !managedConstraint &&
+                    !canonicalFragments.some((fragment) => normalized.includes(normalizeSqlText(fragment)))) {
+                    throw new Error(`Migration 069 cannot safely preserve inline constraint in ${table}`);
+                }
+            }
+            return clauses.filter((clause) => {
+                if (!clauseIsTableConstraint(clause)) {
+                    return false;
+                }
+                const normalized = normalizeSqlText(clause);
+                return !canonicalFragments.some((fragment) => normalized.includes(normalizeSqlText(fragment)));
+            });
+        };
+        const nodeExtras = extraConstraints('registry_nodes', [
+            "CHECK (kind IN ('item', 'person', 'client'))",
+            'FOREIGN KEY (parent_id) REFERENCES registry_nodes(id)',
+            'FOREIGN KEY (merged_into) REFERENCES registry_nodes(id)',
+            'REFERENCES registry_nodes(id) ON DELETE SET NULL',
+        ]);
+        const aliasExtras = this.tableExists('registry_aliases')
+            ? extraConstraints('registry_aliases', [
+                "CHECK (kind IN ('item', 'person', 'client'))",
+                'PRIMARY KEY (kind, alias, scope_kind, scope_id)',
+                // The pre-scope shape, which is exactly what this rebuild exists to
+                // convert. Listing only the post-migration spelling made every database
+                // written before alias scoping look like it carried a constraint this
+                // code does not understand, so the rebuild preserved it and emitted a
+                // CREATE TABLE with two PRIMARY KEY clauses. The daemon could not open
+                // its own older database.
+                'PRIMARY KEY (kind, alias)',
+                'FOREIGN KEY (node_id) REFERENCES registry_nodes(id)',
+                'REFERENCES registry_nodes(id) ON DELETE CASCADE',
+            ])
+            : [];
+        const scopeExtras = this.tableExists('registry_scope_bindings')
+            ? extraConstraints('registry_scope_bindings', [
+                "CHECK (scope_kind IN ('global', 'user', 'channel', 'project'))",
+                'PRIMARY KEY (node_id, scope_kind, scope_id)',
+                'FOREIGN KEY (node_id) REFERENCES registry_nodes(id)',
+                'REFERENCES registry_nodes(id) ON DELETE CASCADE',
+            ])
+            : [];
+        const nodes = this.prepare('SELECT * FROM registry_nodes').all();
+        const aliases = this.tableExists('registry_aliases')
+            ? this.prepare('SELECT * FROM registry_aliases').all()
+            : [];
+        const scopes = this.tableExists('registry_scope_bindings')
+            ? this.prepare('SELECT * FROM registry_scope_bindings').all()
+            : [];
+        const nodeIds = new Set();
+        for (const row of nodes) {
+            if (typeof row.id !== 'string' ||
+                !row.id ||
+                !['item', 'person', 'client'].includes(String(row.kind)) ||
+                typeof row.name !== 'string' ||
+                !row.name.trim()) {
+                throw new Error('Migration 069 source row violates registry node contract');
+            }
+            nodeIds.add(row.id);
+        }
+        const aliasKeys = new Set();
+        for (const row of aliases) {
+            const key = `${String(row.kind)}:${String(row.alias)}:${String(row.scope_kind ?? 'global')}:${String(row.scope_id ?? '*')}`;
+            if (!nodeIds.has(String(row.node_id)) ||
+                !['item', 'person', 'client'].includes(String(row.kind)) ||
+                typeof row.alias !== 'string' ||
+                !row.alias ||
+                aliasKeys.has(key)) {
+                throw new Error('Migration 069 source row violates registry alias contract');
+            }
+            aliasKeys.add(key);
+        }
+        const customObjects = this.prepare(`SELECT sql FROM sqlite_master
+       WHERE type IN ('index', 'trigger')
+         AND tbl_name IN ('registry_nodes', 'registry_aliases', 'registry_scope_bindings')
+         AND sql IS NOT NULL
+         AND name NOT IN (
+           'idx_registry_nodes_kind', 'idx_registry_nodes_parent',
+           'idx_registry_aliases_node', 'idx_registry_aliases_scope',
+           'idx_registry_scope_lookup'
+         )`).all();
+        let migrationSQL = fs_1.default.readFileSync(path_1.default.join(migrationsDir, '069-create-registry-nodes.sql'), 'utf8');
+        const inject = (table, extras) => {
+            if (extras.length === 0) {
+                return;
+            }
+            const pattern = new RegExp(`(CREATE TABLE IF NOT EXISTS ${table} \\([\\s\\S]*?)(\\n\\);)`);
+            if (!pattern.test(migrationSQL)) {
+                throw new Error(`Migration 069 cannot preserve ${table} constraints`);
+            }
+            migrationSQL = migrationSQL.replace(pattern, `$1,\n  ${extras.join(',\n  ')}$2`);
+        };
+        inject('registry_nodes', nodeExtras);
+        inject('registry_aliases', aliasExtras);
+        inject('registry_scope_bindings', scopeExtras);
+        const previousForeignKeys = this.readForeignKeysEnabled();
+        this.exec('PRAGMA foreign_keys = OFF');
+        if (this.readForeignKeysEnabled()) {
+            throw new Error('Migration 069 could not disable foreign_keys before rebuild');
+        }
+        try {
+            this.transaction(() => {
+                this.exec('DROP TABLE IF EXISTS registry_scope_bindings');
+                this.exec('DROP TABLE IF EXISTS registry_aliases');
+                this.exec('DROP TABLE registry_nodes');
+                this.exec(migrationSQL);
+                const insertNode = this.prepare(`INSERT INTO registry_nodes
+         (id, kind, name, parent_id, merged_into, merge_reason, note, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+                for (const row of nodes) {
+                    insertNode.run(row.id, row.kind, row.name, row.parent_id ?? null, row.merged_into ?? null, row.merge_reason ?? null, row.note ?? null, typeof row.created_at === 'number' ? row.created_at : 0, typeof row.updated_at === 'number'
+                        ? row.updated_at
+                        : typeof row.created_at === 'number'
+                            ? row.created_at
+                            : 0);
+                }
+                const insertAlias = this.prepare(`INSERT INTO registry_aliases
+         (node_id, kind, alias, alias_display, scope_kind, scope_id, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`);
+                for (const row of aliases) {
+                    insertAlias.run(row.node_id, row.kind, row.alias, typeof row.alias_display === 'string' ? row.alias_display : row.alias, typeof row.scope_kind === 'string' ? row.scope_kind : 'global', typeof row.scope_id === 'string' ? row.scope_id : '*', typeof row.created_at === 'number' ? row.created_at : 0);
+                }
+                const insertScope = this.prepare('INSERT INTO registry_scope_bindings (node_id, scope_kind, scope_id) VALUES (?, ?, ?)');
+                for (const row of scopes) {
+                    insertScope.run(row.node_id, row.scope_kind, row.scope_id);
+                }
+                for (const object of customObjects) {
+                    this.exec(object.sql);
+                }
+                const violations = this.prepare('PRAGMA foreign_key_check').all();
+                if (violations.length > 0) {
+                    throw new Error('Migration 069 repair left foreign key violations');
+                }
+            });
+        }
+        finally {
+            this.exec(`PRAGMA foreign_keys = ${previousForeignKeys ? 'ON' : 'OFF'}`);
+        }
+    }
+    rebuildRecordActors070() {
+        const originalSql = String(this.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='record_actors'").get()?.sql ?? '');
+        const actorExtras = splitCreateTableClauses(originalSql).filter((clause) => {
+            if (!clauseIsTableConstraint(clause)) {
+                return false;
+            }
+            const normalized = normalizeSqlText(clause);
+            return ![
+                'PRIMARY KEY (record_id, person_id, role)',
+                'FOREIGN KEY (record_id) REFERENCES decisions(id)',
+            ].some((fragment) => normalized.includes(normalizeSqlText(fragment)));
+        });
+        for (const clause of splitCreateTableClauses(originalSql).filter((candidate) => !clauseIsTableConstraint(candidate))) {
+            const normalized = normalizeSqlText(clause);
+            const hasInlineConstraint = ['check(', 'unique', 'collate', 'references'].some((token) => normalized.includes(token));
+            const canonicalReference = normalized.includes('record_idtextnotnullreferencesdecisions(id)ondeletecascade');
+            if (hasInlineConstraint && !canonicalReference) {
+                throw new Error('Migration 070 cannot safely preserve inline record_actors constraint');
+            }
+        }
+        const rows = this.prepare('SELECT * FROM record_actors').all();
+        const keys = new Set();
+        for (const row of rows) {
+            const key = `${String(row.record_id)}:${String(row.person_id)}:${String(row.role)}`;
+            const decision = this.prepare('SELECT 1 FROM decisions WHERE id = ?').get(row.record_id);
+            if (!decision ||
+                typeof row.person_id !== 'string' ||
+                !row.person_id ||
+                typeof row.role !== 'string' ||
+                !row.role ||
+                keys.has(key)) {
+                throw new Error('Migration 070 source row violates record actor contract');
+            }
+            keys.add(key);
+        }
+        const customObjects = this.prepare(`SELECT sql FROM sqlite_master
+       WHERE type IN ('index', 'trigger') AND tbl_name = 'record_actors'
+         AND sql IS NOT NULL AND name != 'idx_record_actors_person'`).all();
+        const previousForeignKeys = this.readForeignKeysEnabled();
+        this.exec('PRAGMA foreign_keys = OFF');
+        if (this.readForeignKeysEnabled()) {
+            throw new Error('Migration 070 could not disable foreign_keys before rebuild');
+        }
+        try {
+            this.transaction(() => {
+                this.exec('DROP TABLE record_actors');
+                this.exec(`CREATE TABLE record_actors (
+        record_id TEXT NOT NULL REFERENCES decisions(id) ON DELETE CASCADE,
+        person_id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        position INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY (record_id, person_id, role)
+        ${actorExtras.length > 0 ? `, ${actorExtras.join(', ')}` : ''}
+      )`);
+                this.exec('CREATE INDEX idx_record_actors_person ON record_actors(person_id, record_id)');
+                const insert = this.prepare(`INSERT INTO record_actors
+         (record_id, person_id, role, position, created_at) VALUES (?, ?, ?, ?, ?)`);
+                for (const row of rows) {
+                    insert.run(row.record_id, row.person_id, row.role, typeof row.position === 'number' ? row.position : 0, typeof row.created_at === 'number' ? row.created_at : 0);
+                }
+                for (const object of customObjects) {
+                    this.exec(object.sql);
+                }
+                const violations = this.prepare('PRAGMA foreign_key_check').all();
+                if (violations.length > 0) {
+                    throw new Error('Migration 070 repair left foreign key violations');
+                }
+            });
+        }
+        finally {
+            this.exec(`PRAGMA foreign_keys = ${previousForeignKeys ? 'ON' : 'OFF'}`);
+        }
+    }
     applyRepairMigration(migrationsDir, fileName, label) {
         const migrationPath = path_1.default.join(migrationsDir, fileName);
         if (!fs_1.default.existsSync(migrationPath)) {
@@ -589,6 +1330,29 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
             throw new Error(`Repair migration ${fileName} failed: ${message}`);
         }
     }
+    rebuildWorkflowMemoryKind098(migrationsDir) {
+        const migrationPath = path_1.default.join(migrationsDir, '098-workflow-memory-kind.sql');
+        if (!fs_1.default.existsSync(migrationPath)) {
+            throw new Error('Migration 098 workflow-kind rebuild SQL is missing');
+        }
+        const previousForeignKeys = this.readForeignKeysEnabled();
+        this.exec('PRAGMA foreign_keys = OFF');
+        if (this.readForeignKeysEnabled()) {
+            throw new Error('Migration 098 could not disable foreign_keys before rebuilding decisions');
+        }
+        try {
+            this.transaction(() => {
+                this.exec(fs_1.default.readFileSync(migrationPath, 'utf8'));
+            });
+            const violations = this.prepare('PRAGMA foreign_key_check').all();
+            if (violations.length > 0) {
+                throw new Error('Migration 098 left foreign key violations');
+            }
+        }
+        finally {
+            this.exec(`PRAGMA foreign_keys = ${previousForeignKeys ? 'ON' : 'OFF'}`);
+        }
+    }
     operatorMemoryCommitIntentTableSql() {
         const tableDefinition = this.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name = 'operator_memory_commit_intents'").get();
         return tableDefinition?.sql ?? '';
@@ -647,6 +1411,1149 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
             throw new Error('Migration 041 recovery failed: incompatible operator_memory_commit_intents table definition missing claim invariant');
         }
     }
+    needsToolTraceDiagnosticsRepair068() {
+        if (!this.tableExists('tool_traces')) {
+            // The table itself is missing: let the recovery helper fail loudly.
+            return true;
+        }
+        const columns = this.tableColumns('tool_traces');
+        const hasMissingColumn = [
+            'diagnostic_json',
+            'evidence_json',
+            'catalog_revision',
+            'owner_scope',
+            'project_id',
+            'channel_id',
+        ].some((column) => !columns.has(column));
+        const hasMissingIndex = [
+            'idx_tool_traces_scope_recency',
+            'idx_tool_traces_channel_recency',
+        ].some((indexName) => !this.indexExists(indexName));
+        return hasMissingColumn || hasMissingIndex || !this.schemaVersionExists(68);
+    }
+    recoverToolTraceDiagnosticsMigration068() {
+        this.transaction(() => {
+            if (!this.tableExists('tool_traces')) {
+                throw new Error('Migration 068 recovery failed: missing table tool_traces');
+            }
+            const expectedColumns = [
+                'diagnostic_json',
+                'evidence_json',
+                'catalog_revision',
+                'owner_scope',
+                'project_id',
+                'channel_id',
+            ];
+            const columns = this.tableColumns('tool_traces');
+            for (const column of expectedColumns) {
+                if (!columns.has(column)) {
+                    this.exec(`ALTER TABLE tool_traces ADD COLUMN ${column} TEXT`);
+                }
+            }
+            this.exec(`
+        CREATE INDEX IF NOT EXISTS idx_tool_traces_scope_recency
+          ON tool_traces(owner_scope, project_id, created_at DESC, trace_id DESC);
+        CREATE INDEX IF NOT EXISTS idx_tool_traces_channel_recency
+          ON tool_traces(owner_scope, project_id, channel_id, created_at DESC, trace_id DESC);
+      `);
+            const actualColumns = this.tableColumns('tool_traces');
+            for (const column of expectedColumns) {
+                if (!actualColumns.has(column)) {
+                    throw new Error(`Migration 068 recovery failed: missing tool_traces.${column}`);
+                }
+            }
+            for (const index of ['idx_tool_traces_scope_recency', 'idx_tool_traces_channel_recency']) {
+                if (!this.indexExists(index)) {
+                    throw new Error(`Migration 068 recovery failed: missing index ${index}`);
+                }
+            }
+            this.prepare('INSERT OR IGNORE INTO schema_version (version) VALUES (?)').run(68);
+        });
+    }
+    toolTracesTableSql() {
+        const row = this.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='tool_traces'").get();
+        return row?.sql ?? '';
+    }
+    tableSql(name) {
+        const row = this.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name = ?").get(name);
+        if (!row?.sql) {
+            throw new Error(`Missing CREATE TABLE definition for ${name}`);
+        }
+        return row.sql;
+    }
+    storedObjectsForTable(table, excludedIndexes = new Set()) {
+        const indexes = this.prepare("SELECT name, sql FROM sqlite_master WHERE type='index' AND tbl_name = ? AND sql IS NOT NULL").all(table)
+            .filter((row) => !excludedIndexes.has(row.name))
+            .map((row) => row.sql);
+        const triggers = this.prepare("SELECT sql FROM sqlite_master WHERE type='trigger' AND tbl_name = ? AND sql IS NOT NULL").all(table).map((row) => row.sql);
+        return { indexes, triggers };
+    }
+    tablesInForeignKeyGraph(parent) {
+        const graph = new Set([parent]);
+        const tables = this.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").all();
+        for (const { name } of tables) {
+            const refs = this.prepare('SELECT "table" AS ref FROM pragma_foreign_key_list(?)').all(name);
+            if (refs.some((ref) => ref.ref === parent)) {
+                graph.add(name);
+            }
+        }
+        return [...graph];
+    }
+    observationVersionsShape072() {
+        if (!this.tableExists('observation_versions')) {
+            return false;
+        }
+        const required = [
+            'observation_id',
+            'source',
+            'source_id',
+            'producer_version_id',
+            'body',
+            'body_location_json',
+            'author',
+            'source_at',
+            'observed_at',
+            'content_hash',
+            'metadata_json',
+            'scope_json',
+        ];
+        const columns = this.tableColumns('observation_versions');
+        const clauses = splitCreateTableClauses(this.tableSql('observation_versions'));
+        const columnClauses = new Map(clauses
+            .filter((clause) => !clauseIsTableConstraint(clause))
+            .map((clause) => [clauseColumnName(clause), normalizeSqlText(clause)]));
+        const bodyXor = normalizeSqlText('CHECK ((body IS NOT NULL AND body_location_json IS NULL) OR ' +
+            '(body IS NULL AND body_location_json IS NOT NULL))');
+        const columnInfo = new Map(this.prepare('PRAGMA table_info(observation_versions)').all().map((column) => [column.name, column]));
+        // Whether any index points AT an observation is that index's own business.
+        // This migration declares the evidence; it does not declare its readers.
+        return (required.every((column) => columns.has(column)) &&
+            required.every((column) => {
+                const expected = ['source_at', 'observed_at'].includes(column) ? 'INTEGER' : 'TEXT';
+                return columnInfo.get(column)?.type.toUpperCase() === expected;
+            }) &&
+            columnInfo.get('observation_id')?.pk === 1 &&
+            ['source', 'source_id', 'observed_at', 'content_hash', 'metadata_json', 'scope_json'].every((column) => columnInfo.get(column)?.notnull === 1) &&
+            columnClauses.get('source') ===
+                normalizeSqlText('source TEXT NOT NULL CHECK (length(trim(source)) > 0)') &&
+            columnClauses.get('source_id') ===
+                normalizeSqlText('source_id TEXT NOT NULL CHECK (length(trim(source_id)) > 0)') &&
+            columnClauses.get('content_hash') ===
+                normalizeSqlText('content_hash TEXT NOT NULL CHECK (length(trim(content_hash)) > 0)') &&
+            clauses.some((clause) => normalizeSqlText(clause) === bodyXor) &&
+            this.indexExists('observation_source_versions') &&
+            normalizeSqlText(this.indexSql('observation_source_versions')).includes('onobservation_versions(source,source_id,observed_at,observation_id)'));
+    }
+    needsObservationVersionsRepair072() {
+        return !this.observationVersionsShape072() || !this.schemaVersionExists(72);
+    }
+    recoverObservationVersionsMigration072() {
+        if (this.observationVersionsShape072()) {
+            this.transaction(() => {
+                this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(72, 'Immutable connector and owner observation versions');
+            });
+            return;
+        }
+        const canonical = new Map([
+            ['observation_id', 'observation_id TEXT PRIMARY KEY'],
+            ['source', 'source TEXT NOT NULL CHECK (length(trim(source)) > 0)'],
+            ['source_id', 'source_id TEXT NOT NULL CHECK (length(trim(source_id)) > 0)'],
+            ['producer_version_id', 'producer_version_id TEXT'],
+            ['body', 'body TEXT'],
+            ['body_location_json', 'body_location_json TEXT'],
+            ['author', 'author TEXT'],
+            ['source_at', 'source_at INTEGER'],
+            ['observed_at', 'observed_at INTEGER NOT NULL'],
+            ['content_hash', 'content_hash TEXT NOT NULL CHECK (length(trim(content_hash)) > 0)'],
+            ['metadata_json', 'metadata_json TEXT NOT NULL'],
+            ['scope_json', 'scope_json TEXT NOT NULL'],
+        ]);
+        let existingNames = [];
+        let columnDefs = [...canonical.values()];
+        let constraints = [
+            'CHECK ((body IS NOT NULL AND body_location_json IS NULL) OR ' +
+                '(body IS NULL AND body_location_json IS NOT NULL))',
+        ];
+        const bodyXor = normalizeSqlText(constraints[0]);
+        let objects = { indexes: [], triggers: [] };
+        if (this.tableExists('observation_versions')) {
+            const clauses = splitCreateTableClauses(this.tableSql('observation_versions'));
+            if (clauses.length === 0) {
+                throw new Error('Migration 072 recovery failed: unreadable observation_versions');
+            }
+            const columns = clauses.filter((clause) => !clauseIsTableConstraint(clause));
+            existingNames = columns.map(clauseColumnName);
+            const missing = [...canonical.keys()].filter((name) => !existingNames.includes(name));
+            const count = this.prepare('SELECT COUNT(*) AS count FROM observation_versions').get().count;
+            if (missing.length > 0 && count > 0) {
+                throw new Error(`Migration 072 cannot preserve populated rows missing columns: ${missing.join(', ')}`);
+            }
+            for (const clause of columns) {
+                const name = clauseColumnName(clause);
+                if (!canonical.has(name)) {
+                    continue;
+                }
+                const normalized = normalizeSqlText(clause);
+                const expected = normalizeSqlText(canonical.get(name));
+                const legacyExpected = normalizeSqlText(name === 'observation_id'
+                    ? 'observation_id TEXT PRIMARY KEY'
+                    : [
+                        'source',
+                        'source_id',
+                        'observed_at',
+                        'content_hash',
+                        'metadata_json',
+                        'scope_json',
+                    ].includes(name)
+                        ? `${name} ${['observed_at', 'source_at'].includes(name) ? 'INTEGER' : 'TEXT'} NOT NULL`
+                        : `${name} ${name === 'source_at' ? 'INTEGER' : 'TEXT'}`);
+                if (normalized !== expected &&
+                    normalized !== legacyExpected &&
+                    /collate|generated|references|\bunique\b|\bcheck\b/i.test(clause)) {
+                    throw new Error(`Migration 072 cannot safely preserve inline constraint on ${name}`);
+                }
+            }
+            const extras = columns.filter((clause) => !canonical.has(clauseColumnName(clause)));
+            columnDefs = [...canonical.values(), ...extras];
+            const customConstraints = clauses.filter((clause) => clauseIsTableConstraint(clause) &&
+                !(normalizeSqlText(clause).includes('bodyisnotnullandbody_location_jsonisnull') &&
+                    normalizeSqlText(clause).includes('bodyisnullandbody_location_jsonisnotnull')));
+            for (const constraint of clauses.filter(clauseIsTableConstraint)) {
+                const normalizedConstraint = normalizeSqlText(constraint);
+                if ((normalizedConstraint.includes('body') ||
+                    normalizedConstraint.includes('body_location_json')) &&
+                    normalizedConstraint !== bodyXor) {
+                    throw new Error('Migration 072 cannot safely preserve conflicting body CHECK');
+                }
+            }
+            constraints = [...constraints, ...customConstraints];
+            objects = this.storedObjectsForTable('observation_versions', new Set(['observation_source_versions']));
+        }
+        const previousForeignKeys = this.readForeignKeysEnabled();
+        this.exec('PRAGMA foreign_keys = OFF');
+        if (this.readForeignKeysEnabled()) {
+            throw new Error('Migration 072 recovery failed: could not disable foreign_keys');
+        }
+        try {
+            this.transaction(() => {
+                if (this.tableExists('observation_versions')) {
+                    this.exec(`CREATE TABLE observation_versions_072_new (\n  ${[...columnDefs, ...constraints].join(',\n  ')}\n)`);
+                    if (existingNames.length > 0) {
+                        const columns = existingNames.map(quoteSqlIdentifier).join(', ');
+                        this.exec(`INSERT INTO observation_versions_072_new (${columns}) SELECT ${columns} FROM observation_versions`);
+                    }
+                    this.exec('DROP TABLE observation_versions');
+                    this.exec('ALTER TABLE observation_versions_072_new RENAME TO observation_versions');
+                }
+                else {
+                    this.exec(`CREATE TABLE observation_versions (\n  ${[...columnDefs, ...constraints].join(',\n  ')}\n)`);
+                }
+                for (const sql of objects.indexes) {
+                    this.exec(sql);
+                }
+                this.exec('CREATE INDEX observation_source_versions ON observation_versions(source, source_id, observed_at, observation_id)');
+                for (const sql of objects.triggers) {
+                    this.exec(sql);
+                }
+                if (!this.observationVersionsShape072()) {
+                    throw new Error('Migration 072 recovery failed: incomplete observation shape');
+                }
+                for (const table of this.tablesInForeignKeyGraph('observation_versions')) {
+                    if (this.prepare('SELECT 1 FROM pragma_foreign_key_check(?)').all(table).length > 0) {
+                        throw new Error(`Migration 072 recovery failed: foreign key violations after rebuild (${table})`);
+                    }
+                }
+                this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(72, 'Immutable connector and owner observation versions');
+            });
+        }
+        finally {
+            this.exec(`PRAGMA foreign_keys = ${previousForeignKeys ? 'ON' : 'OFF'}`);
+        }
+    }
+    registryCorrectionsShape073() {
+        const expected = new Map([
+            ['registry_identity_state', ['singleton', 'revision']],
+            [
+                'registry_corrections',
+                [
+                    'command_id',
+                    'operation',
+                    'expected_revision',
+                    'committed_revision',
+                    'principal_id',
+                    'agent_id',
+                    'origin',
+                    'payload_json',
+                    'reason',
+                    'evidence_json',
+                    'scope_json',
+                    'receipt_json',
+                    'created_at',
+                ],
+            ],
+            [
+                'registry_ref_assignments',
+                [
+                    'command_id',
+                    'edge_id',
+                    'endpoint',
+                    'original_kind',
+                    'original_id',
+                    'resolved_node_id',
+                    'committed_revision',
+                    'created_at',
+                ],
+            ],
+        ]);
+        if (!([...expected].every(([table, columns]) => this.tableExists(table) &&
+            columns.every((column) => this.tableColumns(table).has(column))) &&
+            this.indexExists('idx_registry_ref_assignments_current') &&
+            normalizeSqlText(this.indexSql('idx_registry_ref_assignments_current')).includes('onregistry_ref_assignments(edge_id,endpoint,committed_revisiondesc)'))) {
+            return false;
+        }
+        const stateSql = normalizeSqlText(this.tableSql('registry_identity_state'));
+        const correctionsSql = normalizeSqlText(this.tableSql('registry_corrections'));
+        const assignmentsSql = normalizeSqlText(this.tableSql('registry_ref_assignments'));
+        const correctionClauses = splitCreateTableClauses(this.tableSql('registry_corrections'));
+        const aggregateAuthorityCheck = normalizeSqlText(`CHECK (
+        (origin = 'trusted' AND principal_id IS NOT NULL AND length(trim(principal_id)) > 0
+          AND agent_id IS NOT NULL AND length(trim(agent_id)) > 0)
+        OR (origin = 'legacy_unattributed' AND principal_id IS NULL AND agent_id IS NULL)
+      )`);
+        const stateRows = this.prepare('SELECT singleton, revision FROM registry_identity_state ORDER BY singleton').all();
+        const correctionInfo = new Map(this.prepare('PRAGMA table_info(registry_corrections)').all().map((column) => [column.name, column]));
+        const assignmentInfo = new Map(this.prepare('PRAGMA table_info(registry_ref_assignments)').all().map((column) => [column.name, column]));
+        const assignmentFks = this.prepare('SELECT "from" AS from_col, "table" AS target, "to" AS to_col, on_delete FROM pragma_foreign_key_list(?)').all('registry_ref_assignments');
+        return (stateSql.includes('singletonintegerprimarykeycheck(singleton=1)') &&
+            stateSql.includes('revisionintegernotnullcheck(revision>=0)') &&
+            stateRows.length === 1 &&
+            stateRows[0]?.singleton === 1 &&
+            Number.isSafeInteger(stateRows[0]?.revision) &&
+            (stateRows[0]?.revision ?? -1) >= 0 &&
+            correctionInfo.get('command_id')?.pk === 1 &&
+            [
+                'command_id',
+                'operation',
+                'expected_revision',
+                'committed_revision',
+                'principal_id',
+                'agent_id',
+                'origin',
+                'payload_json',
+                'reason',
+                'evidence_json',
+                'scope_json',
+                'receipt_json',
+                'created_at',
+            ].every((name) => {
+                const column = correctionInfo.get(name);
+                return ['expected_revision', 'committed_revision', 'created_at'].includes(name)
+                    ? column?.type.toUpperCase() === 'INTEGER'
+                    : column?.type.toUpperCase() === 'TEXT';
+            }) &&
+            [
+                'operation',
+                'expected_revision',
+                'committed_revision',
+                'origin',
+                'payload_json',
+                'reason',
+                'evidence_json',
+                'scope_json',
+                'receipt_json',
+                'created_at',
+            ].every((column) => correctionInfo.get(column)?.notnull === 1) &&
+            correctionsSql.includes("operationin('add_alias','merge','split','assign_refs')") &&
+            correctionsSql.includes('expected_revision>=0') &&
+            correctionsSql.includes('committed_revisionintegernotnullunique') &&
+            correctionsSql.includes('committed_revision>expected_revision') &&
+            correctionsSql.includes("originin('trusted','legacy_unattributed')") &&
+            correctionsSql.includes('length(trim(reason))>0') &&
+            correctionClauses.some((clause) => normalizeSqlText(clause) === aggregateAuthorityCheck) &&
+            assignmentInfo.get('command_id')?.pk === 1 &&
+            [
+                'command_id',
+                'edge_id',
+                'endpoint',
+                'original_kind',
+                'original_id',
+                'resolved_node_id',
+                'committed_revision',
+                'created_at',
+            ].every((name) => {
+                const column = assignmentInfo.get(name);
+                return ['committed_revision', 'created_at'].includes(name)
+                    ? column?.type.toUpperCase() === 'INTEGER'
+                    : column?.type.toUpperCase() === 'TEXT';
+            }) &&
+            assignmentInfo.get('edge_id')?.pk === 2 &&
+            assignmentInfo.get('endpoint')?.pk === 3 &&
+            [
+                'command_id',
+                'edge_id',
+                'endpoint',
+                'original_kind',
+                'original_id',
+                'committed_revision',
+                'created_at',
+            ].every((column) => assignmentInfo.get(column)?.notnull === 1) &&
+            assignmentInfo.get('resolved_node_id')?.notnull === 0 &&
+            assignmentsSql.includes("endpointin('from','to')") &&
+            assignmentFks.some((fk) => fk.from_col === 'command_id' &&
+                fk.target === 'registry_corrections' &&
+                fk.to_col === 'command_id' &&
+                fk.on_delete.toUpperCase() === 'CASCADE') &&
+            assignmentFks.some((fk) => fk.from_col === 'resolved_node_id' && fk.target === 'registry_nodes' && fk.to_col === 'id'));
+    }
+    needsRegistryCorrectionsRepair073() {
+        return !this.registryCorrectionsShape073() || !this.schemaVersionExists(73);
+    }
+    recoverRegistryCorrectionsMigration073(migrationsDir) {
+        const tables = ['registry_identity_state', 'registry_corrections', 'registry_ref_assignments'];
+        const malformed = tables.filter((table) => this.tableExists(table) &&
+            !(table === 'registry_identity_state'
+                ? ['singleton', 'revision']
+                : table === 'registry_corrections'
+                    ? [
+                        'command_id',
+                        'operation',
+                        'expected_revision',
+                        'committed_revision',
+                        'principal_id',
+                        'agent_id',
+                        'origin',
+                        'payload_json',
+                        'reason',
+                        'evidence_json',
+                        'scope_json',
+                        'receipt_json',
+                        'created_at',
+                    ]
+                    : [
+                        'command_id',
+                        'edge_id',
+                        'endpoint',
+                        'original_kind',
+                        'original_id',
+                        'resolved_node_id',
+                        'committed_revision',
+                        'created_at',
+                    ]).every((column) => this.tableColumns(table).has(column)));
+        const allTablesPresent = tables.every((table) => this.tableExists(table));
+        for (const table of tables) {
+            if (!this.tableExists(table)) {
+                continue;
+            }
+            const requiredColumns = table === 'registry_identity_state'
+                ? ['singleton', 'revision']
+                : table === 'registry_corrections'
+                    ? [
+                        'command_id',
+                        'operation',
+                        'expected_revision',
+                        'committed_revision',
+                        'principal_id',
+                        'agent_id',
+                        'origin',
+                        'payload_json',
+                        'reason',
+                        'evidence_json',
+                        'scope_json',
+                        'receipt_json',
+                        'created_at',
+                    ]
+                    : [
+                        'command_id',
+                        'edge_id',
+                        'endpoint',
+                        'original_kind',
+                        'original_id',
+                        'resolved_node_id',
+                        'committed_revision',
+                        'created_at',
+                    ];
+            if (allTablesPresent &&
+                requiredColumns.every((column) => this.tableColumns(table).has(column)) &&
+                !this.registryCorrectionsShape073()) {
+                throw new Error(`Migration 073 cannot safely repair structurally incompatible table ${table}`);
+            }
+        }
+        for (const table of malformed) {
+            const count = this.prepare(`SELECT COUNT(*) AS count FROM ${quoteSqlIdentifier(table)}`).get().count;
+            if (count > 0) {
+                throw new Error(`Migration 073 cannot safely repair populated incompatible table ${table}`);
+            }
+            const excluded = table === 'registry_ref_assignments'
+                ? new Set(['idx_registry_ref_assignments_current'])
+                : new Set();
+            const objects = this.storedObjectsForTable(table, excluded);
+            if (objects.indexes.length > 0 ||
+                objects.triggers.length > 0 ||
+                this.tablesInForeignKeyGraph(table).length > 1 ||
+                /\b(?:check|unique|references)\b/i.test(this.tableSql(table))) {
+                throw new Error(`Migration 073 cannot safely replace incompatible table ${table}`);
+            }
+        }
+        const sql = fs_1.default.readFileSync(path_1.default.join(migrationsDir, '073-registry-corrections.sql'), 'utf8');
+        this.transaction(() => {
+            if (malformed.includes('registry_ref_assignments')) {
+                this.exec('DROP TABLE registry_ref_assignments');
+            }
+            if (malformed.includes('registry_corrections')) {
+                this.exec('DROP TABLE registry_corrections');
+            }
+            if (malformed.includes('registry_identity_state')) {
+                this.exec('DROP TABLE registry_identity_state');
+            }
+            this.exec(sql);
+            if (!this.registryCorrectionsShape073()) {
+                throw new Error('Migration 073 recovery failed: incomplete correction shape');
+            }
+            this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(73, 'Atomic scoped registry correction history');
+        });
+    }
+    workGraphRefsShape074() {
+        if (!this.tableExists('twin_edges')) {
+            return false;
+        }
+        const clauses = splitCreateTableClauses(this.tableSql('twin_edges'));
+        const columnClauses = new Map(clauses
+            .filter((clause) => !clauseIsTableConstraint(clause))
+            .map((clause) => [clauseColumnName(clause), normalizeSqlText(clause)]));
+        // 079 extends the relation list with 'refines','contradicts','amends'; a
+        // table already at that shape satisfies the 074 endpoint contract too.
+        const edgeTypeClause = clauses.find((clause) => !clauseIsTableConstraint(clause) && clauseColumnName(clause) === 'edge_type');
+        const edgeTypeOk = edgeTypeClause !== undefined &&
+            [
+                "edge_type TEXT NOT NULL CHECK (edge_type IN ('supersedes','builds_on','debates','synthesizes','mentions','derived_from','case_member','alias_of','next_action_for','blocks'))",
+                "edge_type TEXT NOT NULL CHECK (edge_type IN ('supersedes','refines','contradicts','builds_on','debates','synthesizes','mentions','derived_from','case_member','alias_of','next_action_for','blocks','amends'))",
+            ].some((definition) => normalizeSqlText(edgeTypeClause) === normalizeSqlText(definition));
+        const exactColumns = new Map([
+            [
+                'confidence',
+                'confidence REAL NOT NULL DEFAULT 1.0 CHECK (confidence >= 0.0 AND confidence <= 1.0)',
+            ],
+            ['source', "source TEXT NOT NULL CHECK (source IN ('agent','human','code'))"],
+            ['content_hash', 'content_hash BLOB NOT NULL CHECK(length(content_hash)=32)'],
+        ]);
+        const required = [
+            'edge_id',
+            'edge_type',
+            'subject_kind',
+            'subject_id',
+            'object_kind',
+            'object_id',
+            'relation_attrs_json',
+            'confidence',
+            'source',
+            'agent_id',
+            'model_run_id',
+            'envelope_hash',
+            'human_actor_id',
+            'human_actor_role',
+            'authority_scope_json',
+            'reason_classification',
+            'reason_text',
+            'evidence_refs_json',
+            'request_idempotency_key',
+            'edge_idempotency_key',
+            'content_hash',
+            'created_at',
+        ];
+        const info = new Map(this.prepare('PRAGMA table_info(twin_edges)').all().map((column) => [column.name, column]));
+        return (required.every((column) => info.has(column)) &&
+            required.every((column) => {
+                const expected = column === 'confidence'
+                    ? 'REAL'
+                    : column === 'created_at'
+                        ? 'INTEGER'
+                        : column === 'content_hash'
+                            ? 'BLOB'
+                            : 'TEXT';
+                return info.get(column)?.type.toUpperCase() === expected;
+            }) &&
+            info.get('edge_id')?.pk === 1 &&
+            [
+                'edge_type',
+                'subject_kind',
+                'subject_id',
+                'object_kind',
+                'object_id',
+                'confidence',
+                'source',
+                'content_hash',
+                'created_at',
+            ].every((column) => info.get(column)?.notnull === 1) &&
+            edgeTypeOk &&
+            [...exactColumns].every(([name, definition]) => columnClauses.get(name) === normalizeSqlText(definition)) &&
+            clauses.some((clause) => !clauseIsTableConstraint(clause) &&
+                clauseColumnName(clause) === 'subject_kind' &&
+                normalizeSqlText(clause) ===
+                    normalizeSqlText("subject_kind TEXT NOT NULL CHECK (subject_kind IN ('memory','case','entity','report','edge','registry','observation'))")) &&
+            clauses.some((clause) => !clauseIsTableConstraint(clause) &&
+                clauseColumnName(clause) === 'object_kind' &&
+                normalizeSqlText(clause) ===
+                    normalizeSqlText("object_kind TEXT NOT NULL CHECK (object_kind IN ('memory','case','entity','report','edge','raw','registry','observation'))")) &&
+            !clauses.some((clause) => clauseIsTableConstraint(clause) && /\b(?:subject_kind|object_kind)\b/i.test(clause)) &&
+            this.indexExists('idx_twin_edges_subject') &&
+            this.indexExists('idx_twin_edges_object') &&
+            this.indexExists('idx_twin_edges_model_run_id') &&
+            this.indexExists('idx_twin_edges_request_idempotency') &&
+            this.indexExists('ux_twin_edges_model_run_edge_idempotency') &&
+            normalizeSqlText(this.indexSql('idx_twin_edges_subject')).includes('ontwin_edges(subject_kind,subject_id,created_atdesc)') &&
+            normalizeSqlText(this.indexSql('idx_twin_edges_object')).includes('ontwin_edges(object_kind,object_id,created_atdesc)') &&
+            normalizeSqlText(this.indexSql('idx_twin_edges_model_run_id')).includes('ontwin_edges(model_run_id,created_atdesc)') &&
+            normalizeSqlText(this.indexSql('idx_twin_edges_request_idempotency')).includes('ontwin_edges(model_run_id,request_idempotency_key,created_atdesc)wheremodel_run_idisnotnullandrequest_idempotency_keyisnotnull') &&
+            normalizeSqlText(this.indexSql('ux_twin_edges_model_run_edge_idempotency')).includes('uniqueindexux_twin_edges_model_run_edge_idempotencyontwin_edges(model_run_id,edge_idempotency_key)wheremodel_run_idisnotnullandedge_idempotency_keyisnotnull'));
+    }
+    needsWorkGraphRefsRepair074() {
+        return !this.workGraphRefsShape074() || !this.schemaVersionExists(74);
+    }
+    recoverWorkGraphRefsMigration074() {
+        if (!this.tableExists('twin_edges')) {
+            throw new Error('Migration 074 recovery failed: missing twin_edges');
+        }
+        if (this.workGraphRefsShape074()) {
+            this.transaction(() => {
+                this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(74, 'Registry and observation work graph references');
+            });
+            return;
+        }
+        const clauses = splitCreateTableClauses(this.tableSql('twin_edges'));
+        if (clauses.length === 0) {
+            throw new Error('Migration 074 recovery failed: unreadable twin_edges');
+        }
+        const existingColumns = [];
+        const columns = [];
+        const constraints = [];
+        const subjectDef = "subject_kind TEXT NOT NULL CHECK (subject_kind IN ('memory','case','entity','report','edge','registry','observation'))";
+        const objectDef = "object_kind TEXT NOT NULL CHECK (object_kind IN ('memory','case','entity','report','edge','raw','registry','observation'))";
+        const legacySubjectDef = normalizeSqlText("subject_kind TEXT NOT NULL CHECK (subject_kind IN ('memory','case','entity','report','edge'))");
+        const legacyObjectDef = normalizeSqlText("object_kind TEXT NOT NULL CHECK (object_kind IN ('memory','case','entity','report','edge','raw'))");
+        const exactProtectedColumns = new Map([
+            [
+                'confidence',
+                'confidence REAL NOT NULL DEFAULT 1.0 CHECK (confidence >= 0.0 AND confidence <= 1.0)',
+            ],
+            ['source', "source TEXT NOT NULL CHECK (source IN ('agent','human','code'))"],
+            ['content_hash', 'content_hash BLOB NOT NULL CHECK(length(content_hash)=32)'],
+        ]);
+        // The edge_type CHECK was extended by migration 079; a table carrying the
+        // newer relation list is preserved as-is instead of being rebuilt down.
+        const allowedEdgeTypeDefs = new Set([
+            "edge_type TEXT NOT NULL CHECK (edge_type IN ('supersedes','builds_on','debates','synthesizes','mentions','derived_from','case_member','alias_of','next_action_for','blocks'))",
+            "edge_type TEXT NOT NULL CHECK (edge_type IN ('supersedes','refines','contradicts','builds_on','debates','synthesizes','mentions','derived_from','case_member','alias_of','next_action_for','blocks','amends'))",
+        ].map(normalizeSqlText));
+        for (const clause of clauses) {
+            if (clauseIsTableConstraint(clause)) {
+                if (/\b(?:subject_kind|object_kind)\b/i.test(clause)) {
+                    throw new Error('Migration 074 cannot safely preserve conflicting endpoint CHECK');
+                }
+                constraints.push(clause);
+                continue;
+            }
+            const name = clauseColumnName(clause);
+            existingColumns.push(name);
+            if (name === 'subject_kind') {
+                const normalizedClause = normalizeSqlText(clause);
+                if (normalizedClause !== legacySubjectDef &&
+                    normalizedClause !== normalizeSqlText(subjectDef)) {
+                    throw new Error('Migration 074 cannot safely preserve inline constraint on subject_kind');
+                }
+                columns.push(subjectDef);
+            }
+            else if (name === 'object_kind') {
+                const normalizedClause = normalizeSqlText(clause);
+                if (normalizedClause !== legacyObjectDef &&
+                    normalizedClause !== normalizeSqlText(objectDef)) {
+                    throw new Error('Migration 074 cannot safely preserve inline constraint on object_kind');
+                }
+                columns.push(objectDef);
+            }
+            else if (name === 'edge_type') {
+                if (!allowedEdgeTypeDefs.has(normalizeSqlText(clause))) {
+                    throw new Error('Migration 074 cannot safely preserve inline constraint on edge_type');
+                }
+                columns.push(clause);
+            }
+            else if (exactProtectedColumns.has(name)) {
+                if (normalizeSqlText(clause) !== normalizeSqlText(exactProtectedColumns.get(name))) {
+                    throw new Error(`Migration 074 cannot safely preserve inline constraint on ${name}`);
+                }
+                columns.push(clause);
+            }
+            else {
+                columns.push(clause);
+            }
+        }
+        const objects = this.storedObjectsForTable('twin_edges', new Set([
+            'idx_twin_edges_subject',
+            'idx_twin_edges_object',
+            'idx_twin_edges_model_run_id',
+            'idx_twin_edges_request_idempotency',
+            'ux_twin_edges_model_run_edge_idempotency',
+        ]));
+        const previousForeignKeys = this.readForeignKeysEnabled();
+        this.exec('PRAGMA foreign_keys = OFF');
+        if (this.readForeignKeysEnabled()) {
+            throw new Error('Migration 074 recovery failed: could not disable foreign_keys');
+        }
+        try {
+            this.transaction(() => {
+                this.exec(`CREATE TABLE twin_edges_074_new (\n  ${[...columns, ...constraints].join(',\n  ')}\n)`);
+                const names = existingColumns.map(quoteSqlIdentifier).join(', ');
+                this.exec(`INSERT INTO twin_edges_074_new (${names}) SELECT ${names} FROM twin_edges`);
+                this.exec('DROP TABLE twin_edges');
+                this.exec('ALTER TABLE twin_edges_074_new RENAME TO twin_edges');
+                for (const sql of objects.indexes) {
+                    this.exec(sql);
+                }
+                this.exec(`
+          CREATE INDEX idx_twin_edges_subject
+            ON twin_edges(subject_kind, subject_id, created_at DESC);
+          CREATE INDEX idx_twin_edges_object
+            ON twin_edges(object_kind, object_id, created_at DESC);
+          CREATE INDEX idx_twin_edges_model_run_id
+            ON twin_edges(model_run_id, created_at DESC);
+          CREATE INDEX idx_twin_edges_request_idempotency
+            ON twin_edges(model_run_id, request_idempotency_key, created_at DESC)
+            WHERE model_run_id IS NOT NULL AND request_idempotency_key IS NOT NULL;
+          CREATE UNIQUE INDEX ux_twin_edges_model_run_edge_idempotency
+            ON twin_edges(model_run_id, edge_idempotency_key)
+            WHERE model_run_id IS NOT NULL AND edge_idempotency_key IS NOT NULL;
+        `);
+                for (const sql of objects.triggers) {
+                    this.exec(sql);
+                }
+                if (!this.workGraphRefsShape074()) {
+                    throw new Error('Migration 074 recovery failed: incomplete work graph shape');
+                }
+                for (const table of this.tablesInForeignKeyGraph('twin_edges')) {
+                    if (this.prepare('SELECT 1 FROM pragma_foreign_key_check(?)').all(table).length > 0) {
+                        throw new Error(`Migration 074 recovery failed: foreign key violations after rebuild (${table})`);
+                    }
+                }
+                this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(74, 'Registry and observation work graph references');
+            });
+        }
+        finally {
+            this.exec(`PRAGMA foreign_keys = ${previousForeignKeys ? 'ON' : 'OFF'}`);
+        }
+    }
+    /**
+     * 079 endpoint shape: the 074 work-graph shape plus the extended edge_type
+     * relation list ('refines','contradicts','amends') used by authored record
+     * links. `workGraphRefsShape074` already accepts this edge_type variant, so
+     * the extra check here is the only difference.
+     */
+    twinEdgeRelationsShape079() {
+        if (!this.tableExists('twin_edges')) {
+            return false;
+        }
+        const clauses = splitCreateTableClauses(this.tableSql('twin_edges'));
+        const edgeTypeClause = clauses.find((clause) => !clauseIsTableConstraint(clause) && clauseColumnName(clause) === 'edge_type');
+        return (this.workGraphRefsShape074() &&
+            edgeTypeClause !== undefined &&
+            normalizeSqlText(edgeTypeClause) ===
+                normalizeSqlText("edge_type TEXT NOT NULL CHECK (edge_type IN ('supersedes','refines','contradicts','builds_on','debates','synthesizes','mentions','derived_from','case_member','alias_of','next_action_for','blocks','amends'))") &&
+            !clauses.some((clause) => clauseIsTableConstraint(clause) && /\bedge_type\b/i.test(clause)));
+    }
+    needsTwinEdgeRelationsRepair079() {
+        return !this.twinEdgeRelationsShape079() || !this.schemaVersionExists(79);
+    }
+    /**
+     * Rebuild twin_edges with the extended relation CHECK while preserving every
+     * existing column (including runtime-added custom columns), index, trigger,
+     * and foreign-key child - the same contract recoverWorkGraphRefsMigration074
+     * honours. Only the edge_type clause is rewritten; a table already carrying
+     * the extended list is just stamped.
+     */
+    recoverTwinEdgeRelationsMigration079() {
+        if (!this.tableExists('twin_edges')) {
+            throw new Error('Migration 079 recovery failed: missing twin_edges');
+        }
+        if (this.twinEdgeRelationsShape079()) {
+            this.transaction(() => {
+                this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(79, 'Twin edge relations for judgment links (refines/contradicts/amends)');
+            });
+            return;
+        }
+        const clauses = splitCreateTableClauses(this.tableSql('twin_edges'));
+        if (clauses.length === 0) {
+            throw new Error('Migration 079 recovery failed: unreadable twin_edges');
+        }
+        const edgeTypeDef = "edge_type TEXT NOT NULL CHECK (edge_type IN ('supersedes','refines','contradicts','builds_on','debates','synthesizes','mentions','derived_from','case_member','alias_of','next_action_for','blocks','amends'))";
+        const allowedEdgeTypeDefs = new Set([
+            "edge_type TEXT NOT NULL CHECK (edge_type IN ('supersedes','builds_on','debates','synthesizes','mentions','derived_from','case_member','alias_of','next_action_for','blocks'))",
+            edgeTypeDef,
+        ].map(normalizeSqlText));
+        const existingColumns = [];
+        const columns = [];
+        const constraints = [];
+        for (const clause of clauses) {
+            if (clauseIsTableConstraint(clause)) {
+                if (/\bedge_type\b/i.test(clause)) {
+                    throw new Error('Migration 079 cannot safely preserve conflicting edge_type CHECK');
+                }
+                constraints.push(clause);
+                continue;
+            }
+            const name = clauseColumnName(clause);
+            existingColumns.push(name);
+            if (name === 'edge_type') {
+                if (!allowedEdgeTypeDefs.has(normalizeSqlText(clause))) {
+                    throw new Error('Migration 079 cannot safely preserve inline constraint on edge_type');
+                }
+                columns.push(edgeTypeDef);
+            }
+            else {
+                columns.push(clause);
+            }
+        }
+        const objects = this.storedObjectsForTable('twin_edges', new Set([
+            'idx_twin_edges_subject',
+            'idx_twin_edges_object',
+            'idx_twin_edges_model_run_id',
+            'idx_twin_edges_request_idempotency',
+            'ux_twin_edges_model_run_edge_idempotency',
+        ]));
+        const previousForeignKeys = this.readForeignKeysEnabled();
+        this.exec('PRAGMA foreign_keys = OFF');
+        if (this.readForeignKeysEnabled()) {
+            throw new Error('Migration 079 recovery failed: could not disable foreign_keys');
+        }
+        try {
+            this.transaction(() => {
+                this.exec(`CREATE TABLE twin_edges_079_new (\n  ${[...columns, ...constraints].join(',\n  ')}\n)`);
+                // Generated columns (table_xinfo hidden: 2 = VIRTUAL, 3 = STORED) refuse
+                // direct writes; the rebuilt table recomputes them from its own clause.
+                const generatedColumns = new Set(this.prepare('SELECT name FROM pragma_table_xinfo(?) WHERE hidden IN (2, 3)').all('twin_edges').map((row) => row.name));
+                const names = existingColumns
+                    .filter((name) => !generatedColumns.has(name))
+                    .map(quoteSqlIdentifier)
+                    .join(', ');
+                this.exec(`INSERT INTO twin_edges_079_new (${names}) SELECT ${names} FROM twin_edges`);
+                this.exec('DROP TABLE twin_edges');
+                this.exec('ALTER TABLE twin_edges_079_new RENAME TO twin_edges');
+                for (const sql of objects.indexes) {
+                    this.exec(sql);
+                }
+                this.exec(`
+          CREATE INDEX idx_twin_edges_subject
+            ON twin_edges(subject_kind, subject_id, created_at DESC);
+          CREATE INDEX idx_twin_edges_object
+            ON twin_edges(object_kind, object_id, created_at DESC);
+          CREATE INDEX idx_twin_edges_model_run_id
+            ON twin_edges(model_run_id, created_at DESC);
+          CREATE INDEX idx_twin_edges_request_idempotency
+            ON twin_edges(model_run_id, request_idempotency_key, created_at DESC)
+            WHERE model_run_id IS NOT NULL AND request_idempotency_key IS NOT NULL;
+          CREATE UNIQUE INDEX ux_twin_edges_model_run_edge_idempotency
+            ON twin_edges(model_run_id, edge_idempotency_key)
+            WHERE model_run_id IS NOT NULL AND edge_idempotency_key IS NOT NULL;
+        `);
+                for (const sql of objects.triggers) {
+                    this.exec(sql);
+                }
+                if (!this.twinEdgeRelationsShape079()) {
+                    throw new Error('Migration 079 recovery failed: incomplete twin edge relations shape');
+                }
+                for (const table of this.tablesInForeignKeyGraph('twin_edges')) {
+                    if (this.prepare('SELECT 1 FROM pragma_foreign_key_check(?)').all(table).length > 0) {
+                        throw new Error(`Migration 079 recovery failed: foreign key violations after rebuild (${table})`);
+                    }
+                }
+                this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(79, 'Twin edge relations for judgment links (refines/contradicts/amends)');
+            });
+        }
+        finally {
+            this.exec(`PRAGMA foreign_keys = ${previousForeignKeys ? 'ON' : 'OFF'}`);
+        }
+    }
+    legacyRecordKindShape077() {
+        if (!this.tableExists('decisions')) {
+            return false;
+        }
+        const clauses = splitCreateTableClauses(this.tableSql('decisions'));
+        const recordKindClause = clauses.find((clause) => !clauseIsTableConstraint(clause) && clauseColumnName(clause) === 'record_kind');
+        return Boolean(recordKindClause &&
+            normalizeSqlText(recordKindClause) ===
+                normalizeSqlText("record_kind TEXT NOT NULL DEFAULT 'legacy' CHECK (record_kind IN ('legacy', 'judgment', 'commitment'))") &&
+            !clauses.some((clause) => clauseIsTableConstraint(clause) && /\brecord_kind\b/i.test(clause)));
+    }
+    recoverLegacyRecordKindMigration077() {
+        if (!this.tableExists('decisions')) {
+            throw new Error('Migration 077 recovery failed: missing decisions');
+        }
+        if (this.legacyRecordKindShape077()) {
+            this.transaction(() => {
+                this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(77, 'Distinguish legacy memory records from agent judgments');
+            });
+            return;
+        }
+        const clauses = splitCreateTableClauses(this.tableSql('decisions'));
+        if (clauses.length === 0) {
+            throw new Error('Migration 077 recovery failed: unreadable decisions');
+        }
+        const existingColumns = [];
+        const columns = [];
+        const constraints = [];
+        let hasRecordKind = false;
+        for (const clause of clauses) {
+            if (clauseIsTableConstraint(clause)) {
+                if (/\brecord_kind\b/i.test(clause)) {
+                    throw new Error('Migration 077 cannot safely preserve conflicting record_kind CHECK');
+                }
+                constraints.push(clause);
+                continue;
+            }
+            const name = clauseColumnName(clause);
+            existingColumns.push(name);
+            if (name === 'record_kind') {
+                hasRecordKind = true;
+                columns.push("record_kind TEXT NOT NULL DEFAULT 'legacy' CHECK (record_kind IN ('legacy', 'judgment', 'commitment'))");
+            }
+            else {
+                columns.push(clause);
+            }
+        }
+        if (!hasRecordKind) {
+            throw new Error('Migration 077 recovery failed: record_kind column is missing');
+        }
+        const objects = this.storedObjectsForTable('decisions');
+        const previousForeignKeys = this.readForeignKeysEnabled();
+        this.exec('PRAGMA foreign_keys = OFF');
+        if (this.readForeignKeysEnabled()) {
+            throw new Error('Migration 077 recovery failed: could not disable foreign_keys');
+        }
+        try {
+            this.transaction(() => {
+                this.exec(`CREATE TABLE decisions_077_new (\n  ${[...columns, ...constraints].join(',\n  ')}\n)`);
+                const names = existingColumns.map(quoteSqlIdentifier).join(', ');
+                const source = existingColumns
+                    .map((name) => name === 'record_kind'
+                    ? `CASE WHEN ${this.tableExists('judgment_commands') ? 'EXISTS (SELECT 1 FROM judgment_commands jc WHERE jc.record_id = decisions.id)' : '0'} THEN record_kind ELSE 'legacy' END`
+                    : quoteSqlIdentifier(name))
+                    .join(', ');
+                this.exec(`INSERT INTO decisions_077_new (${names}) SELECT ${source} FROM decisions`);
+                this.exec('DROP TABLE decisions');
+                this.exec('ALTER TABLE decisions_077_new RENAME TO decisions');
+                for (const sql of objects.indexes) {
+                    this.exec(sql);
+                }
+                for (const sql of objects.triggers) {
+                    this.exec(sql);
+                }
+                if (!this.legacyRecordKindShape077()) {
+                    throw new Error('Migration 077 recovery failed: incomplete record_kind shape');
+                }
+                for (const table of this.tablesInForeignKeyGraph('decisions')) {
+                    if (this.prepare('SELECT 1 FROM pragma_foreign_key_check(?)').all(table).length > 0) {
+                        throw new Error(`Migration 077 recovery failed: foreign key violations after rebuild (${table})`);
+                    }
+                }
+                this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(77, 'Distinguish legacy memory records from agent judgments');
+            });
+        }
+        finally {
+            this.exec(`PRAGMA foreign_keys = ${previousForeignKeys ? 'ON' : 'OFF'}`);
+        }
+    }
+    toolTracesHasOperationOriginShape() {
+        const columns = this.tableColumns('tool_traces');
+        if (!columns.has('operation_id') || !columns.has('actor_principal_id')) {
+            return false;
+        }
+        const modelRunColumn = this.prepare('PRAGMA table_info(tool_traces)').all().find((column) => column.name === 'model_run_id');
+        if (!modelRunColumn || modelRunColumn.notnull !== 0) {
+            return false;
+        }
+        const normalized = normalizeSqlText(this.toolTracesTableSql());
+        // The FULL origin CHECK must be present, not merely a prefix: a weakened
+        // `CHECK (model_run_id IS NOT NULL OR 1)` would let a both-null-origin row
+        // exist, so a table carrying it is NOT migrated and must be repaired.
+        if (!normalized.includes(normalizeSqlText(TOOL_TRACES_ORIGIN_CHECK))) {
+            return false;
+        }
+        // The model_runs FK must survive so a legacy/causal model reference is real.
+        if (!normalized.includes(normalizeSqlText(TOOL_TRACES_MODEL_FK))) {
+            return false;
+        }
+        // The origin lookup indexes are part of the shape this migration guarantees.
+        return (this.indexExists('idx_tool_traces_operation_id') &&
+            this.indexExists('idx_tool_traces_actor_principal'));
+    }
+    needsServiceOperationOriginsRepair071() {
+        if (!this.tableExists('tool_traces')) {
+            // The table itself is missing: let the recovery helper fail loudly.
+            return true;
+        }
+        return !this.toolTracesHasOperationOriginShape() || !this.schemaVersionExists(71);
+    }
+    readForeignKeysEnabled() {
+        const row = this.prepare('PRAGMA foreign_keys').get();
+        return Boolean(row?.foreign_keys);
+    }
+    /**
+     * tool_traces plus every table that declares a FK referencing it. This is the
+     * relevant FK graph for the 071 rebuild: tool_traces' own model_runs reference
+     * and any child (e.g. an ON DELETE CASCADE table) whose rows the rebuild must
+     * have preserved. A valid child whose table name needs quoting (a space, an
+     * embedded quote, a reserved word) is inspected correctly too: the name is fed
+     * to the table-valued pragma as a bound argument, not interpolated -- so no
+     * referencing child is silently skipped by an identifier regex.
+     */
+    tablesInToolTracesFkGraph() {
+        const graph = new Set(['tool_traces']);
+        const tables = this.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").all();
+        for (const { name } of tables) {
+            const fkList = this.prepare('SELECT "table" AS ref FROM pragma_foreign_key_list(?)').all(name);
+            if (fkList.some((fk) => fk.ref === 'tool_traces')) {
+                graph.add(name);
+            }
+        }
+        return [...graph];
+    }
+    recoverServiceOperationOriginsMigration071() {
+        if (!this.tableExists('tool_traces')) {
+            throw new Error('Migration 071 recovery failed: missing table tool_traces');
+        }
+        // Idempotent: a database already carrying the full operation-origin shape
+        // only needs its schema_version stamped. Never infer health from version.
+        if (this.toolTracesHasOperationOriginShape()) {
+            this.transaction(() => {
+                this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(71, 'Service operation-origin tool traces');
+            });
+            return;
+        }
+        // The 071 rebuild recreates the 068 scope indexes, which reference
+        // owner_scope/project_id/channel_id. A legacy ledger stamped 68 but missing
+        // those diagnostic columns (the main loop skips version 68 when it is
+        // already stamped, so the in-loop 071 branch reaches here before the
+        // end-of-run repair) would abort the rebuild with "no such column". Repair
+        // the real 068 prerequisite first, reusing the same structural dependency
+        // the late repair path already orders (068 before 071). This runs before
+        // the FK toggle/transaction below, so no nested transaction is introduced,
+        // and it is a no-op on a healthy database.
+        if (this.needsToolTraceDiagnosticsRepair068()) {
+            this.recoverToolTraceDiagnosticsMigration068();
+        }
+        // FK enforcement MUST be toggled OUTSIDE a transaction (SQLite silently
+        // ignores the pragma while one is open). Disabling it before BEGIN is what
+        // stops the DROP TABLE below from CASCADE-deleting real child rows; the
+        // whole-graph foreign_key_check inside the transaction is the honest
+        // preservation proof, never a post-deletion recount. Restore in finally.
+        const previousForeignKeys = this.readForeignKeysEnabled();
+        this.exec('PRAGMA foreign_keys = OFF');
+        if (this.readForeignKeysEnabled()) {
+            // A pragma that did not take effect means a transaction is already open;
+            // proceeding would let CASCADE run. Refuse rather than pretend it worked.
+            throw new Error('Migration 071 recovery failed: could not disable foreign_keys (transaction already open?)');
+        }
+        try {
+            this.transaction(() => {
+                // Preserve the COMPLETE existing table definition. Every column keeps its
+                // exact declared type, NOT NULL/DEFAULT/CHECK/UNIQUE/COLLATE and quoted
+                // name; only model_run_id is relaxed to nullable and the two origin
+                // columns + origin CHECK are added. Reconstructing from name/type alone
+                // would silently drop constraints and defaults a live database carries.
+                const originalSql = this.toolTracesTableSql();
+                const clauses = splitCreateTableClauses(originalSql);
+                if (clauses.length === 0) {
+                    throw new Error('Migration 071 recovery failed: could not read tool_traces definition');
+                }
+                const existingColumnNames = [];
+                const columnDefs = [];
+                const constraintDefs = [];
+                for (const clause of clauses) {
+                    if (clauseIsTableConstraint(clause)) {
+                        constraintDefs.push(clause);
+                        continue;
+                    }
+                    const name = clauseColumnName(clause);
+                    existingColumnNames.push(name);
+                    if (name === 'model_run_id') {
+                        // Relax the single NOT NULL so an operation-origin row (model NULL)
+                        // is allowed; everything else about the column is preserved.
+                        columnDefs.push(clause.replace(/\s+not\s+null\b/i, ''));
+                    }
+                    else {
+                        columnDefs.push(clause);
+                    }
+                }
+                const present = new Set(existingColumnNames);
+                if (!present.has('operation_id')) {
+                    columnDefs.push('operation_id TEXT');
+                }
+                if (!present.has('actor_principal_id')) {
+                    columnDefs.push('actor_principal_id TEXT');
+                }
+                const constraints = [...constraintDefs];
+                const hasModelFk = constraints.some((clause) => normalizeSqlText(clause).includes('referencesmodel_runs(model_run_id)'));
+                if (!hasModelFk) {
+                    constraints.push(TOOL_TRACES_MODEL_FK);
+                }
+                constraints.push(TOOL_TRACES_ORIGIN_CHECK);
+                // Preserve every custom/existing trigger on the old table; DROP TABLE
+                // drops them, and RENAME does not carry them, so recreate from DDL.
+                const triggerSqls = this.prepare("SELECT sql FROM sqlite_master WHERE type='trigger' AND tbl_name='tool_traces' AND sql IS NOT NULL").all().map((row) => row.sql);
+                // Preserve every non-auto index on the old table (033/061/068 plus any
+                // runtime-created ones) by recreating them from their stored DDL.
+                const indexSqls = this.prepare("SELECT sql FROM sqlite_master WHERE type='index' AND tbl_name='tool_traces' AND sql IS NOT NULL").all().map((row) => row.sql);
+                this.exec(`CREATE TABLE tool_traces_071_new (\n  ${[...columnDefs, ...constraints].join(',\n  ')}\n)`);
+                // Copy every column the old table actually carries (canonical, runtime
+                // extras, and any already-present operation_id/actor_principal_id values
+                // from a partially-repaired shape - never dropping real origin values).
+                // Each name is re-quoted: clauseColumnName decoded it, so a quoted name
+                // carrying a space/embedded-quote/reserved word must be emitted quoted or
+                // it would parse as several bare tokens and abort the rebuild.
+                const columnList = existingColumnNames.map(quoteSqlIdentifier).join(', ');
+                this.exec(`INSERT INTO tool_traces_071_new (${columnList}) SELECT ${columnList} FROM tool_traces`);
+                this.exec('DROP TABLE tool_traces');
+                this.exec('ALTER TABLE tool_traces_071_new RENAME TO tool_traces');
+                for (const sql of indexSqls) {
+                    this.exec(sql.replace(/^CREATE\s+INDEX/i, 'CREATE INDEX IF NOT EXISTS'));
+                }
+                this.exec(`
+          CREATE INDEX IF NOT EXISTS idx_tool_traces_model_run_id
+            ON tool_traces(model_run_id, created_at DESC);
+          CREATE INDEX IF NOT EXISTS idx_tool_traces_gateway_call_id
+            ON tool_traces(gateway_call_id);
+          CREATE INDEX IF NOT EXISTS idx_tool_traces_scope_recency
+            ON tool_traces(owner_scope, project_id, created_at DESC, trace_id DESC);
+          CREATE INDEX IF NOT EXISTS idx_tool_traces_channel_recency
+            ON tool_traces(owner_scope, project_id, channel_id, created_at DESC, trace_id DESC);
+          CREATE INDEX IF NOT EXISTS idx_tool_traces_operation_id
+            ON tool_traces(operation_id, created_at DESC);
+          CREATE INDEX IF NOT EXISTS idx_tool_traces_actor_principal
+            ON tool_traces(actor_principal_id, created_at DESC);
+        `);
+                for (const sql of triggerSqls) {
+                    this.exec(sql);
+                }
+                if (!this.toolTracesHasOperationOriginShape()) {
+                    throw new Error('Migration 071 recovery failed: operation-origin shape missing after rebuild');
+                }
+                // Validate the RELEVANT FK graph, not merely tool_traces' own FK: check
+                // tool_traces (its model_runs reference - catches a dangling row) AND
+                // every table that references tool_traces (a CASCADE child that the
+                // rebuild must have preserved). Any violation aborts the whole
+                // transaction, so nothing partial or unattributed is ever committed.
+                // Unrelated tables are deliberately NOT checked - a pre-existing
+                // violation elsewhere must not block this upgrade.
+                for (const table of this.tablesInToolTracesFkGraph()) {
+                    const violations = this.prepare('SELECT 1 FROM pragma_foreign_key_check(?)').all(table);
+                    if (violations.length > 0) {
+                        throw new Error(`Migration 071 recovery failed: foreign key violations after rebuild (${table})`);
+                    }
+                }
+                this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(71, 'Service operation-origin tool traces');
+            });
+        }
+        finally {
+            this.exec(`PRAGMA foreign_keys = ${previousForeignKeys ? 'ON' : 'OFF'}`);
+        }
+    }
     recoverMemoryProvenanceMigration032() {
         this.transaction(() => {
             const expectedDecisionColumns = [
@@ -713,443 +2620,6 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
             }
         }
     }
-    recoverConnectorEventScopeMigration034() {
-        this.transaction(() => {
-            const expectedColumns = [
-                'source_cursor',
-                'tenant_id',
-                'project_id',
-                'memory_scope_kind',
-                'memory_scope_id',
-            ];
-            const columns = this.tableColumns('connector_event_index');
-            for (const column of expectedColumns) {
-                if (!columns.has(column)) {
-                    this.exec(`ALTER TABLE connector_event_index ADD COLUMN ${column} TEXT`);
-                    columns.add(column);
-                }
-            }
-            this.exec(`
-        CREATE INDEX IF NOT EXISTS idx_connector_event_scope
-          ON connector_event_index(tenant_id, project_id, memory_scope_kind, memory_scope_id)
-      `);
-            this.exec(`
-        CREATE INDEX IF NOT EXISTS idx_connector_event_source_cursor
-          ON connector_event_index(source_connector, source_cursor)
-      `);
-            this.assertMigration034Complete();
-            this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(34, 'Add connector event scope columns');
-        });
-    }
-    assertMigration034Complete() {
-        const columns = this.tableColumns('connector_event_index');
-        for (const column of [
-            'source_cursor',
-            'tenant_id',
-            'project_id',
-            'memory_scope_kind',
-            'memory_scope_id',
-        ]) {
-            if (!columns.has(column)) {
-                throw new Error(`Migration 034 recovery failed: missing connector_event_index.${column}`);
-            }
-        }
-        for (const indexName of ['idx_connector_event_scope', 'idx_connector_event_source_cursor']) {
-            if (!this.indexExists(indexName)) {
-                throw new Error(`Migration 034 recovery failed: missing index ${indexName}`);
-            }
-        }
-    }
-    recoverConnectorEventSourceEntityIdMigration067() {
-        this.transaction(() => {
-            const columns = this.tableColumns('connector_event_index');
-            if (!columns.has('source_entity_id')) {
-                this.exec('ALTER TABLE connector_event_index ADD COLUMN source_entity_id TEXT');
-            }
-            // Backfill only when metadata_json exists; a legacy/minimal table rebuilt by the repair path
-            // may not have it yet. New rows carry source_entity_id at write time regardless.
-            if (columns.has('metadata_json')) {
-                this.exec(`
-          UPDATE connector_event_index
-            SET source_entity_id = json_extract(metadata_json, '$.sourceEntityId')
-            WHERE source_entity_id IS NULL
-              AND metadata_json IS NOT NULL
-              AND json_extract(metadata_json, '$.sourceEntityId') IS NOT NULL
-        `);
-            }
-            this.exec(`
-        CREATE INDEX IF NOT EXISTS idx_connector_event_source_entity
-          ON connector_event_index(source_connector, source_entity_id)
-      `);
-            this.assertMigration067Complete();
-            this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(67, 'Add connector_event_index source_entity_id');
-        });
-    }
-    assertMigration067Complete() {
-        const columns = this.tableColumns('connector_event_index');
-        if (!columns.has('source_entity_id')) {
-            throw new Error('Migration 067 recovery failed: missing connector_event_index.source_entity_id');
-        }
-        if (!this.indexExists('idx_connector_event_source_entity')) {
-            throw new Error('Migration 067 recovery failed: missing index idx_connector_event_source_entity');
-        }
-    }
-    recoverConnectorEventOperatorSeqMigration039() {
-        this.transaction(() => {
-            const columns = this.tableColumns('connector_event_index');
-            if (!columns.has('operator_ingest_seq')) {
-                this.exec(`
-          ALTER TABLE connector_event_index
-            ADD COLUMN operator_ingest_seq INTEGER CHECK (
-              operator_ingest_seq IS NULL OR operator_ingest_seq >= 1
-            )
-        `);
-            }
-            this.exec(`
-        CREATE TABLE IF NOT EXISTS connector_event_index_operator_seq_cursors (
-          source_connector TEXT NOT NULL,
-          channel TEXT NOT NULL DEFAULT '',
-          next_seq INTEGER NOT NULL CHECK (next_seq >= 1),
-          PRIMARY KEY (source_connector, channel)
-        )
-      `);
-            this.exec(`
-        WITH ranked_events AS (
-          SELECT
-            event_index_id,
-            ROW_NUMBER() OVER (
-              PARTITION BY source_connector, COALESCE(channel, '')
-              ORDER BY rowid ASC
-            ) AS operator_seq
-          FROM connector_event_index
-        )
-        UPDATE connector_event_index
-        SET operator_ingest_seq = (
-          SELECT operator_seq
-          FROM ranked_events
-          WHERE ranked_events.event_index_id = connector_event_index.event_index_id
-        )
-        WHERE operator_ingest_seq IS NULL
-      `);
-            this.exec(`
-        INSERT OR IGNORE INTO connector_event_index_operator_seq_cursors (
-          source_connector,
-          channel,
-          next_seq
-        )
-        SELECT
-          source_connector,
-          COALESCE(channel, ''),
-          COALESCE(MAX(operator_ingest_seq), 0) + 1
-        FROM connector_event_index
-        GROUP BY source_connector, COALESCE(channel, '')
-      `);
-            this.exec(`
-        CREATE UNIQUE INDEX IF NOT EXISTS idx_connector_event_index_operator_scope_seq
-          ON connector_event_index(source_connector, COALESCE(channel, ''), operator_ingest_seq)
-          WHERE operator_ingest_seq IS NOT NULL
-      `);
-            this.exec(`
-        CREATE INDEX IF NOT EXISTS idx_connector_event_index_operator_cursor_order
-          ON connector_event_index(source_connector, channel, operator_ingest_seq)
-      `);
-            this.exec(`
-        CREATE TRIGGER IF NOT EXISTS trg_connector_event_index_operator_ingest_seq_ai
-        AFTER INSERT ON connector_event_index
-        WHEN NEW.operator_ingest_seq IS NULL
-        BEGIN
-          INSERT OR IGNORE INTO connector_event_index_operator_seq_cursors (
-            source_connector,
-            channel,
-            next_seq
-          )
-          VALUES (NEW.source_connector, COALESCE(NEW.channel, ''), 1);
-
-          UPDATE connector_event_index
-          SET operator_ingest_seq = (
-            SELECT next_seq
-            FROM connector_event_index_operator_seq_cursors
-            WHERE source_connector = NEW.source_connector
-              AND channel = COALESCE(NEW.channel, '')
-          )
-          WHERE event_index_id = NEW.event_index_id;
-
-          UPDATE connector_event_index_operator_seq_cursors
-          SET next_seq = next_seq + 1
-          WHERE source_connector = NEW.source_connector
-            AND channel = COALESCE(NEW.channel, '');
-        END
-      `);
-            this.exec(`
-        CREATE TRIGGER IF NOT EXISTS trg_connector_event_index_operator_ingest_seq_explicit_ai
-        AFTER INSERT ON connector_event_index
-        WHEN NEW.operator_ingest_seq IS NOT NULL
-        BEGIN
-          INSERT OR IGNORE INTO connector_event_index_operator_seq_cursors (
-            source_connector,
-            channel,
-            next_seq
-          )
-          VALUES (NEW.source_connector, COALESCE(NEW.channel, ''), 1);
-
-          UPDATE connector_event_index_operator_seq_cursors
-          SET next_seq = CASE
-            WHEN next_seq <= NEW.operator_ingest_seq THEN NEW.operator_ingest_seq + 1
-            ELSE next_seq
-          END
-          WHERE source_connector = NEW.source_connector
-            AND channel = COALESCE(NEW.channel, '');
-        END
-      `);
-            this.assertMigration039Complete();
-            this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(39, 'Add connector event operator ingest sequence');
-        });
-    }
-    assertMigration039Complete() {
-        const columns = this.tableColumns('connector_event_index');
-        if (!columns.has('operator_ingest_seq')) {
-            throw new Error('Migration 039 recovery failed: missing connector_event_index.operator_ingest_seq');
-        }
-        if (!this.tableExists('connector_event_index_operator_seq_cursors')) {
-            throw new Error('Migration 039 recovery failed: missing connector_event_index_operator_seq_cursors');
-        }
-        for (const indexName of [
-            'idx_connector_event_index_operator_scope_seq',
-            'idx_connector_event_index_operator_cursor_order',
-        ]) {
-            if (!this.indexExists(indexName)) {
-                throw new Error(`Migration 039 recovery failed: missing index ${indexName}`);
-            }
-        }
-        for (const triggerName of [
-            'trg_connector_event_index_operator_ingest_seq_ai',
-            'trg_connector_event_index_operator_ingest_seq_explicit_ai',
-        ]) {
-            if (!this.triggerExists(triggerName)) {
-                throw new Error(`Migration 039 recovery failed: missing trigger ${triggerName}`);
-            }
-        }
-    }
-    recoverConnectorEventSequencesMigration062() {
-        this.transaction(() => {
-            const columns = this.tableColumns('connector_event_index');
-            if (!columns.has('operator_observation_seq')) {
-                this.exec(`
-          ALTER TABLE connector_event_index
-            ADD COLUMN operator_observation_seq INTEGER CHECK (
-              operator_observation_seq IS NULL OR operator_observation_seq >= 1
-            )
-        `);
-            }
-            this.exec(`
-        CREATE TABLE IF NOT EXISTS connector_event_index_observation_cursors (
-          source_connector TEXT PRIMARY KEY,
-          next_seq INTEGER NOT NULL CHECK (next_seq >= 1)
-        )
-      `);
-            this.exec(`
-        WITH existing_max AS (
-          SELECT source_connector, MAX(operator_observation_seq) AS max_seq
-          FROM connector_event_index
-          WHERE operator_observation_seq IS NOT NULL
-          GROUP BY source_connector
-        ), ranked_nulls AS (
-          SELECT event_index_id,
-                 source_connector,
-                 ROW_NUMBER() OVER (
-                   PARTITION BY source_connector
-                   ORDER BY source_timestamp_ms, rowid
-                 ) AS seq
-          FROM connector_event_index
-          WHERE operator_observation_seq IS NULL
-        )
-        UPDATE connector_event_index
-        SET operator_observation_seq = (
-          SELECT COALESCE(existing_max.max_seq, 0) + ranked_nulls.seq
-          FROM ranked_nulls
-          LEFT JOIN existing_max
-            ON existing_max.source_connector = ranked_nulls.source_connector
-          WHERE ranked_nulls.event_index_id = connector_event_index.event_index_id
-        )
-        WHERE operator_observation_seq IS NULL
-      `);
-            this.exec(`
-        INSERT INTO connector_event_index_observation_cursors (source_connector, next_seq)
-        SELECT source_connector, MAX(operator_observation_seq) + 1
-        FROM connector_event_index
-        GROUP BY source_connector
-        ON CONFLICT(source_connector) DO UPDATE SET next_seq = CASE
-          WHEN connector_event_index_observation_cursors.next_seq < excluded.next_seq
-          THEN excluded.next_seq
-          ELSE connector_event_index_observation_cursors.next_seq
-        END
-      `);
-            this.exec(`
-        CREATE UNIQUE INDEX IF NOT EXISTS idx_connector_event_index_observation_seq
-          ON connector_event_index(source_connector, operator_observation_seq)
-          WHERE operator_observation_seq IS NOT NULL
-      `);
-            this.exec(`
-        CREATE TRIGGER IF NOT EXISTS trg_connector_event_index_operator_ingest_seq_au
-        AFTER UPDATE OF operator_ingest_seq ON connector_event_index
-        WHEN NEW.operator_ingest_seq IS NULL AND OLD.operator_ingest_seq IS NOT NULL
-        BEGIN
-          INSERT INTO connector_event_index_operator_seq_cursors
-            (source_connector, channel, next_seq)
-          VALUES (NEW.source_connector, COALESCE(NEW.channel, ''), 1)
-          ON CONFLICT(source_connector, channel) DO NOTHING;
-          UPDATE connector_event_index
-          SET operator_ingest_seq = (
-            SELECT next_seq FROM connector_event_index_operator_seq_cursors
-            WHERE source_connector = NEW.source_connector
-              AND channel = COALESCE(NEW.channel, '')
-          )
-          WHERE event_index_id = NEW.event_index_id;
-          UPDATE connector_event_index_operator_seq_cursors
-          SET next_seq = next_seq + 1
-          WHERE source_connector = NEW.source_connector
-            AND channel = COALESCE(NEW.channel, '');
-        END
-      `);
-            this.exec(`
-        CREATE TRIGGER IF NOT EXISTS trg_connector_event_index_observation_seq_ai
-        AFTER INSERT ON connector_event_index
-        WHEN NEW.operator_observation_seq IS NULL
-        BEGIN
-          INSERT INTO connector_event_index_observation_cursors
-            (source_connector, next_seq)
-          VALUES (NEW.source_connector, 1)
-          ON CONFLICT(source_connector) DO NOTHING;
-          UPDATE connector_event_index
-          SET operator_observation_seq = (
-            SELECT next_seq FROM connector_event_index_observation_cursors
-            WHERE source_connector = NEW.source_connector
-          )
-          WHERE event_index_id = NEW.event_index_id;
-          UPDATE connector_event_index_observation_cursors
-          SET next_seq = next_seq + 1
-          WHERE source_connector = NEW.source_connector;
-        END
-      `);
-            this.exec(`
-        CREATE TRIGGER IF NOT EXISTS trg_connector_event_index_observation_seq_au
-        AFTER UPDATE OF operator_observation_seq ON connector_event_index
-        WHEN NEW.operator_observation_seq IS NULL AND OLD.operator_observation_seq IS NOT NULL
-        BEGIN
-          INSERT INTO connector_event_index_observation_cursors
-            (source_connector, next_seq)
-          VALUES (NEW.source_connector, 1)
-          ON CONFLICT(source_connector) DO NOTHING;
-          UPDATE connector_event_index
-          SET operator_observation_seq = (
-            SELECT next_seq FROM connector_event_index_observation_cursors
-            WHERE source_connector = NEW.source_connector
-          )
-          WHERE event_index_id = NEW.event_index_id;
-          UPDATE connector_event_index_observation_cursors
-          SET next_seq = next_seq + 1
-          WHERE source_connector = NEW.source_connector;
-        END
-      `);
-            this.exec(`
-        CREATE TRIGGER IF NOT EXISTS trg_connector_event_index_observation_seq_explicit_ai
-        AFTER INSERT ON connector_event_index
-        WHEN NEW.operator_observation_seq IS NOT NULL
-        BEGIN
-          INSERT INTO connector_event_index_observation_cursors
-            (source_connector, next_seq)
-          VALUES (NEW.source_connector, 1)
-          ON CONFLICT(source_connector) DO NOTHING;
-          UPDATE connector_event_index_observation_cursors
-          SET next_seq = CASE
-            WHEN next_seq <= NEW.operator_observation_seq THEN NEW.operator_observation_seq + 1
-            ELSE next_seq
-          END
-          WHERE source_connector = NEW.source_connector;
-        END
-      `);
-            this.assertMigration062Complete();
-            this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(62, 'Refresh connector event delivery and observation sequences');
-        });
-    }
-    assertMigration062Complete() {
-        const columns = this.tableColumns('connector_event_index');
-        if (!columns.has('operator_observation_seq')) {
-            throw new Error('Migration 062 recovery failed: missing connector_event_index.operator_observation_seq');
-        }
-        if (!this.tableExists('connector_event_index_observation_cursors')) {
-            throw new Error('Migration 062 recovery failed: missing connector_event_index_observation_cursors');
-        }
-        const cursorColumns = this.tableColumns('connector_event_index_observation_cursors');
-        for (const columnName of ['source_connector', 'next_seq']) {
-            if (!cursorColumns.has(columnName)) {
-                throw new Error(`Migration 062 recovery failed: missing connector_event_index_observation_cursors.${columnName}`);
-            }
-        }
-        if (!this.indexExists('idx_connector_event_index_observation_seq')) {
-            throw new Error('Migration 062 recovery failed: missing index idx_connector_event_index_observation_seq');
-        }
-        for (const triggerName of [
-            'trg_connector_event_index_operator_ingest_seq_au',
-            'trg_connector_event_index_observation_seq_ai',
-            'trg_connector_event_index_observation_seq_au',
-            'trg_connector_event_index_observation_seq_explicit_ai',
-        ]) {
-            if (!this.triggerExists(triggerName)) {
-                throw new Error(`Migration 062 recovery failed: missing trigger ${triggerName}`);
-            }
-        }
-    }
-    recoverConnectorEventLegacyRefreshMigration063() {
-        this.transaction(() => {
-            this.assertMigration062Complete();
-            const connectorColumns = this.tableColumns('connector_event_index');
-            for (const columnName of [
-                'content_hash',
-                'metadata_json',
-                'source_timestamp_ms',
-                'source_type',
-                'channel',
-                'operator_ingest_seq',
-                'operator_observation_seq',
-            ]) {
-                if (!connectorColumns.has(columnName)) {
-                    throw new Error(`Migration 063 recovery failed: missing connector_event_index.${columnName}`);
-                }
-            }
-            this.exec(`
-        CREATE TRIGGER IF NOT EXISTS trg_connector_event_index_legacy_content_refresh_au
-        AFTER UPDATE OF content_hash, metadata_json, source_timestamp_ms, source_type, channel
-        ON connector_event_index
-        WHEN (
-          OLD.content_hash IS NOT NEW.content_hash
-          OR OLD.metadata_json IS NOT NEW.metadata_json
-          OR OLD.source_timestamp_ms IS NOT NEW.source_timestamp_ms
-          OR OLD.source_type IS NOT NEW.source_type
-          OR OLD.channel IS NOT NEW.channel
-        ) AND (
-          NEW.operator_ingest_seq IS OLD.operator_ingest_seq
-          OR NEW.operator_observation_seq IS OLD.operator_observation_seq
-        )
-        BEGIN
-          UPDATE connector_event_index
-          SET operator_ingest_seq = CASE
-                WHEN NEW.operator_ingest_seq IS OLD.operator_ingest_seq THEN NULL
-                ELSE NEW.operator_ingest_seq
-              END,
-              operator_observation_seq = CASE
-                WHEN NEW.operator_observation_seq IS OLD.operator_observation_seq THEN NULL
-                ELSE NEW.operator_observation_seq
-              END
-          WHERE event_index_id = NEW.event_index_id;
-        END
-      `);
-            if (!this.triggerExists('trg_connector_event_index_legacy_content_refresh_au')) {
-                throw new Error('Migration 063 recovery failed: missing trigger trg_connector_event_index_legacy_content_refresh_au');
-            }
-            this.prepare('INSERT OR IGNORE INTO schema_version (version, description) VALUES (?, ?)').run(63, 'Refresh sequences for legacy connector event updates');
-        });
-    }
     tableColumns(tableName) {
         if (!SQLITE_IDENTIFIER_PATTERN.test(tableName)) {
             throw new Error('Invalid SQLite table identifier');
@@ -1168,6 +2638,13 @@ class NodeSQLiteAdapter extends base_adapter_js_1.DatabaseAdapter {
         const row = this.prepare("SELECT name FROM sqlite_master WHERE type='index' AND name = ?").get(indexName);
         return row?.name === indexName;
     }
+    indexSql(indexName) {
+        if (!SQLITE_IDENTIFIER_PATTERN.test(indexName)) {
+            throw new Error('Invalid SQLite index identifier');
+        }
+        const row = this.prepare("SELECT sql FROM sqlite_master WHERE type='index' AND name = ?").get(indexName);
+        return row?.sql ?? '';
+    }
     triggerExists(triggerName) {
         const row = this.prepare("SELECT name FROM sqlite_master WHERE type='trigger' AND name = ?").get(triggerName);
         return row?.name === triggerName;