create-principles-disciple 1.104.0 → 1.104.2

package/plugin/dist/core/principle-internalization/lifecycle-read-model.js

@@ -1,21 +0,0 @@
-/**
- * Lifecycle read model — re-export facade (PRI-56).
- *
- * All computation lives in @principles/core/runtime-v2.
- * This file re-exports types, the core builder, and provides
- * a backward-compatible path-based wrapper for existing consumers.
- */
-// Re-export core builder (PRI-56)
-export { buildLifecycleReadModel } from '@principles/core/runtime-v2';
-// Re-export filesystem implementation (PRI-56)
-export { FilesystemLifecycleDatasource, LineageSourceRetiredError } from './filesystem-lifecycle-datasource.js';
-import { buildLifecycleReadModel } from '@principles/core/runtime-v2';
-import { FilesystemLifecycleDatasource } from './filesystem-lifecycle-datasource.js';
-/**
- * Backward-compatible wrapper — accepts directory paths like the original API.
- * Existing consumers (lifecycle-refresh, evolution-status, nocturnal-service)
- * continue using this without changes.
- */
-export function buildLifecycleReadModelFromPaths(workspaceDir, stateDir) {
-    return buildLifecycleReadModel(new FilesystemLifecycleDatasource(workspaceDir, stateDir));
-}

package/plugin/dist/core/principle-internalization/lifecycle-refresh.js

@@ -1,4 +0,0 @@
-import { PrincipleLifecycleService, } from './principle-lifecycle-service.js';
-export function refreshPrincipleLifecycle(workspaceDir, stateDir) {
-    return new PrincipleLifecycleService(workspaceDir, stateDir).recomputeAll();
-}

package/plugin/dist/core/principle-internalization/principle-lifecycle-service.js

@@ -1,89 +0,0 @@
-import { loadLedger, updatePrinciple, updatePrincipleValueMetrics, updateRule, } from '../principle-tree-ledger.js';
-import { buildLifecycleReadModel } from './lifecycle-read-model.js';
-import { FilesystemLifecycleDatasource } from './filesystem-lifecycle-datasource.js';
-import { computePrincipleAdherence, computeRuleMetrics, } from '@principles/core/runtime-v2';
-import { assessDeprecatedReadiness, } from '@principles/core/runtime-v2';
-import { recommendLifecycleRoute, } from '@principles/core/runtime-v2';
-function createValueMetrics(principle, adherence, current) {
-    const violatedCount = principle.summary.repeatedErrorSignal;
-    const totalOpportunities = Math.max(violatedCount + principle.summary.replayReportCount, current?.totalOpportunities ?? 0);
-    const adheredCount = Math.max(0, Math.round((adherence.adherenceRate / 100) * totalOpportunities));
-    return {
-        principleId: principle.principle.id,
-        painPreventedCount: current?.painPreventedCount ?? principle.principle.painPreventedCount,
-        avgPainSeverityPrevented: current?.avgPainSeverityPrevented ?? 0,
-        lastPainPreventedAt: current?.lastPainPreventedAt ?? principle.principle.lastPainPreventedAt,
-        totalOpportunities,
-        adheredCount,
-        violatedCount,
-        implementationCost: current?.implementationCost ?? 0,
-        benefitScore: Number(((current?.painPreventedCount ?? principle.principle.painPreventedCount) *
-            Math.max(current?.avgPainSeverityPrevented ?? 0, 1) *
-            (adherence.adherenceRate / 100)).toFixed(2)),
-        calculatedAt: new Date().toISOString(),
-    };
-}
-export class PrincipleLifecycleService {
-    workspaceDir;
-    stateDir;
-    constructor(workspaceDir, stateDir) {
-        this.workspaceDir = workspaceDir;
-        this.stateDir = stateDir;
-    }
-    buildReadModel() {
-        const datasource = new FilesystemLifecycleDatasource(this.workspaceDir, this.stateDir);
-        return buildLifecycleReadModel(datasource);
-    }
-    listAssessments(readModel = this.buildReadModel()) {
-        return readModel.principles.map((principleEvidence) => {
-            const ruleMetrics = Object.fromEntries(principleEvidence.rules.map((ruleEvidence) => [
-                ruleEvidence.rule.id,
-                computeRuleMetrics(ruleEvidence),
-            ]));
-            const adherence = computePrincipleAdherence(principleEvidence, ruleMetrics);
-            const deprecatedReadiness = assessDeprecatedReadiness(principleEvidence, ruleMetrics, adherence);
-            const routeRecommendation = recommendLifecycleRoute(principleEvidence, ruleMetrics, adherence);
-            return {
-                principle: principleEvidence.principle,
-                summary: principleEvidence.summary,
-                ruleMetrics,
-                adherence,
-                deprecatedReadiness,
-                routeRecommendation,
-            };
-        });
-    }
-    listRouteRecommendations(readModel = this.buildReadModel()) {
-        return this.listAssessments(readModel).map((assessment) => assessment.routeRecommendation);
-    }
-    recomputeAll() {
-        const ledger = loadLedger(this.stateDir);
-        const readModel = this.buildReadModel();
-        const assessments = this.listAssessments(readModel);
-        return assessments.map((assessment) => {
-            const principleEvidence = readModel.principles.find((principle) => principle.principle.id === assessment.principle.id);
-            if (!principleEvidence) {
-                throw new Error(`Missing lifecycle evidence for principle "${assessment.principle.id}".`);
-            }
-            for (const [ruleId, metrics] of Object.entries(assessment.ruleMetrics)) {
-                updateRule(this.stateDir, ruleId, {
-                    coverageRate: metrics.coverageRate,
-                    falsePositiveRate: metrics.falsePositiveRate,
-                    updatedAt: readModel.generatedAt,
-                });
-            }
-            updatePrinciple(this.stateDir, principleEvidence.principle.id, {
-                adherenceRate: assessment.adherence.adherenceRate,
-                updatedAt: readModel.generatedAt,
-            });
-            updatePrincipleValueMetrics(this.stateDir, principleEvidence.principle.id, createValueMetrics(principleEvidence, assessment.adherence, ledger.tree.metrics[principleEvidence.principle.id]));
-            return {
-                principleId: principleEvidence.principle.id,
-                ruleMetrics: assessment.ruleMetrics,
-                adherence: assessment.adherence,
-                deprecatedReadiness: assessment.deprecatedReadiness,
-                routeRecommendation: assessment.routeRecommendation,
-            };
-        });
-    }
-}

package/plugin/dist/core/principle-training-state.js

@@ -1,113 +0,0 @@
-/**
- * Principle Training State Store
- * ================================================================
- *
- * Legacy compatibility adapter over the hybrid principle tree ledger file.
- * Top-level principle training records remain source-compatible for existing
- * consumers, while `_tree` is reserved for first-class Rule/Implementation
- * entities managed by principle-tree-ledger.ts.
- */
-import { loadLedger, saveLedger, saveLedgerAsync, updateTrainingStore, } from './principle-tree-ledger.js';
-/** File name for principle training state persistence */
-export const PRINCIPLE_TRAINING_FILE = 'principle_training_state.json';
-export function createDefaultPrincipleState(principleId) {
-    return {
-        principleId,
-        evaluability: 'manual_only',
-        applicableOpportunityCount: 0,
-        observedViolationCount: 0,
-        complianceRate: 0,
-        violationTrend: 0,
-        generatedSampleCount: 0,
-        approvedSampleCount: 0,
-        includedTrainRunIds: [],
-        deployedCheckpointIds: [],
-        internalizationStatus: 'prompt_only',
-    };
-}
-export function loadStore(stateDir) {
-    return ledgerTrainingStore(stateDir);
-}
-export function saveStore(stateDir, store) {
-    const ledger = loadLedger(stateDir);
-    saveLedger(stateDir, {
-        ...ledger,
-        trainingStore: store,
-    });
-}
-export async function loadStoreAsync(stateDir) {
-    return ledgerTrainingStore(stateDir);
-}
-export async function saveStoreAsync(stateDir, store) {
-    const ledger = loadLedger(stateDir);
-    await saveLedgerAsync(stateDir, {
-        ...ledger,
-        trainingStore: store,
-    });
-}
-export function getPrincipleState(stateDir, principleId) {
-    const store = loadStore(stateDir);
-    return store[principleId] ?? createDefaultPrincipleState(principleId);
-}
-export function setPrincipleState(stateDir, state) {
-    updateTrainingStore(stateDir, (store) => {
-        store[state.principleId] = state;
-    });
-}
-export function removePrincipleState(stateDir, principleId) {
-    updateTrainingStore(stateDir, (store) => {
-        delete store[principleId];
-    });
-}
-export function listPrincipleIds(stateDir) {
-    return Object.keys(loadStore(stateDir));
-}
-export function listPrinciplesByStatus(stateDir, status) {
-    return Object.values(loadStore(stateDir)).filter((state) => state.internalizationStatus === status);
-}
-export function listEvaluablePrinciples(stateDir) {
-    return Object.values(loadStore(stateDir)).filter((state) => state.evaluability !== 'manual_only' && state.internalizationStatus !== 'prompt_only');
-}
-// ── #212: Status transition mechanism ───────────────────────────────────────
-/**
- * Valid transitions in the internalization lifecycle:
- *
- * prompt_only → needs_training    (after manual validation or detectorMetadata upgrade)
- * needs_training → in_training    (training run started)
- * in_training → deployed_pending_eval  (checkpoint deployed for evaluation)
- * deployed_pending_eval → internalized (evaluation passed)
- * any → regressed                 (compliance dropped below threshold)
- * regressed → needs_training      (retraining triggered)
- */
-const VALID_TRANSITIONS = {
-    prompt_only: ['needs_training', 'regressed'],
-    needs_training: ['in_training', 'regressed'],
-    in_training: ['deployed_pending_eval', 'regressed'],
-    deployed_pending_eval: ['internalized', 'regressed'],
-    internalized: ['regressed'],
-    regressed: ['needs_training'],
-};
-/**
- * Transition a principle's internalization status to the next valid state.
- * Throws if the transition is not allowed.
- *
- * #212: This enables principles created as `prompt_only` to eventually
- * become `needs_training` and enter the nocturnal evaluation pipeline.
- */
-export function transitionInternalizationStatus(stateDir, principleId, nextStatus) {
-    updateTrainingStore(stateDir, (store) => {
-        const state = store[principleId];
-        if (!state) {
-            throw new Error(`Cannot transition: principle ${principleId} not found in training store`);
-        }
-        const allowed = VALID_TRANSITIONS[state.internalizationStatus] ?? [];
-        if (!allowed.includes(nextStatus)) {
-            throw new Error(`Invalid transition: ${state.internalizationStatus} → ${nextStatus}. ` +
-                `Allowed: ${allowed.join(', ') || 'none (terminal state)'}`);
-        }
-        state.internalizationStatus = nextStatus;
-    });
-}
-function ledgerTrainingStore(stateDir) {
-    return loadLedger(stateDir).trainingStore;
-}

package/plugin/dist/core/principle-tree-ledger.js

@@ -1,42 +0,0 @@
-/**
- * Principle Tree Ledger — plugin adapter (re-export) over @principles/core.
- *
- * PRI-459: This file WAS a full duplicate implementation of
- * principle_training_state.json parsing / serialization / mutation (~600
- * lines of inlined parsers, serializers, mutators, and a parallel codec).
- * That dual ownership caused two real failure classes:
- *
- *   1. Lost updates — core wrote the file UNLOCKED, the plugin wrote it WITH
- *      a lock, and neither knew the other's lock. Concurrent writers (e.g.
- *      evolution-worker async + a pd-cli command) could silently drop edits.
- *   2. Silent field loss — the two codecs parsed the same bytes at different
- *      strictness; a field one side persisted could be dropped on the next
- *      load by the other.
- *
- * Both are now fixed by converging on a SINGLE source of truth in core:
- *   - parse/serialize: @principles/core/runtime-v2/principle-tree/ledger-codec
- *   - mutation (with cross-process file lock): @principles/core/principle-tree-ledger
- *
- * This file is now a thin re-export so existing relative imports
- * (`from './principle-tree-ledger.js'`) keep resolving. Consumers get the
- * exact same API surface, now backed by the locked core implementation.
- *
- * Do NOT reintroduce parsing / serialization / mutation logic here. The
- * architecture-regression guard "PRI-459: single principle_training_state
- * ledger implementation" enforces this.
- */
-export { 
-// Constants
-TREE_NAMESPACE, 
-// Lock
-LockAcquisitionError, 
-// I/O + mutators
-loadLedger, saveLedger, saveLedgerAsync, updateTrainingStore, addPrincipleToLedger, createRule, createImplementation, updatePrinciple, updateRule, deleteRule, updateImplementation, deleteImplementation, listImplementationsForRule, getPrincipleSubtree, updatePrincipleValueMetrics, 
-// Lifecycle
-isValidLifecycleTransition, getAllowedTransitions, transitionImplementationState, listRuleImplementationsByState, findActiveImplementation, } from '@principles/core/principle-tree-ledger';
-// Back-compat alias: the historical plugin module exported `getLedgerFilePath`
-// (core names it `getLedgerFilePathPublic` for the same path). Keep the old
-// name resolvable for any consumer still on it; both compute
-// path.join(stateDir, 'principle_training_state.json').
-import { getLedgerFilePathPublic } from '@principles/core/principle-tree-ledger';
-export const getLedgerFilePath = getLedgerFilePathPublic;

package/plugin/dist/core/profile.js

@@ -1,211 +0,0 @@
-export const PROFILE_AUDIT_LEVELS = new Set(["low", "medium", "high"]);
-export const PROFILE_EVOLUTION_MODES = new Set(["realtime", "async"]);
-export const PROFILE_TEST_LEVELS = new Set(["smoke", "unit", "full"]);
-export const PROFILE_DEFAULTS = {
-    audit_level: "medium",
-    risk_paths: [],
-    evolution_mode: "realtime",
-    gate: {
-        require_plan_for_risk_paths: true,
-        require_audit_before_write: true,
-        require_reviewer_after_write: true,
-    },
-    tests: {
-        on_change: "smoke",
-        on_risk_change: "unit",
-        commands: {},
-    },
-    pain: {
-        soft_capture_threshold: 30,
-        adaptive: {
-            enabled: true,
-            spiral_boost: 20,
-            min_threshold: 15,
-            max_threshold: 70,
-            backlog_trigger: 6,
-            hard_failure_trigger: 1,
-            low_recent_success_boost: 15,
-            high_recent_pain_boost: 10,
-        },
-    },
-    lifecycle: {
-        enabled: true,
-        heartbeat_stale_hours: 72,
-    },
-    progressive_gate: {
-        enabled: true,
-        plan_approvals: {
-            enabled: false,
-            max_lines_override: -1,
-            allowed_patterns: [],
-            allowed_operations: [],
-        },
-    },
-    edit_verification: {
-        enabled: true,
-        max_file_size_bytes: 10 * 1024 * 1024, // 10MB
-        fuzzy_match_enabled: true,
-        fuzzy_match_threshold: 0.8,
-        skip_large_file_action: "warn", // "warn" or "block"
-    },
-    thinking_checkpoint: {
-        enabled: false, // Default OFF to avoid blocking new users
-        window_ms: 5 * 60 * 1000, // 5 minute window
-        high_risk_tools: ['run_shell_command', 'delete_file', 'move_file'],
-    },
-    custom_guards: [],
-};
-// Reason: normalizeProfile handles arbitrary JSON profile shapes where static typing cannot capture runtime field existence
-export function normalizeProfile(rawProfile) {
-    const defaults = JSON.parse(JSON.stringify(PROFILE_DEFAULTS));
-    const warnings = [];
-    const normalized = { ...defaults };
-    let invalid = false;
-    if (!rawProfile || typeof rawProfile !== "object" || Array.isArray(rawProfile)) {
-        warnings.push("PROFILE root must be an object; defaults applied.");
-        invalid = true;
-    }
-    else {
-        // Merge known fields (Support both snake_case and camelCase)
-        const auditLevel = rawProfile.audit_level ?? rawProfile.auditLevel;
-        if (PROFILE_AUDIT_LEVELS.has(auditLevel)) {
-            normalized.audit_level = auditLevel;
-        }
-        else if (auditLevel !== undefined) {
-            warnings.push(`Invalid audit_level '${auditLevel}'`);
-        }
-        const evolutionMode = rawProfile.evolution_mode ?? rawProfile.evolutionMode;
-        if (PROFILE_EVOLUTION_MODES.has(evolutionMode)) {
-            normalized.evolution_mode = evolutionMode;
-        }
-        else if (evolutionMode !== undefined) {
-            warnings.push(`Invalid evolution_mode '${evolutionMode}'`);
-        }
-        const riskPaths = rawProfile.risk_paths ?? rawProfile.riskPaths;
-        if (Array.isArray(riskPaths)) {
-            normalized.risk_paths = riskPaths.filter((p) => typeof p === 'string');
-        }
-        else if (typeof riskPaths === 'string') {
-            normalized.risk_paths = [riskPaths];
-        }
-        else if (riskPaths !== undefined) {
-            warnings.push("risk_paths must be an array of strings");
-        }
-        // Gate settings
-        if (rawProfile.gate && typeof rawProfile.gate === 'object') {
-            const g = rawProfile.gate;
-            normalized.gate.require_plan_for_risk_paths = g.require_plan_for_risk_paths ?? g.requirePlanForRiskPaths ?? defaults.gate.require_plan_for_risk_paths;
-            normalized.gate.require_audit_before_write = g.require_audit_before_write ?? g.requireAuditBeforeWrite ?? defaults.gate.require_audit_before_write;
-            normalized.gate.require_reviewer_after_write = g.require_reviewer_after_write ?? g.requireReviewerAfterWrite ?? defaults.gate.require_reviewer_after_write;
-        }
-        // Progressive Gate
-        if (rawProfile.progressive_gate && typeof rawProfile.progressive_gate === 'object') {
-            const pg = rawProfile.progressive_gate;
-            normalized.progressive_gate.enabled = pg.enabled ?? pg.enabled ?? defaults.progressive_gate.enabled;
-            // Plan approvals configuration
-            if (pg.plan_approvals && typeof pg.plan_approvals === 'object') {
-                const pa = pg.plan_approvals;
-                normalized.progressive_gate.plan_approvals.enabled = pa.enabled ?? pa.planApprovals ?? defaults.progressive_gate.plan_approvals.enabled;
-                const maxLines = pa.max_lines_override ?? pa.maxLinesOverride;
-                if (typeof maxLines === 'number' && maxLines >= -1) {
-                    normalized.progressive_gate.plan_approvals.max_lines_override = maxLines;
-                }
-                if (Array.isArray(pa.allowed_patterns)) {
-                    normalized.progressive_gate.plan_approvals.allowed_patterns = pa.allowed_patterns.filter((p) => typeof p === 'string');
-                }
-                if (Array.isArray(pa.allowed_operations)) {
-                    normalized.progressive_gate.plan_approvals.allowed_operations = pa.allowed_operations.filter((o) => typeof o === 'string');
-                }
-            }
-        }
-        else if (rawProfile.progressiveGate && typeof rawProfile.progressiveGate === 'object') {
-            const pg = rawProfile.progressiveGate;
-            normalized.progressive_gate.enabled = pg.enabled ?? defaults.progressive_gate.enabled;
-            // Plan approvals configuration (camelCase)
-            if (pg.planApprovals && typeof pg.planApprovals === 'object') {
-                const pa = pg.planApprovals;
-                normalized.progressive_gate.plan_approvals.enabled = pa.enabled ?? defaults.progressive_gate.plan_approvals.enabled;
-                const maxLines = pa.maxLinesOverride;
-                if (typeof maxLines === 'number' && maxLines >= -1) {
-                    normalized.progressive_gate.plan_approvals.max_lines_override = maxLines;
-                }
-                if (Array.isArray(pa.allowedPatterns)) {
-                    normalized.progressive_gate.plan_approvals.allowed_patterns = pa.allowedPatterns.filter((p) => typeof p === 'string');
-                }
-                if (Array.isArray(pa.allowedOperations)) {
-                    normalized.progressive_gate.plan_approvals.allowed_operations = pa.allowedOperations.filter((o) => typeof o === 'string');
-                }
-            }
-        }
-        // Edit verification settings (P-03)
-        const evRaw = rawProfile.edit_verification ?? rawProfile.editVerification;
-        if (evRaw && typeof evRaw === 'object') {
-            normalized.edit_verification.enabled = evRaw.enabled ?? defaults.edit_verification.enabled;
-            const maxSize = evRaw.max_file_size_bytes ?? evRaw.maxFileSizeBytes;
-            if (typeof maxSize === 'number' && maxSize >= 0) {
-                normalized.edit_verification.max_file_size_bytes = maxSize;
-            }
-            normalized.edit_verification.fuzzy_match_enabled = evRaw.fuzzy_match_enabled ?? evRaw.fuzzyMatchEnabled ?? defaults.edit_verification.fuzzy_match_enabled;
-            const threshold = evRaw.fuzzy_match_threshold ?? evRaw.fuzzyMatchThreshold;
-            if (typeof threshold === 'number' && threshold > 0 && threshold <= 1) {
-                normalized.edit_verification.fuzzy_match_threshold = threshold;
-            }
-            const action = evRaw.skip_large_file_action ?? evRaw.skipLargeFileAction;
-            if (typeof action === 'string' && ['warn', 'block'].includes(action)) {
-                normalized.edit_verification.skip_large_file_action = action;
-            }
-        }
-        // Test settings
-        if (rawProfile.tests && typeof rawProfile.tests === 'object') {
-            const t = rawProfile.tests;
-            const onChange = t.on_change ?? t.onChange;
-            if (PROFILE_TEST_LEVELS.has(onChange)) {
-                normalized.tests.on_change = onChange;
-            }
-            const onRiskChange = t.on_risk_change ?? t.onRiskChange;
-            if (PROFILE_TEST_LEVELS.has(onRiskChange)) {
-                normalized.tests.on_risk_change = onRiskChange;
-            }
-            if (t.commands && typeof t.commands === 'object') {
-                normalized.tests.commands = { ...defaults.tests.commands, ...t.commands };
-            }
-        }
-        // Pain settings
-        if (rawProfile.pain && typeof rawProfile.pain === 'object') {
-            const p = rawProfile.pain;
-            normalized.pain.soft_capture_threshold = p.soft_capture_threshold ?? p.softCaptureThreshold ?? defaults.pain.soft_capture_threshold;
-            if (p.adaptive && typeof p.adaptive === 'object') {
-                normalized.pain.adaptive = { ...defaults.pain.adaptive, ...p.adaptive };
-            }
-        }
-        // Thinking OS Checkpoint settings (P-10)
-        const tcRaw = rawProfile.thinking_checkpoint ?? rawProfile.thinkingCheckpoint;
-        if (tcRaw && typeof tcRaw === 'object') {
-            normalized.thinking_checkpoint.enabled = tcRaw.enabled ?? defaults.thinking_checkpoint.enabled;
-            const windowMs = tcRaw.window_ms ?? tcRaw.windowMs;
-            if (typeof windowMs === 'number' && windowMs > 0) {
-                normalized.thinking_checkpoint.window_ms = windowMs;
-            }
-            if (Array.isArray(tcRaw.high_risk_tools ?? tcRaw.highRiskTools)) {
-                normalized.thinking_checkpoint.high_risk_tools = (tcRaw.high_risk_tools ?? tcRaw.highRiskTools).filter((t) => typeof t === 'string');
-            }
-        }
-        if (Array.isArray(rawProfile.custom_guards)) {
-            normalized.custom_guards = rawProfile.custom_guards.map((item) => {
-                let severity = "error";
-                const itemSeverity = item.severity;
-                if (itemSeverity && ["info", "warning", "error", "fatal"].includes(String(itemSeverity).toLowerCase())) {
-                    severity = String(itemSeverity).toLowerCase();
-                }
-                return {
-                    pattern: String(item.pattern || ""),
-                    message: String(item.message || "Custom guard triggered"),
-                    severity,
-                };
-            }).filter((item) => item.pattern);
-        }
-    }
-    normalized._profile_invalid = invalid;
-    normalized._profile_warnings = warnings;
-    return normalized;
-}

package/plugin/dist/core/reflection/reflection-context.js

@@ -1,91 +0,0 @@
-import { loadLedger } from '../principle-tree-ledger.js';
-export class ReflectionContextCollector {
-    stateDir;
-    trajectory;
-    constructor(stateDir, trajectory) {
-        this.stateDir = stateDir;
-        this.trajectory = trajectory;
-    }
-    collect(principleId) {
-        const ledger = loadLedger(this.stateDir);
-        const principle = ledger.tree.principles[principleId];
-        if (!principle) {
-            return null;
-        }
-        if (!principle.derivedFromPainIds || principle.derivedFromPainIds.length === 0) {
-            return null;
-        }
-        return this.buildContext(principle);
-    }
-    collectBatch(filter) {
-        const ledger = loadLedger(this.stateDir);
-        const principles = Object.values(ledger.tree.principles);
-        const results = [];
-        for (const principle of principles) {
-            if (filter?.status && principle.status !== filter.status) {
-                continue;
-            }
-            if (!principle.derivedFromPainIds || principle.derivedFromPainIds.length === 0) {
-                continue;
-            }
-            const ctx = this.buildContext(principle);
-            if (ctx) {
-                results.push(ctx);
-            }
-        }
-        return results;
-    }
-    buildContext(principle) {
-        const sourcePainIds = principle.derivedFromPainIds;
-        const { painEvents } = this.resolvePainEvents(sourcePainIds);
-        return {
-            principle,
-            painEvents,
-            sessionSnapshot: null,
-        };
-    }
-    resolvePainEvents(sourcePainIds) {
-        const sessions = this.trajectory.listRecentSessions({ limit: 100 });
-        const sourcePainIdSet = new Set(sourcePainIds);
-        const exactMatches = [];
-        const heuristicMatches = [];
-        let exactSessionId = null;
-        let heuristicSessionId = null;
-        for (const session of sessions) {
-            const sessionPainEvents = this.trajectory.listPainEventsForSession(session.sessionId);
-            for (const pe of sessionPainEvents) {
-                if (sourcePainIdSet.has(String(pe.id))) {
-                    exactMatches.push({
-                        source: pe.source,
-                        score: pe.score,
-                        severity: pe.severity,
-                        reason: pe.reason,
-                        createdAt: pe.createdAt,
-                    });
-                    if (!exactSessionId) {
-                        exactSessionId = session.sessionId;
-                    }
-                    continue;
-                }
-                const peText = [pe.reason, pe.origin].filter(Boolean);
-                const isMatch = sourcePainIds.some((painId) => peText.some((field) => field?.includes(painId)));
-                if (isMatch) {
-                    heuristicMatches.push({
-                        source: pe.source,
-                        score: pe.score,
-                        severity: pe.severity,
-                        reason: pe.reason,
-                        createdAt: pe.createdAt,
-                    });
-                    if (!heuristicSessionId) {
-                        heuristicSessionId = session.sessionId;
-                    }
-                }
-            }
-        }
-        if (exactMatches.length > 0) {
-            return { painEvents: exactMatches, sessionId: exactSessionId };
-        }
-        return { painEvents: heuristicMatches, sessionId: heuristicSessionId };
-    }
-}

package/plugin/dist/core/replay-engine.js

@@ -1,82 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { getImplementationAssetRoot } from './code-implementation-storage.js';
-import { loadLedger } from './principle-tree-ledger.js';
-export class ReplayEngine {
-    workspaceDir;
-    stateDir;
-    constructor(workspaceDir, stateDir) {
-        this.workspaceDir = workspaceDir;
-        this.stateDir = stateDir;
-    }
-    listReports(implementationId) {
-        const reportDir = path.join(getImplementationAssetRoot(this.stateDir, implementationId), 'replays');
-        if (!fs.existsSync(reportDir))
-            return [];
-        try {
-            const files = fs.readdirSync(reportDir).filter((file) => file.endsWith('.json'));
-            return files
-                .sort()
-                .reverse()
-                .map((file) => {
-                const content = fs.readFileSync(path.join(reportDir, file), 'utf-8');
-                return JSON.parse(content);
-            });
-        }
-        catch (err) {
-            console.warn(`[ReplayEngine] Failed to read reports in ${reportDir}: ${err instanceof Error ? err.message : String(err)}`);
-            return [];
-        }
-    }
-    getLatestReport(implementationId) {
-        const reports = this.listReports(implementationId);
-        return reports[0] ?? null;
-    }
-    hasPassingReport(implementationId) {
-        return this.listReports(implementationId).some((report) => report.overallDecision === 'pass');
-    }
-    _getImplementationById(implementationId) {
-        const ledger = loadLedger(this.stateDir);
-        return ledger.tree.implementations[implementationId] ?? null;
-    }
-}
-export function formatReplayReport(report) {
-    const decisionEmoji = report.overallDecision === 'pass'
-        ? 'PASS'
-        : report.overallDecision === 'fail'
-            ? 'FAIL'
-            : 'NEEDS-REVIEW';
-    let output = '';
-    output += '\nReplay Evaluation Report\n';
-    output += `${'='.repeat(50)}\n`;
-    output += `Implementation: ${report.implementationId}\n`;
-    output += `Generated At:   ${report.generatedAt}\n`;
-    output += `Overall Decision: [${decisionEmoji}]\n\n`;
-    output += `Evidence Status: ${report.evidenceSummary.evidenceStatus} (samples=${report.evidenceSummary.totalSamples})\n\n`;
-    const formatSection = (label, summary) => {
-        const rate = summary.total > 0
-            ? ((summary.passed / summary.total) * 100).toFixed(1)
-            : 'N/A';
-        let section = `  ${label}:\n`;
-        section += `    Total: ${summary.total} | Passed: ${summary.passed} | Failed: ${summary.failed}\n`;
-        section += `    Pass Rate: ${rate}%\n`;
-        if (summary.failed > 0) {
-            section += '    Failures:\n';
-            for (const detail of summary.details.filter((item) => !item.passed)) {
-                section += `      - ${detail.sampleFingerprint}: ${detail.reason ?? detail.decision}\n`;
-            }
-        }
-        return section;
-    };
-    output += formatSection('Pain-Negative Samples', report.replayResults.painNegative);
-    output += formatSection('Success-Positive Samples', report.replayResults.successPositive);
-    output += formatSection('Principle-Anchor Samples', report.replayResults.principleAnchor);
-    if (report.blockers.length > 0) {
-        output += '\nBlockers:\n';
-        for (const blocker of report.blockers) {
-            output += `  - ${blocker}\n`;
-        }
-    }
-    output += `${'='.repeat(50)}\n`;
-    return output;
-}