principles-disciple 1.7.1 → 1.7.2

package/dist/service/evolution-worker.js

@@ -7,6 +7,7 @@ import { extractCommonSubstring } from '../utils/nlp.js';
 import { SystemLogger } from '../core/system-logger.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { initPersistence, flushAllSessions } from '../core/session-tracker.js';
+import { acquireLockAsync, releaseLock } from '../utils/file-lock.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)
@@ -61,84 +62,55 @@ export function summarizePainCandidateSample(text) {
 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.
- */
-export function acquireQueueLock(lockPath, logger) {
-    let retries = 0;
-    while (retries < LOCK_MAX_RETRIES) {
-        try {
-            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') {
-                // Check if lock is stale
-                try {
-                    const stat = fs.statSync(lockPath);
-                    const content = fs.readFileSync(lockPath, 'utf8').trim();
-                    const pid = parseInt(content.split('\n')[0] || '0', 10);
-                    let isStale = false;
-                    if (pid > 0) {
-                        try {
-                            process.kill(pid, 0);
-                        }
-                        catch (e) {
-                            if (e.code === 'ESRCH')
-                                isStale = true;
-                        }
-                        if (!isStale && Date.now() - stat.mtimeMs > LOCK_STALE_MS)
-                            isStale = true;
-                    }
-                    else if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
-                        isStale = true;
-                    }
-                    if (isStale) {
-                        fs.unlinkSync(lockPath);
-                        retries++;
-                        const start = Date.now();
-                        while (Date.now() - start < LOCK_RETRY_DELAY_MS) { /* spin */ }
-                        continue;
-                    }
-                }
-                catch { /* stat/read failed, treat as busy */ }
-                retries++;
-                const start = Date.now();
-                while (Date.now() - start < LOCK_RETRY_DELAY_MS) { /* spin */ }
-                continue;
-            }
-            throw err;
-        }
+export async function acquireQueueLock(resourcePath, logger, lockSuffix = EVOLUTION_QUEUE_LOCK_SUFFIX) {
+    try {
+        const ctx = await acquireLockAsync(resourcePath, {
+            lockSuffix,
+            maxRetries: LOCK_MAX_RETRIES,
+            baseRetryDelayMs: LOCK_RETRY_DELAY_MS,
+            lockStaleMs: LOCK_STALE_MS,
+        });
+        return () => releaseLock(ctx);
+    }
+    catch (error) {
+        logger?.warn?.(`[PD:EvolutionWorker] Failed to acquire lock for ${resourcePath}: ${String(error)}`);
+        throw error;
     }
-    logger?.warn?.(`[PD:EvolutionWorker] Failed to acquire lock after ${LOCK_MAX_RETRIES} retries: ${lockPath}`);
-    return null;
 }
-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}`;
+async function requireQueueLock(resourcePath, logger, scope, lockSuffix = EVOLUTION_QUEUE_LOCK_SUFFIX) {
+    try {
+        return await acquireQueueLock(resourcePath, logger, lockSuffix);
+    }
+    catch {
+        throw new Error(`[PD:EvolutionWorker] ${scope}: queue lock unavailable for ${resourcePath}`);
+    }
 }
-export function hasRecentDuplicateTask(queue, source, preview, now, reason) {
+export function extractEvolutionTaskId(task) {
+    if (!task)
+        return null;
+    const match = task.match(/\[ID:\s*([A-Za-z0-9_-]+)\]/);
+    return match?.[1] || null;
+}
+function findRecentDuplicateTask(queue, source, preview, now, reason) {
     const key = normalizePainDedupKey(source, preview, reason);
-    return queue.some((task) => {
+    return queue.find((task) => {
         if (task.status === 'completed')
             return false;
-        const taskTime = new Date(task.timestamp).getTime();
+        const taskTime = new Date(task.enqueued_at || task.timestamp).getTime();
         if (!Number.isFinite(taskTime) || (now - taskTime) > PAIN_QUEUE_DEDUP_WINDOW_MS)
             return false;
         return normalizePainDedupKey(task.source, task.trigger_text_preview || '', task.reason) === key;
     });
 }
+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, reason) {
+    return !!findRecentDuplicateTask(queue, source, preview, now, reason);
+}
 export function hasEquivalentPromotedRule(dictionary, phrase) {
     const normalizedPhrase = phrase.trim().toLowerCase();
     return Object.values(dictionary.getAllRules()).some((rule) => {
@@ -153,7 +125,7 @@ export function hasEquivalentPromotedRule(dictionary, phrase) {
         return false;
     });
 }
-function checkPainFlag(wctx, logger) {
+async function checkPainFlag(wctx, logger) {
     try {
         const painFlagPath = wctx.resolve('PAIN_FLAG');
         if (!fs.existsSync(painFlagPath))
@@ -182,10 +154,7 @@ function checkPainFlag(wctx, logger) {
         if (logger)
             logger.info(`[PD:EvolutionWorker] Detected pain flag (score: ${score}, source: ${source}). Enqueueing evolution task.`);
         const queuePath = wctx.resolve('EVOLUTION_QUEUE');
-        const lockPath = queuePath + EVOLUTION_QUEUE_LOCK_SUFFIX;
-        const releaseLock = acquireQueueLock(lockPath, logger);
-        if (!releaseLock)
-            return; // Could not acquire lock
+        const releaseLock = await requireQueueLock(queuePath, logger, 'checkPainFlag');
         try {
             let queue = [];
             if (fs.existsSync(queuePath)) {
@@ -198,9 +167,10 @@ function checkPainFlag(wctx, logger) {
                 }
             }
             const now = Date.now();
-            if (hasRecentDuplicateTask(queue, source, preview, now, reason)) {
+            const duplicateTask = findRecentDuplicateTask(queue, source, preview, now, reason);
+            if (duplicateTask) {
                 logger?.info?.(`[PD:EvolutionWorker] Duplicate pain task skipped for source=${source} preview=${preview || 'N/A'}`);
-                fs.appendFileSync(painFlagPath, `\nstatus: queued\n`, 'utf8');
+                fs.appendFileSync(painFlagPath, `\nstatus: queued\ntask_id: ${duplicateTask.id}\n`, 'utf8');
                 return;
             }
             const taskId = createEvolutionTaskId(source, score, preview, reason, now);
@@ -211,10 +181,11 @@ function checkPainFlag(wctx, logger) {
                 reason,
                 trigger_text_preview: preview,
                 timestamp: new Date(now).toISOString(),
+                enqueued_at: new Date(now).toISOString(),
                 status: 'pending'
             });
             fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
-            fs.appendFileSync(painFlagPath, '\nstatus: queued\n', 'utf8');
+            fs.appendFileSync(painFlagPath, `\nstatus: queued\ntask_id: ${taskId}\n`, 'utf8');
         }
         finally {
             releaseLock();
@@ -225,14 +196,12 @@ function checkPainFlag(wctx, logger) {
             logger.warn(`[PD:EvolutionWorker] Error processing pain flag: ${String(err)}`);
     }
 }
-function processEvolutionQueue(wctx, logger, eventLog) {
+async function processEvolutionQueue(wctx, logger, eventLog) {
     const queuePath = wctx.resolve('EVOLUTION_QUEUE');
     if (!fs.existsSync(queuePath))
         return;
-    const lockPath = queuePath + EVOLUTION_QUEUE_LOCK_SUFFIX;
-    const releaseLock = acquireQueueLock(lockPath, logger);
-    if (!releaseLock)
-        return; // Could not acquire lock
+    const directivePath = wctx.resolve('EVOLUTION_DIRECTIVE');
+    const releaseLock = await requireQueueLock(queuePath, logger, 'processEvolutionQueue');
     try {
         let queue = [];
         try {
@@ -248,29 +217,29 @@ function processEvolutionQueue(wctx, logger, eventLog) {
         const timeout = config.get('intervals.task_timeout_ms') || (30 * 60 * 1000);
         for (const task of queue) {
             if (task.status === 'in_progress' && task.timestamp) {
-                const age = Date.now() - new Date(task.timestamp).getTime();
+                const startedAt = task.started_at || task.timestamp;
+                const age = Date.now() - new Date(startedAt).getTime();
                 if (age > timeout) {
                     if (logger)
                         logger.info(`[PD:EvolutionWorker] Resetting timed-out task: ${task.id}`);
                     task.status = 'pending';
+                    delete task.started_at;
+                    delete task.assigned_session_key;
                     queueChanged = true;
                 }
             }
         }
         const pendingTasks = queue.filter(t => t.status === 'pending');
         if (pendingTasks.length > 0) {
-            const directivePath = wctx.resolve('EVOLUTION_DIRECTIVE');
             const highestScoreTask = pendingTasks.sort((a, b) => b.score - a.score)[0];
+            const nowIso = new Date().toISOString();
             const taskDescription = `Diagnose systemic pain [ID: ${highestScoreTask.id}]. Source: ${highestScoreTask.source}. Reason: ${highestScoreTask.reason}. ` +
                 `Trigger text: "${highestScoreTask.trigger_text_preview || 'N/A'}"`;
-            const directive = {
-                active: true,
-                task: taskDescription,
-                timestamp: new Date().toISOString()
-            };
-            fs.writeFileSync(directivePath, JSON.stringify(directive, null, 2), 'utf8');
             highestScoreTask.task = taskDescription;
             highestScoreTask.status = 'in_progress';
+            highestScoreTask.started_at = nowIso;
+            delete highestScoreTask.completed_at;
+            delete highestScoreTask.assigned_session_key;
             queueChanged = true;
             if (eventLog) {
                 eventLog.recordEvolutionTask({
@@ -279,6 +248,43 @@ function processEvolutionQueue(wctx, logger, eventLog) {
                     reason: highestScoreTask.reason
                 });
             }
+            fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
+            queueChanged = false;
+            const directive = {
+                active: true,
+                taskId: highestScoreTask.id,
+                task: taskDescription,
+                timestamp: nowIso
+            };
+            try {
+                fs.writeFileSync(directivePath, JSON.stringify(directive, null, 2), 'utf8');
+            }
+            catch (directiveError) {
+                highestScoreTask.status = 'pending';
+                delete highestScoreTask.started_at;
+                delete highestScoreTask.task;
+                delete highestScoreTask.assigned_session_key;
+                try {
+                    fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
+                }
+                catch (rollbackError) {
+                    throw new Error(`[PD:EvolutionWorker] Failed to persist directive and failed to roll back queue: ${String(directiveError)}; rollback=${String(rollbackError)}`);
+                }
+                throw directiveError;
+            }
+        }
+        else {
+            const hasInProgressTask = queue.some((task) => task.status === 'in_progress');
+            if (!hasInProgressTask && fs.existsSync(directivePath)) {
+                const clearedAt = new Date().toISOString();
+                fs.writeFileSync(directivePath, JSON.stringify({
+                    active: false,
+                    task: null,
+                    taskId: null,
+                    timestamp: clearedAt,
+                    clearedAt,
+                }, null, 2), 'utf8');
+            }
         }
         if (queueChanged) {
             fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
@@ -343,7 +349,7 @@ async function processDetectionQueue(wctx, api, eventLog) {
                     if (logger)
                         logger.debug?.(`[PD:EvolutionWorker] L3 Semantic search failed: ${String(e)}`);
                 }
-                trackPainCandidate(text, wctx);
+                await trackPainCandidate(text, wctx);
             }
         }
     }
@@ -352,16 +358,11 @@ async function processDetectionQueue(wctx, api, eventLog) {
             logger.warn(`[PD:EvolutionWorker] Detection queue failed: ${String(err)}`);
     }
 }
-export function trackPainCandidate(text, wctx) {
+export async function trackPainCandidate(text, wctx) {
     if (!shouldTrackPainCandidate(text))
         return;
     const candidatePath = wctx.resolve('PAIN_CANDIDATES');
-    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;
-    }
+    const releaseLock = await requireQueueLock(candidatePath, console, 'trackPainCandidate', PAIN_CANDIDATES_LOCK_SUFFIX);
     try {
         let data = { candidates: {} };
         if (fs.existsSync(candidatePath)) {
@@ -392,16 +393,11 @@ export function trackPainCandidate(text, wctx) {
         releaseLock();
     }
 }
-export function processPromotion(wctx, logger, eventLog) {
+export async 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;
-    }
+    const releaseLock = await requireQueueLock(candidatePath, logger, 'processPromotion', PAIN_CANDIDATES_LOCK_SUFFIX);
     try {
         const config = wctx.config;
         const dictionary = wctx.dictionary;
@@ -453,6 +449,36 @@ export function processPromotion(wctx, logger, eventLog) {
         releaseLock();
     }
 }
+export async function registerEvolutionTaskSession(workspaceResolve, taskId, sessionKey, logger) {
+    const queuePath = workspaceResolve('EVOLUTION_QUEUE');
+    if (!fs.existsSync(queuePath))
+        return false;
+    const releaseLock = await requireQueueLock(queuePath, logger, 'registerEvolutionTaskSession');
+    try {
+        let queue;
+        try {
+            queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
+        }
+        catch (parseErr) {
+            logger?.warn?.(`[PD:EvolutionWorker] Failed to parse EVOLUTION_QUEUE for session registration: ${queuePath} - ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
+            return false;
+        }
+        const task = queue.find((item) => item.id === taskId && item.status === 'in_progress');
+        if (!task) {
+            logger?.warn?.(`[PD:EvolutionWorker] Could not find in-progress evolution task ${taskId} for session assignment`);
+            return false;
+        }
+        task.assigned_session_key = sessionKey;
+        if (!task.started_at) {
+            task.started_at = new Date().toISOString();
+        }
+        fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
+        return true;
+    }
+    finally {
+        releaseLock();
+    }
+}
 export const EvolutionWorkerService = {
     id: 'principles-evolution-worker',
     api: null,
@@ -476,28 +502,32 @@ export const EvolutionWorkerService = {
         const initialDelay = 5000;
         const interval = config.get('intervals.worker_poll_ms') || (15 * 60 * 1000);
         intervalId = setInterval(() => {
-            checkPainFlag(wctx, logger);
-            processEvolutionQueue(wctx, logger, eventLog);
-            if (api) {
-                processDetectionQueue(wctx, api, eventLog).catch(err => {
-                    if (logger)
-                        logger.error(`[PD:EvolutionWorker] Error in detection queue: ${String(err)}`);
-                });
-            }
-            processPromotion(wctx, logger, eventLog);
-            wctx.dictionary.flush();
-            flushAllSessions();
+            void (async () => {
+                await checkPainFlag(wctx, logger);
+                await processEvolutionQueue(wctx, logger, eventLog);
+                if (api) {
+                    await processDetectionQueue(wctx, api, eventLog);
+                }
+                await processPromotion(wctx, logger, eventLog);
+                wctx.dictionary.flush();
+                flushAllSessions();
+            })().catch((err) => {
+                if (logger)
+                    logger.error(`[PD:EvolutionWorker] Error in worker interval: ${String(err)}`);
+            });
         }, interval);
         setTimeout(() => {
-            checkPainFlag(wctx, logger);
-            processEvolutionQueue(wctx, logger, eventLog);
-            if (api) {
-                processDetectionQueue(wctx, api, eventLog).catch(err => {
-                    if (logger)
-                        logger.error(`[PD:EvolutionWorker] Startup detection queue failed: ${String(err)}`);
-                });
-            }
-            processPromotion(wctx, logger, eventLog);
+            void (async () => {
+                await checkPainFlag(wctx, logger);
+                await processEvolutionQueue(wctx, logger, eventLog);
+                if (api) {
+                    await processDetectionQueue(wctx, api, eventLog);
+                }
+                await processPromotion(wctx, logger, eventLog);
+            })().catch((err) => {
+                if (logger)
+                    logger.error(`[PD:EvolutionWorker] Startup worker cycle failed: ${String(err)}`);
+            });
         }, initialDelay);
     },
     stop(ctx) {

package/dist/service/runtime-summary-service.d.ts

@@ -73,6 +73,10 @@ export declare class RuntimeSummaryService {
     private static buildGfiSources;
     private static findLastPainSignal;
     private static buildGateStats;
+    private static resolveSessionSortTime;
+    private static mergeEvents;
+    private static getEventDedupKey;
+    private static resolveEvolutionDataQuality;
     private static readJsonFile;
     private static asFiniteNumber;
 }

package/dist/service/runtime-summary-service.js

@@ -27,7 +27,7 @@ export class RuntimeSummaryService {
         const bufferedEvents = hasBufferedEventAccess
             ? wctx.eventLog.getBufferedEvents()
             : [];
-        const events = [...persistedEvents, ...bufferedEvents];
+        const events = this.mergeEvents(persistedEvents, bufferedEvents);
         const dailyStats = this.readJsonFile(path.join(wctx.stateDir, 'logs', 'daily-stats.json'), warnings, false);
         const today = generatedAt.slice(0, 10);
         const dailyGfiPeak = dailyStats?.[today]?.gfi?.peak;
@@ -69,7 +69,7 @@ export class RuntimeSummaryService {
             evolution: {
                 queue: queueStats,
                 directive: directiveSummary,
-                dataQuality: queue ? 'authoritative' : 'partial',
+                dataQuality: this.resolveEvolutionDataQuality(queue, queueStats, directiveSummary),
             },
             pain: {
                 activeFlag: Object.keys(painFlag).length > 0,
@@ -109,7 +109,7 @@ export class RuntimeSummaryService {
                 pushWarning(warnings, `Failed to parse session snapshot: ${file}`);
             }
         }
-        return sessions.sort((a, b) => (b.lastActivityAt ?? 0) - (a.lastActivityAt ?? 0));
+        return sessions.sort((a, b) => this.resolveSessionSortTime(b) - this.resolveSessionSortTime(a));
     }
     static selectSession(sessions, explicitSessionId) {
         if (explicitSessionId) {
@@ -133,9 +133,12 @@ export class RuntimeSummaryService {
                 currentGfi: Number.isFinite(live.currentGfi) ? Number(live.currentGfi) : persisted?.currentGfi,
                 dailyGfiPeak: Number.isFinite(live.dailyGfiPeak) ? Number(live.dailyGfiPeak) : persisted?.dailyGfiPeak,
                 lastActivityAt: Number.isFinite(live.lastActivityAt) ? Number(live.lastActivityAt) : persisted?.lastActivityAt,
+                lastControlActivityAt: Number.isFinite(live.lastControlActivityAt)
+                    ? Number(live.lastControlActivityAt)
+                    : persisted?.lastControlActivityAt,
             });
         }
-        return [...merged.values()].sort((a, b) => (b.lastActivityAt ?? 0) - (a.lastActivityAt ?? 0));
+        return [...merged.values()].sort((a, b) => this.resolveSessionSortTime(b) - this.resolveSessionSortTime(a));
     }
     static buildQueueStats(queue) {
         const stats = { pending: 0, inProgress: 0, completed: 0 };
@@ -298,6 +301,42 @@ export class RuntimeSummaryService {
             dataQuality: scoped.length > 0 ? 'authoritative' : 'partial',
         };
     }
+    static resolveSessionSortTime(session) {
+        return session.lastControlActivityAt ?? session.lastActivityAt ?? 0;
+    }
+    static mergeEvents(persistedEvents, bufferedEvents) {
+        const merged = new Map();
+        for (const entry of [...persistedEvents, ...bufferedEvents]) {
+            merged.set(this.getEventDedupKey(entry), entry);
+        }
+        return [...merged.values()].sort((a, b) => (a.ts || '').localeCompare(b.ts || ''));
+    }
+    static getEventDedupKey(entry) {
+        const eventId = typeof entry.data?.eventId === 'string' ? entry.data.eventId : null;
+        if (eventId) {
+            return `${entry.type}:${entry.sessionId ?? 'none'}:${eventId}`;
+        }
+        return [
+            entry.ts ?? 'no-ts',
+            entry.type ?? 'no-type',
+            entry.category ?? 'no-category',
+            entry.sessionId ?? 'no-session',
+            typeof entry.data?.source === 'string' ? entry.data.source : 'no-source',
+            typeof entry.data?.toolName === 'string' ? entry.data.toolName : 'no-tool',
+            typeof entry.data?.reason === 'string' ? entry.data.reason : 'no-reason',
+        ].join('::');
+    }
+    static resolveEvolutionDataQuality(queue, queueStats, directive) {
+        if (!queue)
+            return 'partial';
+        if (queueStats.inProgress > 0 && (!directive.exists || directive.active !== true)) {
+            return 'partial';
+        }
+        if (directive.active && queueStats.inProgress === 0 && queueStats.pending === 0) {
+            return 'partial';
+        }
+        return 'authoritative';
+    }
     static readJsonFile(filePath, warnings, warnOnMissing) {
         if (!fs.existsSync(filePath)) {
             if (warnOnMissing) {

package/dist/tools/agent-spawn.js

@@ -5,8 +5,11 @@
  * Uses the low-level OpenClaw Subagent API.
  */
 import { Type } from '@sinclair/typebox';
+import * as fs from 'fs';
 import { randomUUID } from 'node:crypto';
 import { loadAgentDefinition, listAvailableAgents } from '../core/agent-loader.js';
+import { resolvePdPath } from '../core/paths.js';
+import { extractEvolutionTaskId, registerEvolutionTaskSession } from '../service/evolution-worker.js';
 /**
  * Extract assistant text from session messages
  */
@@ -40,6 +43,23 @@ function extractAssistantText(messages) {
     }
     return '';
 }
+async function registerDiagnosticianRun(api, task, sessionKey) {
+    const taskId = extractEvolutionTaskId(task);
+    if (!taskId)
+        return;
+    try {
+        const workspaceDir = api.resolvePath('.');
+        const queuePath = resolvePdPath(workspaceDir, 'EVOLUTION_QUEUE');
+        if (!fs.existsSync(queuePath)) {
+            api.logger?.warn?.(`[PD:AgentSpawn] Evolution task ${taskId} not registered because queue file is missing`);
+            return;
+        }
+        await registerEvolutionTaskSession((key) => resolvePdPath(workspaceDir, key), taskId, sessionKey, api.logger);
+    }
+    catch (error) {
+        api.logger?.warn?.(`[PD:AgentSpawn] Failed to register evolution task session: ${String(error)}`);
+    }
+}
 /**
  * Build the full system prompt for a subagent
  * Combines the agent definition with any context-specific additions
@@ -285,6 +305,9 @@ pd_run_worker(
                     deliver: false, // Critical: don't send directly to external channels
                     idempotencyKey: randomUUID(),
                 });
+                if (agentType === 'diagnostician') {
+                    await registerDiagnosticianRun(api, task, sessionKey);
+                }
                 if (runAsync) {
                     const duration = Date.now() - startTime;
                     return {

package/dist/utils/file-lock.d.ts

@@ -28,6 +28,11 @@ export interface LockContext {
     /** 获取锁的时间 */
     acquiredAt: number;
 }
+export declare class LockAcquisitionError extends Error {
+    readonly filePath: string;
+    readonly lockPath: string;
+    constructor(message: string, filePath: string, lockPath: string);
+}
 /**
  * 获取文件锁
  *
@@ -37,6 +42,7 @@ export interface LockContext {
  * @throws Error 如果无法获取锁
  */
 export declare function acquireLock(filePath: string, options?: LockOptions): LockContext;
+export declare function acquireLockAsync(filePath: string, options?: LockOptions): Promise<LockContext>;
 /**
  * 释放文件锁
  *
@@ -52,6 +58,7 @@ export declare function releaseLock(ctx: LockContext): void;
  * @returns 操作的返回值
  */
 export declare function withLock<T>(filePath: string, fn: () => T, options?: LockOptions): T;
+export declare function withLockAsync<T>(filePath: string, fn: () => Promise<T>, options?: LockOptions): Promise<T>;
 export declare function withAsyncLock<T>(filePath: string, fn: () => Promise<T>): Promise<T>;
 /**
  * 检查锁状态（用于调试）