principles-disciple 1.11.0 → 1.13.0

package/src/core/control-ui-db.ts

@@ -34,40 +34,40 @@ export interface ControlUiDatabaseOptions {
 }
 
 export interface RecentThinkingContext {
-  toolCalls: Array<{
+  toolCalls: {
     id: number;
     toolName: string;
     outcome: 'success' | 'failure' | 'blocked';
     errorType: string | null;
     errorMessage: string | null;
     createdAt: string;
-  }>;
-  painEvents: Array<{
+  }[];
+  painEvents: {
     id: number;
     source: string;
     score: number;
     reason: string | null;
     createdAt: string;
-  }>;
-  gateBlocks: Array<{
+  }[];
+  gateBlocks: {
     id: number;
     toolName: string;
     reason: string;
     filePath: string | null;
     createdAt: string;
-  }>;
-  userCorrections: Array<{
+  }[];
+  userCorrections: {
     id: number;
     correctionCue: string | null;
     rawExcerpt: string | null;
     createdAt: string;
-  }>;
-  principleEvents: Array<{
+  }[];
+  principleEvents: {
     id: number;
     principleId: string | null;
     eventType: string;
     createdAt: string;
-  }>;
+  }[];
 }
 
 const DEFAULT_BUSY_TIMEOUT_MS = 5000;
@@ -274,6 +274,25 @@ export class ControlUiDatabase {
     return this.db.prepare(sql).get(...params) as T | undefined;
   }
 
+  /**
+   * Execute SQL statement that does not return rows (DDL, CREATE TABLE, etc.).
+   *
+   * Returns: void (executes directly)
+   * Not for: SELECT queries (use all() or get() instead)
+   */
+  execute(sql: string): void {
+    this.db.exec(sql);
+  }
+
+  /**
+   * Execute a parameterized write statement (INSERT, UPDATE, DELETE).
+   */
+  run(sql: string, ...params: unknown[]): void {
+    this.withWrite(() => {
+      this.db.prepare(sql).run(...params);
+    });
+  }
+
   restoreRawText(inlineText?: string | null, blobRef?: string | null): string {
     if (inlineText) return inlineText;
     if (!blobRef) return '';

package/src/core/detection-funnel.ts

@@ -12,9 +12,11 @@ export interface DetectionResult {
  * A simple LRU Cache implementation using Map.
  */
 class SimpleLRU<K, V> {
-    private cache: Map<K, V>;
-    constructor(private maxSize: number = 100) {
+    private readonly cache: Map<K, V>;
+    private readonly maxSize: number;
+    constructor(maxSize = 100) {
         this.cache = new Map();
+        this.maxSize = maxSize;
     }
 
     get(key: K): V | undefined {
@@ -45,10 +47,13 @@ class SimpleLRU<K, V> {
  * Orchestrates the three-layer detection funnel for pain signals.
  */
 export class DetectionFunnel {
-    private cache = new SimpleLRU<string, { detected: boolean; severity?: number }>(100);
+    private readonly cache = new SimpleLRU<string, { detected: boolean; severity?: number }>(100);
     private asyncQueue: string[] = [];
+    private readonly dictionary: PainDictionary;
 
-    constructor(private dictionary: PainDictionary) {}
+    constructor(dictionary: PainDictionary) {
+        this.dictionary = dictionary;
+    }
 
     /**
      * Detects pain in the given text using L1 (Exact), L2 (Cache), and L3 (Async).
@@ -70,7 +75,7 @@ export class DetectionFunnel {
         }
 
         // --- Layer 2: LRU Cache (Sync) ---
-        const hash = this.computeHash(text);
+        const hash = DetectionFunnel.computeHash(text);
         const cached = this.cache.get(hash);
         if (cached) {
             return {
@@ -89,7 +94,7 @@ export class DetectionFunnel {
         };
     }
 
-    private computeHash(text: string): string {
+    private static computeHash(text: string): string {
         return createHash('sha256').update(text).digest('hex');
     }
 
@@ -104,7 +109,7 @@ export class DetectionFunnel {
      * Internal method for the worker to update the cache after a semantic hit.
      */
     updateCache(text: string, result: { detected: boolean; severity?: number }): void {
-        const hash = this.computeHash(text);
+        const hash = DetectionFunnel.computeHash(text);
         this.cache.set(hash, result);
     }
 

package/src/core/diagnostician-task-store.ts

@@ -0,0 +1,156 @@
+/**
+ * Diagnostician Task Store
+ *
+ * Manages diagnostician task prompts stored in `.state/diagnostician_tasks.json`.
+ * This replaces the previous HEARTBEAT.md approach which had a race condition:
+ * the main session heartbeat would overwrite HEARTBEAT.md while the diagnostician
+ * was still running, causing the task prompt to be lost.
+ *
+ * This store uses file-level locking via withLockAsync to prevent concurrent writes.
+ *
+ * Design:
+ * - Each task is written once by the evolution worker (when pain is detected)
+ * - The prompt hook reads tasks during heartbeat triggers and injects them
+ * - The diagnostician agent completes the task and writes marker files
+ * - The worker detects marker files and extracts principles
+ *
+ * File format:
+ * {
+ *   "tasks": {
+ *     "<task-id>": {
+ *       "prompt": "...full diagnostician prompt...",
+ *       "createdAt": "ISO timestamp",
+ *       "status": "pending" | "completed"
+ *     }
+ *   }
+ * }
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { withLockAsync } from '../utils/file-lock.js';
+
+const DIAGNOSTICIAN_TASKS_FILE = 'diagnostician_tasks.json';
+
+export interface DiagnosticianTask {
+  prompt: string;
+  createdAt: string;
+  status: 'pending' | 'completed';
+}
+
+export interface DiagnosticianTaskStore {
+  tasks: Record<string, DiagnosticianTask>;
+}
+
+/**
+ * Resolve the diagnostician tasks file path.
+ */
+function resolveTasksPath(stateDir: string): string {
+  return path.join(stateDir, DIAGNOSTICIAN_TASKS_FILE);
+}
+
+/**
+ * Read the diagnostician task store from disk.
+ * Returns an empty store if the file doesn't exist or is malformed.
+ */
+function readTaskStore(stateDir: string): DiagnosticianTaskStore {
+  const filePath = resolveTasksPath(stateDir);
+  if (!fs.existsSync(filePath)) {
+    return { tasks: {} };
+  }
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.tasks === 'object') {
+      return parsed as DiagnosticianTaskStore;
+    }
+    return { tasks: {} };
+  } catch {
+    return { tasks: {} };
+  }
+}
+
+/**
+ * Add a new diagnostician task to the store.
+ * Overwrites if a task with the same ID already exists.
+ * Read-modify-write is performed atomically inside the file lock.
+ */
+export async function addDiagnosticianTask(
+  stateDir: string,
+  taskId: string,
+  prompt: string,
+): Promise<void> {
+  const filePath = resolveTasksPath(stateDir);
+  await withLockAsync(filePath, async () => {
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: function defined later in file, hoisting pattern
+    const store = readTaskStoreSync(filePath);
+    store.tasks[taskId] = {
+      prompt,
+      createdAt: new Date().toISOString(),
+      status: 'pending',
+    };
+    const tmpPath = filePath + '.tmp';
+    fs.writeFileSync(tmpPath, JSON.stringify(store, null, 2), 'utf8');
+    fs.renameSync(tmpPath, filePath);
+  });
+}
+
+/**
+ * Mark a task as completed and remove it from the store.
+ * Read-modify-write is performed atomically inside the file lock.
+ */
+export async function completeDiagnosticianTask(
+  stateDir: string,
+  taskId: string,
+): Promise<void> {
+  const filePath = resolveTasksPath(stateDir);
+  await withLockAsync(filePath, async () => {
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: function defined later in file, hoisting pattern
+    const store = readTaskStoreSync(filePath);
+    delete store.tasks[taskId];
+    const tmpPath = filePath + '.tmp';
+    fs.writeFileSync(tmpPath, JSON.stringify(store, null, 2), 'utf8');
+    fs.renameSync(tmpPath, filePath);
+  });
+}
+
+/**
+ * Synchronous read without lock — for use INSIDE a lock context.
+ */
+ 
+function readTaskStoreSync(filePath: string): DiagnosticianTaskStore {
+  if (!fs.existsSync(filePath)) {
+    return { tasks: {} };
+  }
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.tasks === 'object') {
+      return parsed as DiagnosticianTaskStore;
+    }
+    return { tasks: {} };
+  } catch {
+    return { tasks: {} };
+  }
+}
+
+/**
+ * Get all pending diagnostician tasks.
+ * Returns an array of [taskId, task] pairs.
+ */
+export function getPendingDiagnosticianTasks(
+  stateDir: string,
+): { id: string; task: DiagnosticianTask }[] {
+  const store = readTaskStore(stateDir);
+  return Object.entries(store.tasks)
+    .filter(([, task]) => task.status === 'pending')
+    .map(([id, task]) => ({ id, task }));
+}
+
+/**
+ * Check if there are any pending diagnostician tasks.
+ */
+export function hasPendingDiagnosticianTasks(stateDir: string): boolean {
+  const store = readTaskStore(stateDir);
+  return Object.values(store.tasks).some(t => t.status === 'pending');
+}

package/src/core/dictionary.ts

@@ -62,10 +62,10 @@ const DEFAULT_RULES: Record<string, PainRule> = {
 
 export class PainDictionary {
     private data: PainDictionaryData = { rules: {} };
-    private filePath: string;
-    private compiledRegex: Map<string, RegExp> = new Map();
+    private readonly filePath: string;
+    private readonly compiledRegex: Map<string, RegExp> = new Map();
 
-    constructor(private stateDir: string) {
+    constructor(private readonly stateDir: string) {
         this.filePath = path.join(stateDir, 'pain_dictionary.json');
     }
 
@@ -73,7 +73,7 @@ export class PainDictionary {
         if (fs.existsSync(this.filePath)) {
             try {
                 this.data = JSON.parse(fs.readFileSync(this.filePath, 'utf8'));
-            } catch (e) {
+            } catch {
                 console.error('[PD] Failed to parse pain_dictionary.json, using defaults.');
                 this.data = { rules: { ...DEFAULT_RULES } };
             }

package/src/core/empathy-keyword-matcher.ts

@@ -14,13 +14,13 @@
 
 import * as fs from 'fs';
 import * as path from 'path';
-import {
+import type {
   EmpathyKeywordStore,
   EmpathyKeywordEntry,
   EmpathyKeywordStats,
   EmpathyMatchResult,
-  EmpathyKeywordConfig,
-  SeedKeywordEntry,
+  EmpathyKeywordConfig} from './empathy-types.js';
+import {
   EMPATHY_SEED_KEYWORDS,
   DEFAULT_EMPATHY_KEYWORD_CONFIG,
   scoreToSeverity,
@@ -80,6 +80,7 @@ export function loadKeywordStore(stateDir: string, language?: 'zh' | 'en'): Empa
   try {
     if (!fs.existsSync(filePath)) {
       const store = createDefaultKeywordStore(language);
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: function defined later in file, hoisting pattern
       saveKeywordStore(stateDir, store);
       return store;
     }
@@ -91,6 +92,7 @@ export function loadKeywordStore(stateDir: string, language?: 'zh' | 'en'): Empa
     if (!parsed.terms || !parsed.stats || !parsed.version) {
       console.warn('[PD:Empathy] Invalid keyword store format, creating default');
       const store = createDefaultKeywordStore(language);
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: function defined later in file, hoisting pattern
       saveKeywordStore(stateDir, store);
       return store;
     }
@@ -99,6 +101,7 @@ export function loadKeywordStore(stateDir: string, language?: 'zh' | 'en'): Empa
   } catch (e) {
     console.warn(`[PD:Empathy] Failed to load keyword store: ${e}`);
     const store = createDefaultKeywordStore(language);
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: function defined later in file, hoisting pattern
     saveKeywordStore(stateDir, store);
     return store;
   }
@@ -107,6 +110,7 @@ export function loadKeywordStore(stateDir: string, language?: 'zh' | 'en'): Empa
 /**
  * Saves the keyword store to disk.
  */
+ 
 export function saveKeywordStore(stateDir: string, store: EmpathyKeywordStore): void {
   const filePath = path.join(stateDir, KEYWORD_STORE_FILE);
   const dir = path.dirname(filePath);

package/src/core/empathy-types.ts

@@ -178,8 +178,8 @@ export interface EmpathyKeywordConfig {
 export const DEFAULT_EMPATHY_KEYWORD_CONFIG: EmpathyKeywordConfig = {
   matchThreshold: 0.3,
   maxTermsPerMessage: 5,
-  optimizationIntervalTurns: 100,
-  optimizationIntervalMs: 24 * 60 * 60 * 1000, // 24 hours
+  optimizationIntervalTurns: 50,
+  optimizationIntervalMs: 6 * 60 * 60 * 1000, // 6 hours
   penaltyMild: 10,
   penaltyModerate: 25,
   penaltySevere: 40,
@@ -216,3 +216,14 @@ export function severityToPenalty(
     case 'severe': return config.penaltySevere;
   }
 }
+
+/**
+ * Normalizes various severity string inputs to the canonical empathy severity type.
+ * Handles common aliases: 'high' → 'severe', 'medium' → 'moderate'.
+ */
+export function normalizeSeverity(input?: string): 'mild' | 'moderate' | 'severe' {
+  const normalized = (input || '').toLowerCase();
+  if (normalized === 'severe' || normalized === 'high') return 'severe';
+  if (normalized === 'moderate' || normalized === 'medium') return 'moderate';
+  return 'mild';
+}

package/src/core/event-log.ts

@@ -29,7 +29,7 @@ export class EventLog {
   private readonly statsFile: string;
   private readonly logger?: PluginLogger;
   
-  private statsCache: Map<string, DailyStats> = new Map();
+  private readonly statsCache: Map<string, DailyStats> = new Map();
   private eventBuffer: EventLogEntry[] = [];
   private readonly maxBufferSize = 20;
   private readonly flushIntervalMs = 30000;
@@ -66,9 +66,12 @@ export class EventLog {
     this.record('rule_promotion', 'promoted', undefined, data);
   }
   
-  recordHookExecution(data: HookExecutionEventData): void {
+  recordHookExecution(data: HookExecutionEventData, opts?: { flushImmediately?: boolean }): void {
     const category = data.error ? 'failure' : 'success';
     this.record('hook_execution', category, undefined, data);
+    if (opts?.flushImmediately) {
+      this.flushEvents();
+    }
   }
   
   recordGateBlock(sessionId: string | undefined, data: GateBlockEventData): void {
@@ -104,6 +107,7 @@ export class EventLog {
     this.record('warn', 'failure', sessionId, { message, ...context });
   }
   
+  // eslint-disable-next-line @typescript-eslint/max-params -- Reason: event record requires type + category + session + data - refactoring would break internal API
   private record(
     type: EventType, 
     category: EventCategory, 
@@ -130,6 +134,7 @@ export class EventLog {
     }
   }
 
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- Reason: utility method doesn't require this - pure function
   private formatDate(date: Date): string {
     return date.toISOString().split('T')[0];
   }
@@ -155,7 +160,8 @@ export class EventLog {
     }
 
     if (entry.type === 'tool_call') {
-      const data = entry.data as unknown as ToolCallEventData;
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars -- Reason: data used for type narrowing only, actual fields accessed via stats
+      const _data = entry.data as unknown as ToolCallEventData;
       stats.tools.total++;
       if (entry.category === 'success') stats.tools.success++;
       else stats.tools.failure++;
@@ -237,6 +243,7 @@ export class EventLog {
     return this.eventBuffer.map((entry) => ({ ...entry, data: { ...entry.data } }));
   }
 
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- Reason: getEventDedupKey is a pure key-generation function, no this reference needed
   private getEventDedupKey(entry: EventLogEntry): string {
     const eventId = typeof (entry.data as { eventId?: unknown } | undefined)?.eventId === 'string'
       ? String((entry.data as { eventId?: string }).eventId)
@@ -452,6 +459,7 @@ export class EventLog {
    * Rollback an empathy event by ID.
    * Returns the rolled back score, or 0 if event not found.
    */
+  // eslint-disable-next-line @typescript-eslint/max-params -- Reason: rollback requires eventId + sessionId + reason + triggeredBy - refactoring would break API
   rollbackEmpathyEvent(eventId: string, sessionId: string | undefined, reason: string, triggeredBy: 'user_command' | 'natural_language' | 'system'): number {
     const allEvents = this.getMergedEvents();
     let foundEvent: { entry: EventLogEntry; data: PainSignalEventData } | null = null;
@@ -459,7 +467,7 @@ export class EventLog {
     for (const entry of allEvents) {
       if (entry.type === 'pain_signal') {
         const data = entry.data as unknown as PainSignalEventData;
-        if ((entry.data as any).eventId === eventId && data.source === 'user_empathy') {
+        if (data.eventId === eventId && data.source === 'user_empathy') {
           foundEvent = { entry, data };
           break;
         }
@@ -494,7 +502,7 @@ export class EventLog {
       if (entry.sessionId === sessionId && entry.type === 'pain_signal') {
         const data = entry.data as unknown as PainSignalEventData;
         if (data.source === 'user_empathy' && !data.deduped) {
-          return (entry.data as any).eventId || null;
+          return data.eventId || null;
         }
       }
     }
@@ -518,7 +526,7 @@ export class EventLog {
  * Service to manage multiple EventLog instances by stateDir.
  */
 export class EventLogService {
-  private static instances: Map<string, EventLog> = new Map();
+  private static readonly instances: Map<string, EventLog> = new Map();
   
   static get(stateDir: string, logger?: PluginLogger): EventLog {
     let instance = this.instances.get(stateDir);

package/src/core/evolution-engine.ts

@@ -21,19 +21,17 @@ import {
   HIGH_RISK_TOOLS,
 } from '../constants/tools.js';
 
-import {
-  EvolutionTier,
+import type {
   EvolutionEvent,
   EvolutionScorecard,
   EvolutionStats,
   EvolutionConfig,
-  EvolutionStorage,
   TaskDifficulty,
   TierDefinition,
-  TierPermissions,
   GateDecision,
-  ToolCallContext,
-  TierPromotionEvent,
+  ToolCallContext} from './evolution-types.js';
+import {
+  EvolutionTier,
   DEFAULT_EVOLUTION_CONFIG,
   TIER_DEFINITIONS,
   TASK_DIFFICULTY_CONFIG,
@@ -44,11 +42,11 @@ import {
 // ===== 主引擎 =====
 
 export class EvolutionEngine {
-  private scorecard: EvolutionScorecard;
-  private workspaceDir: string;
-  private stateDir: string;
-  private config: EvolutionConfig;
-  private storagePath: string;
+  private readonly scorecard: EvolutionScorecard;
+  private readonly workspaceDir: string;
+  private readonly stateDir: string;
+  private readonly config: EvolutionConfig;
+  private readonly storagePath: string;
 
   constructor(workspaceDir: string, config?: Partial<EvolutionConfig>) {
     this.workspaceDir = workspaceDir;
@@ -123,14 +121,14 @@ export class EvolutionEngine {
   ): { pointsAwarded: number; isDoubleReward: boolean; newTier?: EvolutionTier } {
     // 探索性工具成功不给积分，只重置失败记录
     if (EXPLORATORY_TOOLS.has(toolName)) {
-      const taskHash = this.computeTaskHash(toolName, options?.filePath);
+      const taskHash = EvolutionEngine.computeTaskHash(toolName, options?.filePath);
       this.scorecard.recentFailureHashes.delete(taskHash);
       this.saveScorecard();
       return { pointsAwarded: 0, isDoubleReward: false };
     }
 
-    const difficulty = options?.difficulty || this.inferDifficulty(toolName);
-    const taskHash = this.computeTaskHash(toolName, options?.filePath);
+    const difficulty = options?.difficulty || EvolutionEngine.inferDifficulty(toolName);
+    const taskHash = EvolutionEngine.computeTaskHash(toolName, options?.filePath);
     
     // 计算积分
     let points = this.calculatePoints(difficulty, taskHash);
@@ -178,14 +176,14 @@ export class EvolutionEngine {
   ): { pointsAwarded: number; lessonRecorded: boolean } {
     // 探索性工具失败：记录但几乎不影响
     if (EXPLORATORY_TOOLS.has(toolName)) {
-      const event = this.createEvent('failure', this.computeTaskHash(toolName, options?.filePath), 'trivial', toolName, options?.filePath, options?.reason, 0, false, options?.sessionId);
+      const event = this.createEvent('failure', EvolutionEngine.computeTaskHash(toolName, options?.filePath), 'trivial', toolName, options?.filePath, options?.reason, 0, false, options?.sessionId);
       this.addEvent(event);
       this.saveScorecard();
       return { pointsAwarded: 0, lessonRecorded: true };
     }
 
-    const difficulty = options?.difficulty || this.inferDifficulty(toolName);
-    const taskHash = this.computeTaskHash(toolName, options?.filePath);
+    const difficulty = options?.difficulty || EvolutionEngine.inferDifficulty(toolName);
+    const taskHash = EvolutionEngine.computeTaskHash(toolName, options?.filePath);
 
     // 失败不扣分，但记录教训（用于后续双倍奖励）
     this.scorecard.recentFailureHashes.set(taskHash, new Date().toISOString());
@@ -244,7 +242,7 @@ export class EvolutionEngine {
   // ===== 积分计算 =====
 
   private calculatePoints(difficulty: TaskDifficulty, taskHash: string): number {
-    const basePoints = TASK_DIFFICULTY_CONFIG[difficulty].basePoints;
+    const {basePoints} = TASK_DIFFICULTY_CONFIG[difficulty];
     
     // 难度衰减
     const penalty = this.getDifficultyPenalty(difficulty);
@@ -300,15 +298,6 @@ export class EvolutionEngine {
       this.scorecard.currentTier = newTier;
       this.scorecard.stats.tierPromotions++;
 
-      // 记录升级事件
-      const promotionEvent: TierPromotionEvent = {
-        previousTier,
-        newTier,
-        totalPoints: this.scorecard.totalPoints,
-        timestamp: new Date().toISOString(),
-        newPermissions: getTierDefinition(newTier).permissions,
-      };
-
       console.log(`[Evolution] 🎉 Tier promotion: ${previousTier} → ${newTier} (${getTierDefinition(newTier).name})`);
       
       return newTier;
@@ -319,7 +308,7 @@ export class EvolutionEngine {
 
   // ===== 任务难度推断 =====
 
-  private inferDifficulty(toolName: string): TaskDifficulty {
+  private static inferDifficulty(toolName: string): TaskDifficulty {
     if (HIGH_RISK_TOOLS.has(toolName)) return 'hard';
     if (CONSTRUCTIVE_TOOLS.has(toolName)) return 'normal';
     return 'trivial';
@@ -327,13 +316,14 @@ export class EvolutionEngine {
 
   // ===== 任务哈希 =====
 
-  private computeTaskHash(toolName: string, filePath?: string): string {
+  private static computeTaskHash(toolName: string, filePath?: string): string {
     const normalizedPath = filePath ? path.normalize(filePath) : '_nofile';
     return `${toolName}:${normalizedPath}`;
   }
 
   // ===== 事件管理 =====
 
+  // eslint-disable-next-line @typescript-eslint/max-params -- Reason: event creation requires all event fields - refactoring would break internal structure
   private createEvent(
     type: 'success' | 'failure',
     taskHash: string,
@@ -395,6 +385,7 @@ export class EvolutionEngine {
     return this.createNewScorecard();
   }
 
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- Reason: createNewScorecard is a factory function, no this reference needed
   private createNewScorecard(): EvolutionScorecard {
     const now = new Date().toISOString();
     return {
@@ -453,12 +444,15 @@ export class EvolutionEngine {
     } catch (e) {
       console.error(`[Evolution] Failed to save scorecard: ${String(e)}`);
       this.scheduleRetrySave();
-      try { fs.unlinkSync(tempPath); } catch {}
+      /* eslint-disable @typescript-eslint/no-unused-vars, no-unused-vars -- Reason: intentionally ignored - cleanup failure should not mask original error */
+      try { fs.unlinkSync(tempPath); } catch (_e) {
+        // Cleanup failure intentionally ignored - should not mask original error
+      }
     }
   }
 
   /** Per-instance retry queue (P0 fix: was static, causing cross-instance race) */
-  private retryQueue: Array<{ engine: EvolutionEngine; data: Partial<EvolutionScorecard> }> = [];
+  private retryQueue: { engine: EvolutionEngine; data: Partial<EvolutionScorecard> }[] = [];
   private retryTimer: ReturnType<typeof setTimeout> | null = null;
 
   /** 调度重试保存 */
@@ -533,6 +527,7 @@ export class EvolutionEngine {
 
   // ===== 工具方法 =====
 
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- Reason: generateId is a pure utility function, no this reference needed
   private generateId(): string {
     return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
   }
@@ -557,6 +552,7 @@ export function getEvolutionEngine(workspaceDir: string): EvolutionEngine {
   if (!_instances.has(resolved)) {
     _instances.set(resolved, new EvolutionEngine(resolved));
   }
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Reason: set() above guarantees get() returns non-null
   return _instances.get(resolved)!;
 }
 

package/src/core/evolution-logger.ts

@@ -10,7 +10,7 @@
  * 2. evolution_events 表 (SQLite) - 结构化查询
  */
 
-import { createHash, randomBytes } from 'crypto';
+import { randomBytes } from 'crypto';
 import type { TrajectoryDatabase } from './trajectory.js';
 import { SystemLogger } from './system-logger.js';
 
@@ -131,7 +131,7 @@ export class EvolutionLogger {
         });
       } catch (err) {
         // Database write failure doesn't affect main flow, but log for diagnostics
-        // eslint-disable-next-line no-console
+         
         console.error(`[EvolutionLogger] Failed to write to trajectory: ${String(err)}`);
       }
     }
@@ -264,6 +264,7 @@ export class EvolutionLogger {
     durationMs?: number;
     principlesGenerated?: number;
   }): void {
+    // eslint-disable-next-line @typescript-eslint/init-declarations -- assigned in all if/else branches
     let summary: string;
     if (params.resolution === 'marker_detected' || params.resolution === 'late_marker_principle_created') {
       summary = `任务 ${params.taskId} 完成，已生成 ${params.principlesGenerated || 0} 条原则`;