principles-disciple 1.5.4

package/dist/service/evolution-worker.js

@@ -0,0 +1,293 @@
+import * as fs from 'fs';
+import { createHash } from 'crypto';
+import { DictionaryService } from '../core/dictionary-service.js';
+import { DetectionService } from '../core/detection-service.js';
+import { ensureStateTemplates } from '../core/init.js';
+import { extractCommonSubstring } from '../utils/nlp.js';
+import { SystemLogger } from '../core/system-logger.js';
+import { WorkspaceContext } from '../core/workspace-context.js';
+import { initPersistence, flushAllSessions } from '../core/session-tracker.js';
+let intervalId = null;
+function checkPainFlag(wctx, logger) {
+    try {
+        const painFlagPath = wctx.resolve('PAIN_FLAG');
+        if (!fs.existsSync(painFlagPath))
+            return;
+        const rawPain = fs.readFileSync(painFlagPath, 'utf8');
+        const lines = rawPain.split('\n');
+        let score = 0;
+        let source = 'unknown';
+        let reason = 'Systemic pain detected';
+        let preview = '';
+        let isQueued = false;
+        for (const line of lines) {
+            if (line.startsWith('score:'))
+                score = parseInt(line.split(':', 2)[1].trim(), 10) || 0;
+            if (line.startsWith('source:'))
+                source = line.split(':', 2)[1].trim();
+            if (line.startsWith('reason:'))
+                reason = line.slice('reason:'.length).trim();
+            if (line.startsWith('trigger_text_preview:'))
+                preview = line.slice('trigger_text_preview:'.length).trim();
+            if (line.startsWith('status: queued'))
+                isQueued = true;
+        }
+        if (isQueued || score < 30)
+            return;
+        if (logger)
+            logger.info(`[PD:EvolutionWorker] Detected pain flag (score: ${score}, source: ${source}). Enqueueing evolution task.`);
+        const queuePath = wctx.resolve('EVOLUTION_QUEUE');
+        let queue = [];
+        if (fs.existsSync(queuePath)) {
+            try {
+                queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
+            }
+            catch (e) {
+                if (logger)
+                    logger.error(`[PD:EvolutionWorker] Failed to parse evolution queue: ${String(e)}`);
+            }
+        }
+        const taskId = createHash('md5').update(`${source}:${score}:${new Date().toISOString()}`).digest('hex').substring(0, 8);
+        queue.push({
+            id: taskId,
+            score,
+            source,
+            reason,
+            trigger_text_preview: preview,
+            timestamp: new Date().toISOString(),
+            status: 'pending'
+        });
+        fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
+        fs.appendFileSync(painFlagPath, '\nstatus: queued\n', 'utf8');
+    }
+    catch (err) {
+        if (logger)
+            logger.warn(`[PD:EvolutionWorker] Error processing pain flag: ${String(err)}`);
+    }
+}
+function processEvolutionQueue(wctx, logger, eventLog) {
+    try {
+        const queuePath = wctx.resolve('EVOLUTION_QUEUE');
+        if (!fs.existsSync(queuePath))
+            return;
+        const queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
+        let queueChanged = false;
+        const config = wctx.config;
+        const timeout = config.get('intervals.task_timeout_ms') || (30 * 60 * 1000);
+        for (const task of queue) {
+            if (task.status === 'in_progress' && task.timestamp) {
+                const age = Date.now() - new Date(task.timestamp).getTime();
+                if (age > timeout) {
+                    if (logger)
+                        logger.info(`[PD:EvolutionWorker] Resetting timed-out task: ${task.id}`);
+                    task.status = 'pending';
+                    queueChanged = true;
+                }
+            }
+        }
+        const pendingTasks = queue.filter(t => t.status === 'pending');
+        if (pendingTasks.length > 0) {
+            const directivePath = wctx.resolve('EVOLUTION_DIRECTIVE');
+            const highestScoreTask = pendingTasks.sort((a, b) => b.score - a.score)[0];
+            const directive = {
+                active: true,
+                task: `Diagnose systemic pain [ID: ${highestScoreTask.id}]. Source: ${highestScoreTask.source}. Reason: ${highestScoreTask.reason}. ` +
+                    `Trigger text: "${highestScoreTask.trigger_text_preview || 'N/A'}"`,
+                timestamp: new Date().toISOString()
+            };
+            fs.writeFileSync(directivePath, JSON.stringify(directive, null, 2), 'utf8');
+            highestScoreTask.status = 'in_progress';
+            queueChanged = true;
+            if (eventLog) {
+                eventLog.recordEvolutionTask({
+                    taskId: highestScoreTask.id,
+                    taskType: highestScoreTask.source,
+                    reason: highestScoreTask.reason
+                });
+            }
+        }
+        if (queueChanged) {
+            fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
+        }
+    }
+    catch (err) {
+        if (logger)
+            logger.warn(`[PD:EvolutionWorker] Error processing evolution queue: ${String(err)}`);
+    }
+}
+async function processDetectionQueue(wctx, api, eventLog) {
+    const logger = api.logger;
+    try {
+        const funnel = DetectionService.get(wctx.stateDir);
+        const queue = funnel.flushQueue();
+        if (queue.length === 0)
+            return;
+        if (logger)
+            logger.info(`[PD:EvolutionWorker] Processing ${queue.length} items from detection funnel.`);
+        const dictionary = DictionaryService.get(wctx.stateDir);
+        for (const text of queue) {
+            const match = dictionary.match(text);
+            if (match) {
+                if (eventLog) {
+                    eventLog.recordRuleMatch(undefined, {
+                        ruleId: match.ruleId,
+                        layer: 'L2',
+                        severity: match.severity,
+                        textPreview: text.substring(0, 100)
+                    });
+                }
+            }
+            else {
+                try {
+                    const searchTool = api.runtime.tools?.createMemorySearchTool?.({ config: api.config });
+                    if (searchTool) {
+                        const searchResult = await searchTool.execute('pre-emptive-pain-check', {
+                            query: text,
+                            limit: 1,
+                            threshold: 0.85
+                        });
+                        if (searchResult && searchResult.results?.length > 0) {
+                            const hit = searchResult.results[0];
+                            if (logger)
+                                logger.info?.(`[PD:EvolutionWorker] L3 Semantic Hit: ${hit.id} (Score: ${hit.score})`);
+                            funnel.updateCache(text, { detected: true, severity: 40 });
+                            if (eventLog) {
+                                eventLog.recordRuleMatch(undefined, {
+                                    ruleId: 'SEMANTIC_HIT',
+                                    layer: 'L3',
+                                    severity: 40,
+                                    textPreview: text.substring(0, 100)
+                                });
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    if (logger)
+                        logger.debug?.(`[PD:EvolutionWorker] L3 Semantic search failed: ${String(e)}`);
+                }
+                trackPainCandidate(text, wctx);
+            }
+        }
+    }
+    catch (err) {
+        if (logger)
+            logger.warn(`[PD:EvolutionWorker] Detection queue failed: ${String(err)}`);
+    }
+}
+function trackPainCandidate(text, wctx) {
+    const candidatePath = wctx.resolve('PAIN_CANDIDATES');
+    let data = { candidates: {} };
+    if (fs.existsSync(candidatePath)) {
+        try {
+            data = JSON.parse(fs.readFileSync(candidatePath, 'utf8'));
+        }
+        catch (e) {
+            // Keep going with empty data if parse fails, but log it
+            console.error(`[PD:EvolutionWorker] Failed to parse pain candidates: ${String(e)}`);
+        }
+    }
+    const fingerprint = createHash('md5').update(text.substring(0, 50)).digest('hex').substring(0, 8);
+    if (!data.candidates[fingerprint]) {
+        data.candidates[fingerprint] = { count: 0, firstSeen: new Date().toISOString(), samples: [] };
+    }
+    const cand = data.candidates[fingerprint];
+    cand.count++;
+    if (cand.samples.length < 5)
+        cand.samples.push(text.substring(0, 200));
+    fs.writeFileSync(candidatePath, JSON.stringify(data, null, 2), 'utf8');
+}
+function processPromotion(wctx, logger, eventLog) {
+    const candidatePath = wctx.resolve('PAIN_CANDIDATES');
+    if (!fs.existsSync(candidatePath))
+        return;
+    try {
+        const config = wctx.config;
+        const dictionary = wctx.dictionary;
+        const data = JSON.parse(fs.readFileSync(candidatePath, 'utf8'));
+        const countThreshold = config.get('thresholds.promotion_count_threshold') || 3;
+        let promotedCount = 0;
+        for (const [fingerprint, cand] of Object.entries(data.candidates)) {
+            if (cand.status === 'pending' && cand.count >= countThreshold) {
+                const commonPhrases = extractCommonSubstring(cand.samples);
+                if (commonPhrases.length > 0) {
+                    const phrase = commonPhrases[0];
+                    const ruleId = `P_PROMOTED_${fingerprint.toUpperCase()}`;
+                    if (logger)
+                        logger.info(`[PD:EvolutionWorker] Promoting candidate ${fingerprint} to formal rule: ${ruleId}`);
+                    SystemLogger.log(wctx.workspaceDir, 'RULE_PROMOTED', `Candidate ${fingerprint} promoted to rule ${ruleId}`);
+                    dictionary.addRule(ruleId, {
+                        type: 'exact_match',
+                        phrases: [phrase],
+                        severity: config.get('scores.default_confusion') || 35,
+                        status: 'active'
+                    });
+                    cand.status = 'promoted';
+                    promotedCount++;
+                }
+            }
+        }
+        if (promotedCount > 0) {
+            fs.writeFileSync(candidatePath, JSON.stringify(data, null, 2), 'utf8');
+        }
+    }
+    catch (err) {
+        if (logger)
+            logger.warn(`[PD:EvolutionWorker] Error during rule promotion: ${String(err)}`);
+    }
+}
+export const EvolutionWorkerService = {
+    id: 'principles-evolution-worker',
+    api: null,
+    start(ctx) {
+        const logger = ctx?.logger || console;
+        const api = this.api;
+        const workspaceDir = ctx?.workspaceDir;
+        if (!workspaceDir) {
+            if (logger)
+                logger.warn('[PD:EvolutionWorker] workspaceDir not found in service config. Evolution cycle disabled.');
+            return;
+        }
+        const wctx = WorkspaceContext.fromHookContext({ workspaceDir, ...ctx.config });
+        if (logger)
+            logger.info(`[PD:EvolutionWorker] Starting with workspaceDir=${wctx.workspaceDir}, stateDir=${wctx.stateDir}`);
+        initPersistence(wctx.stateDir);
+        const eventLog = wctx.eventLog;
+        const config = wctx.config;
+        const language = config.get('language') || 'en';
+        ensureStateTemplates({ logger }, wctx.stateDir, language);
+        const initialDelay = 5000;
+        const interval = config.get('intervals.worker_poll_ms') || (15 * 60 * 1000);
+        intervalId = setInterval(() => {
+            checkPainFlag(wctx, logger);
+            processEvolutionQueue(wctx, logger, eventLog);
+            if (api) {
+                processDetectionQueue(wctx, api, eventLog).catch(err => {
+                    if (logger)
+                        logger.error(`[PD:EvolutionWorker] Error in detection queue: ${String(err)}`);
+                });
+            }
+            processPromotion(wctx, logger, eventLog);
+            wctx.dictionary.flush();
+            flushAllSessions();
+        }, interval);
+        setTimeout(() => {
+            checkPainFlag(wctx, logger);
+            processEvolutionQueue(wctx, logger, eventLog);
+            if (api) {
+                processDetectionQueue(wctx, api, eventLog).catch(err => {
+                    if (logger)
+                        logger.error(`[PD:EvolutionWorker] Startup detection queue failed: ${String(err)}`);
+                });
+            }
+            processPromotion(wctx, logger, eventLog);
+        }, initialDelay);
+    },
+    stop(ctx) {
+        if (ctx?.logger)
+            ctx.logger.info('[PD:EvolutionWorker] Stopping background service...');
+        if (intervalId)
+            clearInterval(intervalId);
+        flushAllSessions();
+    }
+};

package/dist/tools/agent-spawn.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Agent Spawn Tool
+ *
+ * Provides a tool for spawning subagents with predefined agent definitions.
+ * Uses the low-level OpenClaw Subagent API.
+ */
+import type { OpenClawPluginApi } from '../openclaw-sdk.js';
+/**
+ * Agent Spawn Tool definition
+ */
+export declare const agentSpawnTool: {
+    name: string;
+    description: string;
+    parameters: import("@sinclair/typebox").TObject<{
+        agentType: import("@sinclair/typebox").TString;
+        task: import("@sinclair/typebox").TString;
+    }>;
+    /**
+     * Execution logic for the agent spawn tool
+     */
+    execute(params: {
+        agentType: string;
+        task: string;
+    }, api: OpenClawPluginApi, _workspaceDir?: string): Promise<string>;
+};
+/**
+ * Batch spawn multiple agents in sequence
+ * Useful for evolution workflow
+ */
+export declare function spawnAgentSequence(agents: Array<{
+    type: string;
+    task: string;
+}>, api: OpenClawPluginApi, onProgress?: (agent: string, result: string) => void): Promise<Map<string, string>>;

package/dist/tools/agent-spawn.js

@@ -0,0 +1,170 @@
+/**
+ * Agent Spawn Tool
+ *
+ * Provides a tool for spawning subagents with predefined agent definitions.
+ * Uses the low-level OpenClaw Subagent API.
+ */
+import { Type } from '@sinclair/typebox';
+import { randomUUID } from 'node:crypto';
+import { loadAgentDefinition, listAvailableAgents } from '../core/agent-loader.js';
+/**
+ * Extract assistant text from session messages
+ */
+function extractAssistantText(messages) {
+    if (!messages || typeof messages !== 'object')
+        return '';
+    const m = messages;
+    // Try assistantTexts helper first
+    if (m.assistantTexts && Array.isArray(m.assistantTexts)) {
+        return m.assistantTexts.join('\n');
+    }
+    // Fall back to parsing messages array
+    if (m.messages && Array.isArray(m.messages)) {
+        // Find the last assistant message
+        for (let i = m.messages.length - 1; i >= 0; i--) {
+            const msg = m.messages[i];
+            if (msg.role === 'assistant' && msg.content) {
+                if (typeof msg.content === 'string') {
+                    return msg.content;
+                }
+                if (Array.isArray(msg.content)) {
+                    const textParts = msg.content
+                        .filter((c) => c.type === 'text' && c.text)
+                        .map((c) => c.text);
+                    if (textParts.length > 0) {
+                        return textParts.join('\n');
+                    }
+                }
+            }
+        }
+    }
+    return '';
+}
+/**
+ * Build the full system prompt for a subagent
+ * Combines the agent definition with any context-specific additions
+ */
+function buildSubagentSystemPrompt(agentDef, _task) {
+    // The systemPrompt from the agent definition is the main content
+    // It will be appended to OpenClaw's minimal subagent prompt
+    return agentDef.systemPrompt;
+}
+/**
+ * Agent Spawn Tool definition
+ */
+export const agentSpawnTool = {
+    name: 'pd_spawn_agent',
+    description: `启动指定类型的子智能体执行任务。
+
+可用的智能体类型:
+- explorer: 快速收集证据（文件、日志、复现步骤）
+- diagnostician: 根因分析（verb/adjective + 5Whys）
+- auditor: 演绎审计（axiom/system/via-negativa）
+- planner: 制定电影剧本计划
+- implementer: 按计划执行代码修改
+- reviewer: 代码审查（正确性、安全性、可维护性）
+- reporter: 最终汇报（技术细节转管理报告）`,
+    parameters: Type.Object({
+        agentType: Type.String({
+            description: '智能体类型: explorer, diagnostician, auditor, planner, implementer, reviewer, reporter',
+        }),
+        task: Type.String({
+            description: '任务描述，详细说明子智能体需要完成的工作',
+        }),
+    }),
+    /**
+     * Execution logic for the agent spawn tool
+     */
+    async execute(params, api, _workspaceDir) {
+        const { agentType, task } = params;
+        // 1. Validate agent type
+        const availableAgents = listAvailableAgents();
+        if (!availableAgents.includes(agentType)) {
+            return `❌ 未找到智能体定义: "${agentType}"。
+
+可用的智能体: ${availableAgents.join(', ')}`;
+        }
+        // 2. Load agent definition
+        const agentDef = loadAgentDefinition(agentType);
+        if (!agentDef) {
+            return `❌ 无法加载智能体定义: ${agentType}`;
+        }
+        // 3. Check subagent runtime availability
+        const subagentRuntime = api.runtime?.subagent;
+        if (!subagentRuntime) {
+            return `❌ Subagent runtime 不可用。请确保 OpenClaw Gateway 正在运行。`;
+        }
+        // 4. Build session key
+        const sessionKey = `agent:${agentType}:${randomUUID()}`;
+        // 5. Build system prompt
+        const extraSystemPrompt = buildSubagentSystemPrompt(agentDef, task);
+        const startTime = Date.now();
+        try {
+            // 6. Run subagent
+            await subagentRuntime.run({
+                sessionKey,
+                message: task,
+                extraSystemPrompt,
+                lane: 'subagent',
+                deliver: false, // Critical: don't send directly to external channels
+                idempotencyKey: randomUUID(),
+            });
+            // 7. Wait for completion
+            const result = await subagentRuntime.waitForRun({
+                runId: sessionKey,
+            });
+            const duration = Date.now() - startTime;
+            // 8. Handle timeout
+            if (result.status === 'timeout') {
+                return `⚠️ 智能体 **${agentDef.name}** 执行超时 (${(duration / 1000).toFixed(1)}s)。
+
+建议：
+- 简化任务描述
+- 分解为多个子任务
+- 检查任务是否需要更多上下文`;
+            }
+            // 9. Handle error
+            if (result.status === 'error') {
+                return `❌ 智能体 **${agentDef.name}** 执行失败: ${result.error || '未知错误'}`;
+            }
+            // 10. Get results
+            const messages = await subagentRuntime.getSessionMessages({ sessionKey });
+            const output = extractAssistantText(messages);
+            if (!output || output.trim() === '') {
+                return `⚠️ 智能体 **${agentDef.name}** 执行完成，但没有返回输出。`;
+            }
+            // 11. Return formatted result
+            return `✅ **${agentDef.name}** 执行完成 (${(duration / 1000).toFixed(1)}s)
+
+---
+
+${output}`;
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            return `❌ 智能体 **${agentDef.name}** 执行异常: ${errorMsg}`;
+        }
+        finally {
+            // 12. Cleanup session
+            try {
+                await subagentRuntime.deleteSession({ sessionKey });
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    },
+};
+/**
+ * Batch spawn multiple agents in sequence
+ * Useful for evolution workflow
+ */
+export async function spawnAgentSequence(agents, api, onProgress) {
+    const results = new Map();
+    for (const { type, task } of agents) {
+        const result = await agentSpawnTool.execute({ agentType: type, task }, api);
+        results.set(type, result);
+        onProgress?.(type, result);
+    }
+    return results;
+}

package/dist/tools/critique-prompt.d.ts

@@ -0,0 +1,14 @@
+import type { OpenClawPluginApi } from '../openclaw-sdk.js';
+/**
+ * 构建反思提示词 (Critique Prompt) V2
+ *
+ * 严格按照测试用例的调用习惯和断言要求进行重写。
+ * 增加 OpenClaw 兼容性路径解析。
+ */
+export declare function buildCritiquePromptV2(params: {
+    context: string;
+    depth?: number;
+    model_id?: string;
+    workspaceDir?: string;
+    api?: OpenClawPluginApi;
+}): string;

package/dist/tools/critique-prompt.js

@@ -0,0 +1,81 @@
+import { loadModelIndex } from './model-index.js';
+/**
+ * 深度指令模板 (必须与测试用例中的 quick/balanced/thorough 关键字对齐)
+ */
+const DEPTH_INSTRUCTIONS = {
+    1: 'Provide a quick surface-level analysis.',
+    2: 'Provide a balanced analysis with moderate depth.',
+    3: 'Provide an extremely thorough and exhaustive analysis.',
+};
+/**
+ * 构建反思提示词 (Critique Prompt) V2
+ *
+ * 严格按照测试用例的调用习惯和断言要求进行重写。
+ * 增加 OpenClaw 兼容性路径解析。
+ */
+export function buildCritiquePromptV2(params) {
+    const { context, depth = 2, model_id, workspaceDir, api } = params;
+    // 1. 确定工作区目录 (优先级：显式传入 > api.config > api.workspaceDir > api.resolvePath)
+    const effectiveWorkspaceDir = workspaceDir
+        || api?.config?.workspaceDir
+        || api?.workspaceDir
+        || api?.resolvePath?.('.');
+    if (!effectiveWorkspaceDir) {
+        throw new Error('Workspace directory is required for deep reflection.');
+    }
+    // 2. 深度校验与警告日志
+    let validatedDepth = 2;
+    if (typeof depth === 'number') {
+        if (depth >= 1 && depth <= 3) {
+            validatedDepth = depth;
+        }
+        else {
+            if (api?.logger) {
+                api.logger.warn(`[DeepReflect] Invalid depth value ${depth}. Falling back to 2.`);
+            }
+        }
+    }
+    const depthMsg = DEPTH_INSTRUCTIONS[validatedDepth];
+    // 3. 加载模型索引
+    const modelIndexMessage = loadModelIndex(effectiveWorkspaceDir, api);
+    // 4. 构造最终提示词
+    return `
+# Role: Principal Critical Thinker & Strategist
+---
+[SYSTEM_ID: Critical Analysis Engine]
+
+## Objective
+Provide a high-intensity critical analysis and actionable feedback for the provided task context.
+
+## Depth Requirement
+${depthMsg}
+
+## Meta-Cognitive Models
+The agent has inherited meta-cognitive models (T-01 to T-09) from the **thinking_os** framework. Use these as your foundational logic.
+
+## Model Selection Guidelines
+Step 1: Determine if the task context is a **general planning** task or **domain-specific**.
+Step 2: Select 1-2 relevant models.
+Step 3: If no match is found, use **Fallback** to **Meta-Cognitive Models**.
+
+## Domain-Specific Models Index
+${modelIndexMessage}
+
+## Task Context to Analyze
+---
+${context}
+---
+
+## Instructions
+1. Apply the selected models rigorously.
+2. Identify blind spots and logic gaps.
+3. Provide high-impact recommendations.
+
+## Output Structure
+- **Blind Spots**: ...
+- **Risk Warnings**: ...
+- **Alternative Approaches**: ...
+- **Recommendations**: ...
+- **Confidence Level**: [LOW/MEDIUM/HIGH]
+`.trim();
+}

package/dist/tools/deep-reflect.d.ts

@@ -0,0 +1,19 @@
+import type { OpenClawPluginApi } from '../openclaw-sdk.js';
+export declare const deepReflectTool: {
+    name: string;
+    description: string;
+    parameters: import("@sinclair/typebox").TObject<{
+        context: import("@sinclair/typebox").TString;
+        depth: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        model_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>;
+    /**
+     * Tool execution logic
+     * @param workspaceDir Optional parameter for unit testing
+     */
+    execute(params: {
+        context: string;
+        depth?: number;
+        model_id?: string;
+    }, api: OpenClawPluginApi, workspaceDir?: string): Promise<string>;
+};