create-principles-disciple 1.85.0 → 1.87.0

package/console/dist/server/models/EvidenceChainConsoleModel.d.ts

@@ -22,37 +22,13 @@
  * - ERR-014/016/017: Evidence previews bounded via sanitizeString
  * - ERR-013: Use Object.hasOwn() for untrusted object keys
  */
-export type EvidenceChainState = 'evidence_only' | 'pain_recorded' | 'diagnosis_queued' | 'diagnosis_running' | 'diagnosis_succeeded' | 'diagnosis_failed' | 'diagnosis_retry_wait' | 'candidate_generated' | 'internalization_started';
-export interface EvidenceChainRecord {
-    id: string;
-    sourceKind: string;
-    observedAt: string;
-    state: EvidenceChainState;
-    summary: string;
-    admissionDecision?: string;
-    linkedPainId?: string;
-    linkedTaskId?: string;
-    linkedTaskStatus?: string;
-    linkedCandidateId?: string;
-    linkedPrincipleId?: string;
-    failureReason?: string;
-    degradedReason?: string;
-    nextAction?: string;
-}
-export interface EvidenceChainResponse {
-    records: EvidenceChainRecord[];
-    generatedAt: string;
-    /** Present when data sources are degraded rather than genuinely empty */
-    degradedReason?: string;
-    nextAction?: string;
-    /** Present when evidence-only sources exist but no pain signals */
-    note?: string;
-}
+import { crossReferenceByTimestamp, resolveSummary } from '@principles/core/runtime-v2';
+import type { EvidenceChainState, EvidenceChainRecord, EvidenceChainResponse } from '@principles/core/runtime-v2';
+export type { EvidenceChainState, EvidenceChainRecord, EvidenceChainResponse, };
+export { crossReferenceByTimestamp, resolveSummary, };
 export declare class EvidenceChainConsoleModel {
-    private readConnection;
     private readonly workspaceDir;
     constructor(workspaceDir: string);
-    private getReadConnection;
     getEvidenceChain(): Promise<EvidenceChainResponse>;
     dispose(): void;
 }

package/console/dist/server/models/EvidenceChainConsoleModel.js

@@ -22,158 +22,40 @@
  * - ERR-014/016/017: Evidence previews bounded via sanitizeString
  * - ERR-013: Use Object.hasOwn() for untrusted object keys
  */
-import { SqliteConnection, sanitizeString } from '@principles/core/runtime-v2';
+import { SqliteConnection, sanitizeString, assembleEvidenceChain, crossReferenceByTimestamp, resolveSummary, } from '@principles/core/runtime-v2';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import Database from 'better-sqlite3';
+export { crossReferenceByTimestamp, resolveSummary, };
 // ── Helpers ────────────────────────────────────────────────────────────────────
-function isString(value) {
-    return typeof value === 'string';
-}
-/**
- * Runtime type guard: check if a value is a plain object (Record<string, unknown>).
- * Rejects null, arrays, primitives. Used instead of `as Record<string, unknown>`
- * on untrusted DB rows and parsed JSON (ERR-001/005).
- */
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-/**
- * Coerce an array of unknown values (e.g. better-sqlite3 .all() result)
- * into an array of Record<string, unknown> with runtime validation.
- * Filters out any non-record entries instead of casting the whole array (ERR-001).
- */
-function coerceRowsToRecords(rows) {
-    const result = [];
-    for (const row of rows) {
-        if (isRecord(row)) {
-            result.push(row);
-        }
-    }
-    return result;
+function isString(value) {
+    return typeof value === 'string';
 }
-/**
- * Safe own-property getter for untrusted records (ERR-013).
- * Uses Object.hasOwn() instead of `in` to avoid prototype-chain matches.
- * Returns undefined when key is absent — caller decides whether that's an error.
- */
 function getOwnValue(record, key) {
     return Object.hasOwn(record, key) ? record[key] : undefined;
 }
-/**
- * Read an own string property from an untrusted record.
- * Returns undefined when key is absent or value is not a string.
- */
 function readOwnString(record, key) {
     const value = getOwnValue(record, key);
     return isString(value) ? value : undefined;
 }
-/**
- * Read an own string-array property from an untrusted record.
- * Returns empty array when key is absent, value is not an array,
- * or array contains non-string elements (ERR-005/007).
- */
 function readOwnStringArray(record, key) {
     const value = getOwnValue(record, key);
     if (!Array.isArray(value))
         return [];
     return value.filter(isString);
 }
-/**
- * Coerce a value to string — handles SQLite INTEGER PRIMARY KEY returning number.
- * Returns empty string only for null/undefined; numbers are stringified.
- */
-function coerceToString(value) {
-    if (typeof value === 'string')
-        return value;
-    if (typeof value === 'number' && Number.isFinite(value))
-        return String(value);
-    return '';
-}
 function isMissingTableError(err) {
     if (!(err instanceof Error))
         return false;
     return err.message.includes('no such table');
 }
-/**
- * Map pain_events source to a display-friendly sourceKind.
- * Manual sources are highest confidence; hook/system sources are evidence-only by default.
- */
-function mapSourceKind(source) {
-    switch (source) {
-        case 'manual':
-        case 'owner_explicit_cli':
-        case 'owner_explicit_chat':
-            return 'manual';
-        case 'tool_call':
-        case 'hook':
-            return 'tool_call';
-        case 'rulehost':
-        case 'gate':
-            return 'rulehost';
-        case 'empathy':
-        case 'empathy_inferred':
-            return 'empathy_inferred';
-        case 'review':
-        case 'review_finding':
-            return 'review';
-        default:
-            return source || 'unknown';
-    }
-}
-/**
- * Determine admission decision based on source kind (PEAT-B1 defaults).
- * Owner-explicit manual pain → store_signal (admitted).
- * Tool failures, dispatch errors, provider failures → evidence_only.
- * Empathy inferred → owner_confirmation_required.
- */
-function inferAdmissionDecision(sourceKind) {
-    switch (sourceKind) {
-        case 'manual':
-        case 'review':
-            return 'store_signal';
-        case 'empathy_inferred':
-            return 'owner_confirmation_required';
-        default:
-            return 'evidence_only';
-    }
-}
-function determineState(links) {
-    const { sourceKind, linkedTaskStatus, linkedCandidateId, linkedPrincipleId } = links;
-    // If linked to a principle, internalization has started
-    if (linkedPrincipleId) {
-        return 'internalization_started';
-    }
-    // If linked to a candidate, candidate was generated
-    if (linkedCandidateId) {
-        return 'candidate_generated';
-    }
-    // If linked to a task, check task status
-    if (linkedTaskStatus) {
-        switch (linkedTaskStatus) {
-            case 'pending':
-            case 'queued':
-                return 'diagnosis_queued';
-            case 'running':
-                return 'diagnosis_running';
-            case 'succeeded':
-                return 'diagnosis_succeeded';
-            case 'failed':
-                return 'diagnosis_failed';
-            case 'retry_wait':
-                return 'diagnosis_retry_wait';
-            case 'needs_human_review':
-                return 'diagnosis_failed';
-            default:
-                return 'diagnosis_queued';
-        }
-    }
-    // No task linked — check admission decision
-    const admission = inferAdmissionDecision(sourceKind);
-    if (admission === 'store_signal') {
-        return 'pain_recorded';
-    }
-    return 'evidence_only';
+function isMissingColumnError(err) {
+    if (!(err instanceof Error))
+        return false;
+    return err.message.includes('no such column');
 }
 function readLedgerPrinciples(workspaceDir) {
     const ledgerPath = path.join(workspaceDir, '.state', 'principle_training_state.json');
@@ -246,20 +128,11 @@ function readLedgerPrinciples(workspaceDir) {
 }
 // ── Model ──────────────────────────────────────────────────────────────────────
 export class EvidenceChainConsoleModel {
-    readConnection = null;
     workspaceDir;
     constructor(workspaceDir) {
         this.workspaceDir = workspaceDir;
     }
-    getReadConnection() {
-        if (!this.readConnection) {
-            this.readConnection = new SqliteConnection({ workspaceDir: this.workspaceDir, readonly: true });
-        }
-        return this.readConnection;
-    }
     async getEvidenceChain() {
-        const generatedAt = new Date().toISOString();
-        const records = [];
         const degradedReasons = [];
         const degradedNextActions = [];
         // ── 1. Read pain_events from trajectory.db ────────────────────────────
@@ -270,7 +143,18 @@ export class EvidenceChainConsoleModel {
             let trajDb = null;
             try {
                 trajDb = new Database(trajectoryDbPath, { readonly: true });
-                painEvents = coerceRowsToRecords(trajDb.prepare('SELECT id, session_id, source, score, reason, severity, origin, confidence, text, created_at FROM pain_events ORDER BY created_at DESC LIMIT 100').all());
+                try {
+                    painEvents = trajDb.prepare('SELECT id, session_id, source, score, reason, severity, origin, confidence, text, created_at, canonical_pain_id, runtime_task_id FROM pain_events ORDER BY created_at DESC LIMIT 100').all();
+                }
+                catch (colErr) {
+                    const colMessage = colErr instanceof Error ? colErr.message : String(colErr);
+                    if (colMessage.includes('no such column')) {
+                        painEvents = trajDb.prepare('SELECT id, session_id, source, score, reason, severity, origin, confidence, text, created_at FROM pain_events ORDER BY created_at DESC LIMIT 100').all();
+                    }
+                    else {
+                        throw colErr;
+                    }
+                }
                 trajectoryDbAvailable = true;
             }
             catch (err) {
@@ -291,31 +175,66 @@ export class EvidenceChainConsoleModel {
             degradedReasons.push('Trajectory database not found');
             degradedNextActions.push('PD has not recorded any pain signals in this workspace yet.');
         }
-        // ── 2. Read diagnostician tasks from state.db ─────────────────────────
+        // ── 2. Read tasks & candidates from state.db ──────────────────────
         const stateDbPath = path.join(this.workspaceDir, '.pd', 'state.db');
-        let taskMap = new Map();
+        let tasks = [];
+        let dreamerTasks = [];
+        let candidates = [];
         let stateDbAvailable = false;
         if (fs.existsSync(stateDbPath)) {
+            const conn = new SqliteConnection({ workspaceDir: this.workspaceDir, readonly: true });
             try {
-                const conn = this.getReadConnection();
                 const db = conn.getDb();
-                const tasks = coerceRowsToRecords(db.prepare("SELECT task_id, status, last_error, created_at FROM tasks WHERE task_kind = 'diagnostician' ORDER BY created_at DESC").all());
-                for (const task of tasks) {
-                    const taskId = isString(task.task_id) ? task.task_id : '';
-                    // Diagnostician task IDs follow pattern "diagnosis_<painId>"
-                    const painId = taskId.startsWith('diagnosis_') ? taskId.slice('diagnosis_'.length) : taskId;
-                    taskMap.set(painId, {
-                        taskId,
-                        status: isString(task.status) ? task.status : 'unknown',
-                        lastError: isString(task.last_error) ? task.last_error : null,
-                        createdAt: isString(task.created_at) ? task.created_at : '',
-                    });
+                try {
+                    tasks = db.prepare("SELECT task_id, status, last_error, created_at, diagnostic_json, input_ref FROM tasks WHERE task_kind = 'diagnostician' ORDER BY created_at DESC").all();
+                }
+                catch (colErr) {
+                    if (isMissingColumnError(colErr)) {
+                        try {
+                            tasks = db.prepare("SELECT task_id, status, last_error, created_at, diagnostic_json FROM tasks WHERE task_kind = 'diagnostician' ORDER BY created_at DESC").all();
+                        }
+                        catch (colErr2) {
+                            if (isMissingColumnError(colErr2)) {
+                                tasks = db.prepare("SELECT task_id, status, last_error, created_at FROM tasks WHERE task_kind = 'diagnostician' ORDER BY created_at DESC").all();
+                            }
+                            else {
+                                throw colErr2;
+                            }
+                        }
+                    }
+                    else {
+                        throw colErr;
+                    }
+                }
+                try {
+                    dreamerTasks = db.prepare("SELECT task_id, status FROM tasks WHERE task_kind = 'dreamer'").all();
+                }
+                catch {
+                    degradedReasons.push('Dreamer task query failed — internalization pipeline status is unavailable.');
+                    degradedNextActions.push('Check state database dreamer task table integrity.');
+                }
+                try {
+                    candidates = db.prepare('SELECT candidate_id, task_id, title, description, abstracted_principle, confidence, recommendation_kind FROM principle_candidates').all();
+                }
+                catch (colErr) {
+                    if (isMissingColumnError(colErr)) {
+                        candidates = db.prepare('SELECT candidate_id, task_id FROM principle_candidates').all();
+                    }
+                    else if (isMissingTableError(colErr)) {
+                        // ERR-002: degrade with a specific reason instead of falling through
+                        // to the generic "Tasks/candidates" message.
+                        degradedReasons.push('Candidates table not found in state database');
+                        degradedNextActions.push('Workspace may need initialization via pd config doctor.');
+                    }
+                    else {
+                        throw colErr;
+                    }
                 }
                 stateDbAvailable = true;
             }
             catch (err) {
                 if (isMissingTableError(err)) {
-                    degradedReasons.push('Tasks table not found in state database');
+                    degradedReasons.push('Tasks/candidates table not found in state database');
                     degradedNextActions.push('Workspace may need initialization via pd config doctor.');
                 }
                 else {
@@ -323,171 +242,57 @@ export class EvidenceChainConsoleModel {
                     degradedNextActions.push('Check workspace .pd directory integrity.');
                 }
             }
+            finally {
+                try {
+                    conn.close();
+                }
+                catch { /* best-effort */ }
+            }
         }
         else {
             degradedReasons.push('State database not found');
             degradedNextActions.push('PD runtime has not been initialized in this workspace.');
         }
-        // ── 3. Read candidates from state.db ──────────────────────────────────
-        let candidateMap = new Map(); // painId → candidateId
-        if (stateDbAvailable) {
-            try {
-                const conn = this.getReadConnection();
-                const db = conn.getDb();
-                const candidates = coerceRowsToRecords(db.prepare('SELECT candidate_id, task_id FROM principle_candidates').all());
-                for (const c of candidates) {
-                    const candidateId = isString(c.candidate_id) ? c.candidate_id : '';
-                    const taskId = isString(c.task_id) ? c.task_id : '';
-                    // Reverse-map: taskId → painId
-                    const painId = taskId.startsWith('diagnosis_') ? taskId.slice('diagnosis_'.length) : '';
-                    if (painId && candidateId) {
-                        candidateMap.set(painId, candidateId);
-                    }
-                }
-            }
-            catch (err) {
-                if (isMissingTableError(err)) {
-                    degradedReasons.push('Candidates table not found in state database');
-                    degradedNextActions.push('Candidate and internalization chain links are unavailable. Workspace may need initialization.');
-                }
-                else {
-                    degradedReasons.push('Failed to read candidates table');
-                    degradedNextActions.push('Check state database integrity.');
-                }
-            }
-        }
-        // ── 4. Read ledger principles ─────────────────────────────────────────
+        // ── 3. Read ledger principles ────────────────────────────────────
         const ledgerResult = readLedgerPrinciples(this.workspaceDir);
         const ledgerPrinciples = ledgerResult.principles;
         if (ledgerResult.degradedReason) {
             degradedReasons.push(ledgerResult.degradedReason);
             degradedNextActions.push(ledgerResult.nextAction ?? 'Review principle ledger file.');
         }
-        const painToPrincipleMap = new Map(); // painId → principleId
-        for (const p of ledgerPrinciples) {
-            for (const painId of p.derivedFromPainIds ?? []) {
-                painToPrincipleMap.set(painId, p.id);
+        // ── 4. Assemble using shared logic ──────────────────────────────
+        const response = assembleEvidenceChain({
+            workspaceDir: this.workspaceDir,
+            painEvents,
+            tasks,
+            candidates,
+            dreamerTasks,
+            ledgerPrinciples,
+            trajectoryDbAvailable,
+            stateDbAvailable,
+            degradedReasons,
+            degradedNextActions,
+        });
+        // ── 5. Sanitize strings in place ─────────────────────────────────
+        for (const record of response.records) {
+            record.summary = sanitizeString(record.summary, this.workspaceDir);
+            if (record.rootCauseSummary) {
+                record.rootCauseSummary = sanitizeString(record.rootCauseSummary, this.workspaceDir);
             }
-        }
-        // ── 5. Build evidence chain records from pain_events ──────────────────
-        for (const event of painEvents) {
-            // SQLite INTEGER PRIMARY KEY returns number, not string — must coerce
-            const eventId = coerceToString(event.id);
-            if (!eventId)
-                continue; // Skip records with no valid id (ERR-009: fail loud)
-            const source = isString(event.source) ? event.source : 'unknown';
-            const reason = isString(event.reason) ? event.reason : '';
-            const text = isString(event.text) ? event.text : '';
-            const createdAt = isString(event.created_at) ? event.created_at : '';
-            const score = typeof event.score === 'number' ? event.score : 0;
-            const sourceKind = mapSourceKind(source);
-            // Use id as a stable painId reference
-            const painId = `pain_${eventId}`;
-            // Look up linked task, candidate, principle
-            const linkedTask = taskMap.get(painId);
-            const linkedCandidateId = candidateMap.get(painId) || undefined;
-            const linkedPrincipleId = painToPrincipleMap.get(painId) || undefined;
-            // Determine state
-            const state = determineState({
-                sourceKind,
-                linkedTaskStatus: linkedTask?.status,
-                linkedCandidateId,
-                linkedPrincipleId,
-            });
-            // Build bounded, sanitized summary
-            const rawSummary = text || reason || `Pain signal (source: ${source}, score: ${score})`;
-            const summary = sanitizeString(rawSummary, this.workspaceDir);
-            const record = {
-                id: painId,
-                sourceKind,
-                observedAt: createdAt,
-                state,
-                summary,
-                admissionDecision: inferAdmissionDecision(sourceKind),
-            };
-            if (linkedTask) {
-                record.linkedTaskId = linkedTask.taskId;
-                record.linkedTaskStatus = linkedTask.status;
-                if (linkedTask.lastError && (state === 'diagnosis_failed' || state === 'diagnosis_retry_wait')) {
-                    record.failureReason = sanitizeString(linkedTask.lastError, this.workspaceDir);
-                    record.nextAction = state === 'diagnosis_retry_wait'
-                        ? 'Diagnosis is waiting for automatic retry. Check pipeline status if it stays in this state.'
-                        : 'Diagnosis failed. Check the error details and retry if appropriate.';
-                }
-                else if (state === 'diagnosis_succeeded' && !linkedCandidateId) {
-                    record.nextAction = 'Diagnosis completed. A candidate principle may be generated shortly.';
-                }
+            if (record.failureReason) {
+                record.failureReason = sanitizeString(record.failureReason, this.workspaceDir);
             }
-            if (linkedCandidateId) {
-                record.linkedCandidateId = linkedCandidateId;
+            if (record.candidateTitle) {
+                record.candidateTitle = sanitizeString(record.candidateTitle, this.workspaceDir);
             }
-            if (linkedPrincipleId) {
-                record.linkedPrincipleId = linkedPrincipleId;
+            if (record.candidateSummary) {
+                record.candidateSummary = sanitizeString(record.candidateSummary, this.workspaceDir);
             }
-            records.push(record);
-        }
-        // ── 6. Also include tasks that have no matching pain_event ─────────────
-        // This catches manual pain that was recorded directly through the bridge
-        // without a trajectory.db entry (e.g., pd pain record)
-        const coveredPainIds = new Set(records.map(r => r.id));
-        for (const [painId, task] of taskMap.entries()) {
-            if (coveredPainIds.has(painId))
-                continue;
-            const linkedCandidateId = candidateMap.get(painId) || undefined;
-            const linkedPrincipleId = painToPrincipleMap.get(painId) || undefined;
-            const state = determineState({
-                sourceKind: 'manual',
-                linkedTaskStatus: task.status,
-                linkedCandidateId,
-                linkedPrincipleId,
-            });
-            records.push({
-                id: painId,
-                sourceKind: 'manual',
-                observedAt: task.createdAt,
-                state,
-                summary: sanitizeString(`Manual pain signal (task: ${task.taskId})`, this.workspaceDir),
-                admissionDecision: 'store_signal',
-                linkedTaskId: task.taskId,
-                linkedTaskStatus: task.status,
-                linkedCandidateId,
-                linkedPrincipleId,
-                failureReason: (task.lastError && (state === 'diagnosis_failed' || state === 'diagnosis_retry_wait'))
-                    ? sanitizeString(task.lastError, this.workspaceDir)
-                    : undefined,
-                nextAction: (state === 'diagnosis_retry_wait')
-                    ? 'Diagnosis is waiting for automatic retry.'
-                    : (state === 'diagnosis_failed')
-                        ? 'Diagnosis failed. Check error details and retry.'
-                        : undefined,
-            });
-        }
-        // Sort by observedAt descending
-        records.sort((a, b) => b.observedAt.localeCompare(a.observedAt));
-        // ── 7. Build response ─────────────────────────────────────────────────
-        const response = {
-            records,
-            generatedAt,
-        };
-        if (degradedReasons.length > 0) {
-            response.degradedReason = degradedReasons.join('; ');
-            response.nextAction = degradedNextActions.join(' ');
-        }
-        // Note when evidence-only sources exist but no pain signals
-        if (records.length === 0 && trajectoryDbAvailable && stateDbAvailable) {
-            response.note = 'PD has not captured any displayable behavior evidence in this workspace yet.';
         }
         return response;
     }
+    // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- lifecycle interface; connections are request-scoped
     dispose() {
-        if (this.readConnection) {
-            try {
-                this.readConnection.close();
-            }
-            catch (err) {
-                console.warn('EvidenceChainConsoleModel.dispose: failed to close connection:', err instanceof Error ? err.message : String(err));
-            }
-            this.readConnection = null;
-        }
+        // Connections are opened and closed per-request; no persistent state.
     }
 }

package/console/dist/server/models/GovernanceConsoleModel.d.ts

@@ -18,8 +18,8 @@ export type GovernanceState = 'none' | 'in_progress' | 'owner_review_ready' | 'd
  * Machine-readable codes for degraded signals.
  * Frontend maps these via i18n; `reason` is English debug text.
  */
-export type DegradedReasonCode = 'task_retry_wait' | 'task_failed' | 'approval_table_missing';
-export type DegradedNextActionCode = 'check_task_status' | 'fix_and_retry' | 'run_integrity_check';
+export type DegradedReasonCode = 'task_retry_wait' | 'task_failed' | 'approval_table_missing' | 'trajectory_db_unavailable';
+export type DegradedNextActionCode = 'check_task_status' | 'fix_and_retry' | 'run_integrity_check' | 'check_trajectory_db';
 export interface DegradedSignal {
     /** Machine-readable code for i18n mapping */
     reasonCode: DegradedReasonCode;
@@ -60,15 +60,17 @@ export interface GovernanceQueueResponse {
     inProgressSummary?: string;
     /** Degraded signals when state is 'degraded' */
     degradedSignals?: DegradedSignal[];
+    /** PRI-380: Number of pain events in trajectory.db (behavior evidence in progress) */
+    evidenceInProgressCount?: number;
+    /** Wave 4: Number of gate blocks today (seconds-level auto-blocks by RuleHost) */
+    gateBlocksToday?: number;
     generatedAt: string;
     /** Present when data is degraded/missing rather than genuinely zero */
     note?: string;
 }
 export declare class GovernanceConsoleModel {
-    private readConnection;
     private readonly workspaceDir;
     constructor(workspaceDir: string);
-    private getReadConnection;
     getGovernanceQueue(): Promise<GovernanceQueueResponse>;
     dispose(): void;
 }