create-principles-disciple 1.93.0 → 1.95.0

package/plugin/dist/core/trajectory.js

@@ -19,6 +19,332 @@ const DEFAULT_INLINE_THRESHOLD = 16 * 1024;
 const DEFAULT_BUSY_TIMEOUT_MS = 5000;
 const DEFAULT_ORPHAN_BLOB_GRACE_DAYS = 7;
 const SCHEMA_VERSION = 1;
+/**
+ * Type guard: narrows `object` to `{ name: unknown }` without `as` casts.
+ * Used for PRAGMA table_info rows (rc-2-no-as-bypass).
+ */
+function hasNameField(row) {
+    return Object.hasOwn(row, 'name');
+}
+/**
+ * Apply the full trajectory.db schema (tables + indexes + views + migrations) to an open
+ * Database handle. Used by TrajectoryDatabase.initSchema() and exported via
+ * initTrajectorySchema() for external callers (e.g. `pd runtime init`).
+ *
+ * DDL is the single source of truth for trajectory.db schema. pain-signal-observability.ts
+ * in principles-core also duplicates a subset of this DDL (acknowledged duplication); when
+ * updating this function, audit ensureTrajectorySchema() in core for parallel updates.
+ *
+ * Idempotent: all CREATE statements use IF NOT EXISTS; ALTER columns use try/catch on
+ * "duplicate column name" to skip existing columns.
+ */
+function applyTrajectorySchema(db) {
+    const warnings = [];
+    const tables = [
+        'schema_version', 'ingest_checkpoint', 'sessions', 'assistant_turns',
+        'user_turns', 'tool_calls', 'pain_events', 'gate_blocks', 'trust_changes',
+        'principle_events', 'task_outcomes', 'correction_samples', 'sample_reviews',
+        'exports_audit', 'evolution_tasks', 'evolution_events',
+    ];
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_version (version INTEGER NOT NULL);
+    CREATE TABLE IF NOT EXISTS ingest_checkpoint (
+      source_key TEXT PRIMARY KEY,
+      imported_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS sessions (
+      session_id TEXT PRIMARY KEY,
+      started_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS assistant_turns (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      run_id TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      model TEXT NOT NULL,
+      raw_text TEXT,
+      sanitized_text TEXT NOT NULL,
+      usage_json TEXT NOT NULL,
+      empathy_signal_json TEXT NOT NULL,
+      blob_ref TEXT,
+      raw_excerpt TEXT,
+      created_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS user_turns (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      turn_index INTEGER NOT NULL,
+      raw_text TEXT,
+      blob_ref TEXT,
+      raw_excerpt TEXT,
+      correction_detected INTEGER NOT NULL DEFAULT 0,
+      correction_cue TEXT,
+      references_assistant_turn_id INTEGER,
+      created_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS tool_calls (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      tool_name TEXT NOT NULL,
+      outcome TEXT NOT NULL,
+      duration_ms INTEGER,
+      exit_code INTEGER,
+      error_type TEXT,
+      error_message TEXT,
+      gfi_before REAL,
+      gfi_after REAL,
+      params_json TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS pain_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      source TEXT NOT NULL,
+      score REAL NOT NULL,
+      reason TEXT,
+      severity TEXT,
+      origin TEXT,
+      confidence REAL,
+      text TEXT,
+      created_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS gate_blocks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT,
+      tool_name TEXT NOT NULL,
+      file_path TEXT,
+      reason TEXT NOT NULL,
+      plan_status TEXT,
+      created_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS trust_changes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT,
+      previous_score REAL NOT NULL,
+      new_score REAL NOT NULL,
+      delta REAL NOT NULL,
+      reason TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS principle_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      principle_id TEXT,
+      event_type TEXT NOT NULL,
+      payload_json TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS task_outcomes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      task_id TEXT,
+      outcome TEXT NOT NULL,
+      summary TEXT,
+      principle_ids_json TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS correction_samples (
+      sample_id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      bad_assistant_turn_id INTEGER NOT NULL,
+      user_correction_turn_id INTEGER NOT NULL,
+      recovery_tool_span_json TEXT NOT NULL,
+      diff_excerpt TEXT NOT NULL,
+      principle_ids_json TEXT NOT NULL,
+      quality_score REAL NOT NULL,
+      review_status TEXT NOT NULL,
+      export_mode TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS sample_reviews (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      sample_id TEXT NOT NULL,
+      review_status TEXT NOT NULL,
+      note TEXT,
+      created_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS exports_audit (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      export_kind TEXT NOT NULL,
+      mode TEXT NOT NULL,
+      approved_only INTEGER NOT NULL,
+      file_path TEXT NOT NULL,
+      row_count INTEGER NOT NULL,
+      created_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS evolution_tasks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      task_id TEXT UNIQUE NOT NULL,
+      trace_id TEXT NOT NULL,
+      source TEXT NOT NULL,
+      reason TEXT,
+      score INTEGER DEFAULT 0,
+      status TEXT DEFAULT 'pending',
+      enqueued_at TEXT,
+      started_at TEXT,
+      completed_at TEXT,
+      resolution TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS evolution_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      trace_id TEXT NOT NULL,
+      task_id TEXT,
+      stage TEXT NOT NULL,
+      level TEXT DEFAULT 'info',
+      message TEXT NOT NULL,
+      summary TEXT,
+      metadata_json TEXT,
+      created_at TEXT NOT NULL
+    );
+  `);
+    // Migration: Add text column to pain_events if it doesn't exist (MEM-01)
+    // SQLite doesn't support IF NOT EXISTS for ADD COLUMN, so we use try/catch
+    try {
+        db.exec(`ALTER TABLE pain_events ADD COLUMN text TEXT`);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (!message.includes('duplicate column name') && !message.includes('no column named')) {
+            // Re-throw unexpected errors — silently swallowing migration failures is dangerous
+            throw err;
+        }
+    }
+    // PRI-406: Add canonical_pain_id and runtime_task_id columns to pain_events
+    for (const col of [
+        { name: 'canonical_pain_id', type: 'TEXT' },
+        { name: 'runtime_task_id', type: 'TEXT' },
+    ]) {
+        try {
+            db.exec(`ALTER TABLE pain_events ADD COLUMN ${col.name} ${col.type}`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (!message.includes('duplicate column name') && !message.includes('no column named')) {
+                throw err;
+            }
+        }
+    }
+    // Trajectory enhancement: add stop_reason, thinking_blocks_count, result_preview
+    const trajectoryEnhancementColumns = [
+        { table: 'assistant_turns', name: 'stop_reason', type: 'TEXT' },
+        { table: 'assistant_turns', name: 'thinking_blocks_count', type: 'INTEGER' },
+        { table: 'tool_calls', name: 'result_preview', type: 'TEXT' },
+    ];
+    for (const col of trajectoryEnhancementColumns) {
+        try {
+            db.exec(`ALTER TABLE ${col.table} ADD COLUMN ${col.name} ${col.type}`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (!message.includes('duplicate column name') && !message.includes('no column named')) {
+                throw err;
+            }
+        }
+    }
+    // PRI-406: Partial unique index on canonical_pain_id (non-null only) for dedup
+    db.exec(`
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_pain_events_canonical_pain_id
+    ON pain_events(canonical_pain_id)
+    WHERE canonical_pain_id IS NOT NULL
+  `);
+    // V2 migration: Add V2 columns to evolution_tasks if they don't exist
+    const v2Columns = [
+        { name: 'task_kind', type: 'TEXT' },
+        { name: 'priority', type: 'TEXT' },
+        { name: 'retry_count', type: 'INTEGER' },
+        { name: 'max_retries', type: 'INTEGER' },
+        { name: 'last_error', type: 'TEXT' },
+        { name: 'result_ref', type: 'TEXT' },
+    ];
+    for (const col of v2Columns) {
+        const rows = db.prepare(`PRAGMA table_info(evolution_tasks)`).all();
+        const exists = rows.some((row) => {
+            if (typeof row !== 'object' || row === null)
+                return false;
+            // Use type guard predicate to narrow without `as` (rc-2-no-as-bypass)
+            return hasNameField(row) && row.name === col.name;
+        });
+        if (!exists) {
+            db.exec(`ALTER TABLE evolution_tasks ADD COLUMN ${col.name} ${col.type}`);
+        }
+    }
+    db.exec(`
+    CREATE VIEW IF NOT EXISTS v_error_clusters AS
+    SELECT tool_name, COALESCE(error_type, 'unknown') AS error_type, COUNT(*) AS occurrences
+    FROM tool_calls
+    WHERE outcome = 'failure'
+    GROUP BY tool_name, COALESCE(error_type, 'unknown')
+    ORDER BY occurrences DESC;
+    CREATE VIEW IF NOT EXISTS v_principle_effectiveness AS
+    SELECT event_type, COUNT(*) AS total
+    FROM principle_events
+    GROUP BY event_type
+    ORDER BY total DESC;
+    CREATE VIEW IF NOT EXISTS v_sample_queue AS
+    SELECT review_status, COUNT(*) AS total
+    FROM correction_samples
+    GROUP BY review_status;
+    CREATE INDEX IF NOT EXISTS idx_assistant_turns_session_id ON assistant_turns(session_id);
+    CREATE INDEX IF NOT EXISTS idx_assistant_turns_created_at ON assistant_turns(created_at);
+    CREATE INDEX IF NOT EXISTS idx_assistant_turns_provider_model ON assistant_turns(provider, model);
+    CREATE INDEX IF NOT EXISTS idx_user_turns_session_id ON user_turns(session_id);
+    CREATE INDEX IF NOT EXISTS idx_tool_calls_session_id ON tool_calls(session_id);
+    CREATE INDEX IF NOT EXISTS idx_tool_calls_created_at ON tool_calls(created_at);
+    CREATE INDEX IF NOT EXISTS idx_pain_events_session_id ON pain_events(session_id);
+    CREATE INDEX IF NOT EXISTS idx_correction_samples_review_status ON correction_samples(review_status);
+    CREATE INDEX IF NOT EXISTS idx_evolution_tasks_trace_id ON evolution_tasks(trace_id);
+    CREATE INDEX IF NOT EXISTS idx_evolution_tasks_status ON evolution_tasks(status);
+    CREATE INDEX IF NOT EXISTS idx_evolution_tasks_created_at ON evolution_tasks(created_at);
+    CREATE INDEX IF NOT EXISTS idx_evolution_events_trace_id ON evolution_events(trace_id);
+    CREATE INDEX IF NOT EXISTS idx_evolution_events_created_at ON evolution_events(created_at);
+  `);
+    return { tables, warnings };
+}
+/**
+ * Initialize trajectory.db schema at the given workspace directory.
+ *
+ * Opens trajectory.db in write mode, applies the full schema (tables + indexes + views +
+ * migrations), then closes the DB. Does NOT run importLegacyArtifacts() or
+ * pruneUnreferencedBlobs() — those are runtime side-effects of TrajectoryDatabase
+ * construction and are not needed for pure initialization.
+ *
+ * Idempotent: safe to call on an existing DB; all CREATE statements use IF NOT EXISTS.
+ *
+ * @returns list of created/verified table names and any warnings
+ */
+export function initTrajectorySchema(workspaceDir) {
+    const resolvedDir = path.resolve(workspaceDir);
+    const stateDir = resolvePdPath(resolvedDir, 'STATE_DIR');
+    const blobDir = resolvePdPath(resolvedDir, 'TRAJECTORY_BLOBS_DIR');
+    const exportDir = resolvePdPath(resolvedDir, 'EXPORTS_DIR');
+    const dbPath = resolvePdPath(resolvedDir, 'TRAJECTORY_DB');
+    fs.mkdirSync(stateDir, { recursive: true });
+    fs.mkdirSync(blobDir, { recursive: true });
+    fs.mkdirSync(exportDir, { recursive: true });
+    const db = new Database(dbPath);
+    try {
+        db.pragma('journal_mode = WAL');
+        db.pragma('foreign_keys = ON');
+        db.pragma('synchronous = NORMAL');
+        db.pragma(`busy_timeout = ${DEFAULT_BUSY_TIMEOUT_MS}`);
+        const result = applyTrajectorySchema(db);
+        // Record schema version (same logic as TrajectoryDatabase.initSchema)
+        const row = db.prepare('SELECT version FROM schema_version LIMIT 1').get();
+        if (!row) {
+            db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(SCHEMA_VERSION);
+        }
+        else if (row.version !== SCHEMA_VERSION) {
+            db.prepare('UPDATE schema_version SET version = ?').run(SCHEMA_VERSION);
+        }
+        return result;
+    }
+    finally {
+        db.close();
+    }
+}
 function nowIso() {
     return new Date().toISOString();
 }
@@ -170,60 +496,14 @@ export class TrajectoryDatabase {
                 }
             }
         });
-        // FTS indexing is best-effort — run outside the transaction so it cannot
-        // roll back the committed pain event row (MEM-03, MEM-04).
-        if (input.text && insertedId > 0) {
-            try {
-                this.db.prepare(`
-          INSERT INTO pain_events_fts (text, pain_event_id) VALUES (?, ?)
-        `).run(input.text, insertedId);
-            }
-            catch (err) {
-                // Non-fatal: FTS index is for search convenience, not correctness.
-                // Log but do not re-throw — the pain event itself is already committed.
-                console.warn(`[trajectory] FTS index insert failed for pain_event ${insertedId}: ${String(err)}`);
-            }
-        }
+        // FTS5 index write removed (PRI-451 Wave 1): the only reader (searchPainEvents)
+        // was dead code removed in Wave 1.1. The pain event row itself is committed
+        // above; nothing reads the FTS index anymore.
         return insertedId;
     }
-    /**
-     * Search pain_events using FTS5 full-text search (MEM-04).
-     * Returns pain events matching the query, ordered by relevance.
-     */
-    searchPainEvents(query, limit = 10) {
-        if (!query || query.trim().length === 0) {
-            return [];
-        }
-        // Escape FTS5 special characters and format query for porter tokenizer
-        const ftsQuery = query.trim().split(/\s+/).map(term => `"${term.replace(/"/g, '""')}"`).join(' ');
-        try {
-            const results = this.db.prepare(`
-        SELECT pe.*
-        FROM pain_events_fts pf
-        JOIN pain_events pe ON pe.id = pf.pain_event_id
-        WHERE pain_events_fts MATCH ?
-        ORDER BY bm25(pain_events_fts) DESC
-        LIMIT ?
-      `).all(ftsQuery, limit);
-            return results.map(row => ({
-                id: row.id,
-                sessionId: row.session_id,
-                source: row.source,
-                score: row.score,
-                reason: row.reason,
-                severity: row.severity,
-                origin: row.origin,
-                confidence: row.confidence,
-                text: row.text,
-                createdAt: row.created_at,
-            }));
-        }
-        catch (err) {
-            // If FTS5 query fails (e.g., syntax error), return empty results
-            console.warn(`[PD:TrajectoryDatabase] FTS5 search failed: ${String(err)}`);
-            return [];
-        }
-    }
+    // searchPainEvents removed (PRI-451 Wave 1): dead code. Its only caller was
+    // processDetectionQueue (also removed). The FTS5 index write it read is
+    // removed in Wave 1.2.
     recordGateBlock(input) {
         this.withWrite(() => {
             this.db.prepare(`
@@ -908,266 +1188,13 @@ export class TrajectoryDatabase {
         return this.pruneUnreferencedBlobs();
     }
     initSchema() {
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS schema_version (version INTEGER NOT NULL);
-      CREATE TABLE IF NOT EXISTS ingest_checkpoint (
-        source_key TEXT PRIMARY KEY,
-        imported_at TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS sessions (
-        session_id TEXT PRIMARY KEY,
-        started_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS assistant_turns (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        session_id TEXT NOT NULL,
-        run_id TEXT NOT NULL,
-        provider TEXT NOT NULL,
-        model TEXT NOT NULL,
-        raw_text TEXT,
-        sanitized_text TEXT NOT NULL,
-        usage_json TEXT NOT NULL,
-        empathy_signal_json TEXT NOT NULL,
-        blob_ref TEXT,
-        raw_excerpt TEXT,
-        created_at TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS user_turns (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        session_id TEXT NOT NULL,
-        turn_index INTEGER NOT NULL,
-        raw_text TEXT,
-        blob_ref TEXT,
-        raw_excerpt TEXT,
-        correction_detected INTEGER NOT NULL DEFAULT 0,
-        correction_cue TEXT,
-        references_assistant_turn_id INTEGER,
-        created_at TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS tool_calls (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        session_id TEXT NOT NULL,
-        tool_name TEXT NOT NULL,
-        outcome TEXT NOT NULL,
-        duration_ms INTEGER,
-        exit_code INTEGER,
-        error_type TEXT,
-        error_message TEXT,
-        gfi_before REAL,
-        gfi_after REAL,
-        params_json TEXT NOT NULL,
-        created_at TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS pain_events (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        session_id TEXT NOT NULL,
-        source TEXT NOT NULL,
-        score REAL NOT NULL,
-        reason TEXT,
-        severity TEXT,
-        origin TEXT,
-        confidence REAL,
-        text TEXT,
-        created_at TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS gate_blocks (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        session_id TEXT,
-        tool_name TEXT NOT NULL,
-        file_path TEXT,
-        reason TEXT NOT NULL,
-        plan_status TEXT,
-        created_at TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS trust_changes (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        session_id TEXT,
-        previous_score REAL NOT NULL,
-        new_score REAL NOT NULL,
-        delta REAL NOT NULL,
-        reason TEXT NOT NULL,
-        created_at TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS principle_events (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        principle_id TEXT,
-        event_type TEXT NOT NULL,
-        payload_json TEXT NOT NULL,
-        created_at TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS task_outcomes (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        session_id TEXT NOT NULL,
-        task_id TEXT,
-        outcome TEXT NOT NULL,
-        summary TEXT,
-        principle_ids_json TEXT NOT NULL,
-        created_at TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS correction_samples (
-        sample_id TEXT PRIMARY KEY,
-        session_id TEXT NOT NULL,
-        bad_assistant_turn_id INTEGER NOT NULL,
-        user_correction_turn_id INTEGER NOT NULL,
-        recovery_tool_span_json TEXT NOT NULL,
-        diff_excerpt TEXT NOT NULL,
-        principle_ids_json TEXT NOT NULL,
-        quality_score REAL NOT NULL,
-        review_status TEXT NOT NULL,
-        export_mode TEXT NOT NULL,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS sample_reviews (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        sample_id TEXT NOT NULL,
-        review_status TEXT NOT NULL,
-        note TEXT,
-        created_at TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS exports_audit (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        export_kind TEXT NOT NULL,
-        mode TEXT NOT NULL,
-        approved_only INTEGER NOT NULL,
-        file_path TEXT NOT NULL,
-        row_count INTEGER NOT NULL,
-        created_at TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS evolution_tasks (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        task_id TEXT UNIQUE NOT NULL,
-        trace_id TEXT NOT NULL,
-        source TEXT NOT NULL,
-        reason TEXT,
-        score INTEGER DEFAULT 0,
-        status TEXT DEFAULT 'pending',
-        enqueued_at TEXT,
-        started_at TEXT,
-        completed_at TEXT,
-        resolution TEXT,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS evolution_events (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        trace_id TEXT NOT NULL,
-        task_id TEXT,
-        stage TEXT NOT NULL,
-        level TEXT DEFAULT 'info',
-        message TEXT NOT NULL,
-        summary TEXT,
-        metadata_json TEXT,
-        created_at TEXT NOT NULL
-      );
-    `);
-        // Migration: Add text column to pain_events if it doesn't exist (MEM-01)
-        // SQLite doesn't support IF NOT EXISTS for ADD COLUMN, so we use try/catch
-        try {
-            this.db.exec(`ALTER TABLE pain_events ADD COLUMN text TEXT`);
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            if (!message.includes('duplicate column name') && !message.includes('no column named')) {
-                // Re-throw unexpected errors — silently swallowing migration failures is dangerous
-                throw err;
-            }
-        }
-        // PRI-406: Add canonical_pain_id and runtime_task_id columns to pain_events
-        for (const col of [
-            { name: 'canonical_pain_id', type: 'TEXT' },
-            { name: 'runtime_task_id', type: 'TEXT' },
-        ]) {
-            try {
-                this.db.exec(`ALTER TABLE pain_events ADD COLUMN ${col.name} ${col.type}`);
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                if (!message.includes('duplicate column name') && !message.includes('no column named')) {
-                    throw err;
-                }
-            }
-        }
-        // Trajectory enhancement: add stop_reason, thinking_blocks_count, result_preview
-        const trajectoryEnhancementColumns = [
-            { table: 'assistant_turns', name: 'stop_reason', type: 'TEXT' },
-            { table: 'assistant_turns', name: 'thinking_blocks_count', type: 'INTEGER' },
-            { table: 'tool_calls', name: 'result_preview', type: 'TEXT' },
-        ];
-        for (const col of trajectoryEnhancementColumns) {
-            try {
-                this.db.exec(`ALTER TABLE ${col.table} ADD COLUMN ${col.name} ${col.type}`);
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                if (!message.includes('duplicate column name') && !message.includes('no column named')) {
-                    throw err;
-                }
-            }
+        const result = applyTrajectorySchema(this.db);
+        // Best-effort: surface any warnings from schema initialization (rc-9: no silent fallback).
+        // Warnings include failed migrations or view creation issues; surfaced via console.info
+        // because TrajectoryDatabase does not have a warnings buffer at this layer.
+        for (const w of result.warnings) {
+            console.info(`[PD:TrajectoryDatabase] schema init warning: ${w}`);
         }
-        // PRI-406: Partial unique index on canonical_pain_id (non-null only) for dedup
-        this.db.exec(`
-      CREATE UNIQUE INDEX IF NOT EXISTS idx_pain_events_canonical_pain_id
-      ON pain_events(canonical_pain_id)
-      WHERE canonical_pain_id IS NOT NULL
-    `);
-        // Create FTS5 virtual table for pain_events text search (MEM-04)
-        this.db.exec(`
-      CREATE VIRTUAL TABLE IF NOT EXISTS pain_events_fts USING fts5(
-        text,
-        pain_event_id UNINDEXED,
-        tokenize='porter unicode61'
-      )
-    `);
-        // V2 migration: Add V2 columns to evolution_tasks if they don't exist
-        // SQLite does not support IF NOT EXISTS for ADD COLUMN, so we must check manually
-        // before each ALTER to avoid "duplicate column name" errors on existing DBs
-        const v2Columns = [
-            { name: 'task_kind', type: 'TEXT' },
-            { name: 'priority', type: 'TEXT' },
-            { name: 'retry_count', type: 'INTEGER' },
-            { name: 'max_retries', type: 'INTEGER' },
-            { name: 'last_error', type: 'TEXT' },
-            { name: 'result_ref', type: 'TEXT' },
-        ];
-        for (const col of v2Columns) {
-            const exists = this.db.prepare(`PRAGMA table_info(evolution_tasks)`).all()
-                .some((row) => row.name === col.name);
-            if (!exists) {
-                this.db.exec(`ALTER TABLE evolution_tasks ADD COLUMN ${col.name} ${col.type}`);
-            }
-        }
-        this.db.exec(`
-      CREATE VIEW IF NOT EXISTS v_error_clusters AS
-      SELECT tool_name, COALESCE(error_type, 'unknown') AS error_type, COUNT(*) AS occurrences
-      FROM tool_calls
-      WHERE outcome = 'failure'
-      GROUP BY tool_name, COALESCE(error_type, 'unknown')
-      ORDER BY occurrences DESC;
-      CREATE VIEW IF NOT EXISTS v_principle_effectiveness AS
-      SELECT event_type, COUNT(*) AS total
-      FROM principle_events
-      GROUP BY event_type
-      ORDER BY total DESC;
-      CREATE VIEW IF NOT EXISTS v_sample_queue AS
-      SELECT review_status, COUNT(*) AS total
-      FROM correction_samples
-      GROUP BY review_status;
-      CREATE INDEX IF NOT EXISTS idx_assistant_turns_session_id ON assistant_turns(session_id);
-      CREATE INDEX IF NOT EXISTS idx_assistant_turns_created_at ON assistant_turns(created_at);
-      CREATE INDEX IF NOT EXISTS idx_assistant_turns_provider_model ON assistant_turns(provider, model);
-      CREATE INDEX IF NOT EXISTS idx_user_turns_session_id ON user_turns(session_id);
-      CREATE INDEX IF NOT EXISTS idx_tool_calls_session_id ON tool_calls(session_id);
-      CREATE INDEX IF NOT EXISTS idx_tool_calls_created_at ON tool_calls(created_at);
-      CREATE INDEX IF NOT EXISTS idx_pain_events_session_id ON pain_events(session_id);
-      CREATE INDEX IF NOT EXISTS idx_correction_samples_review_status ON correction_samples(review_status);
-      CREATE INDEX IF NOT EXISTS idx_evolution_tasks_trace_id ON evolution_tasks(trace_id);
-      CREATE INDEX IF NOT EXISTS idx_evolution_tasks_status ON evolution_tasks(status);
-      CREATE INDEX IF NOT EXISTS idx_evolution_tasks_created_at ON evolution_tasks(created_at);
-      CREATE INDEX IF NOT EXISTS idx_evolution_events_trace_id ON evolution_events(trace_id);
-      CREATE INDEX IF NOT EXISTS idx_evolution_events_created_at ON evolution_events(created_at);
-    `);
         const row = this.db.prepare('SELECT version FROM schema_version LIMIT 1').get();
         this.migrateSchema(row?.version);
         if (!row) {

package/plugin/dist/core/workspace-context.d.ts

@@ -6,12 +6,11 @@ import { HygieneTracker } from './hygiene/tracker.js';
 import { EvolutionReducerImpl } from './evolution-reducer.js';
 import type { TrajectoryDatabase } from './trajectory.js';
 import { PrincipleLifecycleService } from './principle-internalization/principle-lifecycle-service.js';
-import { type PrincipleSubtree } from './principle-tree-ledger.js';
-import type { Principle, PrincipleValueMetrics } from '../types/principle-tree-schema.js';
+import { type PrincipleSubtree, type LedgerPrinciple, type PrincipleValueMetrics } from './principle-tree-ledger.js';
 import type { Principle as ActivePrinciple } from './evolution-types.js';
 interface PrincipleTreeLedgerAccessor {
     getPrincipleSubtree(_principleId: string): PrincipleSubtree | undefined;
-    updatePrinciple(_principleId: string, updates: Partial<Principle>): Principle;
+    updatePrinciple(_principleId: string, updates: Partial<LedgerPrinciple>): LedgerPrinciple;
     updatePrincipleValueMetrics(principleId: string, _metrics: PrincipleValueMetrics): PrincipleValueMetrics;
 }
 /**