create-principles-disciple 1.86.0 → 1.87.0

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

@@ -6,18 +6,14 @@ function isMissingTableError(err) {
         return false;
     return err.message.includes('no such table');
 }
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 export class GovernanceConsoleModel {
-    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 getGovernanceQueue() {
         const stateDbPath = path.join(this.workspaceDir, '.pd', 'state.db');
         if (!fs.existsSync(stateDbPath)) {
@@ -34,213 +30,291 @@ export class GovernanceConsoleModel {
                 note: 'state.db not found — workspace may not be initialized',
             };
         }
-        const conn = this.getReadConnection();
-        const store = new SqliteApprovalQueueStore(conn);
-        const queue = new ApprovalQueue(store);
-        const artifactStore = new SqlitePIArtifactStore(conn);
-        const db = conn.getDb();
-        // ── Gather signals from multiple data sources ───────────────────────
-        // 1. Pending approvals
-        let pendingApprovals;
-        let missingApprovalTable = false;
+        const conn = new SqliteConnection({ workspaceDir: this.workspaceDir, readonly: true });
         try {
-            pendingApprovals = await queue.listPending();
-        }
-        catch (err) {
-            if (isMissingTableError(err)) {
-                pendingApprovals = [];
-                missingApprovalTable = true;
+            const store = new SqliteApprovalQueueStore(conn);
+            const queue = new ApprovalQueue(store);
+            const artifactStore = new SqlitePIArtifactStore(conn);
+            const db = conn.getDb();
+            // 1. Pending approvals
+            let pendingApprovals;
+            let missingApprovalTable = false;
+            try {
+                pendingApprovals = await queue.listPending();
+            }
+            catch (err) {
+                if (isMissingTableError(err)) {
+                    pendingApprovals = [];
+                    missingApprovalTable = true;
+                }
+                else {
+                    throw err;
+                }
+            }
+            const pendingReviewCount = pendingApprovals.length;
+            const behaviorDeviationCount = pendingApprovals.filter((a) => a.riskLevel === 'high' || a.riskLevel === 'critical').length;
+            const artifactPrincipleMap = new Map();
+            for (const approval of pendingApprovals) {
+                if (!artifactPrincipleMap.has(approval.artifactId)) {
+                    try {
+                        const artifact = await artifactStore.getArtifactById(approval.artifactId);
+                        artifactPrincipleMap.set(approval.artifactId, artifact?.sourcePrincipleId ?? null);
+                    }
+                    catch (err) {
+                        if (isMissingTableError(err)) {
+                            artifactPrincipleMap.set(approval.artifactId, null);
+                        }
+                        else {
+                            throw err;
+                        }
+                    }
+                }
+            }
+            const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
+            const stagnationSignals = pendingApprovals
+                .filter((a) => {
+                const requestedAt = new Date(a.requestedAt).getTime();
+                return !Number.isNaN(requestedAt) && requestedAt < sevenDaysAgo;
+            })
+                .map((a) => {
+                const requestedAt = new Date(a.requestedAt).getTime();
+                const daysSince = Math.floor((Date.now() - requestedAt) / (24 * 60 * 60 * 1000));
+                const principleId = artifactPrincipleMap.get(a.artifactId) ?? 'unlinked';
+                return {
+                    type: 'never_activated',
+                    principleId,
+                    daysSince,
+                };
+            });
+            // 2. Check internalization pipeline activity (tasks)
+            let hasInternalizationTasks = false;
+            let hasRetryWaitTasks = false;
+            let hasFailedTasks = false;
+            const retryWaitReasons = [];
+            const failedReasons = [];
+            try {
+                const tasks = db.prepare(`SELECT task_kind, status, last_error FROM tasks WHERE task_kind IN ('dreamer', 'philosopher', 'scribe', 'artificer', 'evaluator')`).all();
+                hasInternalizationTasks = tasks.length > 0;
+                for (const task of tasks) {
+                    if (task.status === 'retry_wait') {
+                        hasRetryWaitTasks = true;
+                        const errText = task.last_error ? task.last_error.substring(0, 120) : 'unknown error';
+                        retryWaitReasons.push(`${task.task_kind}: ${errText}`);
+                    }
+                    if (task.status === 'failed') {
+                        hasFailedTasks = true;
+                        const errText = task.last_error ? task.last_error.substring(0, 120) : 'unknown error';
+                        failedReasons.push(`${task.task_kind}: ${errText}`);
+                    }
+                }
+            }
+            catch (err) {
+                if (!isMissingTableError(err))
+                    throw err;
+            }
+            // 3. Check candidates table
+            let hasConsumedCandidates = false;
+            let hasPendingCandidates = false;
+            try {
+                const candidateRow = db.prepare(`SELECT status, COUNT(*) as c FROM principle_candidates GROUP BY status`).all();
+                for (const row of candidateRow) {
+                    if (row.status === 'consumed')
+                        hasConsumedCandidates = true;
+                    if (row.status === 'pending' || row.status === 'new')
+                        hasPendingCandidates = true;
+                }
+            }
+            catch (err) {
+                if (!isMissingTableError(err))
+                    throw err;
+            }
+            // 4. Degraded signals
+            const degradedSignals = [];
+            if (hasRetryWaitTasks) {
+                degradedSignals.push({
+                    reasonCode: 'task_retry_wait',
+                    nextActionCode: 'check_task_status',
+                    reason: `Internalization task waiting for retry: ${retryWaitReasons.join('; ')}`,
+                    nextAction: 'Check internalization pipeline status, or wait for automatic retry.',
+                    source: 'internalization_task',
+                });
+            }
+            if (hasFailedTasks) {
+                degradedSignals.push({
+                    reasonCode: 'task_failed',
+                    nextActionCode: 'fix_and_retry',
+                    reason: `Internalization task failed: ${failedReasons.join('; ')}`,
+                    nextAction: 'Check failure details, fix the issue and retry.',
+                    source: 'internalization_task',
+                });
+            }
+            if (missingApprovalTable) {
+                degradedSignals.push({
+                    reasonCode: 'approval_table_missing',
+                    nextActionCode: 'run_integrity_check',
+                    reason: 'Approval table does not exist. This may be an old workspace.',
+                    nextAction: 'Run pd runtime internalization integrity to check and repair table structure.',
+                    source: 'source_unavailable',
+                });
+            }
+            // ── Determine governance state ──────────────────────────────────────
+            const hasOwnerReadyItems = pendingReviewCount > 0;
+            const hasPipelineActivity = hasInternalizationTasks || hasConsumedCandidates || hasPendingCandidates;
+            const hasDegradation = degradedSignals.length > 0;
+            let governanceState;
+            let stateReasonCode;
+            let nextActionCode;
+            let stateReason;
+            let nextAction;
+            let inProgressSummary;
+            if (hasOwnerReadyItems) {
+                governanceState = 'owner_review_ready';
+                stateReasonCode = 'pending_approvals';
+                nextActionCode = 'review_approvals';
+                stateReason = `${pendingReviewCount} principle(s) pending your review and decision.`;
+                nextAction = 'Review pending principles and approve, reject, or park.';
+            }
+            else if (hasDegradation) {
+                governanceState = 'degraded';
+                stateReasonCode = 'degraded_state';
+                nextActionCode = 'check_degraded_signals';
+                stateReason = 'Part of the governance pipeline or data source is degraded.';
+                nextAction = 'Check degraded signal details and follow suggested actions.';
+            }
+            else if (hasPipelineActivity) {
+                governanceState = 'in_progress';
+                if (hasInternalizationTasks) {
+                    stateReasonCode = 'pipeline_active';
+                    nextActionCode = 'check_pipeline_status';
+                    inProgressSummary = 'PD is processing the internalization pipeline: diagnostics, principle candidates, or internalization task activity recorded, but no owner-reviewable decision items yet.';
+                    stateReason = 'Pipeline has activity, but candidate principles are not ready for review.';
+                    nextAction = 'Wait for internalization tasks to complete. If no change for a long time, check pipeline status.';
+                }
+                else {
+                    stateReasonCode = 'consumed_candidates';
+                    nextActionCode = 'wait_for_pipeline';
+                    inProgressSummary = 'PD has recorded governance chain activity (candidates generated), but candidates are not yet ready for review.';
+                    stateReason = 'Candidate records exist, but have not entered the review stage.';
+                    nextAction = 'Wait for the internalization pipeline to convert candidates into reviewable principles.';
+                }
             }
             else {
-                throw err;
+                governanceState = 'none';
+                stateReasonCode = 'no_pipeline_activity';
+                nextActionCode = 'wait_for_pipeline';
+                stateReason = 'No governance chain activity recorded yet.';
+                nextAction = 'PD will surface principle candidates here once behavior deviations are captured and reviewable artifacts are generated.';
             }
-        }
-        const pendingReviewCount = pendingApprovals.length;
-        const behaviorDeviationCount = pendingApprovals.filter((a) => a.riskLevel === 'high' || a.riskLevel === 'critical').length;
-        // Build artifactId → sourcePrincipleId map for stagnation signals
-        const artifactPrincipleMap = new Map();
-        for (const approval of pendingApprovals) {
-            if (!artifactPrincipleMap.has(approval.artifactId)) {
+            // PRI-380: Query trajectory.db for behavior evidence count
+            let evidenceInProgressCount = 0;
+            const trajectoryDbPath = path.join(this.workspaceDir, '.state', 'trajectory.db');
+            if (fs.existsSync(trajectoryDbPath)) {
                 try {
-                    const artifact = await artifactStore.getArtifactById(approval.artifactId);
-                    artifactPrincipleMap.set(approval.artifactId, artifact?.sourcePrincipleId ?? null);
+                    const Database = (await import('better-sqlite3')).default;
+                    const trajDb = new Database(trajectoryDbPath, { readonly: true });
+                    try {
+                        const rows = trajDb.prepare('SELECT COUNT(*) as c FROM pain_events').all();
+                        if (Array.isArray(rows) && rows.length > 0) {
+                            const [row] = rows;
+                            if (isRecord(row) && Object.hasOwn(row, 'c') && typeof row.c === 'number') {
+                                evidenceInProgressCount = row.c;
+                            }
+                        }
+                    }
+                    catch (err) {
+                        if (!isMissingTableError(err))
+                            throw err;
+                        degradedSignals.push({
+                            reasonCode: 'trajectory_db_unavailable',
+                            nextActionCode: 'check_trajectory_db',
+                            reason: 'Behavior evidence source (trajectory.db) is unavailable — evidence count may be inaccurate.',
+                            nextAction: 'Check trajectory.db file integrity in .state directory.',
+                            source: 'source_unavailable',
+                        });
+                    }
+                    finally {
+                        trajDb.close();
+                    }
                 }
                 catch (err) {
-                    if (isMissingTableError(err)) {
-                        artifactPrincipleMap.set(approval.artifactId, null);
-                    }
-                    else {
+                    degradedSignals.push({
+                        reasonCode: 'trajectory_db_unavailable',
+                        nextActionCode: 'check_trajectory_db',
+                        reason: 'Behavior evidence source (trajectory.db) is unavailable — evidence count may be inaccurate.',
+                        nextAction: 'Check trajectory.db file integrity in .state directory.',
+                        source: 'source_unavailable',
+                    });
+                    if (!(err instanceof Error))
                         throw err;
-                    }
                 }
             }
-        }
-        const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
-        const stagnationSignals = pendingApprovals
-            .filter((a) => {
-            const requestedAt = new Date(a.requestedAt).getTime();
-            return !Number.isNaN(requestedAt) && requestedAt < sevenDaysAgo;
-        })
-            .map((a) => {
-            const requestedAt = new Date(a.requestedAt).getTime();
-            const daysSince = Math.floor((Date.now() - requestedAt) / (24 * 60 * 60 * 1000));
-            const principleId = artifactPrincipleMap.get(a.artifactId) ?? 'unlinked';
-            return {
-                type: 'never_activated',
-                principleId,
-                daysSince,
-            };
-        });
-        // 2. Check internalization pipeline activity (tasks)
-        let hasInternalizationTasks = false;
-        let hasRetryWaitTasks = false;
-        let hasFailedTasks = false;
-        const retryWaitReasons = [];
-        const failedReasons = [];
-        try {
-            const tasks = db.prepare(`SELECT task_kind, status, last_error FROM tasks WHERE task_kind IN ('dreamer', 'philosopher', 'scribe', 'artificer', 'evaluator')`).all();
-            hasInternalizationTasks = tasks.length > 0;
-            for (const task of tasks) {
-                if (task.status === 'retry_wait') {
-                    hasRetryWaitTasks = true;
-                    const errText = task.last_error ? task.last_error.substring(0, 120) : 'unknown error';
-                    retryWaitReasons.push(`${task.task_kind}: ${errText}`);
+            // Wave 4: Query gate_blocks for today's auto-block count
+            let gateBlocksToday = 0;
+            if (fs.existsSync(trajectoryDbPath)) {
+                try {
+                    const Database = (await import('better-sqlite3')).default;
+                    const trajDb = new Database(trajectoryDbPath, { readonly: true });
+                    try {
+                        const todayStart = new Date();
+                        todayStart.setHours(0, 0, 0, 0);
+                        const row = trajDb.prepare('SELECT COUNT(*) as c FROM gate_blocks WHERE created_at >= ?').get(todayStart.toISOString());
+                        if (isRecord(row) && Object.hasOwn(row, 'c') && typeof row.c === 'number') {
+                            gateBlocksToday = row.c;
+                        }
+                    }
+                    catch (err) {
+                        if (!isMissingTableError(err))
+                            throw err;
+                    }
+                    finally {
+                        trajDb.close();
+                    }
                 }
-                if (task.status === 'failed') {
-                    hasFailedTasks = true;
-                    const errText = task.last_error ? task.last_error.substring(0, 120) : 'unknown error';
-                    failedReasons.push(`${task.task_kind}: ${errText}`);
+                catch (err) {
+                    degradedSignals.push({
+                        reasonCode: 'trajectory_db_unavailable',
+                        nextActionCode: 'check_trajectory_db',
+                        reason: 'gate_blocks source is unavailable — gate block count may be inaccurate.',
+                        nextAction: 'Check trajectory.db file integrity in .state directory.',
+                        source: 'source_unavailable',
+                    });
+                    console.warn('GovernanceConsoleModel: failed to read gate_blocks:', err);
                 }
             }
-        }
-        catch (err) {
-            if (!isMissingTableError(err))
-                throw err;
-        }
-        // 3. Check candidates table for pipeline activity
-        let hasConsumedCandidates = false;
-        let hasPendingCandidates = false;
-        try {
-            const candidateRow = db.prepare(`SELECT status, COUNT(*) as c FROM principle_candidates GROUP BY status`).all();
-            for (const row of candidateRow) {
-                if (row.status === 'consumed')
-                    hasConsumedCandidates = true;
-                if (row.status === 'pending' || row.status === 'new')
-                    hasPendingCandidates = true;
+            const response = {
+                pendingReviewCount,
+                behaviorDeviationCount,
+                stagnationSignals,
+                governanceState,
+                stateReasonCode,
+                nextActionCode,
+                stateReason,
+                nextAction,
+                generatedAt: new Date().toISOString(),
+            };
+            if (inProgressSummary) {
+                response.inProgressSummary = inProgressSummary;
             }
-        }
-        catch (err) {
-            if (!isMissingTableError(err))
-                throw err;
-        }
-        // 4. Degraded signals
-        const degradedSignals = [];
-        if (hasRetryWaitTasks) {
-            degradedSignals.push({
-                reasonCode: 'task_retry_wait',
-                nextActionCode: 'check_task_status',
-                reason: `Internalization task waiting for retry: ${retryWaitReasons.join('; ')}`,
-                nextAction: 'Check internalization pipeline status, or wait for automatic retry.',
-                source: 'internalization_task',
-            });
-        }
-        if (hasFailedTasks) {
-            degradedSignals.push({
-                reasonCode: 'task_failed',
-                nextActionCode: 'fix_and_retry',
-                reason: `Internalization task failed: ${failedReasons.join('; ')}`,
-                nextAction: 'Check failure details, fix the issue and retry.',
-                source: 'internalization_task',
-            });
-        }
-        if (missingApprovalTable) {
-            degradedSignals.push({
-                reasonCode: 'approval_table_missing',
-                nextActionCode: 'run_integrity_check',
-                reason: 'Approval table does not exist. This may be an old workspace.',
-                nextAction: 'Run pd runtime internalization integrity to check and repair table structure.',
-                source: 'source_unavailable',
-            });
-        }
-        // ── Determine governance state ──────────────────────────────────────
-        // P1-2: Only pendingReviewCount determines owner_review_ready.
-        // Validated artifacts are NOT sufficient — they may be demo/smoke/historical.
-        // The owner-actionable queue read model (PRI-330) will refine this.
-        const hasOwnerReadyItems = pendingReviewCount > 0;
-        const hasPipelineActivity = hasInternalizationTasks || hasConsumedCandidates || hasPendingCandidates;
-        const hasDegradation = degradedSignals.length > 0;
-        let governanceState;
-        let stateReasonCode;
-        let nextActionCode;
-        let stateReason;
-        let nextAction;
-        let inProgressSummary;
-        if (hasOwnerReadyItems) {
-            governanceState = 'owner_review_ready';
-            stateReasonCode = 'pending_approvals';
-            nextActionCode = 'review_approvals';
-            stateReason = `${pendingReviewCount} principle(s) pending your review and decision.`;
-            nextAction = 'Review pending principles and approve, reject, or park.';
-        }
-        else if (hasDegradation) {
-            governanceState = 'degraded';
-            stateReasonCode = 'degraded_state';
-            nextActionCode = 'check_degraded_signals';
-            stateReason = 'Part of the governance pipeline or data source is degraded.';
-            nextAction = 'Check degraded signal details and follow suggested actions.';
-        }
-        else if (hasPipelineActivity) {
-            governanceState = 'in_progress';
-            if (hasInternalizationTasks) {
-                stateReasonCode = 'pipeline_active';
-                nextActionCode = 'check_pipeline_status';
-                inProgressSummary = 'PD is processing the internalization pipeline: diagnostics, principle candidates, or internalization task activity recorded, but no owner-reviewable decision items yet.';
-                stateReason = 'Pipeline has activity, but candidate principles are not ready for review.';
-                nextAction = 'Wait for internalization tasks to complete. If no change for a long time, check pipeline status.';
+            if (degradedSignals.length > 0) {
+                response.degradedSignals = degradedSignals;
             }
-            else {
-                stateReasonCode = 'consumed_candidates';
-                nextActionCode = 'wait_for_pipeline';
-                inProgressSummary = 'PD has recorded governance chain activity (candidates generated), but candidates are not yet ready for review.';
-                stateReason = 'Candidate records exist, but have not entered the review stage.';
-                nextAction = 'Wait for the internalization pipeline to convert candidates into reviewable principles.';
+            if (evidenceInProgressCount > 0) {
+                response.evidenceInProgressCount = evidenceInProgressCount;
             }
+            if (gateBlocksToday > 0) {
+                response.gateBlocksToday = gateBlocksToday;
+            }
+            return response;
         }
-        else {
-            governanceState = 'none';
-            stateReasonCode = 'no_pipeline_activity';
-            nextActionCode = 'wait_for_pipeline';
-            stateReason = 'No governance chain activity recorded yet.';
-            nextAction = 'PD will surface principle candidates here once behavior deviations are captured and reviewable artifacts are generated.';
-        }
-        const response = {
-            pendingReviewCount,
-            behaviorDeviationCount,
-            stagnationSignals,
-            governanceState,
-            stateReasonCode,
-            nextActionCode,
-            stateReason,
-            nextAction,
-            generatedAt: new Date().toISOString(),
-        };
-        if (inProgressSummary) {
-            response.inProgressSummary = inProgressSummary;
-        }
-        if (degradedSignals.length > 0) {
-            response.degradedSignals = degradedSignals;
-        }
-        return response;
-    }
-    dispose() {
-        if (this.readConnection) {
+        finally {
             try {
-                this.readConnection.close();
+                conn.close();
             }
-            catch (err) {
-                console.warn('GovernanceConsoleModel.dispose: failed to close connection:', err instanceof Error ? err.message : String(err));
-            }
-            this.readConnection = null;
+            catch { /* best-effort */ }
         }
     }
+    // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- lifecycle interface; connections are request-scoped
+    dispose() {
+        // Connections are opened and closed per-request; no persistent state.
+    }
 }

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

@@ -13,7 +13,7 @@
  * Classification is purely read-side; it does NOT mutate any data.
  */
 // ── Heuristics ────────────────────────────────────────────────────────────────
-/** Regex that matches exactly T-01 through T-10 (Thinking OS axioms) */
+/** Regex that matches core Thinking OS axiom IDs (T-NN pattern, e.g. T-01..T-10) */
 const BUILTIN_ID_REGEX = /^T-(0[1-9]|10)$/;
 /** ID prefixes that indicate demo / dogfood data */
 const DEMO_ID_PREFIXES = ['DEMO_', 'demo_', 'story-a', 'story_a', 'dogfood_'];

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

@@ -0,0 +1,49 @@
+/**
+ * PrincipleTrajectoryModel — assembles per-principle trajectory data.
+ *
+ * Reads from:
+ * - principle_training_state.json (ledger)
+ * - state.db: principle_candidates, tasks, artifacts, pi_artifacts, approvals, activations
+ *
+ * Returns 6 stages: evidence → diagnosis → proposal → review → deploy → behavior.
+ * Each stage has status (available/unavailable/not_applicable), summary, and
+ * structured metadata for the frontend to render.
+ *
+ * ERR checklist:
+ * - ERR-001/005: All DB rows treated as unknown, runtime validation
+ * - ERR-002: Degraded paths include reason + nextAction, never silent fallback
+ * - ERR-009/010: Required fields fail loud
+ * - ERR-013: Use Object.hasOwn() for untrusted object keys
+ * - ERR-014/016/017: Previews bounded, no raw JSON.stringify on unknown values
+ */
+export interface TrajectoryStage {
+    key: 'evidence' | 'diagnosis' | 'proposal' | 'review' | 'deploy' | 'behavior';
+    status: 'available' | 'unavailable' | 'not_applicable';
+    summary: string;
+    detail?: string;
+    timestamp?: string;
+    unavailableReason?: string;
+    nextAction?: string;
+    meta?: Record<string, unknown>;
+}
+export interface TrajectoryResponse {
+    principleId: string;
+    stages: TrajectoryStage[];
+    degraded?: {
+        reason: string;
+        nextAction: string;
+    };
+}
+export declare class PrincipleTrajectoryModel {
+    private readonly workspaceDir;
+    constructor(workspaceDir: string);
+    getTrajectory(principleId: string): Promise<TrajectoryResponse>;
+    private assembleEvidenceStage;
+    private assembleDiagnosisStage;
+    private assembleProposalStage;
+    private assembleReviewStage;
+    private assembleDeployStage;
+    private assembleBehaviorStage;
+    private createAllUnavailable;
+    dispose(): void;
+}