create-principles-disciple 1.82.0 → 1.83.0

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

@@ -0,0 +1,246 @@
+import { SqliteConnection, SqliteApprovalQueueStore, SqlitePIArtifactStore, ApprovalQueue, } from '@principles/core/runtime-v2';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+function isMissingTableError(err) {
+    if (!(err instanceof Error))
+        return false;
+    return err.message.includes('no such table');
+}
+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)) {
+            return {
+                pendingReviewCount: 0,
+                behaviorDeviationCount: 0,
+                stagnationSignals: [],
+                governanceState: 'none',
+                stateReasonCode: 'state_db_missing',
+                nextActionCode: 'run_config_doctor',
+                stateReason: 'State database not initialized. PD has not run in this workspace.',
+                nextAction: 'Ensure the OpenClaw plugin is enabled, or run pd config doctor.',
+                generatedAt: new Date().toISOString(),
+                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;
+        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;
+        // Build artifactId → sourcePrincipleId map for stagnation signals
+        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 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;
+            }
+        }
+        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.';
+            }
+            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 {
+            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) {
+            try {
+                this.readConnection.close();
+            }
+            catch (err) {
+                console.warn('GovernanceConsoleModel.dispose: failed to close connection:', err instanceof Error ? err.message : String(err));
+            }
+            this.readConnection = null;
+        }
+    }
+}

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

@@ -19,22 +19,18 @@ export interface SystemHealthStatus {
 }
 export declare class HealthCheckModel {
     private readonly workspaceDir;
-    private readonly stateDir;
     private operatorHealth;
     private painChain;
     private pruning;
     private runtime;
-    private eventLog;
     constructor(workspaceDir: string);
     checkSystemHealth(): Promise<SystemHealthStatus>;
-    private checkEventLog;
     private checkSqlite;
     private checkPainChainFlow;
     private checkTaskQueue;
     private checkPrincipleTree;
     private checkGfiHealth;
     private getPipelineTimestamps;
-    private getEventLogReadModel;
     private getRuntime;
     private getPainChain;
     private getPruning;

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

@@ -1,22 +1,16 @@
-import * as path from 'path';
 import { OperatorHealthReadModel, PainChainReadModel, PruningReadModel, RuntimeStateManager, } from '@principles/core/runtime-v2';
-import { EventLogReadModel } from './EventLogReadModel.js';
 const noop = () => { };
 export class HealthCheckModel {
     workspaceDir;
-    stateDir;
     operatorHealth = null;
     painChain = null;
     pruning = null;
     runtime = null;
-    eventLog = null;
     constructor(workspaceDir) {
         this.workspaceDir = workspaceDir;
-        this.stateDir = path.join(workspaceDir, '.state');
     }
     async checkSystemHealth() {
         const checks = [];
-        checks.push(await this.checkEventLog());
         checks.push(await this.checkSqlite());
         checks.push(await this.checkPainChainFlow());
         checks.push(await this.checkTaskQueue());
@@ -32,53 +26,9 @@ export class HealthCheckModel {
             generatedAt: new Date().toISOString(),
         };
     }
-    async checkEventLog() {
-        try {
-            const eventLog = this.getEventLogReadModel();
-            const recentEvents = await eventLog.getEventsByTypes([], 1);
-            const now = new Date();
-            if (recentEvents.length === 0) {
-                return {
-                    id: 'event_log',
-                    name: '事件日志',
-                    status: 'warning',
-                    message: '暂无事件记录',
-                    lastCheck: now.toISOString(),
-                };
-            }
-            const [lastEvent] = recentEvents;
-            const eventTime = new Date(lastEvent.ts);
-            const diffMinutes = (now.getTime() - eventTime.getTime()) / (1000 * 60);
-            if (diffMinutes > 60) {
-                return {
-                    id: 'event_log',
-                    name: '事件日志',
-                    status: 'warning',
-                    message: `最后事件超过 ${Math.floor(diffMinutes)} 分钟前`,
-                    lastCheck: now.toISOString(),
-                };
-            }
-            return {
-                id: 'event_log',
-                name: '事件日志',
-                status: 'healthy',
-                message: `正常记录中，最后事件 ${Math.floor(diffMinutes)} 分钟前`,
-                lastCheck: now.toISOString(),
-            };
-        }
-        catch (e) {
-            return {
-                id: 'event_log',
-                name: '事件日志',
-                status: 'error',
-                message: `读取失败: ${e.message}`,
-                lastCheck: new Date().toISOString(),
-            };
-        }
-    }
     async checkSqlite() {
         try {
-            const runtime = this.getRuntime();
+            const runtime = await this.getRuntime();
             await runtime.listTasks({ limit: 1 });
             return {
                 id: 'sqlite',
@@ -143,7 +93,7 @@ export class HealthCheckModel {
     }
     async checkTaskQueue() {
         try {
-            const runtime = this.getRuntime();
+            const runtime = await this.getRuntime();
             const pendingTasks = await runtime.listTasks({ status: 'pending', limit: 100 });
             const leasedTasks = await runtime.listTasks({ status: 'leased', limit: 100 });
             const failedTasks = await runtime.listTasks({ status: 'failed', limit: 100 });
@@ -217,7 +167,7 @@ export class HealthCheckModel {
     }
     async checkGfiHealth() {
         try {
-            const health = this.getOperatorHealth();
+            const health = await this.getOperatorHealth();
             const snapshot = await health.getSnapshot();
             const { gfi } = snapshot;
             const { active } = gfi;
@@ -269,37 +219,59 @@ export class HealthCheckModel {
         }
     }
     async getPipelineTimestamps() {
-        const eventLog = this.getEventLogReadModel();
-        const [painSignals, tasks, candidates, promotions] = await Promise.all([
-            eventLog.getEventsByTypes(['pain_signal'], 1),
-            eventLog.getEventsByTypes(['diagnosis_task', 'heartbeat_diagnosis', 'evolution_task'], 1),
-            eventLog.getEventsByTypes(['principle_candidate'], 1),
-            eventLog.getEventsByTypes(['rule_promotion'], 1),
-        ]);
-        return {
-            lastPainSignal: painSignals[0]?.ts ?? null,
-            lastTaskCreated: tasks[0]?.ts ?? null,
-            lastCandidateGenerated: candidates[0]?.ts ?? null,
-            lastPrincipleAdded: promotions[0]?.ts ?? null,
-        };
-    }
-    getEventLogReadModel() {
-        if (!this.eventLog) {
-            this.eventLog = new EventLogReadModel(this.stateDir);
+        try {
+            const runtime = await this.getRuntime();
+            const [painTasks, diagTasks, candidates] = await Promise.all([
+                runtime.listTasks({ taskKind: 'pain_collector', limit: 1 }),
+                runtime.listTasks({ taskKind: 'diagnostician', limit: 1 }),
+                runtime.listTasks({ status: 'succeeded', limit: 1 }),
+            ]);
+            const lastPainSignal = painTasks[0]?.updatedAt ?? null;
+            const lastTaskCreated = diagTasks[0]?.createdAt ?? null;
+            const lastCandidateGenerated = candidates[0]?.updatedAt ?? null;
+            let lastPrincipleAdded = null;
+            try {
+                const pruning = this.getPruning();
+                const summary = pruning.getHealthSummary();
+                const { byStatus } = summary;
+                if ((byStatus.active ?? 0) > 0) {
+                    const signals = pruning.getPrincipleSignals();
+                    const latestSignal = signals.length > 0 ? signals[0] : null;
+                    lastPrincipleAdded = latestSignal?.updatedAt ?? null;
+                }
+            }
+            catch {
+                // Pruning not available — leave as null
+            }
+            return {
+                lastPainSignal,
+                lastTaskCreated,
+                lastCandidateGenerated,
+                lastPrincipleAdded,
+            };
+        }
+        catch {
+            return {
+                lastPainSignal: null,
+                lastTaskCreated: null,
+                lastCandidateGenerated: null,
+                lastPrincipleAdded: null,
+            };
         }
-        return this.eventLog;
     }
-    getRuntime() {
+    async getRuntime() {
         if (!this.runtime) {
             this.runtime = new RuntimeStateManager({ workspaceDir: this.workspaceDir });
+            await this.runtime.initialize();
         }
         return this.runtime;
     }
-    getPainChain() {
+    async getPainChain() {
         if (!this.painChain) {
+            const runtime = await this.getRuntime();
             this.painChain = new PainChainReadModel({
                 workspaceDir: this.workspaceDir,
-                stateManager: this.getRuntime(),
+                stateManager: runtime,
             });
         }
         return this.painChain;
@@ -310,11 +282,12 @@ export class HealthCheckModel {
         }
         return this.pruning;
     }
-    getOperatorHealth() {
+    async getOperatorHealth() {
         if (!this.operatorHealth) {
+            const painChain = await this.getPainChain();
             this.operatorHealth = new OperatorHealthReadModel({
                 workspaceDir: this.workspaceDir,
-                painChainReadModel: this.getPainChain(),
+                painChainReadModel: painChain,
                 pruningReadModel: this.getPruning(),
             });
         }
@@ -333,9 +306,5 @@ export class HealthCheckModel {
             this.runtime.close().catch(noop);
             this.runtime = null;
         }
-        if (this.eventLog) {
-            this.eventLog.dispose();
-            this.eventLog = null;
-        }
     }
 }

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

@@ -0,0 +1,19 @@
+export interface LifecycleMetricsResponse {
+    principleId: string;
+    adherence: {
+        insufficientData: boolean;
+        rate: number | null;
+        note: string;
+    };
+    ruleMetrics: {
+        ruleId: string;
+        triggered: number;
+        lastTriggeredAt: string | null;
+    }[];
+}
+export declare class LifecycleConsoleModel {
+    private readonly workspaceDir;
+    private readonly stateDir;
+    constructor(workspaceDir: string);
+    getLifecycleMetrics(principleId: string): LifecycleMetricsResponse | null;
+}

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

@@ -0,0 +1,55 @@
+import { buildLifecycleReadModel, computePrincipleAdherence, computeRuleMetrics, } from '@principles/core/runtime-v2';
+import { ConsoleLifecycleDatasource } from './ConsoleLifecycleDatasource.js';
+export class LifecycleConsoleModel {
+    workspaceDir;
+    stateDir;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+        this.stateDir = `${workspaceDir}/.state`;
+    }
+    getLifecycleMetrics(principleId) {
+        const datasource = new ConsoleLifecycleDatasource(this.workspaceDir, this.stateDir);
+        const readModel = buildLifecycleReadModel(datasource);
+        const principle = readModel.principles.find((p) => p.principle.id === principleId);
+        if (!principle)
+            return null;
+        const ruleMetricsMap = {};
+        for (const rule of principle.rules) {
+            ruleMetricsMap[rule.rule.id] = computeRuleMetrics(rule);
+        }
+        const adherence = computePrincipleAdherence(principle, ruleMetricsMap);
+        // Build ruleMetrics array from lifecycle evidence
+        const ruleMetrics = principle.rules.map((rule) => {
+            const triggered = rule.replayEvidence.reportCount;
+            const latestReport = rule.replayEvidence.latestReports.length > 0
+                ? rule.replayEvidence.latestReports[0]
+                : null;
+            const lastTriggeredAt = latestReport?.generatedAt ?? null;
+            return {
+                ruleId: rule.rule.id,
+                triggered,
+                lastTriggeredAt,
+            };
+        });
+        if (adherence.insufficientData) {
+            return {
+                principleId,
+                adherence: {
+                    insufficientData: true,
+                    rate: null,
+                    note: '该原则尚无规则，无法计算依从率',
+                },
+                ruleMetrics,
+            };
+        }
+        return {
+            principleId,
+            adherence: {
+                insufficientData: false,
+                rate: adherence.adherenceRate,
+                note: '',
+            },
+            ruleMetrics,
+        };
+    }
+}

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

@@ -0,0 +1,41 @@
+/**
+ * PrincipleClassifier — Read model that classifies principles into
+ * owner-actionable vs noise categories.
+ *
+ * Categories:
+ *  - owner_actionable: Needs a real governance decision (pending, probation, candidate)
+ *  - demo: Demo / example principles planted by the framework
+ *  - smoke: Smoke-test principles for CI validation
+ *  - historical: Archived or deprecated principles (already decided long ago)
+ *  - builtin: Core Thinking OS axioms (T-01..T-10) — not governance targets
+ *  - already_decided: Approved / rejected via approval queue
+ *
+ * Classification is purely read-side; it does NOT mutate any data.
+ */
+import type { PrincipleListItem } from './PrinciplesConsoleModel.js';
+export type PrincipleCategory = 'owner_actionable' | 'demo' | 'smoke' | 'historical' | 'builtin' | 'already_decided';
+export interface ClassifiedPrinciple {
+    principle: PrincipleListItem;
+    category: PrincipleCategory;
+}
+/**
+ * Classify a single principle. Order matters — earlier checks win.
+ *
+ * @param p - The principle to classify
+ * @param decidedPrincipleIds - Set of principle IDs that have been decided
+ *   via the approval queue (approved or rejected). These should be classified
+ *   as already_decided regardless of their ledger status.
+ */
+export declare function classifyPrinciple(p: PrincipleListItem, decidedPrincipleIds?: Set<string>): PrincipleCategory;
+/**
+ * Classify a batch of principles. Returns the classified array.
+ *
+ * @param principles - The principles to classify
+ * @param decidedPrincipleIds - Set of principle IDs that have been decided
+ *   via the approval queue (approved or rejected).
+ */
+export declare function classifyPrinciples(principles: PrincipleListItem[], decidedPrincipleIds?: Set<string>): ClassifiedPrinciple[];
+/**
+ * Filter to only owner-actionable principles.
+ */
+export declare function filterOwnerActionable(classified: ClassifiedPrinciple[]): ClassifiedPrinciple[];