create-principles-disciple 1.93.0 → 1.95.0

package/plugin/dist/core/intent-doc-reader.js

@@ -0,0 +1,189 @@
+/**
+ * PRI-467 — safeReadIntentDoc: plugin I/O wrapper for reading INTENT.md.
+ *
+ * Reads `.principles/INTENT.md` with:
+ * - Feature flag check FIRST (SPEC §12: flag off → flag_disabled without fs)
+ * - TTL + mtime cache (60s TTL, mtime check) mirroring prompt.ts cachedReadFile
+ * - 32KB size cap (INTENT_MAX_BYTES)
+ * - Never throws — all errors return structured `reason` + `nextAction`
+ *
+ * Trust boundary (SPEC §12.2):
+ * - Raw content is returned for the pure builder to escape; this reader does
+ *   NOT escape or bound the content for prompt injection. The pure builder
+ *   `buildIntentFrictionBlock` handles escaping + bounding.
+ *
+ * ERR checklist:
+ * EP-01 / ERR-001, ERR-005: raw content validated with typeof, never `as`
+ * EP-02 / ERR-025, ERR-070: production path; plugin I/O file in the whitelist
+ * EP-03 / ERR-002, ERR-014: every degraded path returns structured reason + nextAction
+ * EP-09: tests use real fs writes in temp dirs
+ *
+ * Architecture: this file is I/O (fs, path). It is whitelisted in
+ * architecture-regression.test.ts KNOWN_PLUGIN_CORE_FILES.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { INTENT_MAX_BYTES, parseIntentDocSections, computeIntentContentHash, validateIntentDocSections, } from '@principles/core/runtime-v2';
+import { loadFeatureFlagFromConfig } from './pd-config-loader.js';
+// ── Constants ────────────────────────────────────────────────────────────────
+const INTENT_FILENAME = 'INTENT.md';
+const INTENT_DIR = '.principles';
+const INTENT_CACHE_TTL_MS = 60_000; // 1 minute (SPEC §12.1)
+// ── Module-level cache (per-workspace) ───────────────────────────────────────
+const _intentDocCache = new Map();
+/**
+ * Reset the intent doc cache for test isolation.
+ * Call in beforeEach() to ensure tests don't pollute each other.
+ */
+export function resetIntentDocCacheForTest(workspaceDir) {
+    if (workspaceDir) {
+        _intentDocCache.delete(workspaceDir);
+    }
+    else {
+        _intentDocCache.clear();
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function getIntentFilePath(workspaceDir) {
+    return path.join(workspaceDir, INTENT_DIR, INTENT_FILENAME);
+}
+function buildDocFromRaw(raw, filePath, readAt) {
+    const sections = parseIntentDocSections(raw);
+    const warnings = validateIntentDocSections(sections);
+    const contentHash = computeIntentContentHash(raw);
+    return {
+        raw,
+        sections,
+        contentHash,
+        path: filePath,
+        readAt,
+        warnings,
+    };
+}
+// ── Main entrypoint ──────────────────────────────────────────────────────────
+/**
+ * Safely read INTENT.md for prompt injection.
+ *
+ * Contract (SPEC §12):
+ * 1. Flag check FIRST via loadFeatureFlagFromConfig. Flag off → flag_disabled
+ *    WITHOUT any fs access to INTENT.md.
+ * 2. Flag on → check TTL + mtime cache. If cached and fresh → return cached.
+ * 3. Otherwise → stat the file (oversized check), read, parse, validate, cache.
+ * 4. Never throws — all errors return structured reason + nextAction.
+ *
+ * @param workspaceDir - Absolute path to the workspace root
+ * @param options - Optional logger for debug-level diagnostics
+ * @returns SafeReadIntentDocResult (never throws)
+ */
+export function safeReadIntentDoc(workspaceDir, options) {
+    // SPEC §12 — Flag check FIRST. Flag off → no fs access, no cache access.
+    const flagResult = loadFeatureFlagFromConfig(workspaceDir, 'intent_engineering', options?.logger);
+    if (!flagResult.enabled) {
+        return {
+            ok: false,
+            found: false,
+            flagEnabled: false,
+            reason: 'flag_disabled',
+            nextAction: 'Enable the intent_engineering feature flag in .pd/config.yaml to read INTENT.md.',
+            warnings: [],
+        };
+    }
+    const filePath = getIntentFilePath(workspaceDir);
+    const now = Date.now();
+    // Check cache freshness (TTL + mtime)
+    const cached = _intentDocCache.get(workspaceDir);
+    if (cached && (now - cached.loadedAt) < INTENT_CACHE_TTL_MS) {
+        // Cache is within TTL. Verify mtime hasn't changed.
+        try {
+            const stat = fs.statSync(filePath);
+            if (stat.mtimeMs === cached.mtime) {
+                // Cache hit — return cached doc
+                return {
+                    ok: true,
+                    found: true,
+                    flagEnabled: true,
+                    doc: cached.doc,
+                    warnings: cached.doc.warnings,
+                };
+            }
+        }
+        catch {
+            // File may have been deleted since caching. Fall through to not_found path.
+            // Don't return cached doc if the file no longer exists.
+        }
+    }
+    // Fresh read path
+    try {
+        // Check existence first
+        if (!fs.existsSync(filePath)) {
+            // Invalidate stale cache entry if any
+            _intentDocCache.delete(workspaceDir);
+            return {
+                ok: false,
+                found: false,
+                flagEnabled: true,
+                reason: 'not_found',
+                nextAction: 'Create .principles/INTENT.md using "pd intent init".',
+                warnings: [],
+            };
+        }
+        const stat = fs.statSync(filePath);
+        // SPEC §12 — 32KB size cap
+        if (stat.size > INTENT_MAX_BYTES) {
+            _intentDocCache.delete(workspaceDir);
+            return {
+                ok: false,
+                found: true,
+                flagEnabled: true,
+                reason: 'oversized',
+                nextAction: `INTENT.md exceeds ${INTENT_MAX_BYTES} bytes (${stat.size} bytes). Reduce content.`,
+                warnings: [],
+            };
+        }
+        const raw = fs.readFileSync(filePath, 'utf8');
+        // PRI-467 review fix (P2): TOCTOU guard — re-check actual byte length
+        // after readFileSync. The file may have grown between statSync() and
+        // readFileSync(), bypassing the stat.size oversized check. Without this,
+        // an oversized file would enter parse/hash/cache as ok:true.
+        const actualBytes = Buffer.byteLength(raw, 'utf8');
+        if (actualBytes > INTENT_MAX_BYTES) {
+            _intentDocCache.delete(workspaceDir);
+            return {
+                ok: false,
+                found: true,
+                flagEnabled: true,
+                reason: 'oversized',
+                nextAction: `INTENT.md exceeds ${INTENT_MAX_BYTES} bytes (${actualBytes} bytes after read). Reduce content.`,
+                warnings: [],
+            };
+        }
+        const doc = buildDocFromRaw(raw, filePath, new Date(now).toISOString());
+        // Update cache
+        _intentDocCache.set(workspaceDir, {
+            doc,
+            mtime: stat.mtimeMs,
+            loadedAt: now,
+        });
+        return {
+            ok: true,
+            found: true,
+            flagEnabled: true,
+            doc,
+            warnings: doc.warnings,
+        };
+    }
+    catch (err) {
+        // ERR-002 — graceful degradation with reason + nextAction
+        _intentDocCache.delete(workspaceDir);
+        const message = err instanceof Error ? err.message : String(err);
+        options?.logger?.warn?.(`[PD:Intent] safeReadIntentDoc failed: workspace=${workspaceDir}, error=${message}`);
+        return {
+            ok: false,
+            found: false,
+            flagEnabled: true,
+            reason: 'read_error',
+            nextAction: 'Check filesystem permissions for .principles/INTENT.md.',
+            warnings: [],
+        };
+    }
+}

package/plugin/dist/core/pain-diagnostic-gate.d.ts

@@ -1,30 +1,35 @@
-declare const PAIN_DIAGNOSTIC_SOURCES: readonly ["manual", "tool_failure", "dispatch_error", "gate_blocked", "user_empathy", "llm_paralysis", "semantic", "subagent_error"];
-export type PainDiagnosticSource = typeof PAIN_DIAGNOSTIC_SOURCES[number];
-export type PainDiagnosticGateReason = 'manual' | 'high_gfi' | 'repeated_failure' | 'semantic_pain' | 'llm_paralysis' | 'risky_high_score' | 'subagent_error' | 'gate_blocked' | 'cooldown' | 'below_gate';
-export interface PainDiagnosticGateInput {
-    source: PainDiagnosticSource | string;
-    score: number;
-    currentGfi: number;
-    consecutiveErrors?: number;
-    isRisky?: boolean;
-    errorHash?: string;
-    sessionId?: string;
-    nowMs?: number;
-    cooldownMs?: number;
-    thresholds?: {
-        painTrigger?: number;
-        highSeverity?: number;
-        highGfi?: number;
-        repeatedFailure?: number;
-        semanticPain?: number;
-    };
-}
-export interface PainDiagnosticGateDecision {
-    shouldDiagnose: boolean;
-    reason: PainDiagnosticGateReason;
-    episodeKey: string;
-    detail: string;
-}
+/**
+ * Pain Diagnostic Gate — PRI-446 thin adapter
+ *
+ * @deprecated PRI-454 — Gate A (PainDiagnosticGate) is superseded by Gate B
+ * (TriggerController + EvidenceTriage). This module remains as the rollback
+ * path when `painEvidenceAdmission` or `painEvidenceAdmissionDefault` flags
+ * are OFF. Do not add new callers. New admission logic must use
+ * `evaluateTriggerController` from runtime-v2/evidence-triage.
+ *
+ * Disposition: Archive (do not delete) per PRI-454 plan step 6.
+ * Removal conditions: Both flags confirmed ON in production for 30 days,
+ * and all 5 MVP paths verified on Gate B. See
+ * docs/plans/2026-06-pain-evidence-admission-track.md.
+ *
+ * The pure decision logic (threshold tree, cooldown comparison, episode-key
+ * construction) now lives in principles-core
+ * (runtime-v2/pain-gate/pain-diagnostic-gate-policy.ts). This file is the
+ * stateful adapter that owns:
+ *   - the cooldown Map (lastDiagnosedAtByEpisode)
+ *   - Date.now() injection
+ *   - SystemLogger for unknown-source telemetry
+ *
+ * It preserves the original export names (evaluatePainDiagnosticGate,
+ * isCooldownActiveForEpisode, resetPainDiagnosticGateForTest) so all 5 callers
+ * (gate-block-helper, llm, pain, prompt x2) and the characterization test keep
+ * working unchanged.
+ *
+ * ERR checklist:
+ * - ERR-011: this is a stateful adapter delegating to core pure logic.
+ */
+import { type PainDiagnosticSource, type PainDiagnosticGateReason, type PainDiagnosticGateInput, type PainDiagnosticGateDecision } from '@principles/core/runtime-v2';
+export type { PainDiagnosticSource, PainDiagnosticGateReason, PainDiagnosticGateInput, PainDiagnosticGateDecision, };
 export declare function resetPainDiagnosticGateForTest(): void;
 /**
  * Check whether cooldown is currently active for a given episode.
@@ -32,5 +37,9 @@ export declare function resetPainDiagnosticGateForTest(): void;
  * with the PainDiagnosticGate's cooldown state.
  */
 export declare function isCooldownActiveForEpisode(source: string, sessionId: string | undefined, errorHash: string | undefined, cooldownMs?: number): boolean;
+/**
+ * Evaluate the pain diagnostic gate. Delegates the pure decision to core and,
+ * when the decision is to diagnose, records the current time against the
+ * episode so subsequent calls within the cooldown window are suppressed.
+ */
 export declare function evaluatePainDiagnosticGate(input: PainDiagnosticGateInput): PainDiagnosticGateDecision;
-export {};

package/plugin/dist/core/pain-diagnostic-gate.js

@@ -1,42 +1,37 @@
+/**
+ * Pain Diagnostic Gate — PRI-446 thin adapter
+ *
+ * @deprecated PRI-454 — Gate A (PainDiagnosticGate) is superseded by Gate B
+ * (TriggerController + EvidenceTriage). This module remains as the rollback
+ * path when `painEvidenceAdmission` or `painEvidenceAdmissionDefault` flags
+ * are OFF. Do not add new callers. New admission logic must use
+ * `evaluateTriggerController` from runtime-v2/evidence-triage.
+ *
+ * Disposition: Archive (do not delete) per PRI-454 plan step 6.
+ * Removal conditions: Both flags confirmed ON in production for 30 days,
+ * and all 5 MVP paths verified on Gate B. See
+ * docs/plans/2026-06-pain-evidence-admission-track.md.
+ *
+ * The pure decision logic (threshold tree, cooldown comparison, episode-key
+ * construction) now lives in principles-core
+ * (runtime-v2/pain-gate/pain-diagnostic-gate-policy.ts). This file is the
+ * stateful adapter that owns:
+ *   - the cooldown Map (lastDiagnosedAtByEpisode)
+ *   - Date.now() injection
+ *   - SystemLogger for unknown-source telemetry
+ *
+ * It preserves the original export names (evaluatePainDiagnosticGate,
+ * isCooldownActiveForEpisode, resetPainDiagnosticGateForTest) so all 5 callers
+ * (gate-block-helper, llm, pain, prompt x2) and the characterization test keep
+ * working unchanged.
+ *
+ * ERR checklist:
+ * - ERR-011: this is a stateful adapter delegating to core pure logic.
+ */
 import { SystemLogger } from './system-logger.js';
-const PAIN_DIAGNOSTIC_SOURCES = [
-    'manual',
-    'tool_failure',
-    'dispatch_error',
-    'gate_blocked',
-    'user_empathy',
-    'llm_paralysis',
-    'semantic',
-    'subagent_error',
-];
-const DEFAULT_COOLDOWN_MS = 15 * 60 * 1000;
+import { evaluatePainDiagnosticGateDecision, normalizedSource, buildEpisodeKey, isCooldownActive as isCooldownActiveCore, } from '@principles/core/runtime-v2';
+// Module-level cooldown state — owned by this adapter (core is stateless).
 const lastDiagnosedAtByEpisode = new Map();
-function normalizedSource(source) {
-    if (source.startsWith('llm_') && source !== 'llm_paralysis') {
-        return 'semantic';
-    }
-    if (!PAIN_DIAGNOSTIC_SOURCES.includes(source)) {
-        SystemLogger.log('', 'GATE_UNKNOWN_SOURCE', `Unknown pain source: "${source}"`);
-    }
-    return source;
-}
-function buildEpisodeKey(input) {
-    const source = normalizedSource(input.source);
-    const sessionId = input.sessionId || 'unknown';
-    const hash = input.errorHash || 'no-hash';
-    return `${sessionId}:${source}:${hash}`;
-}
-function withinCooldown(input, episodeKey) {
-    const cooldownMs = input.cooldownMs ?? DEFAULT_COOLDOWN_MS;
-    if (cooldownMs <= 0)
-        return false;
-    const nowMs = input.nowMs ?? Date.now();
-    const last = lastDiagnosedAtByEpisode.get(episodeKey);
-    return last !== undefined && nowMs - last < cooldownMs;
-}
-function markDiagnosed(input, episodeKey) {
-    lastDiagnosedAtByEpisode.set(episodeKey, input.nowMs ?? Date.now());
-}
 export function resetPainDiagnosticGateForTest() {
     lastDiagnosedAtByEpisode.clear();
 }
@@ -46,60 +41,29 @@ export function resetPainDiagnosticGateForTest() {
  * with the PainDiagnosticGate's cooldown state.
  */
 export function isCooldownActiveForEpisode(source, sessionId, errorHash, cooldownMs) {
-    const episodeKey = buildEpisodeKey({ source, sessionId, errorHash });
-    return withinCooldown({ source, sessionId, errorHash, cooldownMs }, episodeKey);
+    const episodeKey = buildEpisodeKey({ source, sessionId, errorHash, score: 0, currentGfi: 0 });
+    const last = lastDiagnosedAtByEpisode.get(episodeKey);
+    const nowMs = Date.now();
+    return isCooldownActiveCore({ source, sessionId, errorHash, cooldownMs, nowMs, lastDiagnosedAtMs: last });
 }
+/**
+ * Evaluate the pain diagnostic gate. Delegates the pure decision to core and,
+ * when the decision is to diagnose, records the current time against the
+ * episode so subsequent calls within the cooldown window are suppressed.
+ */
 export function evaluatePainDiagnosticGate(input) {
-    const source = normalizedSource(input.source);
-    const episodeKey = buildEpisodeKey(input);
-    const painTrigger = input.thresholds?.painTrigger ?? 40;
-    const highSeverity = input.thresholds?.highSeverity ?? 70;
-    const highGfi = input.thresholds?.highGfi ?? Math.max(highSeverity, painTrigger + 30);
-    const repeatedFailure = input.thresholds?.repeatedFailure ?? 4;
-    const semanticPain = input.thresholds?.semanticPain ?? Math.max(painTrigger, 60);
-    const score = Number.isFinite(input.score) ? input.score : 0;
-    const currentGfi = Number.isFinite(input.currentGfi) ? input.currentGfi : 0;
-    const consecutiveErrors = Number.isFinite(input.consecutiveErrors) ? input.consecutiveErrors : 0;
-    const approve = (reason, detail) => {
-        if (withinCooldown(input, episodeKey)) {
-            return {
-                shouldDiagnose: false,
-                reason: 'cooldown',
-                episodeKey,
-                detail: `recently diagnosed; ${detail}`,
-            };
-        }
-        markDiagnosed(input, episodeKey);
-        return { shouldDiagnose: true, reason, episodeKey, detail };
-    };
-    if (source === 'manual') {
-        return approve('manual', 'manual pain signal bypasses automatic gate');
-    }
-    if (source === 'subagent_error' && score >= painTrigger) {
-        return approve('subagent_error', `subagent error score ${score} >= ${painTrigger}`);
-    }
-    if (source === 'llm_paralysis' && score >= painTrigger) {
-        return approve('llm_paralysis', `llm paralysis score ${score} >= ${painTrigger}`);
-    }
-    if (source === 'gate_blocked' && score >= painTrigger) {
-        return approve('gate_blocked', `gate blocked score ${score} >= ${painTrigger}`);
-    }
-    if ((source === 'user_empathy' || source === 'semantic') && score >= semanticPain) {
-        return approve('semantic_pain', `semantic pain score ${score} >= ${semanticPain}`);
+    // Surface unknown sources via telemetry (core cannot log).
+    const { unknown } = normalizedSource(input.source);
+    if (unknown) {
+        SystemLogger.log('', 'GATE_UNKNOWN_SOURCE', `Unknown pain source: "${input.source}"`);
     }
-    if (input.isRisky === true && score >= highSeverity) {
-        return approve('risky_high_score', `risky operation score ${score} >= ${highSeverity}`);
-    }
-    if (consecutiveErrors >= repeatedFailure) {
-        return approve('repeated_failure', `consecutive errors ${consecutiveErrors} >= ${repeatedFailure}`);
-    }
-    if (currentGfi >= highGfi) {
-        return approve('high_gfi', `GFI ${currentGfi.toFixed(1)} >= ${highGfi}`);
+    const episodeKey = buildEpisodeKey(input);
+    const last = lastDiagnosedAtByEpisode.get(episodeKey);
+    const nowMs = input.nowMs ?? Date.now();
+    const decision = evaluatePainDiagnosticGateDecision({ ...input, nowMs }, last);
+    // Record the diagnosis time when approved (matches prior markDiagnosed behavior).
+    if (decision.shouldDiagnose) {
+        lastDiagnosedAtByEpisode.set(episodeKey, nowMs);
     }
-    return {
-        shouldDiagnose: false,
-        reason: 'below_gate',
-        episodeKey,
-        detail: `score=${score}; gfi=${currentGfi.toFixed(1)}; consecutive=${consecutiveErrors}`,
-    };
+    return decision;
 }

package/plugin/dist/core/pain.d.ts

@@ -1,67 +1,4 @@
-/**
- * Required fields — every pain flag MUST have these.
- */
-export interface PainFlagData {
-    /** What triggered this pain signal (e.g., tool_failure, human_intervention, intercept_extraction) */
-    source: string;
-    /** Pain score 0-100 */
-    score: string;
-    /** ISO 8601 timestamp */
-    time: string;
-    /** Human-readable reason / error description */
-    reason: string;
-    /** Session ID — identifies which conversation this happened in */
-    session_id: string;
-    /** Agent ID — identifies which agent (main, builder, diagnostician, etc.) */
-    agent_id: string;
-    /** Whether this involves risky operation ('true' / 'false') */
-    is_risky: string;
-    /** Correlation trace ID (for linking events across the pipeline) */
-    trace_id: string;
-    /** Preview of the text that triggered this pain */
-    trigger_text_preview: string;
-    /** Trajectory pain_events row ID (set by recordPainEvent) */
-    pain_event_id?: string;
-}
-export interface PainFlagContractResult {
-    status: 'missing' | 'valid' | 'invalid';
-    format: 'missing' | 'empty' | 'kv' | 'json' | 'invalid_json';
-    data: Record<string, string>;
-    missingFields: string[];
-}
-/**
- * Builds legacy pain flag data for compatibility tests and historical readers.
- * Do not use this to create new Runtime V2 diagnosis requests.
- */
-export declare function buildPainFlag(input: {
-    source: string;
-    score: string;
-    time?: string;
-    reason: string;
-    session_id?: string;
-    agent_id?: string;
-    is_risky?: boolean;
-    trace_id?: string;
-    trigger_text_preview?: string;
-    pain_event_id?: string;
-}): PainFlagData;
-/**
- * Validates a pain flag read from disk.
- * Returns list of missing required fields — empty string means all present.
- */
-export declare function validatePainFlag(data: Record<string, string>): string[];
 export declare function computePainScore(rc: number, isSpiral: boolean, missingTestCommand: boolean, softScore: number, projectDir?: string): number;
-export declare function painSeverityLabel(painScore: number, isSpiral?: boolean, projectDir?: string): string;
-/**
- * Reads and validates the legacy pain flag file.
- *
- * - If file doesn't exist → returns {}
- * - If file is JSON format → converts to KV in memory only
- * - If file is KV format → validates required fields, logs warning if missing
- * - If file has unknown fields → silently ignores them (forward-compatible)
- */
-export declare function readPainFlagData(projectDir: string): Record<string, string>;
-export declare function readPainFlagContract(projectDir: string): PainFlagContractResult;
 /**
  * Track principle value metrics when a pain signal is written.
  * This is observation-only — it does NOT affect the pain flag write flow.

package/plugin/dist/core/pain.js

@@ -1,44 +1,5 @@
-import * as fs from 'fs';
-import { parseKvLines } from '../utils/io.js';
 import { resolvePdPath } from './paths.js';
 import { ConfigService } from './config-service.js';
-import { SystemLogger } from './system-logger.js';
-/**
- * Builds legacy pain flag data for compatibility tests and historical readers.
- * Do not use this to create new Runtime V2 diagnosis requests.
- */
-export function buildPainFlag(input) {
-    // Omit optional fields when not provided — prevents writing empty lines to disk
-    // which causes agent confusion (SKILL.md vs reality drift)
-    return {
-        source: input.source,
-        score: input.score,
-        time: input.time || new Date().toISOString(),
-        reason: input.reason,
-        session_id: input.session_id ?? '',
-        agent_id: input.agent_id ?? '',
-        is_risky: input.is_risky ? 'true' : 'false',
-        trace_id: input.trace_id ?? '',
-        trigger_text_preview: input.trigger_text_preview ?? '',
-        pain_event_id: input.pain_event_id,
-    };
-}
-/**
- * Validates a pain flag read from disk.
- * Returns list of missing required fields — empty string means all present.
- */
-export function validatePainFlag(data) {
-    const missing = [];
-    // Only source/score/time/reason are truly required — session_id/agent_id
-    // may be empty in automated contexts (heartbeat, background workers)
-    const required = ['source', 'score', 'time', 'reason'];
-    for (const field of required) {
-        if (!data[field] || data[field].trim() === '') {
-            missing.push(field);
-        }
-    }
-    return missing;
-}
 export function computePainScore(rc, isSpiral, missingTestCommand, softScore, projectDir) {
     let score = Math.max(0, softScore || 0);
     const stateDir = projectDir ? resolvePdPath(projectDir, 'STATE_DIR') : undefined;
@@ -59,134 +20,6 @@ export function computePainScore(rc, isSpiral, missingTestCommand, softScore, pr
     }
     return Math.min(100, score);
 }
-export function painSeverityLabel(painScore, isSpiral = false, projectDir) {
-    if (isSpiral) {
-        return "critical";
-    }
-    const stateDir = projectDir ? resolvePdPath(projectDir, 'STATE_DIR') : undefined;
-    const config = stateDir ? ConfigService.get(stateDir) : null;
-    const thresholds = config ? config.get('severity_thresholds') : {
-        high: 70,
-        medium: 40,
-        low: 20
-    };
-    if (painScore >= thresholds.high) {
-        return "high";
-    }
-    else if (painScore >= thresholds.medium) {
-        return "medium";
-    }
-    else if (painScore >= thresholds.low) {
-        return "low";
-    }
-    else {
-        return "info";
-    }
-}
-/**
- * Converts a JSON pain flag object to KV format.
- */
-function convertJsonToKv(json) {
-    const kvData = {};
-    const fieldMap = {
-        source: 'source',
-        score: 'score',
-        time: 'time',
-        timestamp: 'time',
-        reason: 'reason',
-        session_id: 'session_id',
-        sessionId: 'session_id',
-        agent_id: 'agent_id',
-        agentId: 'agent_id',
-        is_risky: 'is_risky',
-        isRisky: 'is_risky',
-        severity: 'severity',
-        painId: 'pain_id',
-    };
-    for (const [jsonKey, kvKey] of Object.entries(fieldMap)) {
-        if (json[jsonKey] !== undefined) {
-            kvData[kvKey] = String(json[jsonKey]);
-        }
-    }
-    for (const [key, value] of Object.entries(json)) {
-        if (fieldMap[key] === undefined && value !== undefined && value !== null) {
-            kvData[key] = String(value);
-        }
-    }
-    return kvData;
-}
-/**
- * Reads and validates the legacy pain flag file.
- *
- * - If file doesn't exist → returns {}
- * - If file is JSON format → converts to KV in memory only
- * - If file is KV format → validates required fields, logs warning if missing
- * - If file has unknown fields → silently ignores them (forward-compatible)
- */
-export function readPainFlagData(projectDir) {
-    const painFlagPath = resolvePdPath(projectDir, 'PAIN_FLAG');
-    try {
-        if (!fs.existsSync(painFlagPath)) {
-            return {};
-        }
-        const content = fs.readFileSync(painFlagPath, "utf-8").trim();
-        if (!content) {
-            return {};
-        }
-        // Detect JSON format. Legacy compatibility only: parse in memory and do not
-        // rewrite .pain_flag, because Runtime V2 must not create or repair this file.
-        if (content.startsWith('{')) {
-            let json;
-            try {
-                json = JSON.parse(content);
-            }
-            catch {
-                SystemLogger.log(projectDir, 'PAIN_FLAG_CORRUPT', 'Pain flag file contains invalid JSON');
-                return {};
-            }
-            const kvData = convertJsonToKv(json);
-            SystemLogger.log(projectDir, 'PAIN_FLAG_LEGACY_JSON_READ', `Read legacy JSON pain flag in memory (${Object.keys(json).length} fields)`);
-            return kvData;
-        }
-        // KV format — parse and validate
-        const data = parseKvLines(content);
-        const missing = validatePainFlag(data);
-        if (missing.length > 0) {
-            SystemLogger.log(projectDir, 'PAIN_FLAG_INCOMPLETE', `Pain flag missing required fields: ${missing.join(', ')}`);
-        }
-        return data;
-    }
-    catch (e) {
-        SystemLogger.log(projectDir, 'PAIN_FLAG_READ_ERROR', `Failed to read pain flag: ${String(e)}`);
-        return {};
-    }
-}
-export function readPainFlagContract(projectDir) {
-    const data = readPainFlagData(projectDir);
-    if (Object.keys(data).length === 0) {
-        const painFlagPath = resolvePdPath(projectDir, 'PAIN_FLAG');
-        if (!fs.existsSync(painFlagPath)) {
-            return { status: 'missing', format: 'missing', data: {}, missingFields: [] };
-        }
-        const raw = fs.readFileSync(painFlagPath, 'utf-8').trim();
-        if (!raw) {
-            return { status: 'missing', format: 'empty', data: {}, missingFields: [] };
-        }
-        return {
-            status: 'invalid',
-            format: raw.startsWith('{') ? 'invalid_json' : 'kv',
-            data: {},
-            missingFields: ['unparseable'],
-        };
-    }
-    const missing = validatePainFlag(data);
-    return {
-        status: missing.length > 0 ? 'invalid' : 'valid',
-        format: 'kv',
-        data,
-        missingFields: missing,
-    };
-}
 /**
  * Track principle value metrics when a pain signal is written.
  * This is observation-only — it does NOT affect the pain flag write flow.

package/plugin/dist/core/paths.d.ts

@@ -50,7 +50,6 @@ export declare const PD_FILES: {
     CURRENT_FOCUS: string;
     WEEK_STATE: string;
     THINKING_OS_CANDIDATES: string;
-    SEMANTIC_PAIN: string;
     EVOLUTION_STREAM: string;
     EVOLUTION_LOCK: string;
 };