principles-disciple 1.5.4 → 1.7.0

package/dist/core/event-log.js

@@ -44,6 +44,9 @@ export class EventLog {
     recordGateBlock(sessionId, data) {
         this.record('gate_block', 'blocked', sessionId, data);
     }
+    recordGateBypass(sessionId, data) {
+        this.record('gate_bypass', 'bypassed', sessionId, data);
+    }
     recordPlanApproval(sessionId, data) {
         this.record('plan_approval', 'approved', sessionId, data);
     }
@@ -57,6 +60,9 @@ export class EventLog {
     recordTrustChange(sessionId, data) {
         this.record('trust_change', 'changed', sessionId, data);
     }
+    recordEmpathyRollback(sessionId, data) {
+        this.record('empathy_rollback', 'rolled_back', sessionId, data);
+    }
     recordError(sessionId, message, context) {
         this.record('error', 'failure', sessionId, { message, ...context });
     }
@@ -115,6 +121,45 @@ export class EventLog {
             const data = entry.data;
             stats.pain.signalsDetected++;
             stats.pain.maxScore = Math.max(stats.pain.maxScore, data.score);
+            // Update empathy stats for user_empathy source
+            if (data.source === 'user_empathy') {
+                if (data.deduped) {
+                    stats.empathy.dedupedCount++;
+                }
+                else {
+                    stats.empathy.totalEvents++;
+                    stats.empathy.totalPenaltyScore += data.score || 0;
+                    // By severity
+                    if (data.severity) {
+                        stats.empathy.bySeverity[data.severity]++;
+                        stats.empathy.scoreBySeverity[data.severity] += data.score || 0;
+                    }
+                    // By detection mode
+                    if (data.detection_mode) {
+                        stats.empathy.byDetectionMode[data.detection_mode]++;
+                    }
+                    // By origin
+                    if (data.origin) {
+                        stats.empathy.byOrigin[data.origin]++;
+                    }
+                    // Confidence distribution
+                    const conf = data.confidence ?? 1;
+                    if (conf >= 0.8)
+                        stats.empathy.confidenceDistribution.high++;
+                    else if (conf >= 0.5)
+                        stats.empathy.confidenceDistribution.medium++;
+                    else
+                        stats.empathy.confidenceDistribution.low++;
+                }
+                // Update dedupe hit rate
+                const total = stats.empathy.totalEvents + stats.empathy.dedupedCount;
+                stats.empathy.dedupeHitRate = total > 0 ? stats.empathy.dedupedCount / total : 0;
+            }
+        }
+        else if (entry.type === 'empathy_rollback') {
+            const data = entry.data;
+            stats.empathy.rollbackCount++;
+            stats.empathy.rolledBackScore += data.originalScore || 0;
         }
     }
     startFlushTimer() {
@@ -164,6 +209,280 @@ export class EventLog {
         }
         return stats;
     }
+    /**
+     * Get aggregated empathy statistics for multiple time ranges.
+     * @param range 'today' | 'week' | 'session'
+     * @param sessionId Optional session ID for session-scoped stats
+     */
+    getEmpathyStats(range, sessionId) {
+        const now = new Date();
+        const today = this.formatDate(now);
+        // Aggregate stats based on range
+        const result = {
+            totalEvents: 0,
+            dedupedCount: 0,
+            dedupeHitRate: 0,
+            totalPenaltyScore: 0,
+            rolledBackScore: 0,
+            rollbackCount: 0,
+            bySeverity: { mild: 0, moderate: 0, severe: 0 },
+            scoreBySeverity: { mild: 0, moderate: 0, severe: 0 },
+            byDetectionMode: { structured: 0, legacy_tag: 0 },
+            byOrigin: { assistant_self_report: 0, user_manual: 0, system_infer: 0 },
+            confidenceDistribution: { high: 0, medium: 0, low: 0 },
+            dailyTrend: [],
+        };
+        if (range === 'session' && sessionId) {
+            // For session range, scan event buffer and events file
+            this.aggregateSessionEmpathy(sessionId, result);
+        }
+        else if (range === 'week') {
+            // For week range, aggregate last 7 days
+            for (let i = 0; i < 7; i++) {
+                const date = new Date(now);
+                date.setDate(date.getDate() - i);
+                const dateStr = this.formatDate(date);
+                const stats = this.getDailyStats(dateStr);
+                result.totalEvents += stats.empathy.totalEvents;
+                result.dedupedCount += stats.empathy.dedupedCount;
+                result.totalPenaltyScore += stats.empathy.totalPenaltyScore;
+                result.rolledBackScore += stats.empathy.rolledBackScore;
+                result.rollbackCount += stats.empathy.rollbackCount;
+                for (const sev of ['mild', 'moderate', 'severe']) {
+                    result.bySeverity[sev] += stats.empathy.bySeverity[sev];
+                    result.scoreBySeverity[sev] += stats.empathy.scoreBySeverity[sev];
+                }
+                result.byDetectionMode.structured += stats.empathy.byDetectionMode.structured;
+                result.byDetectionMode.legacy_tag += stats.empathy.byDetectionMode.legacy_tag;
+                for (const org of ['assistant_self_report', 'user_manual', 'system_infer']) {
+                    result.byOrigin[org] += stats.empathy.byOrigin[org];
+                }
+                result.confidenceDistribution.high += stats.empathy.confidenceDistribution.high;
+                result.confidenceDistribution.medium += stats.empathy.confidenceDistribution.medium;
+                result.confidenceDistribution.low += stats.empathy.confidenceDistribution.low;
+                if (stats.empathy.totalEvents > 0 || stats.empathy.dedupedCount > 0) {
+                    result.dailyTrend.push({
+                        date: dateStr,
+                        count: stats.empathy.totalEvents,
+                        score: stats.empathy.totalPenaltyScore,
+                    });
+                }
+            }
+        }
+        else {
+            // Today only
+            const stats = this.getDailyStats(today);
+            Object.assign(result, stats.empathy);
+            if (stats.empathy.totalEvents > 0 || stats.empathy.dedupedCount > 0) {
+                result.dailyTrend = [{
+                        date: today,
+                        count: stats.empathy.totalEvents,
+                        score: stats.empathy.totalPenaltyScore,
+                    }];
+            }
+        }
+        // Calculate dedupe hit rate
+        const total = result.totalEvents + result.dedupedCount;
+        result.dedupeHitRate = total > 0 ? result.dedupedCount / total : 0;
+        return result;
+    }
+    /**
+     * Aggregate empathy stats for a specific session.
+     */
+    aggregateSessionEmpathy(sessionId, result) {
+        // Check event buffer first
+        for (const entry of this.eventBuffer) {
+            if (entry.sessionId === sessionId && entry.type === 'pain_signal') {
+                const data = entry.data;
+                if (data.source === 'user_empathy') {
+                    if (data.deduped) {
+                        result.dedupedCount++;
+                    }
+                    else {
+                        result.totalEvents++;
+                        result.totalPenaltyScore += data.score || 0;
+                        if (data.severity) {
+                            result.bySeverity[data.severity]++;
+                            result.scoreBySeverity[data.severity] += data.score || 0;
+                        }
+                        if (data.detection_mode)
+                            result.byDetectionMode[data.detection_mode]++;
+                        if (data.origin)
+                            result.byOrigin[data.origin]++;
+                        const conf = data.confidence ?? 1;
+                        if (conf >= 0.8)
+                            result.confidenceDistribution.high++;
+                        else if (conf >= 0.5)
+                            result.confidenceDistribution.medium++;
+                        else
+                            result.confidenceDistribution.low++;
+                    }
+                }
+            }
+            else if (entry.sessionId === sessionId && entry.type === 'empathy_rollback') {
+                const data = entry.data;
+                result.rollbackCount++;
+                result.rolledBackScore += data.originalScore || 0;
+            }
+        }
+        // Also check events file for persisted events
+        if (fs.existsSync(this.eventsFile)) {
+            try {
+                const content = fs.readFileSync(this.eventsFile, 'utf-8');
+                const lines = content.trim().split('\n');
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const entry = JSON.parse(line);
+                        if (entry.sessionId === sessionId) {
+                            if (entry.type === 'pain_signal') {
+                                const data = entry.data;
+                                if (data.source === 'user_empathy') {
+                                    if (data.deduped) {
+                                        result.dedupedCount++;
+                                    }
+                                    else {
+                                        result.totalEvents++;
+                                        result.totalPenaltyScore += data.score || 0;
+                                        if (data.severity) {
+                                            result.bySeverity[data.severity]++;
+                                            result.scoreBySeverity[data.severity] += data.score || 0;
+                                        }
+                                        if (data.detection_mode)
+                                            result.byDetectionMode[data.detection_mode]++;
+                                        if (data.origin)
+                                            result.byOrigin[data.origin]++;
+                                        const conf = data.confidence ?? 1;
+                                        if (conf >= 0.8)
+                                            result.confidenceDistribution.high++;
+                                        else if (conf >= 0.5)
+                                            result.confidenceDistribution.medium++;
+                                        else
+                                            result.confidenceDistribution.low++;
+                                    }
+                                }
+                            }
+                            else if (entry.type === 'empathy_rollback') {
+                                const data = entry.data;
+                                result.rollbackCount++;
+                                result.rolledBackScore += data.originalScore || 0;
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip malformed lines
+                    }
+                }
+            }
+            catch (e) {
+                if (this.logger)
+                    this.logger.error(`[PD] Failed to read events.jsonl: ${String(e)}`);
+            }
+        }
+    }
+    /**
+     * Rollback an empathy event by ID.
+     * Returns the rolled back score, or 0 if event not found.
+     */
+    rollbackEmpathyEvent(eventId, sessionId, reason, triggeredBy) {
+        // Search for the event in buffer and file
+        let foundEvent = null;
+        // Check buffer first
+        for (const entry of this.eventBuffer) {
+            if (entry.type === 'pain_signal') {
+                const data = entry.data;
+                if (entry.data.eventId === eventId && data.source === 'user_empathy') {
+                    foundEvent = { entry, data };
+                    break;
+                }
+            }
+        }
+        // If not in buffer, check file
+        if (!foundEvent && fs.existsSync(this.eventsFile)) {
+            try {
+                const content = fs.readFileSync(this.eventsFile, 'utf-8');
+                const lines = content.trim().split('\n');
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const entry = JSON.parse(line);
+                        if (entry.type === 'pain_signal') {
+                            const data = entry.data;
+                            if (entry.data.eventId === eventId && data.source === 'user_empathy') {
+                                foundEvent = { entry, data };
+                                break;
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip malformed lines
+                    }
+                }
+            }
+            catch (e) {
+                if (this.logger)
+                    this.logger.error(`[PD] Failed to read events.jsonl: ${String(e)}`);
+            }
+        }
+        if (!foundEvent || foundEvent.data.deduped) {
+            return 0;
+        }
+        const originalScore = foundEvent.data.score || 0;
+        // Record the rollback event
+        this.recordEmpathyRollback(sessionId, {
+            eventId,
+            originalScore,
+            originalSessionId: foundEvent.entry.sessionId,
+            reason,
+            triggeredBy,
+        });
+        return originalScore;
+    }
+    /**
+     * Get the last empathy event ID for a session (for rollback).
+     */
+    getLastEmpathyEventId(sessionId) {
+        // Check buffer in reverse
+        for (let i = this.eventBuffer.length - 1; i >= 0; i--) {
+            const entry = this.eventBuffer[i];
+            if (entry.sessionId === sessionId && entry.type === 'pain_signal') {
+                const data = entry.data;
+                if (data.source === 'user_empathy' && !data.deduped) {
+                    return entry.data.eventId || null;
+                }
+            }
+        }
+        // Check file
+        if (fs.existsSync(this.eventsFile)) {
+            try {
+                const content = fs.readFileSync(this.eventsFile, 'utf-8');
+                const lines = content.trim().split('\n');
+                for (let i = lines.length - 1; i >= 0; i--) {
+                    if (!lines[i].trim())
+                        continue;
+                    try {
+                        const entry = JSON.parse(lines[i]);
+                        if (entry.sessionId === sessionId && entry.type === 'pain_signal') {
+                            const data = entry.data;
+                            if (data.source === 'user_empathy' && !data.deduped) {
+                                return entry.data.eventId || null;
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip malformed lines
+                    }
+                }
+            }
+            catch (e) {
+                if (this.logger)
+                    this.logger.error(`[PD] Failed to read events.jsonl: ${String(e)}`);
+            }
+        }
+        return null;
+    }
     /**
      * Dispose of the EventLog, flushing pending data and clearing timer.
      */

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

@@ -81,13 +81,13 @@ export declare class EvolutionEngine {
     private isLockStale;
     /** 持久化评分卡（含锁保护） */
     private saveScorecard;
-    /** 保存失败后的重试队列 */
-    private static retryQueue;
-    private static retryTimer;
+    /** Per-instance retry queue (P0 fix: was static, causing cross-instance race) */
+    private retryQueue;
+    private retryTimer;
     /** 调度重试保存 */
-    private static scheduleRetrySave;
+    private scheduleRetrySave;
     /** 处理重试队列 */
-    private static processRetryQueue;
+    private processRetryQueue;
     /** 无锁快速保存（用于重试） */
     private saveScorecardImmediate;
     private generateId;

package/dist/core/evolution-engine.js

@@ -30,10 +30,10 @@ const EXPLORATORY_TOOLS = new Set([
 const CONSTRUCTIVE_TOOLS = new Set([
     'write', 'write_file', 'edit', 'edit_file', 'replace', 'apply_patch',
     'insert', 'patch', 'delete_file', 'move_file', 'run_shell_command',
-    'pd_spawn_agent', 'sessions_spawn',
+    'pd_run_worker', 'sessions_spawn',
 ]);
 // 高风险工具：需要 allowRiskPath 权限
-// 注意：pd_spawn_agent 和 sessions_spawn 已从高风险中移出，它们由 allowSubagentSpawn 单独控制
+// 注意：pd_run_worker 和 sessions_spawn 已从高风险中移出，它们由 allowSubagentSpawn 单独控制
 const HIGH_RISK_TOOLS = new Set([
     'run_shell_command', 'delete_file', 'move_file',
 ]);
@@ -202,7 +202,7 @@ export class EvolutionEngine {
             };
         }
         // 子智能体检查
-        if ((context.toolName === 'pd_spawn_agent' || context.toolName === 'sessions_spawn') && !perms.allowSubagentSpawn) {
+        if ((context.toolName === 'pd_run_worker' || context.toolName === 'sessions_spawn') && !perms.allowSubagentSpawn) {
             return {
                 allowed: false,
                 reason: `Tier ${this.scorecard.currentTier} (${tierDef.name}) 未解锁子智能体权限`,
@@ -464,29 +464,29 @@ export class EvolutionEngine {
             release();
         }
     }
-    /** 保存失败后的重试队列 */
-    static retryQueue = [];
-    static retryTimer = null;
+    /** Per-instance retry queue (P0 fix: was static, causing cross-instance race) */
+    retryQueue = [];
+    retryTimer = null;
     /** 调度重试保存 */
-    static scheduleRetrySave(engine) {
+    scheduleRetrySave() {
         // 每个引擎只保留最新数据
-        EvolutionEngine.retryQueue = EvolutionEngine.retryQueue.filter(item => item.engine !== engine);
-        EvolutionEngine.retryQueue.push({ engine, data: { ...engine.scorecard } });
-        // 启动重试定时器
-        if (!EvolutionEngine.retryTimer) {
-            EvolutionEngine.retryTimer = setTimeout(() => {
-                EvolutionEngine.processRetryQueue();
+        this.retryQueue = this.retryQueue.filter(item => item.engine !== this);
+        this.retryQueue.push({ engine: this, data: { ...this.scorecard } });
+        // 启动重试定时器（每个实例独立）
+        if (!this.retryTimer) {
+            this.retryTimer = setTimeout(() => {
+                this.processRetryQueue();
             }, 1000);
         }
     }
     /** 处理重试队列 */
-    static processRetryQueue() {
-        EvolutionEngine.retryTimer = null;
+    processRetryQueue() {
+        this.retryTimer = null;
         const latestByEngine = new Map();
-        for (const item of EvolutionEngine.retryQueue) {
+        for (const item of this.retryQueue) {
             latestByEngine.set(item.engine, item.data);
         }
-        EvolutionEngine.retryQueue = [];
+        this.retryQueue = [];
         for (const [engine, data] of latestByEngine) {
             try {
                 engine.saveScorecardImmediate(data);
@@ -494,7 +494,7 @@ export class EvolutionEngine {
             }
             catch (e) {
                 console.error(`[Evolution] Retry save failed: ${String(e)}`);
-                EvolutionEngine.scheduleRetrySave(engine);
+                engine.scheduleRetrySave(); // 每个引擎独立重试
             }
         }
     }

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

@@ -0,0 +1,5 @@
+export interface MigrationResult {
+    importedEvents: number;
+    streamPath: string;
+}
+export declare function migrateLegacyEvolutionData(workspaceDir: string): MigrationResult;

package/dist/core/evolution-migration.js

@@ -0,0 +1,65 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { stableContentHash } from './evolution-reducer.js';
+import { SystemLogger } from './system-logger.js';
+function appendEvent(streamPath, event) {
+    fs.appendFileSync(streamPath, `${JSON.stringify(event)}\n`, 'utf8');
+}
+function loadImportedHashes(streamPath, workspaceDir) {
+    if (!fs.existsSync(streamPath))
+        return new Set();
+    const raw = fs.readFileSync(streamPath, 'utf8').trim();
+    if (!raw)
+        return new Set();
+    const hashes = new Set();
+    for (const line of raw.split('\n')) {
+        try {
+            const event = JSON.parse(line);
+            if (event.type !== 'legacy_import')
+                continue;
+            const hash = event.data.contentHash;
+            if (typeof hash === 'string')
+                hashes.add(hash);
+        }
+        catch (e) {
+            SystemLogger.log(workspaceDir, 'MIGRATION_WARN', `skip malformed line: ${String(e)}`);
+        }
+    }
+    return hashes;
+}
+export function migrateLegacyEvolutionData(workspaceDir) {
+    const streamPath = path.join(workspaceDir, 'memory', 'evolution.jsonl');
+    fs.mkdirSync(path.dirname(streamPath), { recursive: true });
+    const candidates = [
+        path.join(workspaceDir, 'memory', 'ISSUE_LOG.md'),
+        path.join(workspaceDir, 'memory', 'DECISIONS.md'),
+        path.join(workspaceDir, '.principles', 'PRINCIPLES.md'),
+    ];
+    const existingHashes = loadImportedHashes(streamPath, workspaceDir);
+    let importedEvents = 0;
+    for (const sourceFile of candidates) {
+        if (!fs.existsSync(sourceFile)) {
+            continue;
+        }
+        const content = fs.readFileSync(sourceFile, 'utf8').trim();
+        if (!content) {
+            continue;
+        }
+        const contentHash = stableContentHash(`${sourceFile}:${content}`);
+        if (existingHashes.has(contentHash)) {
+            continue;
+        }
+        appendEvent(streamPath, {
+            ts: new Date().toISOString(),
+            type: 'legacy_import',
+            data: {
+                sourceFile: path.relative(workspaceDir, sourceFile),
+                content,
+                contentHash,
+            },
+        });
+        importedEvents += 1;
+        existingHashes.add(contentHash);
+    }
+    return { importedEvents, streamPath };
+}

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

@@ -0,0 +1,69 @@
+import type { EvolutionLoopEvent, Principle } from './evolution-types.js';
+export interface EvolutionReducer {
+    emit(event: EvolutionLoopEvent): void;
+    emitSync(event: EvolutionLoopEvent): void;
+    getEventLog(): EvolutionLoopEvent[];
+    getCandidatePrinciples(): Principle[];
+    getProbationPrinciples(): Principle[];
+    getActivePrinciples(): Principle[];
+    getPrincipleById(id: string): Principle | null;
+    promote(principleId: string, reason?: string): void;
+    deprecate(principleId: string, reason: string): void;
+    rollbackPrinciple(principleId: string, reason: string): void;
+    recordProbationFeedback(principleId: string, success: boolean): void;
+    getStats(): {
+        candidateCount: number;
+        probationCount: number;
+        activeCount: number;
+        deprecatedCount: number;
+        lastPromotedAt: string | null;
+    };
+}
+export declare class EvolutionReducerImpl implements EvolutionReducer {
+    private readonly streamPath;
+    private readonly lockTargetPath;
+    private readonly blacklistPath;
+    private readonly workspaceDir;
+    private readonly memoryEvents;
+    private readonly principles;
+    private readonly failureStreak;
+    private lastPromotedAt;
+    private isReplaying;
+    constructor(opts: {
+        workspaceDir: string;
+    });
+    emit(event: EvolutionLoopEvent): void;
+    emitSync(event: EvolutionLoopEvent): void;
+    getEventLog(): EvolutionLoopEvent[];
+    getCandidatePrinciples(): Principle[];
+    getProbationPrinciples(): Principle[];
+    getActivePrinciples(): Principle[];
+    getPrincipleById(id: string): Principle | null;
+    promote(principleId: string, reason?: string): void;
+    deprecate(principleId: string, reason: string): void;
+    rollbackPrinciple(principleId: string, reason: string): void;
+    recordProbationFeedback(principleId: string, success: boolean): void;
+    getStats(): {
+        candidateCount: number;
+        probationCount: number;
+        activeCount: number;
+        deprecatedCount: number;
+        lastPromotedAt: string | null;
+    };
+    private ensureDirs;
+    private loadFromStream;
+    private applyEvent;
+    private onCandidateCreated;
+    private onPrinciplePromoted;
+    private onPrincipleDeprecated;
+    private onPrincipleRolledBack;
+    private onPainDetected;
+    private updateFailureStreakFromPain;
+    private nextPrincipleId;
+    private getByStatus;
+    private sweepExpiredProbation;
+    private persistBlacklist;
+    private loadBlacklist;
+    private isBlacklisted;
+}
+export declare function stableContentHash(input: string): string;