principles-disciple 1.7.0 → 1.7.1

package/dist/core/session-tracker.js

@@ -6,6 +6,11 @@ const sessions = new Map();
 let persistDir = null;
 /** Debounce timer for persistence */
 let persistTimer = null;
+function logSessionTrackerWarning(message, error) {
+    const detail = error instanceof Error ? error.message : error ? String(error) : '';
+    const suffix = detail ? `: ${detail}` : '';
+    console.warn(`[PD:SessionTracker] ${message}${suffix}`);
+}
 /**
  * Initialize persistence for session state.
  * Call this once during plugin startup.
@@ -48,13 +53,13 @@ function loadAllSessions() {
                 }
                 sessions.set(state.sessionId, state);
             }
-            catch {
-                // Ignore corrupted files
+            catch (error) {
+                logSessionTrackerWarning(`Failed to load session snapshot ${file}`, error);
             }
         }
     }
     catch (err) {
-        // Ignore errors during load
+        logSessionTrackerWarning('Failed to load persisted sessions', err);
     }
 }
 /**
@@ -69,8 +74,8 @@ function persistSession(state) {
     try {
         fs.writeFileSync(sessionPath, JSON.stringify(state, null, 2), 'utf-8');
     }
-    catch {
-        // Ignore persistence errors
+    catch (error) {
+        logSessionTrackerWarning(`Failed to persist session ${state.sessionId}`, error);
     }
 }
 /**
@@ -108,6 +113,8 @@ function getOrCreateSession(sessionId, workspaceDir) {
             cacheHits: 0,
             stuckLoops: 0,
             currentGfi: 0,
+            gfiBySource: {},
+            lastErrorSource: '',
             lastErrorHash: '',
             consecutiveErrors: 0,
             dailyToolCalls: 0,
@@ -124,6 +131,12 @@ function getOrCreateSession(sessionId, workspaceDir) {
     }
     return state;
 }
+function ensureGfiLedger(state) {
+    if (!state.gfiBySource || typeof state.gfiBySource !== 'object') {
+        state.gfiBySource = {};
+    }
+    return state.gfiBySource;
+}
 export function trackToolRead(sessionId, filePath, workspaceDir) {
     const state = getOrCreateSession(sessionId, workspaceDir);
     const normalizedPath = path.posix.normalize(filePath.replace(/\\/g, '/'));
@@ -165,12 +178,14 @@ export function trackLlmOutput(sessionId, usage, config, workspaceDir) {
 /**
  * Tracks physical friction based on tool execution failures.
  */
-export function trackFriction(sessionId, deltaF, hash, workspaceDir) {
+export function trackFriction(sessionId, deltaF, hash, workspaceDir, options) {
     const state = getOrCreateSession(sessionId, workspaceDir);
+    const ledger = ensureGfiLedger(state);
     if (hash && hash === state.lastErrorHash) {
         state.consecutiveErrors++;
     }
     else {
+        state.lastErrorSource = options?.source || (hash ? `unattributed:${hash}` : 'unattributed:unknown');
         state.lastErrorHash = hash;
         state.consecutiveErrors = 1;
     }
@@ -178,6 +193,8 @@ export function trackFriction(sessionId, deltaF, hash, workspaceDir) {
     const multiplier = Math.pow(1.5, state.consecutiveErrors - 1);
     const addedFriction = deltaF * multiplier;
     state.currentGfi = (state.currentGfi || 0) + addedFriction;
+    const sourceKey = options?.source || (hash ? `unattributed:${hash}` : 'unattributed:unknown');
+    ledger[sourceKey] = (ledger[sourceKey] || 0) + addedFriction;
     state.lastActivityAt = Date.now();
     SystemLogger.log(state.workspaceDir, 'GFI_INC', `Friction added: +${addedFriction.toFixed(1)} (Base: ${deltaF}, Mult: ${multiplier.toFixed(2)}). Total GFI: ${state.currentGfi.toFixed(1)}`);
     // Update daily stats
@@ -190,12 +207,36 @@ export function trackFriction(sessionId, deltaF, hash, workspaceDir) {
 /**
  * Resets the friction index upon successful action.
  */
-export function resetFriction(sessionId, workspaceDir) {
+export function resetFriction(sessionId, workspaceDir, options) {
     const state = getOrCreateSession(sessionId, workspaceDir);
+    const ledger = ensureGfiLedger(state);
+    if (options?.source) {
+        const sourceKey = options.source;
+        const currentSource = ledger[sourceKey] || 0;
+        const requestedAmount = Number.isFinite(options.amount) ? Number(options.amount) : currentSource;
+        const amountToRemove = Math.max(0, Math.min(currentSource, requestedAmount));
+        if (amountToRemove > 0) {
+            ledger[sourceKey] = Math.max(0, currentSource - amountToRemove);
+            if (ledger[sourceKey] === 0) {
+                delete ledger[sourceKey];
+            }
+            state.currentGfi = Math.max(0, (state.currentGfi || 0) - amountToRemove);
+            SystemLogger.log(state.workspaceDir, 'GFI_SLICE_RESET', `Friction slice reset for ${sourceKey}: -${amountToRemove.toFixed(1)}. Total GFI: ${state.currentGfi.toFixed(1)}`);
+            if (state.lastErrorSource === sourceKey) {
+                state.consecutiveErrors = 0;
+                state.lastErrorHash = '';
+                state.lastErrorSource = '';
+            }
+        }
+        schedulePersistence(state);
+        return state;
+    }
     if (state.currentGfi > 0) {
         SystemLogger.log(state.workspaceDir, 'GFI_RESET', `Friction reset to 0 (Was: ${state.currentGfi.toFixed(1)}). Action successful.`);
     }
     state.currentGfi = 0;
+    state.gfiBySource = {};
+    state.lastErrorSource = '';
     state.consecutiveErrors = 0;
     state.lastErrorHash = '';
     // Schedule persistence
@@ -248,6 +289,16 @@ export function clearInjectedProbationIds(sessionId, workspaceDir) {
 export function getSession(sessionId) {
     return sessions.get(sessionId);
 }
+export function listSessions(workspaceDir) {
+    return [...sessions.values()]
+        .filter((state) => !workspaceDir || !state.workspaceDir || state.workspaceDir === workspaceDir)
+        .map((state) => ({
+        ...state,
+        toolReadsByFile: { ...state.toolReadsByFile },
+        gfiBySource: state.gfiBySource ? { ...state.gfiBySource } : undefined,
+        injectedProbationIds: state.injectedProbationIds ? [...state.injectedProbationIds] : undefined,
+    }));
+}
 export function clearSession(sessionId) {
     sessions.delete(sessionId);
 }
@@ -264,8 +315,8 @@ export function garbageCollectSessions() {
                     try {
                         fs.unlinkSync(sessionPath);
                     }
-                    catch {
-                        // Ignore deletion errors
+                    catch (error) {
+                        logSessionTrackerWarning(`Failed to delete session snapshot for ${id}`, error);
                     }
                 }
             }

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

@@ -17,6 +17,8 @@ export interface TrustScorecard {
         reason: string;
         timestamp: string;
     }>;
+    frozen?: boolean;
+    reward_policy?: 'frozen_all_positive' | 'frozen_atomic_positive_keep_plan_ready';
 }
 export type TrustStage = 1 | 2 | 3 | 4;
 export declare const EXPLORATORY_TOOLS: string[];
@@ -29,6 +31,7 @@ export declare class TrustEngine {
     private get config();
     private get trustSettings();
     private loadScorecard;
+    private applyLegacyFreezeMetadata;
     private saveScorecard;
     getScore(): number;
     getScorecard(): TrustScorecard;
@@ -45,6 +48,7 @@ export declare class TrustEngine {
         toolName?: string;
         error?: string;
     }): void;
+    private touchScorecard;
     private updateScore;
     resetTrust(newScore?: number): void;
     getStatusSummary(): {

package/dist/core/trust-engine.js

@@ -29,6 +29,7 @@ export const CONSTRUCTIVE_TOOLS = [
     'insert', 'patch', 'delete_file', 'move_file', 'run_shell_command',
     'pd_run_worker', 'sessions_spawn', 'evolve-task', 'init-strategy'
 ];
+const LEGACY_TRUST_REWARD_POLICY = 'frozen_all_positive';
 export class TrustEngine {
     scorecard;
     workspaceDir;
@@ -69,6 +70,7 @@ export class TrustEngine {
                     data.history = [];
                 if (data.exploratory_failure_streak === undefined)
                     data.exploratory_failure_streak = 0;
+                this.applyLegacyFreezeMetadata(data);
                 return data;
             }
             catch (e) {
@@ -77,7 +79,7 @@ export class TrustEngine {
         }
         const now = new Date();
         const coldStartEnd = new Date(now.getTime() + settings.cold_start.cold_start_period_ms);
-        return {
+        const scorecard = {
             trust_score: settings.cold_start.initial_trust,
             success_streak: 0,
             failure_streak: 0,
@@ -88,6 +90,12 @@ export class TrustEngine {
             first_activity_at: now.toISOString(),
             history: []
         };
+        this.applyLegacyFreezeMetadata(scorecard);
+        return scorecard;
+    }
+    applyLegacyFreezeMetadata(scorecard) {
+        scorecard.frozen = true;
+        scorecard.reward_policy = LEGACY_TRUST_REWARD_POLICY;
     }
     saveScorecard() {
         const scorecardPath = resolvePdPath(this.workspaceDir, 'AGENT_SCORECARD');
@@ -120,39 +128,19 @@ export class TrustEngine {
         return new Date() < new Date(this.scorecard.cold_start_end);
     }
     recordSuccess(reason, context, isSubagent = false) {
-        const settings = this.trustSettings;
-        const rewards = settings.rewards;
         const toolName = context?.toolName;
         // 1. Check if this is an exploratory tool success
         const isExploratory = toolName && EXPLORATORY_TOOLS.includes(toolName);
         if (reason === 'tool_success' && isExploratory) {
-            // Exploratory tools don't grant trust points, but they:
-            // 1. Reset the exploratory failure streak
-            // 2. Prove the agent isn't stuck (no delta, no success_streak increment)
             this.scorecard.exploratory_failure_streak = 0;
-            this.updateScore(0, `Exploratory Success: ${toolName}`, 'info', context);
+            this.touchScorecard();
             return;
         }
-        let delta = rewards.success_base;
-        if (isSubagent) {
-            delta = rewards.subagent_success;
-        }
-        else if (reason === 'tool_success') {
-            delta = rewards.tool_success_reward ?? 0.2;
-        }
-        else if (reason === 'plan_ready') {
-            delta = 5; // Strategic reward
-        }
-        this.scorecard.success_streak++;
+        // Phase 1 freeze: do not let atomic successes inflate legacy trust.
+        this.scorecard.success_streak = 0;
         this.scorecard.failure_streak = 0; // Reset failure streak on constructive success
         this.scorecard.exploratory_failure_streak = 0;
-        if (this.scorecard.success_streak >= rewards.streak_bonus_threshold) {
-            delta += rewards.streak_bonus;
-        }
-        if (this.scorecard.trust_score < settings.stages.stage_1_observer) {
-            delta += rewards.recovery_boost;
-        }
-        this.updateScore(delta, reason, 'success', context);
+        this.touchScorecard();
     }
     recordFailure(type, context) {
         const settings = this.trustSettings;
@@ -204,8 +192,14 @@ export class TrustEngine {
             delta = penalties.max_penalty;
         this.updateScore(delta, `Failure: ${toolName || type}`, 'failure', context);
     }
+    touchScorecard() {
+        this.applyLegacyFreezeMetadata(this.scorecard);
+        this.scorecard.last_updated = new Date().toISOString();
+        this.saveScorecard();
+    }
     updateScore(delta, reason, type, context) {
         const oldScore = this.scorecard.trust_score;
+        this.applyLegacyFreezeMetadata(this.scorecard);
         this.scorecard.trust_score += delta;
         // Floor score: never drop below 30 (prevents Trust collapse from cascades)
         if (this.scorecard.trust_score < 30)
@@ -255,6 +249,7 @@ export class TrustEngine {
         this.scorecard.first_activity_at = now.toISOString();
         this.scorecard.cold_start_end = coldStartEnd.toISOString();
         this.scorecard.history.push({ type: 'success', delta: 0, reason: 'Manual trust reset (Spiritual Cleanse)', timestamp: now.toISOString() });
+        this.applyLegacyFreezeMetadata(this.scorecard);
         this.saveScorecard();
     }
     getStatusSummary() {

package/dist/hooks/gate.js

@@ -37,7 +37,7 @@ const BASH_TOOLS_SET = new Set([
 /**
  * 分析 Bash 命令风险等级
  */
-function analyzeBashCommand(command, safePatterns, dangerousPatterns) {
+function analyzeBashCommand(command, safePatterns, dangerousPatterns, logger) {
     let normalizedCmd = command.trim().toLowerCase();
     // P2 fix: Unicode de-obfuscation — convert Cyrillic/Unicode lookalikes to ASCII equivalents
     // Common Cyrillic lookalikes that could bypass detection: аеорсух (Cyrillic) → aeopcyx (Latin)
@@ -72,8 +72,10 @@ function analyzeBashCommand(command, safePatterns, dangerousPatterns) {
                     return 'dangerous';
                 }
             }
-            catch {
-                // 忽略无效正则
+            catch (error) {
+                logger?.warn?.(`[PD_GATE] Invalid dangerous bash regex "${pattern}": ${String(error)}. Failing closed.`);
+                return 'dangerous';
+                // Fail-closed: 无效的危险模式正则视为匹配危险命令
             }
         }
     }
@@ -87,8 +89,8 @@ function analyzeBashCommand(command, safePatterns, dangerousPatterns) {
                     break;
                 }
             }
-            catch {
-                // ignore
+            catch (error) {
+                logger?.warn?.(`[PD_GATE] Invalid safe bash regex "${pattern}": ${String(error)}. Ignoring safe override.`);
             }
         }
         if (!isSafe) {
@@ -187,7 +189,7 @@ export function handleBeforeToolCall(event, ctx) {
         // TIER 3: Bash 命令 - 根据内容判断
         if (BASH_TOOLS_SET.has(event.toolName)) {
             const command = String(event.params.command || event.params.args || '');
-            const bashRisk = analyzeBashCommand(command, gfiGateConfig?.bash_safe_patterns || [], gfiGateConfig?.bash_dangerous_patterns || []);
+            const bashRisk = analyzeBashCommand(command, gfiGateConfig?.bash_safe_patterns || [], gfiGateConfig?.bash_dangerous_patterns || [], logger);
             if (bashRisk === 'dangerous') {
                 // 危险命令 - 直接拦截
                 logger?.warn?.(`[PD:GFI_GATE] Dangerous bash command blocked: ${command.substring(0, 50)}...`);
@@ -378,6 +380,46 @@ GFI: ${currentGfi}/100
             matchesAnyPattern(relPath, planApprovals.allowed_patterns || []) &&
             ((planApprovals.max_lines_override ?? -1) === -1 || lineChanges <= (planApprovals.max_lines_override ?? -1)));
         logger.info(`[PD_GATE] Trust: ${trustScore} (Stage ${stage}), Risk: ${riskLevel}, Path: ${relPath}`);
+        // ── EP SIMULATION MODE (M6验证) ──
+        // 记录EP系统的模拟决策，但不生效（仅用于对比分析）
+        // BUGFIX #90: 移到所有Stage检查之前，确保所有Stage都触发EP simulation记录
+        try {
+            const epDecision = checkEvolutionGate(ctx.workspaceDir, {
+                toolName: event.toolName,
+                content: event.params?.content,
+                lineCount: lineChanges,
+                isRiskPath: risky,
+            });
+            const epLogEntry = {
+                timestamp: new Date().toISOString(),
+                toolName: event.toolName,
+                filePath: relPath,
+                trustEngine: { score: trustScore, stage, decision: 'allow' },
+                epSystem: { tier: epDecision.currentTier ?? 'UNKNOWN', allowed: epDecision.allowed, reason: epDecision.reason },
+                conflict: epDecision.allowed === false, // Trust允许但EP拒绝（任何阶段）
+            };
+            const epLogPath = path.join(ctx.workspaceDir, '.state', 'ep_simulation.jsonl');
+            // 安全创建目录（如果失败则跳过日志写入，但不影响 Trust Engine 决策）
+            let canWriteEpLog = true;
+            try {
+                fs.mkdirSync(path.dirname(epLogPath), { recursive: true });
+            }
+            catch (mkdirErr) {
+                if (!mkdirErr || mkdirErr.code !== 'EEXIST') {
+                    logger.warn(`[PD_EP_SIM] Failed to create log dir: ${mkdirErr?.message ?? String(mkdirErr)}, skipping log`);
+                    canWriteEpLog = false;
+                }
+            }
+            if (canWriteEpLog) {
+                fs.appendFileSync(epLogPath, JSON.stringify(epLogEntry) + '\n');
+            }
+            logger.info(`[PD_EP_SIM] Tier: ${epDecision.currentTier}, Allowed: ${epDecision.allowed}, Trust: ${trustScore} (Stage ${stage})`);
+        }
+        catch (err) {
+            // EP 模拟失败不应该影响 Trust Engine 决策
+            const errMsg = err instanceof Error ? err.message : String(err);
+            logger.warn(`[PD_EP_SIM] Simulation failed: ${errMsg}, continuing with Trust Engine`);
+        }
         // Stage 1 (Bankruptcy): Block ALL writes to risk paths, and all medium+ writes
         if (stage === 1) {
             if (canUsePlanApproval) {
@@ -400,17 +442,17 @@ GFI: ${currentGfi}/100
             }
             if (risky || riskLevel !== 'LOW') {
                 // Block if not approved by whitelist
-                return block(relPath, `Trust score too low (${trustScore}). Stage 1 agents cannot modify risk paths or perform non-trivial edits.`, wctx, event.toolName);
+                return block(relPath, `Trust score too low (${trustScore}). Stage 1 agents cannot modify risk paths or perform non-trivial edits.`, wctx, event.toolName, ctx.sessionId);
             }
         }
         // Stage 2 (Editor): Block writes to risk paths. Block large changes.
         if (stage === 2) {
             if (risky) {
-                return block(relPath, `Stage 2 agents are not authorized to modify risk paths.`, wctx, event.toolName);
+                return block(relPath, `Stage 2 agents are not authorized to modify risk paths.`, wctx, event.toolName, ctx.sessionId);
             }
             const stage2Limit = trustSettings.limits?.stage_2_max_lines ?? 50;
             if (lineChanges > stage2Limit) {
-                return block(relPath, `Modification too large (${lineChanges} lines) for Stage 2. Max allowed is ${stage2Limit}.`, wctx, event.toolName);
+                return block(relPath, `Modification too large (${lineChanges} lines) for Stage 2. Max allowed is ${stage2Limit}.`, wctx, event.toolName, ctx.sessionId);
             }
         }
         // Stage 3 (Developer): Allow normal writes. Require READY plan for risk paths.
@@ -418,12 +460,12 @@ GFI: ${currentGfi}/100
             if (risky) {
                 const planStatus = getPlanStatus(ctx.workspaceDir);
                 if (planStatus !== 'READY') {
-                    return block(relPath, `No READY plan found. Stage 3 requires a plan for risk path modifications.`, wctx, event.toolName);
+                    return block(relPath, `No READY plan found. Stage 3 requires a plan for risk path modifications.`, wctx, event.toolName, ctx.sessionId);
                 }
             }
             const stage3Limit = trustSettings.limits?.stage_3_max_lines ?? 300;
             if (lineChanges > stage3Limit) {
-                return block(relPath, `Modification too large (${lineChanges} lines) for Stage 3. Max allowed is ${stage3Limit}.`, wctx, event.toolName);
+                return block(relPath, `Modification too large (${lineChanges} lines) for Stage 3. Max allowed is ${stage3Limit}.`, wctx, event.toolName, ctx.sessionId);
             }
         }
         // Stage 4 (Architect): Full bypass
@@ -446,52 +488,13 @@ GFI: ${currentGfi}/100
             }
             return;
         }
-        // ── EP SIMULATION MODE (M6验证) ──
-        // 记录EP系统的模拟决策，但不生效（仅用于对比分析）
-        try {
-            const epDecision = checkEvolutionGate(ctx.workspaceDir, {
-                toolName: event.toolName,
-                content: event.params?.content,
-                lineCount: lineChanges,
-                isRiskPath: risky,
-            });
-            const epLogEntry = {
-                timestamp: new Date().toISOString(),
-                toolName: event.toolName,
-                filePath: relPath,
-                trustEngine: { score: trustScore, stage, decision: 'allow' },
-                epSystem: { tier: epDecision.currentTier ?? 'UNKNOWN', allowed: epDecision.allowed, reason: epDecision.reason },
-                conflict: epDecision.allowed === false, // Trust允许但EP拒绝（任何阶段）
-            };
-            const epLogPath = path.join(ctx.workspaceDir, '.state', 'ep_simulation.jsonl');
-            // 安全创建目录（如果失败则跳过日志写入，但不影响 Trust Engine 决策）
-            let canWriteEpLog = true;
-            try {
-                fs.mkdirSync(path.dirname(epLogPath), { recursive: true });
-            }
-            catch (mkdirErr) {
-                if (!mkdirErr || mkdirErr.code !== 'EEXIST') {
-                    logger.warn(`[PD_EP_SIM] Failed to create log dir: ${mkdirErr?.message ?? String(mkdirErr)}, skipping log`);
-                    canWriteEpLog = false;
-                }
-            }
-            if (canWriteEpLog) {
-                fs.appendFileSync(epLogPath, JSON.stringify(epLogEntry) + '\n');
-            }
-            logger.info(`[PD_EP_SIM] Tier: ${epDecision.currentTier}, Allowed: ${epDecision.allowed}, Trust: ${trustScore} (Stage ${stage})`);
-        }
-        catch (err) {
-            // EP 模拟失败不应该影响 Trust Engine 决策
-            const errMsg = err instanceof Error ? err.message : String(err);
-            logger.warn(`[PD_EP_SIM] Simulation failed: ${errMsg}, continuing with Trust Engine`);
-        }
     }
     else {
         // FALLBACK: Legacy Gate Logic
         if (risky && profile.gate?.require_plan_for_risk_paths) {
             const planStatus = getPlanStatus(ctx.workspaceDir);
             if (planStatus !== 'READY') {
-                return block(relPath, `No READY plan found in PLAN.md.`, wctx, event.toolName);
+                return block(relPath, `No READY plan found in PLAN.md.`, wctx, event.toolName, ctx.sessionId);
             }
         }
     }
@@ -512,10 +515,22 @@ GFI: ${currentGfi}/100
         }
     }
 }
-function block(filePath, reason, wctx, toolName) {
+function block(filePath, reason, wctx, toolName, sessionId) {
     const logger = console;
     logger.error(`[PD_GATE] BLOCKED: ${filePath}. Reason: ${reason}`);
-    trackBlock(wctx.workspaceDir);
+    if (sessionId) {
+        trackBlock(sessionId);
+    }
+    try {
+        wctx.eventLog.recordGateBlock(sessionId, {
+            toolName,
+            filePath,
+            reason,
+        });
+    }
+    catch (error) {
+        logger.warn(`[PD_GATE] Failed to record gate block event: ${String(error)}`);
+    }
     return {
         block: true,
         blockReason: `[Principles Disciple] Security Gate Blocked this action.\nFile: ${filePath}\nReason: ${reason}\n\nHint: You may need a READY plan or a higher trust score to perform this action.`,

package/dist/hooks/llm.js

@@ -237,7 +237,7 @@ export function handleLlmOutput(event, ctx) {
                 const calibratedScore = Math.round(weightedScore * calibrationFactor);
                 const boundedScore = applyRateLimit(ctx.sessionId, event.runId, calibratedScore, config);
                 if (boundedScore > 0) {
-                    trackFriction(ctx.sessionId, boundedScore, `user_empathy_${signal.severity}`, ctx.workspaceDir);
+                    trackFriction(ctx.sessionId, boundedScore, `user_empathy_${signal.severity}`, ctx.workspaceDir, { source: 'user_empathy' });
                     try {
                         wctx.trajectory?.recordPainEvent?.({
                             sessionId: ctx.sessionId,
@@ -298,7 +298,10 @@ export function handleLlmOutput(event, ctx) {
             const rolledBackScore = eventLog.rollbackEmpathyEvent(eventId, ctx.sessionId, 'Natural language rollback request detected', 'natural_language');
             if (rolledBackScore > 0) {
                 // Reset GFI after successful rollback
-                resetFriction(ctx.sessionId);
+                resetFriction(ctx.sessionId, ctx.workspaceDir, {
+                    source: 'user_empathy',
+                    amount: rolledBackScore,
+                });
             }
         }
     }

package/dist/hooks/subagent.js

@@ -1,6 +1,7 @@
 import { writePainFlag } from '../core/pain.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { empathyObserverManager } from '../service/empathy-observer-manager.js';
+import { acquireQueueLock, EVOLUTION_QUEUE_LOCK_SUFFIX } from '../service/evolution-worker.js';
 import * as fs from 'fs';
 function emitSubagentPainEvent(wctx, payload) {
     try {
@@ -61,38 +62,49 @@ export async function handleSubagentEnded(event, ctx) {
         }, true);
         const queuePath = wctx.resolve('EVOLUTION_QUEUE');
         if (fs.existsSync(queuePath)) {
+            const lockPath = queuePath + EVOLUTION_QUEUE_LOCK_SUFFIX;
+            const releaseLock = acquireQueueLock(lockPath, console);
+            if (!releaseLock) {
+                console.warn('[PD:Subagent] Failed to acquire queue lock, skipping queue update');
+                return;
+            }
             try {
                 const queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
                 let changed = false;
-                // Find in_progress tasks
-                const inProgressTasks = queue.filter((t) => t.status === 'in_progress');
-                if (inProgressTasks.length > 0) {
-                    const resolveTaskTime = (task) => {
-                        const raw = task?.enqueued_at || task?.timestamp;
-                        const ts = new Date(raw).getTime();
-                        return Number.isFinite(ts) ? ts : Number.MAX_SAFE_INTEGER;
-                    };
-                    // Sort by enqueue timestamp (fallback to legacy timestamp) to find the oldest task
-                    const oldestTask = inProgressTasks.sort((a, b) => resolveTaskTime(a) - resolveTaskTime(b))[0];
-                    // Mark as completed
-                    const taskIndex = queue.findIndex((t) => t.id === oldestTask.id);
-                    if (taskIndex !== -1) {
-                        queue[taskIndex].status = 'completed';
-                        queue[taskIndex].completed_at = new Date().toISOString();
-                        changed = true;
-                        // Clean up the .pain_flag if it was queued, to reset the environment
-                        const painFlagPath = wctx.resolve('PAIN_FLAG');
-                        if (fs.existsSync(painFlagPath)) {
-                            try {
-                                const painData = fs.readFileSync(painFlagPath, 'utf8');
-                                if (painData.includes('status: queued')) {
-                                    fs.unlinkSync(painFlagPath);
-                                }
-                            }
-                            catch (e) {
-                                console.error(`[PD:Subagent] Failed to cleanup pain flag: ${String(e)}`);
+                const resolveTaskTime = (task) => {
+                    const raw = task?.enqueued_at || task?.timestamp;
+                    const ts = new Date(raw).getTime();
+                    return Number.isFinite(ts) ? ts : Number.MAX_SAFE_INTEGER;
+                };
+                // Resolve the queue entry by its position, not by id. Historical pain
+                // records may legitimately share the same id in legacy data.
+                let oldestTaskIndex = -1;
+                let oldestTaskTime = Number.MAX_SAFE_INTEGER;
+                queue.forEach((task, index) => {
+                    if (task?.status !== 'in_progress')
+                        return;
+                    const taskTime = resolveTaskTime(task);
+                    if (taskTime < oldestTaskTime) {
+                        oldestTaskTime = taskTime;
+                        oldestTaskIndex = index;
+                    }
+                });
+                if (oldestTaskIndex !== -1) {
+                    queue[oldestTaskIndex].status = 'completed';
+                    queue[oldestTaskIndex].completed_at = new Date().toISOString();
+                    changed = true;
+                    // Clean up the .pain_flag if it was queued, to reset the environment
+                    const painFlagPath = wctx.resolve('PAIN_FLAG');
+                    if (fs.existsSync(painFlagPath)) {
+                        try {
+                            const painData = fs.readFileSync(painFlagPath, 'utf8');
+                            if (painData.includes('status: queued')) {
+                                fs.unlinkSync(painFlagPath);
                             }
                         }
+                        catch (e) {
+                            console.error(`[PD:Subagent] Failed to cleanup pain flag: ${String(e)}`);
+                        }
                     }
                 }
                 if (changed) {
@@ -102,6 +114,9 @@ export async function handleSubagentEnded(event, ctx) {
             catch (e) {
                 console.error(`[PD:Subagent] Failed to update evolution queue: ${String(e)}`);
             }
+            finally {
+                releaseLock();
+            }
         }
     }
 }

package/dist/hooks/trajectory-collector.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Trajectory Collector - 行为进化引擎 Phase 0 数据收集
+ *
+ * 收集工具调用和 LLM 输出到 memory/trajectories/ 目录
+ * 用于分析工具使用模式、识别原则应用案例、评估行为质量
+ */
+import type { PluginHookAfterToolCallEvent, PluginHookToolContext, PluginHookLlmOutputEvent, PluginHookAgentContext, PluginHookBeforeMessageWriteEvent } from '../openclaw-sdk.js';
+/**
+ * 工具调用完成后的处理
+ * 记录：工具名、参数、结果、错误、执行时间
+ */
+export declare function handleAfterToolCall(event: PluginHookAfterToolCallEvent, ctx: PluginHookToolContext & {
+    workspaceDir?: string;
+}): void;
+/**
+ * LLM 输出处理
+ * 记录：provider、model、输出长度、token 使用量
+ */
+export declare function handleLlmOutput(event: PluginHookLlmOutputEvent, ctx: PluginHookAgentContext & {
+    workspaceDir?: string;
+}): void;
+/**
+ * 消息写入前的处理
+ * 记录：用户/助手消息内容
+ */
+export declare function handleBeforeMessageWrite(event: PluginHookBeforeMessageWriteEvent, ctx: PluginHookAgentContext & {
+    workspaceDir?: string;
+}): void;
+/**
+ * 轨迹汇总统计（供 cron 任务调用）
+ */
+export declare function computeTrajectoryStats(workspaceDir: string): object;