pulseed 0.6.5 → 0.6.6

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

@@ -1,32 +1,59 @@
 import { randomUUID } from "node:crypto";
 import * as fsp from "node:fs/promises";
 import * as path from "node:path";
-import { createRuntimeStorePaths, encodeRuntimePathSegment, ensureRuntimeStorePaths, } from "./runtime-paths.js";
+import { z } from "zod";
+import { createRuntimeStorePaths, encodeRuntimePathSegment, } from "./runtime-paths.js";
+import { RuntimeEvidenceStateStore, } from "./runtime-evidence-state-store.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, } from "./artifact-retention.js";
+const RuntimeEvidenceReproducibilityManifestSchema = z.object({
+    schema_version: z.literal("runtime-reproducibility-manifest-v1"),
+    manifest_id: z.string().min(1),
+    generated_at: z.string().datetime(),
+    updated_at: z.string().datetime(),
+    scope: z.object({
+        goal_id: z.string().min(1).optional(),
+        run_id: z.string().min(1).optional(),
+    }).strict(),
+    finalization_preflight: z.object({
+        manifest_required_before_delivery: z.boolean().default(true),
+        approval_required_before_external_submission: z.boolean().default(true),
+        status: z.enum(["manifest_ready", "manifest_incomplete"]),
+        missing: z.array(z.string().min(1)).default([]),
+    }).strict(),
+    code_state: z.object({
+        commit: z.string().min(1).optional(),
+        dirty: z.boolean().optional(),
+        diff_sha256: z.string().min(1).optional(),
+        source: z.string().min(1).default("provided"),
+    }).strict(),
+    artifacts: z.array(z.unknown()).default([]),
+}).passthrough();
 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";
+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, RuntimeEvidenceScalarValueSchema, } from "./evidence-types.js";
 const summaryIndexUpdateLocks = new Map();
 export class RuntimeEvidenceLedger {
     paths;
+    store;
     constructor(runtimeRootOrPaths) {
         this.paths =
             typeof runtimeRootOrPaths === "string"
                 ? createRuntimeStorePaths(runtimeRootOrPaths)
                 : runtimeRootOrPaths ?? createRuntimeStorePaths();
+        this.store = new RuntimeEvidenceStateStore(this.paths);
     }
     async ensureReady() {
-        await ensureRuntimeStorePaths(this.paths);
+        await this.store.ensureReady();
     }
     goalPath(goalId) {
-        return this.paths.evidenceGoalPath(goalId);
+        return legacyEvidenceScopePath(this.paths.rootDir, "goals", goalId);
     }
     runPath(runId) {
-        return this.paths.evidenceRunPath(runId);
+        return legacyEvidenceScopePath(this.paths.rootDir, "runs", runId);
     }
     async append(input) {
         const entry = RuntimeEvidenceEntrySchema.parse({
@@ -44,17 +71,11 @@ export class RuntimeEvidenceLedger {
             ...input,
         });
         await this.ensureReady();
-        const targets = new Set();
-        if (entry.scope.goal_id)
-            targets.add(this.paths.evidenceGoalPath(entry.scope.goal_id));
-        if (entry.scope.run_id)
-            targets.add(this.paths.evidenceRunPath(entry.scope.run_id));
-        await Promise.all([...targets].map(async (target) => {
-            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);
+        const scopes = scopesForEntry(entry);
+        await this.store.append(entry);
+        await Promise.all(scopes.map(async (scope) => {
+            await withSummaryIndexUpdateLock(summaryIndexKey(scope), async () => {
+                await rebuildSummaryIndexForScope(scope, this.paths, this.store);
             });
         }));
         return [entry];
@@ -77,15 +98,16 @@ export class RuntimeEvidenceLedger {
         return correction;
     }
     async readByGoal(goalId) {
-        return readEvidenceFile(this.paths.evidenceGoalPath(goalId));
+        return this.store.readByGoal(goalId);
     }
     async readByRun(runId) {
-        return readEvidenceFile(this.paths.evidenceRunPath(runId));
+        return this.store.readByRun(runId);
     }
     async summarizeGoal(goalId) {
+        const scope = evidenceGoalScope(goalId);
         const manifests = await readReproducibilityManifests(this.paths, { goal_id: goalId });
         const indexed = manifests.length === 0
-            ? await readSummaryIndex(this.paths.evidenceGoalPath(goalId), { goal_id: goalId })
+            ? await readDbSummaryIndex(scope, this.store)
             : null;
         if (indexed)
             return indexed.summary;
@@ -94,9 +116,10 @@ export class RuntimeEvidenceLedger {
         return summary;
     }
     async summarizeRun(runId) {
+        const scope = evidenceRunScope(runId);
         const manifests = await readReproducibilityManifests(this.paths, { run_id: runId });
         const indexed = manifests.length === 0
-            ? await readSummaryIndex(this.paths.evidenceRunPath(runId), { run_id: runId })
+            ? await readDbSummaryIndex(scope, this.store)
             : null;
         if (indexed)
             return indexed.summary;
@@ -105,27 +128,90 @@ export class RuntimeEvidenceLedger {
         return summary;
     }
     async rebuildSummaryIndexForGoal(goalId) {
-        return rebuildSummaryIndex(this.paths.evidenceGoalPath(goalId), this.paths);
+        return rebuildSummaryIndexForScope(evidenceGoalScope(goalId), this.paths, this.store);
     }
     async rebuildSummaryIndexForRun(runId) {
-        return rebuildSummaryIndex(this.paths.evidenceRunPath(runId), this.paths);
+        return rebuildSummaryIndexForScope(evidenceRunScope(runId), this.paths, this.store);
     }
+    async listExtractionRefs(limit) {
+        return this.store.listExtractionRefs(limit);
+    }
+}
+function legacyEvidenceScopePath(runtimeRoot, scopeDir, scopeId) {
+    return path.join(runtimeRoot, "evidence-ledger", scopeDir, `${encodeRuntimePathSegment(scopeId)}.jsonl`);
+}
+function evidenceGoalScope(goalId) {
+    return { kind: "goal", id: goalId };
+}
+function evidenceRunScope(runId) {
+    return { kind: "run", id: runId };
+}
+function scopesForEntry(entry) {
+    const scopes = [];
+    if (entry.scope.goal_id)
+        scopes.push(evidenceGoalScope(entry.scope.goal_id));
+    if (entry.scope.run_id)
+        scopes.push(evidenceRunScope(entry.scope.run_id));
+    return scopes;
+}
+function scopeToSummaryScope(scope) {
+    return scope.kind === "goal" ? { goal_id: scope.id } : { run_id: scope.id };
+}
+function summaryIndexKey(scope) {
+    return `control-db://runtime-evidence/${scope.kind}/${scope.id}`;
+}
+async function readDbSummaryIndex(scope, store) {
+    const indexed = await store.loadSummaryIndex(scope);
+    if (!indexed)
+        return null;
+    if (indexed.summary.schema_version !== "runtime-evidence-summary-v1")
+        return null;
+    if (!isCurrentEvidenceSummaryShape(indexed.summary))
+        return null;
+    const summaryScope = scopeToSummaryScope(scope);
+    if (summaryScope.goal_id && indexed.summary.scope.goal_id !== summaryScope.goal_id)
+        return null;
+    if (summaryScope.run_id && indexed.summary.scope.run_id !== summaryScope.run_id)
+        return null;
+    return indexed;
 }
-async function rebuildSummaryIndex(canonicalPath, paths) {
-    const scope = summaryScopeFromPath(canonicalPath);
-    const read = await readEvidenceFile(canonicalPath);
-    const manifests = await readReproducibilityManifests(paths, scope);
-    const summary = summarizeEvidence(scope, read, manifests);
+async function rebuildSummaryIndexForScope(scope, paths, store) {
+    const summaryScope = scopeToSummaryScope(scope);
+    const read = scope.kind === "goal" ? await store.readByGoal(scope.id) : await store.readByRun(scope.id);
+    const manifests = await readReproducibilityManifests(paths, summaryScope);
+    const summary = summarizeEvidence(summaryScope, read, manifests);
     const activeRead = manifests.length === 0 ? activeEvidenceRead(read) : null;
-    await writeSummaryIndex(canonicalPath, summary, activeRead
-        ? {
+    if (activeRead) {
+        await writeDbSummaryIndex(scope, summary, store, {
             warnings: read.warnings,
             primaryMetric: resolvePrimaryMetricKey([...activeRead.entries].reverse()) ?? undefined,
             metricObservationState: buildMetricObservationState(activeRead.entries),
-        }
-        : undefined);
+        });
+    }
     return summary;
 }
+async function writeDbSummaryIndex(scope, summary, store, checkpointRead) {
+    const warnings = checkpointRead ? checkpointRead.warnings : [];
+    const index = {
+        schema_version: "runtime-evidence-summary-index-v1",
+        generated_at: new Date().toISOString(),
+        canonical_log_path: summaryIndexKey(scope),
+        canonical_log_size: 0,
+        canonical_log_mtime_ms: 0,
+        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),
+        },
+    };
+    await store.saveSummaryIndex(scope, index);
+}
 async function withSummaryIndexUpdateLock(canonicalPath, action) {
     const previous = summaryIndexUpdateLocks.get(canonicalPath) ?? Promise.resolve();
     let release = () => undefined;
@@ -145,38 +231,6 @@ async function withSummaryIndexUpdateLock(canonicalPath, action) {
         }
     }
 }
-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) {
-    return `${canonicalPath}.summary.json`;
-}
-function summaryScopeFromPath(canonicalPath) {
-    const basename = path.basename(canonicalPath, ".jsonl");
-    const decoded = decodeURIComponent(basename);
-    return canonicalPath.includes(`${path.sep}runs${path.sep}`) ? { run_id: decoded } : { goal_id: decoded };
-}
 async function readReproducibilityManifests(paths, scope) {
     let fileNames;
     try {
@@ -193,25 +247,37 @@ async function readReproducibilityManifests(paths, scope) {
             continue;
         if (!reproducibilityManifestFileMayMatchScope(fileName, scope))
             continue;
-        try {
-            const parsed = JSON.parse(await fsp.readFile(path.join(paths.reproducibilityManifestsDir, fileName), "utf8"));
-            if (parsed.schema_version !== "runtime-reproducibility-manifest-v1")
-                continue;
-            if (scope.goal_id && parsed.scope?.goal_id !== scope.goal_id)
-                continue;
-            if (scope.run_id && parsed.scope?.run_id !== scope.run_id)
-                continue;
-            manifests.push({
-                ...parsed,
-                artifacts: Array.isArray(parsed.artifacts) ? parsed.artifacts.filter(isManifestArtifactRef) : [],
-            });
-        }
-        catch {
+        const manifest = await readReproducibilityManifestFile(path.join(paths.reproducibilityManifestsDir, fileName));
+        if (!manifest)
             continue;
-        }
+        if (scope.goal_id && manifest.scope.goal_id !== scope.goal_id)
+            continue;
+        if (scope.run_id && manifest.scope.run_id !== scope.run_id)
+            continue;
+        manifests.push(manifest);
     }
     return manifests;
 }
+async function readReproducibilityManifestFile(filePath) {
+    const raw = await fsp.readFile(filePath, "utf8");
+    let parsedJson;
+    try {
+        parsedJson = JSON.parse(raw);
+    }
+    catch (err) {
+        if (err instanceof SyntaxError)
+            return null;
+        throw err;
+    }
+    const parsed = RuntimeEvidenceReproducibilityManifestSchema.safeParse(parsedJson);
+    if (!parsed.success)
+        return null;
+    return {
+        schema_version: parsed.data.schema_version,
+        scope: parsed.data.scope,
+        artifacts: parsed.data.artifacts.filter(isManifestArtifactRef),
+    };
+}
 function reproducibilityManifestFileMayMatchScope(fileName, scope) {
     const basename = fileName.slice(0, -".json".length);
     let manifestId;
@@ -241,141 +307,13 @@ function safeManifestScopeId(value) {
 function isManifestArtifactRef(value) {
     return typeof value === "object"
         && value !== null
-        && 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");
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return null;
-        throw err;
-    }
-    try {
-        const parsed = JSON.parse(text);
-        if (parsed.schema_version !== "runtime-evidence-summary-index-v1")
-            return null;
-        if (parsed.summary.schema_version !== "runtime-evidence-summary-v1")
-            return null;
-        if (!isCurrentEvidenceSummaryShape(parsed.summary))
-            return null;
-        const stat = await fsp.stat(canonicalPath);
-        if (parsed.canonical_log_size !== stat.size)
-            return null;
-        if (parsed.canonical_log_mtime_ms !== stat.mtimeMs)
-            return null;
-        if (expectedScope.goal_id && parsed.summary.scope.goal_id !== expectedScope.goal_id)
-            return null;
-        if (expectedScope.run_id && parsed.summary.scope.run_id !== expectedScope.run_id)
-            return null;
-        return parsed;
-    }
-    catch {
-        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;
+        && typeof value.label === "string"
+        && (value.path === undefined || typeof value.path === "string")
+        && (value.state_relative_path === undefined
+            || typeof value.state_relative_path === "string")
+        && (value.url === undefined || typeof value.url === "string")
+        && (value.size_bytes === undefined
+            || isSafeNonnegativeInteger(value.size_bytes));
 }
 function isCurrentEvidenceSummaryShape(summary) {
     return summary.context_policy_version === "quarantine-filtered-planning-context-v2"
@@ -388,62 +326,39 @@ function isCurrentEvidenceSummaryShape(summary) {
         && typeof summary.artifact_retention === "object"
         && summary.artifact_retention !== null
         && isCurrentArtifactRetentionShape(summary.artifact_retention)
+        && isCurrentSummaryEntry(summary.latest_strategy)
+        && isCurrentSummaryEntry(summary.best_evidence)
+        && Array.isArray(summary.recent_entries)
+        && summary.recent_entries.every((entry) => isCurrentSummaryEntry(entry))
+        && Array.isArray(summary.recent_failed_attempts)
+        && summary.recent_failed_attempts.every((entry) => isCurrentSummaryEntry(entry))
         && Array.isArray(summary.evaluator_summary.budgets)
         && Array.isArray(summary.evaluator_summary.calibration)
         && typeof summary.candidate_selection_summary === "object"
         && summary.candidate_selection_summary !== null;
 }
+function isCurrentSummaryEntry(value) {
+    return value === null || RuntimeEvidenceEntrySchema.safeParse(value).success;
+}
 function isCurrentArtifactRetentionShape(artifactRetention) {
     const cleanupPlan = artifactRetention.cleanup_plan;
-    if (typeof cleanupPlan !== "object"
+    if (!isSafeNonnegativeInteger(artifactRetention.total_artifacts)
+        || !isSafeNonnegativeInteger(artifactRetention.total_size_bytes)
+        || !isSafeNonnegativeInteger(artifactRetention.unknown_size_count)
+        || !isSafeNonnegativeInteger(artifactRetention.protected_count)
+        || typeof artifactRetention.by_retention_class !== "object"
+        || artifactRetention.by_retention_class === null
+        || Object.values(artifactRetention.by_retention_class).some((value) => !isSafeNonnegativeInteger(value))
+        || typeof cleanupPlan !== "object"
         || cleanupPlan === null
         || !Array.isArray(cleanupPlan.actions)) {
         return false;
     }
-    return cleanupPlan.actions.every((action) => typeof action.retention_basis === "string");
+    return cleanupPlan.actions.every((action) => typeof action.retention_basis === "string"
+        && (action.size_bytes === undefined || isSafeNonnegativeInteger(action.size_bytes)));
 }
-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 isSafeNonnegativeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
 function activeEvidenceRead(read) {
     const entries = [...read.entries].sort((a, b) => a.occurred_at.localeCompare(b.occurred_at));
@@ -454,37 +369,6 @@ function activeEvidenceRead(read) {
         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);
 }
@@ -564,225 +448,6 @@ function updateMetricState(previous, observation) {
         ].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(),
-        canonical_log_path: canonicalPath,
-        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");
-}
-async function readEvidenceFile(filePath) {
-    let text;
-    try {
-        text = await fsp.readFile(filePath, "utf8");
-    }
-    catch (err) {
-        if (err.code === "ENOENT") {
-            return { entries: [], warnings: [] };
-        }
-        throw err;
-    }
-    const entries = [];
-    const warnings = [];
-    const lines = text.split(/\r?\n/);
-    for (let index = 0; index < lines.length; index += 1) {
-        const line = lines[index];
-        if (!line?.trim())
-            continue;
-        try {
-            const parsed = RuntimeEvidenceEntrySchema.safeParse(JSON.parse(line));
-            if (parsed.success) {
-                entries.push(parsed.data);
-            }
-            else {
-                warnings.push({
-                    file: filePath,
-                    line: index + 1,
-                    message: parsed.error.issues.map((issue) => issue.message).join("; "),
-                });
-            }
-        }
-        catch (err) {
-            warnings.push({
-                file: filePath,
-                line: index + 1,
-                message: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    return { entries, warnings };
-}
 function summarizeEvidence(scope, read, manifests = []) {
     const entries = [...read.entries].sort((a, b) => a.occurred_at.localeCompare(b.occurred_at));
     const corrections = entries.flatMap((entry) => entry.correction ? [entry.correction] : []);