principles-disciple 1.126.0 → 1.128.0

package/src/core/evolution-reducer.ts

@@ -1,891 +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 type {
-  CandidateCreatedData,
-  EvolutionLoopEvent,
-  PainDetectedData,
-  Principle,
-  PrincipleDeprecatedData,
-  PrincipleDetectorSpec,
-  PrincipleEvaluatorLevel,
-  PrinciplePromotedData,
-  PrincipleRolledBackData,
-  PrincipleStatus,
-  PrincipleSuggestedRule,
-} from './evolution-types.js';
-import { isCompleteDetectorMetadata } from './evolution-types.js';
-import { updateTrainingStore, addPrincipleToLedger, updatePrinciple, type LedgerPrinciple } 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: string, workspaceDir: string, principleId: string, count: number): void {
-  try {
-    updatePrinciple(stateDir, principleId, { compilationRetryCount: count });
-  } catch (err) {
-    SystemLogger.log(workspaceDir, 'RETRY_COUNT_UPDATE_FAILED',
-      `Failed to update compilationRetryCount for ${principleId}: ${String(err)}`);
-  }
-}
-
-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;
-  /**
-   * 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;
-    evaluability?: PrincipleEvaluatorLevel;
-    detectorMetadata?: PrincipleDetectorSpec;
-    /** Highly abstracted principle text — if absent, falls back to action-based title */
-    abstractedPrinciple?: string;
-    /** Associated core axiom (e.g., "T-01") */
-    coreAxiomId?: string;
-    // ── Principle-Tree metadata (Phase 1, optional) ──
-    priority?: 'P0' | 'P1' | 'P2';
-    scope?: 'general' | 'domain';
-    domain?: string;
-    suggestedRules?: PrincipleSuggestedRule[];
-  }): string | null;
-  getStats(): {
-    candidateCount: number;
-    probationCount: number;
-    activeCount: number;
-    deprecatedCount: number;
-    lastPromotedAt: string | null;
-  };
-}
- 
-
-const PROBATION_SUCCESS_THRESHOLD = 3;
-const CIRCUIT_BREAKER_THRESHOLD = 3;
-const PROBATION_MAX_AGE_DAYS = 30;
-
-export class EvolutionReducerImpl implements EvolutionReducer {
-  private readonly streamPath: string;
-  private readonly lockTargetPath: string;
-  private readonly blacklistPath: string;
-  private readonly principlesPath: string;
-  private readonly workspaceDir: string;
-  private readonly stateDir: string | undefined;
-  private readonly memoryEvents: EvolutionLoopEvent[] = [];
-  private readonly principles = new Map<string, Principle>();
-  private readonly failureStreak = new Map<string, number>();
-  private lastPromotedAt: string | null = null;
-  private isReplaying = false;
-  /** Registered pain_detected callbacks (e.g., PainSignalBridge). */
-  private readonly _painCallbacks: Array<(event: EvolutionLoopEvent) => void> = [];
-
-  constructor(opts: { workspaceDir: string; stateDir?: string }) {
-    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: EvolutionLoopEvent): void {
-    this.emitSync(event);
-  }
-
-  emitSync(event: EvolutionLoopEvent): void {
-    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
-  }
-
-  /**
-   * Register a callback for 'pain_detected' events.
-   * The callback is invoked synchronously within emitSync() after applyEvent completes.
-   * HG-4: Callbacks are fire-and-forget from the emitSync perspective.
-   */
-  on(callback: (event: EvolutionLoopEvent) => void): void {
-    this._painCallbacks.push(callback);
-  }
-
-  getEventLog(): EvolutionLoopEvent[] {
-    return [...this.memoryEvents];
-  }
-
-  getCandidatePrinciples(): Principle[] {
-    return this.getByStatus('candidate');
-  }
-
-  getProbationPrinciples(): Principle[] {
-    // Lazy cleanup: sweep expired probation principles on access
-    this.sweepExpiredProbation();
-    return this.getByStatus('probation');
-  }
-
-  getActivePrinciples(): Principle[] {
-    return this.getByStatus('active');
-  }
-
-  getPrincipleById(id: string): Principle | null {
-    return this.principles.get(id) ?? null;
-  }
-
-  promote(principleId: string, reason = 'manual'): void {
-    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) as PrincipleStatus;
-    const event: EvolutionLoopEvent = {
-      ts: new Date().toISOString(),
-      type: 'principle_promoted',
-      data: {
-        principleId,
-        from: p.status,
-        to: toStatus,
-        reason,
-        successCount: p.validation.successCount,
-      },
-    };
-    this.emitSync(event);
-  }
-
-  deprecate(principleId: string, reason: string): void {
-    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: string, reason: string): void {
-    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: string, success: boolean): void {
-    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: {
-    painId: string;
-    painType: 'tool_failure' | 'subagent_error' | 'user_frustration';
-    triggerPattern: string;
-    action: string;
-    source: string;
-    evaluability?: PrincipleEvaluatorLevel;
-    detectorMetadata?: PrincipleDetectorSpec;
-    abstractedPrinciple?: string;
-    coreAxiomId?: string;
-    priority?: 'P0' | 'P1' | 'P2';
-    scope?: 'general' | 'domain';
-    domain?: string;
-    suggestedRules?: PrincipleSuggestedRule[];
-  }): string | null {
-    // 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: PrincipleEvaluatorLevel = 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: 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: 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;
-  }
-
-  private syncPrincipleToFile(principle: Principle): boolean {
-    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;
-    }
-  }
-
-  private static detectPrincipleLanguage(content: string): 'zh' | 'en' {
-    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';
-  }
-
-  private static formatPrincipleForFile(principle: Principle, existingContent: string): string {
-    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(): {
-    candidateCount: number;
-    probationCount: number;
-    activeCount: number;
-    deprecatedCount: number;
-    lastPromotedAt: string | null;
-  } {
-    return {
-      candidateCount: this.getCandidatePrinciples().length,
-      probationCount: this.getProbationPrinciples().length,
-      activeCount: this.getActivePrinciples().length,
-      deprecatedCount: this.getByStatus('deprecated').length,
-      lastPromotedAt: this.lastPromotedAt,
-    };
-  }
-
-  private ensureDirs(): void {
-    fs.mkdirSync(path.dirname(this.streamPath), { recursive: true });
-    fs.mkdirSync(path.dirname(this.lockTargetPath), { recursive: true });
-    fs.mkdirSync(path.dirname(this.blacklistPath), { recursive: true });
-  }
-
-  private loadFromStream(): void {
-    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) as EvolutionLoopEvent;
-        this.applyEvent(event);
-      } catch (e) {
-        SystemLogger.log(this.workspaceDir, 'EVOLUTION_WARN', `skip malformed event line: ${String(e)}`);
-      }
-    }
-    this.isReplaying = false;
-  }
-
-  private applyEvent(event: EvolutionLoopEvent): void {
-    this.memoryEvents.push(event);
-
-    switch (event.type) {
-      case 'pain_detected':
-        this.updateFailureStreakFromPain(event.data);
-        if (!this.isReplaying) {
-          this.onPainDetected(event.data, event.ts);
-        }
-        // PainSignalBridge subscriptions: invoke registered callbacks (fire-and-forget)
-        for (const cb of this._painCallbacks) {
-          try {
-            cb(event);
-          } catch {
-            // Keep the evolution loop resilient — callback errors must not propagate
-          }
-        }
-        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;
-    }
-  }
-
-  private onCandidateCreated(data: CandidateCreatedData, ts: string): void {
-    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: 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);
-  }
-
-  private onPrinciplePromoted(data: PrinciplePromotedData, ts: string): void {
-    const p = this.principles.get(data.principleId);
-    if (!p) return;
-    p.status = data.to;
-    if (data.to === 'active') {
-      p.activatedAt = ts;
-    }
-    this.lastPromotedAt = ts;
-  }
-
-  private onPrincipleDeprecated(data: PrincipleDeprecatedData, ts: string): void {
-    const p = this.principles.get(data.principleId);
-    if (!p) return;
-    p.status = 'deprecated';
-    p.deprecatedAt = ts;
-  }
-
-  private onPrincipleRolledBack(data: PrincipleRolledBackData, ts: string): void {
-    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,
-    });
-  }
-
-   
-  private onPainDetected(data: PainDetectedData, _eventTs: string): void {
-    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,
-          },
-        });
-      }
-    }
-  }
-
-  private updateFailureStreakFromPain(data: PainDetectedData): void {
-    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);
-  }
-
-  private nextPrincipleId(): string {
-    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')}`;
-  }
-
-  private getByStatus(status: PrincipleStatus): Principle[] {
-    return [...this.principles.values()].filter((p) => p.status === status);
-  }
-
-  private sweepExpiredProbation(): void {
-    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');
-      }
-    }
-  }
-
-  private persistBlacklist(entry: { painId?: string; pattern?: string; reason: string; rolledBackAt: string }): void {
-    const list = this.loadBlacklist();
-    list.push(entry);
-    atomicWriteFileSync(this.blacklistPath, JSON.stringify(list, null, 2));
-  }
-
-  private loadBlacklist(): { painId?: string; pattern?: string; reason: string; rolledBackAt: string }[] {
-    if (!fs.existsSync(this.blacklistPath)) return [];
-    try {
-      return JSON.parse(fs.readFileSync(this.blacklistPath, 'utf8')) as {
-        painId?: string;
-        pattern?: string;
-        reason: string;
-        rolledBackAt: string;
-      }[];
-    } catch (e) {
-      SystemLogger.log(this.workspaceDir, 'EVOLUTION_WARN', `failed to parse blacklist: ${String(e)}`);
-      return [];
-    }
-  }
-
-  private isBlacklisted(painId: string, trigger: string): boolean {
-    return this.loadBlacklist().some((entry) =>
-      (entry.painId && entry.painId === painId) ||
-      (entry.pattern && trigger.includes(entry.pattern))
-    );
-  }
-}
-
-export function stableContentHash(input: string): string {
-  return crypto.createHash('sha1').update(input).digest('hex');
-}