pulseed 0.6.0 → 0.6.2

package/dist/runtime/store/evidence-ledger.js

@@ -1,438 +1,16 @@
 import { randomUUID } from "node:crypto";
 import * as fsp from "node:fs/promises";
 import * as path from "node:path";
-import { z } from "zod";
 import { createRuntimeStorePaths, ensureRuntimeStorePaths, } from "./runtime-paths.js";
-import { summarizeEvidenceMetricTrends } from "./metric-history.js";
+import { correctionStateForTarget, MemoryCorrectionEntrySchema, summarizeMemoryCorrectionState, } from "../../platform/corrections/memory-correction-ledger.js";
+import { extractMetricObservationsFromEvidence, summarizeEvidenceMetricTrends, } from "./metric-history.js";
 import { summarizeEvidenceEvaluatorResults, } from "./evaluator-results.js";
 import { summarizeEvidenceResearchMemos, } from "./research-evidence.js";
 import { summarizeEvidenceDreamCheckpoints, } from "./dream-checkpoints.js";
-import { summarizeArtifactRetention, RuntimeArtifactRetentionClassSchema, } from "./artifact-retention.js";
-export const RuntimeEvidenceOutcomeSchema = z.enum([
-    "improved",
-    "regressed",
-    "inconclusive",
-    "failed",
-    "blocked",
-    "continued",
-]);
-export const RuntimeEvidenceEntryKindSchema = z.enum([
-    "observation",
-    "strategy",
-    "task_generation",
-    "execution",
-    "verification",
-    "decision",
-    "metric",
-    "evaluator",
-    "research",
-    "dream_checkpoint",
-    "artifact",
-    "failure",
-    "other",
-]);
-export const RuntimeEvidenceArtifactRefSchema = z.object({
-    label: z.string().min(1),
-    path: z.string().min(1).optional(),
-    state_relative_path: z.string().min(1).optional(),
-    url: z.string().url().optional(),
-    kind: z.enum(["log", "metrics", "report", "diff", "url", "other"]).default("other"),
-    retention_class: RuntimeArtifactRetentionClassSchema.optional(),
-    size_bytes: z.number().int().nonnegative().optional(),
-    source: z.string().min(1).optional(),
-    dependency_refs: z.array(z.string().min(1)).optional(),
-}).strict();
-export const RuntimeEvidenceMetricSchema = z.object({
-    label: z.string().min(1),
-    value: z.union([z.string(), z.number(), z.boolean(), z.null()]).optional(),
-    unit: z.string().min(1).optional(),
-    direction: z.enum(["maximize", "minimize", "neutral"]).optional(),
-    confidence: z.number().min(0).max(1).optional(),
-    observed_at: z.string().datetime().optional(),
-    source: z.string().min(1).optional(),
-    summary: z.string().min(1).optional(),
-}).strict();
-export const RuntimeEvidenceCandidateDispositionSchema = z.enum(["retained", "promoted", "retired"]);
-export const RuntimeEvidenceCandidateLineageSchema = z.object({
-    parent_candidate_id: z.string().min(1).optional(),
-    source_candidate_id: z.string().min(1).optional(),
-    source_strategy_id: z.string().min(1).optional(),
-    source_strategy: z.string().min(1).optional(),
-    strategy_family: z.string().min(1),
-    feature_lineage: z.array(z.string().min(1)).default([]),
-    model_lineage: z.array(z.string().min(1)).default([]),
-    config_lineage: z.array(z.string().min(1)).default([]),
-    seed_lineage: z.array(z.string().min(1)).default([]),
-    fold_lineage: z.array(z.string().min(1)).default([]),
-    postprocess_lineage: z.array(z.string().min(1)).default([]),
-    notes: z.string().min(1).optional(),
-}).strict();
-export const RuntimeEvidenceCandidateSimilaritySchema = z.object({
-    candidate_id: z.string().min(1),
-    similarity: z.number().min(0).max(1),
-    signal: z.enum(["declared", "lineage", "metric_correlation", "artifact_overlap", "other"]).default("declared"),
-    summary: z.string().min(1).optional(),
-}).strict();
-export const RuntimeEvidenceCandidateNearMissReasonSchema = z.enum([
-    "close_to_best",
-    "stability",
-    "novelty",
-    "weak_dimension_improvement",
-    "complementarity",
-    "ensemble_potential",
-]);
-export const RuntimeEvidenceCandidateNearMissSchema = z.object({
-    status: z.enum(["retained", "promoted", "rejected"]).default("retained"),
-    reason_to_keep: z.array(RuntimeEvidenceCandidateNearMissReasonSchema).min(1),
-    margin_to_best: z.number().min(0).optional(),
-    weak_dimensions: z.array(z.string().min(1)).default([]),
-    complementary_candidate_ids: z.array(z.string().min(1)).default([]),
-    follow_up: z.object({
-        title: z.string().min(1),
-        rationale: z.string().min(1),
-        target_dimensions: z.array(z.string().min(1)).default([]),
-        expected_evidence_gain: z.string().min(1).optional(),
-    }).strict().optional(),
-    evidence_refs: z.array(z.string().min(1)).default([]),
-    summary: z.string().min(1).optional(),
-}).strict();
-export const RuntimeEvidenceCandidateRecordSchema = z.object({
-    candidate_id: z.string().min(1),
-    label: z.string().min(1).optional(),
-    lineage: RuntimeEvidenceCandidateLineageSchema,
-    metrics: z.array(RuntimeEvidenceMetricSchema).default([]),
-    artifacts: z.array(RuntimeEvidenceArtifactRefSchema).default([]),
-    similarity: z.array(RuntimeEvidenceCandidateSimilaritySchema).default([]),
-    robustness: z.object({
-        stability_score: z.number().min(0).max(1).optional(),
-        diversity_score: z.number().min(0).max(1).optional(),
-        risk_penalty: z.number().min(0).max(1).optional(),
-        robust_score: z.number().min(0).max(1).optional(),
-        evidence_confidence: z.number().min(0).max(1).optional(),
-        repeated_evaluations: z.number().int().nonnegative().optional(),
-        mean_score: z.number().optional(),
-        max_score: z.number().optional(),
-        score_stddev: z.number().min(0).optional(),
-        fold_score_range: z.number().min(0).optional(),
-        seed_score_range: z.number().min(0).optional(),
-        weak_dimensions: z.array(z.string().min(1)).default([]),
-        provenance_refs: z.array(z.string().min(1)).default([]),
-        summary: z.string().min(1).optional(),
-    }).strict().optional(),
-    near_miss: RuntimeEvidenceCandidateNearMissSchema.optional(),
-    disposition: RuntimeEvidenceCandidateDispositionSchema.default("retained"),
-    disposition_reason: z.string().min(1).optional(),
-    produced_at: z.string().datetime().optional(),
-}).strict();
-export const RuntimeEvidenceEvaluatorSignalSchema = z.enum(["local", "external"]);
-export const RuntimeEvidenceEvaluatorStatusSchema = z.enum([
-    "pending",
-    "ready",
-    "approval_required",
-    "submitted",
-    "passed",
-    "succeeded",
-    "completed",
-    "failed",
-    "regressed",
-    "blocked",
-    "unknown",
-]);
-export const RuntimeEvidenceEvaluatorPublishActionSchema = z.object({
-    id: z.string().min(1),
-    label: z.string().min(1),
-    tool_name: z.string().min(1).optional(),
-    payload_ref: z.string().min(1).optional(),
-    approval_required: z.literal(true).default(true),
-    status: z.enum(["approval_required", "approved", "submitted", "completed", "blocked"]).optional(),
-}).strict();
-export const RuntimeEvidenceEvaluatorValidationSchema = z.object({
-    status: z.enum(["pending", "passed", "failed", "blocked", "unknown"]).default("unknown"),
-    command: z.string().min(1).optional(),
-    summary: z.string().min(1).optional(),
-}).strict();
-export const RuntimeEvidenceEvaluatorProvenanceSchema = z.object({
-    kind: z.enum(["local_command", "external_url", "ci", "benchmark", "human_review", "other"]).default("other"),
-    command: z.string().min(1).optional(),
-    url: z.string().url().optional(),
-    run_id: z.string().min(1).optional(),
-    external_id: z.string().min(1).optional(),
-    raw_ref: z.string().min(1).optional(),
-    retrieved_at: z.string().datetime().optional(),
-}).strict();
-export const RuntimeEvidenceEvaluatorBudgetSchema = z.object({
-    policy_id: z.string().min(1).optional(),
-    max_attempts: z.number().int().positive().optional(),
-    used_attempts: z.number().int().nonnegative().optional(),
-    remaining_attempts: z.number().int().nonnegative(),
-    approval_required: z.boolean().default(true),
-    deadline_at: z.string().datetime().optional(),
-    phase: z.enum(["exploration", "consolidation", "finalization", "other"]).optional(),
-    portfolio_policy: z.object({
-        diversified_portfolio_required: z.boolean().default(false),
-        reserve_for_finalization: z.boolean().default(false),
-        min_strategy_families: z.number().int().positive().optional(),
-    }).strict().optional(),
-}).strict();
-export const RuntimeEvidenceEvaluatorCandidateSnapshotSchema = z.object({
-    evidence_entry_id: z.string().min(1).optional(),
-    primary_metric_label: z.string().min(1).optional(),
-    local_metrics: z.array(RuntimeEvidenceMetricSchema).default([]),
-    robust_selection: z.object({
-        raw_rank: z.number().int().positive().optional(),
-        robust_score: z.number().min(0).max(1).optional(),
-        stability_score: z.number().min(0).max(1).optional(),
-        diversity_score: z.number().min(0).max(1).optional(),
-        risk_penalty: z.number().min(0).max(1).optional(),
-        portfolio_role: z.enum(["raw_best", "robust_best", "safe", "aggressive", "diverse", "near_miss", "other"]).optional(),
-    }).strict().optional(),
-    summary: z.string().min(1).optional(),
-}).strict();
-export const RuntimeEvidenceEvaluatorCalibrationSchema = z.object({
-    mode: z.literal("calibration_only").default("calibration_only"),
-    use_for_selection: z.boolean().default(false),
-    direct_optimization_allowed: z.literal(false).default(false),
-    minimum_observations: z.number().int().positive().default(1),
-    conclusion: z.string().min(1).optional(),
-}).strict();
-export const RuntimeEvidenceEvaluatorObservationSchema = z.object({
-    evaluator_id: z.string().min(1),
-    signal: RuntimeEvidenceEvaluatorSignalSchema,
-    source: z.string().min(1),
-    candidate_id: z.string().min(1),
-    candidate_label: z.string().min(1).optional(),
-    artifact_labels: z.array(z.string().min(1)).optional(),
-    status: RuntimeEvidenceEvaluatorStatusSchema.default("unknown"),
-    score: z.union([z.string(), z.number(), z.boolean(), z.null()]).optional(),
-    score_label: z.string().min(1).optional(),
-    direction: z.enum(["maximize", "minimize", "neutral"]).optional(),
-    observed_at: z.string().datetime().optional(),
-    expected_score: z.union([z.string(), z.number(), z.boolean(), z.null()]).optional(),
-    expected_status: RuntimeEvidenceEvaluatorStatusSchema.optional(),
-    expectation_source: z.string().min(1).optional(),
-    validation: RuntimeEvidenceEvaluatorValidationSchema.optional(),
-    publish_action: RuntimeEvidenceEvaluatorPublishActionSchema.optional(),
-    provenance: RuntimeEvidenceEvaluatorProvenanceSchema.optional(),
-    budget: RuntimeEvidenceEvaluatorBudgetSchema.optional(),
-    candidate_snapshot: RuntimeEvidenceEvaluatorCandidateSnapshotSchema.optional(),
-    calibration: RuntimeEvidenceEvaluatorCalibrationSchema.optional(),
-    summary: z.string().min(1).optional(),
-}).strict();
-export const RuntimeEvidenceResearchSourceSchema = z.object({
-    url: z.string().url(),
-    title: z.string().min(1).optional(),
-    source_type: z.enum(["official_docs", "maintainer", "paper", "issue_thread", "example", "writeup", "other"]).default("other"),
-    provenance: z.enum(["quoted", "paraphrased", "summarized"]).default("summarized"),
-    relevance: z.string().min(1).optional(),
-}).strict();
-export const RuntimeEvidenceResearchFindingSchema = z.object({
-    finding: z.string().min(1),
-    source_urls: z.array(z.string().url()).min(1),
-    applicability: z.string().min(1),
-    risks_constraints: z.array(z.string().min(1)).default([]),
-    proposed_experiment: z.string().min(1),
-    expected_metric_impact: z.string().min(1),
-    fact_vs_adaptation: z.object({
-        facts: z.array(z.string().min(1)).default([]),
-        adaptation: z.string().min(1),
-    }).strict(),
-}).strict();
-export const RuntimeEvidenceResearchExternalActionSchema = z.object({
-    label: z.string().min(1),
-    reason: z.string().min(1),
-    approval_required: z.literal(true).default(true),
-}).strict();
-export const RuntimeEvidenceResearchMemoSchema = z.object({
-    trigger: z.enum(["plateau", "uncertainty", "knowledge_gap"]),
-    query: z.string().min(1),
-    summary: z.string().min(1),
-    sources: z.array(RuntimeEvidenceResearchSourceSchema).min(1),
-    findings: z.array(RuntimeEvidenceResearchFindingSchema).min(1),
-    candidate_playbook: z.object({
-        title: z.string().min(1),
-        steps: z.array(z.string().min(1)).default([]),
-        source_urls: z.array(z.string().url()).default([]),
-    }).strict().optional(),
-    untrusted_content_policy: z.literal("webpage_instructions_are_untrusted").default("webpage_instructions_are_untrusted"),
-    external_actions: z.array(RuntimeEvidenceResearchExternalActionSchema).default([]),
-    confidence: z.number().min(0).max(1).default(0.5),
-}).strict();
-export const RuntimeEvidenceDreamCheckpointTriggerSchema = z.enum([
-    "iteration",
-    "plateau",
-    "breakthrough",
-    "pre_finalization",
-]);
-export const RuntimeEvidenceDreamCheckpointMemoryRefSchema = z.object({
-    source_type: z.enum(["soil", "playbook", "runtime_evidence", "other"]),
-    ref: z.string().min(1).optional(),
-    summary: z.string().min(1),
-    authority: z.literal("advisory_only").default("advisory_only"),
-    relevance_score: z.number().min(0).max(1).optional(),
-    source_reliability: z.number().min(0).max(1).optional(),
-    recency_score: z.number().min(0).max(1).optional(),
-    prior_success_contribution: z.number().min(0).max(1).optional(),
-    retrieval: z.object({
-        kind: z.enum(["route_hit", "fallback_hit", "checkpoint", "manual", "unknown"]).default("unknown"),
-        score: z.number().min(0).max(1).optional(),
-        confidence: z.number().min(0).max(1).optional(),
-    }).strict().optional(),
-    ranking_trace: z.object({
-        score: z.number().min(0).max(1),
-        decision: z.enum(["admitted", "rejected"]),
-        reason: z.string().min(1),
-    }).strict().optional(),
-}).strict();
-export const RuntimeEvidenceDreamCheckpointStrategyCandidateSchema = z.object({
-    title: z.string().min(1),
-    rationale: z.string().min(1),
-    target_dimensions: z.array(z.string().min(1)).default([]),
-    expected_evidence_gain: z.string().min(1).optional(),
-    retry_reason: z.string().min(1).optional(),
-    failed_lineage_warning: z.object({
-        fingerprint: z.string().min(1),
-        count: z.number().int().positive(),
-        reason: z.string().min(1),
-    }).strict().optional(),
-}).strict();
-export const RuntimeEvidenceDreamCheckpointActiveHypothesisSchema = z.object({
-    hypothesis: z.string().min(1),
-    supporting_evidence_ref: z.string().min(1).optional(),
-    target_metric_or_dimension: z.string().min(1),
-    expected_next_observation: z.string().min(1),
-    status: z.enum(["active", "testing", "supported", "weakened"]).default("active"),
-}).strict();
-export const RuntimeEvidenceDreamCheckpointRejectedApproachSchema = z.object({
-    approach: z.string().min(1),
-    rejection_reason: z.string().min(1),
-    evidence_ref: z.string().min(1).optional(),
-    revisit_condition: z.string().min(1).optional(),
-    confidence: z.number().min(0).max(1).default(0.5),
-}).strict();
-export const RuntimeEvidenceDreamRunControlRecommendationSchema = z.object({
-    id: z.string().min(1).optional(),
-    action: z.enum([
-        "stay_current_mode",
-        "widen_exploration",
-        "consolidate_candidates",
-        "freeze_experiment_queue",
-        "enter_finalization",
-        "preserve_near_miss_candidates",
-        "retire_low_value_lineage",
-        "request_operator_approval",
-    ]),
-    rationale: z.string().min(1),
-    evidence: z.array(z.object({
-        kind: z.enum(["metric", "artifact", "lineage", "task_history", "deadline", "external_feedback", "memory", "runtime_state"]),
-        ref: z.string().min(1).optional(),
-        summary: z.string().min(1),
-    }).strict()).min(1),
-    target_mode: z.enum(["exploration", "consolidation", "finalization"]).optional(),
-    target_strategy_family: z.string().min(1).optional(),
-    candidate_refs: z.array(z.string().min(1)).default([]),
-    lineage_refs: z.array(z.string().min(1)).default([]),
-    approval_required: z.boolean().default(false),
-    risk: z.enum(["low", "medium", "high"]).default("medium"),
-    confidence: z.number().min(0).max(1).default(0.5),
-    policy_decision: z.object({
-        disposition: z.enum(["auto_apply", "approval_required", "advisory_only"]),
-        reason: z.string().min(1),
-    }).strict().optional(),
-}).strict();
-export const RuntimeEvidenceDreamCheckpointSchema = z.object({
-    trigger: RuntimeEvidenceDreamCheckpointTriggerSchema,
-    summary: z.string().min(1),
-    current_goal: z.string().min(1),
-    active_dimensions: z.array(z.string().min(1)).default([]),
-    best_evidence_so_far: z.string().min(1).optional(),
-    recent_strategy_families: z.array(z.string().min(1)).default([]),
-    exhausted: z.array(z.string().min(1)).default([]),
-    promising: z.array(z.string().min(1)).default([]),
-    relevant_memories: z.array(RuntimeEvidenceDreamCheckpointMemoryRefSchema).default([]),
-    active_hypotheses: z.array(RuntimeEvidenceDreamCheckpointActiveHypothesisSchema).default([]),
-    rejected_approaches: z.array(RuntimeEvidenceDreamCheckpointRejectedApproachSchema).default([]),
-    next_strategy_candidates: z.array(RuntimeEvidenceDreamCheckpointStrategyCandidateSchema).default([]),
-    run_control_recommendations: z.array(RuntimeEvidenceDreamRunControlRecommendationSchema).optional(),
-    guidance: z.string().min(1),
-    uncertainty: z.array(z.string().min(1)).default([]),
-    context_authority: z.literal("advisory_only").default("advisory_only"),
-    confidence: z.number().min(0).max(1).default(0.5),
-}).strict();
-export const RuntimeEvidenceDivergentHypothesisSchema = z.object({
-    strategy_id: z.string().min(1).optional(),
-    hypothesis: z.string().min(1),
-    strategy_family: z.string().min(1),
-    role: z.enum(["exploitation", "adjacent_exploration", "divergent_exploration"]),
-    novelty_score: z.number().min(0).max(1),
-    similarity_to_recent_failures: z.number().min(0).max(1).default(0),
-    expected_cost: z.enum(["low", "medium", "high"]),
-    relationship_to_lineage: z.enum([
-        "current_best",
-        "neighbor",
-        "failed_lineage",
-        "different_mechanism",
-        "different_assumption",
-        "unknown",
-    ]),
-    prior_evidence: z.string().min(1).optional(),
-    downrank_reason: z.string().min(1).optional(),
-    smoke_status: z.enum(["not_run", "promote", "defer", "retire"]).default("not_run"),
-    smoke_reason: z.string().min(1).optional(),
-    smoke_evidence_ref: z.string().min(1).optional(),
-    evidence_authority: z.literal("speculative_hypothesis").default("speculative_hypothesis"),
-}).strict();
-export const RuntimeEvidenceEntrySchema = z.object({
-    schema_version: z.literal("runtime-evidence-entry-v1"),
-    id: z.string().min(1),
-    occurred_at: z.string().datetime(),
-    kind: RuntimeEvidenceEntryKindSchema,
-    scope: z.object({
-        goal_id: z.string().min(1).optional(),
-        run_id: z.string().min(1).optional(),
-        task_id: z.string().min(1).optional(),
-        loop_index: z.number().int().nonnegative().optional(),
-        phase: z.string().min(1).optional(),
-    }).strict(),
-    hypothesis: z.string().min(1).optional(),
-    strategy: z.string().min(1).optional(),
-    task: z.object({
-        id: z.string().min(1).optional(),
-        description: z.string().min(1).optional(),
-        action: z.string().min(1).optional(),
-        primary_dimension: z.string().min(1).optional(),
-    }).strict().optional(),
-    verification: z.object({
-        command: z.string().min(1).optional(),
-        verdict: z.string().min(1).optional(),
-        confidence: z.number().min(0).max(1).optional(),
-        summary: z.string().min(1).optional(),
-    }).strict().optional(),
-    metrics: z.array(RuntimeEvidenceMetricSchema).default([]),
-    evaluators: z.array(RuntimeEvidenceEvaluatorObservationSchema).optional(),
-    research: z.array(RuntimeEvidenceResearchMemoSchema).optional(),
-    dream_checkpoints: z.array(RuntimeEvidenceDreamCheckpointSchema).optional(),
-    divergent_exploration: z.array(RuntimeEvidenceDivergentHypothesisSchema).optional(),
-    candidates: z.array(RuntimeEvidenceCandidateRecordSchema).optional(),
-    artifacts: z.array(RuntimeEvidenceArtifactRefSchema).default([]),
-    result: z.object({
-        status: z.string().min(1).optional(),
-        summary: z.string().min(1).optional(),
-        error: z.string().min(1).optional(),
-    }).strict().optional(),
-    outcome: RuntimeEvidenceOutcomeSchema.optional(),
-    decision_reason: z.string().min(1).optional(),
-    raw_refs: z.array(z.object({
-        kind: z.string().min(1),
-        id: z.string().min(1).optional(),
-        path: z.string().min(1).optional(),
-        state_relative_path: z.string().min(1).optional(),
-        url: z.string().url().optional(),
-    }).strict()).default([]),
-    summary: z.string().min(1).optional(),
-}).strict().refine((entry) => entry.scope.goal_id || entry.scope.run_id, {
-    message: "goal_id or run_id is required",
-    path: ["scope"],
-});
+import { summarizeArtifactRetention, } from "./artifact-retention.js";
+import { RuntimeEvidenceEntrySchema, } from "./evidence-types.js";
+export { RuntimeArtifactRetentionClassSchema, RuntimeEvidenceArtifactRefSchema, RuntimeEvidenceCandidateDispositionSchema, RuntimeEvidenceCandidateLineageSchema, RuntimeEvidenceCandidateNearMissReasonSchema, RuntimeEvidenceCandidateNearMissSchema, RuntimeEvidenceCandidateRecordSchema, RuntimeEvidenceCandidateSimilaritySchema, RuntimeEvidenceDivergentHypothesisSchema, RuntimeEvidenceDreamCheckpointSchema, RuntimeEvidenceDreamCheckpointActiveHypothesisSchema, RuntimeEvidenceDreamCheckpointMemoryRefSchema, RuntimeEvidenceDreamCheckpointRejectedApproachSchema, RuntimeEvidenceDreamCheckpointStrategyCandidateSchema, RuntimeEvidenceDreamCheckpointTriggerSchema, RuntimeEvidenceDreamRunControlRecommendationSchema, RuntimeEvidenceEntryKindSchema, RuntimeEvidenceEntrySchema, RuntimeEvidenceEvaluatorBudgetSchema, RuntimeEvidenceEvaluatorCalibrationSchema, RuntimeEvidenceEvaluatorCandidateSnapshotSchema, RuntimeEvidenceEvaluatorObservationSchema, RuntimeEvidenceEvaluatorProvenanceSchema, RuntimeEvidenceEvaluatorPublishActionSchema, RuntimeEvidenceEvaluatorSignalSchema, RuntimeEvidenceEvaluatorStatusSchema, RuntimeEvidenceEvaluatorValidationSchema, RuntimeEvidenceMetricSchema, RuntimeEvidenceMemoryUsageStatsSchema, RuntimeEvidenceOutcomeSchema, RuntimeEvidenceResearchExternalActionSchema, RuntimeEvidenceResearchFindingSchema, RuntimeEvidenceResearchMemoSchema, RuntimeEvidenceResearchSourceSchema, } from "./evidence-types.js";
+const summaryIndexUpdateLocks = new Map();
 export class RuntimeEvidenceLedger {
     paths;
     constructor(runtimeRootOrPaths) {
@@ -472,14 +50,32 @@ export class RuntimeEvidenceLedger {
         if (entry.scope.run_id)
             targets.add(this.paths.evidenceRunPath(entry.scope.run_id));
         await Promise.all([...targets].map(async (target) => {
-            await fsp.mkdir(path.dirname(target), { recursive: true });
-            await fsp.appendFile(target, `${JSON.stringify(entry)}\n`, "utf8");
-        }));
-        await Promise.all([...targets].map(async (target) => {
-            await rebuildSummaryIndex(target, this.paths);
+            await withSummaryIndexUpdateLock(target, async () => {
+                await fsp.mkdir(path.dirname(target), { recursive: true });
+                const preAppendIndex = await readPreAppendSummaryIndex(target);
+                await fsp.appendFile(target, `${JSON.stringify(entry)}\n`, "utf8");
+                await updateSummaryIndexAfterAppend(target, this.paths, [entry], preAppendIndex);
+            });
         }));
         return [entry];
     }
+    async appendCorrection(input) {
+        const { scope, evidence_id, ...correctionInput } = input;
+        const correction = MemoryCorrectionEntrySchema.parse(correctionInput);
+        await this.append({
+            id: evidence_id ?? correction.correction_id,
+            occurred_at: correction.created_at,
+            kind: "correction",
+            scope,
+            correction,
+            summary: correction.reason,
+            raw_refs: [{
+                    kind: correction.target_ref.kind,
+                    id: correction.target_ref.id,
+                }],
+        });
+        return correction;
+    }
     async readByGoal(goalId) {
         return readEvidenceFile(this.paths.evidenceGoalPath(goalId));
     }
@@ -520,7 +116,57 @@ async function rebuildSummaryIndex(canonicalPath, paths) {
     const read = await readEvidenceFile(canonicalPath);
     const manifests = await readReproducibilityManifests(paths, scope);
     const summary = summarizeEvidence(scope, read, manifests);
-    await writeSummaryIndex(canonicalPath, summary);
+    const activeRead = manifests.length === 0 ? activeEvidenceRead(read) : null;
+    await writeSummaryIndex(canonicalPath, summary, activeRead
+        ? {
+            warnings: read.warnings,
+            primaryMetric: resolvePrimaryMetricKey([...activeRead.entries].reverse()) ?? undefined,
+            metricObservationState: buildMetricObservationState(activeRead.entries),
+        }
+        : undefined);
+    return summary;
+}
+async function withSummaryIndexUpdateLock(canonicalPath, action) {
+    const previous = summaryIndexUpdateLocks.get(canonicalPath) ?? Promise.resolve();
+    let release = () => undefined;
+    const current = new Promise((resolve) => {
+        release = resolve;
+    });
+    const next = previous.then(() => current, () => current);
+    summaryIndexUpdateLocks.set(canonicalPath, next);
+    await previous;
+    try {
+        return await action();
+    }
+    finally {
+        release();
+        if (summaryIndexUpdateLocks.get(canonicalPath) === next) {
+            summaryIndexUpdateLocks.delete(canonicalPath);
+        }
+    }
+}
+async function updateSummaryIndexAfterAppend(canonicalPath, paths, appendedEntries, preAppendIndex) {
+    const scope = summaryScopeFromPath(canonicalPath);
+    const manifests = await readReproducibilityManifests(paths, scope);
+    if (manifests.length > 0) {
+        return rebuildSummaryIndex(canonicalPath, paths);
+    }
+    if (!preAppendIndex) {
+        return rebuildSummaryIndex(canonicalPath, paths);
+    }
+    const warnings = readWarningsFromSummaryIndex(preAppendIndex);
+    if (!warnings)
+        return rebuildSummaryIndex(canonicalPath, paths);
+    const metricState = readMetricObservationStateFromSummaryIndex(preAppendIndex);
+    const primaryMetric = preAppendIndex.append_state?.primary_metric;
+    const summary = updateSummaryFromAppend(scope, preAppendIndex.summary, appendedEntries, warnings, metricState, primaryMetric);
+    if (!summary)
+        return rebuildSummaryIndex(canonicalPath, paths);
+    await writeSummaryIndex(canonicalPath, summary, {
+        warnings,
+        primaryMetric,
+        metricObservationState: updateMetricObservationState(metricState, appendedEntries),
+    });
     return summary;
 }
 function summaryIndexPath(canonicalPath) {
@@ -570,6 +216,41 @@ function isManifestArtifactRef(value) {
         && typeof value.label === "string";
 }
 async function readSummaryIndex(canonicalPath, expectedScope) {
+    return readSummaryIndexWithStat(canonicalPath, expectedScope);
+}
+async function readPreAppendSummaryIndex(canonicalPath) {
+    try {
+        const stat = await fsp.stat(canonicalPath);
+        if (stat.size === 0)
+            return emptySummaryIndex(canonicalPath);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return emptySummaryIndex(canonicalPath);
+        throw err;
+    }
+    const scope = summaryScopeFromPath(canonicalPath);
+    return readSummaryIndexWithStat(canonicalPath, scope);
+}
+async function emptySummaryIndex(canonicalPath) {
+    const scope = summaryScopeFromPath(canonicalPath);
+    const summary = summarizeEvidence(scope, { entries: [], warnings: [] });
+    return {
+        schema_version: "runtime-evidence-summary-index-v1",
+        generated_at: new Date().toISOString(),
+        canonical_log_path: canonicalPath,
+        canonical_log_size: 0,
+        canonical_log_mtime_ms: 0,
+        summary,
+        append_state: {
+            schema_version: "runtime-evidence-summary-append-state-v1",
+            warnings: [],
+            primary_metric: undefined,
+            metric_observations: [],
+        },
+    };
+}
+async function readSummaryIndexWithStat(canonicalPath, expectedScope) {
     let text;
     try {
         text = await fsp.readFile(summaryIndexPath(canonicalPath), "utf8");
@@ -602,8 +283,78 @@ async function readSummaryIndex(canonicalPath, expectedScope) {
         return null;
     }
 }
+function readCheckpointFromSummaryIndex(index) {
+    const checkpoint = index.checkpoint;
+    if (!checkpoint || checkpoint.schema_version !== "runtime-evidence-summary-checkpoint-v1")
+        return null;
+    if (!Array.isArray(checkpoint.entries) || !Array.isArray(checkpoint.warnings))
+        return null;
+    const entries = [];
+    for (const entry of checkpoint.entries) {
+        const parsed = RuntimeEvidenceEntrySchema.safeParse(entry);
+        if (!parsed.success)
+            return null;
+        entries.push(parsed.data);
+    }
+    const warnings = [];
+    for (const warning of checkpoint.warnings) {
+        if (typeof warning !== "object"
+            || warning === null
+            || typeof warning.file !== "string"
+            || typeof warning.line !== "number"
+            || typeof warning.message !== "string") {
+            return null;
+        }
+        warnings.push(warning);
+    }
+    return { entries, warnings };
+}
+function readWarningsFromSummaryIndex(index) {
+    if (index.append_state?.schema_version === "runtime-evidence-summary-append-state-v1") {
+        return validateRuntimeEvidenceWarnings(index.append_state.warnings);
+    }
+    return readCheckpointFromSummaryIndex(index)?.warnings ?? null;
+}
+function readMetricObservationStateFromSummaryIndex(index) {
+    const state = index.append_state?.metric_observations;
+    if (!state)
+        return null;
+    if (!Array.isArray(state))
+        return null;
+    for (const group of state) {
+        if (typeof group !== "object"
+            || group === null
+            || typeof group.metric_key !== "string"
+            || (group.direction !== "maximize" && group.direction !== "minimize")
+            || typeof group.count !== "number"
+            || !Array.isArray(group.recent)) {
+            return null;
+        }
+    }
+    return state;
+}
+function validateRuntimeEvidenceWarnings(value) {
+    if (!Array.isArray(value))
+        return null;
+    const warnings = [];
+    for (const warning of value) {
+        if (typeof warning !== "object"
+            || warning === null
+            || typeof warning.file !== "string"
+            || typeof warning.line !== "number"
+            || typeof warning.message !== "string") {
+            return null;
+        }
+        warnings.push(warning);
+    }
+    return warnings;
+}
 function isCurrentEvidenceSummaryShape(summary) {
-    return Array.isArray(summary.candidate_lineages)
+    return summary.context_policy_version === "quarantine-filtered-planning-context-v2"
+        && Array.isArray(summary.candidate_lineages)
+        && Array.isArray(summary.corrections)
+        && typeof summary.correction_state === "object"
+        && summary.correction_state !== null
         && Array.isArray(summary.recommended_candidate_portfolio)
         && Array.isArray(summary.near_miss_candidates)
         && typeof summary.artifact_retention === "object"
@@ -613,8 +364,316 @@ function isCurrentEvidenceSummaryShape(summary) {
         && typeof summary.candidate_selection_summary === "object"
         && summary.candidate_selection_summary !== null;
 }
-async function writeSummaryIndex(canonicalPath, summary) {
+function updateSummaryFromAppend(scope, previous, appendedEntries, warnings, metricState, primaryMetric) {
+    if (appendedEntries.length === 0) {
+        return {
+            ...previous,
+            generated_at: new Date().toISOString(),
+            warnings,
+        };
+    }
+    if (!canIncrementSummaryWithEntries(appendedEntries))
+        return null;
+    if (previous.total_entries > 0 && !primaryMetric)
+        return null;
+    if (!canPreservePrimaryMetric(appendedEntries, primaryMetric))
+        return null;
+    const combinedRecent = [...appendedEntries, ...previous.recent_entries]
+        .sort((a, b) => b.occurred_at.localeCompare(a.occurred_at));
+    const recentEntries = dedupeEvidenceEntriesById(combinedRecent).slice(0, 10);
+    const recentFailedAttempts = dedupeEvidenceEntriesById([
+        ...appendedEntries.filter(isFailedEvidenceEntry),
+        ...previous.recent_failed_attempts,
+    ].sort((a, b) => b.occurred_at.localeCompare(a.occurred_at))).slice(0, 5);
+    const latestStrategyCandidates = appendedEntries.filter((entry) => entry.kind === "strategy" || Boolean(entry.strategy) || Boolean(entry.decision_reason));
+    const latestStrategy = [...latestStrategyCandidates, previous.latest_strategy].filter((entry) => Boolean(entry))
+        .sort((a, b) => b.occurred_at.localeCompare(a.occurred_at))[0] ?? null;
+    const bestEvidence = updateBestEvidenceFromAppend(previous.best_evidence, appendedEntries, primaryMetric);
+    if (bestEvidence === undefined)
+        return null;
+    if (!metricState)
+        return null;
+    const metricTrends = summarizeMetricState(updateMetricObservationState(metricState, appendedEntries));
+    return {
+        ...previous,
+        generated_at: new Date().toISOString(),
+        scope,
+        total_entries: previous.total_entries + appendedEntries.length,
+        latest_strategy: latestStrategy,
+        best_evidence: bestEvidence,
+        metric_trends: metricTrends.length > 0 ? metricTrends : previous.metric_trends,
+        recent_failed_attempts: recentFailedAttempts,
+        recent_entries: recentEntries,
+        warnings,
+    };
+}
+function activeEvidenceRead(read) {
+    const entries = [...read.entries].sort((a, b) => a.occurred_at.localeCompare(b.occurred_at));
+    const corrections = entries.flatMap((entry) => entry.correction ? [entry.correction] : []);
+    const correctionState = summarizeMemoryCorrectionState(corrections);
+    return {
+        entries: entries.filter((entry) => isRuntimeEvidenceEntryActive(entry, correctionState)),
+        warnings: read.warnings,
+    };
+}
+function updateBestEvidenceFromAppend(previousBest, appendedEntries, primaryMetric) {
+    if (!primaryMetric) {
+        return chooseBestEvidence(dedupeEvidenceEntriesById([
+            ...appendedEntries,
+            ...(previousBest ? [previousBest] : []),
+        ].sort((a, b) => b.occurred_at.localeCompare(a.occurred_at))));
+    }
+    let best = previousBest;
+    for (const entry of appendedEntries) {
+        const metric = findComparableMetric([entry], primaryMetric);
+        if (!metric)
+            continue;
+        if (!best) {
+            best = entry;
+            continue;
+        }
+        const current = chooseBestEvidence([entry, best].sort((a, b) => b.occurred_at.localeCompare(a.occurred_at)));
+        if (!current)
+            return undefined;
+        best = current;
+    }
+    return best;
+}
+function canPreservePrimaryMetric(appendedEntries, primaryMetric) {
+    if (!primaryMetric)
+        return appendedEntries.every((entry) => entry.metrics.length === 0);
+    return appendedEntries.every((entry) => entry.metrics.every((metric) => metric.direction === undefined
+        || metric.direction === "neutral"
+        || (metric.label === primaryMetric.label && metric.direction === primaryMetric.direction))
+        && (!entry.task?.primary_dimension || entry.task.primary_dimension === primaryMetric.label));
+}
+function buildMetricObservationState(entries) {
+    return updateMetricObservationState([], entries);
+}
+function updateMetricObservationState(previous, appendedEntries) {
+    const groups = new Map();
+    for (const group of previous ?? []) {
+        groups.set(`${group.metric_key}\0${group.direction}`, {
+            ...group,
+            recent: [...group.recent],
+        });
+    }
+    for (const observation of extractMetricObservationsFromEvidence(appendedEntries).sort((a, b) => a.observed_at.localeCompare(b.observed_at))) {
+        const key = `${observation.metric_key}\0${observation.direction}`;
+        const next = updateMetricState(groups.get(key), observation);
+        groups.set(key, next);
+    }
+    return [...groups.values()];
+}
+function updateMetricState(previous, observation) {
+    const normalized = observation.direction === "maximize" ? observation.value : -observation.value;
+    if (!previous) {
+        return {
+            metric_key: observation.metric_key,
+            direction: observation.direction,
+            count: 1,
+            confidence_sum: observation.confidence,
+            first_value: observation.value,
+            first_normalized: normalized,
+            first_observed_at: observation.observed_at,
+            latest_value: observation.value,
+            latest_normalized: normalized,
+            latest_observed_at: observation.observed_at,
+            best_value: observation.value,
+            best_normalized: normalized,
+            best_observed_at: observation.observed_at,
+            previous_best_normalized: normalized,
+            last_meaningful_improvement_delta: null,
+            last_meaningful_improvement_observed_at: null,
+            last_meaningful_improvement_index: null,
+            last_breakthrough_delta: null,
+            post_improvement_min_normalized: normalized,
+            post_improvement_max_normalized: normalized,
+            recent: [{ value: observation.value, normalized, observed_at: observation.observed_at, source: observation.source }],
+        };
+    }
+    const improvementThreshold = 0.01;
+    const breakthroughThreshold = 0.05;
+    const delta = normalized - previous.latest_normalized;
+    const meaningful = delta >= improvementThreshold;
+    const breakthrough = delta >= breakthroughThreshold;
+    const count = previous.count + 1;
+    const bestImproved = normalized > previous.best_normalized;
+    const postMin = meaningful ? normalized : Math.min(previous.post_improvement_min_normalized, normalized);
+    const postMax = meaningful ? normalized : Math.max(previous.post_improvement_max_normalized, normalized);
+    return {
+        ...previous,
+        count,
+        confidence_sum: previous.confidence_sum + observation.confidence,
+        latest_value: observation.value,
+        latest_normalized: normalized,
+        latest_observed_at: observation.observed_at,
+        best_value: bestImproved ? observation.value : previous.best_value,
+        best_normalized: bestImproved ? normalized : previous.best_normalized,
+        best_observed_at: bestImproved ? observation.observed_at : previous.best_observed_at,
+        previous_best_normalized: previous.best_normalized,
+        last_meaningful_improvement_delta: meaningful ? delta : previous.last_meaningful_improvement_delta,
+        last_meaningful_improvement_observed_at: meaningful
+            ? observation.observed_at
+            : previous.last_meaningful_improvement_observed_at,
+        last_meaningful_improvement_index: meaningful ? count - 1 : previous.last_meaningful_improvement_index,
+        last_breakthrough_delta: breakthrough ? delta : previous.last_breakthrough_delta,
+        post_improvement_min_normalized: postMin,
+        post_improvement_max_normalized: postMax,
+        recent: [
+            ...previous.recent,
+            { value: observation.value, normalized, observed_at: observation.observed_at, source: observation.source },
+        ].slice(-5),
+    };
+}
+function summarizeMetricState(states) {
+    return states.map(metricTrendFromState);
+}
+function metricTrendFromState(state) {
+    const improvementThreshold = 0.01;
+    const breakthroughThreshold = 0.05;
+    const noiseBand = 0.005;
+    const recentValues = state.recent.map((entry) => entry.normalized);
+    const recentSlope = linearSlope(recentValues);
+    const minRecent = Math.min(...recentValues);
+    const maxRecent = Math.max(...recentValues);
+    const recentRange = maxRecent - minRecent;
+    const latestBestDelta = state.latest_normalized - state.previous_best_normalized;
+    const latestDeltaFromBest = state.latest_normalized - state.best_normalized;
+    const latestDeltaFromFirst = state.latest_normalized - state.first_normalized;
+    const bestDelta = state.best_normalized - state.first_normalized;
+    const postImprovementRange = state.post_improvement_max_normalized - state.post_improvement_min_normalized;
+    const observationsSinceLastMeaningfulImprovement = state.last_meaningful_improvement_index === null
+        ? null
+        : (state.count - 1) - state.last_meaningful_improvement_index;
+    const trend = classifyCompactMetricTrend({
+        count: state.count,
+        latestBestDelta,
+        latestDeltaFromBest,
+        latestDeltaFromFirst,
+        bestDelta,
+        recentSlope,
+        recentRange,
+        postImprovementRange,
+        observationsSinceLastMeaningfulImprovement,
+        improvementThreshold,
+        breakthroughThreshold,
+        noiseBand,
+    });
+    const meanConfidence = state.confidence_sum / state.count;
+    const sampleConfidence = Math.min(1, state.count / 5);
+    const trendConfidence = trend === "noisy"
+        ? Math.max(0.35, Math.min(0.75, noiseBand / Math.max(recentRange, Number.EPSILON)))
+        : 1;
+    const confidence = clamp01(meanConfidence * sampleConfidence * trendConfidence);
+    return {
+        metric_key: state.metric_key,
+        direction: state.direction,
+        trend,
+        latest_value: state.latest_value,
+        latest_observed_at: state.latest_observed_at,
+        best_value: state.best_value,
+        best_observed_at: state.best_observed_at,
+        observation_count: state.count,
+        recent_slope_per_observation: denormalizeMetricDelta(recentSlope, state.direction),
+        best_delta: denormalizeMetricDelta(bestDelta, state.direction),
+        last_meaningful_improvement_delta: state.last_meaningful_improvement_delta === null
+            ? null
+            : denormalizeMetricDelta(state.last_meaningful_improvement_delta, state.direction),
+        last_breakthrough_delta: state.last_breakthrough_delta === null
+            ? null
+            : denormalizeMetricDelta(state.last_breakthrough_delta, state.direction),
+        time_since_last_meaningful_improvement_ms: state.last_meaningful_improvement_observed_at
+            ? Math.max(0, Date.now() - Date.parse(state.last_meaningful_improvement_observed_at))
+            : null,
+        improvement_threshold: denormalizeMetricDelta(improvementThreshold, state.direction),
+        breakthrough_threshold: denormalizeMetricDelta(breakthroughThreshold, state.direction),
+        noise_band: denormalizeMetricDelta(noiseBand, state.direction),
+        confidence,
+        source_refs: state.recent.map((entry) => entry.source),
+        summary: `${state.metric_key} trend is ${trend} from ${state.count} observation(s); latest=${state.latest_value}, best=${state.best_value}`,
+    };
+}
+function classifyCompactMetricTrend(input) {
+    if (input.count < 2)
+        return "noisy";
+    if (input.latestBestDelta >= input.breakthroughThreshold)
+        return "breakthrough";
+    if (input.latestBestDelta >= input.improvementThreshold)
+        return "improving";
+    if (input.latestDeltaFromBest <= -input.improvementThreshold)
+        return "regressing";
+    if (input.observationsSinceLastMeaningfulImprovement !== null
+        && input.observationsSinceLastMeaningfulImprovement >= 2
+        && input.postImprovementRange <= input.noiseBand) {
+        return "stalled";
+    }
+    if (input.latestDeltaFromFirst <= -input.improvementThreshold || input.recentSlope <= -input.improvementThreshold) {
+        return "regressing";
+    }
+    if (input.recentSlope >= input.improvementThreshold)
+        return "improving";
+    if (input.recentRange === 0 || input.recentRange <= Number.EPSILON)
+        return "stalled";
+    if (input.recentRange <= input.noiseBand || Math.abs(input.recentSlope) < input.noiseBand) {
+        return input.bestDelta >= input.improvementThreshold ? "stalled" : "noisy";
+    }
+    if (input.bestDelta < input.improvementThreshold)
+        return "stalled";
+    return "noisy";
+}
+function linearSlope(values) {
+    if (values.length < 2)
+        return 0;
+    const n = values.length;
+    const meanX = (n - 1) / 2;
+    const meanY = values.reduce((sum, value) => sum + value, 0) / n;
+    let numerator = 0;
+    let denominator = 0;
+    for (let index = 0; index < n; index += 1) {
+        const dx = index - meanX;
+        numerator += dx * (values[index] - meanY);
+        denominator += dx * dx;
+    }
+    return denominator === 0 ? 0 : numerator / denominator;
+}
+function denormalizeMetricDelta(delta, direction) {
+    return direction === "maximize" ? delta : -delta;
+}
+function canIncrementSummaryWithEntries(entries) {
+    return entries.every((entry) => entry.kind !== "correction"
+        && entry.kind !== "failure"
+        && entry.outcome !== "failed"
+        && entry.outcome !== "regressed"
+        && entry.result?.status !== "failed"
+        && entry.verification?.verdict !== "fail"
+        && !entry.correction
+        && !entry.correction_state
+        && !entry.evaluators?.length
+        && !entry.research?.length
+        && !entry.dream_checkpoints?.length
+        && !entry.divergent_exploration?.length
+        && !entry.candidates?.length
+        && !entry.artifacts.length
+        && !entry.quarantine_state
+        && entry.verification_status !== "suspicious"
+        && entry.verification_status !== "contradicted"
+        && !isSuspiciousProvenance(entry.provenance));
+}
+function dedupeEvidenceEntriesById(entries) {
+    const seen = new Set();
+    const unique = [];
+    for (const entry of entries) {
+        if (seen.has(entry.id))
+            continue;
+        seen.add(entry.id);
+        unique.push(entry);
+    }
+    return unique;
+}
+async function writeSummaryIndex(canonicalPath, summary, checkpointRead) {
     const stat = await fsp.stat(canonicalPath);
+    const warnings = checkpointRead ? checkpointRead.warnings : [];
     const index = {
         schema_version: "runtime-evidence-summary-index-v1",
         generated_at: new Date().toISOString(),
@@ -622,6 +681,25 @@ async function writeSummaryIndex(canonicalPath, summary) {
         canonical_log_size: stat.size,
         canonical_log_mtime_ms: stat.mtimeMs,
         summary,
+        append_state: {
+            schema_version: "runtime-evidence-summary-append-state-v1",
+            warnings,
+            ...(checkpointRead && "primaryMetric" in checkpointRead && checkpointRead.primaryMetric
+                ? { primary_metric: checkpointRead.primaryMetric }
+                : {}),
+            metric_observations: checkpointRead && "metricObservationState" in checkpointRead
+                ? checkpointRead.metricObservationState
+                : buildMetricObservationState(summary.recent_entries),
+        },
+        ...(checkpointRead && "entries" in checkpointRead
+            ? {
+                checkpoint: {
+                    schema_version: "runtime-evidence-summary-checkpoint-v1",
+                    entries: checkpointRead.entries,
+                    warnings,
+                },
+            }
+            : {}),
     };
     await fsp.mkdir(path.dirname(canonicalPath), { recursive: true });
     await fsp.writeFile(summaryIndexPath(canonicalPath), `${JSON.stringify(index)}\n`, "utf8");
@@ -669,28 +747,35 @@ async function readEvidenceFile(filePath) {
 }
 function summarizeEvidence(scope, read, manifests = []) {
     const entries = [...read.entries].sort((a, b) => a.occurred_at.localeCompare(b.occurred_at));
-    const newestFirst = [...entries].reverse();
-    const evaluatorSummary = summarizeEvidenceEvaluatorResults(entries);
+    const corrections = entries.flatMap((entry) => entry.correction ? [entry.correction] : []);
+    const correctionState = summarizeMemoryCorrectionState(corrections);
+    const activeEntries = entries.filter((entry) => isRuntimeEvidenceEntryActive(entry, correctionState));
+    const newestFirst = [...activeEntries].reverse();
+    const evaluatorSummary = summarizeEvidenceEvaluatorResults(activeEntries);
+    const activeDreamCheckpoints = filterRetractedDreamCheckpointMemories(summarizeEvidenceDreamCheckpoints(activeEntries), correctionState, scope);
     return {
         schema_version: "runtime-evidence-summary-v1",
+        context_policy_version: "quarantine-filtered-planning-context-v2",
         generated_at: new Date().toISOString(),
         scope,
         total_entries: entries.length,
         latest_strategy: newestFirst.find((entry) => entry.kind === "strategy" || Boolean(entry.strategy) || Boolean(entry.decision_reason)) ?? null,
         best_evidence: chooseBestEvidence(newestFirst),
-        metric_trends: summarizeEvidenceMetricTrends(entries),
+        metric_trends: summarizeEvidenceMetricTrends(activeEntries),
         evaluator_summary: evaluatorSummary,
-        research_memos: summarizeEvidenceResearchMemos(entries),
-        dream_checkpoints: summarizeEvidenceDreamCheckpoints(entries),
-        divergent_exploration: entries
+        research_memos: summarizeEvidenceResearchMemos(activeEntries),
+        dream_checkpoints: activeDreamCheckpoints,
+        divergent_exploration: activeEntries
             .flatMap((entry) => entry.divergent_exploration ?? [])
             .slice(-10)
             .reverse(),
-        candidate_lineages: summarizeCandidateLineages(entries),
-        recommended_candidate_portfolio: selectDiversifiedCandidatePortfolio(entries),
-        candidate_selection_summary: summarizeCandidateSelection(entries, evaluatorSummary),
-        near_miss_candidates: summarizeNearMissCandidates(entries),
-        artifact_retention: summarizeArtifactRetention(entries, { manifests }),
+        corrections,
+        correction_state: correctionState,
+        candidate_lineages: summarizeCandidateLineages(activeEntries),
+        recommended_candidate_portfolio: selectDiversifiedCandidatePortfolio(activeEntries),
+        candidate_selection_summary: summarizeCandidateSelection(activeEntries, evaluatorSummary),
+        near_miss_candidates: summarizeNearMissCandidates(activeEntries),
+        artifact_retention: summarizeArtifactRetention(activeEntries, { manifests }),
         recent_failed_attempts: newestFirst
             .filter((entry) => entry.outcome === "failed"
             || entry.outcome === "regressed"
@@ -698,11 +783,105 @@ function summarizeEvidence(scope, read, manifests = []) {
             || entry.result?.status === "failed"
             || entry.verification?.verdict === "fail")
             .slice(0, 5),
-        failed_lineages: summarizeFailedLineages(entries),
+        failed_lineages: summarizeFailedLineages(activeEntries),
         recent_entries: newestFirst.slice(0, 10),
         warnings: read.warnings,
     };
 }
+function isRuntimeEvidenceEntryActive(entry, correctionState) {
+    if (entry.kind === "correction")
+        return false;
+    if (entry.quarantine_state?.status === "quarantined")
+        return false;
+    if (entry.verification_status === "suspicious" || entry.verification_status === "contradicted")
+        return false;
+    if (isSuspiciousProvenance(entry.provenance))
+        return false;
+    return runtimeEvidenceCorrectionRefs(entry).every((ref) => correctionStateForTarget(correctionState, ref).active);
+}
+function runtimeEvidenceCorrectionRefs(entry) {
+    const refs = [
+        { kind: "runtime_evidence", id: entry.id },
+    ];
+    if (entry.scope.run_id) {
+        refs.push({ kind: "runtime_evidence", id: entry.id, scope: { run_id: entry.scope.run_id } });
+    }
+    if (entry.scope.goal_id) {
+        refs.push({ kind: "runtime_evidence", id: entry.id, scope: { goal_id: entry.scope.goal_id } });
+    }
+    if (entry.scope.goal_id || entry.scope.run_id || entry.scope.task_id) {
+        refs.push({
+            kind: "runtime_evidence",
+            id: entry.id,
+            scope: {
+                ...(entry.scope.goal_id ? { goal_id: entry.scope.goal_id } : {}),
+                ...(entry.scope.run_id ? { run_id: entry.scope.run_id } : {}),
+                ...(entry.scope.task_id ? { task_id: entry.scope.task_id } : {}),
+            },
+        });
+    }
+    return refs;
+}
+function filterRetractedDreamCheckpointMemories(checkpoints, correctionState, scope) {
+    return checkpoints
+        .map((checkpoint) => {
+        const relevant_memories = checkpoint.relevant_memories.filter((memory) => isDreamCheckpointMemoryRefAdmissible(memory)
+            && (!memory.ref || dreamMemoryCorrectionRefs(memory.ref, checkpoint, scope).every((ref) => correctionStateForTarget(correctionState, ref).active)));
+        return {
+            checkpoint,
+            relevant_memories,
+            planning_context_status: relevant_memories.length === checkpoint.relevant_memories.length
+                ? "active"
+                : "partially_retracted",
+        };
+    })
+        .filter(({ checkpoint, relevant_memories }) => checkpoint.relevant_memories.length === 0 || relevant_memories.length > 0)
+        .map(({ checkpoint, relevant_memories, planning_context_status }) => ({
+        ...checkpoint,
+        relevant_memories,
+        planning_context_status,
+    }));
+}
+function isDreamCheckpointMemoryRefAdmissible(memory) {
+    if (memory.quarantine_state?.status === "quarantined")
+        return false;
+    if (memory.verification_status === "suspicious" || memory.verification_status === "contradicted")
+        return false;
+    if (isSuspiciousProvenance(memory.provenance))
+        return false;
+    if (memory.provenance
+        && (memory.provenance.source_type === "web" || memory.provenance.source_type === "external")
+        && memory.provenance.reliability !== undefined
+        && memory.provenance.reliability < 0.5) {
+        return false;
+    }
+    return true;
+}
+function isSuspiciousProvenance(provenance) {
+    if (!provenance)
+        return false;
+    if (provenance.verification_status === "suspicious" || provenance.verification_status === "contradicted") {
+        return true;
+    }
+    const riskSignals = new Set(provenance.risk_signals);
+    return riskSignals.has("hallucinated")
+        || riskSignals.has("low_provenance")
+        || riskSignals.has("contradiction")
+        || riskSignals.has("prompt_injection_like")
+        || riskSignals.has("unverified_external");
+}
+function dreamMemoryCorrectionRefs(ref, checkpoint, scope) {
+    const refs = [{ kind: "dream_checkpoint", id: ref }];
+    if (checkpoint.run_id)
+        refs.push({ kind: "dream_checkpoint", id: ref, scope: { run_id: checkpoint.run_id } });
+    if (checkpoint.goal_id)
+        refs.push({ kind: "dream_checkpoint", id: ref, scope: { goal_id: checkpoint.goal_id } });
+    if (scope.run_id)
+        refs.push({ kind: "dream_checkpoint", id: ref, scope: { run_id: scope.run_id } });
+    if (scope.goal_id)
+        refs.push({ kind: "dream_checkpoint", id: ref, scope: { goal_id: scope.goal_id } });
+    return refs;
+}
 export function selectDiversifiedCandidatePortfolio(entriesOldestFirst, options = {}) {
     const limit = options.limit ?? 3;
     if (limit <= 0)
@@ -775,7 +954,7 @@ function scoreCandidateSelectionContexts(rawRanked, calibration = []) {
         const diversityScore = clamp01(candidate.robustness?.diversity_score === undefined
             ? inferredDiversity
             : Math.min(candidate.robustness.diversity_score, inferredDiversity));
-        const riskPenalty = clamp01(candidate.robustness?.risk_penalty ?? inferredCandidateRiskPenalty(candidate));
+        const riskPenalty = clamp01(candidate.robustness?.risk_penalty ?? 0);
         const evidenceConfidence = clamp01(candidate.robustness?.evidence_confidence ?? context.metric?.confidence ?? 0.5);
         const calibrationAdjustment = evaluatorCalibrationAdjustment(candidate.candidate_id, calibration);
         const robustScore = clamp01(candidate.robustness?.robust_score
@@ -848,19 +1027,6 @@ function highestKnownSimilarity(candidate, allCandidates) {
     }
     return highest;
 }
-function inferredCandidateRiskPenalty(candidate) {
-    const lineageText = [
-        ...candidate.lineage.config_lineage,
-        ...candidate.lineage.postprocess_lineage,
-    ].map(normalizeLineageText).join(" ");
-    if (lineageText.includes("manual") || lineageText.includes("threshold") || lineageText.includes("postprocess")) {
-        return 0.15;
-    }
-    if (lineageText.includes("calibration") || lineageText.includes("weight")) {
-        return 0.08;
-    }
-    return 0;
-}
 function candidateSelectionReasons(candidate, scores) {
     const reasons = [];
     if (scores.stabilityScore >= 0.8)
@@ -939,6 +1105,8 @@ function summarizeNearMissCandidates(entriesOldestFirst) {
 }
 function nearMissReasonsForCandidate(context, rawBest, scored) {
     const explicit = context.candidate.near_miss?.reason_to_keep ?? [];
+    if (explicit.length > 0)
+        return [...explicit];
     const reasons = new Set(explicit);
     if (context.candidate.near_miss?.status === "retained" || context.candidate.near_miss?.status === "promoted") {
         for (const reason of inferredNearMissReasons(context, rawBest, scored))
@@ -971,14 +1139,6 @@ function inferredNearMissReasons(context, rawBest, scored) {
     if (complementaryCandidateIds(context.candidate).length > 0 || highestKnownSimilarity(context.candidate, [context.candidate, rawBest.candidate]) <= 0.5) {
         reasons.push("complementarity");
     }
-    const lineageText = [
-        ...context.candidate.lineage.model_lineage,
-        ...context.candidate.lineage.config_lineage,
-        ...(context.candidate.near_miss?.summary ? [context.candidate.near_miss.summary] : []),
-    ].map(normalizeLineageText).join(" ");
-    if (lineageText.includes("stack") || lineageText.includes("ensemble") || lineageText.includes("blend")) {
-        reasons.push("ensemble_potential");
-    }
     return reasons;
 }
 function isImplicitNearMiss(context, rawBest, scored) {
@@ -1136,25 +1296,12 @@ function resolvePrimaryCandidateMetricKey(entriesOldestFirst) {
         const coverageDelta = b.candidate_count - a.candidate_count;
         if (coverageDelta !== 0)
             return coverageDelta;
-        const localityDelta = Number(isLocalValidationMetricLabel(b.key.label)) - Number(isLocalValidationMetricLabel(a.key.label));
-        if (localityDelta !== 0)
-            return localityDelta;
         const positionDelta = a.position_sum / a.candidate_count - b.position_sum / b.candidate_count;
         if (positionDelta !== 0)
             return positionDelta;
         return b.latest_index - a.latest_index;
     })[0]?.key ?? null;
 }
-function isLocalValidationMetricLabel(label) {
-    const normalized = normalizeLineageText(label);
-    const externalHints = ["public", "private", "leaderboard", "external", "lb", "submission"];
-    for (const hint of externalHints) {
-        if (normalized === hint || normalized.includes(hint)) {
-            return false;
-        }
-    }
-    return true;
-}
 function candidateComparableMetric(candidate, primaryMetric) {
     for (const metric of candidate.metrics) {
         if (primaryMetric && (metric.label !== primaryMetric.label || metric.direction !== primaryMetric.direction))
@@ -1392,13 +1539,52 @@ function chooseBestMetricEvidence(entriesNewestFirst) {
     return candidates.sort(compareComparableEvidenceMetrics)[0]?.entry ?? null;
 }
 function resolvePrimaryMetricKey(entriesNewestFirst) {
-    for (const entry of entriesNewestFirst) {
-        const metric = findFirstDirectedNumericMetric(entry);
-        if (metric?.direction === "maximize" || metric?.direction === "minimize") {
-            return { label: metric.label, direction: metric.direction };
-        }
-    }
-    return null;
+    const oldestFirst = [...entriesNewestFirst].reverse();
+    const byMetric = new Map();
+    oldestFirst.forEach((entry, entryIndex) => {
+        const seenForEntry = new Set();
+        entry.metrics.forEach((metric, metricIndex) => {
+            const comparable = toComparableMetric(metric);
+            if (!comparable)
+                return;
+            const key = { label: metric.label, direction: comparable.direction };
+            const mapKey = `${key.label}:${key.direction}`;
+            if (seenForEntry.has(mapKey))
+                return;
+            seenForEntry.add(mapKey);
+            const existing = byMetric.get(mapKey);
+            const explicitPrimary = entry.task?.primary_dimension === metric.label ? 1 : 0;
+            if (!existing) {
+                byMetric.set(mapKey, {
+                    key,
+                    entry_count: 1,
+                    explicit_primary_count: explicitPrimary,
+                    position_sum: metricIndex,
+                    latest_index: entryIndex,
+                });
+                return;
+            }
+            existing.entry_count += 1;
+            existing.explicit_primary_count += explicitPrimary;
+            existing.position_sum += metricIndex;
+            existing.latest_index = entryIndex;
+        });
+    });
+    // Primary evidence metric inference is intentionally structural: exact
+    // task.primary_dimension matches win, then broadest repeated metric coverage,
+    // then stable first-position metric ordering, then recency as the final tie.
+    return [...byMetric.values()].sort((a, b) => {
+        const explicitDelta = b.explicit_primary_count - a.explicit_primary_count;
+        if (explicitDelta !== 0)
+            return explicitDelta;
+        const coverageDelta = b.entry_count - a.entry_count;
+        if (coverageDelta !== 0)
+            return coverageDelta;
+        const positionDelta = a.position_sum / a.entry_count - b.position_sum / b.entry_count;
+        if (positionDelta !== 0)
+            return positionDelta;
+        return b.latest_index - a.latest_index;
+    })[0]?.key ?? null;
 }
 function findComparableMetric(entries, key) {
     for (const entry of entries) {
@@ -1412,13 +1598,6 @@ function findComparableMetric(entries, key) {
     }
     return null;
 }
-function findFirstDirectedNumericMetric(entry) {
-    for (const metric of entry.metrics) {
-        if (toComparableMetric(metric))
-            return metric;
-    }
-    return null;
-}
 function toComparableMetric(metric) {
     if (typeof metric.value !== "number" || !Number.isFinite(metric.value))
         return null;