principles-disciple 1.6.0 → 1.7.1

package/dist/service/evolution-worker.js

@@ -8,6 +8,151 @@ import { SystemLogger } from '../core/system-logger.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 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)
+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.
+ */
+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;
+        }
+    }
+    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}`;
+}
+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 || '', task.reason) === key;
+    });
+}
+export function hasEquivalentPromotedRule(dictionary, phrase) {
+    const normalizedPhrase = phrase.trim().toLowerCase();
+    return Object.values(dictionary.getAllRules()).some((rule) => {
+        if (rule.status !== 'active')
+            return false;
+        if (rule.type === 'exact_match' && Array.isArray(rule.phrases)) {
+            return rule.phrases.some((candidate) => candidate.trim().toLowerCase() === normalizedPhrase);
+        }
+        if (rule.type === 'regex' && typeof rule.pattern === 'string') {
+            return rule.pattern.trim().toLowerCase() === normalizedPhrase;
+        }
+        return false;
+    });
+}
 function checkPainFlag(wctx, logger) {
     try {
         const painFlagPath = wctx.resolve('PAIN_FLAG');
@@ -37,28 +182,43 @@ 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');
-        let queue = [];
-        if (fs.existsSync(queuePath)) {
-            try {
-                queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
+        const lockPath = queuePath + EVOLUTION_QUEUE_LOCK_SUFFIX;
+        const releaseLock = acquireQueueLock(lockPath, logger);
+        if (!releaseLock)
+            return; // Could not acquire lock
+        try {
+            let queue = [];
+            if (fs.existsSync(queuePath)) {
+                try {
+                    queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
+                }
+                catch (e) {
+                    if (logger)
+                        logger.error(`[PD:EvolutionWorker] Failed to parse evolution queue: ${String(e)}`);
+                }
             }
-            catch (e) {
-                if (logger)
-                    logger.error(`[PD:EvolutionWorker] Failed to parse evolution queue: ${String(e)}`);
+            const now = Date.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 = createEvolutionTaskId(source, score, preview, reason, now);
+            queue.push({
+                id: taskId,
+                score,
+                source,
+                reason,
+                trigger_text_preview: preview,
+                timestamp: new Date(now).toISOString(),
+                status: 'pending'
+            });
+            fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
+            fs.appendFileSync(painFlagPath, '\nstatus: queued\n', 'utf8');
+        }
+        finally {
+            releaseLock();
         }
-        const taskId = createHash('md5').update(`${source}:${score}:${new Date().toISOString()}`).digest('hex').substring(0, 8);
-        queue.push({
-            id: taskId,
-            score,
-            source,
-            reason,
-            trigger_text_preview: preview,
-            timestamp: new Date().toISOString(),
-            status: 'pending'
-        });
-        fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
-        fs.appendFileSync(painFlagPath, '\nstatus: queued\n', 'utf8');
     }
     catch (err) {
         if (logger)
@@ -66,11 +226,23 @@ function checkPainFlag(wctx, logger) {
     }
 }
 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
     try {
-        const queuePath = wctx.resolve('EVOLUTION_QUEUE');
-        if (!fs.existsSync(queuePath))
+        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)}`);
             return;
-        const queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
+        }
         let queueChanged = false;
         const config = wctx.config;
         const timeout = config.get('intervals.task_timeout_ms') || (30 * 60 * 1000);
@@ -116,6 +288,9 @@ function processEvolutionQueue(wctx, logger, eventLog) {
         if (logger)
             logger.warn(`[PD:EvolutionWorker] Error processing evolution queue: ${String(err)}`);
     }
+    finally {
+        releaseLock();
+    }
 }
 async function processDetectionQueue(wctx, api, eventLog) {
     const logger = api.logger;
@@ -177,44 +352,80 @@ 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;
+                    }
                     if (logger)
                         logger.info(`[PD:EvolutionWorker] Promoting candidate ${fingerprint} to formal rule: ${ruleId}`);
                     SystemLogger.log(wctx.workspaceDir, 'RULE_PROMOTED', `Candidate ${fingerprint} promoted to rule ${ruleId}`);
@@ -226,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');
         }
     }
@@ -237,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',

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

@@ -0,0 +1,79 @@
+export type RuntimeDataQuality = 'authoritative' | 'partial';
+export type RuntimeRewardPolicy = 'frozen_all_positive' | 'frozen_atomic_positive_keep_plan_ready';
+interface RuntimeSummarySource {
+    source: string;
+    score?: number;
+    ts?: string;
+    confidence?: number;
+    origin?: string;
+}
+interface RuntimePainSignal {
+    source: string;
+    ts: string | null;
+    reason: string | null;
+}
+export interface RuntimeSummary {
+    gfi: {
+        current: number | null;
+        peak: number | null;
+        sources: RuntimeSummarySource[];
+        dataQuality: RuntimeDataQuality;
+    };
+    legacyTrust: {
+        score: number | null;
+        stage: 1 | 2 | 3 | 4 | null;
+        frozen: true;
+        lastUpdated: string | null;
+        rewardPolicy: RuntimeRewardPolicy;
+    };
+    evolution: {
+        queue: {
+            pending: number;
+            inProgress: number;
+            completed: number;
+        };
+        directive: {
+            exists: boolean;
+            active: boolean | null;
+            ageSeconds: number | null;
+            taskPreview: string | null;
+        };
+        dataQuality: RuntimeDataQuality;
+    };
+    pain: {
+        activeFlag: boolean;
+        activeFlagSource: string | null;
+        candidates: number | null;
+        lastSignal: RuntimePainSignal | null;
+    };
+    gate: {
+        recentBlocks: number | null;
+        recentBypasses: number | null;
+        dataQuality: RuntimeDataQuality;
+    };
+    metadata: {
+        generatedAt: string;
+        workspaceDir: string;
+        sessionId: string | null;
+        selectedSessionReason: 'explicit' | 'latest_active' | 'none';
+        warnings: string[];
+    };
+}
+export declare class RuntimeSummaryService {
+    static getSummary(workspaceDir: string, options?: {
+        sessionId?: string | null;
+    }): RuntimeSummary;
+    private static readSessions;
+    private static selectSession;
+    private static mergeSessionSnapshots;
+    private static buildQueueStats;
+    private static buildDirectiveSummary;
+    private static readLegacyTrust;
+    private static readEvents;
+    private static buildGfiSources;
+    private static findLastPainSignal;
+    private static buildGateStats;
+    private static readJsonFile;
+    private static asFiniteNumber;
+}
+export {};