create-principles-disciple 1.85.0 → 1.87.0

package/plugin/dist/core/rule-host.js

@@ -1,11 +1,15 @@
 /**
  * Rule Host — Constrained execution layer for active code implementations
  *
- * PURPOSE: Load active code implementations from the principle-tree ledger,
- * execute them in a constrained node:vm context, and merge their decisions.
+ * PURPOSE: Load active code implementations from the SQLite activations table
+ * (code_tool_hook channel), execute them in a constrained node:vm context,
+ * and merge their decisions.
  *
- * ARCHITECTURE:
- *   - Constructor takes stateDir to access the principle-tree ledger
+ * ARCHITECTURE (PRI-436):
+ *   - SQLite is the SOLE production source of active RuleCode
+ *   - No filesystem ledger or implementation asset reads occur during evaluation
+ *   - Constructor takes stateDir for API compatibility (no longer used for impl loading)
+ *   - workspaceDir enables reading code_tool_hook activations from SQLite
  *   - evaluate(input) loads active code implementations and runs them
  *   - Each implementation executes in an isolated vm context with minimal helpers
  *   - Decision merge: block short-circuits, requireApproval collects, allow is implicit
@@ -19,18 +23,35 @@
  *   - On ANY host error (load failure, eval error, vm error): return undefined
  *   - Never throw, never bypass downstream gates (Progressive Gate, Edit Verification)
  */
-import * as fs from 'fs';
-import { listImplementationsByLifecycleState, } from './principle-tree-ledger.js';
-import { loadEntrySource } from './code-implementation-storage.js';
 import { createRuleHostHelpers } from '@principles/core/runtime-v2';
 import { mergeDecisions } from '@principles/core/runtime-v2';
+import { validateRuleHostResult } from '@principles/core/runtime-v2';
+import { SqliteConnection } from '@principles/core/runtime-v2';
 import { loadRuleImplementationModule } from './rule-implementation-runtime.js';
+import { EventLogService } from './event-log.js';
+/**
+ * Type guard for RuleHostMeta from untrusted module exports.
+ * Validates all four required string fields (EP-01: no `as` bypass at trust boundary).
+ */
+function isRuleHostMeta(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const v = value;
+    return (typeof v['name'] === 'string' &&
+        typeof v['version'] === 'string' &&
+        typeof v['ruleId'] === 'string' &&
+        typeof v['coversCondition'] === 'string');
+}
 export class RuleHost {
     stateDir;
     logger;
-    constructor(stateDir, logger = console) {
+    workspaceDir;
+    implementationSources = new Map();
+    constructor(stateDir, logger = console, options) {
         this.stateDir = stateDir;
         this.logger = logger;
+        this.workspaceDir = options?.workspaceDir ?? null;
     }
     /**
      * Evaluate the input against all active code implementations.
@@ -44,7 +65,17 @@ export class RuleHost {
     evaluate(input) {
         try {
             const activeImpls = this._loadActiveCodeImplementations();
-            return mergeDecisions(activeImpls, input, this.logger);
+            return mergeDecisions(activeImpls, input, {
+                warn: this.logger.warn,
+                onImplementationUnhealthy: (impl, reason) => {
+                    const source = this.implementationSources.get(impl.implId);
+                    if (!source) {
+                        this.logger.warn?.(`[RuleHost] No source mapping for implId=${impl.implId}, cannot record unhealthy event`);
+                        return;
+                    }
+                    this._recordUnhealthy(source.activationId, source.artifactId, source.ruleId, reason, 'Fix the RuleCode runtime error or return shape, then re-activate the rule');
+                },
+            });
         }
         catch (hostError) {
             // Conservative degradation: log and return undefined (D-08)
@@ -53,100 +84,228 @@ export class RuleHost {
         }
     }
     /**
-     * Load active code implementations from the ledger.
-     * Filters by type=code and lifecycleState=active, then attempts to
-     * compile each implementation's code asset via node:vm.
+     * Load active code implementations from the SQLite activations table.
+     *
+     * PRI-436: SQLite is the SOLE production source. The filesystem ledger
+     * (principle-tree-ledger) and implementation asset paths have been deleted.
+     * No fallback, no dual-source, no deprecated adapter.
+     *
+     * Source: activations table (code_tool_hook channel, deactivated_at IS NULL)
+     *   → JOIN pi_artifacts for content_json → extract implementationCode → compile
      */
     _loadActiveCodeImplementations() {
+        if (!this.workspaceDir) {
+            return [];
+        }
+        try {
+            return this._loadFromActivationsTable(this.workspaceDir);
+        }
+        catch (activationError) {
+            this.logger.warn?.(`[RuleHost] Failed to load code_tool_hook activations: ${String(activationError)}`);
+            return [];
+        }
+    }
+    /**
+     * Load active code implementations from the activations table (code_tool_hook channel).
+     *
+     * For each activation record:
+     *   1. Query the pi_artifacts table for the artifact content
+     *   2. Parse content_json to extract implementationCode (treated as unknown, EP-01)
+     *   3. Compile via loadRuleImplementationModule (isolated vm context)
+     *
+     * PRI-436 invariant: at most one active activation per rule (target_ref).
+     * Duplicate active activations for the same target_ref are ALL skipped
+     * (zero executions) and emit structured unhealthy evidence via logger.warn
+     * (Runtime Contract Rule 9: graceful degradation includes a reason).
+     *
+     * All data from SQLite is treated as unknown and validated before use.
+     */
+    _loadFromActivationsTable(workspaceDir) {
+        this.implementationSources.clear();
+        const sqliteConn = new SqliteConnection(workspaceDir);
         try {
-            const activeAllTypes = listImplementationsByLifecycleState(this.stateDir, 'active');
-            // Filter to code-type implementations only
-            const codeImpls = activeAllTypes.filter((impl) => impl.type === 'code');
-            if (codeImpls.length === 0) {
+            const db = sqliteConn.getDb();
+            const rows = db.prepare(`
+        SELECT a.activation_id, a.artifact_id, a.target_ref,
+               p.content_json, p.source_rule_id
+        FROM activations a
+        JOIN pi_artifacts p ON a.artifact_id = p.artifact_id
+        WHERE a.channel = 'code_tool_hook' AND a.deactivated_at IS NULL
+        ORDER BY a.activated_at ASC
+      `).all();
+            if (!Array.isArray(rows)) {
+                this.logger.warn?.('[RuleHost] Activations table query returned non-array, skipping');
                 return [];
             }
+            // PRI-436: Group active rows by target_ref to detect duplicates.
+            // At most one active activation per rule (target_ref) is allowed.
+            // Duplicate groups are skipped entirely (zero executions) and emit
+            // structured unhealthy evidence. Non-duplicate rows proceed to compilation.
+            const rowsByTargetRef = new Map();
+            for (const row of rows) {
+                if (!row || typeof row !== 'object') {
+                    continue;
+                }
+                const r = row;
+                const targetRef = typeof r['target_ref'] === 'string' ? r['target_ref'] : '';
+                const activationId = typeof r['activation_id'] === 'string' ? r['activation_id'] : '';
+                if (!targetRef) {
+                    this.logger.warn?.(`[RuleHost] Activation ${activationId}: missing target_ref, skipping`);
+                    continue;
+                }
+                const group = rowsByTargetRef.get(targetRef);
+                if (group) {
+                    group.push(r);
+                }
+                else {
+                    rowsByTargetRef.set(targetRef, [r]);
+                }
+            }
+            // Emit structured unhealthy evidence for duplicate groups; collect valid (non-duplicate) rows.
+            const validRows = [];
+            for (const [targetRef, group] of rowsByTargetRef) {
+                if (group.length > 1) {
+                    const activationIds = [];
+                    const artifactIds = [];
+                    for (const r of group) {
+                        if (typeof r['activation_id'] === 'string')
+                            activationIds.push(r['activation_id']);
+                        if (typeof r['artifact_id'] === 'string')
+                            artifactIds.push(r['artifact_id']);
+                    }
+                    this.logger.warn?.(`[RuleHost] Duplicate active activations detected — skipping all executions for this rule. ` +
+                        `targetRef=${targetRef} count=${group.length} ` +
+                        `activationIds=[${activationIds.join(', ')}] ` +
+                        `artifactIds=[${artifactIds.join(', ')}] ` +
+                        `reason=at most one active activation per rule is allowed ` +
+                        `nextAction=deactivate all but one activation for this target_ref`);
+                    for (const r of group) {
+                        const activationId = typeof r['activation_id'] === 'string' ? r['activation_id'] : '';
+                        const artifactId = typeof r['artifact_id'] === 'string' ? r['artifact_id'] : '';
+                        if (activationId && artifactId) {
+                            this._recordUnhealthy(activationId, artifactId, targetRef, `duplicate active activation for target_ref ${targetRef}`, 'Deactivate all but one activation for this target_ref');
+                        }
+                    }
+                }
+                else {
+                    validRows.push(group[0]);
+                }
+            }
             const loaded = [];
-            for (const impl of codeImpls) {
+            for (const r of validRows) {
+                const activationId = typeof r['activation_id'] === 'string' ? r['activation_id'] : '';
+                const artifactId = typeof r['artifact_id'] === 'string' ? r['artifact_id'] : '';
+                const contentJson = typeof r['content_json'] === 'string' ? r['content_json'] : '';
+                const sourceRuleId = typeof r['source_rule_id'] === 'string' ? r['source_rule_id'] : null;
+                if (!activationId || !artifactId || !contentJson) {
+                    this.logger.warn?.(`[RuleHost] Activation row missing required fields, skipping`);
+                    continue;
+                }
                 try {
-                    const loadedImpl = this._loadSingleImplementation(impl);
-                    if (loadedImpl) {
-                        loaded.push(loadedImpl);
+                    const content = JSON.parse(contentJson);
+                    if (!content || typeof content !== 'object' || Array.isArray(content)) {
+                        this.logger.warn?.(`[RuleHost] Activation ${activationId}: content_json is not an object, skipping`);
+                        continue;
+                    }
+                    const contentObj = content;
+                    const implementationCode = contentObj['implementationCode'];
+                    if (typeof implementationCode !== 'string' || implementationCode.length === 0) {
+                        this.logger.warn?.(`[RuleHost] Activation ${activationId}: no implementationCode in artifact, skipping`);
+                        continue;
+                    }
+                    const ruleId = typeof contentObj['ruleId'] === 'string'
+                        ? contentObj['ruleId']
+                        : (sourceRuleId ?? artifactId);
+                    const implId = `act-impl-${activationId}`;
+                    const moduleExports = loadRuleImplementationModule(implementationCode, implId);
+                    if (!moduleExports || typeof moduleExports.callEvaluate !== 'function') {
+                        const reason = 'compiled module has no evaluate function';
+                        this.logger.warn?.(`[RuleHost] Activation ${activationId}: ${reason}, skipping`);
+                        this._recordUnhealthy(activationId, artifactId, ruleId, reason, 'Fix the RuleCode to export an evaluate(input, helpers) function, then re-activate');
+                        continue;
                     }
+                    const fallbackMeta = {
+                        name: implId,
+                        version: '1',
+                        ruleId,
+                        coversCondition: 'all',
+                    };
+                    const meta = isRuleHostMeta(moduleExports.meta)
+                        ? moduleExports.meta
+                        : fallbackMeta;
+                    // PRI-437: Use callEvaluate (vm-context-bounded) instead of raw evaluate.
+                    // callEvaluate runs the invocation INSIDE the vm context with a time
+                    // boundary, terminating infinite loops and excessive computation.
+                    const boundedCallEvaluate = moduleExports.callEvaluate;
+                    this.implementationSources.set(implId, { activationId, artifactId, ruleId });
+                    loaded.push({
+                        implId,
+                        ruleId,
+                        meta,
+                        evaluate: (input) => {
+                            const frozenHelpers = createRuleHostHelpers(input);
+                            // PRI-437: Execute inside vm context with timeout boundary.
+                            const rawResult = boundedCallEvaluate(input, frozenHelpers);
+                            const validation = validateRuleHostResult(rawResult);
+                            if (!validation.valid) {
+                                throw new Error(`[RuleHost] Activation ${activationId} returned invalid RuleHostResult: ${validation.errors.join('; ')}`);
+                            }
+                            const result = rawResult;
+                            if (result.matched && (result.decision === 'block' || result.decision === 'requireApproval')) {
+                                result.ruleId = ruleId;
+                                result.principleId = meta.ruleId ?? ruleId;
+                            }
+                            return result;
+                        },
+                    });
                 }
                 catch (loadError) {
-                    // Individual load failure: log and skip
-                    this.logger.warn?.(`[RuleHost] Failed to load implementation ${impl.id}: ${String(loadError)}`);
+                    const reason = `compilation failed: ${String(loadError)}`;
+                    this.logger.warn?.(`[RuleHost] Failed to load activation ${activationId}: ${reason}`);
+                    // ruleId is declared inside the try block and may not be assigned yet;
+                    // fall back to sourceRuleId or artifactId (both available in scope)
+                    this._recordUnhealthy(activationId, artifactId, sourceRuleId ?? artifactId, reason, 'Fix the RuleCode syntax/compilation error, then re-activate the rule');
                 }
             }
             return loaded;
         }
-        catch (ledgerError) {
-            // Ledger access failure: log and return empty
-            this.logger.warn?.(`[RuleHost] Failed to access ledger: ${String(ledgerError)}`);
-            return [];
+        finally {
+            try {
+                sqliteConn.close();
+            }
+            catch {
+                // best-effort cleanup
+            }
         }
     }
     /**
-     * Load and compile a single implementation from its code asset path.
+     * PRI-437: Record an unhealthy activation state to EventLog.
      *
-     * The implementation file is expected to export:
-     *   - meta: { name, version, ruleId, coversCondition }
-     *   - evaluate(input: RuleHostInput): RuleHostResult
+     * This makes compile/load failures visible to CLI (pd runtime health) and
+     * Console API — NOT just a logger.warn that's silently skipped.
      *
-     * Uses the shared isolated runtime loader so candidate code does not execute
-     * in the host global realm.
+     * ERR-002: degradation includes a reason and nextAction (not silent).
+     * Failures in EventLog recording are caught and logged (never throw).
      */
-    _loadSingleImplementation(impl) {
-        let sourceCode = loadEntrySource(this.stateDir, impl.id);
-        if (!sourceCode) {
-            const assetPath = impl.path;
-            if (!assetPath || !fs.existsSync(assetPath)) {
-                return null;
-            }
-            try {
-                sourceCode = fs.readFileSync(assetPath, 'utf-8');
-            }
-            catch {
-                return null;
-            }
-        }
+    _recordUnhealthy(activationId, artifactId, ruleId, reason, nextAction) {
         try {
-            const moduleExports = loadRuleImplementationModule(sourceCode, impl.id);
-            if (!moduleExports || typeof moduleExports.evaluate !== 'function') {
-                return null;
-            }
-            const fallbackMeta = {
-                name: impl.id,
-                version: impl.version,
-                ruleId: impl.ruleId,
-                coversCondition: impl.coversCondition,
-            };
-            const meta = moduleExports.meta && typeof moduleExports.meta === 'object'
-                ? moduleExports.meta
-                : fallbackMeta;
-            // Return a loaded implementation that wraps the compiled evaluate
-            // with the actual helpers from the input at evaluation time
-            const rawEvaluate = moduleExports.evaluate;
-            return {
-                implId: impl.id,
-                ruleId: impl.ruleId,
-                meta,
-                evaluate: (input) => {
-                    const frozenHelpers = createRuleHostHelpers(input);
-                    const result = rawEvaluate(input, frozenHelpers);
-                    // C: Enrich result with rule/principle IDs for observability
-                    if (result.matched && (result.decision === 'block' || result.decision === 'requireApproval')) {
-                        result.ruleId = impl.ruleId;
-                        result.principleId = meta.ruleId ?? impl.ruleId;
-                    }
-                    return result;
-                },
-            };
+            // Pass undefined as logger: RuleHostLogger only has warn(), but EventLog
+            // calls this.logger.error() without optional chaining. Passing the
+            // RuleHostLogger directly would cause TypeError if EventLog tried to
+            // log an internal error. EventLog's logger is optional; RuleHost already
+            // logs its own warnings for the unhealthy event.
+            const eventLog = EventLogService.get(this.stateDir);
+            eventLog.recordRuleHostUnhealthy({
+                activationId,
+                artifactId,
+                ruleId,
+                reason,
+                nextAction,
+            });
         }
-        catch (compileError) {
-            // Compilation failure: log and skip
-            this.logger.warn?.(`[RuleHost] Failed to compile implementation ${impl.id}: ${String(compileError)}`);
-            return null;
+        catch (recordError) {
+            // EventLog recording must never break RuleHost evaluation
+            this.logger.warn?.(`[RuleHost] Failed to record unhealthy event for activation ${activationId}: ${String(recordError)}`);
         }
     }
 }

package/plugin/dist/core/rule-implementation-runtime.d.ts

@@ -1,5 +1,18 @@
 export interface RuleImplementationModuleExports {
     meta?: unknown;
     evaluate?: unknown;
+    /**
+     * Call evaluate(input, helpers) INSIDE the vm context with a time boundary.
+     *
+     * PRI-437: The evaluate() function extracted from a vm context executes in
+     * the vm realm, but a direct host-realm call has NO timeout protection —
+     * an infinite loop in RuleCode would hang the host process forever.
+     *
+     * callEvaluate runs the invocation inside the vm context via
+     * Script.runInContext({ timeout }), which terminates infinite loops.
+     *
+     * Throws on timeout, compilation error, or if evaluate is missing.
+     */
+    callEvaluate?: (input: unknown, helpers: unknown) => unknown;
 }
 export declare function loadRuleImplementationModule(sourceCode: string, filename: string): RuleImplementationModuleExports;

package/plugin/dist/core/rule-implementation-runtime.js

@@ -1,4 +1,36 @@
 import { nodeVm } from '../utils/node-vm-polyfill.js';
+import { spawnSync } from 'node:child_process';
+/** Timeout (ms) for compiling RuleCode (defining evaluate + meta). */
+const COMPILE_TIMEOUT_MS = 1000;
+/** Timeout (ms) for executing evaluate(input, helpers) inside the vm. */
+const EVALUATE_PROCESS_TIMEOUT_MS = 3000;
+const EVALUATE_PROCESS_OUTPUT_BYTES = 1024 * 1024;
+const EVALUATION_PROCESS_SOURCE = String.raw `
+const vm = require('node:vm');
+try {
+  const workerData = JSON.parse(require('node:fs').readFileSync(0, 'utf8'));
+  const context = vm.createContext(Object.create(null));
+  new vm.Script(workerData.source, { filename: workerData.filename }).runInContext(context, { timeout: 1000 });
+  const input = workerData.input;
+  const helpers = Object.freeze({
+    isRiskPath: () => input.workspace.isRiskPath,
+    getToolName: () => input.action.toolName,
+    getEstimatedLineChanges: () => input.derived.estimatedLineChanges,
+    getBashRisk: () => input.derived.bashRisk,
+    hasPlanFile: () => input.workspace.hasPlanFile,
+    getPlanStatus: () => input.workspace.planStatus,
+    getEpTier: () => input.evolution.epTier,
+  });
+  context.__pdCallInput = input;
+  context.__pdCallHelpers = helpers;
+  const result = new vm.Script('__pdRuleModule.evaluate(__pdCallInput, __pdCallHelpers)', { filename: workerData.filename + '.call' })
+    .runInContext(context, { timeout: 1000 });
+  process.stdout.write(JSON.stringify({ ok: true, result }));
+} catch (error) {
+  process.stdout.write(JSON.stringify({ ok: false, error: String(error) }));
+  process.exitCode = 1;
+}
+`;
 function normalizeImplementationSource(sourceCode) {
     const withoutExports = sourceCode
         .replace(/export\s+const\s+meta\s*=/, 'const meta =')
@@ -9,16 +41,72 @@ globalThis.__pdRuleModule = {
   evaluate: typeof evaluate === 'undefined' ? undefined : evaluate,
 };`;
 }
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 export function loadRuleImplementationModule(sourceCode, filename) {
     const context = nodeVm.createContext(Object.create(null));
     const script = new nodeVm.Script(normalizeImplementationSource(sourceCode), {
         filename,
     });
+    // Compile phase: define evaluate + meta (timeout-bounded)
     script.runInContext(context, {
-        timeout: 1000,
+        timeout: COMPILE_TIMEOUT_MS,
         displayErrors: true,
     });
     const moduleExports = context.__pdRuleModule;
-    delete context.__pdRuleModule;
-    return moduleExports ?? {};
+    // Note: keep __pdRuleModule on the context so callEvaluate can reference it.
+    // We do NOT delete it here — it's needed for subsequent evaluate calls.
+    const hasEvaluate = typeof moduleExports?.evaluate === 'function';
+    const meta = moduleExports?.meta;
+    if (!hasEvaluate) {
+        // No evaluate function — return early with no callEvaluate
+        return { meta, evaluate: moduleExports?.evaluate };
+    }
+    // PRI-437: Create a context-aware caller that runs evaluate INSIDE the vm
+    // context with a time boundary. This terminates infinite loops and
+    // excessive computation that would otherwise hang the host process.
+    //
+    // The callEvaluate function:
+    //   1. Sets input and helpers as context globals (sandboxed)
+    //   2. Compiles a tiny call script
+    //   3. Runs it in the context with EVALUATE_TIMEOUT_MS
+    //   4. Cleans up globals
+    //   5. Returns the raw result (validation happens in the caller)
+    const normalizedSource = normalizeImplementationSource(sourceCode);
+    const callEvaluate = (input, _helpers) => {
+        const child = spawnSync(process.execPath, [
+            '--max-old-space-size=32',
+            '-e',
+            EVALUATION_PROCESS_SOURCE,
+        ], {
+            input: JSON.stringify({ source: normalizedSource, filename, input }),
+            encoding: 'utf8',
+            timeout: EVALUATE_PROCESS_TIMEOUT_MS,
+            maxBuffer: EVALUATE_PROCESS_OUTPUT_BYTES,
+            windowsHide: true,
+        });
+        if (child.error) {
+            throw new Error(`RuleCode process failed: ${child.error.message}`);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(child.stdout);
+        }
+        catch {
+            const stderr = child.stderr.trim().slice(0, 500);
+            throw new Error(`RuleCode process exited without a valid result${stderr ? `: ${stderr}` : ''}`);
+        }
+        if (!isRecord(parsed) || !Object.hasOwn(parsed, 'ok') || parsed['ok'] !== true || !Object.hasOwn(parsed, 'result')) {
+            const reason = isRecord(parsed) && Object.hasOwn(parsed, 'error') && typeof parsed['error'] === 'string'
+                ? parsed['error'] : 'RuleCode process failed';
+            throw new Error(reason);
+        }
+        return parsed['result'];
+    };
+    return {
+        meta,
+        evaluate: moduleExports?.evaluate,
+        callEvaluate,
+    };
 }

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

@@ -36,9 +36,9 @@ export class PromptActivationReader {
                     continue;
                 }
                 if (artifactRow === null) {
-                    const warning = `artifact_not_found: artifactId=${activation.artifactId}; nextAction=check_pi_artifacts_table`;
+                    const warning = `artifact_not_found: artifactId=${activation.artifactId}; nextAction=check_pi_artifacts_table_or_remove_stale_activation`;
                     warnings.push(warning);
-                    this.deps.logger?.warn?.(`[PD:RuntimeV2] ${warning}`);
+                    this.deps.logger?.info?.(`[PD:RuntimeV2] ${warning}`);
                     continue;
                 }
                 const result = resolvePrincipleFromArtifact(artifactRow, activation);

package/plugin/dist/core/thinking-models.d.ts

@@ -1,11 +1,12 @@
 /**
  * Thinking Models — Detection Engine
  *
- * THINKING_OS.md is the single source of truth for model definitions (id, name, description).
+ * Core principle metadata (id, name, description) comes from the
+ * Core Principle Registry in @principles/core/runtime-v2.
  * Detection patterns are carefully tuned regexes that match AI output text.
  *
  * Flow:
- *   THINKING_OS.md (authority) → id, name, description, antiPattern
+ *   Core Principle Registry (authority) → id, name, description
  *   BUILTIN_PATTERNS (engine) → detection regexes per model id
  *   THINKING_MODELS (merged) → full definitions with patterns
  */

package/plugin/dist/core/thinking-models.js

@@ -1,15 +1,17 @@
 /**
  * Thinking Models — Detection Engine
  *
- * THINKING_OS.md is the single source of truth for model definitions (id, name, description).
+ * Core principle metadata (id, name, description) comes from the
+ * Core Principle Registry in @principles/core/runtime-v2.
  * Detection patterns are carefully tuned regexes that match AI output text.
  *
  * Flow:
- *   THINKING_OS.md (authority) → id, name, description, antiPattern
+ *   Core Principle Registry (authority) → id, name, description
  *   BUILTIN_PATTERNS (engine) → detection regexes per model id
  *   THINKING_MODELS (merged) → full definitions with patterns
  */
 import { loadThinkingOsFromWorkspace, generateDetectionPatterns } from './thinking-os-parser.js';
+import { CORE_PRINCIPLES } from '@principles/core/runtime-v2';
 const BUILTIN_PATTERNS = [
     {
         id: 'T-01',
@@ -147,36 +149,14 @@ const BUILTIN_PATTERNS = [
     },
 ];
 const BUILTIN_PATTERN_MAP = new Map(BUILTIN_PATTERNS.map((p) => [p.id, p]));
-// Fallback name/description lookup tables (must be defined before listThinkingModels uses them)
+// Fallback name/description lookup — delegates to Core Principle Registry
 function getFallbackName(id) {
-    const names = {
-        'T-01': 'Survey Before Acting',
-        'T-02': 'Respect Constraints',
-        'T-03': 'Evidence Over Assumption',
-        'T-04': 'Reversible First',
-        'T-05': 'Safety Rails',
-        'T-06': 'Simplicity First',
-        'T-07': 'Minimal Change Surface',
-        'T-08': 'Pain As Signal',
-        'T-09': 'Divide And Conquer',
-        'T-10': 'Memory Externalization',
-    };
-    return names[id] ?? id;
+    const entry = CORE_PRINCIPLES.find(p => p.id === id);
+    return entry?.name ?? id;
 }
 function getFallbackDescription(id) {
-    const descs = {
-        'T-01': 'Understand the structure first before making changes.',
-        'T-02': 'Trust files, not your context window. Write conclusions to files.',
-        'T-03': 'Use logs, code, and outputs before inferring causes.',
-        'T-04': 'Prefer changes that are safe to roll back when risk is high.',
-        'T-05': 'Call out guardrails, prohibitions, and failure-prevention constraints.',
-        'T-06': 'Prefer the smallest understandable solution over over-engineering.',
-        'T-07': 'Limit the blast radius and touch only what is necessary.',
-        'T-08': 'Treat failures and friction as clues to step back and rethink.',
-        'T-09': 'Split the task into smaller phases before execution.',
-        'T-10': 'Write intermediate conclusions to files for persistence.',
-    };
-    return descs[id] ?? '';
+    const entry = CORE_PRINCIPLES.find(p => p.id === id);
+    return entry?.statement ?? '';
 }
 // ---------------------------------------------------------------------------
 // Runtime model definitions — merged from THINKING_OS.md + builtin patterns

package/plugin/dist/core/trajectory-types.d.ts

@@ -62,6 +62,10 @@ export interface TrajectoryPainEventInput {
     confidence?: number | null;
     text?: string;
     createdAt?: string;
+    /** PRI-406: Canonical pain identity (e.g. manual_<ts>_<hash> or pain_<ts>_<hash>). */
+    canonicalPainId?: string;
+    /** PRI-406: Runtime V2 diagnostician task ID linked to this pain event. */
+    runtimeTaskId?: string;
 }
 export interface TrajectoryGateBlockInput {
     sessionId?: string | null;