principles-disciple 1.154.0 → 1.155.0

package/dist/core/control-ui-db.d.ts

@@ -102,5 +102,16 @@ export declare class ControlUiDatabase {
     run(sql: string, ...params: unknown[]): void;
     restoreRawText(inlineText?: string | null, blobRef?: string | null): string;
     private initSchema;
+    /**
+     * Create or replace a view, tolerating missing dependency tables.
+     *
+     * Views in ControlUiDatabase depend on tables created by TrajectoryDatabase
+     * (assistant_turns, tool_calls, pain_events, user_turns, correction_samples).
+     * If ControlUiDatabase is constructed before TrajectoryDatabase has created
+     * those tables, CREATE VIEW would throw. We DROP+CREATE with try/catch so
+     * missing-dependency views are skipped with a warning (rc-9: surfaced via
+     * console.info) rather than aborting schema initialization.
+     */
+    private createViewSafely;
     private withWrite;
 }

package/dist/core/control-ui-db.js

@@ -180,9 +180,15 @@ export class ControlUiDatabase {
         ON thinking_model_events(assistant_turn_id);
       CREATE INDEX IF NOT EXISTS idx_thinking_model_events_run_id
         ON thinking_model_events(run_id);
-
-      DROP VIEW IF EXISTS v_thinking_model_usage;
-      CREATE VIEW v_thinking_model_usage AS
+    `);
+        // Views depend on tables owned by TrajectoryDatabase (assistant_turns, tool_calls,
+        // pain_events, user_turns, correction_samples). If ControlUiDatabase is constructed
+        // before TrajectoryDatabase has run initSchema (e.g. llm_output is the first hook
+        // triggered on a fresh workspace), CREATE VIEW would throw and break the hook.
+        // Wrap each view creation in try/catch so missing-dependency views are skipped with
+        // a warning rather than aborting schema initialization (rc-9: no silent fallback —
+        // failures are surfaced via console.info).
+        this.createViewSafely('v_thinking_model_usage', `
       WITH totals AS (
         SELECT COUNT(*) AS assistant_turns FROM assistant_turns
       ),
@@ -205,10 +211,9 @@ export class ControlUiDatabase {
           ELSE ROUND(CAST(usage_rows.distinct_turns AS REAL) / CAST(totals.assistant_turns AS REAL), 4)
         END AS coverage_rate
       FROM usage_rows, totals
-      ORDER BY usage_rows.hits DESC, usage_rows.model_id ASC;
-
-      DROP VIEW IF EXISTS v_thinking_model_effectiveness;
-      CREATE VIEW v_thinking_model_effectiveness AS
+      ORDER BY usage_rows.hits DESC, usage_rows.model_id ASC
+    `);
+        this.createViewSafely('v_thinking_model_effectiveness', `
       WITH event_windows AS (
         SELECT
           e.id,
@@ -274,10 +279,9 @@ export class ControlUiDatabase {
         ) THEN 1 ELSE 0 END) AS correction_sample_windows
       FROM bounded_windows b
       GROUP BY b.model_id
-      ORDER BY events DESC, model_id ASC;
-
-      DROP VIEW IF EXISTS v_thinking_model_scenarios;
-      CREATE VIEW v_thinking_model_scenarios AS
+      ORDER BY events DESC, model_id ASC
+    `);
+        this.createViewSafely('v_thinking_model_scenarios', `
       SELECT
         e.model_id AS model_id,
         CAST(j.value AS TEXT) AS scenario,
@@ -290,19 +294,39 @@ export class ControlUiDatabase {
         END
       ) AS j
       GROUP BY e.model_id, CAST(j.value AS TEXT)
-      ORDER BY hits DESC, scenario ASC;
-
-      DROP VIEW IF EXISTS v_thinking_model_daily_trend;
-      CREATE VIEW v_thinking_model_daily_trend AS
+      ORDER BY hits DESC, scenario ASC
+    `);
+        this.createViewSafely('v_thinking_model_daily_trend', `
       SELECT
         substr(created_at, 1, 10) AS day,
         model_id,
         COUNT(*) AS hits
       FROM thinking_model_events
       GROUP BY substr(created_at, 1, 10), model_id
-      ORDER BY day ASC, model_id ASC;
+      ORDER BY day ASC, model_id ASC
     `);
     }
+    /**
+     * Create or replace a view, tolerating missing dependency tables.
+     *
+     * Views in ControlUiDatabase depend on tables created by TrajectoryDatabase
+     * (assistant_turns, tool_calls, pain_events, user_turns, correction_samples).
+     * If ControlUiDatabase is constructed before TrajectoryDatabase has created
+     * those tables, CREATE VIEW would throw. We DROP+CREATE with try/catch so
+     * missing-dependency views are skipped with a warning (rc-9: surfaced via
+     * console.info) rather than aborting schema initialization.
+     */
+    createViewSafely(viewName, viewBody) {
+        try {
+            this.db.exec(`DROP VIEW IF EXISTS ${viewName};`);
+            this.db.exec(`CREATE VIEW ${viewName} AS ${viewBody};`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            // rc-9: surface the failure — do not silently swallow
+            console.info(`[PD:ControlUiDatabase] view ${viewName} creation skipped: ${message}. It will be created on next TrajectoryDatabase initSchema().`);
+        }
+    }
     withWrite(fn) {
         return withLock(this.dbPath, fn, { lockSuffix: '.trajectory.lock', lockStaleMs: 30000 });
     }

package/dist/core/trajectory.d.ts

@@ -1,5 +1,21 @@
 import type { CorrectionSampleReviewStatus, CorrectionExportMode, TrajectoryDataStats, TrajectoryAssistantTurnInput, TrajectoryUserTurnInput, TrajectoryToolCallInput, TrajectoryPainEventInput, TrajectoryGateBlockInput, TrajectoryTrustChangeInput, TrajectoryPrincipleEventInput, TrajectoryTaskOutcomeInput, TrajectorySessionInput, EvolutionTaskInput, EvolutionEventInput, EvolutionTaskRecord, EvolutionEventRecord, EvolutionTaskFilters, AssistantTurnRecord, CorrectionSampleRecord, TrajectoryExportResult, TrajectoryDatabaseOptions } from './trajectory-types.js';
 export type { CorrectionSampleReviewStatus, CorrectionExportMode, TrajectoryDataStats, TrajectoryAssistantTurnInput, TrajectoryUserTurnInput, TrajectoryToolCallInput, TrajectoryPainEventInput, TrajectoryGateBlockInput, DailyMetricRow, TrajectoryTrustChangeInput, TrajectoryPrincipleEventInput, TrajectoryTaskOutcomeInput, TrajectorySessionInput, TaskKind, TaskPriority, EvolutionTaskInput, EvolutionEventInput, EvolutionTaskRecord, EvolutionEventRecord, EvolutionTaskFilters, AssistantTurnRecord, CorrectionSampleRecord, TrajectoryExportResult, TrajectoryDatabaseOptions, } from './trajectory-types.js';
+/**
+ * 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 declare function initTrajectorySchema(workspaceDir: string): {
+    tables: string[];
+    warnings: string[];
+};
 export declare class TrajectoryDatabase {
     private readonly workspaceDir;
     private readonly stateDir;

package/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();
 }
@@ -862,261 +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;
-            }
+        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: 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;
-                }
-            }
-        }
-        // 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
-    `);
-        // pain_events_fts FTS5 virtual table creation removed (PRI-451 Wave 1):
-        // the only reader (searchPainEvents) was dead code. Existing DBs keep the
-        // orphan table harmlessly (CREATE was IF NOT EXISTS); new DBs skip it.
-        // 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/dist/index.d.ts

@@ -47,4 +47,6 @@ declare const plugin: {
 };
 export { PrincipleTreeLedgerAdapter } from '@principles/core/runtime-v2';
 export { loadFeatureFlagFromWorkspace, isRecord };
+export { initTrajectorySchema } from './core/trajectory.js';
+export { initWorkflowSchema } from './service/subagent-workflow/workflow-store.js';
 export default plugin;

package/dist/index.js

@@ -747,4 +747,9 @@ const plugin = {
 export { PrincipleTreeLedgerAdapter } from '@principles/core/runtime-v2';
 /* istanbul ignore next — test exports for evolution worker gate */
 export { loadFeatureFlagFromWorkspace, isRecord };
+// Schema initialization exports for `pd runtime init` (unified DB init).
+// These functions open the DB in write mode, apply the full schema, and close the DB.
+// They do NOT run runtime side-effects (importLegacyArtifacts, pruneUnreferencedBlobs).
+export { initTrajectorySchema } from './core/trajectory.js';
+export { initWorkflowSchema } from './service/subagent-workflow/workflow-store.js';
 export default plugin;

package/dist/service/subagent-workflow/workflow-store.d.ts

@@ -28,3 +28,17 @@ export declare class WorkflowStore {
     recordDuration(workflowId: string, durationMs: number): void;
     getCompletionDurations(workflowType: string, limit?: number): number[];
 }
+/**
+ * Initialize subagent_workflows.db schema at the given workspace directory.
+ *
+ * Opens the DB in write mode, applies the full schema (tables + indexes + migrations),
+ * then closes the DB. Used by `pd runtime init` for unified DB 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 declare function initWorkflowSchema(workspaceDir: string): {
+    tables: string[];
+    warnings: string[];
+};

package/dist/service/subagent-workflow/workflow-store.js

@@ -78,8 +78,12 @@ export class WorkflowStore {
                 this.db.exec('ALTER TABLE subagent_workflows ADD COLUMN duration_ms INTEGER');
                 console.info(`[PD:WorkflowStore] Schema migration v${fromVersion} → v${toVersion}: added duration_ms column`);
             }
-            catch {
-                void 0;
+            catch (err) {
+                // rc-9: surface failure reason instead of silent void 0
+                const message = err instanceof Error ? err.message : String(err);
+                if (!message.includes('duplicate column name')) {
+                    console.info(`[PD:WorkflowStore] Schema migration v${fromVersion} → v${toVersion} failed: ${message}`);
+                }
             }
         }
     }
@@ -207,3 +211,88 @@ export class WorkflowStore {
         return rows.map(r => r.duration_ms);
     }
 }
+/**
+ * Initialize subagent_workflows.db schema at the given workspace directory.
+ *
+ * Opens the DB in write mode, applies the full schema (tables + indexes + migrations),
+ * then closes the DB. Used by `pd runtime init` for unified DB 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 initWorkflowSchema(workspaceDir) {
+    const resolvedDir = path.resolve(workspaceDir);
+    const stateDir = path.join(resolvedDir, '.state');
+    const dbPath = path.join(stateDir, 'subagent_workflows.db');
+    const warnings = [];
+    const tables = ['schema_version', 'subagent_workflows', 'subagent_workflow_events'];
+    fs.mkdirSync(stateDir, { 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}`);
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS schema_version (
+                version INTEGER NOT NULL
+            );
+            CREATE TABLE IF NOT EXISTS subagent_workflows (
+                workflow_id TEXT PRIMARY KEY,
+                workflow_type TEXT NOT NULL,
+                transport TEXT NOT NULL,
+                parent_session_id TEXT NOT NULL,
+                child_session_key TEXT NOT NULL,
+                run_id TEXT,
+                state TEXT NOT NULL DEFAULT 'pending',
+                cleanup_state TEXT NOT NULL DEFAULT 'none',
+                created_at INTEGER NOT NULL,
+                updated_at INTEGER NOT NULL,
+                last_observed_at INTEGER,
+                duration_ms INTEGER,
+                metadata_json TEXT NOT NULL DEFAULT '{}'
+            );
+            CREATE TABLE IF NOT EXISTS subagent_workflow_events (
+                workflow_id TEXT NOT NULL,
+                event_type TEXT NOT NULL,
+                from_state TEXT,
+                to_state TEXT NOT NULL,
+                reason TEXT NOT NULL,
+                payload_json TEXT NOT NULL DEFAULT '{}',
+                created_at INTEGER NOT NULL,
+                FOREIGN KEY (workflow_id) REFERENCES subagent_workflows(workflow_id) ON DELETE CASCADE
+            );
+            CREATE INDEX IF NOT EXISTS idx_workflows_parent_session ON subagent_workflows(parent_session_id);
+            CREATE INDEX IF NOT EXISTS idx_workflows_child_session ON subagent_workflows(child_session_key);
+            CREATE INDEX IF NOT EXISTS idx_workflows_state ON subagent_workflows(state);
+            CREATE INDEX IF NOT EXISTS idx_workflows_type ON subagent_workflows(workflow_type);
+            CREATE INDEX IF NOT EXISTS idx_events_workflow ON subagent_workflow_events(workflow_id);
+        `);
+        // Run migrations to bring schema up to SCHEMA_VERSION
+        const row = db.prepare('SELECT version FROM schema_version LIMIT 1').get();
+        const currentVersion = row?.version ?? 0;
+        if (currentVersion === 0) {
+            db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(SCHEMA_VERSION);
+        }
+        else if (currentVersion < SCHEMA_VERSION) {
+            // Inline migration logic (mirrors WorkflowStore.runMigrations)
+            if (currentVersion < 2 && SCHEMA_VERSION >= 2) {
+                try {
+                    db.exec('ALTER TABLE subagent_workflows ADD COLUMN duration_ms INTEGER');
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    if (!message.includes('duplicate column name')) {
+                        warnings.push(`migration v${currentVersion}→v${SCHEMA_VERSION} duration_ms failed: ${message}`);
+                    }
+                }
+            }
+            db.prepare('UPDATE schema_version SET version = ?').run(SCHEMA_VERSION);
+        }
+        return { tables, warnings };
+    }
+    finally {
+        db.close();
+    }
+}

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
-  "version": "1.154.0",
+  "version": "1.155.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "principles-disciple",
-  "version": "1.154.0",
+  "version": "1.155.0",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
-  "main": "./dist/bundle.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/bundle.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
   },
   "repository": {
     "type": "git",