create-principles-disciple 1.0.0 → 1.74.0

package/plugin/dist/core/runtime-v2-prompt-activation-reader.js

@@ -0,0 +1,181 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import * as yaml from 'js-yaml';
+import { SqliteConnection, SqliteActivationStateStore, computeEffectiveFlags, DEFAULT_FEATURE_FLAGS } from '@principles/core/runtime-v2';
+export const RUNTIME_V2_PRINCIPLE_BUDGET = 2000;
+const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+export class PromptActivationReader {
+    workspaceDir;
+    deps;
+    constructor(workspaceDir, deps) {
+        this.workspaceDir = workspaceDir;
+        this.deps = deps ?? {};
+    }
+    async readActivatedPrinciples() {
+        const warnings = [];
+        const principles = [];
+        const flags = this.loadFeatureFlags();
+        const promptFlag = flags.flags['prompt'];
+        if (!promptFlag || !promptFlag.enabled) {
+            this.deps.logger?.info?.(`[PD:RuntimeV2] Prompt feature flag disabled — skipping Runtime V2 activation read`);
+            return { principles, warnings: ['prompt_feature_disabled'], source: 'runtime_v2' };
+        }
+        let sqliteConn = null;
+        try {
+            sqliteConn = new SqliteConnection(this.workspaceDir);
+            const store = new SqliteActivationStateStore(sqliteConn);
+            const activations = await store.listPromptActivations();
+            for (const activation of activations) {
+                if (activation.channel !== 'prompt' || activation.action !== 'prompt_activate') {
+                    continue;
+                }
+                const result = this.resolvePrincipleFromActivation(sqliteConn, activation);
+                if (result.ok) {
+                    principles.push(result.principle);
+                }
+                else {
+                    warnings.push(result.warning);
+                    this.deps.logger?.warn?.(`[PD:RuntimeV2] ${result.warning}`);
+                }
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            const warning = `activation_db_unreadable: ${msg}; nextAction=check_workspace_pd_state_db`;
+            warnings.push(warning);
+            this.deps.logger?.warn?.(`[PD:RuntimeV2] ${warning}`);
+        }
+        finally {
+            try {
+                sqliteConn?.close();
+            }
+            catch {
+                // best-effort
+            }
+        }
+        return { principles, warnings, source: 'runtime_v2' };
+    }
+    loadFeatureFlags() {
+        const configPath = path.join(this.workspaceDir, '.pd', 'feature-flags.yaml');
+        if (!fs.existsSync(configPath)) {
+            return computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath);
+        }
+        let raw;
+        try {
+            raw = fs.readFileSync(configPath, 'utf8');
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            this.deps.logger?.warn?.(`[PD:RuntimeV2] Feature flags unreadable: ${msg} — using defaults`);
+            return computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath);
+        }
+        let parsed;
+        try {
+            parsed = yaml.load(raw, { schema: yaml.JSON_SCHEMA });
+        }
+        catch {
+            this.deps.logger?.warn?.(`[PD:RuntimeV2] Feature flags YAML parse error — using defaults`);
+            return {
+                ...computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath),
+                warnings: ['feature-flags.yaml: YAML parse error, using defaults'],
+            };
+        }
+        if (!isRecord(parsed)) {
+            this.deps.logger?.warn?.(`[PD:RuntimeV2] Feature flags not a mapping — using defaults`);
+            return {
+                ...computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath),
+                warnings: ['feature-flags.yaml: expected a mapping, using defaults'],
+            };
+        }
+        const parsedRecord = Object.create(null);
+        const yamlWarnings = [];
+        for (const key of Object.keys(parsed)) {
+            if (DANGEROUS_KEYS.has(key)) {
+                yamlWarnings.push(`feature-flags.yaml: dangerous key '${key}' rejected`);
+                continue;
+            }
+            if (Object.hasOwn(parsed, key)) {
+                parsedRecord[key] = parsed[key];
+            }
+        }
+        const result = computeEffectiveFlags(parsedRecord, DEFAULT_FEATURE_FLAGS, configPath);
+        if (yamlWarnings.length > 0) {
+            result.warnings = [...yamlWarnings, ...result.warnings];
+            for (const w of yamlWarnings) {
+                this.deps.logger?.warn?.(`[PD:RuntimeV2] ${w}`);
+            }
+        }
+        return result;
+    }
+    resolvePrincipleFromActivation(sqliteConn, activation) {
+        const db = sqliteConn.getDb();
+        let contentJson;
+        try {
+            const row = db.prepare(`
+        SELECT artifact_id, artifact_kind, content_json, validation_status
+        FROM pi_artifacts
+        WHERE artifact_id = ?
+      `).get(activation.artifactId);
+            if (!isRecord(row)) {
+                return { ok: false, warning: `artifact_query_unexpected: artifactId=${activation.artifactId}; nextAction=check_pi_artifacts_table` };
+            }
+            const artifact_id = Object.hasOwn(row, 'artifact_id') && typeof row.artifact_id === 'string' && row.artifact_id.length > 0 ? row.artifact_id : null;
+            const artifact_kind = Object.hasOwn(row, 'artifact_kind') && typeof row.artifact_kind === 'string' ? row.artifact_kind : null;
+            const raw_content_json = Object.hasOwn(row, 'content_json') && typeof row.content_json === 'string' ? row.content_json : null;
+            const validation_status = Object.hasOwn(row, 'validation_status') && typeof row.validation_status === 'string' ? row.validation_status : null;
+            if (!artifact_id) {
+                return { ok: false, warning: `artifact_not_found: artifactId=${activation.artifactId} activationId=${activation.activationId}; nextAction=verify_artifact_exists_or_remove_stale_activation` };
+            }
+            if (artifact_kind !== 'principle') {
+                return { ok: false, warning: `artifact_not_principle: artifactId=${artifact_id} kind=${artifact_kind ?? 'missing'}; nextAction=skip_non_principle_activations` };
+            }
+            if (validation_status !== 'validated') {
+                return { ok: false, warning: `artifact_not_validated: artifactId=${artifact_id} status=${validation_status ?? 'missing'}; nextAction=skip_unvalidated_artifacts` };
+            }
+            if (raw_content_json === null) {
+                return { ok: false, warning: `artifact_missing_content_json: artifactId=${artifact_id}; nextAction=ensure_artifact_has_content_json` };
+            }
+            contentJson = raw_content_json;
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return { ok: false, warning: `artifact_query_failed: artifactId=${activation.artifactId} reason=${msg}; nextAction=check_pi_artifacts_table` };
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(contentJson);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return { ok: false, warning: `artifact_content_json_parse_error: artifactId=${activation.artifactId} reason=${msg}; nextAction=fix_artifact_content_json` };
+        }
+        if (!isRecord(parsed)) {
+            return { ok: false, warning: `artifact_content_malformed: artifactId=${activation.artifactId} reason=parsed_to_non_object; nextAction=fix_artifact_content_json` };
+        }
+        const principleId = Object.hasOwn(parsed, 'principleId') && typeof parsed.principleId === 'string' ? parsed.principleId : undefined;
+        const text = Object.hasOwn(parsed, 'text') && typeof parsed.text === 'string' ? parsed.text : undefined;
+        const draftObj = Object.hasOwn(parsed, 'principleDraft') && isRecord(parsed.principleDraft) ? parsed.principleDraft : null;
+        const draftTitle = draftObj && Object.hasOwn(draftObj, 'title') && typeof draftObj.title === 'string' ? draftObj.title : undefined;
+        const draftStatement = draftObj && Object.hasOwn(draftObj, 'statement') && typeof draftObj.statement === 'string' ? draftObj.statement : undefined;
+        const resolvedPrincipleId = principleId && principleId.length > 0 ? principleId : draftTitle;
+        const resolvedText = text && text.length > 0 ? text : draftStatement;
+        if (!resolvedPrincipleId || resolvedPrincipleId.length === 0) {
+            return { ok: false, warning: `artifact_missing_principle_id: artifactId=${activation.artifactId}; nextAction=ensure_artifact_has_principleId_or_principleDraft_title` };
+        }
+        if (!resolvedText || resolvedText.length === 0) {
+            return { ok: false, warning: `artifact_missing_text: artifactId=${activation.artifactId} principleId=${resolvedPrincipleId}; nextAction=ensure_artifact_has_text_or_principleDraft_statement` };
+        }
+        return {
+            ok: true,
+            principle: {
+                principleId: resolvedPrincipleId,
+                text: resolvedText,
+                artifactId: activation.artifactId,
+                activationId: activation.activationId,
+            },
+        };
+    }
+}

package/plugin/dist/core/schema/db-types.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Shared type definitions for database operations.
+ * Kept separate to avoid circular dependencies between schema-definitions and migration-runner.
+ */
+/** Minimal interface for better-sqlite3 Database instances. */
+export interface Db {
+    exec(_sql: string): unknown;
+    get<T = unknown>(_sql: string, ..._params: unknown[]): T | undefined;
+    run(_sql: string, ..._params: unknown[]): unknown;
+    close(): void;
+}

package/plugin/dist/core/schema/db-types.js

@@ -0,0 +1,5 @@
+/**
+ * Shared type definitions for database operations.
+ * Kept separate to avoid circular dependencies between schema-definitions and migration-runner.
+ */
+export {};

package/plugin/dist/core/schema/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Schema Management — Unified database schema definitions and migrations.
+ *
+ * Usage:
+ *   // In a database class constructor:
+ *   import { ensureDatabaseSchema } from './schema';
+ *   ensureDatabaseSchema(db, 'trajectory.db');
+ *
+ * CLI:
+ *   node scripts/db-migrate.mjs status
+ *   node scripts/db-migrate.mjs run
+ */
+export { MigrationRunner, ensureDatabaseSchema } from './migration-runner.js';
+export { SCHEMAS, getCatalog, DB_TYPES } from './schema-definitions.js';
+export { ALL_MIGRATIONS } from './migrations/index.js';
+export type { Db } from './db-types.js';
+export type { Migration, DbType, TableDefinition, ViewDefinition, FtsDefinition, SchemaCatalog, } from './migration-runner.js';

package/plugin/dist/core/schema/index.js

@@ -0,0 +1,15 @@
+/**
+ * Schema Management — Unified database schema definitions and migrations.
+ *
+ * Usage:
+ *   // In a database class constructor:
+ *   import { ensureDatabaseSchema } from './schema';
+ *   ensureDatabaseSchema(db, 'trajectory.db');
+ *
+ * CLI:
+ *   node scripts/db-migrate.mjs status
+ *   node scripts/db-migrate.mjs run
+ */
+export { MigrationRunner, ensureDatabaseSchema } from './migration-runner.js';
+export { SCHEMAS, getCatalog, DB_TYPES } from './schema-definitions.js';
+export { ALL_MIGRATIONS } from './migrations/index.js';

package/plugin/dist/core/schema/migration-runner.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Migration Runner — Executes and tracks schema migrations.
+ *
+ * Each migration is versioned. The runner reads the current version from
+ * the `schema_version` table and only executes migrations with higher IDs.
+ *
+ * Usage:
+ *   const runner = new MigrationRunner(db);
+ *   runner.run(allMigrations.filter(m => m.db === 'trajectory.db'));
+ */
+import type { Migration } from './schema-definitions.js';
+import { type DbType } from './schema-definitions.js';
+import type { Db } from './db-types.js';
+export declare class MigrationRunner {
+    private readonly db;
+    constructor(db: Db);
+    /**
+     * Run all pending migrations for a given database type.
+     * @returns Array of migration names that were applied
+     */
+    runMigrations(migrations: Migration[], _dbType: DbType): string[];
+    /**
+     * Apply all schema definitions (tables, indexes, views, FTS) for a database.
+     * This is a convenience method that creates everything from the schema catalog.
+     * Used for initial setup when no migrations exist yet.
+     */
+    applySchemaCatalog(dbType: DbType): void;
+    /**
+     * Get the current migration version.
+     * Returns '000' if no version is set (fresh database).
+     */
+    getCurrentVersion(): string;
+    /**
+     * Get all available migration info for a database type.
+     */
+    getMigrationInfo(migrations: Migration[], dbType: DbType): {
+        id: string;
+        name: string;
+        applied: boolean;
+    }[];
+    /**
+     * Rollback the latest migration (if down migration is defined).
+     */
+    rollback(migrations: Migration[], dbType: DbType): string | null;
+    private ensureVersionTable;
+    private setVersion;
+}
+/**
+ * Factory: create a MigrationRunner and apply schema catalog for a given database.
+ * This is the main entry point for database classes.
+ */
+export declare function ensureDatabaseSchema(db: Db, dbType: DbType): void;
+export type { Migration, DbType, TableDefinition, ViewDefinition, FtsDefinition, SchemaCatalog } from './schema-definitions.js';

package/plugin/dist/core/schema/migration-runner.js

@@ -0,0 +1,170 @@
+/**
+ * Migration Runner — Executes and tracks schema migrations.
+ *
+ * Each migration is versioned. The runner reads the current version from
+ * the `schema_version` table and only executes migrations with higher IDs.
+ *
+ * Usage:
+ *   const runner = new MigrationRunner(db);
+ *   runner.run(allMigrations.filter(m => m.db === 'trajectory.db'));
+ */
+import { getCatalog } from './schema-definitions.js';
+export class MigrationRunner {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Run all pending migrations for a given database type.
+     * @returns Array of migration names that were applied
+     */
+    runMigrations(migrations, _dbType) {
+        // NOTE: _dbType is kept for API signature compatibility but migrations are pre-filtered by caller
+        void _dbType;
+        // Ensure schema_version table exists before anything else
+        this.ensureVersionTable();
+        const currentVersion = this.getCurrentVersion();
+        const applied = [];
+        // Filter to pending migrations (higher ID than current)
+        const pending = migrations
+            .filter(m => m.id > currentVersion)
+            .sort((a, b) => a.id.localeCompare(b.id));
+        for (const migration of pending) {
+            console.log(`[MigrationRunner] Applying ${migration.id}-${migration.name}...`);
+            try {
+                migration.up(this.db);
+                this.setVersion(migration.id);
+                applied.push(`${migration.id}-${migration.name}`);
+            }
+            catch (err) {
+                throw new Error(`Migration ${migration.id}-${migration.name} failed: ${String(err)}`, { cause: err });
+            }
+        }
+        if (applied.length > 0) {
+            console.log(`[MigrationRunner] Applied ${applied.length} migration(s): ${applied.join(', ')}`);
+        }
+        return applied;
+    }
+    /**
+     * Apply all schema definitions (tables, indexes, views, FTS) for a database.
+     * This is a convenience method that creates everything from the schema catalog.
+     * Used for initial setup when no migrations exist yet.
+     */
+    applySchemaCatalog(dbType) {
+        this.ensureVersionTable();
+        const catalog = getCatalog(dbType);
+        // Tables
+        for (const [key, table] of Object.entries(catalog.tables)) {
+            try {
+                this.db.exec(table.ddl);
+            }
+            catch (err) {
+                throw new Error(`Failed to create table ${key}: ${String(err)}`, { cause: err });
+            }
+            // Indexes
+            for (const indexDdl of table.indexes ?? []) {
+                try {
+                    this.db.exec(indexDdl);
+                }
+                catch (err) {
+                    throw new Error(`Failed to create index for ${key}: ${String(err)}`, { cause: err });
+                }
+            }
+        }
+        // Views
+        for (const [key, view] of Object.entries(catalog.views)) {
+            try {
+                this.db.exec(view.ddl);
+            }
+            catch (err) {
+                throw new Error(`Failed to create view ${key}: ${String(err)}`, { cause: err });
+            }
+        }
+        // FTS5 virtual tables
+        for (const [key, fts] of Object.entries(catalog.fts)) {
+            try {
+                this.db.exec(fts.ddl);
+            }
+            catch (err) {
+                throw new Error(`Failed to create FTS table ${key}: ${String(err)}`, { cause: err });
+            }
+        }
+    }
+    /**
+     * Get the current migration version.
+     * Returns '000' if no version is set (fresh database).
+     */
+    getCurrentVersion() {
+        try {
+            const row = this.db.get('SELECT version FROM schema_version ORDER BY version DESC LIMIT 1');
+            return row?.version ?? '000';
+        }
+        catch {
+            return '000';
+        }
+    }
+    /**
+     * Get all available migration info for a database type.
+     */
+    getMigrationInfo(migrations, dbType) {
+        const currentVersion = this.getCurrentVersion();
+        return migrations
+            .filter(m => m.db === dbType)
+            .sort((a, b) => a.id.localeCompare(b.id))
+            .map(m => ({
+            id: m.id,
+            name: m.name,
+            applied: m.id <= currentVersion,
+        }));
+    }
+    /**
+     * Rollback the latest migration (if down migration is defined).
+     */
+    rollback(migrations, dbType) {
+        const currentVersion = this.getCurrentVersion();
+        if (currentVersion === '000')
+            return null;
+        const migration = migrations.find(m => m.db === dbType && m.id === currentVersion);
+        if (!migration)
+            return null;
+        if (!migration.down) {
+            throw new Error(`Migration ${migration.id}-${migration.name} has no down migration`);
+        }
+        console.log(`[MigrationRunner] Rolling back ${migration.id}-${migration.name}...`);
+        migration.down(this.db);
+        // Set version to previous migration
+        const previousMigrations = migrations
+            .filter(m => m.db === dbType && m.id < currentVersion)
+            .sort((a, b) => b.id.localeCompare(a.id));
+        const newVersion = previousMigrations[0]?.id ?? '000';
+        this.setVersion(newVersion);
+        console.log(`[MigrationRunner] Rolled back to ${newVersion}`);
+        return migration.id;
+    }
+    // -----------------------------------------------------------------------
+    // Private helpers
+    // -----------------------------------------------------------------------
+    ensureVersionTable() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS schema_version (
+        version TEXT NOT NULL DEFAULT '000'
+      )
+    `);
+        // Ensure at least one row exists
+        const count = this.db.get('SELECT COUNT(*) as cnt FROM schema_version');
+        if (!count || count.cnt === 0) {
+            this.db.exec("INSERT INTO schema_version (version) VALUES ('000')");
+        }
+    }
+    setVersion(version) {
+        this.db.exec(`UPDATE schema_version SET version = '${version}'`);
+    }
+}
+/**
+ * Factory: create a MigrationRunner and apply schema catalog for a given database.
+ * This is the main entry point for database classes.
+ */
+export function ensureDatabaseSchema(db, dbType) {
+    const runner = new MigrationRunner(db);
+    runner.applySchemaCatalog(dbType);
+}

package/plugin/dist/core/schema/migrations/001-init-trajectory.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Migration: Initialize trajectory.db tables
+ * This creates all core event store tables.
+ */
+import type { Migration } from '../migration-runner.js';
+export declare const migration: Migration;

package/plugin/dist/core/schema/migrations/001-init-trajectory.js

@@ -0,0 +1,193 @@
+/**
+ * Migration: Initialize trajectory.db tables
+ * This creates all core event store tables.
+ */
+export const migration = {
+    id: '001',
+    name: 'init-trajectory',
+    db: 'trajectory.db',
+    up(db) {
+        // Core tables
+        db.exec(`CREATE TABLE IF NOT EXISTS sessions (
+      session_id TEXT PRIMARY KEY,
+      started_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )`);
+        db.exec(`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
+    )`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_assistant_turns_session_id ON assistant_turns(session_id)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_assistant_turns_created_at ON assistant_turns(created_at)`);
+        db.exec(`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
+    )`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_user_turns_session_id ON user_turns(session_id)`);
+        db.exec(`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
+    )`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_tool_calls_session_id ON tool_calls(session_id)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_tool_calls_created_at ON tool_calls(created_at)`);
+        db.exec(`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
+    )`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_pain_events_session_id ON pain_events(session_id)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_pain_events_created_at ON pain_events(created_at)`);
+        // FTS5
+        db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS pain_events_fts USING fts5(
+      text,
+      pain_event_id UNINDEXED,
+      tokenize='porter unicode61'
+    )`);
+        db.exec(`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,
+      gfi REAL,
+      gfi_after REAL,
+      trust_stage INTEGER,
+      gate_type TEXT,
+      created_at TEXT NOT NULL
+    )`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_gate_blocks_created_at ON gate_blocks(created_at)`);
+        db.exec(`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
+    )`);
+        db.exec(`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
+    )`);
+        db.exec(`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
+    )`);
+        db.exec(`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
+    )`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_correction_samples_review_status ON correction_samples(review_status)`);
+        db.exec(`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
+    )`);
+        db.exec(`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
+    )`);
+        db.exec(`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,
+      task_kind TEXT,
+      priority TEXT,
+      retry_count INTEGER,
+      max_retries INTEGER,
+      last_error TEXT,
+      result_ref TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_evolution_tasks_trace_id ON evolution_tasks(trace_id)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_evolution_tasks_status ON evolution_tasks(status)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_evolution_tasks_created_at ON evolution_tasks(created_at)`);
+        db.exec(`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
+    )`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_evolution_events_trace_id ON evolution_events(trace_id)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_evolution_events_created_at ON evolution_events(created_at)`);
+        db.exec(`CREATE TABLE IF NOT EXISTS ingest_checkpoint (
+      source_key TEXT PRIMARY KEY,
+      imported_at TEXT NOT NULL
+    )`);
+    },
+};

package/plugin/dist/core/schema/migrations/002-init-central.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Migration: Initialize central.db (aggregated multi-workspace) tables
+ */
+import type { Migration } from '../migration-runner.js';
+export declare const migration: Migration;