create-principles-disciple 1.0.0 → 1.74.0

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

@@ -0,0 +1,179 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import { RuntimeStateManager, InternalizationQueueReadModel, } from '@principles/core/runtime-v2';
+export class EvolutionConsoleModel {
+    workspaceDir;
+    stateManager = null;
+    initPromise = null;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+    }
+    async ensureInitialized() {
+        if (!this.stateManager) {
+            this.stateManager = new RuntimeStateManager({ workspaceDir: this.workspaceDir });
+            this.initPromise = this.stateManager.initialize();
+        }
+        await this.initPromise;
+        return this.stateManager;
+    }
+    async getStats() {
+        const mgr = await this.ensureInitialized();
+        const allTasks = await mgr.listTasks();
+        let pending = 0;
+        let inProgress = 0;
+        let completed = 0;
+        let failed = 0;
+        const stageMap = {};
+        for (const task of allTasks) {
+            switch (task.status) {
+                case 'pending':
+                    pending++;
+                    break;
+                case 'leased':
+                    inProgress++;
+                    break;
+                case 'succeeded':
+                    completed++;
+                    break;
+                case 'retry_wait':
+                    inProgress++;
+                    break;
+                case 'failed':
+                    failed++;
+                    break;
+                default: break;
+            }
+            const stage = task.status;
+            stageMap[stage] = (stageMap[stage] ?? 0) + 1;
+        }
+        const stageDistribution = Object.entries(stageMap)
+            .map(([stage, count]) => ({ stage, count }))
+            .sort((a, b) => b.count - a.count);
+        return {
+            total: allTasks.length,
+            pending,
+            inProgress,
+            completed,
+            failed,
+            stageDistribution,
+        };
+    }
+    async getTasks(filters = {}) {
+        const mgr = await this.ensureInitialized();
+        const page = Math.max(1, filters.page ?? 1);
+        const pageSize = Math.min(Math.max(1, filters.pageSize ?? 20), 100);
+        let tasks = await mgr.listTasks();
+        if (filters.status && filters.status !== 'all') {
+            tasks = tasks.filter(t => t.status === filters.status);
+        }
+        if (filters.taskKind && filters.taskKind !== 'all') {
+            tasks = tasks.filter(t => t.taskKind === filters.taskKind);
+        }
+        tasks.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+        const total = tasks.length;
+        const offset = (page - 1) * pageSize;
+        const items = tasks.slice(offset, offset + pageSize).map(t => ({
+            taskId: t.taskId,
+            taskKind: t.taskKind,
+            status: t.status,
+            createdAt: t.createdAt,
+            leaseOwner: t.leaseOwner ?? null,
+            leaseExpiresAt: t.leaseExpiresAt ?? null,
+        }));
+        return {
+            items,
+            pagination: {
+                page,
+                pageSize,
+                total,
+                totalPages: total === 0 ? 0 : Math.ceil(total / pageSize),
+            },
+        };
+    }
+    async getPrinciples() {
+        const stateDir = path.join(this.workspaceDir, '.state');
+        const ledgerPath = path.join(stateDir, 'principle_training_state.json');
+        const summary = {
+            candidate: 0,
+            probation: 0,
+            active: 0,
+            deprecated: 0,
+            archived: 0,
+            total: 0,
+        };
+        const recent = [];
+        if (!fs.existsSync(ledgerPath)) {
+            return { summary, recent };
+        }
+        try {
+            const raw = fs.readFileSync(ledgerPath, 'utf8');
+            const parsed = JSON.parse(raw);
+            const principles = Object.values(parsed._tree?.principles ?? parsed.tree?.principles ?? {});
+            for (const p of principles) {
+                summary.total++;
+                switch (p.status) {
+                    case 'candidate':
+                        summary.candidate++;
+                        break;
+                    case 'probation':
+                        summary.probation++;
+                        break;
+                    case 'active':
+                        summary.active++;
+                        break;
+                    case 'deprecated':
+                        summary.deprecated++;
+                        break;
+                    case 'archived':
+                        summary.archived++;
+                        break;
+                }
+            }
+            const sorted = [...principles].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+            for (const p of sorted.slice(0, 20)) {
+                recent.push({
+                    principleId: p.id,
+                    status: p.status,
+                    text: p.text,
+                    triggerPattern: p.triggerPattern,
+                    action: p.action,
+                    evaluability: p.evaluability,
+                    createdAt: p.createdAt,
+                    updatedAt: p.updatedAt,
+                });
+            }
+        }
+        catch {
+            // Silently skip invalid entries
+        }
+        return { summary, recent };
+    }
+    async getQueueHealth() {
+        const mgr = await this.ensureInitialized();
+        const readModel = new InternalizationQueueReadModel(mgr);
+        try {
+            const snapshot = await readModel.getSnapshot();
+            return {
+                pendingCount: snapshot.pendingCount,
+                retryWaitCount: snapshot.retryWaitCount,
+                countsByTaskKind: snapshot.countsByTaskKind,
+                countsByChannel: snapshot.countsByChannel,
+                invalidMetadataCount: snapshot.invalidMetadataCount,
+                blockedCount: snapshot.blockedSummary.count,
+                dependencyFailedCount: snapshot.dependencyFailedSummary.count,
+                readyTaskCount: snapshot.readyTasks.length,
+                noReadyTasksReason: snapshot.noReadyTasks?.reason ?? null,
+            };
+        }
+        finally {
+            await readModel.close();
+        }
+    }
+    dispose() {
+        if (this.stateManager) {
+            this.stateManager.close().catch((_e) => { });
+            this.stateManager = null;
+        }
+        this.initPromise = null;
+    }
+}

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

@@ -0,0 +1,38 @@
+import type { GateBlockItem, EmpathyEvent } from '../types/index.js';
+export declare class FeedbackConsoleModel {
+    private readonly workspaceDir;
+    private readonly stateDir;
+    private gateModel;
+    private eventLogReadModel;
+    constructor(workspaceDir: string);
+    getGfi(): Promise<{
+        current: number;
+        peakToday: number;
+        threshold: number;
+        trend: {
+            hour: string;
+            value: number;
+        }[];
+        sources: Record<string, number>;
+    }>;
+    getEmpathyEvents(_limit?: number): Promise<EmpathyEvent[]>;
+    getEmpathySummary(): Promise<{
+        totalEvents: number;
+        totalPenaltyScore: number;
+        rollbackCount: number;
+        bySeverity: Record<string, number>;
+        byOrigin: Record<string, number>;
+    }>;
+    getGateBlocks(limit?: number): Promise<GateBlockItem[]>;
+    getRuleHostSummary(): Promise<{
+        totalEvaluated: number;
+        totalBlocked: number;
+        totalRequireApproval: number;
+        blockRate: number;
+    }>;
+    private static convertScoreToSeverity;
+    private readDailyStats;
+    private getGateModel;
+    private getEventLogReadModel;
+    dispose(): void;
+}

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

@@ -0,0 +1,129 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import { EventLogReadModel } from './EventLogReadModel.js';
+import { GateConsoleModel } from './GateConsoleModel.js';
+export class FeedbackConsoleModel {
+    workspaceDir;
+    stateDir;
+    gateModel = null;
+    eventLogReadModel = null;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+        this.stateDir = path.join(workspaceDir, '.state');
+    }
+    async getGfi() {
+        const stats = await this.getGateModel().getGateStats();
+        return {
+            current: stats.gfi.current,
+            peakToday: stats.gfi.peakToday,
+            threshold: stats.gfi.threshold,
+            trend: stats.gfi.trend,
+            sources: stats.gfi.sources,
+        };
+    }
+    async getEmpathyEvents(_limit) {
+        const events = await this.getEventLogReadModel().getEventsByTypes(['empathy_rollback', 'user_empathy', 'pain_signal'], _limit ?? 50);
+        return events
+            .filter(e => e.type === 'empathy_rollback' ||
+            e.type === 'user_empathy' ||
+            (e.type === 'pain_signal' && typeof e.data?.source === 'string'))
+            .map(event => ({
+            timestamp: event.ts,
+            severity: FeedbackConsoleModel.convertScoreToSeverity(event.data?.score ?? 50),
+            score: event.data?.score ?? 50,
+            reason: event.data?.reason ?? '',
+            origin: typeof event.data?.origin === 'string' ? event.data.origin : typeof event.data?.source === 'string' ? event.data.source : 'unknown',
+            gfiAfter: 0,
+        }));
+    }
+    async getEmpathySummary() {
+        const dailyStats = await this.readDailyStats();
+        let totalEvents = 0;
+        let totalPenaltyScore = 0;
+        let rollbackCount = 0;
+        const bySeverity = {};
+        const byOrigin = {};
+        for (const day of Object.values(dailyStats)) {
+            const emp = day?.empathy;
+            if (!emp)
+                continue;
+            totalEvents += Number(emp.totalEvents) || 0;
+            totalPenaltyScore += Number(emp.totalPenaltyScore) || 0;
+            rollbackCount += Number(emp.rollbackCount) || 0;
+            if (emp.bySeverity) {
+                for (const [k, v] of Object.entries(emp.bySeverity)) {
+                    bySeverity[k] = (bySeverity[k] ?? 0) + (Number(v) || 0);
+                }
+            }
+            if (emp.byOrigin) {
+                for (const [k, v] of Object.entries(emp.byOrigin)) {
+                    byOrigin[k] = (byOrigin[k] ?? 0) + (Number(v) || 0);
+                }
+            }
+        }
+        return { totalEvents, totalPenaltyScore, rollbackCount, bySeverity, byOrigin };
+    }
+    async getGateBlocks(limit) {
+        return this.getGateModel().getGateBlocks(limit);
+    }
+    async getRuleHostSummary() {
+        const dailyStats = await this.readDailyStats();
+        let totalEvaluated = 0;
+        let totalBlocked = 0;
+        let totalRequireApproval = 0;
+        for (const day of Object.values(dailyStats)) {
+            const evo = day?.evolution;
+            if (!evo)
+                continue;
+            totalEvaluated += Number(evo.rulehostEvaluated) || 0;
+            totalBlocked += Number(evo.rulehostBlocked) || 0;
+            totalRequireApproval += Number(evo.rulehostRequireApproval) || 0;
+        }
+        return {
+            totalEvaluated,
+            totalBlocked,
+            totalRequireApproval,
+            blockRate: totalEvaluated > 0 ? Math.round((totalBlocked / totalEvaluated) * 10000) / 100 : 0,
+        };
+    }
+    static convertScoreToSeverity(score) {
+        if (score >= 70)
+            return 'high';
+        if (score >= 40)
+            return 'medium';
+        return 'low';
+    }
+    async readDailyStats() {
+        const statsPath = path.join(this.stateDir, 'logs', 'daily-stats.json');
+        try {
+            const raw = await fs.promises.readFile(statsPath, 'utf8');
+            return JSON.parse(raw);
+        }
+        catch {
+            console.warn('[FeedbackConsoleModel] Failed to parse daily-stats.json at ' + statsPath);
+            return {};
+        }
+    }
+    getGateModel() {
+        if (!this.gateModel) {
+            this.gateModel = new GateConsoleModel(this.workspaceDir);
+        }
+        return this.gateModel;
+    }
+    getEventLogReadModel() {
+        if (!this.eventLogReadModel) {
+            this.eventLogReadModel = new EventLogReadModel(this.stateDir);
+        }
+        return this.eventLogReadModel;
+    }
+    dispose() {
+        if (this.gateModel) {
+            this.gateModel.dispose();
+            this.gateModel = null;
+        }
+        if (this.eventLogReadModel) {
+            this.eventLogReadModel.dispose();
+            this.eventLogReadModel = null;
+        }
+    }
+}

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

@@ -0,0 +1,50 @@
+import type { GateBlockItem } from '../types/index.js';
+export interface GateStatsOutput {
+    generatedAt: string;
+    today: {
+        gfiBlocks: number;
+        stageBlocks: number;
+        bypassAttempts: number;
+    };
+    trust: {
+        stage: number;
+        score: number;
+        status: 'healthy' | 'warning' | 'critical';
+    };
+    evolution: {
+        tier: string;
+        points: number;
+        status: string;
+    };
+    gfi: {
+        current: number;
+        peakToday: number;
+        threshold: number;
+        trend: {
+            hour: string;
+            value: number;
+        }[];
+        sources: Record<string, number>;
+        stage: 'stable' | 'elevated' | 'critical' | 'saturated';
+    };
+}
+export declare class GateConsoleModel {
+    private readonly workspaceDir;
+    private readonly stateDir;
+    private healthReadModel;
+    private painChainReadModel;
+    private pruningReadModel;
+    private stateManager;
+    private eventLogReadModel;
+    private ownsHealthReadModel;
+    constructor(workspaceDir: string);
+    getGateStats(): Promise<GateStatsOutput>;
+    getGateBlocks(_limit?: number): Promise<GateBlockItem[]>;
+    private static classifyGateType;
+    dispose(): void;
+    private getHealthReadModel;
+    private getPainChainReadModel;
+    private getPruningReadModel;
+    private getStateManager;
+    private getEventLogReadModel;
+}

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

@@ -0,0 +1,151 @@
+import * as path from 'path';
+import { OperatorHealthReadModel, PainChainReadModel, PruningReadModel, RuntimeStateManager, classifyGfiWorkspaceHealth, } from '@principles/core/runtime-v2';
+import { EventLogReadModel } from './EventLogReadModel.js';
+export class GateConsoleModel {
+    workspaceDir;
+    stateDir;
+    healthReadModel = null;
+    painChainReadModel = null;
+    pruningReadModel = null;
+    stateManager = null;
+    eventLogReadModel = null;
+    ownsHealthReadModel = false;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+        this.stateDir = path.join(workspaceDir, '.state');
+    }
+    async getGateStats() {
+        const snapshot = await this.getHealthReadModel().getSnapshot();
+        const gfiSnapshot = snapshot.gfi;
+        const { active } = gfiSnapshot;
+        const currentGfi = active?.currentGfi ?? 0;
+        const health = classifyGfiWorkspaceHealth(gfiSnapshot);
+        const trustStatus = health.status === 'degraded' ? 'warning' : 'healthy';
+        const sources = {};
+        if (active?.sources) {
+            for (const [key, value] of Object.entries(active.sources)) {
+                if (value !== undefined) {
+                    sources[key] = value;
+                }
+            }
+        }
+        const eventLog = this.getEventLogReadModel();
+        const [gfiBlocks, stageBlocks, bypassAttempts] = await Promise.all([
+            eventLog.countEventsByTypeToday('gate_block'),
+            eventLog.countEventsByTypeToday('stage_block'),
+            eventLog.countEventsByTypeToday('gate_bypass'),
+        ]);
+        return {
+            generatedAt: snapshot.generatedAt,
+            today: {
+                gfiBlocks,
+                stageBlocks,
+                bypassAttempts,
+            },
+            trust: {
+                stage: 0,
+                score: 0,
+                status: trustStatus,
+            },
+            evolution: {
+                tier: '',
+                points: 0,
+                status: '',
+            },
+            gfi: {
+                current: currentGfi,
+                peakToday: active?.dailyGfiPeak ?? 0,
+                threshold: active?.policy?.criticalThreshold ?? 80,
+                trend: [],
+                sources,
+                stage: active?.stage ?? 'stable',
+            },
+        };
+    }
+    async getGateBlocks(_limit) {
+        const events = await this.getEventLogReadModel().getGateBlocks(_limit ?? 100);
+        return events.map(event => ({
+            timestamp: event.ts,
+            toolName: event.data.toolName ?? 'unknown',
+            filePath: event.data.filePath ?? null,
+            reason: event.data.reason ?? '',
+            gateType: GateConsoleModel.classifyGateType(event.data.blockSource),
+            gfi: 0,
+            trustStage: 0,
+        }));
+    }
+    static classifyGateType(source) {
+        if (!source)
+            return 'other';
+        if (source.includes('gfi') || source.includes('GFI'))
+            return 'gfi';
+        if (source.includes('stage') || source.includes('trust'))
+            return 'stage';
+        if (source.includes('p03') || source.includes('P03'))
+            return 'p03';
+        return 'other';
+    }
+    dispose() {
+        if (this.healthReadModel && this.ownsHealthReadModel) {
+            this.healthReadModel.close().catch((err) => {
+                console.error('[GateConsoleModel] Failed to close health read model:', err);
+            });
+        }
+        if (this.painChainReadModel) {
+            this.painChainReadModel.close().catch((err) => {
+                console.error('[GateConsoleModel] Failed to close pain chain read model:', err);
+            });
+        }
+        if (this.stateManager) {
+            this.stateManager.close().catch((err) => {
+                console.error('[GateConsoleModel] Failed to close state manager:', err);
+            });
+        }
+        if (this.eventLogReadModel) {
+            this.eventLogReadModel.dispose();
+            this.eventLogReadModel = null;
+        }
+    }
+    getHealthReadModel() {
+        if (!this.healthReadModel) {
+            const painChainReadModel = this.getPainChainReadModel();
+            const pruningReadModel = this.getPruningReadModel();
+            this.healthReadModel = new OperatorHealthReadModel({
+                workspaceDir: this.workspaceDir,
+                painChainReadModel,
+                pruningReadModel,
+            });
+            this.ownsHealthReadModel = true;
+        }
+        return this.healthReadModel;
+    }
+    getPainChainReadModel() {
+        if (!this.painChainReadModel) {
+            this.painChainReadModel = new PainChainReadModel({
+                workspaceDir: this.workspaceDir,
+                stateManager: this.getStateManager(),
+            });
+        }
+        return this.painChainReadModel;
+    }
+    getPruningReadModel() {
+        if (!this.pruningReadModel) {
+            this.pruningReadModel = new PruningReadModel({
+                workspaceDir: this.workspaceDir,
+            });
+        }
+        return this.pruningReadModel;
+    }
+    getStateManager() {
+        if (!this.stateManager) {
+            this.stateManager = new RuntimeStateManager({ workspaceDir: this.workspaceDir });
+        }
+        return this.stateManager;
+    }
+    getEventLogReadModel() {
+        if (!this.eventLogReadModel) {
+            this.eventLogReadModel = new EventLogReadModel(this.stateDir);
+        }
+        return this.eventLogReadModel;
+    }
+}

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

@@ -0,0 +1,43 @@
+export interface HealthCheckResult {
+    id: string;
+    name: string;
+    status: 'healthy' | 'warning' | 'error';
+    message: string;
+    lastCheck: string;
+}
+export interface PipelineTimestamps {
+    lastPainSignal: string | null;
+    lastTaskCreated: string | null;
+    lastCandidateGenerated: string | null;
+    lastPrincipleAdded: string | null;
+}
+export interface SystemHealthStatus {
+    overall: 'healthy' | 'degraded' | 'error';
+    checks: HealthCheckResult[];
+    pipeline: PipelineTimestamps;
+    generatedAt: string;
+}
+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;
+    private getOperatorHealth;
+    dispose(): void;
+}