principles-disciple 1.7.2 → 1.7.4

package/dist/core/config.d.ts

@@ -60,9 +60,19 @@ export interface TrustSettings {
     limits: {
         stage_2_max_lines: number;
         stage_3_max_lines: number;
+        stage_2_max_percentage: number;
+        stage_3_max_percentage: number;
+        min_lines_fallback: number;
     };
     history_limit?: number;
 }
+export interface DiagnosticianSettings {
+    context: {
+        time_window_minutes: number;
+        max_message_length: number;
+        max_summary_length: number;
+    };
+}
 export interface PainSettings {
     language: 'en' | 'zh';
     trajectory?: {
@@ -70,6 +80,7 @@ export interface PainSettings {
         busy_timeout_ms?: number;
         orphan_blob_grace_days?: number;
     };
+    diagnostician?: DiagnosticianSettings;
     thresholds: {
         pain_trigger: number;
         cognitive_paralysis_input: number;

package/dist/core/config.js

@@ -10,6 +10,13 @@ import * as path from 'path';
 // ─────────────────────────────────────────────────────────────
 export const DEFAULT_SETTINGS = {
     language: 'zh', // Optimized for the primary user base
+    diagnostician: {
+        context: {
+            time_window_minutes: 5, // pain_timestamp 前后各 5 分钟
+            max_message_length: 500, // 每条消息截断到 500 字符
+            max_summary_length: 3000, // 对话摘要最大 3000 字符
+        }
+    },
     thresholds: {
         pain_trigger: 40, // Increased tolerance before forcing a stop
         cognitive_paralysis_input: 4000,
@@ -37,7 +44,7 @@ export const DEFAULT_SETTINGS = {
     intervals: {
         worker_poll_ms: 15 * 60 * 1000,
         initial_delay_ms: 5000,
-        task_timeout_ms: 30 * 60 * 1000
+        task_timeout_ms: 60 * 60 * 1000 // 1 hour, matching evolution-worker.ts default
     },
     trust: {
         stages: {
@@ -73,6 +80,9 @@ export const DEFAULT_SETTINGS = {
         limits: {
             stage_2_max_lines: 50, // Was 10. 10 lines is barely enough to fix a function signature.
             stage_3_max_lines: 300, // Was 100. Allow substantial feature implementation.
+            stage_2_max_percentage: 10, // Percentage-based threshold for Stage 2
+            stage_3_max_percentage: 15, // Percentage-based threshold for Stage 3
+            min_lines_fallback: 20, // Minimum threshold even for small files
         },
         history_limit: 50
     },
@@ -210,6 +220,14 @@ export class PainConfig {
         // Ensure intervals are positive
         if (settings.intervals.worker_poll_ms < 1000)
             settings.intervals.worker_poll_ms = 15 * 60 * 1000;
+        // Ensure percentage limits are in valid range [0, 100]
+        const l = settings.trust.limits;
+        if (l.stage_2_max_percentage < 0 || l.stage_2_max_percentage > 100)
+            l.stage_2_max_percentage = 10;
+        if (l.stage_3_max_percentage < 0 || l.stage_3_max_percentage > 100)
+            l.stage_3_max_percentage = 15;
+        if (l.min_lines_fallback < 1)
+            l.min_lines_fallback = 20;
     }
     /**
      * Gets a value using dot notation (e.g. 'thresholds.pain_trigger')

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

@@ -0,0 +1,137 @@
+/**
+ * EvolutionLogger - 进化流程日志服务
+ *
+ * 提供两层日志：
+ * - 技术层：结构化 JSON，包含 trace_id、stage、metadata
+ * - 用户层：中文摘要，便于小白用户理解
+ *
+ * 日志写入两个地方：
+ * 1. SYSTEM_LOG (system.jsonl) - 技术细节
+ * 2. evolution_events 表 (SQLite) - 结构化查询
+ */
+import type { TrajectoryDatabase } from './trajectory.js';
+export type EvolutionStage = 'pain_detected' | 'queued' | 'started' | 'analyzing' | 'principle_generated' | 'completed' | 'failed';
+export type EvolutionLogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface EvolutionLogEntry {
+    traceId: string;
+    stage: EvolutionStage;
+    level: EvolutionLogLevel;
+    message: string;
+    summary: string;
+    timestamp: string;
+    metadata?: Record<string, unknown>;
+    taskId?: string;
+    sessionId?: string;
+}
+export interface EvolutionLogInput {
+    traceId: string;
+    stage: EvolutionStage;
+    level?: EvolutionLogLevel;
+    message: string;
+    summary: string;
+    metadata?: Record<string, unknown>;
+    taskId?: string;
+    sessionId?: string;
+}
+export declare const STAGE_LABELS: Record<EvolutionStage, string>;
+export declare const STAGE_COLORS: Record<EvolutionStage, string>;
+/**
+ * 创建新的 trace_id
+ * 格式: ev_{timestamp}_{random}
+ * 使用 crypto.randomBytes 确保不可预测性
+ */
+export declare function createTraceId(): string;
+/**
+ * EvolutionLogger 类
+ * 管理进化流程的日志记录
+ */
+export declare class EvolutionLogger {
+    private readonly workspaceDir;
+    private readonly trajectory;
+    constructor(workspaceDir: string, trajectory?: TrajectoryDatabase);
+    /**
+     * 记录进化事件
+     * 同时写入 SYSTEM_LOG 和 evolution_events 表
+     */
+    log(input: EvolutionLogInput): void;
+    /**
+     * 记录 pain_detected 事件
+     */
+    logPainDetected(params: {
+        traceId: string;
+        source: string;
+        reason: string;
+        score: number;
+        toolName?: string;
+        filePath?: string;
+        sessionId?: string;
+    }): void;
+    /**
+     * 记录 queued 事件
+     */
+    logQueued(params: {
+        traceId: string;
+        taskId: string;
+        score: number;
+        source: string;
+        reason: string;
+    }): void;
+    /**
+     * 记录 started 事件
+     */
+    logStarted(params: {
+        traceId: string;
+        taskId: string;
+    }): void;
+    /**
+     * 记录 analyzing 事件
+     */
+    logAnalyzing(params: {
+        traceId: string;
+        taskId: string;
+        analysisType?: string;
+    }): void;
+    /**
+     * 记录 principle_generated 事件
+     */
+    logPrincipleGenerated(params: {
+        traceId: string;
+        taskId: string;
+        principleId: string;
+        principleText: string;
+    }): void;
+    /**
+     * 记录 completed 事件
+     */
+    logCompleted(params: {
+        traceId: string;
+        taskId: string;
+        resolution: 'marker_detected' | 'auto_completed_timeout' | 'manual';
+        durationMs?: number;
+        principlesGenerated?: number;
+    }): void;
+    /**
+     * 记录 failed 事件
+     */
+    logFailed(params: {
+        traceId: string;
+        taskId: string;
+        error: string;
+        stack?: string;
+    }): void;
+}
+/**
+ * 获取 EvolutionLogger 实例（单例）
+ *
+ * 注意：带 trajectory 和不带 trajectory 的请求会返回不同的实例，
+ * 因为 trajectory 影响事件持久化行为。
+ */
+export declare function getEvolutionLogger(workspaceDir: string, trajectory?: TrajectoryDatabase): EvolutionLogger;
+/**
+ * 清理指定 workspace 的 logger 缓存
+ */
+export declare function disposeEvolutionLogger(workspaceDir: string): boolean;
+/**
+ * 清理所有 logger 缓存（用于测试或进程退出）
+ */
+export declare function disposeAllEvolutionLoggers(): void;

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';