principles-disciple 1.7.3 → 1.7.5

package/dist/core/evolution-logger.js

@@ -0,0 +1,256 @@
+/**
+ * EvolutionLogger - 进化流程日志服务
+ *
+ * 提供两层日志：
+ * - 技术层：结构化 JSON，包含 trace_id、stage、metadata
+ * - 用户层：中文摘要，便于小白用户理解
+ *
+ * 日志写入两个地方：
+ * 1. SYSTEM_LOG (system.jsonl) - 技术细节
+ * 2. evolution_events 表 (SQLite) - 结构化查询
+ */
+import { randomBytes } from 'crypto';
+import { SystemLogger } from './system-logger.js';
+// 阶段对应的中文标签
+export const STAGE_LABELS = {
+    pain_detected: '痛点检测',
+    queued: '加入队列',
+    started: '开始处理',
+    analyzing: '分析中',
+    principle_generated: '原则生成',
+    completed: '完成',
+    failed: '失败',
+};
+// 阶段对应的颜色（用于 UI）
+export const STAGE_COLORS = {
+    pain_detected: '#ef4444', // 红色
+    queued: '#f59e0b', // 橙色
+    started: '#3b82f6', // 蓝色
+    analyzing: '#8b5cf6', // 紫色
+    principle_generated: '#10b981', // 绿色
+    completed: '#22c55e', // 绿色
+    failed: '#dc2626', // 深红色
+};
+/**
+ * 创建新的 trace_id
+ * 格式: ev_{timestamp}_{random}
+ * 使用 crypto.randomBytes 确保不可预测性
+ */
+export function createTraceId() {
+    const timestamp = Date.now().toString(36);
+    const random = randomBytes(3).toString('hex');
+    return `ev_${timestamp}_${random}`;
+}
+/**
+ * EvolutionLogger 类
+ * 管理进化流程的日志记录
+ */
+export class EvolutionLogger {
+    workspaceDir;
+    trajectory;
+    constructor(workspaceDir, trajectory) {
+        this.workspaceDir = workspaceDir;
+        this.trajectory = trajectory || null;
+    }
+    /**
+     * 记录进化事件
+     * 同时写入 SYSTEM_LOG 和 evolution_events 表
+     */
+    log(input) {
+        const entry = {
+            ...input,
+            level: input.level || 'info',
+            timestamp: new Date().toISOString(),
+        };
+        // 1. 写入 SYSTEM_LOG (技术细节)
+        SystemLogger.log(this.workspaceDir, 'EVOLUTION', JSON.stringify({
+            traceId: entry.traceId,
+            stage: entry.stage,
+            level: entry.level,
+            message: entry.message,
+            taskId: entry.taskId,
+            sessionId: entry.sessionId,
+            metadata: entry.metadata,
+        }));
+        // 2. 写入 evolution_events 表 (如果有 trajectory)
+        if (this.trajectory) {
+            try {
+                this.trajectory.recordEvolutionEvent({
+                    traceId: entry.traceId,
+                    taskId: entry.taskId,
+                    stage: entry.stage,
+                    level: entry.level,
+                    message: entry.message,
+                    summary: entry.summary,
+                    metadata: entry.metadata,
+                    createdAt: entry.timestamp,
+                });
+            }
+            catch (err) {
+                // 数据库写入失败不影响主流程
+                console.error(`[EvolutionLogger] Failed to write to trajectory: ${String(err)}`);
+            }
+        }
+    }
+    /**
+     * 记录 pain_detected 事件
+     */
+    logPainDetected(params) {
+        this.log({
+            traceId: params.traceId,
+            stage: 'pain_detected',
+            level: 'info',
+            message: `Pain detected: ${params.source} - ${params.reason}`,
+            summary: `检测到痛点：${params.source} - ${params.reason}`,
+            metadata: {
+                score: params.score,
+                toolName: params.toolName,
+                filePath: params.filePath,
+            },
+            sessionId: params.sessionId,
+        });
+    }
+    /**
+     * 记录 queued 事件
+     */
+    logQueued(params) {
+        this.log({
+            traceId: params.traceId,
+            taskId: params.taskId,
+            stage: 'queued',
+            level: 'info',
+            message: `Task ${params.taskId} enqueued with score ${params.score}`,
+            summary: `任务 ${params.taskId} 已加入进化队列，优先级分数 ${params.score}`,
+            metadata: {
+                score: params.score,
+                source: params.source,
+                reason: params.reason,
+            },
+        });
+    }
+    /**
+     * 记录 started 事件
+     */
+    logStarted(params) {
+        this.log({
+            traceId: params.traceId,
+            taskId: params.taskId,
+            stage: 'started',
+            level: 'info',
+            message: `Task ${params.taskId} started processing`,
+            summary: `任务 ${params.taskId} 开始处理，Diagnostician 正在分析...`,
+        });
+    }
+    /**
+     * 记录 analyzing 事件
+     */
+    logAnalyzing(params) {
+        this.log({
+            traceId: params.traceId,
+            taskId: params.taskId,
+            stage: 'analyzing',
+            level: 'info',
+            message: `Task ${params.taskId} analysis started`,
+            summary: `任务 ${params.taskId} 正在分析根因...`,
+            metadata: {
+                analysisType: params.analysisType,
+            },
+        });
+    }
+    /**
+     * 记录 principle_generated 事件
+     */
+    logPrincipleGenerated(params) {
+        const truncatedText = params.principleText.length > 100
+            ? params.principleText.substring(0, 100) + '...'
+            : params.principleText;
+        this.log({
+            traceId: params.traceId,
+            taskId: params.taskId,
+            stage: 'principle_generated',
+            level: 'info',
+            message: `Principle ${params.principleId} generated for task ${params.taskId}`,
+            summary: `生成新原则：${truncatedText}`,
+            metadata: {
+                principleId: params.principleId,
+                principleText: params.principleText,
+            },
+        });
+    }
+    /**
+     * 记录 completed 事件
+     */
+    logCompleted(params) {
+        let summary;
+        if (params.resolution === 'marker_detected') {
+            summary = `任务 ${params.taskId} 完成，已生成 ${params.principlesGenerated || 0} 条原则`;
+        }
+        else if (params.resolution === 'auto_completed_timeout') {
+            summary = `任务 ${params.taskId} 超时自动完成`;
+        }
+        else {
+            summary = `任务 ${params.taskId} 已完成`;
+        }
+        this.log({
+            traceId: params.traceId,
+            taskId: params.taskId,
+            stage: 'completed',
+            level: params.resolution === 'auto_completed_timeout' ? 'warn' : 'info',
+            message: `Task ${params.taskId} completed with resolution: ${params.resolution}`,
+            summary,
+            metadata: {
+                resolution: params.resolution,
+                durationMs: params.durationMs,
+                principlesGenerated: params.principlesGenerated,
+            },
+        });
+    }
+    /**
+     * 记录 failed 事件
+     */
+    logFailed(params) {
+        this.log({
+            traceId: params.traceId,
+            taskId: params.taskId,
+            stage: 'failed',
+            level: 'error',
+            message: `Task ${params.taskId} failed: ${params.error}`,
+            summary: `任务 ${params.taskId} 失败：${params.error}`,
+            metadata: {
+                error: params.error,
+                stack: params.stack,
+            },
+        });
+    }
+}
+// 单例缓存：键格式为 "workspaceDir" 或 "workspaceDir::with_trajectory"
+const loggerCache = new Map();
+/**
+ * 获取 EvolutionLogger 实例（单例）
+ *
+ * 注意：带 trajectory 和不带 trajectory 的请求会返回不同的实例，
+ * 因为 trajectory 影响事件持久化行为。
+ */
+export function getEvolutionLogger(workspaceDir, trajectory) {
+    // 缓存键区分是否带 trajectory，避免持久化行为不一致
+    const cacheKey = trajectory ? `${workspaceDir}::with_trajectory` : workspaceDir;
+    const cached = loggerCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const logger = new EvolutionLogger(workspaceDir, trajectory);
+    loggerCache.set(cacheKey, logger);
+    return logger;
+}
+/**
+ * 清理指定 workspace 的 logger 缓存
+ */
+export function disposeEvolutionLogger(workspaceDir) {
+    return loggerCache.delete(workspaceDir);
+}
+/**
+ * 清理所有 logger 缓存（用于测试或进程退出）
+ */
+export function disposeAllEvolutionLoggers() {
+    loggerCache.clear();
+}

package/dist/core/evolution-reducer.d.ts

@@ -11,6 +11,17 @@ export interface EvolutionReducer {
     deprecate(principleId: string, reason: string): void;
     rollbackPrinciple(principleId: string, reason: string): void;
     recordProbationFeedback(principleId: string, success: boolean): void;
+    /**
+     * Creates a new principle with generalized trigger/action from diagnostician.
+     * Called after diagnostician analysis to create principle directly.
+     */
+    createPrincipleFromDiagnosis(params: {
+        painId: string;
+        painType: 'tool_failure' | 'subagent_error' | 'user_frustration';
+        triggerPattern: string;
+        action: string;
+        source: string;
+    }): string | null;
     getStats(): {
         candidateCount: number;
         probationCount: number;
@@ -43,6 +54,18 @@ export declare class EvolutionReducerImpl implements EvolutionReducer {
     deprecate(principleId: string, reason: string): void;
     rollbackPrinciple(principleId: string, reason: string): void;
     recordProbationFeedback(principleId: string, success: boolean): void;
+    /**
+     * Creates a new principle with generalized trigger/action from diagnostician.
+     * Called after diagnostician analysis to create principle directly (no intermediate overfitted principle).
+     * @returns the new principle ID, or null if creation failed
+     */
+    createPrincipleFromDiagnosis(params: {
+        painId: string;
+        painType: 'tool_failure' | 'subagent_error' | 'user_frustration';
+        triggerPattern: string;
+        action: string;
+        source: string;
+    }): string | null;
     getStats(): {
         candidateCount: number;
         probationCount: number;

package/dist/core/evolution-reducer.js

@@ -136,6 +136,66 @@ export class EvolutionReducerImpl {
             this.deprecate(principleId, 'conflict_detected');
         }
     }
+    /**
+     * Creates a new principle with generalized trigger/action from diagnostician.
+     * Called after diagnostician analysis to create principle directly (no intermediate overfitted principle).
+     * @returns the new principle ID, or null if creation failed
+     */
+    createPrincipleFromDiagnosis(params) {
+        // Check blacklist first
+        if (this.isBlacklisted(params.painId, params.triggerPattern)) {
+            SystemLogger.log(this.workspaceDir, 'PRINCIPLE_BLACKLISTED', `Principle creation blocked by blacklist for trigger: "${params.triggerPattern.slice(0, 50)}..."`);
+            return null;
+        }
+        // Check if a principle already exists for this painId
+        const existingPrinciple = [...this.principles.values()].find(p => p.source.painId === params.painId);
+        if (existingPrinciple) {
+            // Update existing principle instead of creating new one
+            existingPrinciple.trigger = params.triggerPattern;
+            existingPrinciple.action = params.action;
+            existingPrinciple.text = `When ${params.triggerPattern}, then ${params.action}.`;
+            existingPrinciple.version += 1;
+            SystemLogger.log(this.workspaceDir, 'PRINCIPLE_UPDATED', `Principle ${existingPrinciple.id} updated from diagnostician: "${params.triggerPattern.slice(0, 50)}..."`);
+            return existingPrinciple.id;
+        }
+        // Create new principle with generalized content
+        const principleId = this.nextPrincipleId();
+        const now = new Date().toISOString();
+        const principle = {
+            id: principleId,
+            version: 1,
+            text: `When ${params.triggerPattern}, then ${params.action}.`,
+            source: {
+                painId: params.painId,
+                painType: params.painType,
+                timestamp: now,
+            },
+            trigger: params.triggerPattern,
+            action: params.action,
+            contextTags: [params.source],
+            validation: { successCount: 0, conflictCount: 0 },
+            status: 'candidate',
+            feedbackScore: 0,
+            usageCount: 0,
+            createdAt: now,
+        };
+        this.principles.set(principleId, principle);
+        this.emitSync({
+            ts: now,
+            type: 'candidate_created',
+            data: {
+                painId: principle.source.painId,
+                principleId,
+                trigger: params.triggerPattern,
+                action: params.action,
+                status: 'candidate',
+            },
+        });
+        // Auto-promote since it's already generalized
+        this.promote(principleId, 'diagnostician_generalized');
+        SystemLogger.log(this.workspaceDir, 'PRINCIPLE_CREATED', `Principle ${principleId} created from diagnostician: "${params.triggerPattern.slice(0, 50)}..."`);
+        return principleId;
+    }
     getStats() {
         return {
             candidateCount: this.getCandidatePrinciples().length,
@@ -254,7 +314,6 @@ export class EvolutionReducerImpl {
     }
     onPainDetected(data, eventTs) {
         const trigger = String(data.reason ?? data.source ?? 'unknown trigger');
-        const action = `Prevent recurrence for: ${String(data.source ?? 'unknown')}`;
         // Defense in depth: protocol/system tokens must never become principles,
         // even if a pain_detected event is emitted from a new callsite in the future.
         if (shouldIgnorePainProtocolText(trigger)) {
@@ -263,38 +322,23 @@ export class EvolutionReducerImpl {
         if (this.isBlacklisted(data.painId, trigger)) {
             return;
         }
-        const principleId = this.nextPrincipleId();
-        const principle = {
-            id: principleId,
-            version: 1,
-            text: `When ${trigger}, then ${action}.`,
-            source: {
-                painId: data.painId,
-                painType: data.painType,
-                timestamp: eventTs,
-            },
-            trigger,
-            action,
-            contextTags: [data.source],
-            validation: { successCount: 0, conflictCount: 0 },
-            status: 'candidate',
-            feedbackScore: 0,
-            usageCount: 0,
-            createdAt: eventTs,
-        };
-        this.principles.set(principleId, principle);
+        // NOTE: Principle creation is now deferred to diagnostician analysis.
+        // The diagnostician will read conversation context, generalize the trigger pattern,
+        // and create a principle via createPrincipleFromDiagnosis() after analysis.
+        // Record pain for tracking purposes (but don't create principle yet)
         this.emitSync({
             ts: new Date().toISOString(),
-            type: 'candidate_created',
+            type: 'pain_recorded',
             data: {
-                painId: principle.source.painId,
-                principleId,
-                trigger,
-                action,
-                status: 'candidate',
+                painId: data.painId,
+                painType: data.painType,
+                source: data.source,
+                reason: data.reason,
+                sessionId: data.sessionId,
+                agentId: data.agentId,
             },
         });
-        this.promote(principleId, 'auto_from_pain');
+        // Circuit breaker logic remains for subagent errors
         if (data.painType === 'subagent_error') {
             const key = String(data.taskId ?? data.source ?? 'subagent');
             const next = this.failureStreak.get(key) ?? 0;
@@ -305,7 +349,7 @@ export class EvolutionReducerImpl {
                     type: 'circuit_breaker_opened',
                     data: {
                         taskId: key,
-                        painId: principle.source.painId,
+                        painId: data.painId,
                         failCount: next,
                         reason: 'Max retries exceeded',
                         requireHuman: true,

package/dist/core/evolution-types.d.ts

@@ -157,7 +157,9 @@ export interface PainDetectedData {
     reason: string;
     score?: number;
     sessionId?: string;
+    agentId?: string;
     taskId?: string;
+    traceId?: string;
 }
 export interface CandidateCreatedData {
     painId: string;
@@ -202,6 +204,10 @@ export type EvolutionLoopEvent = {
     ts: string;
     type: 'pain_detected';
     data: PainDetectedData;
+} | {
+    ts: string;
+    type: 'pain_recorded';
+    data: PainDetectedData;
 } | {
     ts: string;
     type: 'candidate_created';

package/dist/core/focus-history.d.ts

@@ -5,7 +5,33 @@
  * - 压缩时备份当前版本到历史目录
  * - 清理过期历史版本
  * - 读取历史版本（用于 full 模式）
+ * - 工作记忆提取与合并（压缩后恢复上下文）
  */
+/**
+ * 文件输出记录
+ */
+export interface FileArtifact {
+    path: string;
+    action: 'created' | 'modified' | 'deleted';
+    description: string;
+}
+/**
+ * 工作记忆快照
+ */
+export interface WorkingMemorySnapshot {
+    lastUpdated: string;
+    artifacts: FileArtifact[];
+    currentTask?: {
+        description: string;
+        status: 'in_progress' | 'blocked' | 'reviewing' | 'completed';
+        progress: number;
+    };
+    activeProblems: Array<{
+        problem: string;
+        approach?: string;
+    }>;
+    nextActions: string[];
+}
 /**
  * 获取历史目录路径
  */
@@ -63,3 +89,122 @@ export declare function compressFocus(focusPath: string, newContent: string): {
  * @param maxLines 最大行数
  */
 export declare function extractSummary(content: string, maxLines?: number): string;
+/**
+ * 从会话消息中提取工作记忆
+ *
+ * @param messages 会话消息数组（OpenClaw 格式）
+ * @param workspaceDir 工作区目录（用于生成相对路径）
+ * @returns 提取的工作记忆快照
+ */
+export declare function extractWorkingMemory(messages: Array<{
+    role?: string;
+    content?: string | unknown[];
+}>, workspaceDir?: string): WorkingMemorySnapshot;
+/**
+ * 解析 CURRENT_FOCUS.md 中的 Working Memory 章节
+ */
+export declare function parseWorkingMemorySection(content: string): WorkingMemorySnapshot | null;
+/**
+ * 将工作记忆合并到 CURRENT_FOCUS.md 内容中
+ *
+ * @param content 原始内容
+ * @param snapshot 工作记忆快照
+ * @returns 合并后的内容
+ */
+export declare function mergeWorkingMemory(content: string, snapshot: WorkingMemorySnapshot): string;
+/**
+ * 生成工作记忆注入字符串（用于 prompt 注入）
+ */
+export declare function workingMemoryToInjection(snapshot: WorkingMemorySnapshot | null): string;
+/**
+ * 压缩配置接口
+ */
+interface CompressionConfig {
+    lineThreshold: number;
+    sizeThreshold: number;
+    intervalMs: number;
+    keepCompletedTasks: number;
+    maxWorkingMemoryArtifacts: number;
+}
+/**
+ * 提取已完成任务作为里程碑
+ */
+export declare function extractMilestones(content: string): {
+    completedTasks: string[];
+    fileArtifacts: string[];
+};
+/**
+ * 归档里程碑到 daily memory 文件
+ */
+export declare function archiveMilestonesToDaily(workspaceDir: string, milestones: {
+    completedTasks: string[];
+    fileArtifacts: string[];
+}, version: string): string | null;
+/**
+ * 清理过期信息和验证文件引用
+ */
+export declare function cleanupStaleInfo(content: string, workspaceDir?: string, config?: CompressionConfig): string;
+/**
+ * 自动压缩 CURRENT_FOCUS.md
+ *
+ * @param focusPath CURRENT_FOCUS.md 的完整路径
+ * @param workspaceDir 工作区目录（可选，用于验证文件引用）
+ * @param stateDir state 目录路径（可选，用于频率限制）
+ * @returns 压缩结果信息，如果不需要压缩则返回 null
+ */
+export declare function autoCompressFocus(focusPath: string, workspaceDir?: string, stateDir?: string): {
+    compressed: boolean;
+    oldLines: number;
+    newLines: number;
+    milestonesArchived: boolean;
+    backupPath: string | null;
+    reason: string;
+};
+/**
+ * 检查是否需要自动压缩
+ */
+export declare function needsAutoCompression(focusPath: string, stateDir?: string): boolean;
+/**
+ * 验证 CURRENT_FOCUS.md 格式
+ *
+ * 仅校验会导致程序崩溃的核心问题，不过度校验
+ *
+ * @param content 文件内容
+ * @returns 验证结果
+ */
+export declare function validateCurrentFocus(content: string): {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+};
+/**
+ * 从模板恢复 CURRENT_FOCUS.md
+ *
+ * @param focusPath CURRENT_FOCUS.md 路径
+ * @param extensionRoot 插件根目录
+ * @returns 恢复是否成功
+ */
+export declare function recoverFromTemplate(focusPath: string, extensionRoot: string): {
+    success: boolean;
+    error?: string;
+    templatePath?: string;
+};
+/**
+ * 安全读取 CURRENT_FOCUS.md（自动验证 + 恢复）
+ *
+ * 仅在文件为空或损坏时才恢复，其他情况正常使用
+ *
+ * @param focusPath CURRENT_FOCUS.md 路径
+ * @param extensionRoot 插件根目录
+ * @param logger 日志记录器
+ * @returns 文件内容和恢复状态
+ */
+export declare function safeReadCurrentFocus(focusPath: string, extensionRoot: string, logger?: {
+    warn?: (msg: string) => void;
+    info?: (msg: string) => void;
+}): {
+    content: string;
+    recovered: boolean;
+    validationErrors: string[];
+};
+export {};