niceeval 0.12.2-canary.31 → 0.13.0

package/dist/runner/reuse-readback.d.cts

@@ -1,38 +1,47 @@
 import { Effect } from "effect";
-import { type ProjectedRecordAttachmentResult } from "../projection/attachment-result.cjs";
-import { type RecordAttachmentProjector } from "../projection/projector.cjs";
 import type { RecordIssue } from "../record/errors/record-errors.cjs";
+import type { RecordReadSession, SelectedAttemptRef } from "../record/host/types.cjs";
 import type { RecordReaderReadError } from "../record/reader/errors.cjs";
-import type { FrozenRecordAttempt, FrozenRecordView } from "../record/reader/types.cjs";
-import { type Score } from "../eval/record/score.cjs";
 import type { Verdict } from "../shared/types.cjs";
-import type { ExecutionReusePlan, ExecutionReusePlanSource, ReusePlanSlot, TargetSlot } from "./reuse-plan.cjs";
-/**
- * A carry is a current projection of a frozen source Attempt, not a recreated
- * legacy EvalResult. The exact source capability stays scoped to the reader.
- */
+import { type ExecutionReusePlan, type ExecutionReusePlanSource, type ReusePlanSlot, type TargetSlot } from "./reuse-plan.cjs";
+/** Fixed-family read states remain visible; a readback never invents a result file. */
+export type CurrentRecordRead<Value> = {
+    readonly state: "available";
+    readonly value: Value;
+} | {
+    readonly state: "not-recorded";
+} | {
+    readonly state: "migration-required";
+    readonly family: string;
+    readonly fromSchemaVersion: number;
+    readonly toSchemaVersion: number;
+    readonly command: "niceeval migrate";
+} | {
+    readonly state: "unsupported";
+    readonly family: string;
+    readonly schemaVersion: number;
+} | {
+    readonly state: "invalid";
+    readonly issues: readonly RecordIssue[];
+};
 export interface CurrentReusedAttemptReadback {
     readonly state: "reused";
     readonly target: CurrentReusedAttemptTarget;
     readonly source: CurrentReusedAttemptSource;
-    /** Reuse is fail-closed unless the current Verdict is a reusable terminal fact. */
     readonly verdict: "passed" | "failed";
     readonly score: CurrentReusedAttemptScore;
-    readonly executionErrors: ProjectedRecordAttachmentResult<readonly CurrentReusedExecutionError[]>;
+    readonly executionErrors: CurrentRecordRead<readonly CurrentReusedExecutionError[]>;
 }
-/** A gap's observed current source. It explains dry output but never authorizes reuse. */
 export interface CurrentReuseCandidateReadback {
     readonly state: "prior";
     readonly target: CurrentReusedAttemptTarget;
     readonly source: CurrentReusedAttemptSource;
-    readonly verdict: ProjectedRecordAttachmentResult<Verdict>;
+    readonly verdict: CurrentRecordRead<Verdict>;
     readonly score: CurrentReusedAttemptScore;
-    readonly executionErrors: ProjectedRecordAttachmentResult<readonly CurrentReusedExecutionError[]>;
-    /** Origin Run's current Sources projection, retained only as a projection. */
+    readonly executionErrors: CurrentRecordRead<readonly CurrentReusedExecutionError[]>;
     readonly sourceFiles: CurrentReuseSourceFiles;
 }
 export type CurrentReuseReadback = CurrentReusedAttemptReadback | CurrentReuseCandidateReadback;
-/** The target identity needed by runtime and dry output, without old result fields. */
 export interface CurrentReusedAttemptTarget {
     readonly runId: TargetSlot["runId"];
     readonly slotId: TargetSlot["slotId"];
@@ -40,27 +49,26 @@ export interface CurrentReusedAttemptTarget {
     readonly evalId: TargetSlot["evalId"];
     readonly attempt: TargetSlot["attempt"];
 }
-/** The exact current source authority. It is never reconstructed from an id string. */
 export interface CurrentReusedAttemptSource {
-    readonly attempt: FrozenRecordAttempt;
+    readonly attempt: SelectedAttemptRef;
     readonly attemptId: ExecutionReusePlanSource["attemptId"];
     readonly origin: ExecutionReusePlanSource["origin"];
     readonly sourceBarrier: ExecutionReusePlanSource["sourceBarrier"];
     readonly evaluationKind: ExecutionReusePlanSource["evaluationKind"];
 }
-/** Score exists only for a Score Eval; an absent Score is not an invented zero. */
 export type CurrentReusedAttemptScore = {
     readonly state: "not-applicable";
 } | {
     readonly state: "applicable";
-    readonly attachment: ProjectedRecordAttachmentResult<Score>;
+    readonly attachment: CurrentRecordRead<{
+        readonly state: "complete" | "partial" | "unavailable";
+        readonly earned?: number;
+    }>;
 };
-/** Durable diagnostic facts normalized before entering the runner/readback ABI. */
 export interface CurrentReusedExecutionCause {
     readonly code: string;
     readonly summary: string;
 }
-/** The display-safe execution-error subset of the current diagnostics projection. */
 export interface CurrentReusedExecutionError {
     readonly kind: "execution-error";
     readonly code: string;
@@ -72,22 +80,18 @@ export interface CurrentReuseSourceFile {
     readonly path: string;
     readonly sha256: string;
 }
-/** Source files retain every projection/read state instead of guessing historic inputs. */
-export type CurrentReuseSourceFiles = ProjectedRecordAttachmentResult<readonly CurrentReuseSourceFile[]> | {
+export type CurrentReuseSourceFiles = CurrentRecordRead<readonly CurrentReuseSourceFile[]> | {
     readonly state: "origin-run-missing";
 } | {
     readonly state: "origin-run-invalid";
     readonly issues: readonly RecordIssue[];
+} | {
+    readonly state: "projection-invalid";
 };
-/** A forged or internally inconsistent plan/readback must never produce a carry. */
 export interface CurrentReuseReadbackPlanInvalid {
     readonly code: "current-reuse-readback-plan-invalid";
-    readonly reason: "source-attempt-id-mismatch" | "source-origin-run-mismatch" | "source-evaluation-kind-invalid" | "source-verdict-unavailable" | "source-verdict-ineligible";
+    readonly reason: "source-attempt-unavailable" | "source-verdict-unavailable" | "source-verdict-ineligible";
 }
-/**
- * A self-contained source identity suitable outside a FrozenRecordView Scope.
- * It deliberately omits the opaque Attempt capability.
- */
 export interface CurrentReusedAttemptSourceSnapshot {
     readonly attemptId: string;
     readonly locator: string;
@@ -101,6 +105,13 @@ export interface CurrentReusedAttemptSourceSnapshot {
     };
     readonly evaluationKind: CurrentReusedAttemptSource["evaluationKind"];
 }
+export interface CurrentReusedAttemptTargetSnapshot {
+    readonly runId: string;
+    readonly slotId: string;
+    readonly experimentId: string;
+    readonly evalId: string;
+    readonly attempt: number;
+}
 export interface CurrentReusedAttemptSnapshot {
     readonly state: "reused";
     readonly target: CurrentReusedAttemptTargetSnapshot;
@@ -115,55 +126,28 @@ export interface CurrentReuseCandidateSnapshot {
     readonly source: CurrentReusedAttemptSourceSnapshot;
     readonly verdict: CurrentReuseCandidateReadback["verdict"];
     readonly score: CurrentReusedAttemptScore;
-    readonly executionErrors: CurrentReuseCandidateReadback["executionErrors"];
+    readonly executionErrors: CurrentReusedAttemptReadback["executionErrors"];
     readonly sourceFiles: CurrentReuseSourceFiles;
 }
 export type CurrentReuseReadbackSnapshot = CurrentReusedAttemptSnapshot | CurrentReuseCandidateSnapshot;
-export interface CurrentReusedAttemptTargetSnapshot {
-    readonly runId: string;
-    readonly slotId: string;
-    readonly experimentId: string;
-    readonly evalId: string;
-    readonly attempt: number;
-}
-/**
- * Reads one typed Attachment from the current frozen view and preserves every
- * durable read state. This never opens a path or reaches into retired graph/evidence data.
- */
-export declare function readFrozenAttemptAttachmentProjection<Value>(input: {
-    readonly view: FrozenRecordView<RecordReaderReadError>;
-    readonly attempt: FrozenRecordAttempt;
-    readonly projector: RecordAttachmentProjector<"attempt", Value>;
-}): Effect.Effect<ProjectedRecordAttachmentResult<Value>, RecordReaderReadError>;
-/**
- * Resolves one carried slot from its exact source Attempt. A current nonterminal
- * or unreadable Verdict is a typed failure, never a fake legacy result.
- */
 export declare function readCurrentReusedAttempt(input: {
-    readonly view: FrozenRecordView<RecordReaderReadError>;
+    readonly reader: RecordReadSession;
     readonly slot: ReusePlanSlot;
 }): Effect.Effect<CurrentReusedAttemptReadback, RecordReaderReadError | CurrentReuseReadbackPlanInvalid>;
-/** Reads a policy-declined source for dry explanation without turning it into a carry. */
 export declare function readCurrentReuseCandidate(input: {
-    readonly view: FrozenRecordView<RecordReaderReadError>;
+    readonly reader: RecordReadSession;
     readonly slot: Extract<ExecutionReusePlan["slots"][number], {
         readonly state: "gap";
     }>;
 }): Effect.Effect<CurrentReuseCandidateReadback | undefined, RecordReaderReadError | CurrentReuseReadbackPlanInvalid>;
-/**
- * Resolves all current readbacks in stable target order. This is for dry/readback
- * consumers; runtime carries use the narrower `readCurrentExecutionReusePlanResults`.
- */
 export declare function readCurrentExecutionReusePlanReadbacks(input: {
-    readonly view: FrozenRecordView<RecordReaderReadError>;
+    readonly reader: RecordReadSession;
     readonly plan: ExecutionReusePlan;
 }): Effect.Effect<readonly CurrentReuseReadback[], RecordReaderReadError | CurrentReuseReadbackPlanInvalid>;
-/** Resolves only scheduler-authorized carries in the planner's stable target order. */
 export declare function readCurrentExecutionReusePlanResults(input: {
-    readonly view: FrozenRecordView<RecordReaderReadError>;
+    readonly reader: RecordReadSession;
     readonly plan: ExecutionReusePlan;
 }): Effect.Effect<readonly CurrentReusedAttemptReadback[], RecordReaderReadError | CurrentReuseReadbackPlanInvalid>;
-/** Removes the scoped frozen capability before handing a current projection to a longer-lived consumer. */
 export declare function projectCurrentReuseReadback(readback: CurrentReuseReadback): CurrentReuseReadbackSnapshot;
 export declare function projectCurrentReusedAttemptReadback(readback: CurrentReusedAttemptReadback): CurrentReusedAttemptSnapshot;
 export declare function projectCurrentReuseCandidateReadback(readback: CurrentReuseCandidateReadback): CurrentReuseCandidateSnapshot;

package/dist/runner/reuse-readback.d.mts

@@ -1,38 +1,47 @@
 import { Effect } from "effect";
-import { type ProjectedRecordAttachmentResult } from "../projection/attachment-result.mjs";
-import { type RecordAttachmentProjector } from "../projection/projector.mjs";
 import type { RecordIssue } from "../record/errors/record-errors.mjs";
+import type { RecordReadSession, SelectedAttemptRef } from "../record/host/types.mjs";
 import type { RecordReaderReadError } from "../record/reader/errors.mjs";
-import type { FrozenRecordAttempt, FrozenRecordView } from "../record/reader/types.mjs";
-import { type Score } from "../eval/record/score.mjs";
 import type { Verdict } from "../shared/types.mjs";
-import type { ExecutionReusePlan, ExecutionReusePlanSource, ReusePlanSlot, TargetSlot } from "./reuse-plan.mjs";
-/**
- * A carry is a current projection of a frozen source Attempt, not a recreated
- * legacy EvalResult. The exact source capability stays scoped to the reader.
- */
+import { type ExecutionReusePlan, type ExecutionReusePlanSource, type ReusePlanSlot, type TargetSlot } from "./reuse-plan.mjs";
+/** Fixed-family read states remain visible; a readback never invents a result file. */
+export type CurrentRecordRead<Value> = {
+    readonly state: "available";
+    readonly value: Value;
+} | {
+    readonly state: "not-recorded";
+} | {
+    readonly state: "migration-required";
+    readonly family: string;
+    readonly fromSchemaVersion: number;
+    readonly toSchemaVersion: number;
+    readonly command: "niceeval migrate";
+} | {
+    readonly state: "unsupported";
+    readonly family: string;
+    readonly schemaVersion: number;
+} | {
+    readonly state: "invalid";
+    readonly issues: readonly RecordIssue[];
+};
 export interface CurrentReusedAttemptReadback {
     readonly state: "reused";
     readonly target: CurrentReusedAttemptTarget;
     readonly source: CurrentReusedAttemptSource;
-    /** Reuse is fail-closed unless the current Verdict is a reusable terminal fact. */
     readonly verdict: "passed" | "failed";
     readonly score: CurrentReusedAttemptScore;
-    readonly executionErrors: ProjectedRecordAttachmentResult<readonly CurrentReusedExecutionError[]>;
+    readonly executionErrors: CurrentRecordRead<readonly CurrentReusedExecutionError[]>;
 }
-/** A gap's observed current source. It explains dry output but never authorizes reuse. */
 export interface CurrentReuseCandidateReadback {
     readonly state: "prior";
     readonly target: CurrentReusedAttemptTarget;
     readonly source: CurrentReusedAttemptSource;
-    readonly verdict: ProjectedRecordAttachmentResult<Verdict>;
+    readonly verdict: CurrentRecordRead<Verdict>;
     readonly score: CurrentReusedAttemptScore;
-    readonly executionErrors: ProjectedRecordAttachmentResult<readonly CurrentReusedExecutionError[]>;
-    /** Origin Run's current Sources projection, retained only as a projection. */
+    readonly executionErrors: CurrentRecordRead<readonly CurrentReusedExecutionError[]>;
     readonly sourceFiles: CurrentReuseSourceFiles;
 }
 export type CurrentReuseReadback = CurrentReusedAttemptReadback | CurrentReuseCandidateReadback;
-/** The target identity needed by runtime and dry output, without old result fields. */
 export interface CurrentReusedAttemptTarget {
     readonly runId: TargetSlot["runId"];
     readonly slotId: TargetSlot["slotId"];
@@ -40,27 +49,26 @@ export interface CurrentReusedAttemptTarget {
     readonly evalId: TargetSlot["evalId"];
     readonly attempt: TargetSlot["attempt"];
 }
-/** The exact current source authority. It is never reconstructed from an id string. */
 export interface CurrentReusedAttemptSource {
-    readonly attempt: FrozenRecordAttempt;
+    readonly attempt: SelectedAttemptRef;
     readonly attemptId: ExecutionReusePlanSource["attemptId"];
     readonly origin: ExecutionReusePlanSource["origin"];
     readonly sourceBarrier: ExecutionReusePlanSource["sourceBarrier"];
     readonly evaluationKind: ExecutionReusePlanSource["evaluationKind"];
 }
-/** Score exists only for a Score Eval; an absent Score is not an invented zero. */
 export type CurrentReusedAttemptScore = {
     readonly state: "not-applicable";
 } | {
     readonly state: "applicable";
-    readonly attachment: ProjectedRecordAttachmentResult<Score>;
+    readonly attachment: CurrentRecordRead<{
+        readonly state: "complete" | "partial" | "unavailable";
+        readonly earned?: number;
+    }>;
 };
-/** Durable diagnostic facts normalized before entering the runner/readback ABI. */
 export interface CurrentReusedExecutionCause {
     readonly code: string;
     readonly summary: string;
 }
-/** The display-safe execution-error subset of the current diagnostics projection. */
 export interface CurrentReusedExecutionError {
     readonly kind: "execution-error";
     readonly code: string;
@@ -72,22 +80,18 @@ export interface CurrentReuseSourceFile {
     readonly path: string;
     readonly sha256: string;
 }
-/** Source files retain every projection/read state instead of guessing historic inputs. */
-export type CurrentReuseSourceFiles = ProjectedRecordAttachmentResult<readonly CurrentReuseSourceFile[]> | {
+export type CurrentReuseSourceFiles = CurrentRecordRead<readonly CurrentReuseSourceFile[]> | {
     readonly state: "origin-run-missing";
 } | {
     readonly state: "origin-run-invalid";
     readonly issues: readonly RecordIssue[];
+} | {
+    readonly state: "projection-invalid";
 };
-/** A forged or internally inconsistent plan/readback must never produce a carry. */
 export interface CurrentReuseReadbackPlanInvalid {
     readonly code: "current-reuse-readback-plan-invalid";
-    readonly reason: "source-attempt-id-mismatch" | "source-origin-run-mismatch" | "source-evaluation-kind-invalid" | "source-verdict-unavailable" | "source-verdict-ineligible";
+    readonly reason: "source-attempt-unavailable" | "source-verdict-unavailable" | "source-verdict-ineligible";
 }
-/**
- * A self-contained source identity suitable outside a FrozenRecordView Scope.
- * It deliberately omits the opaque Attempt capability.
- */
 export interface CurrentReusedAttemptSourceSnapshot {
     readonly attemptId: string;
     readonly locator: string;
@@ -101,6 +105,13 @@ export interface CurrentReusedAttemptSourceSnapshot {
     };
     readonly evaluationKind: CurrentReusedAttemptSource["evaluationKind"];
 }
+export interface CurrentReusedAttemptTargetSnapshot {
+    readonly runId: string;
+    readonly slotId: string;
+    readonly experimentId: string;
+    readonly evalId: string;
+    readonly attempt: number;
+}
 export interface CurrentReusedAttemptSnapshot {
     readonly state: "reused";
     readonly target: CurrentReusedAttemptTargetSnapshot;
@@ -115,55 +126,28 @@ export interface CurrentReuseCandidateSnapshot {
     readonly source: CurrentReusedAttemptSourceSnapshot;
     readonly verdict: CurrentReuseCandidateReadback["verdict"];
     readonly score: CurrentReusedAttemptScore;
-    readonly executionErrors: CurrentReuseCandidateReadback["executionErrors"];
+    readonly executionErrors: CurrentReusedAttemptReadback["executionErrors"];
     readonly sourceFiles: CurrentReuseSourceFiles;
 }
 export type CurrentReuseReadbackSnapshot = CurrentReusedAttemptSnapshot | CurrentReuseCandidateSnapshot;
-export interface CurrentReusedAttemptTargetSnapshot {
-    readonly runId: string;
-    readonly slotId: string;
-    readonly experimentId: string;
-    readonly evalId: string;
-    readonly attempt: number;
-}
-/**
- * Reads one typed Attachment from the current frozen view and preserves every
- * durable read state. This never opens a path or reaches into retired graph/evidence data.
- */
-export declare function readFrozenAttemptAttachmentProjection<Value>(input: {
-    readonly view: FrozenRecordView<RecordReaderReadError>;
-    readonly attempt: FrozenRecordAttempt;
-    readonly projector: RecordAttachmentProjector<"attempt", Value>;
-}): Effect.Effect<ProjectedRecordAttachmentResult<Value>, RecordReaderReadError>;
-/**
- * Resolves one carried slot from its exact source Attempt. A current nonterminal
- * or unreadable Verdict is a typed failure, never a fake legacy result.
- */
 export declare function readCurrentReusedAttempt(input: {
-    readonly view: FrozenRecordView<RecordReaderReadError>;
+    readonly reader: RecordReadSession;
     readonly slot: ReusePlanSlot;
 }): Effect.Effect<CurrentReusedAttemptReadback, RecordReaderReadError | CurrentReuseReadbackPlanInvalid>;
-/** Reads a policy-declined source for dry explanation without turning it into a carry. */
 export declare function readCurrentReuseCandidate(input: {
-    readonly view: FrozenRecordView<RecordReaderReadError>;
+    readonly reader: RecordReadSession;
     readonly slot: Extract<ExecutionReusePlan["slots"][number], {
         readonly state: "gap";
     }>;
 }): Effect.Effect<CurrentReuseCandidateReadback | undefined, RecordReaderReadError | CurrentReuseReadbackPlanInvalid>;
-/**
- * Resolves all current readbacks in stable target order. This is for dry/readback
- * consumers; runtime carries use the narrower `readCurrentExecutionReusePlanResults`.
- */
 export declare function readCurrentExecutionReusePlanReadbacks(input: {
-    readonly view: FrozenRecordView<RecordReaderReadError>;
+    readonly reader: RecordReadSession;
     readonly plan: ExecutionReusePlan;
 }): Effect.Effect<readonly CurrentReuseReadback[], RecordReaderReadError | CurrentReuseReadbackPlanInvalid>;
-/** Resolves only scheduler-authorized carries in the planner's stable target order. */
 export declare function readCurrentExecutionReusePlanResults(input: {
-    readonly view: FrozenRecordView<RecordReaderReadError>;
+    readonly reader: RecordReadSession;
     readonly plan: ExecutionReusePlan;
 }): Effect.Effect<readonly CurrentReusedAttemptReadback[], RecordReaderReadError | CurrentReuseReadbackPlanInvalid>;
-/** Removes the scoped frozen capability before handing a current projection to a longer-lived consumer. */
 export declare function projectCurrentReuseReadback(readback: CurrentReuseReadback): CurrentReuseReadbackSnapshot;
 export declare function projectCurrentReusedAttemptReadback(readback: CurrentReusedAttemptReadback): CurrentReusedAttemptSnapshot;
 export declare function projectCurrentReuseCandidateReadback(readback: CurrentReuseCandidateReadback): CurrentReuseCandidateSnapshot;

package/dist/runner/reuse-readback.d.ts

@@ -1,38 +1,47 @@
 import { Effect } from "effect";
-import { type ProjectedRecordAttachmentResult } from "../projection/attachment-result.js";
-import { type RecordAttachmentProjector } from "../projection/projector.js";
 import type { RecordIssue } from "../record/errors/record-errors.js";
+import type { RecordReadSession, SelectedAttemptRef } from "../record/host/types.js";
 import type { RecordReaderReadError } from "../record/reader/errors.js";
-import type { FrozenRecordAttempt, FrozenRecordView } from "../record/reader/types.js";
-import { type Score } from "../eval/record/score.js";
 import type { Verdict } from "../shared/types.js";
-import type { ExecutionReusePlan, ExecutionReusePlanSource, ReusePlanSlot, TargetSlot } from "./reuse-plan.js";
-/**
- * A carry is a current projection of a frozen source Attempt, not a recreated
- * legacy EvalResult. The exact source capability stays scoped to the reader.
- */
+import { type ExecutionReusePlan, type ExecutionReusePlanSource, type ReusePlanSlot, type TargetSlot } from "./reuse-plan.js";
+/** Fixed-family read states remain visible; a readback never invents a result file. */
+export type CurrentRecordRead<Value> = {
+    readonly state: "available";
+    readonly value: Value;
+} | {
+    readonly state: "not-recorded";
+} | {
+    readonly state: "migration-required";
+    readonly family: string;
+    readonly fromSchemaVersion: number;
+    readonly toSchemaVersion: number;
+    readonly command: "niceeval migrate";
+} | {
+    readonly state: "unsupported";
+    readonly family: string;
+    readonly schemaVersion: number;
+} | {
+    readonly state: "invalid";
+    readonly issues: readonly RecordIssue[];
+};
 export interface CurrentReusedAttemptReadback {
     readonly state: "reused";
     readonly target: CurrentReusedAttemptTarget;
     readonly source: CurrentReusedAttemptSource;
-    /** Reuse is fail-closed unless the current Verdict is a reusable terminal fact. */
     readonly verdict: "passed" | "failed";
     readonly score: CurrentReusedAttemptScore;
-    readonly executionErrors: ProjectedRecordAttachmentResult<readonly CurrentReusedExecutionError[]>;
+    readonly executionErrors: CurrentRecordRead<readonly CurrentReusedExecutionError[]>;
 }
-/** A gap's observed current source. It explains dry output but never authorizes reuse. */
 export interface CurrentReuseCandidateReadback {
     readonly state: "prior";
     readonly target: CurrentReusedAttemptTarget;
     readonly source: CurrentReusedAttemptSource;
-    readonly verdict: ProjectedRecordAttachmentResult<Verdict>;
+    readonly verdict: CurrentRecordRead<Verdict>;
     readonly score: CurrentReusedAttemptScore;
-    readonly executionErrors: ProjectedRecordAttachmentResult<readonly CurrentReusedExecutionError[]>;
-    /** Origin Run's current Sources projection, retained only as a projection. */
+    readonly executionErrors: CurrentRecordRead<readonly CurrentReusedExecutionError[]>;
     readonly sourceFiles: CurrentReuseSourceFiles;
 }
 export type CurrentReuseReadback = CurrentReusedAttemptReadback | CurrentReuseCandidateReadback;
-/** The target identity needed by runtime and dry output, without old result fields. */
 export interface CurrentReusedAttemptTarget {
     readonly runId: TargetSlot["runId"];
     readonly slotId: TargetSlot["slotId"];
@@ -40,27 +49,26 @@ export interface CurrentReusedAttemptTarget {
     readonly evalId: TargetSlot["evalId"];
     readonly attempt: TargetSlot["attempt"];
 }
-/** The exact current source authority. It is never reconstructed from an id string. */
 export interface CurrentReusedAttemptSource {
-    readonly attempt: FrozenRecordAttempt;
+    readonly attempt: SelectedAttemptRef;
     readonly attemptId: ExecutionReusePlanSource["attemptId"];
     readonly origin: ExecutionReusePlanSource["origin"];
     readonly sourceBarrier: ExecutionReusePlanSource["sourceBarrier"];
     readonly evaluationKind: ExecutionReusePlanSource["evaluationKind"];
 }
-/** Score exists only for a Score Eval; an absent Score is not an invented zero. */
 export type CurrentReusedAttemptScore = {
     readonly state: "not-applicable";
 } | {
     readonly state: "applicable";
-    readonly attachment: ProjectedRecordAttachmentResult<Score>;
+    readonly attachment: CurrentRecordRead<{
+        readonly state: "complete" | "partial" | "unavailable";
+        readonly earned?: number;
+    }>;
 };
-/** Durable diagnostic facts normalized before entering the runner/readback ABI. */
 export interface CurrentReusedExecutionCause {
     readonly code: string;
     readonly summary: string;
 }
-/** The display-safe execution-error subset of the current diagnostics projection. */
 export interface CurrentReusedExecutionError {
     readonly kind: "execution-error";
     readonly code: string;
@@ -72,22 +80,18 @@ export interface CurrentReuseSourceFile {
     readonly path: string;
     readonly sha256: string;
 }
-/** Source files retain every projection/read state instead of guessing historic inputs. */
-export type CurrentReuseSourceFiles = ProjectedRecordAttachmentResult<readonly CurrentReuseSourceFile[]> | {
+export type CurrentReuseSourceFiles = CurrentRecordRead<readonly CurrentReuseSourceFile[]> | {
     readonly state: "origin-run-missing";
 } | {
     readonly state: "origin-run-invalid";
     readonly issues: readonly RecordIssue[];
+} | {
+    readonly state: "projection-invalid";
 };
-/** A forged or internally inconsistent plan/readback must never produce a carry. */
 export interface CurrentReuseReadbackPlanInvalid {
     readonly code: "current-reuse-readback-plan-invalid";
-    readonly reason: "source-attempt-id-mismatch" | "source-origin-run-mismatch" | "source-evaluation-kind-invalid" | "source-verdict-unavailable" | "source-verdict-ineligible";
+    readonly reason: "source-attempt-unavailable" | "source-verdict-unavailable" | "source-verdict-ineligible";
 }
-/**
- * A self-contained source identity suitable outside a FrozenRecordView Scope.
- * It deliberately omits the opaque Attempt capability.
- */
 export interface CurrentReusedAttemptSourceSnapshot {
     readonly attemptId: string;
     readonly locator: string;
@@ -101,6 +105,13 @@ export interface CurrentReusedAttemptSourceSnapshot {
     };
     readonly evaluationKind: CurrentReusedAttemptSource["evaluationKind"];
 }
+export interface CurrentReusedAttemptTargetSnapshot {
+    readonly runId: string;
+    readonly slotId: string;
+    readonly experimentId: string;
+    readonly evalId: string;
+    readonly attempt: number;
+}
 export interface CurrentReusedAttemptSnapshot {
     readonly state: "reused";
     readonly target: CurrentReusedAttemptTargetSnapshot;
@@ -115,55 +126,28 @@ export interface CurrentReuseCandidateSnapshot {
     readonly source: CurrentReusedAttemptSourceSnapshot;
     readonly verdict: CurrentReuseCandidateReadback["verdict"];
     readonly score: CurrentReusedAttemptScore;
-    readonly executionErrors: CurrentReuseCandidateReadback["executionErrors"];
+    readonly executionErrors: CurrentReusedAttemptReadback["executionErrors"];
     readonly sourceFiles: CurrentReuseSourceFiles;
 }
 export type CurrentReuseReadbackSnapshot = CurrentReusedAttemptSnapshot | CurrentReuseCandidateSnapshot;
-export interface CurrentReusedAttemptTargetSnapshot {
-    readonly runId: string;
-    readonly slotId: string;
-    readonly experimentId: string;
-    readonly evalId: string;
-    readonly attempt: number;
-}
-/**
- * Reads one typed Attachment from the current frozen view and preserves every
- * durable read state. This never opens a path or reaches into retired graph/evidence data.
- */
-export declare function readFrozenAttemptAttachmentProjection<Value>(input: {
-    readonly view: FrozenRecordView<RecordReaderReadError>;
-    readonly attempt: FrozenRecordAttempt;
-    readonly projector: RecordAttachmentProjector<"attempt", Value>;
-}): Effect.Effect<ProjectedRecordAttachmentResult<Value>, RecordReaderReadError>;
-/**
- * Resolves one carried slot from its exact source Attempt. A current nonterminal
- * or unreadable Verdict is a typed failure, never a fake legacy result.
- */
 export declare function readCurrentReusedAttempt(input: {
-    readonly view: FrozenRecordView<RecordReaderReadError>;
+    readonly reader: RecordReadSession;
     readonly slot: ReusePlanSlot;
 }): Effect.Effect<CurrentReusedAttemptReadback, RecordReaderReadError | CurrentReuseReadbackPlanInvalid>;
-/** Reads a policy-declined source for dry explanation without turning it into a carry. */
 export declare function readCurrentReuseCandidate(input: {
-    readonly view: FrozenRecordView<RecordReaderReadError>;
+    readonly reader: RecordReadSession;
     readonly slot: Extract<ExecutionReusePlan["slots"][number], {
         readonly state: "gap";
     }>;
 }): Effect.Effect<CurrentReuseCandidateReadback | undefined, RecordReaderReadError | CurrentReuseReadbackPlanInvalid>;
-/**
- * Resolves all current readbacks in stable target order. This is for dry/readback
- * consumers; runtime carries use the narrower `readCurrentExecutionReusePlanResults`.
- */
 export declare function readCurrentExecutionReusePlanReadbacks(input: {
-    readonly view: FrozenRecordView<RecordReaderReadError>;
+    readonly reader: RecordReadSession;
     readonly plan: ExecutionReusePlan;
 }): Effect.Effect<readonly CurrentReuseReadback[], RecordReaderReadError | CurrentReuseReadbackPlanInvalid>;
-/** Resolves only scheduler-authorized carries in the planner's stable target order. */
 export declare function readCurrentExecutionReusePlanResults(input: {
-    readonly view: FrozenRecordView<RecordReaderReadError>;
+    readonly reader: RecordReadSession;
     readonly plan: ExecutionReusePlan;
 }): Effect.Effect<readonly CurrentReusedAttemptReadback[], RecordReaderReadError | CurrentReuseReadbackPlanInvalid>;
-/** Removes the scoped frozen capability before handing a current projection to a longer-lived consumer. */
 export declare function projectCurrentReuseReadback(readback: CurrentReuseReadback): CurrentReuseReadbackSnapshot;
 export declare function projectCurrentReusedAttemptReadback(readback: CurrentReusedAttemptReadback): CurrentReusedAttemptSnapshot;
 export declare function projectCurrentReuseCandidateReadback(readback: CurrentReuseCandidateReadback): CurrentReuseCandidateSnapshot;

package/dist/runner/reuse-readback.js

@@ -15,6 +15,4 @@ const __niceevalExport5 = __niceevalCanonical["readCurrentReuseCandidate"];
 export { __niceevalExport5 as readCurrentReuseCandidate };
 const __niceevalExport6 = __niceevalCanonical["readCurrentReusedAttempt"];
 export { __niceevalExport6 as readCurrentReusedAttempt };
-const __niceevalExport7 = __niceevalCanonical["readFrozenAttemptAttachmentProjection"];
-export { __niceevalExport7 as readFrozenAttemptAttachmentProjection };
 //# sourceMappingURL=reuse-readback.js.map