principles-disciple 1.7.0 → 1.7.1

package/dist/hooks/trajectory-collector.js

@@ -0,0 +1,256 @@
+/**
+ * Trajectory Collector - 行为进化引擎 Phase 0 数据收集
+ *
+ * 收集工具调用和 LLM 输出到 memory/trajectories/ 目录
+ * 用于分析工具使用模式、识别原则应用案例、评估行为质量
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+const TRAJECTORY_DIR = 'memory/trajectories/';
+// 敏感字段匹配正则
+const SENSITIVE_KEY_PATTERN = /password|token|authorization|secret|api[_-]?key|credential|cookie|session/i;
+// 最大字符串长度
+const MAX_STRING_LENGTH = 1000;
+const MAX_RESULT_LENGTH = 500;
+/**
+ * 递归脱敏处理：遍历对象/数组，移除敏感字段值
+ */
+function scrubSensitive(obj, depth = 0) {
+    // 防止无限递归
+    if (depth > 10)
+        return '[MAX_DEPTH]';
+    // 处理 null/undefined
+    if (obj == null)
+        return obj;
+    // 处理基本类型
+    if (typeof obj !== 'object') {
+        if (typeof obj === 'string' && obj.length > MAX_STRING_LENGTH) {
+            return obj.slice(0, MAX_STRING_LENGTH) + '...[truncated]';
+        }
+        return obj;
+    }
+    // 处理数组
+    if (Array.isArray(obj)) {
+        return obj.map(item => scrubSensitive(item, depth + 1));
+    }
+    // 处理对象
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (SENSITIVE_KEY_PATTERN.test(key)) {
+            result[key] = '[REDACTED]';
+        }
+        else {
+            result[key] = scrubSensitive(value, depth + 1);
+        }
+    }
+    return result;
+}
+/**
+ * 异步写入队列 - 确保有序、非阻塞写入
+ */
+class AsyncWriteQueue {
+    queue = [];
+    processing = false;
+    async enqueue(task) {
+        this.queue.push(task);
+        if (!this.processing) {
+            this.processNext();
+        }
+    }
+    async processNext() {
+        if (this.queue.length === 0) {
+            this.processing = false;
+            return;
+        }
+        this.processing = true;
+        const task = this.queue.shift();
+        try {
+            await task();
+        }
+        catch {
+            // Silently fail - trajectory collection should not block main functionality
+        }
+        // 处理下一个任务
+        this.processNext();
+    }
+}
+// 全局写入队列实例
+const writeQueue = new AsyncWriteQueue();
+// 目录缓存（避免重复检查）
+const dirCache = new Map();
+/**
+ * 确保轨迹目录存在（异步）
+ */
+async function ensureTrajectoryDirAsync(workspaceDir) {
+    const dir = path.join(workspaceDir, TRAJECTORY_DIR);
+    if (dirCache.get(dir)) {
+        return dir;
+    }
+    try {
+        await fs.promises.mkdir(dir, { recursive: true });
+        dirCache.set(dir, true);
+    }
+    catch {
+        // 目录可能已存在，忽略错误
+        dirCache.set(dir, true);
+    }
+    return dir;
+}
+/**
+ * 获取今日轨迹文件名
+ */
+function getTodayFilename() {
+    const now = new Date();
+    const year = now.getUTCFullYear();
+    const month = String(now.getUTCMonth() + 1).padStart(2, '0');
+    return `${year}-${month}-${String(now.getUTCDate()).padStart(2, '0')}.jsonl`;
+}
+/**
+ * 写入轨迹记录（JSON Lines 格式）- 异步版本
+ */
+function writeTrajectoryRecord(workspaceDir, record) {
+    const line = JSON.stringify(record) + '\n';
+    writeQueue.enqueue(async () => {
+        const dir = await ensureTrajectoryDirAsync(workspaceDir);
+        const filepath = path.join(dir, getTodayFilename());
+        await fs.promises.appendFile(filepath, line, 'utf8');
+    });
+}
+/**
+ * 工具调用完成后的处理
+ * 记录：工具名、参数、结果、错误、执行时间
+ */
+export function handleAfterToolCall(event, ctx) {
+    const workspaceDir = ctx.workspaceDir;
+    if (!workspaceDir)
+        return;
+    // 递归脱敏处理所有字段
+    const sanitizedParams = scrubSensitive(event.params);
+    const sanitizedResult = event.result == null
+        ? null
+        : String(scrubSensitive(event.result)).slice(0, MAX_RESULT_LENGTH);
+    const sanitizedError = event.error == null
+        ? null
+        : String(scrubSensitive(event.error));
+    writeTrajectoryRecord(workspaceDir, {
+        type: 'tool_call',
+        timestamp: new Date().toISOString(),
+        sessionId: ctx.sessionId || 'unknown',
+        toolName: event.toolName,
+        params: sanitizedParams,
+        result: sanitizedResult,
+        error: sanitizedError,
+        durationMs: event.durationMs,
+        success: !event.error,
+        runId: event.runId || null,
+        toolCallId: event.toolCallId || null
+    });
+}
+/**
+ * LLM 输出处理
+ * 记录：provider、model、输出长度、token 使用量
+ */
+export function handleLlmOutput(event, ctx) {
+    const workspaceDir = ctx.workspaceDir;
+    if (!workspaceDir)
+        return;
+    const totalTextLength = event.assistantTexts?.reduce((sum, text) => sum + (text?.length || 0), 0) || 0;
+    writeTrajectoryRecord(workspaceDir, {
+        type: 'llm_output',
+        timestamp: new Date().toISOString(),
+        sessionId: ctx.sessionId || 'unknown',
+        provider: event.provider,
+        model: event.model,
+        textLength: totalTextLength,
+        outputCount: event.assistantTexts?.length || 0,
+        usage: event.usage ? scrubSensitive(event.usage) : null
+    });
+}
+/**
+ * 消息写入前的处理
+ * 记录：用户/助手消息内容
+ */
+export function handleBeforeMessageWrite(event, ctx) {
+    const workspaceDir = ctx.workspaceDir;
+    if (!workspaceDir)
+        return;
+    const msg = event.message;
+    if (!msg || !msg.role)
+        return;
+    // 只记录 user 和 assistant 消息
+    if (msg.role !== 'user' && msg.role !== 'assistant')
+        return;
+    // 提取文本内容
+    let content = '';
+    if (typeof msg.content === 'string') {
+        content = msg.content;
+    }
+    else if (Array.isArray(msg.content)) {
+        content = msg.content
+            .filter((part) => part?.type === 'text')
+            .map((part) => part.text)
+            .join('\n');
+    }
+    // 脱敏处理内容预览
+    const sanitizedPreview = scrubSensitive(content.slice(0, 200));
+    writeTrajectoryRecord(workspaceDir, {
+        type: 'message',
+        timestamp: new Date().toISOString(),
+        sessionId: event.sessionKey || 'unknown',
+        role: msg.role,
+        contentLength: content.length,
+        contentPreview: typeof sanitizedPreview === 'string' ? sanitizedPreview : '[sanitized]',
+        agentId: event.agentId || null
+    });
+}
+/**
+ * 脱敏处理：移除敏感参数（保留旧函数签名以兼容）
+ * @deprecated 使用 scrubSensitive 替代
+ */
+function sanitizeParams(params) {
+    return scrubSensitive(params);
+}
+/**
+ * 轨迹汇总统计（供 cron 任务调用）
+ */
+export function computeTrajectoryStats(workspaceDir) {
+    const dir = path.join(workspaceDir, TRAJECTORY_DIR);
+    const todayFile = path.join(dir, getTodayFilename());
+    if (!fs.existsSync(todayFile)) {
+        return { date: getTodayFilename(), totalRecords: 0, toolCalls: 0, llmOutputs: 0, messages: 0 };
+    }
+    const content = fs.readFileSync(todayFile, 'utf8');
+    const lines = content.split('\n').filter(line => line.trim());
+    const toolCalls = lines.filter(line => {
+        try {
+            return JSON.parse(line).type === 'tool_call';
+        }
+        catch {
+            return false;
+        }
+    }).length;
+    const llmOutputs = lines.filter(line => {
+        try {
+            return JSON.parse(line).type === 'llm_output';
+        }
+        catch {
+            return false;
+        }
+    }).length;
+    const messages = lines.filter(line => {
+        try {
+            return JSON.parse(line).type === 'message';
+        }
+        catch {
+            return false;
+        }
+    }).length;
+    return {
+        date: getTodayFilename(),
+        totalRecords: lines.length,
+        toolCalls,
+        llmOutputs,
+        messages,
+        generatedAt: new Date().toISOString()
+    };
+}

package/dist/index.js

@@ -6,6 +6,7 @@ import { handleBeforeReset, handleBeforeCompaction, handleAfterCompaction } from
 import { handleLlmOutput } from './hooks/llm.js';
 import { handleSubagentEnded } from './hooks/subagent.js';
 import { handleBeforeMessageWrite } from './hooks/message-sanitize.js';
+import * as TrajectoryCollector from './hooks/trajectory-collector.js';
 import { handleInitStrategy, handleManageOkr } from './commands/strategy.js';
 import { handleBootstrapTools, handleResearchTools } from './commands/capabilities.js';
 import { handleThinkingOs } from './commands/thinking-os.js';
@@ -97,6 +98,27 @@ const plugin = {
                 api.logger.error(`[PD] Error in before_message_write: ${String(err)}`);
             }
         });
+        // ── Hook: Trajectory Collection (Behavior Evolution Phase 0) ──
+        // Note: after_tool_call and llm_output are safe to collect
+        // before_message_write conflicts with message-sanitize, skipping for now
+        api.on('after_tool_call', (event, ctx) => {
+            try {
+                const workspaceDir = ctx.workspaceDir || api.resolvePath('.');
+                TrajectoryCollector.handleAfterToolCall(event, { ...ctx, workspaceDir });
+            }
+            catch (err) {
+                // Non-critical: don't log, just skip
+            }
+        });
+        api.on('llm_output', (event, ctx) => {
+            try {
+                const workspaceDir = ctx.workspaceDir || api.resolvePath('.');
+                TrajectoryCollector.handleLlmOutput(event, { ...ctx, workspaceDir });
+            }
+            catch (err) {
+                // Non-critical: don't log, just skip
+            }
+        });
         // ── Hook: Subagent Loop Closure ──
         api.on('subagent_spawning', (_event, _ctx) => {
             // No-op for now, just to satisfy the interface expected by tests.

package/dist/service/empathy-observer-manager.d.ts

@@ -38,5 +38,7 @@ export declare class EmpathyObserverManager {
     private parseJsonPayload;
     private extractAssistantText;
     private scoreFromSeverity;
+    private normalizeSeverity;
+    private normalizeConfidence;
 }
 export declare const empathyObserverManager: EmpathyObserverManager;

package/dist/service/empathy-observer-manager.js

@@ -71,7 +71,37 @@ export class EmpathyObserverManager {
             if (parsed?.damageDetected && sessionId) {
                 const wctx = WorkspaceContext.fromHookContext({ workspaceDir });
                 const score = this.scoreFromSeverity(parsed.severity, wctx.config);
-                trackFriction(sessionId, score, `observer_empathy_${parsed.severity || 'mild'}`, workspaceDir);
+                trackFriction(sessionId, score, `observer_empathy_${parsed.severity || 'mild'}`, workspaceDir, { source: 'user_empathy' });
+                const eventId = `emp_obs_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+                wctx.eventLog.recordPainSignal(sessionId, {
+                    score,
+                    source: 'user_empathy',
+                    reason: parsed.reason || 'Empathy observer detected likely user frustration.',
+                    isRisky: false,
+                    origin: 'system_infer',
+                    severity: this.normalizeSeverity(parsed.severity),
+                    confidence: this.normalizeConfidence(parsed.confidence),
+                    detection_mode: 'structured',
+                    deduped: false,
+                    trigger_text_excerpt: rawText.substring(0, 120),
+                    raw_score: score,
+                    calibrated_score: score,
+                    eventId,
+                });
+                try {
+                    wctx.trajectory?.recordPainEvent?.({
+                        sessionId,
+                        source: 'user_empathy',
+                        score,
+                        reason: parsed.reason || 'Empathy observer detected likely user frustration.',
+                        severity: this.normalizeSeverity(parsed.severity),
+                        origin: 'system_infer',
+                        confidence: this.normalizeConfidence(parsed.confidence),
+                    });
+                }
+                catch (error) {
+                    api.logger.warn(`[PD:EmpathyObserver] Failed to persist observer pain event for ${sessionId}: ${String(error)}`);
+                }
                 api.logger.info(`[PD:EmpathyObserver] Applied GFI +${score} for ${sessionId}`);
             }
         }
@@ -143,5 +173,17 @@ export class EmpathyObserverManager {
             return Number(config.get('empathy_engine.penalties.moderate') ?? 25);
         return Number(config.get('empathy_engine.penalties.mild') ?? 10);
     }
+    normalizeSeverity(severity) {
+        if (severity === 'severe')
+            return 'severe';
+        if (severity === 'moderate')
+            return 'moderate';
+        return 'mild';
+    }
+    normalizeConfidence(value) {
+        if (!Number.isFinite(value))
+            return 1;
+        return Math.max(0, Math.min(1, Number(value)));
+    }
 }
 export const empathyObserverManager = EmpathyObserverManager.getInstance();

package/dist/service/evolution-worker.d.ts

@@ -1,4 +1,5 @@
 import type { OpenClawPluginServiceContext, OpenClawPluginApi } from '../openclaw-sdk.js';
+import { WorkspaceContext } from '../core/workspace-context.js';
 export interface EvolutionQueueItem {
     id: string;
     task?: string;
@@ -9,7 +10,22 @@ export interface EvolutionQueueItem {
     trigger_text_preview?: string;
     status: 'pending' | 'in_progress' | 'completed';
 }
-export declare function hasRecentDuplicateTask(queue: EvolutionQueueItem[], source: string, preview: string, now: number): boolean;
+export declare const EVOLUTION_QUEUE_LOCK_SUFFIX = ".lock";
+export declare const PAIN_CANDIDATES_LOCK_SUFFIX = ".candidates.lock";
+export declare const LOCK_MAX_RETRIES = 50;
+export declare const LOCK_RETRY_DELAY_MS = 50;
+export declare const LOCK_STALE_MS = 30000;
+export declare function createEvolutionTaskId(source: string, score: number, preview: string, reason: string, now: number): string;
+export declare function shouldTrackPainCandidate(text: string): boolean;
+export declare function createPainCandidateFingerprint(text: string): string;
+export declare function summarizePainCandidateSample(text: string): string;
+/**
+ * Acquire an exclusive file lock for the given resource.
+ * Returns a release function. Uses 'wx' flag for atomic exclusive create.
+ * Detects stale locks by checking PID and mtime.
+ */
+export declare function acquireQueueLock(lockPath: string, logger: any): (() => void) | null;
+export declare function hasRecentDuplicateTask(queue: EvolutionQueueItem[], source: string, preview: string, now: number, reason?: string): boolean;
 export declare function hasEquivalentPromotedRule(dictionary: {
     getAllRules(): Record<string, {
         type: string;
@@ -18,6 +34,8 @@ export declare function hasEquivalentPromotedRule(dictionary: {
         status: string;
     }>;
 }, phrase: string): boolean;
+export declare function trackPainCandidate(text: string, wctx: WorkspaceContext): void;
+export declare function processPromotion(wctx: WorkspaceContext, logger: any, eventLog: any): void;
 export interface ExtendedEvolutionWorkerService {
     id: string;
     api: OpenClawPluginApi | null;

package/dist/service/evolution-worker.js

@@ -10,16 +10,63 @@ import { initPersistence, flushAllSessions } from '../core/session-tracker.js';
 let intervalId = null;
 const PAIN_QUEUE_DEDUP_WINDOW_MS = 30 * 60 * 1000;
 // P0 fix: File lock constants and helper for queue operations (prevents TOCTOU race)
-const EVOLUTION_QUEUE_LOCK_SUFFIX = '.lock';
-const LOCK_MAX_RETRIES = 50;
-const LOCK_RETRY_DELAY_MS = 50;
-const LOCK_STALE_MS = 30_000;
+export const EVOLUTION_QUEUE_LOCK_SUFFIX = '.lock';
+export const PAIN_CANDIDATES_LOCK_SUFFIX = '.candidates.lock';
+export const LOCK_MAX_RETRIES = 50;
+export const LOCK_RETRY_DELAY_MS = 50;
+export const LOCK_STALE_MS = 30_000;
+const PAIN_CANDIDATE_MAX_SAMPLES = 5;
+const PAIN_CANDIDATE_SAMPLE_LEN = 1000;
+const PAIN_CANDIDATE_FINGERPRINT_HEAD_LEN = 160;
+const PAIN_CANDIDATE_FINGERPRINT_TAIL_LEN = 80;
+export function createEvolutionTaskId(source, score, preview, reason, now) {
+    // Keep ids short for prompt injection, but include enough entropy to avoid
+    // collisions between different pain events that share the same source/score/preview.
+    return createHash('md5')
+        .update(`${source}:${score}:${preview}:${reason}:${now}`)
+        .digest('hex')
+        .substring(0, 8);
+}
+function normalizePainCandidateText(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+export function shouldTrackPainCandidate(text) {
+    const normalized = normalizePainCandidateText(text);
+    if (!normalized)
+        return false;
+    if (normalized === 'NO_REPLY')
+        return false;
+    // Skip empathy observer payloads: they are classifier telemetry, not user/system pain patterns.
+    if (normalized.startsWith('{')
+        && normalized.endsWith('}')
+        && normalized.includes('"damageDetected"')
+        && normalized.includes('"severity"')
+        && normalized.includes('"confidence"')) {
+        return false;
+    }
+    return true;
+}
+export function createPainCandidateFingerprint(text) {
+    const normalized = normalizePainCandidateText(text);
+    const head = normalized.substring(0, PAIN_CANDIDATE_FINGERPRINT_HEAD_LEN);
+    const tail = normalized.slice(-PAIN_CANDIDATE_FINGERPRINT_TAIL_LEN);
+    return createHash('md5')
+        .update(`${normalized.length}:${head}:${tail}`)
+        .digest('hex')
+        .substring(0, 8);
+}
+export function summarizePainCandidateSample(text) {
+    return normalizePainCandidateText(text).substring(0, PAIN_CANDIDATE_SAMPLE_LEN);
+}
+function isPendingPainCandidate(status) {
+    return status === undefined || status === 'pending';
+}
 /**
  * Acquire an exclusive file lock for the given resource.
  * Returns a release function. Uses 'wx' flag for atomic exclusive create.
  * Detects stale locks by checking PID and mtime.
  */
-function acquireQueueLock(lockPath, logger) {
+export function acquireQueueLock(lockPath, logger) {
     let retries = 0;
     while (retries < LOCK_MAX_RETRIES) {
         try {
@@ -75,18 +122,21 @@ function acquireQueueLock(lockPath, logger) {
     logger?.warn?.(`[PD:EvolutionWorker] Failed to acquire lock after ${LOCK_MAX_RETRIES} retries: ${lockPath}`);
     return null;
 }
-function normalizePainDedupKey(source, preview) {
-    return `${source.trim().toLowerCase()}::${preview.trim().toLowerCase()}`;
+function normalizePainDedupKey(source, preview, reason) {
+    // Include reason in dedup key to match createEvolutionTaskId() behavior
+    // Different reasons for the same source/preview should create different tasks
+    const normalizedReason = (reason || '').trim().toLowerCase();
+    return `${source.trim().toLowerCase()}::${preview.trim().toLowerCase()}::${normalizedReason}`;
 }
-export function hasRecentDuplicateTask(queue, source, preview, now) {
-    const key = normalizePainDedupKey(source, preview);
+export function hasRecentDuplicateTask(queue, source, preview, now, reason) {
+    const key = normalizePainDedupKey(source, preview, reason);
     return queue.some((task) => {
         if (task.status === 'completed')
             return false;
         const taskTime = new Date(task.timestamp).getTime();
         if (!Number.isFinite(taskTime) || (now - taskTime) > PAIN_QUEUE_DEDUP_WINDOW_MS)
             return false;
-        return normalizePainDedupKey(task.source, task.trigger_text_preview || '') === key;
+        return normalizePainDedupKey(task.source, task.trigger_text_preview || '', task.reason) === key;
     });
 }
 export function hasEquivalentPromotedRule(dictionary, phrase) {
@@ -148,12 +198,12 @@ function checkPainFlag(wctx, logger) {
                 }
             }
             const now = Date.now();
-            if (hasRecentDuplicateTask(queue, source, preview, now)) {
+            if (hasRecentDuplicateTask(queue, source, preview, now, reason)) {
                 logger?.info?.(`[PD:EvolutionWorker] Duplicate pain task skipped for source=${source} preview=${preview || 'N/A'}`);
                 fs.appendFileSync(painFlagPath, `\nstatus: queued\n`, 'utf8');
                 return;
             }
-            const taskId = createHash('md5').update(`${source}:${score}:${preview}`).digest('hex').substring(0, 8);
+            const taskId = createEvolutionTaskId(source, score, preview, reason, now);
             queue.push({
                 id: taskId,
                 score,
@@ -302,46 +352,77 @@ async function processDetectionQueue(wctx, api, eventLog) {
             logger.warn(`[PD:EvolutionWorker] Detection queue failed: ${String(err)}`);
     }
 }
-function trackPainCandidate(text, wctx) {
+export function trackPainCandidate(text, wctx) {
+    if (!shouldTrackPainCandidate(text))
+        return;
     const candidatePath = wctx.resolve('PAIN_CANDIDATES');
-    let data = { candidates: {} };
-    if (fs.existsSync(candidatePath)) {
-        try {
-            data = JSON.parse(fs.readFileSync(candidatePath, 'utf8'));
+    const lockPath = candidatePath + PAIN_CANDIDATES_LOCK_SUFFIX;
+    const releaseLock = acquireQueueLock(lockPath, console);
+    if (!releaseLock) {
+        console.warn('[PD:EvolutionWorker] Failed to acquire pain candidates lock, skipping track');
+        return;
+    }
+    try {
+        let data = { candidates: {} };
+        if (fs.existsSync(candidatePath)) {
+            try {
+                data = JSON.parse(fs.readFileSync(candidatePath, 'utf8'));
+            }
+            catch (e) {
+                // Keep going with empty data if parse fails, but log it
+                console.error(`[PD:EvolutionWorker] Failed to parse pain candidates: ${String(e)}`);
+            }
         }
-        catch (e) {
-            // Keep going with empty data if parse fails, but log it
-            console.error(`[PD:EvolutionWorker] Failed to parse pain candidates: ${String(e)}`);
+        const fingerprint = createPainCandidateFingerprint(text);
+        const now = new Date().toISOString();
+        if (!data.candidates[fingerprint]) {
+            data.candidates[fingerprint] = { count: 0, status: 'pending', firstSeen: now, lastSeen: now, samples: [] };
         }
+        const cand = data.candidates[fingerprint];
+        cand.status = cand.status || 'pending';
+        cand.count++;
+        cand.lastSeen = now;
+        const sample = summarizePainCandidateSample(text);
+        if (cand.samples.length < PAIN_CANDIDATE_MAX_SAMPLES && !cand.samples.includes(sample)) {
+            cand.samples.push(sample);
+        }
+        fs.writeFileSync(candidatePath, JSON.stringify(data, null, 2), 'utf8');
     }
-    const fingerprint = createHash('md5').update(text.substring(0, 50)).digest('hex').substring(0, 8);
-    if (!data.candidates[fingerprint]) {
-        data.candidates[fingerprint] = { count: 0, firstSeen: new Date().toISOString(), samples: [] };
+    finally {
+        releaseLock();
     }
-    const cand = data.candidates[fingerprint];
-    cand.count++;
-    if (cand.samples.length < 5)
-        cand.samples.push(text.substring(0, 200));
-    fs.writeFileSync(candidatePath, JSON.stringify(data, null, 2), 'utf8');
 }
-function processPromotion(wctx, logger, eventLog) {
+export function processPromotion(wctx, logger, eventLog) {
     const candidatePath = wctx.resolve('PAIN_CANDIDATES');
     if (!fs.existsSync(candidatePath))
         return;
+    const lockPath = candidatePath + PAIN_CANDIDATES_LOCK_SUFFIX;
+    const releaseLock = acquireQueueLock(lockPath, logger);
+    if (!releaseLock) {
+        logger?.warn?.('[PD:EvolutionWorker] Failed to acquire pain candidates lock, skipping promotion');
+        return;
+    }
     try {
         const config = wctx.config;
         const dictionary = wctx.dictionary;
         const data = JSON.parse(fs.readFileSync(candidatePath, 'utf8'));
         const countThreshold = config.get('thresholds.promotion_count_threshold') || 3;
         let promotedCount = 0;
+        let changed = false;
         for (const [fingerprint, cand] of Object.entries(data.candidates)) {
-            if (cand.status === 'pending' && cand.count >= countThreshold) {
+            if (isPendingPainCandidate(cand.status) && cand.count >= countThreshold) {
+                // Normalize undefined status to 'pending'
+                if (cand.status !== 'pending') {
+                    cand.status = 'pending';
+                    changed = true;
+                }
                 const commonPhrases = extractCommonSubstring(cand.samples);
                 if (commonPhrases.length > 0) {
                     const phrase = commonPhrases[0];
                     const ruleId = `P_PROMOTED_${fingerprint.toUpperCase()}`;
                     if (hasEquivalentPromotedRule(dictionary, phrase)) {
                         cand.status = 'duplicate';
+                        changed = true;
                         logger?.info?.(`[PD:EvolutionWorker] Skipping duplicate promoted rule for candidate ${fingerprint}: ${phrase}`);
                         continue;
                     }
@@ -356,10 +437,11 @@ function processPromotion(wctx, logger, eventLog) {
                     });
                     cand.status = 'promoted';
                     promotedCount++;
+                    changed = true;
                 }
             }
         }
-        if (promotedCount > 0) {
+        if (changed) {
             fs.writeFileSync(candidatePath, JSON.stringify(data, null, 2), 'utf8');
         }
     }
@@ -367,6 +449,9 @@ function processPromotion(wctx, logger, eventLog) {
         if (logger)
             logger.warn(`[PD:EvolutionWorker] Error during rule promotion: ${String(err)}`);
     }
+    finally {
+        releaseLock();
+    }
 }
 export const EvolutionWorkerService = {
     id: 'principles-evolution-worker',