create-principles-disciple 1.104.0 → 1.104.2

package/plugin/dist/core/evolution-reducer.js

@@ -1,720 +0,0 @@
-import * as crypto from 'crypto';
-import * as fs from 'fs';
-import * as path from 'path';
-import { withLock } from '../utils/file-lock.js';
-import { atomicWriteFileSync } from '../utils/io.js';
-import { PathResolver } from './path-resolver.js';
-import { SystemLogger } from './system-logger.js';
-import { shouldIgnorePainProtocolText } from './dictionary.js';
-import { TrajectoryRegistry } from './trajectory.js';
-import { isCompleteDetectorMetadata } from './evolution-types.js';
-import { updateTrainingStore, addPrincipleToLedger, updatePrinciple } from './principle-tree-ledger.js';
-import { PrincipleCompiler } from './principle-compiler/index.js';
-/**
- * Wrapper for updatePrinciple calls in the compilation retry path.
- * If updatePrinciple throws, logs the error instead of propagating —
- * compilation retry state is best-effort and should not crash principle creation.
- */
-function updateRetryCount(stateDir, workspaceDir, principleId, count) {
-    try {
-        updatePrinciple(stateDir, principleId, { compilationRetryCount: count });
-    }
-    catch (err) {
-        SystemLogger.log(workspaceDir, 'RETRY_COUNT_UPDATE_FAILED', `Failed to update compilationRetryCount for ${principleId}: ${String(err)}`);
-    }
-}
-const PROBATION_SUCCESS_THRESHOLD = 3;
-const CIRCUIT_BREAKER_THRESHOLD = 3;
-const PROBATION_MAX_AGE_DAYS = 30;
-export class EvolutionReducerImpl {
-    streamPath;
-    lockTargetPath;
-    blacklistPath;
-    principlesPath;
-    workspaceDir;
-    stateDir;
-    memoryEvents = [];
-    principles = new Map();
-    failureStreak = new Map();
-    lastPromotedAt = null;
-    isReplaying = false;
-    // _painCallbacks pub/sub removed (PRI-451 Wave 1): no code ever registered a
-    // callback via .on(). The pain_detected → PainSignalBridge bridge happens via
-    // emitPainDetectedEvent (hooks/pain.ts), not this pub/sub layer.
-    constructor(opts) {
-        this.workspaceDir = opts.workspaceDir;
-        this.stateDir = opts.stateDir;
-        const resolver = new PathResolver({ workspaceDir: opts.workspaceDir });
-        this.streamPath = resolver.resolve('EVOLUTION_STREAM');
-        this.lockTargetPath = resolver.resolve('EVOLUTION_LOCK');
-        this.blacklistPath = resolver.resolve('PRINCIPLE_BLACKLIST');
-        this.principlesPath = resolver.resolve('PRINCIPLES');
-        this.ensureDirs();
-        this.loadFromStream();
-        this.sweepExpiredProbation();
-    }
-    emit(event) {
-        this.emitSync(event);
-    }
-    emitSync(event) {
-        withLock(this.lockTargetPath, () => {
-            fs.appendFileSync(this.streamPath, `${JSON.stringify(event)}\n`, 'utf8');
-        }, { lockStaleMs: 15000 });
-        this.applyEvent(event);
-        if (event.type !== 'pain_detected') {
-            try {
-                TrajectoryRegistry.use(this.workspaceDir, (trajectory) => {
-                    trajectory.recordPrincipleEvent({
-                        principleId: 'principleId' in event.data && typeof event.data.principleId === 'string' ? event.data.principleId : null,
-                        eventType: event.type,
-                        payload: event.data,
-                        createdAt: event.ts,
-                    });
-                });
-            }
-            catch {
-                // Keep evolution loop resilient if trajectory storage is unavailable.
-            }
-        }
-        // Performance: sweepExpiredProbation() moved to getProbationPrinciples() for lazy cleanup
-    }
-    // on(callback) pub/sub registration removed (PRI-451 Wave 1): dead code —
-    // no caller ever registered a callback. pain_detected events still flow via
-    // emitPainDetectedEvent → PainSignalBridge, unaffected.
-    getEventLog() {
-        return [...this.memoryEvents];
-    }
-    getCandidatePrinciples() {
-        return this.getByStatus('candidate');
-    }
-    getProbationPrinciples() {
-        // Lazy cleanup: sweep expired probation principles on access
-        this.sweepExpiredProbation();
-        return this.getByStatus('probation');
-    }
-    getActivePrinciples() {
-        return this.getByStatus('active');
-    }
-    getPrincipleById(id) {
-        return this.principles.get(id) ?? null;
-    }
-    promote(principleId, reason = 'manual') {
-        const p = this.principles.get(principleId);
-        if (!p || p.status === 'active' || p.status === 'deprecated')
-            return;
-        const toStatus = (p.status === 'candidate' ? 'probation' : p.status === 'probation' ? 'active' : p.status);
-        const event = {
-            ts: new Date().toISOString(),
-            type: 'principle_promoted',
-            data: {
-                principleId,
-                from: p.status,
-                to: toStatus,
-                reason,
-                successCount: p.validation.successCount,
-            },
-        };
-        this.emitSync(event);
-    }
-    deprecate(principleId, reason) {
-        const p = this.principles.get(principleId);
-        if (!p || p.status === 'deprecated')
-            return;
-        this.emitSync({
-            ts: new Date().toISOString(),
-            type: 'principle_deprecated',
-            data: {
-                principleId,
-                reason,
-                triggeredBy: 'manual',
-            },
-        });
-    }
-    rollbackPrinciple(principleId, reason) {
-        const p = this.principles.get(principleId);
-        if (!p)
-            return;
-        this.emitSync({
-            ts: new Date().toISOString(),
-            type: 'principle_rolled_back',
-            data: {
-                principleId,
-                reason,
-                triggeredBy: 'user_command',
-                blacklistPattern: p.trigger,
-                relatedPainId: p.source.painId,
-            },
-        });
-    }
-    recordProbationFeedback(principleId, success) {
-        const p = this.principles.get(principleId);
-        if (!p || p.status !== 'probation')
-            return;
-        if (success) {
-            p.validation.successCount += 1;
-            p.feedbackScore += 10;
-            if (p.validation.successCount >= PROBATION_SUCCESS_THRESHOLD) {
-                this.promote(principleId, 'auto_threshold');
-            }
-            return;
-        }
-        p.validation.conflictCount += 1;
-        if (p.validation.conflictCount >= 1) {
-            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;
-        }
-        // Evaluability defaults to 'weak_heuristic' — allows basic pattern-matching
-        // evaluation without requiring full detectorMetadata.
-        // #212: Only 'deterministic' requires complete detectorMetadata.
-        // 'weak_heuristic' can work with just the trigger pattern.
-        let evaluability = params.evaluability ?? 'weak_heuristic';
-        if (evaluability === 'deterministic' && !isCompleteDetectorMetadata(params.detectorMetadata)) {
-            SystemLogger.log(this.workspaceDir, 'EVALUABILITY_DOWNGRADED', `Principle for painId "${params.painId}" requested evaluability="deterministic" without detectorMetadata — downgrading to "weak_heuristic". Provide valid detectorMetadata for deterministic evaluation.`);
-            evaluability = 'weak_heuristic';
-        }
-        // 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.
-            // Apply the same evaluability normalization as new creation:
-            // deterministic/weak_heuristic without detectorMetadata → downgraded to manual_only.
-            existingPrinciple.trigger = params.triggerPattern;
-            existingPrinciple.action = params.action;
-            existingPrinciple.text = `When ${params.triggerPattern}, then ${params.action}.`;
-            existingPrinciple.version += 1;
-            if (params.evaluability !== undefined) {
-                // Apply normalization (params.evaluability may be invalid without complete metadata)
-                // #212: Only 'deterministic' requires detectorMetadata; 'weak_heuristic' does not.
-                const normalizedEvaluability = (() => {
-                    if (params.evaluability === 'deterministic' && !isCompleteDetectorMetadata(params.detectorMetadata)) {
-                        SystemLogger.log(this.workspaceDir, 'EVALUABILITY_DOWNGRADED', `Principle update for painId "${params.painId}" requested evaluability="deterministic" without detectorMetadata — downgrading to "weak_heuristic".`);
-                        return 'weak_heuristic';
-                    }
-                    return params.evaluability;
-                })();
-                existingPrinciple.evaluability = normalizedEvaluability;
-            }
-            // Preserve detectorMetadata unless explicitly provided in this call.
-            // Accept only if complete (defense in depth — subagent should already filter).
-            if (isCompleteDetectorMetadata(params.detectorMetadata)) {
-                existingPrinciple.detectorMetadata = structuredClone(params.detectorMetadata);
-            }
-            else if (params.detectorMetadata !== undefined) {
-                // Malformed metadata provided — clear any existing metadata
-                existingPrinciple.detectorMetadata = undefined;
-            }
-            // Refresh abstractedPrinciple if provided
-            if (params.abstractedPrinciple) {
-                existingPrinciple.abstractedPrinciple = params.abstractedPrinciple;
-            }
-            // Sync to file to ensure PRINCIPLES.md stays up to date
-            const synced = this.syncPrincipleToFile(existingPrinciple);
-            if (!synced) {
-                SystemLogger.log(this.workspaceDir, 'PRINCIPLE_SYNC_WARN', `Principle ${existingPrinciple.id} updated in memory but failed to sync to PRINCIPLES.md — manual file check required`);
-            }
-            SystemLogger.log(this.workspaceDir, 'PRINCIPLE_UPDATED', `Principle ${existingPrinciple.id} updated from diagnostician: "${params.triggerPattern.slice(0, 50)}..." [evaluability: ${existingPrinciple.evaluability}]`);
-            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,
-            evaluability,
-            detectorMetadata: isCompleteDetectorMetadata(params.detectorMetadata)
-                ? structuredClone(params.detectorMetadata)
-                : undefined,
-            abstractedPrinciple: params.abstractedPrinciple,
-            coreAxiomId: params.coreAxiomId,
-            // ── Principle-Tree metadata (Phase 1, optional) ──
-            priority: params.priority ?? 'P1',
-            scope: params.scope ?? 'general',
-            domain: params.domain,
-            suggestedRules: params.suggestedRules?.length ? params.suggestedRules : undefined,
-        };
-        this.principles.set(principleId, principle);
-        this.emitSync({
-            ts: now,
-            type: 'candidate_created',
-            data: {
-                painId: principle.source.painId,
-                painType: params.painType,
-                principleId,
-                trigger: params.triggerPattern,
-                action: params.action,
-                status: 'candidate',
-                evaluability,
-                detectorMetadata: isCompleteDetectorMetadata(params.detectorMetadata)
-                    ? structuredClone(params.detectorMetadata)
-                    : undefined,
-                abstractedPrinciple: params.abstractedPrinciple,
-            },
-        });
-        this.promote(principleId, 'diagnostician_generalized');
-        const synced = this.syncPrincipleToFile(principle);
-        if (!synced) {
-            SystemLogger.log(this.workspaceDir, 'PRINCIPLE_SYNC_WARN', `Principle ${principleId} created in memory but failed to sync to PRINCIPLES.md — manual file check required`);
-        }
-        // Add to ledger tree so the compiler can find this principle.
-        // Without this, newly diagnosed principles are invisible to the compiler
-        // (which reads tree.principles, not trainingStore or PRINCIPLES.md).
-        if (this.stateDir) {
-            try {
-                // Build a LedgerPrinciple (tree schema) from the evolution-types Principle.
-                // Tree schema Principle does NOT have: source, guardrails, contextTags, validation,
-                // feedbackScore, usageCount, activatedAt, abstractedPrinciple, valueMetrics.
-                // Pain source info is stored via derivedFromPainIds (which the compiler uses).
-                const ledgerPrinciple = {
-                    id: principle.id,
-                    version: principle.version,
-                    text: principle.text,
-                    triggerPattern: principle.trigger,
-                    action: principle.action,
-                    status: principle.status,
-                    evaluability: principle.evaluability,
-                    coreAxiomId: principle.coreAxiomId,
-                    priority: principle.priority ?? 'P1',
-                    scope: principle.scope ?? 'general',
-                    domain: principle.domain,
-                    suggestedRules: principle.suggestedRules?.map((r) => r.name),
-                    detectorMetadata: principle.detectorMetadata,
-                    deprecatedAt: principle.deprecatedAt,
-                    deprecatedReason: undefined,
-                    createdAt: principle.createdAt,
-                    updatedAt: now,
-                    // Ledger-only fields (derived from evolution-types Principle where applicable):
-                    valueScore: 0,
-                    adherenceRate: 0,
-                    painPreventedCount: 0,
-                    lastPainPreventedAt: undefined,
-                    derivedFromPainIds: [params.painId],
-                    ruleIds: [],
-                    conflictsWithPrincipleIds: [],
-                    supersedesPrincipleId: undefined,
-                };
-                addPrincipleToLedger(this.stateDir, ledgerPrinciple);
-                SystemLogger.log(this.workspaceDir, 'LEDGER_PRINCIPLE_ADDED', `Principle ${principleId} added to ledger tree`);
-                // Sync compile: attempt to compile immediately unless evaluability is manual_only.
-                // Failures are not fatal — heartbeat backfill will retry automatically.
-                if (evaluability !== 'manual_only' && this.stateDir) {
-                    const trajectory = TrajectoryRegistry.get(this.workspaceDir);
-                    const compiler = new PrincipleCompiler(this.stateDir, trajectory);
-                    try {
-                        const result = compiler.compileOne(principleId);
-                        if (result.success) {
-                            // Reset retry count on success
-                            updatePrinciple(this.stateDir, principleId, { compilationRetryCount: undefined });
-                            SystemLogger.log(this.workspaceDir, 'COMPILE_SUCCESS', `Principle ${principleId} compiled successfully`);
-                        }
-                        else {
-                            // Compile returned failure — queue for backfill retry (count=0 means "queued", Phase 2 will pick it up).
-                            // This gives exactly 5 total attempts before exhaustion (backfill: 0-4, sync: 0-4).
-                            updateRetryCount(this.stateDir, this.workspaceDir, principleId, 0);
-                            SystemLogger.log(this.workspaceDir, 'COMPILE_FAILED', `Principle ${principleId} compile failed: ${result.reason ?? 'unknown'} (attempt 1/5)`);
-                        }
-                    }
-                    catch (compileErr) {
-                        // Unexpected error during compilation — queue for backfill retry
-                        updateRetryCount(this.stateDir, this.workspaceDir, principleId, 0);
-                        SystemLogger.log(this.workspaceDir, 'COMPILE_FAILED', `Principle ${principleId} compile threw: ${String(compileErr)} (attempt 1/5)`);
-                    }
-                }
-            }
-            catch (err) {
-                SystemLogger.log(this.workspaceDir, 'LEDGER_PRINCIPLE_ADD_FAILED', `Failed to add ${principleId} to ledger tree: ${String(err)}`);
-            }
-        }
-        // #204: Write to training store so listEvaluablePrinciples() can find this principle
-        if (this.stateDir) {
-            try {
-                // Determine initial internalization status based on evaluability:
-                // - manual_only: prompt_only (can only be evaluated manually)
-                // - deterministic/weak_heuristic: needs_training (auto-evaluable, ready for training)
-                const initialStatus = evaluability === 'manual_only' ? 'prompt_only' : 'needs_training';
-                updateTrainingStore(this.stateDir, (trainingStore) => {
-                    trainingStore[principleId] = {
-                        principleId,
-                        evaluability,
-                        internalizationStatus: initialStatus,
-                        applicableOpportunityCount: 0,
-                        observedViolationCount: 0,
-                        complianceRate: 0,
-                        violationTrend: 0,
-                        generatedSampleCount: 0,
-                        approvedSampleCount: 0,
-                        includedTrainRunIds: [],
-                        deployedCheckpointIds: [],
-                    };
-                });
-                SystemLogger.log(this.workspaceDir, 'TRAINING_STORE_UPDATED', `Principle ${principleId} added to training store with evaluability=${evaluability}, internalizationStatus=${initialStatus}`);
-            }
-            catch (err) {
-                SystemLogger.log(this.workspaceDir, 'TRAINING_STORE_UPDATE_FAILED', `Failed to update training store for ${principleId}: ${String(err)}`);
-            }
-        }
-        SystemLogger.log(this.workspaceDir, 'PRINCIPLE_CREATED', `Principle ${principleId} created from diagnostician: "${params.triggerPattern.slice(0, 50)}..." [evaluability: ${evaluability}]`);
-        return principleId;
-    }
-    syncPrincipleToFile(principle) {
-        try {
-            withLock(this.principlesPath + '.lock', () => {
-                let content = '';
-                if (fs.existsSync(this.principlesPath)) {
-                    content = fs.readFileSync(this.principlesPath, 'utf8');
-                }
-                else {
-                    // Auto-create from template if missing
-                    const extensionRoot = PathResolver.getExtensionRoot();
-                    if (extensionRoot) {
-                        const templatePath = path.join(extensionRoot, 'templates', 'workspace', '.principles', 'PRINCIPLES.md');
-                        if (fs.existsSync(templatePath)) {
-                            content = fs.readFileSync(templatePath, 'utf8');
-                        }
-                    }
-                    if (!content) {
-                        // Create a minimal PRINCIPLES.md with just the header
-                        content = '# Principles\n\n<!-- 原则从这里开始记录 -->\n';
-                    }
-                    const parentDir = path.dirname(this.principlesPath);
-                    if (!fs.existsSync(parentDir)) {
-                        fs.mkdirSync(parentDir, { recursive: true });
-                    }
-                    atomicWriteFileSync(this.principlesPath, content);
-                    SystemLogger.log(this.workspaceDir, 'PRINCIPLES_CREATED', `Created PRINCIPLES.md`);
-                }
-                const header = `### ${principle.id}:`;
-                const existingIdx = content.indexOf(header);
-                const formatted = EvolutionReducerImpl.formatPrincipleForFile(principle, content);
-                if (existingIdx >= 0) {
-                    const nextPrincipleRe = /\n### [A-Za-z0-9_-]+:/g;
-                    nextPrincipleRe.lastIndex = existingIdx + header.length;
-                    const nextMatch = nextPrincipleRe.exec(content);
-                    const endIdx = nextMatch ? nextMatch.index : content.length;
-                    content = content.slice(0, existingIdx) + formatted + content.slice(endIdx);
-                }
-                else {
-                    const separator = content.trim().endsWith('<!-- 原则从这里开始记录 -->') ? '\n' : '\n\n';
-                    content = content + separator + formatted;
-                }
-                atomicWriteFileSync(this.principlesPath, content);
-                SystemLogger.log(this.workspaceDir, 'PRINCIPLE_SYNCED', `Principle ${principle.id} synced to PRINCIPLES.md`);
-            }, { lockStaleMs: 10000 });
-            return true;
-        }
-        catch (e) {
-            SystemLogger.log(this.workspaceDir, 'PRINCIPLE_SYNC_ERROR', `Failed to sync ${principle.id} to PRINCIPLES.md: ${String(e)}`);
-            return false;
-        }
-    }
-    static detectPrincipleLanguage(content) {
-        if (!content)
-            return 'zh';
-        const zhMarkers = ['原则', '触发', '必须', '禁止', '验证', '例外', '来源'];
-        const enMarkers = ['Trigger', 'Constraint', 'Must', 'Forbidden', 'Verification', 'Exceptions', 'Source'];
-        let zhCount = 0;
-        let enCount = 0;
-        for (const m of zhMarkers) {
-            if (content.includes(m))
-                zhCount++;
-        }
-        for (const m of enMarkers) {
-            if (content.includes(m))
-                enCount++;
-        }
-        return zhCount >= enCount ? 'zh' : 'en';
-    }
-    static formatPrincipleForFile(principle, existingContent) {
-        const lang = EvolutionReducerImpl.detectPrincipleLanguage(existingContent);
-        const title = principle.abstractedPrinciple
-            ? (principle.abstractedPrinciple.length > 60 ? principle.abstractedPrinciple.slice(0, 57) + '...' : principle.abstractedPrinciple)
-            : (principle.text.length > 60 ? principle.text.slice(0, 57) + '...' : principle.text);
-        const source = principle.source.painId ? `pain_id: ${principle.source.painId} / ${principle.source.timestamp?.slice(0, 10) ?? 'unknown'}` : 'unknown';
-        if (lang === 'zh') {
-            return [
-                `### ${principle.id}: ${title}`,
-                `- **Trigger**: ${principle.trigger}`,
-                `- **Constraint (Must)**: ${principle.action}`,
-                `- **Constraint (Forbidden)**: 禁止违反此原则的行为`,
-                `- **Verification**: 操作前检查是否遵循此原则`,
-                `- **Exceptions**: 无`,
-                `- **Source**: ${source}`,
-                '',
-            ].join('\n');
-        }
-        return [
-            `### ${principle.id}: ${title}`,
-            `- **Trigger**: ${principle.trigger}`,
-            `- **Constraint (Must)**: ${principle.action}`,
-            `- **Constraint (Forbidden)**: Do not violate this principle`,
-            `- **Verification**: Check compliance before acting`,
-            `- **Exceptions**: None`,
-            `- **Source**: ${source}`,
-            '',
-        ].join('\n');
-    }
-    getStats() {
-        return {
-            candidateCount: this.getCandidatePrinciples().length,
-            probationCount: this.getProbationPrinciples().length,
-            activeCount: this.getActivePrinciples().length,
-            deprecatedCount: this.getByStatus('deprecated').length,
-            lastPromotedAt: this.lastPromotedAt,
-        };
-    }
-    ensureDirs() {
-        fs.mkdirSync(path.dirname(this.streamPath), { recursive: true });
-        fs.mkdirSync(path.dirname(this.lockTargetPath), { recursive: true });
-        fs.mkdirSync(path.dirname(this.blacklistPath), { recursive: true });
-    }
-    loadFromStream() {
-        if (!fs.existsSync(this.streamPath))
-            return;
-        const raw = fs.readFileSync(this.streamPath, 'utf8').trim();
-        if (!raw)
-            return;
-        this.isReplaying = true;
-        for (const line of raw.split('\n')) {
-            try {
-                const event = JSON.parse(line);
-                this.applyEvent(event);
-            }
-            catch (e) {
-                SystemLogger.log(this.workspaceDir, 'EVOLUTION_WARN', `skip malformed event line: ${String(e)}`);
-            }
-        }
-        this.isReplaying = false;
-    }
-    applyEvent(event) {
-        this.memoryEvents.push(event);
-        switch (event.type) {
-            case 'pain_detected':
-                this.updateFailureStreakFromPain(event.data);
-                if (!this.isReplaying) {
-                    this.onPainDetected(event.data, event.ts);
-                }
-                // _painCallbacks dispatch removed (PRI-451 Wave 1): no callback was ever
-                // registered via .on() (also removed). The pain_detected → PainSignalBridge
-                // bridge flows through emitPainDetectedEvent (hooks/pain.ts), not here.
-                return;
-            case 'candidate_created':
-                this.onCandidateCreated(event.data, event.ts);
-                return;
-            case 'principle_promoted':
-                this.onPrinciplePromoted(event.data, event.ts);
-                return;
-            case 'principle_deprecated':
-                this.onPrincipleDeprecated(event.data, event.ts);
-                return;
-            case 'principle_rolled_back':
-                this.onPrincipleRolledBack(event.data, event.ts);
-                return;
-            case 'circuit_breaker_opened':
-            case 'legacy_import':
-                return;
-            default:
-                return;
-        }
-    }
-    onCandidateCreated(data, ts) {
-        const existing = this.principles.get(data.principleId);
-        if (existing) {
-            existing.status = 'candidate';
-            // Apply evaluability from event if present (supports event replay)
-            if (data.evaluability) {
-                existing.evaluability = data.evaluability;
-            }
-            if (data.detectorMetadata) {
-                existing.detectorMetadata = structuredClone(data.detectorMetadata);
-            }
-            // Restore abstractedPrinciple from event if present
-            if (data.abstractedPrinciple) {
-                existing.abstractedPrinciple = data.abstractedPrinciple;
-            }
-            if (data.coreAxiomId) {
-                existing.coreAxiomId = data.coreAxiomId;
-            }
-            return;
-        }
-        const principle = {
-            id: data.principleId,
-            version: 1,
-            text: `When ${data.trigger}, then ${data.action}.`,
-            source: {
-                painId: data.painId,
-                painType: data.painType ?? 'tool_failure',
-                timestamp: ts,
-            },
-            trigger: data.trigger,
-            action: data.action,
-            contextTags: [],
-            validation: { successCount: 0, conflictCount: 0 },
-            status: 'candidate',
-            feedbackScore: 0,
-            usageCount: 0,
-            createdAt: ts,
-            // Evaluability defaults to 'manual_only' for replayed events without the field
-            evaluability: data.evaluability ?? 'manual_only',
-            detectorMetadata: data.detectorMetadata
-                ? structuredClone(data.detectorMetadata)
-                : undefined,
-            // Restore abstractedPrinciple from event if present
-            abstractedPrinciple: data.abstractedPrinciple,
-            coreAxiomId: data.coreAxiomId,
-        };
-        this.principles.set(principle.id, principle);
-    }
-    onPrinciplePromoted(data, ts) {
-        const p = this.principles.get(data.principleId);
-        if (!p)
-            return;
-        p.status = data.to;
-        if (data.to === 'active') {
-            p.activatedAt = ts;
-        }
-        this.lastPromotedAt = ts;
-    }
-    onPrincipleDeprecated(data, ts) {
-        const p = this.principles.get(data.principleId);
-        if (!p)
-            return;
-        p.status = 'deprecated';
-        p.deprecatedAt = ts;
-    }
-    onPrincipleRolledBack(data, ts) {
-        const p = this.principles.get(data.principleId);
-        if (p) {
-            p.status = 'deprecated';
-            p.deprecatedAt = ts;
-        }
-        this.persistBlacklist({
-            painId: data.relatedPainId,
-            pattern: data.blacklistPattern,
-            reason: data.reason,
-            rolledBackAt: ts,
-        });
-    }
-    onPainDetected(data, _eventTs) {
-        const trigger = String(data.reason ?? data.source ?? 'unknown trigger');
-        // 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)) {
-            return;
-        }
-        if (this.isBlacklisted(data.painId, trigger)) {
-            return;
-        }
-        // 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: 'pain_recorded',
-            data: {
-                painId: data.painId,
-                painType: data.painType,
-                source: data.source,
-                reason: data.reason,
-                sessionId: data.sessionId,
-                agentId: data.agentId,
-            },
-        });
-        // 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;
-            if (next >= CIRCUIT_BREAKER_THRESHOLD) {
-                const nextRetryAt = new Date(Date.now() + 15 * 60 * 1000).toISOString();
-                this.emitSync({
-                    ts: new Date().toISOString(),
-                    type: 'circuit_breaker_opened',
-                    data: {
-                        taskId: key,
-                        painId: data.painId,
-                        failCount: next,
-                        reason: 'Max retries exceeded',
-                        requireHuman: true,
-                        nextRetryAt,
-                    },
-                });
-            }
-        }
-    }
-    updateFailureStreakFromPain(data) {
-        if (data.painType !== 'subagent_error')
-            return;
-        const key = String(data.taskId ?? data.source ?? 'subagent');
-        const next = (this.failureStreak.get(key) ?? 0) + 1;
-        this.failureStreak.set(key, next);
-    }
-    nextPrincipleId() {
-        const ids = [...this.principles.keys()]
-            .map((id) => Number(id.replace(/^P_/, '')))
-            .filter((n) => Number.isFinite(n));
-        const next = (ids.length ? Math.max(...ids) : 0) + 1;
-        return `P_${String(next).padStart(3, '0')}`;
-    }
-    getByStatus(status) {
-        return [...this.principles.values()].filter((p) => p.status === status);
-    }
-    sweepExpiredProbation() {
-        const now = Date.now();
-        const maxAgeMs = PROBATION_MAX_AGE_DAYS * 24 * 60 * 60 * 1000;
-        // Use getByStatus directly to avoid infinite recursion with getProbationPrinciples()
-        for (const p of this.getByStatus('probation')) {
-            const age = now - new Date(p.createdAt).getTime();
-            if (age > maxAgeMs) {
-                this.deprecate(p.id, 'probation_expired');
-            }
-        }
-    }
-    persistBlacklist(entry) {
-        const list = this.loadBlacklist();
-        list.push(entry);
-        atomicWriteFileSync(this.blacklistPath, JSON.stringify(list, null, 2));
-    }
-    loadBlacklist() {
-        if (!fs.existsSync(this.blacklistPath))
-            return [];
-        try {
-            return JSON.parse(fs.readFileSync(this.blacklistPath, 'utf8'));
-        }
-        catch (e) {
-            SystemLogger.log(this.workspaceDir, 'EVOLUTION_WARN', `failed to parse blacklist: ${String(e)}`);
-            return [];
-        }
-    }
-    isBlacklisted(painId, trigger) {
-        return this.loadBlacklist().some((entry) => (entry.painId && entry.painId === painId) ||
-            (entry.pattern && trigger.includes(entry.pattern)));
-    }
-}
-export function stableContentHash(input) {
-    return crypto.createHash('sha1').update(input).digest('hex');
-}