principles-disciple 1.7.1 → 1.7.3

package/dist/core/session-tracker.js

@@ -4,13 +4,20 @@ import { SystemLogger } from './system-logger.js';
 const sessions = new Map();
 /** Directory for persisting session state */
 let persistDir = null;
-/** Debounce timer for persistence */
-let persistTimer = null;
+/** Debounce timers for persistence, one per session */
+const persistTimers = new Map();
 function logSessionTrackerWarning(message, error) {
     const detail = error instanceof Error ? error.message : error ? String(error) : '';
     const suffix = detail ? `: ${detail}` : '';
     console.warn(`[PD:SessionTracker] ${message}${suffix}`);
 }
+function touchActivity(state, kind = 'general') {
+    const now = Date.now();
+    state.lastActivityAt = now;
+    if (kind === 'control') {
+        state.lastControlActivityAt = now;
+    }
+}
 /**
  * Initialize persistence for session state.
  * Call this once during plugin startup.
@@ -82,18 +89,24 @@ function persistSession(state) {
  * Schedule persistence with debounce.
  */
 function schedulePersistence(state) {
-    if (persistTimer) {
-        clearTimeout(persistTimer);
+    const existing = persistTimers.get(state.sessionId);
+    if (existing) {
+        clearTimeout(existing);
     }
-    persistTimer = setTimeout(() => {
+    const timer = setTimeout(() => {
         persistSession(state);
-        persistTimer = null;
+        persistTimers.delete(state.sessionId);
     }, 1000); // 1 second debounce
+    persistTimers.set(state.sessionId, timer);
 }
 /**
  * Force persist all sessions immediately.
  */
 export function flushAllSessions() {
+    for (const timer of persistTimers.values()) {
+        clearTimeout(timer);
+    }
+    persistTimers.clear();
     for (const state of sessions.values()) {
         persistSession(state);
     }
@@ -108,6 +121,7 @@ function getOrCreateSession(sessionId, workspaceDir) {
             llmTurns: 0,
             blockedAttempts: 0,
             lastActivityAt: Date.now(),
+            lastControlActivityAt: Date.now(),
             totalInputTokens: 0,
             totalOutputTokens: 0,
             cacheHits: 0,
@@ -141,13 +155,13 @@ export function trackToolRead(sessionId, filePath, workspaceDir) {
     const state = getOrCreateSession(sessionId, workspaceDir);
     const normalizedPath = path.posix.normalize(filePath.replace(/\\/g, '/'));
     state.toolReadsByFile[normalizedPath] = (state.toolReadsByFile[normalizedPath] || 0) + 1;
-    state.lastActivityAt = Date.now();
+    touchActivity(state);
     return state;
 }
 export function trackLlmOutput(sessionId, usage, config, workspaceDir) {
     const state = getOrCreateSession(sessionId, workspaceDir);
     state.llmTurns += 1;
-    state.lastActivityAt = Date.now();
+    touchActivity(state);
     if (usage) {
         state.totalInputTokens += usage.input || 0;
         state.totalOutputTokens += usage.output || 0;
@@ -195,7 +209,7 @@ export function trackFriction(sessionId, deltaF, hash, workspaceDir, options) {
     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();
+    touchActivity(state, 'control');
     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
     state.dailyToolFailures++;
@@ -228,6 +242,7 @@ export function resetFriction(sessionId, workspaceDir, options) {
                 state.lastErrorSource = '';
             }
         }
+        touchActivity(state, 'control');
         schedulePersistence(state);
         return state;
     }
@@ -239,6 +254,7 @@ export function resetFriction(sessionId, workspaceDir, options) {
     state.lastErrorSource = '';
     state.consecutiveErrors = 0;
     state.lastErrorHash = '';
+    touchActivity(state, 'control');
     // Schedule persistence
     schedulePersistence(state);
     return state;
@@ -250,6 +266,7 @@ export function resetFriction(sessionId, workspaceDir, options) {
 export function recordThinkingCheckpoint(sessionId, workspaceDir) {
     const state = getOrCreateSession(sessionId, workspaceDir);
     state.lastThinkingTimestamp = Date.now();
+    touchActivity(state, 'control');
     SystemLogger.log(state.workspaceDir, 'THINKING_CHECKPOINT', `Deep thinking recorded at ${new Date(state.lastThinkingTimestamp).toISOString()}`);
     schedulePersistence(state);
     return state;
@@ -269,13 +286,14 @@ export function hasRecentThinking(sessionId, windowMs = 5 * 60 * 1000) {
 export function trackBlock(sessionId) {
     const state = getOrCreateSession(sessionId);
     state.blockedAttempts += 1;
-    state.lastActivityAt = Date.now();
+    touchActivity(state, 'control');
+    schedulePersistence(state);
     return state;
 }
 export function setInjectedProbationIds(sessionId, ids, workspaceDir) {
     const state = getOrCreateSession(sessionId, workspaceDir);
     state.injectedProbationIds = [...ids];
-    state.lastActivityAt = Date.now();
+    touchActivity(state, 'control');
     schedulePersistence(state);
     return state;
 }
@@ -300,6 +318,11 @@ export function listSessions(workspaceDir) {
     }));
 }
 export function clearSession(sessionId) {
+    const timer = persistTimers.get(sessionId);
+    if (timer) {
+        clearTimeout(timer);
+        persistTimers.delete(sessionId);
+    }
     sessions.delete(sessionId);
 }
 // Memory cleanup for abandoned sessions (older than 2 hours)
@@ -307,6 +330,11 @@ export function garbageCollectSessions() {
     const twoHoursAgo = Date.now() - 2 * 60 * 60 * 1000;
     for (const [id, state] of sessions.entries()) {
         if (state.lastActivityAt < twoHoursAgo) {
+            const timer = persistTimers.get(id);
+            if (timer) {
+                clearTimeout(timer);
+                persistTimers.delete(id);
+            }
             sessions.delete(id);
             // Also delete persisted file
             if (persistDir) {

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

@@ -21,8 +21,7 @@ export interface TrustScorecard {
     reward_policy?: 'frozen_all_positive' | 'frozen_atomic_positive_keep_plan_ready';
 }
 export type TrustStage = 1 | 2 | 3 | 4;
-export declare const EXPLORATORY_TOOLS: string[];
-export declare const CONSTRUCTIVE_TOOLS: string[];
+export declare const EXPLORATORY_TOOLS: Set<string>;
 export declare class TrustEngine {
     private scorecard;
     private workspaceDir;

package/dist/core/trust-engine.js

@@ -8,27 +8,8 @@ import { EventLogService } from './event-log.js';
 import { resolvePdPath } from './paths.js';
 import { ConfigService } from './config-service.js';
 import { TrajectoryRegistry } from './trajectory.js';
-export const EXPLORATORY_TOOLS = [
-    // 文件读取
-    'read', 'read_file', 'read_many_files', 'image_read',
-    // 搜索和列表
-    'search_file_content', 'grep', 'grep_search', 'list_directory', 'ls', 'glob',
-    // Web
-    'web_fetch', 'web_search',
-    // 用户交互
-    'ask_user', 'ask_user_question',
-    // LSP
-    'lsp_hover', 'lsp_goto_definition', 'lsp_find_references',
-    // 内存和状态
-    'memory_recall', 'save_memory', 'todo_read', 'todo_write',
-    // 状态查询
-    'pd-status', 'trust', 'report',
-];
-export const CONSTRUCTIVE_TOOLS = [
-    'write', 'write_file', 'edit', 'edit_file', 'replace', 'apply_patch',
-    'insert', 'patch', 'delete_file', 'move_file', 'run_shell_command',
-    'pd_run_worker', 'sessions_spawn', 'evolve-task', 'init-strategy'
-];
+import { EXPLORATORY_TOOLS as SHARED_EXPLORATORY_TOOLS } from '../constants/tools.js';
+export const EXPLORATORY_TOOLS = new Set(SHARED_EXPLORATORY_TOOLS);
 const LEGACY_TRUST_REWARD_POLICY = 'frozen_all_positive';
 export class TrustEngine {
     scorecard;
@@ -130,7 +111,7 @@ export class TrustEngine {
     recordSuccess(reason, context, isSubagent = false) {
         const toolName = context?.toolName;
         // 1. Check if this is an exploratory tool success
-        const isExploratory = toolName && EXPLORATORY_TOOLS.includes(toolName);
+        const isExploratory = toolName ? EXPLORATORY_TOOLS.has(toolName) : false;
         if (reason === 'tool_success' && isExploratory) {
             this.scorecard.exploratory_failure_streak = 0;
             this.touchScorecard();
@@ -147,7 +128,7 @@ export class TrustEngine {
         const penalties = settings.penalties;
         const toolName = context?.toolName;
         // 1. Classification: Is this an exploratory failure?
-        const isExploratory = toolName && EXPLORATORY_TOOLS.includes(toolName);
+        const isExploratory = toolName ? EXPLORATORY_TOOLS.has(toolName) : false;
         // 2. Cold start grace (only for non-risky actions)
         if (type !== 'risky' && this.isColdStart() && (this.scorecard.grace_failures_remaining || 0) > 0) {
             this.scorecard.grace_failures_remaining = (this.scorecard.grace_failures_remaining || 0) - 1;

package/dist/hooks/gate.js

@@ -8,32 +8,14 @@ import { assessRiskLevel, estimateLineChanges } from '../core/risk-calculator.js
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { checkEvolutionGate } from '../core/evolution-engine.js';
 import { EventLogService } from '../core/event-log.js';
+import { AGENT_TOOLS, BASH_TOOLS_SET, HIGH_RISK_TOOLS, LOW_RISK_WRITE_TOOLS, WRITE_TOOLS, } from '../constants/tools.js';
 // ═══ GFI Gate Tool Tiers ═══
 // TIER 0: 只读工具 - 永不拦截
-const READ_ONLY_TOOLS = new Set([
-    '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',
-    'todo_read', 'save_memory',
-    'deep_reflect',
-]);
 // TIER 1: 低风险修改 - GFI >= low_risk_block 时拦截
 // 注意：pd_run_worker、sessions_spawn、task 是 Agent 派生工具，不应被 GFI Gate 拦截
 // 它们属于 AGENT_TOOLS，在早期过滤后直接放行
-const LOW_RISK_WRITE_TOOLS = new Set([
-    'write', 'write_file',
-    'edit', 'edit_file', 'replace', 'apply_patch', 'insert', 'patch',
-]);
 // TIER 2: 高风险操作 - GFI >= high_risk_block 时拦截
-const HIGH_RISK_TOOLS = new Set([
-    'delete_file', 'move_file',
-]);
 // TIER 3: Bash 命令 - 根据内容判断
-const BASH_TOOLS_SET = new Set([
-    'bash', 'run_shell_command', 'exec', 'execute', 'shell', 'cmd',
-]);
 /**
  * 分析 Bash 命令风险等级
  */
@@ -118,12 +100,9 @@ function calculateDynamicThreshold(baseThreshold, trustStage, lineChanges, confi
 export function handleBeforeToolCall(event, ctx) {
     const logger = ctx.logger || console;
     // 1. Identify tool type
-    const WRITE_TOOLS = ['write', 'edit', 'apply_patch', 'write_file', 'replace', 'insert', 'patch', 'edit_file', 'delete_file', 'move_file'];
-    const BASH_TOOLS = ['bash', 'run_shell_command', 'exec', 'execute', 'shell', 'cmd'];
-    const AGENT_TOOLS = ['pd_run_worker', 'sessions_spawn'];
-    const isBash = BASH_TOOLS.includes(event.toolName);
-    const isWriteTool = WRITE_TOOLS.includes(event.toolName);
-    const isAgentTool = AGENT_TOOLS.includes(event.toolName);
+    const isBash = BASH_TOOLS_SET.has(event.toolName);
+    const isWriteTool = WRITE_TOOLS.has(event.toolName);
+    const isAgentTool = AGENT_TOOLS.has(event.toolName);
     // Profile loaded first for config-driven behavior (see below)
     if (!ctx.workspaceDir || (!isWriteTool && !isBash && !isAgentTool)) {
         return;

package/dist/hooks/prompt.js

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { getSession, resetFriction } from '../core/session-tracker.js';
+import { clearInjectedProbationIds, getSession, resetFriction, setInjectedProbationIds } from '../core/session-tracker.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { defaultContextConfig } from '../types.js';
 import { extractSummary, getHistoryVersions } from '../core/focus-history.js';
@@ -575,6 +575,14 @@ ACTION: Run self-audit. If stable, reply ONLY with "HEARTBEAT_OK".
         const reducer = wctx.evolutionReducer;
         const active = reducer.getActivePrinciples().slice(-3);
         const probation = reducer.getProbationPrinciples().slice(0, 5);
+        if (ctx.sessionId) {
+            if (probation.length > 0) {
+                setInjectedProbationIds(ctx.sessionId, probation.map((p) => p.id), workspaceDir);
+            }
+            else {
+                clearInjectedProbationIds(ctx.sessionId, workspaceDir);
+            }
+        }
         if (active.length > 0 || probation.length > 0) {
             const lines = [];
             if (active.length > 0) {
@@ -593,6 +601,9 @@ ACTION: Run self-audit. If stable, reply ONLY with "HEARTBEAT_OK".
         }
     }
     catch (e) {
+        if (ctx.sessionId) {
+            clearInjectedProbationIds(ctx.sessionId, workspaceDir);
+        }
         logger?.warn?.(`[PD:Prompt] Failed to load evolution principles: ${String(e)}`);
     }
     // Build appendSystemContext with recency effect

package/dist/hooks/subagent.js

@@ -1,8 +1,22 @@
+import * as fs from 'fs';
 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';
+import { acquireQueueLock } from '../service/evolution-worker.js';
+const COMPLETION_RETRY_DELAY_MS = 250;
+const COMPLETION_MAX_RETRIES = 3;
+const COMPLETION_RETRY_TTL_MS = 60 * 60 * 1000; // 1 hour TTL for retry entries
+const DIAGNOSTICIAN_SESSION_PREFIX = 'agent:diagnostician:';
+const completionRetryCounts = new Map();
+// Cleanup expired retry entries periodically
+function cleanupExpiredRetryEntries() {
+    const now = Date.now();
+    for (const [key, value] of completionRetryCounts.entries()) {
+        if (now > value.expires) {
+            completionRetryCounts.delete(key);
+        }
+    }
+}
 function emitSubagentPainEvent(wctx, payload) {
     try {
         wctx.evolutionReducer.emitSync({
@@ -22,19 +36,73 @@ function emitSubagentPainEvent(wctx, payload) {
         console.warn(`[PD:Subagent] failed to emit evolution event: ${String(e)}`);
     }
 }
+function isDiagnosticianSession(targetSessionKey) {
+    return typeof targetSessionKey === 'string' && targetSessionKey.startsWith(DIAGNOSTICIAN_SESSION_PREFIX);
+}
+function cleanupPainFlagForTask(wctx, completedTaskId, queue) {
+    const painFlagPath = wctx.resolve('PAIN_FLAG');
+    try {
+        const painData = fs.readFileSync(painFlagPath, 'utf8');
+        const taskIdMatch = painData.match(/^task_id:\s*(.+)$/m);
+        const painTaskId = taskIdMatch?.[1]?.trim();
+        const hasQueuedStatus = painData.includes('status: queued');
+        const hasRemainingActiveTasks = queue.some((task) => task?.status === 'pending' || task?.status === 'in_progress');
+        if (!hasQueuedStatus)
+            return;
+        if (painTaskId) {
+            if (painTaskId === completedTaskId) {
+                fs.unlinkSync(painFlagPath);
+            }
+            return;
+        }
+        // Legacy fallback: only clear an untagged queued pain flag when there are
+        // no active queue entries left. This avoids unrelated diagnostician runs
+        // from deleting a queued flag that belongs to another task.
+        if (!hasRemainingActiveTasks) {
+            fs.unlinkSync(painFlagPath);
+        }
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return; // File doesn't exist, nothing to clean up
+        console.error(`[PD:Subagent] Failed to cleanup pain flag: ${String(e)}`);
+    }
+}
+function getCompletionRetryKey(workspaceDir, targetSessionKey) {
+    return `${workspaceDir}::${targetSessionKey}`;
+}
+function scheduleCompletionRetry(event, ctx, attempt) {
+    const workspaceDir = ctx.workspaceDir;
+    const targetSessionKey = event.targetSessionKey;
+    if (!workspaceDir || !targetSessionKey || attempt >= COMPLETION_MAX_RETRIES) {
+        return;
+    }
+    cleanupExpiredRetryEntries();
+    const retryKey = getCompletionRetryKey(workspaceDir, targetSessionKey);
+    completionRetryCounts.set(retryKey, {
+        count: attempt + 1,
+        expires: Date.now() + COMPLETION_RETRY_TTL_MS
+    });
+    setTimeout(() => {
+        void handleSubagentEnded(event, ctx).finally(() => {
+            const entry = completionRetryCounts.get(retryKey);
+            if (!entry || entry.count <= attempt + 1) {
+                completionRetryCounts.delete(retryKey);
+            }
+        });
+    }, COMPLETION_RETRY_DELAY_MS);
+}
 export async function handleSubagentEnded(event, ctx) {
     const { outcome, targetSessionKey } = event;
     const workspaceDir = ctx.workspaceDir;
     if (!workspaceDir)
         return;
     const wctx = WorkspaceContext.fromHookContext(ctx);
-    // Empathy observer subagent session is handled by sidecar manager
     if (targetSessionKey?.startsWith('empathy_obs:')) {
         await empathyObserverManager.reap(ctx.api, targetSessionKey, workspaceDir);
         return;
     }
     const config = wctx.config;
-    // 1. Autonomous Pain Capture: If subagent failed, record pain
     if (outcome === 'error' || outcome === 'timeout') {
         const scoreSettings = config.get('scores');
         const score = outcome === 'error' ? scoreSettings.subagent_error_penalty : scoreSettings.subagent_timeout_penalty;
@@ -53,70 +121,48 @@ export async function handleSubagentEnded(event, ctx) {
             sessionId: ctx.sessionId,
         });
     }
-    // 2. Loop Closure: Clean up evolution queue if any subagent finished successfully
     if (outcome === 'ok' || outcome === 'deleted') {
-        // ── Trust Engine: Record success using V2 API ──
         wctx.trust.recordSuccess('subagent_success', {
             sessionId: ctx.sessionId,
             api: ctx.api
         }, 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;
-                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) {
-                    fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
-                }
-            }
-            catch (e) {
-                console.error(`[PD:Subagent] Failed to update evolution queue: ${String(e)}`);
-            }
-            finally {
-                releaseLock();
-            }
+    }
+    if ((outcome !== 'ok' && outcome !== 'deleted') || !isDiagnosticianSession(targetSessionKey)) {
+        return;
+    }
+    const queuePath = wctx.resolve('EVOLUTION_QUEUE');
+    if (!fs.existsSync(queuePath))
+        return;
+    const retryKey = getCompletionRetryKey(workspaceDir, targetSessionKey);
+    const retryEntry = completionRetryCounts.get(retryKey);
+    const attempt = retryEntry?.count || 0;
+    let releaseLock = null;
+    try {
+        releaseLock = await acquireQueueLock(queuePath, console);
+        const queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
+        let completedTaskId = null;
+        const matchedTask = queue.find((task) => task?.status === 'in_progress'
+            && typeof task?.assigned_session_key === 'string'
+            && task.assigned_session_key === targetSessionKey);
+        if (matchedTask) {
+            matchedTask.status = 'completed';
+            matchedTask.completed_at = new Date().toISOString();
+            delete matchedTask.assigned_session_key;
+            completedTaskId = matchedTask.id;
+        }
+        else {
+            console.warn(`[PD:Subagent] No in-progress evolution task matched subagent session ${targetSessionKey}`);
         }
+        if (completedTaskId) {
+            fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
+            cleanupPainFlagForTask(wctx, completedTaskId, queue);
+        }
+    }
+    catch (e) {
+        console.error(`[PD:Subagent] Failed to update evolution queue: ${String(e)}`);
+        scheduleCompletionRetry(event, ctx, attempt);
+    }
+    finally {
+        releaseLock?.();
     }
 }

package/dist/service/control-ui-query-service.d.ts

@@ -2,6 +2,8 @@ export interface OverviewResponse {
     workspaceDir: string;
     generatedAt: string;
     dataFreshness: string | null;
+    dataSource: 'trajectory_db_analytics';
+    runtimeControlPlaneSource: 'pd_evolution_status';
     summary: {
         repeatErrorRate: number;
         userCorrectionRate: number;

package/dist/service/control-ui-query-service.js

@@ -98,6 +98,8 @@ export class ControlUiQueryService {
             workspaceDir: this.workspaceDir,
             generatedAt: new Date().toISOString(),
             dataFreshness: stats.lastIngestAt,
+            dataSource: 'trajectory_db_analytics',
+            runtimeControlPlaneSource: 'pd_evolution_status',
             summary: {
                 repeatErrorRate: roundRate(Number(failureStats.repeated_failures), Number(failureStats.total_failures)),
                 userCorrectionRate: roundRate(correctionTotal, stats.userTurns),

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

@@ -7,6 +7,10 @@ export interface EvolutionQueueItem {
     source: string;
     reason: string;
     timestamp: string;
+    enqueued_at?: string;
+    started_at?: string;
+    completed_at?: string;
+    assigned_session_key?: string;
     trigger_text_preview?: string;
     status: 'pending' | 'in_progress' | 'completed';
 }
@@ -19,12 +23,8 @@ export declare function createEvolutionTaskId(source: string, score: number, pre
 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 acquireQueueLock(resourcePath: string, logger: any, lockSuffix?: string): Promise<() => void>;
+export declare function extractEvolutionTaskId(task: string): string | null;
 export declare function hasRecentDuplicateTask(queue: EvolutionQueueItem[], source: string, preview: string, now: number, reason?: string): boolean;
 export declare function hasEquivalentPromotedRule(dictionary: {
     getAllRules(): Record<string, {
@@ -34,8 +34,12 @@ 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 declare function trackPainCandidate(text: string, wctx: WorkspaceContext): Promise<void>;
+export declare function processPromotion(wctx: WorkspaceContext, logger: any, eventLog: any): Promise<void>;
+export declare function registerEvolutionTaskSession(workspaceResolve: (key: string) => string, taskId: string, sessionKey: string, logger?: {
+    warn?: (message: string) => void;
+    info?: (message: string) => void;
+}): Promise<boolean>;
 export interface ExtendedEvolutionWorkerService {
     id: string;
     api: OpenClawPluginApi | null;