principles-disciple 1.7.3 → 1.7.5

package/dist/service/evolution-worker.js

@@ -1,4 +1,5 @@
 import * as fs from 'fs';
+import * as path from 'path';
 import { createHash } from 'crypto';
 import { DictionaryService } from '../core/dictionary-service.js';
 import { DetectionService } from '../core/detection-service.js';
@@ -8,6 +9,8 @@ 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';
+import { getEvolutionLogger } from '../core/evolution-logger.js';
+import { DIAGNOSTICIAN_PROTOCOL_SUMMARY } from '../constants/diagnostician.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)
@@ -137,6 +140,9 @@ async function checkPainFlag(wctx, logger) {
         let reason = 'Systemic pain detected';
         let preview = '';
         let isQueued = false;
+        let traceId = '';
+        let sessionId = '';
+        let agentId = '';
         for (const line of lines) {
             if (line.startsWith('score:'))
                 score = parseInt(line.split(':', 2)[1].trim(), 10) || 0;
@@ -148,6 +154,12 @@ async function checkPainFlag(wctx, logger) {
                 preview = line.slice('trigger_text_preview:'.length).trim();
             if (line.startsWith('status: queued'))
                 isQueued = true;
+            if (line.startsWith('trace_id:'))
+                traceId = line.split(':', 2)[1].trim();
+            if (line.startsWith('session_id:'))
+                sessionId = line.slice('session_id:'.length).trim();
+            if (line.startsWith('agent_id:'))
+                agentId = line.slice('agent_id:'.length).trim();
         }
         if (isQueued || score < 30)
             return;
@@ -174,18 +186,42 @@ async function checkPainFlag(wctx, logger) {
                 return;
             }
             const taskId = createEvolutionTaskId(source, score, preview, reason, now);
+            const nowIso = new Date(now).toISOString();
+            const effectiveTraceId = traceId || taskId;
             queue.push({
                 id: taskId,
                 score,
                 source,
                 reason,
                 trigger_text_preview: preview,
-                timestamp: new Date(now).toISOString(),
-                enqueued_at: new Date(now).toISOString(),
-                status: 'pending'
+                timestamp: nowIso,
+                enqueued_at: nowIso,
+                status: 'pending',
+                session_id: sessionId || undefined,
+                agent_id: agentId || undefined,
+                traceId: effectiveTraceId,
             });
             fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
             fs.appendFileSync(painFlagPath, `\nstatus: queued\ntask_id: ${taskId}\n`, 'utf8');
+            // Log to EvolutionLogger
+            const evoLogger = getEvolutionLogger(wctx.workspaceDir, wctx.trajectory);
+            evoLogger.logQueued({
+                traceId: traceId || taskId,
+                taskId,
+                score,
+                source,
+                reason,
+            });
+            // Record to evolution_tasks table
+            wctx.trajectory?.recordEvolutionTask?.({
+                taskId,
+                traceId: traceId || taskId,
+                source,
+                reason,
+                score,
+                status: 'pending',
+                enqueuedAt: nowIso,
+            });
         }
         finally {
             releaseLock();
@@ -200,33 +236,104 @@ async function processEvolutionQueue(wctx, logger, eventLog) {
     const queuePath = wctx.resolve('EVOLUTION_QUEUE');
     if (!fs.existsSync(queuePath))
         return;
-    const directivePath = wctx.resolve('EVOLUTION_DIRECTIVE');
     const releaseLock = await requireQueueLock(queuePath, logger, 'processEvolutionQueue');
+    const evoLogger = getEvolutionLogger(wctx.workspaceDir, wctx.trajectory);
     try {
         let queue = [];
         try {
             queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
         }
         catch (e) {
-            if (logger)
-                logger.error(`[PD:EvolutionWorker] Failed to parse evolution queue: ${String(e)}`);
+            // Backup corrupted file instead of silently discarding
+            const backupPath = `${queuePath}.corrupted.${Date.now()}`;
+            try {
+                fs.renameSync(queuePath, backupPath);
+                if (logger) {
+                    logger.error(`[PD:EvolutionWorker] Evolution queue corrupted and backed up to ${backupPath}. All pending tasks have been preserved in the backup file. Parse error: ${String(e)}`);
+                }
+                SystemLogger.log(wctx.workspaceDir, 'QUEUE_CORRUPTED', `Queue file backed up to ${backupPath}. Error: ${String(e)}`);
+            }
+            catch (backupErr) {
+                if (logger) {
+                    logger.error(`[PD:EvolutionWorker] Failed to backup corrupted queue: ${String(backupErr)}`);
+                }
+            }
             return;
         }
         let queueChanged = false;
         const config = wctx.config;
-        const timeout = config.get('intervals.task_timeout_ms') || (30 * 60 * 1000);
-        for (const task of queue) {
-            if (task.status === 'in_progress' && task.timestamp) {
-                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 timeout = config.get('intervals.task_timeout_ms') || (60 * 60 * 1000); // Default 1 hour
+        // Check in_progress tasks for completion
+        for (const task of queue.filter(t => t.status === 'in_progress')) {
+            const startedAt = new Date(task.started_at || task.timestamp);
+            // Condition 1: Check for marker file (created by diagnostician on completion)
+            const completeMarker = path.join(wctx.stateDir, `.evolution_complete_${task.id}`);
+            if (fs.existsSync(completeMarker)) {
+                if (logger)
+                    logger.info(`[PD:EvolutionWorker] Task ${task.id} completed - marker file detected`);
+                task.status = 'completed';
+                task.completed_at = new Date().toISOString();
+                task.resolution = 'marker_detected';
+                try {
+                    fs.unlinkSync(completeMarker); // Clean up marker file
+                }
+                catch {
+                    // Best effort cleanup
                 }
+                // Log to EvolutionLogger
+                const durationMs = task.started_at
+                    ? Date.now() - new Date(task.started_at).getTime()
+                    : undefined;
+                evoLogger.logCompleted({
+                    traceId: task.traceId || task.id,
+                    taskId: task.id,
+                    resolution: 'marker_detected',
+                    durationMs,
+                });
+                // Update evolution_tasks table
+                wctx.trajectory?.updateEvolutionTask?.(task.id, {
+                    status: 'completed',
+                    completedAt: task.completed_at,
+                    resolution: 'marker_detected',
+                });
+                wctx.trajectory?.recordTaskOutcome({
+                    sessionId: task.assigned_session_key || 'heartbeat:diagnostician',
+                    taskId: task.id,
+                    outcome: 'ok',
+                    summary: `Task ${task.id} completed - marker file detected.`
+                });
+                queueChanged = true;
+                continue;
+            }
+            // Condition 2: Timeout auto-complete
+            const age = Date.now() - startedAt.getTime();
+            if (age > timeout) {
+                const timeoutMinutes = Math.round(timeout / 60000);
+                if (logger)
+                    logger.info(`[PD:EvolutionWorker] Task ${task.id} auto-completed after ${timeoutMinutes} minute timeout`);
+                task.status = 'completed';
+                task.completed_at = new Date().toISOString();
+                task.resolution = 'auto_completed_timeout';
+                // Log to EvolutionLogger
+                evoLogger.logCompleted({
+                    traceId: task.traceId || task.id,
+                    taskId: task.id,
+                    resolution: 'auto_completed_timeout',
+                    durationMs: age,
+                });
+                // Update evolution_tasks table
+                wctx.trajectory?.updateEvolutionTask?.(task.id, {
+                    status: 'completed',
+                    completedAt: task.completed_at,
+                    resolution: 'auto_completed_timeout',
+                });
+                wctx.trajectory?.recordTaskOutcome({
+                    sessionId: task.assigned_session_key || 'heartbeat:diagnostician',
+                    taskId: task.id,
+                    outcome: 'timeout',
+                    summary: `Task ${task.id} auto-completed after ${timeoutMinutes} minute timeout.`
+                });
+                queueChanged = true;
             }
         }
         const pendingTasks = queue.filter(t => t.status === 'pending');
@@ -235,55 +342,70 @@ async function processEvolutionQueue(wctx, logger, eventLog) {
             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'}"`;
-            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({
+            // Prepare HEARTBEAT content first
+            // Use shared diagnostician protocol (consistent with pd-diagnostician skill)
+            const heartbeatPath = wctx.resolve('HEARTBEAT');
+            const markerFilePath = path.join(wctx.stateDir, `.evolution_complete_${highestScoreTask.id}`);
+            const heartbeatContent = [
+                `## Evolution Task [ID: ${highestScoreTask.id}]`,
+                ``,
+                `**Pain Score**: ${highestScoreTask.score}`,
+                `**Source**: ${highestScoreTask.source}`,
+                `**Reason**: ${highestScoreTask.reason}`,
+                `**Trigger**: "${highestScoreTask.trigger_text_preview || 'N/A'}"`,
+                `**Queued At**: ${highestScoreTask.enqueued_at || nowIso}`,
+                `**Session ID**: ${highestScoreTask.session_id || 'N/A'}`,
+                `**Agent ID**: ${highestScoreTask.agent_id || 'main'}`,
+                ``,
+                `---`,
+                ``,
+                DIAGNOSTICIAN_PROTOCOL_SUMMARY,
+                ``,
+                `---`,
+                ``,
+                `After completing the analysis:`,
+                `1. Write the resulting principle(s) to PRINCIPLES.md`,
+                `2. Mark the task complete by creating an empty file: ${markerFilePath}`,
+                `3. Replace this HEARTBEAT.md content with "HEARTBEAT_OK"`,
+            ].join('\n');
+            // Try to write HEARTBEAT.md FIRST
+            // Only mark task as in_progress after successful write to avoid stuck tasks
+            try {
+                fs.writeFileSync(heartbeatPath, heartbeatContent, 'utf8');
+                if (logger)
+                    logger.info(`[PD:EvolutionWorker] Wrote diagnostician task to HEARTBEAT.md for task ${highestScoreTask.id}`);
+                // HEARTBEAT write succeeded, now mark task as in_progress
+                highestScoreTask.task = taskDescription;
+                highestScoreTask.status = 'in_progress';
+                highestScoreTask.started_at = nowIso;
+                delete highestScoreTask.completed_at;
+                // Use placeholder instead of deleting - allows subagent_ended hook to match
+                // This fixes task_outcomes being empty for HEARTBEAT-triggered diagnostician runs
+                highestScoreTask.assigned_session_key = `heartbeat:diagnostician:${highestScoreTask.id}`;
+                queueChanged = true;
+                // Log to EvolutionLogger
+                evoLogger.logStarted({
+                    traceId: highestScoreTask.traceId || highestScoreTask.id,
                     taskId: highestScoreTask.id,
-                    taskType: highestScoreTask.source,
-                    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)}`);
+                // Update evolution_tasks table
+                wctx.trajectory?.updateEvolutionTask?.(highestScoreTask.id, {
+                    status: 'in_progress',
+                    startedAt: nowIso,
+                });
+                if (eventLog) {
+                    eventLog.recordEvolutionTask({
+                        taskId: highestScoreTask.id,
+                        taskType: highestScoreTask.source,
+                        reason: highestScoreTask.reason
+                    });
                 }
-                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');
+            catch (heartbeatErr) {
+                // HEARTBEAT write failed - keep task as pending for next cycle retry
+                if (logger)
+                    logger.error(`[PD:EvolutionWorker] Failed to write HEARTBEAT.md for task ${highestScoreTask.id}: ${String(heartbeatErr)}. Task will remain pending for next cycle.`);
+                SystemLogger.log(wctx.workspaceDir, 'HEARTBEAT_WRITE_FAILED', `Task ${highestScoreTask.id} HEARTBEAT write failed: ${String(heartbeatErr)}`);
             }
         }
         if (queueChanged) {

package/dist/service/phase3-input-filter.d.ts

@@ -0,0 +1,37 @@
+export interface Phase3EvolutionInput {
+    id?: string | null;
+    status?: string | null;
+    started_at?: string | null;
+    completed_at?: string | null;
+}
+export interface Phase3TrustInput {
+    score?: number | null;
+    frozen?: boolean | null;
+    lastUpdated?: string | null;
+}
+export interface Phase3EvolutionSample {
+    taskId: string;
+    status: 'pending' | 'in_progress' | 'completed';
+    startedAt: string | null;
+    completedAt: string | null;
+}
+export interface Phase3RejectedEvolutionSample {
+    taskId: string | null;
+    status: string | null;
+    reasons: string[];
+}
+export interface Phase3TrustResult {
+    eligible: boolean;
+    rejectedReasons: string[];
+}
+export interface Phase3InputFilterResult {
+    queueTruthReady: boolean;
+    trustInputReady: boolean;
+    phase3ShadowEligible: boolean;
+    evolution: {
+        eligible: Phase3EvolutionSample[];
+        rejected: Phase3RejectedEvolutionSample[];
+    };
+    trust: Phase3TrustResult;
+}
+export declare function evaluatePhase3Inputs(queue: Phase3EvolutionInput[], trust: Phase3TrustInput): Phase3InputFilterResult;

package/dist/service/phase3-input-filter.js

@@ -0,0 +1,106 @@
+function normalizeTaskId(value) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.trim();
+    return normalized ? normalized : null;
+}
+function normalizeStatus(value) {
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    if (normalized === 'in_progress' || normalized === 'completed')
+        return normalized;
+    if (normalized === 'pending')
+        return 'pending';
+    return null;
+}
+function normalizeTimestamp(value) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.trim();
+    if (!normalized)
+        return null;
+    const timestamp = Date.parse(normalized);
+    return Number.isNaN(timestamp) ? null : normalized;
+}
+function dedupe(values) {
+    return [...new Set(values)];
+}
+export function evaluatePhase3Inputs(queue, trust) {
+    const eligible = [];
+    const rejected = [];
+    const taskIdCounts = new Map();
+    for (const item of queue) {
+        const taskId = normalizeTaskId(item?.id);
+        if (!taskId)
+            continue;
+        taskIdCounts.set(taskId, (taskIdCounts.get(taskId) ?? 0) + 1);
+    }
+    for (const item of queue) {
+        const taskId = normalizeTaskId(item?.id);
+        const status = normalizeStatus(item?.status);
+        const reasons = [];
+        const startedAt = normalizeTimestamp(item?.started_at);
+        const completedAt = normalizeTimestamp(item?.completed_at);
+        if (!taskId) {
+            reasons.push('missing_task_id');
+        }
+        else if ((taskIdCounts.get(taskId) ?? 0) > 1) {
+            reasons.push('reused_task_id');
+        }
+        if (!status) {
+            reasons.push('invalid_status');
+        }
+        if (typeof item?.started_at === 'string' && item.started_at.trim() && !startedAt) {
+            reasons.push('invalid_started_at');
+        }
+        if (typeof item?.completed_at === 'string' && item.completed_at.trim() && !completedAt) {
+            reasons.push('invalid_completed_at');
+        }
+        if (status === 'in_progress' && !startedAt) {
+            reasons.push('missing_started_at');
+        }
+        if (status === 'completed' && !completedAt) {
+            reasons.push('missing_completed_at');
+        }
+        if (reasons.length > 0) {
+            rejected.push({
+                taskId,
+                status: typeof item?.status === 'string' ? item.status : null,
+                reasons: dedupe(reasons),
+            });
+            continue;
+        }
+        if (!taskId || !status) {
+            continue;
+        }
+        eligible.push({
+            taskId,
+            status,
+            startedAt,
+            completedAt,
+        });
+    }
+    const trustRejectedReasons = [];
+    const score = typeof trust.score === 'number' && Number.isFinite(trust.score) ? trust.score : null;
+    if (trust.frozen !== true) {
+        trustRejectedReasons.push('legacy_or_unfrozen_trust_schema');
+    }
+    if (score === null) {
+        trustRejectedReasons.push('missing_trust_score');
+    }
+    const trustInputReady = trustRejectedReasons.length === 0;
+    const queueTruthReady = queue.length > 0 && rejected.length === 0 && eligible.length > 0;
+    const phase3ShadowEligible = queueTruthReady && trustInputReady;
+    return {
+        queueTruthReady,
+        trustInputReady,
+        phase3ShadowEligible,
+        evolution: {
+            eligible,
+            rejected,
+        },
+        trust: {
+            eligible: trustInputReady,
+            rejectedReasons: trustRejectedReasons,
+        },
+    };
+}

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

@@ -40,6 +40,15 @@ export interface RuntimeSummary {
         };
         dataQuality: RuntimeDataQuality;
     };
+    phase3: {
+        queueTruthReady: boolean;
+        trustInputReady: boolean;
+        phase3ShadowEligible: boolean;
+        evolutionEligible: number;
+        evolutionRejected: number;
+        evolutionRejectedReasons: string[];
+        trustRejectedReasons: string[];
+    };
     pain: {
         activeFlag: boolean;
         activeFlagSource: string | null;
@@ -77,6 +86,12 @@ export declare class RuntimeSummaryService {
     private static mergeEvents;
     private static getEventDedupKey;
     private static resolveEvolutionDataQuality;
+    private static selectInProgressTask;
+    private static getQueuePriority;
+    private static isResolvableEvolutionTask;
+    private static resolveDirectiveTimestamp;
+    private static buildDirectiveTaskPreview;
+    private static warnOnLegacyDirectiveMismatch;
     private static readJsonFile;
     private static asFiniteNumber;
 }