pulseed 0.6.1 → 0.6.2

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

@@ -1,458 +1,15 @@
 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 { correctionStateForTarget, MemoryCorrectionEntrySchema, MemoryCorrectionTargetStateSchema, summarizeMemoryCorrectionState, } from "../../platform/corrections/memory-correction-ledger.js";
-import { MemoryProvenanceSchema, MemoryQuarantineStateSchema, MemoryVerificationStatusSchema, } from "../../platform/corrections/memory-quarantine.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",
-    "correction",
-    "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 RuntimeEvidenceMemoryUsageStatsSchema = z.object({
-    last_used_at: z.string().datetime().nullable().default(null),
-    use_count: z.number().int().nonnegative().default(0),
-    validated_count: z.number().int().nonnegative().default(0),
-    negative_outcome_count: z.number().int().nonnegative().default(0),
-}).strict();
-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(),
-    verification_status: MemoryVerificationStatusSchema.optional(),
-    provenance: MemoryProvenanceSchema.optional(),
-    quarantine_state: MemoryQuarantineStateSchema.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(),
-    usage_stats: RuntimeEvidenceMemoryUsageStatsSchema.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({
-    candidate_ref: z.string().min(1).optional(),
-    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),
-    candidate_ref: z.string().min(1).optional(),
-    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(),
-    correction: MemoryCorrectionEntrySchema.optional(),
-    correction_state: MemoryCorrectionTargetStateSchema.optional(),
-    verification_status: MemoryVerificationStatusSchema.optional(),
-    provenance: MemoryProvenanceSchema.optional(),
-    quarantine_state: MemoryQuarantineStateSchema.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;
@@ -495,9 +52,9 @@ export class RuntimeEvidenceLedger {
         await Promise.all([...targets].map(async (target) => {
             await withSummaryIndexUpdateLock(target, async () => {
                 await fsp.mkdir(path.dirname(target), { recursive: true });
-                const preAppendCheckpoint = await readPreAppendCheckpoint(target);
+                const preAppendIndex = await readPreAppendSummaryIndex(target);
                 await fsp.appendFile(target, `${JSON.stringify(entry)}\n`, "utf8");
-                await updateSummaryIndexAfterAppend(target, this.paths, [entry], preAppendCheckpoint);
+                await updateSummaryIndexAfterAppend(target, this.paths, [entry], preAppendIndex);
             });
         }));
         return [entry];
@@ -559,7 +116,14 @@ 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, manifests.length === 0 ? read : undefined);
+    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) {
@@ -581,21 +145,28 @@ async function withSummaryIndexUpdateLock(canonicalPath, action) {
         }
     }
 }
-async function updateSummaryIndexAfterAppend(canonicalPath, paths, appendedEntries, preAppendCheckpoint) {
+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 (!preAppendCheckpoint) {
+    if (!preAppendIndex) {
         return rebuildSummaryIndex(canonicalPath, paths);
     }
-    const read = {
-        entries: [...preAppendCheckpoint.entries, ...appendedEntries],
-        warnings: preAppendCheckpoint.warnings,
-    };
-    const summary = summarizeEvidence(scope, read);
-    await writeSummaryIndex(canonicalPath, summary, read);
+    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) {
@@ -647,20 +218,37 @@ function isManifestArtifactRef(value) {
 async function readSummaryIndex(canonicalPath, expectedScope) {
     return readSummaryIndexWithStat(canonicalPath, expectedScope);
 }
-async function readPreAppendCheckpoint(canonicalPath) {
+async function readPreAppendSummaryIndex(canonicalPath) {
     try {
         const stat = await fsp.stat(canonicalPath);
         if (stat.size === 0)
-            return { entries: [], warnings: [] };
+            return emptySummaryIndex(canonicalPath);
     }
     catch (err) {
         if (err.code === "ENOENT")
-            return { entries: [], warnings: [] };
+            return emptySummaryIndex(canonicalPath);
         throw err;
     }
     const scope = summaryScopeFromPath(canonicalPath);
-    const index = await readSummaryIndexWithStat(canonicalPath, scope);
-    return index ? readCheckpointFromSummaryIndex(index) : null;
+    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;
@@ -721,6 +309,46 @@ function readCheckpointFromSummaryIndex(index) {
     }
     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 summary.context_policy_version === "quarantine-filtered-planning-context-v2"
         && Array.isArray(summary.candidate_lineages)
@@ -736,8 +364,316 @@ function isCurrentEvidenceSummaryShape(summary) {
         && typeof summary.candidate_selection_summary === "object"
         && summary.candidate_selection_summary !== null;
 }
+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(),
@@ -745,12 +681,22 @@ async function writeSummaryIndex(canonicalPath, summary, checkpointRead) {
         canonical_log_size: stat.size,
         canonical_log_mtime_ms: stat.mtimeMs,
         summary,
-        ...(checkpointRead
+        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: checkpointRead.warnings,
+                    warnings,
                 },
             }
             : {}),
@@ -1008,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
@@ -1081,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)
@@ -1172,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))
@@ -1204,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) {
@@ -1369,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))