@aquex/cmos-mcp 1.0.0

package/dist/tools/cmos/schema-migrations.js

@@ -0,0 +1,678 @@
+"use strict";
+/**
+ * Schema migrations for CMOS database evolution.
+ *
+ * Handles backward-compatible schema changes via ALTER TABLE
+ * with soft column detection (PRAGMA table_info).
+ *
+ * @module tools/cmos/schema-migrations
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_FEEDBACK_STATUSES = exports.CONSTRAINT_STATUSES = exports.NEXT_STEP_STATUSES = exports.LEARNING_CATEGORIES = exports.DECISION_STATUSES = exports.DECISION_CATEGORIES = void 0;
+exports.migrateStrategicDecisionsV21 = migrateStrategicDecisionsV21;
+exports.ensureStrategicDecisionsSchema = ensureStrategicDecisionsSchema;
+exports.ensureMissionTimestamps = ensureMissionTimestamps;
+exports.ensureLearningsTable = ensureLearningsTable;
+exports.migrateContentHash = migrateContentHash;
+exports.ensureArchivalColumns = ensureArchivalColumns;
+exports.ensureReviewTimestamps = ensureReviewTimestamps;
+exports.computeContentHash = computeContentHash;
+exports.ensureSessionMissionsTable = ensureSessionMissionsTable;
+exports.ensureNextStepsTable = ensureNextStepsTable;
+exports.ensureConstraintsTable = ensureConstraintsTable;
+exports.ensureDecisionsFts5 = ensureDecisionsFts5;
+exports.ensureAgentFeedbackTable = ensureAgentFeedbackTable;
+const crypto = __importStar(require("crypto"));
+/**
+ * Valid decision categories.
+ */
+exports.DECISION_CATEGORIES = [
+    'architectural',
+    'process',
+    'tooling',
+    'design',
+    'business',
+];
+/**
+ * Valid decision statuses.
+ */
+exports.DECISION_STATUSES = ['active', 'superseded', 'archived'];
+/**
+ * New columns for the strategic_decisions evolution (v2.0 → v2.1).
+ */
+const STRATEGIC_DECISIONS_V21_COLUMNS = [
+    { name: 'mission_id', type: 'TEXT' },
+    { name: 'category', type: 'TEXT' },
+    { name: 'superseded_by', type: 'INTEGER' },
+    { name: 'status', type: "TEXT DEFAULT 'active'" },
+    { name: 'evidence', type: 'TEXT' },
+];
+/**
+ * Indexes for the strategic_decisions evolution (v2.1).
+ */
+const STRATEGIC_DECISIONS_V21_INDEXES = [
+    {
+        name: 'idx_strategic_decisions_mission',
+        sql: 'CREATE INDEX IF NOT EXISTS idx_strategic_decisions_mission ON strategic_decisions (mission_id)',
+    },
+    {
+        name: 'idx_strategic_decisions_status',
+        sql: 'CREATE INDEX IF NOT EXISTS idx_strategic_decisions_status ON strategic_decisions (status)',
+    },
+    {
+        name: 'idx_strategic_decisions_category',
+        sql: 'CREATE INDEX IF NOT EXISTS idx_strategic_decisions_category ON strategic_decisions (category)',
+    },
+];
+/**
+ * Get the set of column names for a given table.
+ */
+function getTableColumns(client, tableName) {
+    const result = client.getMany(`PRAGMA table_info('${tableName}')`, []);
+    if (!result.success || !result.data) {
+        return new Set();
+    }
+    return new Set(result.data.map((row) => row.name));
+}
+/**
+ * Ensure a column exists on a table, adding it via ALTER TABLE if missing.
+ * Returns true if the column was added, false if it already existed.
+ */
+function ensureColumn(client, tableName, column, existingColumns) {
+    if (existingColumns.has(column.name)) {
+        return false;
+    }
+    const result = client.execute(`ALTER TABLE ${tableName} ADD COLUMN ${column.name} ${column.type}`, []);
+    return result.success;
+}
+/**
+ * Run the strategic_decisions v2.1 migration.
+ *
+ * Adds category, superseded_by, status, evidence columns.
+ * Sets status='active' on existing rows where status is NULL.
+ * Creates indexes on status, category, and mission_id.
+ *
+ * Safe to call multiple times (idempotent).
+ */
+function migrateStrategicDecisionsV21(client) {
+    const existingColumns = getTableColumns(client, 'strategic_decisions');
+    if (existingColumns.size === 0) {
+        return { columnsAdded: [], indexesCreated: [], rowsUpdated: 0, alreadyCurrent: false };
+    }
+    const columnsAdded = [];
+    for (const column of STRATEGIC_DECISIONS_V21_COLUMNS) {
+        if (ensureColumn(client, 'strategic_decisions', column, existingColumns)) {
+            columnsAdded.push(column.name);
+        }
+    }
+    // Set status='active' on any existing rows where status is NULL
+    let rowsUpdated = 0;
+    if (columnsAdded.includes('status')) {
+        const updateResult = client.execute("UPDATE strategic_decisions SET status = 'active' WHERE status IS NULL", []);
+        if (updateResult.success && updateResult.data?.changes) {
+            rowsUpdated = updateResult.data.changes;
+        }
+    }
+    // Create indexes
+    const indexesCreated = [];
+    for (const index of STRATEGIC_DECISIONS_V21_INDEXES) {
+        const result = client.execute(index.sql, []);
+        if (result.success) {
+            indexesCreated.push(index.name);
+        }
+    }
+    // Update schema version in metadata
+    client.execute("INSERT OR REPLACE INTO metadata (key, value) VALUES ('schema_version', '2.1')", []);
+    return {
+        columnsAdded,
+        indexesCreated,
+        rowsUpdated,
+        alreadyCurrent: columnsAdded.length === 0,
+    };
+}
+/**
+ * Run all pending migrations for the strategic_decisions table.
+ * Currently only v2.1 migration exists.
+ */
+function ensureStrategicDecisionsSchema(client) {
+    return migrateStrategicDecisionsV21(client);
+}
+/**
+ * New columns for the missions table (v2.1).
+ */
+const MISSIONS_TIMESTAMP_COLUMNS = [
+    { name: 'created_at', type: 'TEXT' },
+    { name: 'started_at', type: 'TEXT' },
+    { name: 'updated_at', type: 'TEXT' },
+];
+/**
+ * Ensure missions table has timestamp columns.
+ * Adds created_at, started_at, updated_at if missing.
+ *
+ * Safe to call multiple times (idempotent).
+ */
+function ensureMissionTimestamps(client) {
+    const existingColumns = getTableColumns(client, 'missions');
+    if (existingColumns.size === 0) {
+        return { columnsAdded: [], indexesCreated: [], rowsUpdated: 0, alreadyCurrent: false };
+    }
+    const columnsAdded = [];
+    for (const column of MISSIONS_TIMESTAMP_COLUMNS) {
+        if (ensureColumn(client, 'missions', column, existingColumns)) {
+            columnsAdded.push(column.name);
+        }
+    }
+    return {
+        columnsAdded,
+        indexesCreated: [],
+        rowsUpdated: 0,
+        alreadyCurrent: columnsAdded.length === 0,
+    };
+}
+/**
+ * Valid learning categories.
+ */
+exports.LEARNING_CATEGORIES = ['technical', 'process', 'agent-behavior', 'tooling'];
+/**
+ * Ensure the learnings table exists.
+ * Creates the table and indexes if they don't exist, and runs the lazy
+ * column-level migrations (`evergreen` — Sprint 61 m03) on pre-existing tables.
+ *
+ * Sprint 61 m03 — `evergreen INTEGER DEFAULT 0` is now part of the canonical
+ * schema. It is set to 1 by an operator (or by `cmos_learnings(action="update",
+ * evergreen=true)`) on institutional-rule learnings that should never trip the
+ * staleness signal. The staleness query gates on `evergreen = 0` so flagged
+ * institutional rules drop out of the pile entirely.
+ *
+ * MUST be called on read paths in addition to write paths — un-migrated DBs
+ * would otherwise hit `no such column: evergreen` the first time the staleness
+ * query runs against learnings.
+ *
+ * Safe to call multiple times (idempotent).
+ */
+function ensureLearningsTable(client) {
+    const createResult = client.execute(`CREATE TABLE IF NOT EXISTS learnings (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      content TEXT NOT NULL,
+      category TEXT,
+      status TEXT NOT NULL DEFAULT 'active',
+      sprint_id TEXT,
+      session_id TEXT,
+      mission_id TEXT,
+      created_at TEXT NOT NULL,
+      evergreen INTEGER NOT NULL DEFAULT 0
+    )`, []);
+    const tableCreated = createResult.success;
+    const columnsAdded = tableCreated ? ['learnings (table)'] : [];
+    // Lazy column migration for pre-existing tables (added pre-Sprint 61 m03).
+    const existingColumns = getTableColumns(client, 'learnings');
+    if (existingColumns.size > 0 && !existingColumns.has('evergreen')) {
+        const alterResult = client.execute(`ALTER TABLE learnings ADD COLUMN evergreen INTEGER NOT NULL DEFAULT 0`, []);
+        if (alterResult.success) {
+            columnsAdded.push('learnings.evergreen');
+        }
+    }
+    const indexResults = [];
+    const indexes = [
+        {
+            name: 'idx_learnings_status',
+            sql: 'CREATE INDEX IF NOT EXISTS idx_learnings_status ON learnings (status)',
+        },
+        {
+            name: 'idx_learnings_sprint',
+            sql: 'CREATE INDEX IF NOT EXISTS idx_learnings_sprint ON learnings (sprint_id)',
+        },
+        {
+            name: 'idx_learnings_category',
+            sql: 'CREATE INDEX IF NOT EXISTS idx_learnings_category ON learnings (category)',
+        },
+        {
+            name: 'idx_learnings_evergreen',
+            sql: 'CREATE INDEX IF NOT EXISTS idx_learnings_evergreen ON learnings (evergreen)',
+        },
+    ];
+    for (const index of indexes) {
+        const result = client.execute(index.sql, []);
+        if (result.success) {
+            indexResults.push(index.name);
+        }
+    }
+    return {
+        columnsAdded,
+        indexesCreated: indexResults,
+        rowsUpdated: 0,
+        alreadyCurrent: false,
+    };
+}
+/**
+ * Content hash columns for dedup (v2.2).
+ * Adds content_hash to strategic_decisions and learnings tables.
+ */
+const CONTENT_HASH_COLUMNS = [
+    {
+        table: 'strategic_decisions',
+        column: { name: 'content_hash', type: 'TEXT' },
+        index: {
+            name: 'idx_strategic_decisions_hash',
+            sql: 'CREATE INDEX IF NOT EXISTS idx_strategic_decisions_hash ON strategic_decisions (content_hash)',
+        },
+    },
+    {
+        table: 'learnings',
+        column: { name: 'content_hash', type: 'TEXT' },
+        index: {
+            name: 'idx_learnings_hash',
+            sql: 'CREATE INDEX IF NOT EXISTS idx_learnings_hash ON learnings (content_hash)',
+        },
+    },
+];
+/**
+ * Run the content_hash migration (v2.2).
+ *
+ * Adds content_hash column to strategic_decisions and learnings tables.
+ * Computes SHA-256 hashes for existing records.
+ *
+ * Safe to call multiple times (idempotent).
+ */
+function migrateContentHash(client) {
+    const columnsAdded = [];
+    const indexesCreated = [];
+    let rowsUpdated = 0;
+    for (const spec of CONTENT_HASH_COLUMNS) {
+        const existingColumns = getTableColumns(client, spec.table);
+        if (existingColumns.size === 0)
+            continue;
+        if (ensureColumn(client, spec.table, spec.column, existingColumns)) {
+            columnsAdded.push(`${spec.table}.${spec.column.name}`);
+        }
+        const indexResult = client.execute(spec.index.sql, []);
+        if (indexResult.success) {
+            indexesCreated.push(spec.index.name);
+        }
+    }
+    // Backfill hashes for existing decisions without content_hash
+    const unhashed = client.getMany(`SELECT id, decision_text, project_domain FROM strategic_decisions WHERE content_hash IS NULL`, []);
+    if (unhashed.success && unhashed.data) {
+        for (const row of unhashed.data) {
+            const hash = computeContentHash(row.decision_text, row.project_domain ?? 'general');
+            client.execute(`UPDATE strategic_decisions SET content_hash = ? WHERE id = ?`, [
+                hash,
+                row.id,
+            ]);
+            rowsUpdated++;
+        }
+    }
+    // Backfill hashes for existing learnings without content_hash
+    const unhashedLearnings = client.getMany(`SELECT id, content, category FROM learnings WHERE content_hash IS NULL`, []);
+    if (unhashedLearnings.success && unhashedLearnings.data) {
+        for (const row of unhashedLearnings.data) {
+            const hash = computeContentHash(row.content, row.category ?? '');
+            client.execute(`UPDATE learnings SET content_hash = ? WHERE id = ?`, [hash, row.id]);
+            rowsUpdated++;
+        }
+    }
+    if (columnsAdded.length > 0) {
+        client.execute("INSERT OR REPLACE INTO metadata (key, value) VALUES ('schema_version', '2.2')", []);
+    }
+    return {
+        columnsAdded,
+        indexesCreated,
+        rowsUpdated,
+        alreadyCurrent: columnsAdded.length === 0 && rowsUpdated === 0,
+    };
+}
+/**
+ * Archival-reachability columns (Sprint 52 m04).
+ *
+ * The sprint-close archival query reads `strategic_decisions.session_id` and
+ * `learnings.session_id`. DBs seeded by `ensureLearningsTable` or pre-v2.1
+ * `strategic_decisions` layouts lack these columns, which makes the ALTER-less
+ * UPDATE fail with `no such column: session_id` — silently reducing archival
+ * to zero rows. This migration backfills the columns on any DB that lacks them.
+ */
+const ARCHIVAL_SESSION_COLUMNS = [
+    { table: 'strategic_decisions', column: { name: 'session_id', type: 'TEXT' } },
+    { table: 'learnings', column: { name: 'session_id', type: 'TEXT' } },
+];
+/**
+ * Ensure session_id exists on learnings and strategic_decisions so sprint-close
+ * archival can cross-reference sessions. Idempotent.
+ */
+function ensureArchivalColumns(client) {
+    const columnsAdded = [];
+    for (const spec of ARCHIVAL_SESSION_COLUMNS) {
+        const existing = getTableColumns(client, spec.table);
+        if (existing.size === 0)
+            continue;
+        if (ensureColumn(client, spec.table, spec.column, existing)) {
+            columnsAdded.push(`${spec.table}.${spec.column.name}`);
+        }
+    }
+    return {
+        columnsAdded,
+        indexesCreated: [],
+        rowsUpdated: 0,
+        alreadyCurrent: columnsAdded.length === 0,
+    };
+}
+/**
+ * Review-timestamp columns (Sprint 52 m03).
+ *
+ * Adds last_reviewed_at to learnings and strategic_decisions so staleness detection can
+ * respect operator triage. Before this, staleness re-fired on sprint_id every time the
+ * cutoff moved, re-flagging learnings that had just been archived/reaffirmed.
+ */
+const REVIEW_TIMESTAMP_TABLES = [
+    { table: 'learnings', column: { name: 'last_reviewed_at', type: 'TEXT' } },
+    { table: 'strategic_decisions', column: { name: 'last_reviewed_at', type: 'TEXT' } },
+];
+/**
+ * Ensure last_reviewed_at columns exist on learnings and strategic_decisions.
+ * Idempotent — safe to call on DBs where the column already exists.
+ */
+function ensureReviewTimestamps(client) {
+    const columnsAdded = [];
+    for (const spec of REVIEW_TIMESTAMP_TABLES) {
+        const existing = getTableColumns(client, spec.table);
+        if (existing.size === 0)
+            continue; // table doesn't exist on this DB
+        if (ensureColumn(client, spec.table, spec.column, existing)) {
+            columnsAdded.push(`${spec.table}.${spec.column.name}`);
+        }
+    }
+    return {
+        columnsAdded,
+        indexesCreated: [],
+        rowsUpdated: 0,
+        alreadyCurrent: columnsAdded.length === 0,
+    };
+}
+/**
+ * Compute a SHA-256 content hash for dedup.
+ * Uses canonical JSON of (text, domain) for consistent hashing.
+ */
+function computeContentHash(text, domain) {
+    const canonical = JSON.stringify({ d: domain, t: text });
+    return crypto.createHash('sha256').update(canonical).digest('hex');
+}
+/**
+ * Ensure the FTS5 virtual table for decisions exists and is synced.
+ *
+ * Creates:
+ * - decisions_fts FTS5 virtual table (content-external, synced with strategic_decisions)
+ * - Triggers for auto-sync on INSERT, UPDATE, DELETE
+ *
+ * Safe to call multiple times (idempotent).
+ */
+/**
+ * Ensure the session_missions junction table exists.
+ * Creates the table and index if they don't exist.
+ *
+ * Safe to call multiple times (idempotent).
+ */
+function ensureSessionMissionsTable(client) {
+    const createResult = client.execute(`CREATE TABLE IF NOT EXISTS session_missions (
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      mission_id TEXT NOT NULL REFERENCES missions(id) ON DELETE CASCADE,
+      linked_at TEXT NOT NULL,
+      source TEXT NOT NULL DEFAULT 'capture',
+      PRIMARY KEY (session_id, mission_id)
+    )`, []);
+    const tableCreated = createResult.success;
+    const indexResults = [];
+    const indexResult = client.execute('CREATE INDEX IF NOT EXISTS idx_session_missions_mission ON session_missions (mission_id)', []);
+    if (indexResult.success) {
+        indexResults.push('idx_session_missions_mission');
+    }
+    return {
+        columnsAdded: tableCreated ? ['session_missions (table)'] : [],
+        indexesCreated: indexResults,
+        rowsUpdated: 0,
+        alreadyCurrent: false,
+    };
+}
+/**
+ * Valid next-step statuses.
+ */
+exports.NEXT_STEP_STATUSES = ['pending', 'completed', 'carried', 'dropped'];
+/**
+ * Ensure the next_steps table exists.
+ * Creates the table and indexes if they don't exist.
+ *
+ * Safe to call multiple times (idempotent).
+ */
+function ensureNextStepsTable(client) {
+    const createResult = client.execute(`CREATE TABLE IF NOT EXISTS next_steps (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      content TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending',
+      session_id TEXT REFERENCES sessions(id) ON DELETE SET NULL,
+      sprint_id TEXT REFERENCES sprints(id) ON DELETE SET NULL,
+      mission_id TEXT REFERENCES missions(id) ON DELETE SET NULL,
+      created_at TEXT NOT NULL,
+      resolved_at TEXT,
+      carried_to_sprint TEXT REFERENCES sprints(id) ON DELETE SET NULL,
+      content_hash TEXT
+    )`, []);
+    const tableCreated = createResult.success;
+    const indexResults = [];
+    const indexes = [
+        {
+            name: 'idx_next_steps_status',
+            sql: 'CREATE INDEX IF NOT EXISTS idx_next_steps_status ON next_steps (status)',
+        },
+        {
+            name: 'idx_next_steps_sprint',
+            sql: 'CREATE INDEX IF NOT EXISTS idx_next_steps_sprint ON next_steps (sprint_id)',
+        },
+        {
+            name: 'idx_next_steps_hash',
+            sql: 'CREATE INDEX IF NOT EXISTS idx_next_steps_hash ON next_steps (content_hash)',
+        },
+    ];
+    for (const index of indexes) {
+        const result = client.execute(index.sql, []);
+        if (result.success) {
+            indexResults.push(index.name);
+        }
+    }
+    return {
+        columnsAdded: tableCreated ? ['next_steps (table)'] : [],
+        indexesCreated: indexResults,
+        rowsUpdated: 0,
+        alreadyCurrent: false,
+    };
+}
+/**
+ * Valid constraint statuses.
+ */
+exports.CONSTRAINT_STATUSES = ['active', 'archived', 'expired'];
+/**
+ * Ensure the constraints table exists.
+ * Creates the table and indexes if they don't exist.
+ *
+ * Safe to call multiple times (idempotent).
+ */
+function ensureConstraintsTable(client) {
+    const createResult = client.execute(`CREATE TABLE IF NOT EXISTS constraints (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      content TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'active',
+      session_id TEXT REFERENCES sessions(id) ON DELETE SET NULL,
+      sprint_id TEXT REFERENCES sprints(id) ON DELETE SET NULL,
+      created_at TEXT NOT NULL,
+      expires_at TEXT,
+      archived_at TEXT,
+      content_hash TEXT
+    )`, []);
+    const tableCreated = createResult.success;
+    const indexResults = [];
+    const indexes = [
+        {
+            name: 'idx_constraints_status',
+            sql: 'CREATE INDEX IF NOT EXISTS idx_constraints_status ON constraints (status)',
+        },
+        {
+            name: 'idx_constraints_expires',
+            sql: 'CREATE INDEX IF NOT EXISTS idx_constraints_expires ON constraints (expires_at)',
+        },
+        {
+            name: 'idx_constraints_hash',
+            sql: 'CREATE INDEX IF NOT EXISTS idx_constraints_hash ON constraints (content_hash)',
+        },
+    ];
+    for (const index of indexes) {
+        const result = client.execute(index.sql, []);
+        if (result.success) {
+            indexResults.push(index.name);
+        }
+    }
+    return {
+        columnsAdded: tableCreated ? ['constraints (table)'] : [],
+        indexesCreated: indexResults,
+        rowsUpdated: 0,
+        alreadyCurrent: false,
+    };
+}
+function ensureDecisionsFts5(client) {
+    // Check if FTS5 table already exists
+    const existing = client.getOne("SELECT name FROM sqlite_master WHERE type='table' AND name='decisions_fts'", []);
+    if (existing.success && existing.data) {
+        return { columnsAdded: [], indexesCreated: [], rowsUpdated: 0, alreadyCurrent: true };
+    }
+    // Create FTS5 virtual table (content-external pattern)
+    const createResult = client.raw(`CREATE VIRTUAL TABLE IF NOT EXISTS decisions_fts USING fts5(
+      decision_text,
+      content='strategic_decisions',
+      content_rowid='id'
+    )`);
+    if (!createResult.success) {
+        return { columnsAdded: [], indexesCreated: [], rowsUpdated: 0, alreadyCurrent: false };
+    }
+    // Create triggers for auto-sync
+    client.raw(`
+    CREATE TRIGGER IF NOT EXISTS decisions_fts_insert AFTER INSERT ON strategic_decisions BEGIN
+      INSERT INTO decisions_fts(rowid, decision_text) VALUES (new.id, new.decision_text);
+    END
+  `);
+    client.raw(`
+    CREATE TRIGGER IF NOT EXISTS decisions_fts_delete AFTER DELETE ON strategic_decisions BEGIN
+      INSERT INTO decisions_fts(decisions_fts, rowid, decision_text) VALUES('delete', old.id, old.decision_text);
+    END
+  `);
+    client.raw(`
+    CREATE TRIGGER IF NOT EXISTS decisions_fts_update AFTER UPDATE OF decision_text ON strategic_decisions BEGIN
+      INSERT INTO decisions_fts(decisions_fts, rowid, decision_text) VALUES('delete', old.id, old.decision_text);
+      INSERT INTO decisions_fts(rowid, decision_text) VALUES (new.id, new.decision_text);
+    END
+  `);
+    // Rebuild index from existing data
+    let rowsUpdated = 0;
+    const rebuildResult = client.execute("INSERT INTO decisions_fts(decisions_fts) VALUES('rebuild')", []);
+    if (rebuildResult.success) {
+        const countResult = client.getOne('SELECT COUNT(*) as count FROM strategic_decisions', []);
+        rowsUpdated = countResult.success ? (countResult.data?.count ?? 0) : 0;
+    }
+    return {
+        columnsAdded: ['decisions_fts (virtual table)'],
+        indexesCreated: ['decisions_fts_insert', 'decisions_fts_delete', 'decisions_fts_update'],
+        rowsUpdated,
+        alreadyCurrent: false,
+    };
+}
+/**
+ * Valid statuses for agent_feedback rows.
+ *
+ * Sprint 56 m03 — the agentFeedback standing-channel lets agents report UX
+ * issues or improvement ideas from high-friction surfaces without being
+ * prompted. Human operator triages periodically.
+ */
+exports.AGENT_FEEDBACK_STATUSES = ['open', 'triaged', 'resolved', 'archived'];
+/**
+ * Ensure the agent_feedback table exists (Sprint 56 m03).
+ *
+ * Holds free-text UX reports emitted by agents through the `agentFeedback`
+ * parameter on cmos_session(complete), cmos_mission_transition(complete),
+ * and cmos_agent_onboard. Kept as a dedicated table rather than reusing
+ * session captures so the triage surface (cmos_feedback) can filter/sort
+ * without entangling sprint-close capture aggregation.
+ *
+ * Safe to call multiple times (idempotent).
+ */
+function ensureAgentFeedbackTable(client) {
+    const createResult = client.execute(`CREATE TABLE IF NOT EXISTS agent_feedback (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      tool_name TEXT NOT NULL,
+      body TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'open',
+      session_id TEXT REFERENCES sessions(id) ON DELETE SET NULL,
+      sprint_id TEXT REFERENCES sprints(id) ON DELETE SET NULL,
+      mission_id TEXT REFERENCES missions(id) ON DELETE SET NULL,
+      project_id TEXT,
+      created_at TEXT NOT NULL,
+      resolved_at TEXT,
+      resolution_note TEXT
+    )`, []);
+    const tableCreated = createResult.success;
+    const indexResults = [];
+    const indexes = [
+        {
+            name: 'idx_agent_feedback_status',
+            sql: 'CREATE INDEX IF NOT EXISTS idx_agent_feedback_status ON agent_feedback (status)',
+        },
+        {
+            name: 'idx_agent_feedback_tool',
+            sql: 'CREATE INDEX IF NOT EXISTS idx_agent_feedback_tool ON agent_feedback (tool_name)',
+        },
+        {
+            name: 'idx_agent_feedback_created',
+            sql: 'CREATE INDEX IF NOT EXISTS idx_agent_feedback_created ON agent_feedback (created_at DESC)',
+        },
+    ];
+    for (const index of indexes) {
+        const result = client.execute(index.sql, []);
+        if (result.success) {
+            indexResults.push(index.name);
+        }
+    }
+    return {
+        columnsAdded: tableCreated ? ['agent_feedback (table)'] : [],
+        indexesCreated: indexResults,
+        rowsUpdated: 0,
+        alreadyCurrent: false,
+    };
+}
+//# sourceMappingURL=schema-migrations.js.map