create-principles-disciple 1.0.0 → 1.73.0

package/console/dist/server/routes/agents.js

@@ -0,0 +1,557 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import Database from 'better-sqlite3';
+import { RuntimeStateManager } from '@principles/core/runtime-v2';
+import { sendSuccess, sendError, sendNotFound, sendBadRequest } from '../utils/response.js';
+const AGENT_REGISTRY = [
+    {
+        id: 'evolution-worker',
+        name: 'Evolution Worker',
+        nameZh: '进化工作者',
+        description: '总调度引擎，驱动整个进化管道的心跳服务',
+        descriptionZh: '总调度引擎，驱动整个进化管道的心跳服务',
+        icon: 'Cpu',
+        category: 'scheduler',
+        taskKind: null,
+        prompt: 'N/A - Heartbeat-driven scheduler, no LLM prompt',
+        tools: ['processCompilationBackfill', 'processEvolutionQueue', 'processDetectionQueue', 'sweepExpiredWorkflows', 'runWorkflowWatchdog'],
+        subAgents: ['nocturnal-reflection', 'correction-observer'],
+    },
+    {
+        id: 'diagnostician',
+        name: 'Diagnostician',
+        nameZh: '诊断者',
+        description: 'Uses 5-Whys method for root cause analysis, extracting principles from pain signals',
+        descriptionZh: '使用 5-Whys 方法进行根因分析，从痛苦信号中提取原则',
+        icon: 'Stethoscope',
+        category: 'analyzer',
+        taskKind: 'diagnostician',
+        prompt: '## Diagnostic Protocol (5 Whys)\nPhase 1 - Evidence Gathering\nPhase 2 - Causal Chain (5 Whys)\nPhase 3 - Root Cause Classification\nPhase 4 - Principle Extraction',
+        tools: ['PainSignalBridge', 'DiagnosticianRunner', 'SqliteContextAssembler'],
+        subAgents: [],
+    },
+    {
+        id: 'nocturnal-reflection',
+        name: 'Nocturnal Reflection',
+        nameZh: '夜间反思',
+        description: 'Deep reflection pipeline that runs Trinity (Dreamer→Philosopher→Scribe) to generate high-quality decision alternatives',
+        descriptionZh: '深度反思管线，运行 Trinity（梦想家→哲学家→书记员）生成高质量决策替代方案',
+        icon: 'Moon',
+        category: 'reflector',
+        taskKind: 'sleep_reflection',
+        prompt: 'Nocturnal Dreamer — Candidate Generation\nNocturnal Philosopher — 6D Scoring & Risk Ranking\nNocturnal Scribe — Tournament Selection & Comparative Analysis',
+        tools: ['NocturnalTargetSelector', 'NocturnalTrajectoryExtractor', 'TrinityRunner', 'NocturnalArbiter', 'NocturnalExecutability', 'NocturnalArtificer'],
+        subAgents: ['trinity-dreamer', 'trinity-philosopher', 'trinity-scribe'],
+    },
+    {
+        id: 'trinity-dreamer',
+        name: 'Trinity Dreamer',
+        nameZh: 'Trinity 梦想家',
+        description: 'Generates 2-3 candidate correction alternatives from session trajectory analysis',
+        descriptionZh: '从会话轨迹分析中生成 2-3 个候选纠正方案',
+        icon: 'Sparkles',
+        category: 'sub-process',
+        taskKind: null,
+        prompt: 'You are a principles analyst specializing in identifying decision alternatives.\nYour task is to analyze a session trajectory and generate 2-3 candidate corrections.\nOutput: {"valid": true, "candidates": [...]}',
+        tools: ['runEmbeddedPiAgent'],
+        subAgents: [],
+    },
+    {
+        id: 'trinity-philosopher',
+        name: 'Trinity Philosopher',
+        nameZh: 'Trinity 哲学家',
+        description: 'Evaluates and ranks candidates using 6-dimensional scoring and risk assessment',
+        descriptionZh: '使用 6 维评分和风险评估对候选方案进行评估和排名',
+        icon: 'Scale',
+        category: 'sub-process',
+        taskKind: null,
+        prompt: 'You are a principles philosopher.\nEvaluate candidates against existing principles.\nScore each on 6 dimensions: correctness, specificity, actionability, non-redundancy, safety, generalizability.',
+        tools: ['runEmbeddedPiAgent'],
+        subAgents: [],
+    },
+    {
+        id: 'trinity-scribe',
+        name: 'Trinity Scribe',
+        nameZh: 'Trinity 书记员',
+        description: 'Performs tournament selection and produces the final structured artifact draft',
+        descriptionZh: '执行锦标赛选择，产出最终结构化 artifact 草稿',
+        icon: 'PenTool',
+        category: 'sub-process',
+        taskKind: null,
+        prompt: 'You are a principles scribe.\nPerform tournament selection among ranked candidates.\nProduce a final structured artifact with comparative analysis.',
+        tools: ['runEmbeddedPiAgent'],
+        subAgents: [],
+    },
+    {
+        id: 'correction-observer',
+        name: 'Correction Observer',
+        nameZh: '纠正观察者',
+        description: 'Optimizes the correction keyword store by analyzing hit rates and false positive rates',
+        descriptionZh: '通过分析命中率和误报率来优化纠正关键词库',
+        icon: 'SearchCheck',
+        category: 'optimizer',
+        taskKind: 'keyword_optimization',
+        prompt: 'You are a correction keyword optimizer.\nAnalyze the current correction keyword store and recent user messages.\nRecommend ADD/UPDATE/REMOVE actions to improve correction cue accuracy.\nOutput: {"updated": boolean, "updates": {...}, "fpTerms": [...], "summary": string}',
+        tools: ['KeywordOptimizationService', 'CorrectionCueLearner'],
+        subAgents: [],
+    },
+    {
+        id: 'pain-diagnostic-gate',
+        name: 'Pain Diagnostic Gate',
+        nameZh: '痛苦诊断门控',
+        description: 'Gatekeeper that decides which pain signals warrant diagnostic analysis based on source, score, and GFI',
+        descriptionZh: '守门人，基于来源、分数和 GFI 决定哪些痛苦信号值得诊断分析',
+        icon: 'ShieldCheck',
+        category: 'gate',
+        taskKind: null,
+        prompt: 'N/A - Rule-based gate, no LLM prompt. Evaluates: source type, score thresholds (40-70 depending on source), GFI, consecutive errors, cooldown.',
+        tools: ['evaluatePainDiagnosticGate'],
+        subAgents: [],
+    },
+];
+const WORKER_STALE_THRESHOLD_MS = 30 * 60 * 1000;
+function mapTaskStatusToAgentStatus(taskStatus) {
+    switch (taskStatus) {
+        case 'pending':
+        case 'leased':
+            return 'running';
+        case 'succeeded':
+            return 'idle';
+        case 'failed':
+            return 'failed';
+        case 'retry_wait':
+            return 'cooldown';
+        default:
+            return 'unknown';
+    }
+}
+function mapTaskStatusToLastStatus(taskStatus) {
+    switch (taskStatus) {
+        case 'succeeded':
+            return 'succeeded';
+        case 'failed':
+            return 'failed';
+        case 'pending':
+            return 'pending';
+        case 'leased':
+            return 'leased';
+        default:
+            return null;
+    }
+}
+function formatCooldownRemaining(leaseExpiresAt) {
+    if (!leaseExpiresAt)
+        return null;
+    const remaining = new Date(leaseExpiresAt).getTime() - Date.now();
+    if (remaining <= 0)
+        return null;
+    const totalSeconds = Math.floor(remaining / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [];
+    if (hours > 0)
+        parts.push(`${hours}h`);
+    if (minutes > 0)
+        parts.push(`${minutes}m`);
+    if (seconds > 0 || parts.length === 0)
+        parts.push(`${seconds}s`);
+    return parts.join(' ');
+}
+const models = new Map();
+class AgentConsoleModel {
+    workspaceDir;
+    stateManager = null;
+    initPromise = null;
+    stageEventsCache = new Map();
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+    }
+    async ensureInitialized() {
+        if (this.stateManager)
+            return this.stateManager;
+        if (this.initPromise) {
+            try {
+                await this.initPromise;
+                if (this.stateManager)
+                    return this.stateManager;
+                throw new Error('initPromise resolved but stateManager is null');
+            }
+            catch {
+                this.initPromise = null;
+            }
+        }
+        const manager = new RuntimeStateManager({ workspaceDir: this.workspaceDir });
+        this.initPromise = manager.initialize();
+        try {
+            await this.initPromise;
+            this.stateManager = manager;
+            return manager;
+        }
+        catch {
+            this.stateManager = null;
+            this.initPromise = null;
+            throw new Error('Failed to initialize RuntimeStateManager');
+        }
+    }
+    readWorkerStatus() {
+        const statusPath = path.join(this.workspaceDir, '.state', 'worker-status.json');
+        if (!fs.existsSync(statusPath))
+            return null;
+        try {
+            const raw = fs.readFileSync(statusPath, 'utf8');
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    readWorkflowData() {
+        const dbPath = path.join(this.workspaceDir, '.state', 'subagent_workflows.db');
+        if (!fs.existsSync(dbPath))
+            return [];
+        let db = null;
+        try {
+            db = new Database(dbPath, { readonly: true });
+            const rows = db.prepare(`
+        SELECT workflow_id, workflow_type, state, created_at, updated_at, duration_ms
+        FROM subagent_workflows
+        ORDER BY updated_at DESC
+        LIMIT 50
+      `).all();
+            return rows;
+        }
+        catch {
+            return [];
+        }
+        finally {
+            db?.close();
+        }
+    }
+    getEvolutionWorkerStatus() {
+        const report = this.readWorkerStatus();
+        if (!report)
+            return { status: 'unknown', lastRunAt: null };
+        const lastRun = new Date(report.timestamp).getTime();
+        const isFresh = Date.now() - lastRun < WORKER_STALE_THRESHOLD_MS;
+        return {
+            status: isFresh ? 'running' : 'idle',
+            lastRunAt: report.timestamp,
+        };
+    }
+    getStageEvents(workflowId) {
+        const cached = this.stageEventsCache.get(workflowId);
+        if (cached)
+            return cached;
+        return {};
+    }
+    refreshStageEvents() {
+        const dbPath = path.join(this.workspaceDir, '.state', 'subagent_workflows.db');
+        if (!fs.existsSync(dbPath))
+            return;
+        let db = null;
+        try {
+            db = new Database(dbPath, { readonly: true });
+            const events = db.prepare(`
+        SELECT workflow_id, event_type, payload_json
+        FROM subagent_workflow_events
+        WHERE event_type LIKE 'trinity_%'
+        ORDER BY created_at DESC
+      `).all();
+            const grouped = new Map();
+            for (const ev of events) {
+                const states = grouped.get(ev.workflow_id) || {};
+                const stage = ev.event_type.replace('trinity_', '').replace('_start', '').replace('_complete', '').replace('_failed', '');
+                if (!states[stage]) {
+                    if (ev.event_type.endsWith('_failed'))
+                        states[stage] = 'failed';
+                    else if (ev.event_type.endsWith('_complete'))
+                        states[stage] = 'completed';
+                    else if (ev.event_type.endsWith('_start'))
+                        states[stage] = 'started';
+                }
+                grouped.set(ev.workflow_id, states);
+            }
+            this.stageEventsCache = grouped;
+        }
+        catch {
+            this.stageEventsCache.clear();
+        }
+        finally {
+            db?.close();
+        }
+    }
+    getTrinitySubAgentStatus(agentId, workflows) {
+        const stageMap = {
+            'trinity-dreamer': 'dreamer',
+            'trinity-philosopher': 'philosopher',
+            'trinity-scribe': 'scribe',
+        };
+        const stage = stageMap[agentId];
+        if (!stage)
+            return { status: 'unknown', lastRunAt: null };
+        const stageOrder = ['dreamer', 'philosopher', 'scribe'];
+        const stageIndex = stageOrder.indexOf(stage);
+        for (const wf of workflows) {
+            if (wf.workflow_type !== 'nocturnal')
+                continue;
+            const eventStates = this.getStageEvents(wf.workflow_id);
+            const stageEvent = eventStates[stage];
+            if (stageEvent === 'failed') {
+                return { status: 'failed', lastRunAt: new Date(wf.updated_at).toISOString() };
+            }
+            if (stageEvent === 'completed') {
+                return { status: 'idle', lastRunAt: new Date(wf.updated_at).toISOString() };
+            }
+            for (let i = stageOrder.length - 1; i >= 0; i--) {
+                const s = stageOrder[i];
+                if (eventStates[s] === 'completed') {
+                    if (i === stageIndex)
+                        return { status: 'idle', lastRunAt: new Date(wf.updated_at).toISOString() };
+                    if (i > stageIndex)
+                        return { status: 'running', lastRunAt: new Date(wf.updated_at).toISOString() };
+                    return { status: 'idle', lastRunAt: new Date(wf.updated_at).toISOString() };
+                }
+                if (eventStates[s] === 'running' || eventStates[s] === 'started') {
+                    if (i === stageIndex)
+                        return { status: 'running', lastRunAt: new Date(wf.updated_at).toISOString() };
+                    if (i < stageIndex)
+                        return { status: 'idle', lastRunAt: new Date(wf.updated_at).toISOString() };
+                    return { status: 'running', lastRunAt: new Date(wf.updated_at).toISOString() };
+                }
+            }
+            if (wf.state === 'active' || wf.state === 'pending') {
+                if (stageIndex === 0)
+                    return { status: 'running', lastRunAt: new Date(wf.updated_at).toISOString() };
+                return { status: 'idle', lastRunAt: new Date(wf.updated_at).toISOString() };
+            }
+            if (wf.state === 'completed') {
+                return { status: 'idle', lastRunAt: new Date(wf.updated_at).toISOString() };
+            }
+            if (wf.state === 'terminal_error') {
+                if (eventStates.dreamer === 'failed') {
+                    return { status: stageIndex === 0 ? 'failed' : 'idle', lastRunAt: new Date(wf.updated_at).toISOString() };
+                }
+                if (eventStates.philosopher === 'failed') {
+                    return { status: stageIndex <= 1 ? (stageIndex === 1 ? 'failed' : 'idle') : 'idle', lastRunAt: new Date(wf.updated_at).toISOString() };
+                }
+                return { status: 'failed', lastRunAt: new Date(wf.updated_at).toISOString() };
+            }
+        }
+        return { status: 'unknown', lastRunAt: null };
+    }
+    async buildAgentInfo(agent, allTasks, workflows) {
+        let status = 'unknown';
+        let lastRunAt = null;
+        let lastStatus = null;
+        let recentTaskCount = 0;
+        let failedTaskCount = 0;
+        let cooldownRemaining = null;
+        if (agent.id === 'evolution-worker') {
+            const workerStatus = this.getEvolutionWorkerStatus();
+            ({ status, lastRunAt } = workerStatus);
+            const queueTasks = allTasks.filter(t => t.taskKind === 'diagnostician' || t.taskKind === 'sleep_reflection' || t.taskKind === 'keyword_optimization');
+            recentTaskCount = queueTasks.length;
+            failedTaskCount = queueTasks.filter(t => t.status === 'failed').length;
+            if (queueTasks.length > 0) {
+                const latest = queueTasks.reduce((a, b) => (a.updatedAt > b.updatedAt ? a : b));
+                lastStatus = mapTaskStatusToLastStatus(latest.status);
+            }
+        }
+        else if (agent.taskKind) {
+            const agentTasks = allTasks.filter(t => t.taskKind === agent.taskKind);
+            recentTaskCount = agentTasks.length;
+            failedTaskCount = agentTasks.filter(t => t.status === 'failed').length;
+            if (agentTasks.length > 0) {
+                const sorted = [...agentTasks].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+                const [latest] = sorted;
+                status = mapTaskStatusToAgentStatus(latest.status);
+                lastRunAt = latest.updatedAt;
+                lastStatus = mapTaskStatusToLastStatus(latest.status);
+                if (latest.status === 'retry_wait') {
+                    cooldownRemaining = formatCooldownRemaining(latest.leaseExpiresAt);
+                }
+            }
+            else {
+                status = 'idle';
+            }
+        }
+        else if (agent.id === 'trinity-dreamer' || agent.id === 'trinity-philosopher' || agent.id === 'trinity-scribe') {
+            const subStatus = this.getTrinitySubAgentStatus(agent.id, workflows);
+            ({ status, lastRunAt } = subStatus);
+        }
+        else if (agent.id === 'pain-diagnostic-gate') {
+            status = 'idle';
+        }
+        return {
+            id: agent.id,
+            name: agent.name,
+            nameZh: agent.nameZh,
+            description: agent.description,
+            descriptionZh: agent.descriptionZh,
+            icon: agent.icon,
+            category: agent.category,
+            status,
+            lastRunAt,
+            lastStatus,
+            recentTaskCount,
+            failedTaskCount,
+            subAgents: agent.subAgents,
+            prompt: agent.prompt,
+            tools: agent.tools,
+            taskKind: agent.taskKind,
+            cooldownRemaining,
+        };
+    }
+    async listAgents() {
+        const mgr = await this.ensureInitialized();
+        const allTasks = await mgr.listTasks();
+        const workflows = this.readWorkflowData();
+        this.refreshStageEvents();
+        const results = [];
+        for (const agent of AGENT_REGISTRY) {
+            results.push(await this.buildAgentInfo(agent, allTasks, workflows));
+        }
+        return results;
+    }
+    async getAgentDetail(agentId) {
+        const agent = AGENT_REGISTRY.find(a => a.id === agentId);
+        if (!agent)
+            return null;
+        const mgr = await this.ensureInitialized();
+        const allTasks = await mgr.listTasks();
+        const workflows = this.readWorkflowData();
+        this.refreshStageEvents();
+        const info = await this.buildAgentInfo(agent, allTasks, workflows);
+        let agentTasks = agent.taskKind
+            ? allTasks.filter(t => t.taskKind === agent.taskKind)
+            : [];
+        agentTasks = [...agentTasks].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+        const recentTasks = agentTasks.slice(0, 20).map(t => ({
+            taskId: t.taskId,
+            status: t.status,
+            createdAt: t.createdAt,
+            updatedAt: t.updatedAt,
+            lastError: t.lastError ?? null,
+            attemptCount: t.attemptCount,
+        }));
+        return { ...info, recentTasks };
+    }
+    async getAgentTasks(agentId) {
+        const agent = AGENT_REGISTRY.find(a => a.id === agentId);
+        if (!agent)
+            return null;
+        if (!agent.taskKind)
+            return { tasks: [] };
+        const mgr = await this.ensureInitialized();
+        const agentTasks = await mgr.listTasks({ taskKind: agent.taskKind });
+        const sorted = [...agentTasks].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+        return {
+            tasks: sorted.map(t => ({
+                taskId: t.taskId,
+                taskKind: t.taskKind,
+                status: t.status,
+                createdAt: t.createdAt,
+                updatedAt: t.updatedAt,
+                lastError: t.lastError ?? null,
+                attemptCount: t.attemptCount,
+                inputRef: t.inputRef ?? null,
+                resultRef: t.resultRef ?? null,
+            })),
+        };
+    }
+    dispose() {
+        if (this.stateManager) {
+            this.stateManager.close().catch((_e) => { });
+            this.stateManager = null;
+        }
+        this.initPromise = null;
+    }
+}
+function getModel(workspaceDir) {
+    let model = models.get(workspaceDir);
+    if (!model) {
+        model = new AgentConsoleModel(workspaceDir);
+        models.set(workspaceDir, model);
+    }
+    return model;
+}
+/* eslint-disable @typescript-eslint/max-params */
+export async function handleAgentsRoute(req, res, workspaceDir, subPath) {
+    if (req.method !== 'GET') {
+        sendNotFound(res, `Route /api/agents${subPath} not found`);
+        return;
+    }
+    const model = getModel(workspaceDir);
+    if (subPath === '' || subPath === '/') {
+        try {
+            const result = await model.listAgents();
+            sendSuccess(res, result);
+        }
+        catch (err) {
+            sendError(res, 500, 'agents_list_error', err.message);
+        }
+        return;
+    }
+    const tasksMatch = /^\/([^/]+)\/tasks\/?$/.exec(subPath);
+    if (tasksMatch) {
+        const agentId = (() => {
+            try {
+                return decodeURIComponent(tasksMatch[1]);
+            }
+            catch {
+                return null;
+            }
+        })();
+        if (!agentId) {
+            sendBadRequest(res, 'Invalid agent ID encoding');
+            return;
+        }
+        try {
+            const result = await model.getAgentTasks(agentId);
+            if (!result) {
+                sendNotFound(res, `Agent '${agentId}' not found`);
+                return;
+            }
+            sendSuccess(res, result);
+        }
+        catch (err) {
+            sendError(res, 500, 'agent_tasks_error', err.message);
+        }
+        return;
+    }
+    const detailMatch = /^\/([^/]+)\/?$/.exec(subPath);
+    if (detailMatch) {
+        const agentId = (() => {
+            try {
+                return decodeURIComponent(detailMatch[1]);
+            }
+            catch {
+                return null;
+            }
+        })();
+        if (!agentId) {
+            sendBadRequest(res, 'Invalid agent ID encoding');
+            return;
+        }
+        try {
+            const result = await model.getAgentDetail(agentId);
+            if (!result) {
+                sendNotFound(res, `Agent '${agentId}' not found`);
+                return;
+            }
+            sendSuccess(res, result);
+        }
+        catch (err) {
+            sendError(res, 500, 'agent_detail_error', err.message);
+        }
+        return;
+    }
+    sendNotFound(res, `Route /api/agents${subPath} not found`);
+}
+export function disposeAgentModels() {
+    for (const model of models.values()) {
+        model.dispose();
+    }
+    models.clear();
+}

package/console/dist/server/routes/approvals.d.ts

@@ -0,0 +1,3 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export declare function handleApprovalsRoute(req: IncomingMessage, res: ServerResponse, workspaceDir: string, subPath: string): Promise<void>;
+export declare function disposeApprovalsModels(): void;