principles-disciple 1.7.1 → 1.7.3

package/dist/constants/tools.d.ts

@@ -0,0 +1,17 @@
+export declare const READ_ONLY_TOOL_NAMES: readonly ["read", "read_file", "read_many_files", "image_read", "search_file_content", "grep", "grep_search", "list_directory", "ls", "glob", "lsp_hover", "lsp_goto_definition", "lsp_find_references", "web_fetch", "web_search", "ref_search_documentation", "ref_read_url", "resolve-library-id", "get-library-docs", "memory_recall", "save_memory", "todo_read", "todo_write", "ask_user", "ask_user_question", "deep_reflect", "pd-status", "trust", "report"];
+export declare const LOW_RISK_WRITE_TOOL_NAMES: readonly ["write", "write_file", "edit", "edit_file", "replace", "apply_patch", "insert", "patch"];
+export declare const BASH_TOOL_NAMES: readonly ["bash", "run_shell_command", "exec", "execute", "shell", "cmd"];
+export declare const HIGH_RISK_TOOL_NAMES: readonly ["delete_file", "move_file", "bash", "run_shell_command", "exec", "execute", "shell", "cmd"];
+export declare const AGENT_TOOL_NAMES: readonly ["pd_run_worker", "sessions_spawn"];
+export declare const CONTENT_LIMITED_TOOL_NAMES: readonly ["write", "write_file", "edit", "edit_file", "replace", "apply_patch", "insert", "patch"];
+export declare const CONSTRUCTIVE_TOOL_NAMES: readonly ["write", "write_file", "edit", "edit_file", "replace", "apply_patch", "insert", "patch", "delete_file", "move_file", "bash", "run_shell_command", "exec", "execute", "shell", "cmd", "pd_run_worker", "sessions_spawn", "evolve-task", "init-strategy"];
+export declare const EXPLORATORY_TOOL_NAMES: readonly ["read", "read_file", "read_many_files", "image_read", "search_file_content", "grep", "grep_search", "list_directory", "ls", "glob", "lsp_hover", "lsp_goto_definition", "lsp_find_references", "web_fetch", "web_search", "ref_search_documentation", "ref_read_url", "resolve-library-id", "get-library-docs", "memory_recall", "save_memory", "todo_read", "todo_write", "ask_user", "ask_user_question", "deep_reflect", "pd-status", "trust", "report"];
+export declare const READ_ONLY_TOOLS: Set<string>;
+export declare const LOW_RISK_WRITE_TOOLS: Set<string>;
+export declare const HIGH_RISK_TOOLS: Set<string>;
+export declare const BASH_TOOLS_SET: Set<string>;
+export declare const AGENT_TOOLS: Set<string>;
+export declare const CONTENT_LIMITED_TOOLS: Set<string>;
+export declare const CONSTRUCTIVE_TOOLS: Set<string>;
+export declare const EXPLORATORY_TOOLS: Set<string>;
+export declare const WRITE_TOOLS: Set<string>;

package/dist/constants/tools.js

@@ -0,0 +1,54 @@
+export const READ_ONLY_TOOL_NAMES = [
+    'read', 'read_file', 'read_many_files', 'image_read',
+    'search_file_content', 'grep', 'grep_search', 'list_directory', 'ls', 'glob',
+    'lsp_hover', 'lsp_goto_definition', 'lsp_find_references',
+    'web_fetch', 'web_search', 'ref_search_documentation', 'ref_read_url',
+    'resolve-library-id', 'get-library-docs',
+    'memory_recall', 'save_memory', 'todo_read', 'todo_write',
+    'ask_user', 'ask_user_question',
+    'deep_reflect',
+    'pd-status', 'trust', 'report',
+];
+export const LOW_RISK_WRITE_TOOL_NAMES = [
+    'write', 'write_file',
+    'edit', 'edit_file', 'replace', 'apply_patch', 'insert', 'patch',
+];
+// BASH aliases must be defined before HIGH_RISK_TOOL_NAMES
+export const BASH_TOOL_NAMES = [
+    'bash', 'run_shell_command', 'exec', 'execute', 'shell', 'cmd',
+];
+export const HIGH_RISK_TOOL_NAMES = [
+    'delete_file', 'move_file',
+    // Include all BASH aliases for consistent high-risk classification
+    ...BASH_TOOL_NAMES,
+];
+export const AGENT_TOOL_NAMES = [
+    'pd_run_worker', 'sessions_spawn',
+];
+export const CONTENT_LIMITED_TOOL_NAMES = [
+    ...LOW_RISK_WRITE_TOOL_NAMES,
+];
+export const CONSTRUCTIVE_TOOL_NAMES = [
+    ...LOW_RISK_WRITE_TOOL_NAMES,
+    'delete_file', 'move_file',
+    // Include all BASH aliases for consistent constructive classification
+    ...BASH_TOOL_NAMES,
+    ...AGENT_TOOL_NAMES,
+    'evolve-task', 'init-strategy',
+];
+export const EXPLORATORY_TOOL_NAMES = [
+    ...READ_ONLY_TOOL_NAMES,
+];
+export const READ_ONLY_TOOLS = new Set(READ_ONLY_TOOL_NAMES);
+export const LOW_RISK_WRITE_TOOLS = new Set(LOW_RISK_WRITE_TOOL_NAMES);
+export const HIGH_RISK_TOOLS = new Set(HIGH_RISK_TOOL_NAMES);
+export const BASH_TOOLS_SET = new Set(BASH_TOOL_NAMES);
+export const AGENT_TOOLS = new Set(AGENT_TOOL_NAMES);
+export const CONTENT_LIMITED_TOOLS = new Set(CONTENT_LIMITED_TOOL_NAMES);
+export const CONSTRUCTIVE_TOOLS = new Set(CONSTRUCTIVE_TOOL_NAMES);
+export const EXPLORATORY_TOOLS = new Set(EXPLORATORY_TOOL_NAMES);
+export const WRITE_TOOLS = new Set([
+    ...LOW_RISK_WRITE_TOOL_NAMES,
+    'delete_file',
+    'move_file',
+]);

package/dist/core/event-log.d.ts

@@ -38,6 +38,9 @@ export declare class EventLog {
      * Intended for live runtime summaries that should not lag behind disk snapshots.
      */
     getBufferedEvents(): EventLogEntry[];
+    private getEventDedupKey;
+    private readPersistedEvents;
+    private getMergedEvents;
     private flushEvents;
     private flushStats;
     /**
@@ -76,4 +79,5 @@ export declare class EventLogService {
     private static instances;
     static get(stateDir: string, logger?: PluginLogger): EventLog;
     static flushAll(): void;
+    static disposeAll(): void;
 }

package/dist/core/event-log.js

@@ -176,6 +176,56 @@ export class EventLog {
     getBufferedEvents() {
         return this.eventBuffer.map((entry) => ({ ...entry, data: { ...entry.data } }));
     }
+    getEventDedupKey(entry) {
+        const eventId = typeof entry.data?.eventId === 'string'
+            ? String(entry.data.eventId)
+            : null;
+        if (eventId) {
+            return `${entry.type}:${entry.sessionId ?? 'none'}:${eventId}`;
+        }
+        const data = entry.data ?? {};
+        return [
+            entry.ts ?? 'no-ts',
+            entry.type ?? 'no-type',
+            entry.category ?? 'no-category',
+            entry.sessionId ?? 'no-session',
+            typeof data.source === 'string' ? data.source : 'no-source',
+            typeof data.toolName === 'string' ? data.toolName : 'no-tool',
+            typeof data.reason === 'string' ? data.reason : 'no-reason',
+        ].join('::');
+    }
+    readPersistedEvents() {
+        if (!fs.existsSync(this.eventsFile))
+            return [];
+        try {
+            const content = fs.readFileSync(this.eventsFile, 'utf-8');
+            return content
+                .trim()
+                .split('\n')
+                .filter((line) => line.trim().length > 0)
+                .map((line) => {
+                try {
+                    return JSON.parse(line);
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter((entry) => entry !== null);
+        }
+        catch (e) {
+            if (this.logger)
+                this.logger.error(`[PD] Failed to read events.jsonl: ${String(e)}`);
+            return [];
+        }
+    }
+    getMergedEvents() {
+        const merged = new Map();
+        for (const entry of [...this.readPersistedEvents(), ...this.getBufferedEvents()]) {
+            merged.set(this.getEventDedupKey(entry), entry);
+        }
+        return [...merged.values()].sort((a, b) => a.ts.localeCompare(b.ts));
+    }
     flushEvents() {
         if (this.eventBuffer.length === 0)
             return;
@@ -297,8 +347,7 @@ export class EventLog {
      * Aggregate empathy stats for a specific session.
      */
     aggregateSessionEmpathy(sessionId, result) {
-        // Check event buffer first
-        for (const entry of this.eventBuffer) {
+        for (const entry of this.getMergedEvents()) {
             if (entry.sessionId === sessionId && entry.type === 'pain_signal') {
                 const data = entry.data;
                 if (data.source === 'user_empathy') {
@@ -332,71 +381,15 @@ export class EventLog {
                 result.rolledBackScore += data.originalScore || 0;
             }
         }
-        // Also check events file for persisted events
-        if (fs.existsSync(this.eventsFile)) {
-            try {
-                const content = fs.readFileSync(this.eventsFile, 'utf-8');
-                const lines = content.trim().split('\n');
-                for (const line of lines) {
-                    if (!line.trim())
-                        continue;
-                    try {
-                        const entry = JSON.parse(line);
-                        if (entry.sessionId === sessionId) {
-                            if (entry.type === 'pain_signal') {
-                                const data = entry.data;
-                                if (data.source === 'user_empathy') {
-                                    if (data.deduped) {
-                                        result.dedupedCount++;
-                                    }
-                                    else {
-                                        result.totalEvents++;
-                                        result.totalPenaltyScore += data.score || 0;
-                                        if (data.severity) {
-                                            result.bySeverity[data.severity]++;
-                                            result.scoreBySeverity[data.severity] += data.score || 0;
-                                        }
-                                        if (data.detection_mode)
-                                            result.byDetectionMode[data.detection_mode]++;
-                                        if (data.origin)
-                                            result.byOrigin[data.origin]++;
-                                        const conf = data.confidence ?? 1;
-                                        if (conf >= 0.8)
-                                            result.confidenceDistribution.high++;
-                                        else if (conf >= 0.5)
-                                            result.confidenceDistribution.medium++;
-                                        else
-                                            result.confidenceDistribution.low++;
-                                    }
-                                }
-                            }
-                            else if (entry.type === 'empathy_rollback') {
-                                const data = entry.data;
-                                result.rollbackCount++;
-                                result.rolledBackScore += data.originalScore || 0;
-                            }
-                        }
-                    }
-                    catch {
-                        // Skip malformed lines
-                    }
-                }
-            }
-            catch (e) {
-                if (this.logger)
-                    this.logger.error(`[PD] Failed to read events.jsonl: ${String(e)}`);
-            }
-        }
     }
     /**
      * Rollback an empathy event by ID.
      * Returns the rolled back score, or 0 if event not found.
      */
     rollbackEmpathyEvent(eventId, sessionId, reason, triggeredBy) {
-        // Search for the event in buffer and file
+        const allEvents = this.getMergedEvents();
         let foundEvent = null;
-        // Check buffer first
-        for (const entry of this.eventBuffer) {
+        for (const entry of allEvents) {
             if (entry.type === 'pain_signal') {
                 const data = entry.data;
                 if (entry.data.eventId === eventId && data.source === 'user_empathy') {
@@ -405,34 +398,6 @@ export class EventLog {
                 }
             }
         }
-        // If not in buffer, check file
-        if (!foundEvent && fs.existsSync(this.eventsFile)) {
-            try {
-                const content = fs.readFileSync(this.eventsFile, 'utf-8');
-                const lines = content.trim().split('\n');
-                for (const line of lines) {
-                    if (!line.trim())
-                        continue;
-                    try {
-                        const entry = JSON.parse(line);
-                        if (entry.type === 'pain_signal') {
-                            const data = entry.data;
-                            if (entry.data.eventId === eventId && data.source === 'user_empathy') {
-                                foundEvent = { entry, data };
-                                break;
-                            }
-                        }
-                    }
-                    catch {
-                        // Skip malformed lines
-                    }
-                }
-            }
-            catch (e) {
-                if (this.logger)
-                    this.logger.error(`[PD] Failed to read events.jsonl: ${String(e)}`);
-            }
-        }
         if (!foundEvent || foundEvent.data.deduped) {
             return 0;
         }
@@ -451,9 +416,9 @@ export class EventLog {
      * Get the last empathy event ID for a session (for rollback).
      */
     getLastEmpathyEventId(sessionId) {
-        // Check buffer in reverse
-        for (let i = this.eventBuffer.length - 1; i >= 0; i--) {
-            const entry = this.eventBuffer[i];
+        const allEvents = this.getMergedEvents();
+        for (let i = allEvents.length - 1; i >= 0; i--) {
+            const entry = allEvents[i];
             if (entry.sessionId === sessionId && entry.type === 'pain_signal') {
                 const data = entry.data;
                 if (data.source === 'user_empathy' && !data.deduped) {
@@ -461,33 +426,6 @@ export class EventLog {
                 }
             }
         }
-        // Check file
-        if (fs.existsSync(this.eventsFile)) {
-            try {
-                const content = fs.readFileSync(this.eventsFile, 'utf-8');
-                const lines = content.trim().split('\n');
-                for (let i = lines.length - 1; i >= 0; i--) {
-                    if (!lines[i].trim())
-                        continue;
-                    try {
-                        const entry = JSON.parse(lines[i]);
-                        if (entry.sessionId === sessionId && entry.type === 'pain_signal') {
-                            const data = entry.data;
-                            if (data.source === 'user_empathy' && !data.deduped) {
-                                return entry.data.eventId || null;
-                            }
-                        }
-                    }
-                    catch {
-                        // Skip malformed lines
-                    }
-                }
-            }
-            catch (e) {
-                if (this.logger)
-                    this.logger.error(`[PD] Failed to read events.jsonl: ${String(e)}`);
-            }
-        }
         return null;
     }
     /**
@@ -519,4 +457,10 @@ export class EventLogService {
             instance.flush();
         }
     }
+    static disposeAll() {
+        for (const instance of this.instances.values()) {
+            instance.dispose();
+        }
+        this.instances.clear();
+    }
 }

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

@@ -75,10 +75,6 @@ export declare class EvolutionEngine {
     private addEvent;
     private loadOrCreateScorecard;
     private createNewScorecard;
-    /** 获取文件锁，返回释放函数 */
-    private acquireFileLock;
-    /** 检查锁文件是否过期（死锁检测） */
-    private isLockStale;
     /** 持久化评分卡（含锁保护） */
     private saveScorecard;
     /** Per-instance retry queue (P0 fix: was static, causing cross-instance race) */
@@ -91,9 +87,12 @@ export declare class EvolutionEngine {
     /** 无锁快速保存（用于重试） */
     private saveScorecardImmediate;
     private generateId;
+    dispose(): void;
 }
 /** 获取指定 workspace 的引擎实例 */
 export declare function getEvolutionEngine(workspaceDir: string): EvolutionEngine;
+export declare function disposeEvolutionEngine(workspaceDir: string): void;
+export declare function disposeAllEvolutionEngines(): void;
 /** 记录成功（便捷函数） */
 export declare function recordEvolutionSuccess(workspaceDir: string, toolName: string, options?: {
     filePath?: string;

package/dist/core/evolution-engine.js

@@ -13,37 +13,9 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { resolvePdPath } from './paths.js';
-// ===== 文件锁常量 =====
-const LOCK_SUFFIX = '.lock';
-const LOCK_MAX_RETRIES = 50;
-const LOCK_RETRY_DELAY_MS = 50;
-const LOCK_STALE_MS = 30_000; // 30秒视为死锁
+import { withLock } from '../utils/file-lock.js';
+import { CONSTRUCTIVE_TOOLS, CONTENT_LIMITED_TOOLS, EXPLORATORY_TOOLS, HIGH_RISK_TOOLS, } from '../constants/tools.js';
 import { EvolutionTier, DEFAULT_EVOLUTION_CONFIG, TIER_DEFINITIONS, TASK_DIFFICULTY_CONFIG, getTierDefinition, getTierByPoints, } from './evolution-types.js';
-// ===== 工具分类（复用 Trust Engine 的分类） =====
-const EXPLORATORY_TOOLS = new Set([
-    'read', 'read_file', 'read_many_files', 'image_read',
-    'search_file_content', 'grep', 'grep_search', 'list_directory', 'ls', 'glob',
-    'web_fetch', 'web_search',
-    'ask_user', 'ask_user_question',
-    'memory_recall', 'save_memory',
-]);
-const CONSTRUCTIVE_TOOLS = new Set([
-    'write', 'write_file', 'edit', 'edit_file', 'replace', 'apply_patch',
-    'insert', 'patch', 'delete_file', 'move_file', 'run_shell_command',
-    'pd_run_worker', 'sessions_spawn',
-]);
-// 高风险工具：需要 allowRiskPath 权限
-// 注意：pd_run_worker 和 sessions_spawn 已从高风险中移出，它们由 allowSubagentSpawn 单独控制
-const HIGH_RISK_TOOLS = new Set([
-    'run_shell_command', 'delete_file', 'move_file',
-]);
-// 内容行数限制仅适用于这些写操作工具
-const CONTENT_LIMITED_TOOLS = new Set([
-    'write', 'write_file',
-    'edit', 'edit_file',
-    'replace', 'apply_patch',
-    'insert', 'patch',
-]);
 // ===== 主引擎 =====
 export class EvolutionEngine {
     scorecard;
@@ -357,77 +329,6 @@ export class EvolutionEngine {
             lastUpdated: now,
         };
     }
-    // ===== 文件锁与原子写入（P0 修复） =====
-    /** 获取文件锁，返回释放函数 */
-    acquireFileLock(resourcePath) {
-        const lockPath = resourcePath + LOCK_SUFFIX;
-        let retries = 0;
-        while (retries < LOCK_MAX_RETRIES) {
-            try {
-                // 'wx' = 写入+排他，文件已存在则抛 EEXIST
-                const fd = fs.openSync(lockPath, 'wx');
-                fs.writeSync(fd, `${process.pid}\n${Date.now()}`);
-                fs.closeSync(fd);
-                return () => {
-                    try {
-                        fs.unlinkSync(lockPath);
-                    }
-                    catch { /* ignore */ }
-                };
-            }
-            catch (err) {
-                if (err.code === 'EEXIST') {
-                    // 检测死锁：锁文件过旧则强制清理
-                    if (this.isLockStale(lockPath)) {
-                        try {
-                            fs.unlinkSync(lockPath);
-                            continue; // 立即重试
-                        }
-                        catch { /* 抢占失败，继续等待 */ }
-                    }
-                    retries++;
-                    // busy wait（可改为指数退避）
-                    const start = Date.now();
-                    while (Date.now() - start < LOCK_RETRY_DELAY_MS) { /* spin */ }
-                    continue;
-                }
-                throw err;
-            }
-        }
-        throw new Error(`[Evolution] Lock acquisition failed after ${LOCK_MAX_RETRIES} retries: ${resourcePath}`);
-    }
-    /** 检查锁文件是否过期（死锁检测） */
-    isLockStale(lockPath) {
-        try {
-            const stat = fs.statSync(lockPath);
-            const mtimeMs = stat.mtimeMs;
-            // 读取 PID 检查进程是否存活
-            const content = fs.readFileSync(lockPath, 'utf8').trim();
-            const parts = content.split('\n');
-            const pid = parseInt(parts[0] || '0', 10);
-            // Unix: signal 0 仅检查进程存在性，Windows 也支持
-            if (pid > 0) {
-                try {
-                    process.kill(pid, 0);
-                    // 进程存活，检查时间
-                    return Date.now() - mtimeMs > LOCK_STALE_MS;
-                }
-                catch (e) {
-                    if (e.code === 'ESRCH') {
-                        // 进程不存在，锁已死
-                        return true;
-                    }
-                    // 无法确定，按时间判断
-                    return Date.now() - mtimeMs > LOCK_STALE_MS;
-                }
-            }
-            // 无有效 PID，按时间判断
-            return Date.now() - mtimeMs > LOCK_STALE_MS;
-        }
-        catch {
-            return false;
-        }
-    }
     /** 持久化评分卡（含锁保护） */
     saveScorecard() {
         this.scorecard.lastUpdated = new Date().toISOString();
@@ -441,27 +342,28 @@ export class EvolutionEngine {
             ...this.scorecard,
             recentFailureHashes: Array.from(this.scorecard.recentFailureHashes.entries()),
         };
-        const release = this.acquireFileLock(this.storagePath);
         const tempPath = `${this.storagePath}.tmp.${Date.now()}.${process.pid}`;
         try {
-            fs.writeFileSync(tempPath, JSON.stringify(serializable, null, 2), 'utf8');
-            // fsync 确保数据落盘
-            const fd = fs.openSync(tempPath, 'r+');
-            fs.fsyncSync(fd);
-            fs.closeSync(fd);
-            // 原子重命名
-            fs.renameSync(tempPath, this.storagePath);
+            withLock(this.storagePath, () => {
+                fs.writeFileSync(tempPath, JSON.stringify(serializable, null, 2), 'utf8');
+                // fsync 确保数据落盘
+                const fd = fs.openSync(tempPath, 'r+');
+                fs.fsyncSync(fd);
+                fs.closeSync(fd);
+                // 原子重命名
+                fs.renameSync(tempPath, this.storagePath);
+            }, {
+                lockSuffix: '.lock',
+                lockStaleMs: 30_000,
+            });
         }
         catch (e) {
             console.error(`[Evolution] Failed to save scorecard: ${String(e)}`);
+            this.scheduleRetrySave();
             try {
                 fs.unlinkSync(tempPath);
             }
             catch { }
-            throw e; // 重新抛出，让调用者知道保存失败
-        }
-        finally {
-            release();
         }
     }
     /** Per-instance retry queue (P0 fix: was static, causing cross-instance race) */
@@ -506,16 +408,42 @@ export class EvolutionEngine {
             recentFailureHashes: Array.from(this.scorecard.recentFailureHashes.entries()),
         };
         const tempPath = `${this.storagePath}.tmp.retry.${Date.now()}.${process.pid}`;
-        fs.writeFileSync(tempPath, JSON.stringify(serializable, null, 2), 'utf8');
-        const fd = fs.openSync(tempPath, 'r');
-        fs.fsyncSync(fd);
-        fs.closeSync(fd);
-        fs.renameSync(tempPath, this.storagePath);
+        withLock(this.storagePath, () => {
+            try {
+                fs.writeFileSync(tempPath, JSON.stringify(serializable, null, 2), 'utf8');
+                const fd = fs.openSync(tempPath, 'r');
+                fs.fsyncSync(fd);
+                fs.closeSync(fd);
+                fs.renameSync(tempPath, this.storagePath);
+            }
+            catch (error) {
+                // Clean up temp file on failure
+                try {
+                    if (fs.existsSync(tempPath)) {
+                        fs.unlinkSync(tempPath);
+                    }
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+                throw error;
+            }
+        }, {
+            lockSuffix: '.lock',
+            lockStaleMs: 30_000,
+        });
     }
     // ===== 工具方法 =====
     generateId() {
         return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
     }
+    dispose() {
+        if (this.retryTimer) {
+            clearTimeout(this.retryTimer);
+            this.retryTimer = null;
+        }
+        this.retryQueue = [];
+    }
 }
 // ===== 便捷函数 =====
 // 使用 Map 按 workspace 隔离实例，避免多 workspace 场景状态串扰
@@ -528,6 +456,20 @@ export function getEvolutionEngine(workspaceDir) {
     }
     return _instances.get(resolved);
 }
+export function disposeEvolutionEngine(workspaceDir) {
+    const resolved = path.resolve(workspaceDir);
+    const instance = _instances.get(resolved);
+    if (!instance)
+        return;
+    instance.dispose();
+    _instances.delete(resolved);
+}
+export function disposeAllEvolutionEngines() {
+    for (const instance of _instances.values()) {
+        instance.dispose();
+    }
+    _instances.clear();
+}
 /** 记录成功（便捷函数） */
 export function recordEvolutionSuccess(workspaceDir, toolName, options) {
     return getEvolutionEngine(workspaceDir).recordSuccess(toolName, options);

package/dist/core/migration.js

@@ -27,7 +27,7 @@ export function migrateDirectoryStructure(api, workspaceDir) {
             { legacy: path.join(legacyStateDir, 'pain_settings.json'), newKey: 'PAIN_SETTINGS' },
             { legacy: path.join(legacyStateDir, 'thinking_os_usage.json'), newKey: 'THINKING_OS_USAGE' },
             { legacy: path.join(legacyStateDir, 'pain_candidates.json'), newKey: 'PAIN_CANDIDATES' },
-            { legacy: path.join(legacyStateDir, 'evolution_directive.json'), newKey: 'EVOLUTION_QUEUE' },
+            { legacy: path.join(legacyStateDir, 'evolution_directive.json'), newKey: 'EVOLUTION_DIRECTIVE' },
             { legacy: path.join(legacyStateDir, 'sessions'), newKey: 'SESSION_DIR' },
             { legacy: path.join(legacyStateDir, 'logs', 'events.jsonl'), newKey: 'SYSTEM_LOG' }, // Backup plan for logs
         ];

package/dist/core/session-tracker.d.ts

@@ -13,6 +13,7 @@ export interface SessionState {
     llmTurns: number;
     blockedAttempts: number;
     lastActivityAt: number;
+    lastControlActivityAt: number;
     totalInputTokens: number;
     totalOutputTokens: number;
     cacheHits: number;