niceeval 0.12.2-canary.31 → 0.13.1

package/dist/runner/reuse-plan.cjs

@@ -1,18 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectTargetReusePlanner = exports.projectTargetPolicyIdentity = exports.PROJECT_TARGET_RECORD_IDENTITY_MAXIMUM_LENGTH = exports.PROJECT_TARGET_INVOCATION_ID_MAXIMUM_LENGTH = exports.PROJECT_TARGET_POLICY_VERSION = exports.PROJECT_TARGET_POLICY_NAME = void 0;
+exports.recordedAttemptVerdict = recordedAttemptVerdict;
 exports.validateProjectTargetReusePlanInput = validateProjectTargetReusePlanInput;
 exports.planProjectTargetReuse = planProjectTargetReuse;
 exports.planProjectTargetReuseWithoutSources = planProjectTargetReuseWithoutSources;
-exports.projectTargetAttachmentProblem = projectTargetAttachmentProblem;
-exports.projectTargetAttachmentGapReason = projectTargetAttachmentGapReason;
 const effect_1 = require("effect");
-const evaluation_ts_1 = require("../eval/record/evaluation.cjs");
 const eligibility_ts_1 = require("../eval/record/eligibility.cjs");
 const verdict_ts_1 = require("../eval/record/verdict.cjs");
-const core_ts_1 = require("../record/model/core.cjs");
 const identifiers_ts_1 = require("../record/model/identifiers.cjs");
-const internal_ts_1 = require("../record/reader/internal.cjs");
 exports.PROJECT_TARGET_POLICY_NAME = "project-target";
 exports.PROJECT_TARGET_POLICY_VERSION = 1;
 exports.PROJECT_TARGET_INVOCATION_ID_MAXIMUM_LENGTH = 255;
@@ -22,9 +18,14 @@ exports.projectTargetPolicyIdentity = Object.freeze({
     version: exports.PROJECT_TARGET_POLICY_VERSION,
 });
 /**
- * Validates the immutable input before any Record I/O. This stays pure so the
- * planner never invents target identities or silently repairs duplicate slots.
+ * Fold the terminal Verdict from the source Attempt's immutable Core outcome
+ * and its fixed Assertions facts. This is a projection, not a second durable
+ * Verdict family.
  */
+function recordedAttemptVerdict(input) {
+    return (0, verdict_ts_1.foldRecordedAttemptVerdict)(input);
+}
+/** Input validation is pure; it never invents a target Slot or repairs an identity. */
 function validateProjectTargetReusePlanInput(input) {
     const unknownInput = input;
     if (typeof unknownInput !== "object" || unknownInput === null) {
@@ -36,21 +37,18 @@ function validateProjectTargetReusePlanInput(input) {
     }
     const target = envelope.target;
     if (typeof target.invocationId !== "string"
-        || !isBoundedNonEmptyText(target.invocationId, exports.PROJECT_TARGET_INVOCATION_ID_MAXIMUM_LENGTH)) {
+        || !isBoundedNonEmptyText(target.invocationId, exports.PROJECT_TARGET_INVOCATION_ID_MAXIMUM_LENGTH)
+        || !Array.isArray(target.runs)) {
         return invalidPlan("invocation-id-invalid");
     }
-    if (!Array.isArray(target.runs))
-        return invalidPlan("target-run-invalid");
     if (typeof envelope.policy !== "object" || envelope.policy === null) {
         return invalidPlan("policy-input-invalid");
     }
     const policy = envelope.policy;
-    if (typeof policy.identity !== "object" || policy.identity === null) {
-        return invalidPlan("policy-unsupported");
-    }
-    const identity = policy.identity;
-    if (identity.name !== exports.PROJECT_TARGET_POLICY_NAME
-        || identity.version !== exports.PROJECT_TARGET_POLICY_VERSION) {
+    if (typeof policy.identity !== "object"
+        || policy.identity === null
+        || policy.identity.name !== exports.PROJECT_TARGET_POLICY_NAME
+        || policy.identity.version !== exports.PROJECT_TARGET_POLICY_VERSION) {
         return invalidPlan("policy-unsupported");
     }
     if (!isExecutionIdentity(policy.reuseContract)
@@ -62,12 +60,8 @@ function validateProjectTargetReusePlanInput(input) {
     const slotIds = new Set();
     const ordinals = new Set();
     for (const run of target.runs) {
-        if (!isTargetRun(run)
-            || typeof run.runId !== "string"
-            || typeof run.experimentId !== "string"
-            || !isUtcMillis(run.startedAt)) {
+        if (!isTargetRun(run))
             return invalidPlan("target-run-invalid");
-        }
         if (runIds.has(run.runId))
             return invalidPlan("target-run-duplicate");
         runIds.add(run.runId);
@@ -91,86 +85,40 @@ function validateProjectTargetReusePlanInput(input) {
     return undefined;
 }
 /**
- * Purely compares the two available immutable payloads. Record reads and
- * attachment states are handled outside this function, preserving the domain
- * boundary between I/O and equality/rerun policy.
- */
-function compareProjectTargetAttemptEligibility(input) {
-    const comparisons = [];
-    let reason;
-    const chooseReason = (next) => {
-        if (reason === undefined)
-            reason = next;
-    };
-    const reuseContract = compareToken("reuse-contract", input.eligibility.reuseContract, input.policy.reuseContract, "reuse-contract-domain-mismatch", "reuse-contract-mismatch");
-    comparisons.push(reuseContract.comparison);
-    if (reuseContract.reason !== undefined)
-        chooseReason(reuseContract.reason);
-    const verdictEligible = input.verdict === "passed" || input.verdict === "failed";
-    comparisons.push(comparison("niceeval.verdict/v1", "verdict-state", "available", verdictEligible ? "match" : "ineligible", verdictEligible ? "verdict-eligible" : "verdict-ineligible"));
-    if (!verdictEligible)
-        chooseReason("verdict-ineligible");
-    const inputIdentity = compareToken("input-identity", input.eligibility.inputIdentity, input.target.inputIdentity, "identity-domain-mismatch", "identity-mismatch");
-    comparisons.push(inputIdentity.comparison);
-    if (inputIdentity.reason !== undefined)
-        chooseReason(inputIdentity.reason);
-    const configIdentity = compareToken("config-identity", input.eligibility.configIdentity, input.target.configIdentity, "identity-domain-mismatch", "identity-mismatch");
-    comparisons.push(configIdentity.comparison);
-    if (configIdentity.reason !== undefined)
-        chooseReason(configIdentity.reason);
-    const duration = compareDuration(input.eligibility.executionDuration, input.target.timeout);
-    comparisons.push(duration.comparison);
-    if (duration.reason !== undefined)
-        chooseReason(duration.reason);
-    if (verdictEligible
-        && (input.policy.rerun === "all"
-            || (input.policy.rerun === "failed" && input.verdict === "failed"))) {
-        chooseReason("rerun-requested");
-    }
-    if (input.policy.keepSandbox)
-        chooseReason("sandbox-retention-requested");
-    return Object.freeze({
-        comparisons: Object.freeze(comparisons),
-        ...(reason === undefined ? {} : { reason }),
-    });
-}
-/**
- * Reads only the frozen current Record and produces a total, target-ordered
- * reuse/gap partition. It never opens storage, walks directories, or creates
- * an Effect runtime of its own.
+ * Plans only from Record Host selection references. It neither reconstructs
+ * attempt handles from strings nor reads private Record paths.
  */
 function planProjectTargetReuse(input) {
     return effect_1.Effect.suspend(() => {
         const invalid = validateProjectTargetReusePlanInput(input);
         if (invalid !== undefined)
             return effect_1.Effect.fail(invalid);
-        const port = (0, internal_ts_1.resolveFrozenRecordReaderPort)(input.view);
-        if (port === undefined)
-            return effect_1.Effect.fail(invalidPlan("view-invalid"));
         return effect_1.Effect.gen(function* () {
-            yield* port.assertOpen(input.view);
-            const discovery = yield* discoverSources(input.view, port, input.target);
+            const selection = yield* input.reader.selectRuns();
+            const readable = yield* effect_1.Effect.forEach(selection.runRefs, (ref) => input.reader.readRun(ref), { concurrency: 1 });
+            const runs = [];
+            const coreIssues = [];
+            for (const read of readable) {
+                if (read.state === "available")
+                    runs.push(read.value);
+                else if (read.state === "core-invalid")
+                    coreIssues.push(...read.issues);
+            }
+            const byRunId = new Map(runs.map((run) => [run.document.runId, run]));
             const slots = [];
-            const origins = new Map();
             for (const target of flattenTargetSlots(input.target)) {
-                const planned = yield* planTargetSlot({
-                    view: input.view,
-                    port,
+                slots.push(yield* planTargetSlot({
+                    reader: input.reader,
                     target,
                     policy: input.policy,
-                    discovery,
-                    origins,
-                });
-                slots.push(planned);
-            }
-            const reuse = [];
-            const gaps = [];
-            for (const slot of slots) {
-                if (slot.state === "reuse")
-                    reuse.push(slot);
-                else
-                    gaps.push(slot);
+                    runs,
+                    byRunId,
+                    selectionHasProblem: selection.problems.length > 0 || coreIssues.length > 0,
+                    coreIssues,
+                }));
             }
+            const reuse = slots.filter((slot) => slot.state === "reuse");
+            const gaps = slots.filter((slot) => slot.state === "gap");
             return Object.freeze({
                 target: input.target,
                 policy: exports.projectTargetPolicyIdentity,
@@ -182,12 +130,7 @@ function planProjectTargetReuse(input) {
         });
     });
 }
-/**
- * Plans a missing Record root without manufacturing a frozen reader capability.
- * Callers must use this only after the Record filesystem classified the whole
- * root as missing; an existing root stays on the reader path so malformed
- * durable state remains fail-closed.
- */
+/** Empty or not-yet-created Record roots produce no source capability. */
 function planProjectTargetReuseWithoutSources(input) {
     return effect_1.Effect.suspend(() => {
         const invalid = validateProjectTargetReusePlanInput(input);
@@ -199,118 +142,29 @@ function planProjectTargetReuseWithoutSources(input) {
             issues: [],
             comparisons: [],
         })));
-        const reuse = Object.freeze([]);
         return effect_1.Effect.succeed(Object.freeze({
             target: input.target,
             policy: exports.projectTargetPolicyIdentity,
             effectiveOptions: effectiveOptions(input.policy),
             slots: gaps,
-            reuse,
+            reuse: Object.freeze([]),
             gaps,
         }));
     });
 }
-/** A small named facade lets Runner wiring keep the policy capability explicit. */
-exports.ProjectTargetReusePlanner = Object.freeze({
-    plan: planProjectTargetReuse,
-});
-function discoverSources(view, port, target) {
-    const targetKeys = sourceKeysForTarget(target);
-    return targetKeys.size === 0
-        ? effect_1.Effect.succeed(Object.freeze({ latestByExperimentEval: new Map() }))
-        : foldProjectTargetSourceCandidates({
-            view,
-            port,
-            candidates: port.candidates(view),
-            targetKeys,
-        });
-}
-function sourceKeysForTarget(target) {
-    const keys = new Set();
-    for (const run of target.runs) {
-        for (const slot of run.slots) {
-            keys.add(sourceKey(slot.experimentId, slot.evalId));
-        }
-    }
-    return keys;
-}
-/**
- * @internal Stream-fold entry point. It intentionally retains only one latest
- * candidate per requested `(experimentId, evalId)` plus one fail-closed
- * unattributed problem; candidate cardinality never determines heap use.
- */
-function foldProjectTargetSourceCandidates(input) {
-    const initial = {
-        latestByExperimentEval: new Map(),
-    };
-    return effect_1.Stream.runFoldEffect(input.candidates, initial, (state, candidate) => collectSourceCandidate(input, state, candidate)).pipe(effect_1.Effect.map((state) => state.unattributedProblem === undefined
-        ? Object.freeze({ latestByExperimentEval: state.latestByExperimentEval })
-        : Object.freeze({
-            latestByExperimentEval: state.latestByExperimentEval,
-            unattributedProblem: state.unattributedProblem,
-        })));
-}
-function collectSourceCandidate(input, state, candidate) {
-    if (state.unattributedProblem !== undefined)
-        return effect_1.Effect.succeed(state);
-    if (candidate.state === "core-invalid") {
-        state.unattributedProblem = Object.freeze({
-            reason: "source-core-invalid",
-            issues: candidate.issues,
-        });
-        return effect_1.Effect.succeed(state);
-    }
-    if (candidate.state === "missing") {
-        state.unattributedProblem = Object.freeze({
-            reason: "source-core-invalid",
-            issues: Object.freeze([]),
-        });
-        return effect_1.Effect.succeed(state);
-    }
-    return effect_1.Effect.gen(function* () {
-        const read = yield* input.port.readRunAttachment(input.view, candidate.value, evaluation_ts_1.evaluationsAttachmentFamilyV1);
-        const problem = projectTargetAttachmentProblem(read);
-        if (problem !== undefined) {
-            state.unattributedProblem = Object.freeze({
-                reason: problem.reason,
-                issues: problem.issues,
-            });
-            return state;
-        }
-        if (read.state !== "available") {
-            throw new Error("available Evaluation Attachment was lost before projection");
-        }
-        const evaluations = (0, evaluation_ts_1.projectEvaluationsAttachmentV1)(read.value);
-        for (const evaluation of evaluations.evaluations) {
-            const key = sourceKey(evaluations.experimentId, evaluation.evalId);
-            if (!input.targetKeys.has(key))
-                continue;
-            const candidateForEval = Object.freeze({
-                run: candidate.value,
-                evaluation,
-            });
-            const prior = state.latestByExperimentEval.get(key);
-            if (prior === undefined
-                || compareSourceRuns(prior.run, candidateForEval.run) < 0) {
-                state.latestByExperimentEval.set(key, candidateForEval);
-            }
-        }
-        return state;
-    });
-}
+exports.ProjectTargetReusePlanner = Object.freeze({ plan: planProjectTargetReuse });
 function planTargetSlot(input) {
     return effect_1.Effect.gen(function* () {
-        const unattributed = input.discovery.unattributedProblem;
-        if (unattributed !== undefined) {
+        if (input.selectionHasProblem) {
             return gapSlot(input.target, {
-                reason: unattributed.reason,
+                reason: "source-core-invalid",
                 scope: "target",
-                issues: unattributed.issues,
+                issues: input.coreIssues,
                 comparisons: [],
             });
         }
-        const source = input.discovery.latestByExperimentEval.get(sourceKey(input.target.experimentId, input.target.evalId));
-        if (source === undefined) {
+        const sourceRun = latestSourceRun(input.runs, input.target);
+        if (sourceRun === undefined) {
             return gapSlot(input.target, {
                 reason: "no-source-run",
                 scope: "slot",
@@ -318,129 +172,166 @@ function planTargetSlot(input) {
                 comparisons: [],
             });
         }
-        const barrier = sourceBarrier(source.run);
-        const sourceSlot = source.evaluation.slots.find((slot) => slot.attempt === input.target.attempt);
-        if (sourceSlot === undefined
-            || !source.run.expectedSlots.includes(sourceSlot.slotId)) {
+        const sourceBarrier = Object.freeze({
+            runId: sourceRun.document.runId,
+            startedAt: sourceRun.document.startedAt,
+        });
+        const expected = sourceRun.document.expectedSlots.find((slot) => slot.evalId === input.target.evalId
+            && slot.attemptOrdinal === input.target.attempt);
+        if (expected === undefined) {
             return gapSlot(input.target, {
                 reason: "source-slot-missing",
                 scope: "slot",
                 issues: [],
-                sourceBarrier: barrier,
+                sourceBarrier,
                 comparisons: [],
             });
         }
-        const member = yield* input.port.member(input.view, source.run, sourceSlot.slotId);
-        if (member.state === "core-invalid") {
+        const member = sourceRun.members.find((candidate) => candidate.document.slotId === expected.slotId);
+        if (member === undefined || member.attempt === null) {
             return gapSlot(input.target, {
-                reason: "source-core-invalid",
+                reason: "source-member-missing",
                 scope: "slot",
-                issues: member.issues,
-                sourceBarrier: barrier,
+                issues: [],
+                sourceBarrier,
                 comparisons: [],
             });
         }
-        if (member.state === "missing") {
+        const readAttempt = yield* input.reader.readAttempt(member.attempt);
+        if (readAttempt.state !== "available") {
             return gapSlot(input.target, {
-                reason: "source-member-missing",
+                reason: "source-core-invalid",
                 scope: "slot",
-                issues: [],
-                sourceBarrier: barrier,
+                issues: issuesOf(readAttempt),
+                sourceBarrier,
                 comparisons: [],
             });
         }
-        const attempt = yield* input.port.attempt(input.view, member.value.attempt);
-        if (attempt.state === "core-invalid") {
+        const candidateResolution = candidateFor({
+            target: input.target,
+            sourceBarrier,
+            attempt: readAttempt.value,
+            byRunId: input.byRunId,
+        });
+        if (candidateResolution === undefined) {
             return gapSlot(input.target, {
                 reason: "source-core-invalid",
                 scope: "slot",
-                issues: attempt.issues,
-                sourceBarrier: barrier,
+                issues: [],
+                sourceBarrier,
                 comparisons: [],
             });
         }
-        if (attempt.state === "missing"
-            || attempt.value.attemptId !== member.value.attempt.attemptId
-            || attempt.value.originRunId !== member.value.attempt.originRunId) {
+        const candidate = candidateResolution.source;
+        if (!reusableSlotIdentityMatches({
+            target: input.target,
+            sourceExpected: expected,
+            originExpected: candidateResolution.originExpected,
+        })) {
             return gapSlot(input.target, {
-                reason: "source-core-invalid",
+                reason: "identity-mismatch",
                 scope: "slot",
                 issues: [],
-                sourceBarrier: barrier,
-                comparisons: [],
+                sourceBarrier,
+                candidate,
+                comparisons: [identityMismatchComparison()],
             });
         }
-        const origin = yield* resolveAttemptOrigin({
-            view: input.view,
-            port: input.port,
-            attempt: attempt.value,
-            cache: input.origins,
-        });
-        if (origin.state === "invalid") {
+        const assertions = yield* input.reader.readAssertions(readAttempt.value.owner);
+        if (assertions.state !== "available") {
+            const problem = attachmentProblem(assertions);
             return gapSlot(input.target, {
-                reason: "source-core-invalid",
+                reason: problem.reason,
                 scope: "slot",
-                issues: origin.issues,
-                sourceBarrier: barrier,
-                comparisons: [],
+                issues: problem.issues,
+                sourceBarrier,
+                candidate,
+                comparisons: [comparison("niceeval.assertions", "assertion-verdict", problem.state, "not-comparable", problem.reason)],
             });
         }
-        const candidate = Object.freeze({
-            evaluationKind: source.evaluation.evaluationKind,
-            attemptId: attempt.value.attemptId,
-            attempt: attempt.value,
-            origin: origin.origin,
-            sourceBarrier: barrier,
+        const verdict = recordedAttemptVerdict({
+            outcome: readAttempt.value.document.outcome,
+            assertions: assertions.value,
         });
-        const eligibilityRead = yield* input.port.readAttemptAttachment(input.view, attempt.value, 
-        // The family is captured in the helper's module; importing its value here
-        // would be equivalent, but this explicit read preserves one Record I/O path.
-        eligibility_ts_1.eligibilityAttachmentFamilyV1);
-        const verdictRead = yield* input.port.readAttemptAttachment(input.view, attempt.value, verdict_ts_1.verdictAttachmentFamilyV1);
-        const eligibilityProblem = projectTargetAttachmentProblem(eligibilityRead);
-        const verdictProblem = projectTargetAttachmentProblem(verdictRead);
-        if (eligibilityProblem !== undefined || verdictProblem !== undefined) {
-            const problems = [eligibilityProblem, verdictProblem].filter((problem) => problem !== undefined);
-            const comparisons = Object.freeze([
-                ...(eligibilityProblem === undefined
-                    ? []
-                    : [
-                        unavailableComparison("niceeval.eligibility/v1", "reuse-contract", eligibilityProblem),
-                    ]),
-                ...(verdictProblem === undefined
-                    ? []
-                    : [
-                        unavailableComparison("niceeval.verdict/v1", "verdict-state", verdictProblem),
-                    ]),
-            ]);
+        if (readAttempt.value.document.outcome !== "completed") {
             return gapSlot(input.target, {
-                reason: problems[0].reason,
+                reason: "attempt-outcome-ineligible",
                 scope: "slot",
-                issues: Object.freeze(problems.flatMap((problem) => problem.issues)),
-                sourceBarrier: barrier,
+                issues: [],
+                sourceBarrier,
                 candidate,
-                comparisons,
+                comparisons: [
+                    comparison("core", "attempt-outcome", "available", "ineligible", `attempt-${readAttempt.value.document.outcome}`),
+                    verdictComparison(verdict, "ineligible"),
+                ],
             });
         }
-        if (eligibilityRead.state !== "available" || verdictRead.state !== "available") {
-            throw new Error("available reuse Attachment was lost before projection");
+        if (verdict !== "passed" && verdict !== "failed") {
+            return gapSlot(input.target, {
+                reason: "verdict-ineligible",
+                scope: "slot",
+                issues: [],
+                sourceBarrier,
+                candidate,
+                comparisons: [verdictComparison(verdict, "ineligible")],
+            });
         }
-        const eligibility = normalizeRecordedEligibility((0, eligibility_ts_1.projectEligibilityAttachmentV1)(eligibilityRead.value));
-        const verdict = normalizeRecordedVerdict((0, verdict_ts_1.projectVerdictAttachmentV1)(verdictRead.value));
-        const comparison = compareProjectTargetAttemptEligibility({
-            eligibility,
-            verdict,
-            target: input.target,
-            policy: input.policy,
+        const observability = yield* input.reader.readAttemptObservability(readAttempt.value.owner);
+        if (observability.state !== "available") {
+            const problem = attachmentProblem(observability);
+            return gapSlot(input.target, {
+                reason: problem.reason,
+                scope: "slot",
+                issues: problem.issues,
+                sourceBarrier,
+                candidate,
+                comparisons: [comparison("niceeval.observability", "execution-duration", problem.state, "not-comparable", problem.reason)],
+            });
+        }
+        const durationRead = (0, eligibility_ts_1.readAttemptExecutionDuration)(observability.value);
+        if (durationRead.state !== "available") {
+            return gapSlot(input.target, {
+                reason: "source-attachment-unavailable",
+                scope: "slot",
+                issues: [],
+                sourceBarrier,
+                candidate,
+                comparisons: [comparison("niceeval.observability", "execution-duration", "unavailable", "not-comparable", durationRead.reason)],
+            });
+        }
+        const duration = durationComparison({
+            source: durationRead.duration,
+            target: input.target.timeout,
         });
-        if (comparison.reason !== undefined) {
+        if (duration.failure !== undefined) {
+            return gapSlot(input.target, {
+                reason: duration.failure,
+                scope: "slot",
+                issues: [],
+                sourceBarrier,
+                candidate,
+                comparisons: [duration.comparison],
+            });
+        }
+        if (input.policy.rerun === "all"
+            || (input.policy.rerun === "failed" && verdict === "failed")) {
+            return gapSlot(input.target, {
+                reason: "rerun-requested",
+                scope: "slot",
+                issues: [],
+                sourceBarrier,
+                candidate,
+                comparisons: [verdictComparison(verdict, "match"), duration.comparison],
+            });
+        }
+        if (input.policy.keepSandbox) {
             return gapSlot(input.target, {
-                reason: comparison.reason,
+                reason: "sandbox-retention-requested",
                 scope: "slot",
                 issues: [],
-                sourceBarrier: barrier,
+                sourceBarrier,
                 candidate,
-                comparisons: comparison.comparisons,
+                comparisons: [verdictComparison(verdict, "match"), duration.comparison],
             });
         }
         return Object.freeze({
@@ -448,160 +339,124 @@ function planTargetSlot(input) {
             state: "reuse",
             adoption: "carried",
             source: candidate,
-            comparisons: comparison.comparisons,
+            comparisons: Object.freeze([
+                comparison("core", "execution-identity", "available", "match", "execution-identity-match"),
+                comparison("core", "attempt-outcome", "available", "match", "attempt-completed"),
+                verdictComparison(verdict, "match"),
+                duration.comparison,
+            ]),
         });
     });
 }
-function resolveAttemptOrigin(input) {
-    return effect_1.Effect.suspend(() => {
-        const key = (0, core_ts_1.recordAttemptReferenceKey)({
-            originRunId: input.attempt.originRunId,
-            attemptId: input.attempt.attemptId,
-        });
-        const cached = input.cache.get(key);
-        if (cached !== undefined)
-            return effect_1.Effect.succeed(cached);
-        return effect_1.Effect.gen(function* () {
-            const run = yield* input.port.run(input.view, input.attempt.originRunId);
-            if (run.state === "core-invalid") {
-                const result = Object.freeze({
-                    state: "invalid",
-                    issues: run.issues,
-                });
-                input.cache.set(key, result);
-                return result;
-            }
-            if (run.state === "missing") {
-                const result = Object.freeze({
-                    state: "invalid",
-                    issues: Object.freeze([]),
-                });
-                input.cache.set(key, result);
-                return result;
-            }
-            for (const slotId of run.value.expectedSlots) {
-                const member = yield* input.port.member(input.view, run.value, slotId);
-                if (member.state === "core-invalid") {
-                    const result = Object.freeze({
-                        state: "invalid",
-                        issues: member.issues,
-                    });
-                    input.cache.set(key, result);
-                    return result;
-                }
-                if (member.state === "available"
-                    && member.value.attempt.originRunId === input.attempt.originRunId
-                    && member.value.attempt.attemptId === input.attempt.attemptId) {
-                    const result = Object.freeze({
-                        state: "available",
-                        origin: Object.freeze({ runId: run.value.runId, slotId }),
-                    });
-                    input.cache.set(key, result);
-                    return result;
-                }
-            }
-            const result = Object.freeze({
-                state: "invalid",
-                issues: Object.freeze([]),
-            });
-            input.cache.set(key, result);
-            return result;
-        });
+function latestSourceRun(runs, target) {
+    const candidates = runs.filter((run) => run.document.experimentId === target.experimentId
+        && run.document.expectedSlots.some((slot) => slot.evalId === target.evalId));
+    return candidates.sort(compareReadableRuns).at(-1);
+}
+function compareReadableRuns(left, right) {
+    if (left.document.startedAt !== right.document.startedAt) {
+        return left.document.startedAt < right.document.startedAt ? -1 : 1;
+    }
+    return (0, identifiers_ts_1.compareCanonicalIdentity)(left.document.runId, right.document.runId);
+}
+function candidateFor(input) {
+    const document = input.attempt.document;
+    const originRun = input.byRunId.get(document.originRunId);
+    if (originRun === undefined)
+        return undefined;
+    const originExpected = originRun.document.expectedSlots.find((slot) => slot.slotId === document.slotId);
+    if (originExpected === undefined
+        || document.evalId !== originExpected.evalId
+        || document.executionIdentityDigest !== originExpected.executionIdentityDigest) {
+        return undefined;
+    }
+    return Object.freeze({
+        source: Object.freeze({
+            attemptId: input.attempt.ref.attemptId,
+            attempt: input.attempt.ref,
+            origin: Object.freeze({ runId: document.originRunId, slotId: document.slotId }),
+            originRun: originRun.ref,
+            sourceBarrier: input.sourceBarrier,
+            evaluationKind: input.target.evaluationKind,
+        }),
+        originExpected,
     });
 }
-/** Converts every non-available RecordAttachment read state into a stable gap. */
-function projectTargetAttachmentProblem(read) {
-    switch (read.state) {
-        case "available":
-            return undefined;
-        case "unavailable":
+function sameSlotIdentity(left, right) {
+    return left.slotId === right.slotId
+        && left.evalId === right.evalId
+        && left.attemptOrdinal === right.attemptOrdinal
+        && left.executionIdentityDigest === right.executionIdentityDigest;
+}
+function targetMatchesSlotIdentity(target, slot) {
+    return target.slotId === slot.slotId
+        && target.evalId === slot.evalId
+        && target.attempt === slot.attemptOrdinal
+        && target.executionIdentityDigest === slot.executionIdentityDigest;
+}
+function reusableSlotIdentityMatches(input) {
+    return sameSlotIdentity(input.sourceExpected, input.originExpected)
+        && targetMatchesSlotIdentity(input.target, input.sourceExpected)
+        && targetMatchesSlotIdentity(input.target, input.originExpected);
+}
+function issuesOf(read) {
+    return read.state === "core-invalid" ? read.issues : Object.freeze([]);
+}
+function attachmentProblem(input) {
+    switch (input.state) {
+        case "not-recorded":
             return Object.freeze({
-                reason: projectTargetAttachmentGapReason("unavailable"),
+                reason: "source-attachment-unavailable",
                 state: "unavailable",
                 issues: Object.freeze([]),
             });
         case "migration-required":
             return Object.freeze({
-                reason: projectTargetAttachmentGapReason("migration-required"),
+                reason: "source-attachment-migration-required",
                 state: "migration-required",
                 issues: Object.freeze([]),
             });
-        case "migration-unavailable":
-            return Object.freeze({
-                reason: projectTargetAttachmentGapReason("migration-unavailable"),
-                state: "migration-unavailable",
-                issues: Object.freeze([]),
-            });
         case "unsupported":
             return Object.freeze({
-                reason: projectTargetAttachmentGapReason("unsupported"),
+                reason: "source-attachment-unsupported",
                 state: "unsupported",
                 issues: Object.freeze([]),
             });
         case "invalid":
             return Object.freeze({
-                reason: projectTargetAttachmentGapReason("invalid"),
+                reason: "source-attachment-invalid",
                 state: "invalid",
-                issues: read.issues,
+                issues: input.issues ?? Object.freeze([]),
             });
     }
 }
-/** Stable read-state mapping used by both source and required-Attempt facts. */
-function projectTargetAttachmentGapReason(state) {
-    switch (state) {
-        case "unavailable":
-            return "source-attachment-unavailable";
-        case "migration-required":
-            return "source-attachment-migration-required";
-        case "migration-unavailable":
-            return "source-attachment-migration-unavailable";
-        case "unsupported":
-            return "source-attachment-unsupported";
-        case "invalid":
-            return "source-attachment-invalid";
-    }
+function identityMismatchComparison() {
+    return comparison("core", "execution-identity", "available", "mismatch", "identity-mismatch");
 }
-function unavailableComparison(attachment, recordedClaim, problem) {
-    return comparison(attachment, recordedClaim, problem.state, "not-comparable", problem.reason);
+function verdictComparison(verdict, result) {
+    return comparison("niceeval.assertions", "assertion-verdict", "available", result, verdict === "errored" ? "verdict-ineligible" : `verdict-${verdict}`);
 }
-function compareToken(recordedClaim, source, target, domainReason, mismatchReason) {
-    if (source.domain !== target.domain) {
-        return Object.freeze({
-            comparison: comparison("niceeval.eligibility/v1", recordedClaim, "available", "mismatch", domainReason),
-            reason: domainReason,
-        });
+function durationComparison(input) {
+    if (input.target === undefined) {
+        return {
+            comparison: comparison("niceeval.observability", "execution-duration", "available", "match", "timeout-unbounded"),
+        };
     }
-    if (source.value !== target.value) {
-        return Object.freeze({
-            comparison: comparison("niceeval.eligibility/v1", recordedClaim, "available", "mismatch", mismatchReason),
-            reason: mismatchReason,
-        });
+    if (input.source.domain !== input.target.domain) {
+        return {
+            comparison: comparison("niceeval.observability", "execution-duration", "available", "mismatch", "duration-domain-mismatch"),
+            failure: "duration-domain-mismatch",
+        };
     }
-    return Object.freeze({
-        comparison: comparison("niceeval.eligibility/v1", recordedClaim, "available", "match", `${recordedClaim}-match`),
-    });
-}
-function compareDuration(source, timeout) {
-    if (timeout === undefined) {
-        return Object.freeze({
-            comparison: comparison("niceeval.eligibility/v1", "execution-duration", "available", "match", "timeout-unbounded"),
-        });
+    if (input.source.milliseconds > input.target.milliseconds) {
+        return {
+            comparison: comparison("niceeval.observability", "execution-duration", "available", "mismatch", "timeout-exceeded"),
+            failure: "timeout-exceeded",
+        };
     }
-    if (source.domain !== timeout.domain) {
-        return Object.freeze({
-            comparison: comparison("niceeval.eligibility/v1", "execution-duration", "available", "mismatch", "duration-domain-mismatch"),
-            reason: "duration-domain-mismatch",
-        });
-    }
-    if (source.milliseconds > timeout.milliseconds) {
-        return Object.freeze({
-            comparison: comparison("niceeval.eligibility/v1", "execution-duration", "available", "mismatch", "timeout-exceeded"),
-            reason: "timeout-exceeded",
-        });
-    }
-    return Object.freeze({
-        comparison: comparison("niceeval.eligibility/v1", "execution-duration", "available", "match", "duration-within-timeout"),
-    });
+    return {
+        comparison: comparison("niceeval.observability", "execution-duration", "available", "match", "duration-within-timeout"),
+    };
 }
 function comparison(attachment, recordedClaim, sourceState, result, reason) {
     return Object.freeze({ attachment, recordedClaim, sourceState, result, reason });
@@ -629,19 +484,7 @@ function effectiveOptions(policy) {
     });
 }
 function flattenTargetSlots(target) {
-    const slots = [];
-    for (const run of target.runs)
-        slots.push(...run.slots);
-    return Object.freeze(slots);
-}
-function sourceBarrier(run) {
-    return Object.freeze({ runId: run.runId, startedAt: run.startedAt });
-}
-function compareSourceRuns(left, right) {
-    if (left.startedAt !== right.startedAt) {
-        return left.startedAt < right.startedAt ? -1 : 1;
-    }
-    return (0, identifiers_ts_1.compareCanonicalIdentity)(left.runId, right.runId);
+    return Object.freeze(target.runs.flatMap((run) => run.slots));
 }
 function sourceKey(experimentId, evalId, ordinal) {
     return ordinal === undefined
@@ -660,7 +503,7 @@ function isTargetRun(value) {
         && typeof run.experimentId === "string"
         && isBoundedRecordIdentity(run.experimentId)
         && typeof run.startedAt === "number"
-        && isUtcMillis(run.startedAt)
+        && (0, identifiers_ts_1.isUtcMillis)(run.startedAt)
         && Array.isArray(run.slots));
 }
 function isTargetSlot(value) {
@@ -678,6 +521,9 @@ function isTargetSlot(value) {
         && typeof slot.attempt === "number"
         && Number.isSafeInteger(slot.attempt)
         && slot.attempt >= 0
+        && (slot.evaluationKind === "pass" || slot.evaluationKind === "score")
+        && typeof slot.executionIdentityDigest === "string"
+        && (0, identifiers_ts_1.isSha256Digest)(slot.executionIdentityDigest)
         && isExecutionIdentity(slot.inputIdentity)
         && isExecutionIdentity(slot.configIdentity)
         && (slot.timeout === undefined || isExecutionDurationLimit(slot.timeout)));
@@ -686,10 +532,8 @@ function isBoundedNonEmptyText(value, maximumLength) {
     return value.length > 0 && value.length <= maximumLength;
 }
 function isBoundedRecordIdentity(value) {
-    return (isBoundedNonEmptyText(value, exports.PROJECT_TARGET_RECORD_IDENTITY_MAXIMUM_LENGTH) && !value.includes("\u0000"));
-}
-function isUtcMillis(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+    return isBoundedNonEmptyText(value, exports.PROJECT_TARGET_RECORD_IDENTITY_MAXIMUM_LENGTH)
+        && !value.includes("\u0000");
 }
 function isRerunOption(value) {
     return value === "none" || value === "failed" || value === "all";
@@ -713,27 +557,4 @@ function isExecutionDurationLimit(value) {
         && Number.isFinite(duration.milliseconds)
         && duration.milliseconds >= 0;
 }
-function normalizeRecordedEligibility(eligibility) {
-    return Object.freeze({
-        reuseContract: Object.freeze({
-            domain: eligibility.reuseContract.domain,
-            value: eligibility.reuseContract.value,
-        }),
-        inputIdentity: Object.freeze({
-            domain: eligibility.inputIdentity.domain,
-            value: eligibility.inputIdentity.value,
-        }),
-        configIdentity: Object.freeze({
-            domain: eligibility.configIdentity.domain,
-            value: eligibility.configIdentity.value,
-        }),
-        executionDuration: Object.freeze({
-            domain: eligibility.executionDuration.domain,
-            milliseconds: eligibility.executionDuration.milliseconds,
-        }),
-    });
-}
-function normalizeRecordedVerdict(verdict) {
-    return verdict;
-}
 //# sourceMappingURL=reuse-plan.cjs.map