niceeval 0.12.2-canary.31 → 0.13.0

package/dist/runner/adoption.cjs

@@ -1,79 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExplicitAdoptionErrorV1 = exports.ADOPTION_CONFIG_IDENTITY_DOMAIN_V1 = exports.ADOPTION_INPUT_IDENTITY_DOMAIN_V1 = exports.EXPLICIT_ADOPTION_POLICY_VERSION_V1 = exports.EXPLICIT_ADOPTION_POLICY_NAME_V1 = void 0;
-exports.mapExplicitAdoptionCommitFailureV1 = mapExplicitAdoptionCommitFailureV1;
-exports.parseExplicitAttemptLocatorV1 = parseExplicitAttemptLocatorV1;
-exports.adoptionRecordRootV1 = adoptionRecordRootV1;
-exports.loadAdoptionProjectV1 = loadAdoptionProjectV1;
-exports.prepareCurrentAdoptionTargetV1 = prepareCurrentAdoptionTargetV1;
-exports.resolveExplicitAttemptLocatorV1 = resolveExplicitAttemptLocatorV1;
-exports.resolveAdoptionAttemptV1 = resolveAdoptionAttemptV1;
-exports.readAdoptionVerdictV1 = readAdoptionVerdictV1;
-exports.readAdoptionEligibilityV1 = readAdoptionEligibilityV1;
-exports.prepareExplicitAdoptionMemberV1 = prepareExplicitAdoptionMemberV1;
-exports.buildExplicitAdoptionRunPlanV1 = buildExplicitAdoptionRunPlanV1;
-exports.commitExplicitAdoptionRunPlansV1 = commitExplicitAdoptionRunPlansV1;
-exports.createExplicitAdoptionInvocationIdV1 = createExplicitAdoptionInvocationIdV1;
-exports.adoptionStartedAtV1 = adoptionStartedAtV1;
-exports.withAdoptionReaderV1 = withAdoptionReaderV1;
-exports.withAdoptionWriteSessionV1 = withAdoptionWriteSessionV1;
-exports.resolveRenameSourceRunV1 = resolveRenameSourceRunV1;
-exports.prepareRenameAdoptionMembersV1 = prepareRenameAdoptionMembersV1;
+exports.ExplicitAdoptionError = exports.ADOPTION_CONFIG_IDENTITY_DOMAIN = exports.ADOPTION_INPUT_IDENTITY_DOMAIN = void 0;
+exports.parseExplicitAttemptLocator = parseExplicitAttemptLocator;
+exports.adoptionRecordRoot = adoptionRecordRoot;
+exports.loadAdoptionProject = loadAdoptionProject;
+exports.prepareCurrentAdoptionTarget = prepareCurrentAdoptionTarget;
+exports.resolveExplicitAttemptLocator = resolveExplicitAttemptLocator;
+exports.resolveAdoptionAttempt = resolveAdoptionAttempt;
+exports.readAdoptionAttemptFacts = readAdoptionAttemptFacts;
+exports.readAdoptionVerdict = readAdoptionVerdict;
+exports.readAdoptionExecutionDuration = readAdoptionExecutionDuration;
+exports.prepareExplicitAdoptionMember = prepareExplicitAdoptionMember;
+exports.buildExplicitAdoptionRunPlan = buildExplicitAdoptionRunPlan;
+exports.commitExplicitAdoptionRunPlans = commitExplicitAdoptionRunPlans;
+exports.createExplicitAdoptionInvocationId = createExplicitAdoptionInvocationId;
+exports.adoptionStartedAt = adoptionStartedAt;
+exports.withAdoptionReader = withAdoptionReader;
+exports.withAdoptionCommitScope = withAdoptionCommitScope;
+exports.resolveRenameSourceRun = resolveRenameSourceRun;
+exports.prepareRenameAdoptionMembers = prepareRenameAdoptionMembers;
 const node_crypto_1 = require("node:crypto");
 const node_path_1 = require("node:path");
 const effect_1 = require("effect");
 const attempt_locator_ts_1 = require("../attempt-locator.cjs");
 const attempt_locator_resolution_ts_1 = require("../attempt-locator-resolution.cjs");
-const evaluation_ts_1 = require("../eval/record/evaluation.cjs");
-const evaluation_record_ts_1 = require("../eval/record/evaluation-record.cjs");
 const eligibility_ts_1 = require("../eval/record/eligibility.cjs");
-const membership_provenance_ts_1 = require("../eval/record/membership-provenance.cjs");
 const verdict_ts_1 = require("../eval/record/verdict.cjs");
 const load_config_ts_1 = require("../load-config.cjs");
+const runtime_ts_1 = require("../record/host/runtime.cjs");
 const identifiers_ts_1 = require("../record/codec/identifiers.cjs");
+const run_context_ts_1 = require("../record/model/run-context.cjs");
 const root_ts_1 = require("../record/platform/root.cjs");
-const internal_ts_1 = require("../record/reader/internal.cjs");
-const runtime_ts_1 = require("../record/reader/runtime.cjs");
-const runtime_ts_2 = require("../record/writer/runtime.cjs");
-const identity_ts_1 = require("../sandbox/identity.cjs");
-const config_identity_ts_1 = require("./config-identity.cjs");
 const discover_ts_1 = require("./discover.cjs");
 const eval_selection_ts_1 = require("./eval-selection.cjs");
+const execution_identity_ts_1 = require("./execution-identity.cjs");
 const fingerprint_ts_1 = require("./fingerprint.cjs");
-const judge_config_ts_1 = require("./judge-config.cjs");
 const sandbox_selection_ts_1 = require("./sandbox-selection.cjs");
 const timeout_ts_1 = require("./timeout.cjs");
-/** The sole manual-adoption policy identity persisted by the v1 migration. */
-exports.EXPLICIT_ADOPTION_POLICY_NAME_V1 = "explicit-adoption";
-exports.EXPLICIT_ADOPTION_POLICY_VERSION_V1 = 1;
 /** Shared domains emitted by the current ProjectTarget producer. */
-exports.ADOPTION_INPUT_IDENTITY_DOMAIN_V1 = "niceeval.input/fingerprint-v1";
-exports.ADOPTION_CONFIG_IDENTITY_DOMAIN_V1 = "niceeval.config/identity-v1";
+exports.ADOPTION_INPUT_IDENTITY_DOMAIN = "niceeval.input/fingerprint-v1";
+exports.ADOPTION_CONFIG_IDENTITY_DOMAIN = "niceeval.config/identity-v1";
 const ADOPTION_TARGET_SLOT_SEPARATOR = "\u0000";
 /** Expected product failures retain a stable code without collapsing Effect causes. */
-class ExplicitAdoptionErrorV1 extends Error {
+class ExplicitAdoptionError extends Error {
     code;
-    name = "ExplicitAdoptionErrorV1";
+    name = "ExplicitAdoptionError";
     constructor(code, message) {
         super(message);
         this.code = code;
     }
 }
-exports.ExplicitAdoptionErrorV1 = ExplicitAdoptionErrorV1;
-/**
- * A plan-token failure is still a domain preflight failure when observed on
- * the session's second frozen view. Real writer/publish failures remain their
- * exact RecordWriteError so callers can report an already-published prefix.
- */
-function mapExplicitAdoptionCommitFailureV1(error) {
-    if (error.code === "evaluation-record-plan-invalid"
-        || error.code === "evaluation-record-origin-draft-missing") {
-        return adoptionError("adoption-evaluation-plan-invalid", "Explicit adoption's already-preflighted Evaluation Record plan became invalid before publication.");
-    }
-    return error;
-}
+exports.ExplicitAdoptionError = ExplicitAdoptionError;
 function adoptionError(code, message) {
-    return new ExplicitAdoptionErrorV1(code, message);
+    return new ExplicitAdoptionError(code, message);
 }
 function safeMessage(cause) {
     return cause instanceof Error ? cause.message : String(cause);
@@ -93,15 +72,12 @@ function utcMillis(value) {
 function slotKey(evalId, attempt) {
     return `${evalId}${ADOPTION_TARGET_SLOT_SEPARATOR}${String(attempt)}`;
 }
-function sameAttemptReference(left, right) {
-    return left.originRunId === right.originRunId && left.attemptId === right.attemptId;
-}
 function attemptLocatorFor(attemptId) {
     const locator = (0, attempt_locator_ts_1.encodeAttemptLocator)(attemptId);
-    return effect_1.Effect.succeed(Object.freeze({ text: locator, locator, attemptId }));
+    return Object.freeze({ text: locator, locator, attemptId });
 }
 /** Strict v1 parser accepts only the current canonical short locator. */
-function parseExplicitAttemptLocatorV1(value) {
+function parseExplicitAttemptLocator(value) {
     const parsed = (0, attempt_locator_ts_1.parseAttemptLocator)(value);
     if (!parsed.valid) {
         return effect_1.Effect.fail(adoptionError("adoption-locator-malformed", "An explicit adoption locator must match @1 followed by 12 canonical uppercase Crockford characters."));
@@ -109,12 +85,12 @@ function parseExplicitAttemptLocatorV1(value) {
     return effect_1.Effect.succeed(Object.freeze({ text: value, locator: parsed.locator }));
 }
 /** The public application boundary owns Record-root construction. */
-function adoptionRecordRootV1(input) {
+function adoptionRecordRoot(input) {
     const root = (0, root_ts_1.makeRecordRoot)((0, node_path_1.resolve)(input.cwd, input.recordRoot ?? ".niceeval/record"));
     return effect_1.Either.isLeft(root) ? effect_1.Effect.fail(root.left) : effect_1.Effect.succeed(root.right);
 }
 /** Discovery is rerun for both read preflight and the write-session frozen view. */
-function loadAdoptionProjectV1(input) {
+function loadAdoptionProject(input) {
     return effect_1.Effect.gen(function* () {
         const cwd = (0, node_path_1.resolve)(input.cwd);
         const config = input.config ?? (yield* effect_1.Effect.tryPromise({
@@ -170,15 +146,43 @@ function runForExperiment(experiment, selectedEvalIds) {
             : { classifyFailure: experiment.classifyFailure }),
     });
 }
-function sortedSlots(slots) {
-    return Object.freeze([...slots].sort((left, right) => left < right ? -1 : left > right ? 1 : 0));
-}
-function asNonEmptySlots(slots) {
-    const [first, ...rest] = slots;
-    return first === undefined ? undefined : Object.freeze([first, ...rest]);
+function adoptionRunContext(run) {
+    const context = (0, run_context_ts_1.canonicalizeRunContext)({
+        experimentId: run.experimentId,
+        execution: {
+            agentId: run.agent.name,
+            model: run.model ?? null,
+            reasoningEffort: run.reasoningEffort ?? null,
+            flags: run.flags,
+        },
+        labels: run.labels ?? {},
+    });
+    return effect_1.Either.isLeft(context)
+        ? effect_1.Either.left(adoptionError("adoption-target-invalid", `Run Context for "${run.experimentId}" is invalid.`))
+        : effect_1.Either.right(context.right);
 }
-function currentTargetSlotId(input) {
-    return decodeBrandedId(identifiers_ts_1.SlotIdSchema, `slot-${(0, identity_ts_1.digestOf)(input)}`, "adoption-target-invalid", "Adoption target Slot");
+function currentTargetSlotIdentity(input) {
+    return effect_1.Effect.gen(function* () {
+        const digestValue = (0, execution_identity_ts_1.slotExecutionIdentityDigestHex)({
+            experimentId: input.experimentId,
+            evalId: input.evalId,
+            attempt: input.attempt,
+            input: input.inputIdentity,
+            config: input.configIdentity,
+            timeout: input.timeout === undefined
+                ? null
+                : { domain: input.timeout.domain, milliseconds: input.timeout.milliseconds },
+        });
+        const digest = yield* decodeBrandedId(identifiers_ts_1.ExecutionIdentityDigestSchema, digestValue, "adoption-target-invalid", "Adoption target execution identity");
+        const evalId = yield* decodeBrandedId(identifiers_ts_1.EvalIdSchema, input.evalId, "adoption-target-invalid", "Adoption target Eval");
+        const slotId = yield* decodeBrandedId(identifiers_ts_1.SlotIdSchema, `slot-${digest}`, "adoption-target-invalid", "Adoption target Slot");
+        return Object.freeze({
+            slotId,
+            evalId,
+            attemptOrdinal: input.attempt,
+            executionIdentityDigest: digest,
+        });
+    });
 }
 /**
  * Rebuilds current discovery, physical planning, config identity and timeout
@@ -186,7 +190,7 @@ function currentTargetSlotId(input) {
  * a produced Run has the complete current denominator rather than only the
  * manually adopted Members.
  */
-function prepareCurrentAdoptionTargetV1(input) {
+function prepareCurrentAdoptionTarget(input) {
     return effect_1.Effect.gen(function* () {
         const experiment = input.project.experiments.find((candidate) => candidate.id === input.experimentId);
         if (experiment === undefined) {
@@ -205,44 +209,45 @@ function prepareCurrentAdoptionTargetV1(input) {
             return yield* effect_1.Effect.fail(adoptionError("adoption-target-invalid", `Current Experiment "${experiment.id}" has no selectable target Slots.`));
         }
         const run = runForExperiment(experiment, selection.selectedEvalIds);
+        const context = yield* adoptionRunContext(run);
         const pairs = yield* (0, sandbox_selection_ts_1.prepareRunSandboxes)(selection.selectedEvals, [run], input.project.planningServices, { configTimeoutMs: input.project.config.timeoutMs }).pipe(effect_1.Effect.mapError((error) => adoptionError("adoption-target-planning-failed", `Current planning for "${experiment.id}" failed: ${safeMessage(error)}`)));
         if (pairs.length !== selection.selectedEvals.length) {
             return yield* effect_1.Effect.fail(adoptionError("adoption-target-planning-failed", `Current planning for "${experiment.id}" did not return every selected Eval.`));
         }
-        const sourceCache = (0, fingerprint_ts_1.createFingerprintSourceCache)();
-        const plannedPairs = yield* effect_1.Effect.forEach(pairs, (pair) => effect_1.Effect.gen(function* () {
-            const identity = yield* effect_1.Effect.try({
-                try: () => (0, config_identity_ts_1.configIdentityForRun)(run, pair.plan, (0, judge_config_ts_1.resolveJudge)(run.judge, pair.evalDef.judge, input.project.config.judge)),
-                catch: (cause) => adoptionError("adoption-target-invalid", `Current configuration identity for "${pair.evalDef.id}" failed: ${safeMessage(cause)}`),
-            });
-            const fingerprint = yield* (0, fingerprint_ts_1.fingerprintWithManifest)(pair, sourceCache, {
-                _tag: "Current",
-                identity,
-            }).pipe(effect_1.Effect.mapError((cause) => adoptionError("adoption-target-invalid", `Current input identity for "${pair.evalDef.id}" failed: ${safeMessage(cause)}`)));
+        const projectPlan = yield* (0, fingerprint_ts_1.planPreparedProjectTarget)(pairs, {
+            configJudge: input.project.config.judge,
+        }).pipe(effect_1.Effect.mapError((cause) => adoptionError("adoption-target-planning-failed", `Current identity planning for "${experiment.id}" failed: ${safeMessage(cause)}`)));
+        const plannedPairs = [];
+        for (const pair of pairs) {
+            const fingerprint = projectPlan.plannedFingerprints.get(pair.key);
+            const configHash = projectPlan.plannedConfigHashes.get(pair.key);
+            if (fingerprint === undefined || configHash === undefined) {
+                return yield* effect_1.Effect.fail(adoptionError("adoption-target-planning-failed", `Current identity planning omitted Eval "${pair.evalDef.id}".`));
+            }
             const timeout = (0, timeout_ts_1.resolveAttemptTimeout)(run, pair.evalDef, input.project.config);
             if (timeout !== undefined && !Number.isFinite(timeout.timeoutMs)) {
                 return yield* effect_1.Effect.fail(adoptionError("adoption-target-invalid", `Current timeout for "${pair.evalDef.id}" is invalid.`));
             }
-            return Object.freeze({
+            plannedPairs.push(Object.freeze({
                 pair,
                 inputIdentity: Object.freeze({
-                    domain: exports.ADOPTION_INPUT_IDENTITY_DOMAIN_V1,
-                    value: fingerprint.fingerprint,
+                    domain: exports.ADOPTION_INPUT_IDENTITY_DOMAIN,
+                    value: fingerprint,
                 }),
                 configIdentity: Object.freeze({
-                    domain: exports.ADOPTION_CONFIG_IDENTITY_DOMAIN_V1,
-                    value: (0, fingerprint_ts_1.hashConfigIdentity)(identity),
+                    domain: exports.ADOPTION_CONFIG_IDENTITY_DOMAIN,
+                    value: configHash,
                 }),
                 ...(timeout === undefined
                     ? {}
                     : {
                         timeout: Object.freeze({
-                            domain: eligibility_ts_1.EXECUTION_DURATION_DOMAIN_V1,
+                            domain: eligibility_ts_1.EXECUTION_DURATION_DOMAIN,
                             milliseconds: timeout.timeoutMs,
                         }),
                     }),
-            });
-        }), { concurrency: 4 });
+            }));
+        }
         const pairByEval = new Map();
         for (const planned of plannedPairs) {
             if (pairByEval.has(planned.pair.evalDef.id)) {
@@ -251,187 +256,187 @@ function prepareCurrentAdoptionTargetV1(input) {
             pairByEval.set(planned.pair.evalDef.id, planned);
         }
         const slots = [];
-        const slotsByEval = new Map();
         const seenSlots = new Set();
         for (const evalDef of selection.selectedEvals) {
             const planned = pairByEval.get(evalDef.id);
             if (planned === undefined) {
                 return yield* effect_1.Effect.fail(adoptionError("adoption-target-planning-failed", `Current planning omitted selected Eval "${evalDef.id}".`));
             }
-            const evaluationSlots = [];
             for (let attempt = 0; attempt < run.attempts; attempt += 1) {
-                const slotId = yield* currentTargetSlotId({
+                const identity = yield* currentTargetSlotIdentity({
                     experimentId: experiment.id,
                     evalId: evalDef.id,
                     attempt,
+                    inputIdentity: planned.inputIdentity,
+                    configIdentity: planned.configIdentity,
+                    ...(planned.timeout === undefined ? {} : { timeout: planned.timeout }),
                 });
-                if (seenSlots.has(slotId)) {
-                    return yield* effect_1.Effect.fail(adoptionError("adoption-target-slot-duplicate", `Current target produced duplicate Slot "${slotId}".`));
+                if (seenSlots.has(identity.slotId)) {
+                    return yield* effect_1.Effect.fail(adoptionError("adoption-target-slot-duplicate", `Current target produced duplicate Slot "${identity.slotId}".`));
                 }
-                seenSlots.add(slotId);
+                seenSlots.add(identity.slotId);
                 const targetSlot = Object.freeze({
-                    slotId,
+                    slotId: identity.slotId,
                     experimentId: experiment.id,
                     evalId: evalDef.id,
+                    attemptOrdinal: identity.attemptOrdinal,
                     attempt,
                     inputIdentity: planned.inputIdentity,
                     configIdentity: planned.configIdentity,
+                    executionIdentityDigest: identity.executionIdentityDigest,
                     ...(planned.timeout === undefined ? {} : { timeout: planned.timeout }),
                 });
                 slots.push(targetSlot);
-                evaluationSlots.push(Object.freeze({ slotId, attempt }));
             }
-            slotsByEval.set(evalDef.id, Object.freeze(evaluationSlots));
-        }
-        const evaluationDefinitions = [];
-        for (const evalDef of selection.selectedEvals) {
-            const evaluationSlots = slotsByEval.get(evalDef.id);
-            const nonEmpty = evaluationSlots === undefined
-                ? undefined
-                : asNonEmptySlots(evaluationSlots);
-            if (nonEmpty === undefined) {
-                return yield* effect_1.Effect.fail(adoptionError("adoption-target-invalid", `Current target lost all Slots for ${evalDef.id}.`));
-            }
-            evaluationDefinitions.push(Object.freeze({
-                evalId: evalDef.id,
-                evaluationKind: evalDef.evaluationKind,
-                slots: nonEmpty,
-            }));
-        }
-        const evaluationsInput = {
-            experimentId: experiment.id,
-            evaluations: evaluationDefinitions,
-        };
-        const evaluations = (0, evaluation_ts_1.buildEvaluationsPayloadV1)(evaluationsInput);
-        if (effect_1.Either.isLeft(evaluations)) {
-            return yield* effect_1.Effect.fail(adoptionError("adoption-target-invalid", "Current target Evaluation attachment is invalid."));
         }
         const byKey = new Map();
         for (const slot of slots)
-            byKey.set(slotKey(slot.evalId, slot.attempt), slot);
+            byKey.set(slotKey(slot.evalId, slot.attemptOrdinal), slot);
+        const expectedSlots = Object.freeze([...slots]
+            .map((slot) => Object.freeze({
+            slotId: slot.slotId,
+            evalId: effect_1.Schema.decodeUnknownSync(identifiers_ts_1.EvalIdSchema)(slot.evalId),
+            attemptOrdinal: slot.attemptOrdinal,
+            executionIdentityDigest: slot.executionIdentityDigest,
+        }))
+            .sort((left, right) => left.slotId < right.slotId ? -1 : left.slotId > right.slotId ? 1 : 0));
         return Object.freeze({
             experimentId: experiment.id,
             startedAt: input.startedAt,
-            expectedSlots: sortedSlots(slots.map((slot) => slot.slotId)),
-            evaluations: evaluations.right,
+            context,
+            expectedSlots,
             slots: Object.freeze([...slots]),
             slotFor: (evalId, attempt) => byKey.get(slotKey(evalId, attempt)),
         });
     });
 }
-function attachmentUnavailable(subject, read) {
-    const code = subject === "evaluations"
-        ? "adoption-source-evaluations-unavailable"
-        : subject === "verdict"
-            ? "adoption-source-verdict-unavailable"
-            : "adoption-source-eligibility-unavailable";
-    const detail = read.state === "invalid"
-        ? "invalid"
-        : read.state;
-    return adoptionError(code, `Source ${subject} Attachment is ${detail}.`);
-}
 function sourceCoreInvalid(message) {
     return adoptionError("adoption-source-core-invalid", message);
 }
-/** Locates one canonical short locator by scanning only the frozen Record view. */
-function resolveExplicitAttemptLocatorV1(view, text) {
+/** Locates one canonical short locator through the live Record Host session. */
+function resolveExplicitAttemptLocator(reader, text) {
     return effect_1.Effect.gen(function* () {
-        const parsed = yield* parseExplicitAttemptLocatorV1(text);
-        const resolved = yield* (0, attempt_locator_resolution_ts_1.resolveAttemptLocator)(view, parsed.locator).pipe(effect_1.Effect.mapError((error) => error.code === "attempt-locator-view-invalid"
-            ? sourceCoreInvalid("The supplied Record view is not an authentic frozen reader.")
-            : error));
+        const parsed = yield* parseExplicitAttemptLocator(text);
+        const selected = yield* reader.selectRuns();
+        const resolved = yield* (0, attempt_locator_resolution_ts_1.resolveAttemptLocator)({
+            reader,
+            selection: selected,
+            locator: parsed.locator,
+        });
         if (resolved.kind === "not-found") {
             return yield* effect_1.Effect.fail(adoptionError("adoption-locator-not-found", `No published current-Record Attempt matches locator "${parsed.text}".`));
         }
         if (resolved.kind === "ambiguous") {
             return yield* effect_1.Effect.fail(adoptionError("adoption-locator-ambiguous", `Locator "${parsed.text}" resolves to more than one immutable Attempt.`));
         }
-        const ref = resolved.attempt;
-        const attempt = yield* view.attempt(ref);
-        if (attempt.state !== "available") {
-            return yield* effect_1.Effect.fail(sourceCoreInvalid(`Locator "${parsed.text}" points at a missing or invalid source Attempt.`));
-        }
-        const locator = Object.freeze({
+        return yield* resolveAdoptionAttempt(reader, resolved.attempt, Object.freeze({
             text: parsed.text,
             locator: parsed.locator,
-            attemptId: ref.attemptId,
-        });
-        return yield* resolveAdoptionAttemptV1(view, attempt.value, locator);
+            attemptId: resolved.attempt.attemptId,
+        }));
     });
 }
 /** Validates the origin anchor and evaluates its source Run/Slot metadata. */
-function resolveAdoptionAttemptV1(view, attempt, locator) {
+function resolveAdoptionAttempt(reader, attempt, locator) {
     return effect_1.Effect.gen(function* () {
-        const sourceLocator = locator ?? (yield* attemptLocatorFor(attempt.attemptId));
-        const checked = yield* view.attempt({
-            originRunId: attempt.originRunId,
-            attemptId: attempt.attemptId,
-        });
-        if (checked.state !== "available" || checked.value !== attempt) {
-            return yield* effect_1.Effect.fail(sourceCoreInvalid(`Source locator "${sourceLocator.text}" does not retain an exact frozen Attempt identity.`));
-        }
-        const port = (0, internal_ts_1.resolveFrozenRecordReaderPort)(view);
-        if (port === undefined) {
-            return yield* effect_1.Effect.fail(sourceCoreInvalid("The supplied Record view is not an authentic frozen reader."));
+        const sourceLocator = locator ?? attemptLocatorFor(attempt.attemptId);
+        const selected = yield* reader.selectRuns({ runIds: Object.freeze([attempt.originRunId]) });
+        if (selected.runRefs.length !== 1) {
+            return yield* effect_1.Effect.fail(sourceCoreInvalid(`Source locator "${sourceLocator.text}" has no readable origin Run.`));
         }
-        const originRun = yield* view.run(attempt.originRunId);
+        const originRun = yield* reader.readRun(selected.runRefs[0]);
         if (originRun.state !== "available") {
             return yield* effect_1.Effect.fail(sourceCoreInvalid(`Source locator "${sourceLocator.text}" has no readable origin Run.`));
         }
-        let originSlot;
-        for (const slotId of originRun.value.expectedSlots) {
-            const member = yield* port.member(view, originRun.value, slotId);
-            if (member.state === "core-invalid") {
-                return yield* effect_1.Effect.fail(sourceCoreInvalid(`Source origin Run for "${sourceLocator.text}" has an invalid Member.`));
-            }
-            if (member.state === "available" && sameAttemptReference(member.value.attempt, attempt)) {
-                if (originSlot !== undefined) {
-                    return yield* effect_1.Effect.fail(sourceCoreInvalid(`Source origin Run for "${sourceLocator.text}" has duplicate origin Members.`));
-                }
-                originSlot = slotId;
-            }
+        const attemptRead = yield* reader.readAttempt(attempt);
+        if (attemptRead.state !== "available") {
+            return yield* effect_1.Effect.fail(sourceCoreInvalid(`Locator "${sourceLocator.text}" points at a missing or invalid source Attempt.`));
         }
+        const originSlot = originRun.value.document.expectedSlots.find((slot) => slot.slotId === attemptRead.value.document.slotId);
         if (originSlot === undefined) {
             return yield* effect_1.Effect.fail(sourceCoreInvalid(`Source locator "${sourceLocator.text}" has no origin Member.`));
         }
-        const evaluations = yield* view.readRunAttachment(originRun.value, evaluation_ts_1.evaluationsAttachmentFamilyV1);
-        if (evaluations.state !== "available") {
-            return yield* effect_1.Effect.fail(attachmentUnavailable("evaluations", evaluations));
-        }
-        const projection = (0, evaluation_ts_1.projectEvaluationsAttachmentV1)(evaluations.value);
-        const sourceSlot = projection.evaluationForSlot(originSlot);
-        if (sourceSlot === undefined) {
-            return yield* effect_1.Effect.fail(sourceCoreInvalid(`Source origin Slot for "${sourceLocator.text}" is absent from its Evaluation attachment.`));
+        const matchingMembers = originRun.value.members.filter((member) => member.attempt !== null
+            && member.attempt.originRunId === attempt.originRunId
+            && member.attempt.attemptId === attempt.attemptId);
+        if (matchingMembers.length !== 1) {
+            return yield* effect_1.Effect.fail(sourceCoreInvalid(matchingMembers.length === 0
+                ? `Source locator "${sourceLocator.text}" has no origin Member.`
+                : `Source origin Run for "${sourceLocator.text}" has duplicate origin Members.`));
         }
         return Object.freeze({
             locator: sourceLocator,
             attempt,
-            origin: Object.freeze({ run: originRun.value, slotId: originSlot }),
-            originExperimentId: projection.experimentId,
-            originEvalId: sourceSlot.evalId,
-            originAttempt: sourceSlot.attempt,
+            origin: Object.freeze({
+                runId: originRun.value.document.runId,
+                slotId: originSlot.slotId,
+                startedAt: originRun.value.document.startedAt,
+            }),
+            originExperimentId: originRun.value.document.experimentId,
+            originEvalId: originSlot.evalId,
+            originAttempt: originSlot.attemptOrdinal,
+            executionIdentityDigest: originSlot.executionIdentityDigest,
         });
     });
 }
-function readAdoptionVerdictV1(view, source) {
-    return view.readAttemptAttachment(source.attempt, verdict_ts_1.verdictAttachmentFamilyV1).pipe(effect_1.Effect.flatMap((verdict) => verdict.state === "available"
-        ? effect_1.Effect.succeed((0, verdict_ts_1.projectVerdictAttachmentV1)(verdict.value))
-        : effect_1.Effect.fail(attachmentUnavailable("verdict", verdict))));
-}
-function readAdoptionEligibilityV1(view, source) {
-    return view.readAttemptAttachment(source.attempt, eligibility_ts_1.eligibilityAttachmentFamilyV1).pipe(effect_1.Effect.flatMap((eligibility) => eligibility.state === "available"
-        ? effect_1.Effect.succeed((0, eligibility_ts_1.projectEligibilityAttachmentV1)(eligibility.value))
-        : effect_1.Effect.fail(attachmentUnavailable("eligibility", eligibility))));
-}
-function identityComparison(input) {
-    const reason = input.source.domain !== input.target.domain
-        ? "identity-domain-mismatch"
-        : input.source.value !== input.target.value
-            ? "identity-mismatch"
-            : `${input.recordedClaim}-match`;
+/** Reads the exact Core outcome and its Assertion-derived terminal Verdict together. */
+function readAdoptionAttemptFacts(reader, source) {
+    return effect_1.Effect.gen(function* () {
+        const attempt = yield* reader.readAttempt(source.attempt);
+        if (attempt.state !== "available") {
+            return yield* effect_1.Effect.fail(adoptionError("adoption-source-verdict-unavailable", "Source Attempt/Core is unavailable."));
+        }
+        const assertions = yield* reader.readAssertions(attempt.value.owner);
+        if (assertions.state !== "available") {
+            const detail = assertions.state === "invalid" ? "invalid" : assertions.state;
+            return yield* effect_1.Effect.fail(adoptionError("adoption-source-verdict-unavailable", `Source Assertions is ${detail}.`));
+        }
+        const outcome = attempt.value.document.outcome;
+        const verdict = (0, verdict_ts_1.foldVerdict)({
+            execution: outcome === "errored" || outcome === "interrupted"
+                ? "errored"
+                : "completed",
+            explicitlySkipped: outcome === "cancelled",
+            assertions: assertions.value.entries.map((entry) => Object.freeze({
+                required: entry.result.gate !== "not-gate",
+                result: entry.result,
+            })),
+        });
+        return Object.freeze({ outcome, verdict });
+    });
+}
+function readAdoptionVerdict(reader, source) {
+    return readAdoptionAttemptFacts(reader, source).pipe(effect_1.Effect.map((facts) => facts.verdict));
+}
+/**
+ * Timing is a fixed Observability fact. No missing, partial, or invalid
+ * timing collection is eligible for adoption, including an unbounded target.
+ */
+function readAdoptionExecutionDuration(reader, source) {
+    return effect_1.Effect.gen(function* () {
+        const attempt = yield* reader.readAttempt(source.attempt);
+        if (attempt.state !== "available") {
+            return yield* effect_1.Effect.fail(adoptionError("adoption-source-observability-unavailable", `Source timing for locator "${source.locator.text}" has no readable Attempt.`));
+        }
+        const observability = yield* reader.readAttemptObservability(attempt.value.owner);
+        if (observability.state !== "available") {
+            const detail = observability.state === "invalid" ? "invalid" : observability.state;
+            return yield* effect_1.Effect.fail(adoptionError("adoption-source-observability-unavailable", `Source timing for locator "${source.locator.text}" is ${detail}.`));
+        }
+        const duration = (0, eligibility_ts_1.readAttemptExecutionDuration)(observability.value);
+        if (duration.state !== "available") {
+            return yield* effect_1.Effect.fail(adoptionError("adoption-source-observability-unavailable", `Source timing for locator "${source.locator.text}" is ${duration.reason}.`));
+        }
+        return duration.duration;
+    });
+}
+function executionIdentityComparison(input) {
+    const reason = input.source === input.target
+        ? "execution-identity-match"
+        : "execution-identity-mismatch";
     return Object.freeze({
-        attachment: "niceeval.eligibility/v1",
-        recordedClaim: input.recordedClaim,
+        attachment: "core",
+        recordedClaim: "execution-identity",
         sourceState: "available",
         result: reason.endsWith("-match") ? "match" : "mismatch",
         reason,
@@ -441,7 +446,7 @@ function durationComparison(input) {
     if (input.target === undefined) {
         return Object.freeze({
             comparison: Object.freeze({
-                attachment: "niceeval.eligibility/v1",
+                attachment: "niceeval.observability",
                 recordedClaim: "execution-duration",
                 sourceState: "available",
                 result: "match",
@@ -452,7 +457,7 @@ function durationComparison(input) {
     if (input.source.domain !== input.target.domain) {
         return Object.freeze({
             comparison: Object.freeze({
-                attachment: "niceeval.eligibility/v1",
+                attachment: "niceeval.observability",
                 recordedClaim: "execution-duration",
                 sourceState: "available",
                 result: "mismatch",
@@ -464,7 +469,7 @@ function durationComparison(input) {
     if (input.source.milliseconds > input.target.milliseconds) {
         return Object.freeze({
             comparison: Object.freeze({
-                attachment: "niceeval.eligibility/v1",
+                attachment: "niceeval.observability",
                 recordedClaim: "execution-duration",
                 sourceState: "available",
                 result: "mismatch",
@@ -475,7 +480,7 @@ function durationComparison(input) {
     }
     return Object.freeze({
         comparison: Object.freeze({
-            attachment: "niceeval.eligibility/v1",
+            attachment: "niceeval.observability",
             recordedClaim: "execution-duration",
             sourceState: "available",
             result: "match",
@@ -484,12 +489,11 @@ function durationComparison(input) {
     });
 }
 /**
- * Builds one accepted reference intent. Input/config comparisons are durable
- * evidence of the operator's manual decision; unlike automatic carry, a
- * mismatch does not silently turn into a gap. Verdict, readable eligibility,
- * duration domain and the current timeout remain hard safety gates.
+ * Builds one accepted reference intent. The Core combined execution identity
+ * is compared exactly, but an explicit operator decision may accept a mismatch.
+ * The folded Verdict and complete fixed Observability timing remain hard gates.
  */
-function prepareExplicitAdoptionMemberV1(input) {
+function prepareExplicitAdoptionMember(input) {
     return effect_1.Effect.gen(function* () {
         const target = input.target.slotFor(input.evalId, input.attempt);
         if (target === undefined) {
@@ -498,13 +502,17 @@ function prepareExplicitAdoptionMemberV1(input) {
                 : "adoption-target-eval-not-selected";
             return yield* effect_1.Effect.fail(adoptionError(code, `Current target ${input.target.experimentId}/${input.evalId} does not contain ordinal ${String(input.attempt)}.`));
         }
-        const verdict = yield* readAdoptionVerdictV1(input.view, input.source);
+        const facts = yield* readAdoptionAttemptFacts(input.reader, input.source);
+        const verdict = facts.verdict;
+        if (facts.outcome !== "completed") {
+            return yield* effect_1.Effect.fail(adoptionError("adoption-source-verdict-ineligible", `Source locator "${input.source.locator.text}" has Attempt outcome "${facts.outcome}" and cannot be explicitly adopted.`));
+        }
         if (verdict !== "passed" && verdict !== "failed") {
             return yield* effect_1.Effect.fail(adoptionError("adoption-source-verdict-ineligible", `Source locator "${input.source.locator.text}" has Verdict "${verdict}" and cannot be explicitly adopted.`));
         }
-        const eligibility = yield* readAdoptionEligibilityV1(input.view, input.source);
+        const executionDuration = yield* readAdoptionExecutionDuration(input.reader, input.source);
         const duration = durationComparison({
-            source: eligibility.executionDuration,
+            source: executionDuration,
             target: target.timeout,
         });
         if (duration.failure !== undefined) {
@@ -514,29 +522,23 @@ function prepareExplicitAdoptionMemberV1(input) {
         }
         const comparisons = Object.freeze([
             Object.freeze({
-                attachment: "niceeval.eligibility/v1",
-                recordedClaim: "reuse-contract",
+                attachment: "core",
+                recordedClaim: "attempt-outcome",
                 sourceState: "available",
-                result: "not-comparable",
-                reason: "explicit-adoption-manual-policy",
+                result: "match",
+                reason: "attempt-completed",
+            }),
+            executionIdentityComparison({
+                source: input.source.executionIdentityDigest,
+                target: target.executionIdentityDigest,
             }),
             Object.freeze({
-                attachment: "niceeval.verdict/v1",
-                recordedClaim: "verdict-state",
+                attachment: "niceeval.assertions",
+                recordedClaim: "assertion-verdict",
                 sourceState: "available",
                 result: "match",
                 reason: "verdict-eligible",
             }),
-            identityComparison({
-                recordedClaim: "input-identity",
-                source: eligibility.inputIdentity,
-                target: target.inputIdentity,
-            }),
-            identityComparison({
-                recordedClaim: "config-identity",
-                source: eligibility.configIdentity,
-                target: target.configIdentity,
-            }),
             duration.comparison,
         ]);
         return Object.freeze({
@@ -551,74 +553,22 @@ function prepareExplicitAdoptionMemberV1(input) {
         });
     });
 }
-function membershipOptions(input) {
-    return Object.freeze({
-        intent: input.intent,
-        experimentId: input.target.experimentId,
-        expectedSlots: input.target.expectedSlots.map((slotId) => String(slotId)),
-    });
-}
-function notDispatchedAdoptionAction(slotId) {
-    return Object.freeze({
-        action: "not-dispatched",
-        slotId,
-        gap: Object.freeze({
-            reason: "rerun-requested",
-            scope: "slot",
-            issues: Object.freeze([]),
-        }),
-        comparisons: Object.freeze([
-            Object.freeze({
-                attachment: "niceeval.eligibility/v1",
-                recordedClaim: "reuse-contract",
-                sourceState: "unavailable",
-                result: "not-comparable",
-                reason: "explicit-adoption-locator-not-authorized-for-target-slot",
-            }),
-        ]),
-    });
-}
-function acceptedAdoptionAction(member) {
-    return Object.freeze({
-        action: "accepted",
-        slotId: member.target.slotId,
-        attemptId: member.source.attempt.attemptId,
-        origin: Object.freeze({
-            runId: member.source.origin.run.runId,
-            slotId: member.source.origin.slotId,
-        }),
-        sourceBarrier: Object.freeze({
-            runId: member.source.origin.run.runId,
-            startedAt: member.source.origin.run.startedAt,
-        }),
-        comparisons: member.comparisons,
-        locator: member.locator,
-        ...(member.operatorReason === undefined
-            ? {}
-            : { operatorReason: member.operatorReason }),
-    });
-}
-/**
- * The full current target remains the Run denominator. Therefore this producer
- * constructs exactly one final provenance action for every expected Slot:
- * explicit Members are accepted, while all other current Slots are explicitly
- * recorded as not dispatched rather than silently disappearing from history.
- */
-function buildExplicitAdoptionActionsV1(input) {
+/** Validates the exact Core Run denominator before the writer records Members. */
+function validateExplicitAdoptionMembers(input) {
     return effect_1.Effect.gen(function* () {
         const expected = new Set();
-        for (const slotId of input.target.expectedSlots) {
-            if (expected.has(slotId)) {
-                return yield* effect_1.Effect.fail(adoptionError("adoption-target-slot-duplicate", `Current target lists Slot "${slotId}" more than once.`));
+        for (const slot of input.target.expectedSlots) {
+            if (expected.has(slot.slotId)) {
+                return yield* effect_1.Effect.fail(adoptionError("adoption-target-slot-duplicate", `Current target lists Slot "${slot.slotId}" more than once.`));
             }
-            expected.add(slotId);
+            expected.add(slot.slotId);
         }
         const targetSlots = new Set(input.target.slots.map((slot) => String(slot.slotId)));
         if (targetSlots.size !== expected.size
             || [...expected].some((slotId) => !targetSlots.has(slotId))) {
             return yield* effect_1.Effect.fail(adoptionError("adoption-target-invalid", "Current target Slot definitions do not exactly match its expected Slot denominator."));
         }
-        const memberBySlot = new Map();
+        const memberBySlot = new Set();
         for (const member of input.members) {
             const slotId = String(member.target.slotId);
             if (!expected.has(slotId)) {
@@ -627,148 +577,144 @@ function buildExplicitAdoptionActionsV1(input) {
             if (memberBySlot.has(slotId)) {
                 return yield* effect_1.Effect.fail(adoptionError("adoption-target-member-duplicate", `More than one source attempts to occupy target Slot "${slotId}".`));
             }
-            memberBySlot.set(slotId, member);
-        }
-        const actions = input.target.expectedSlots.map((slotId) => {
-            const member = memberBySlot.get(String(slotId));
-            return member === undefined
-                ? notDispatchedAdoptionAction(slotId)
-                : acceptedAdoptionAction(member);
-        });
-        const actionSlots = new Set(actions.map((action) => String(action.slotId)));
-        if (actions.length !== input.target.expectedSlots.length
-            || actionSlots.size !== expected.size
-            || [...expected].some((slotId) => !actionSlots.has(slotId))) {
-            return yield* effect_1.Effect.fail(adoptionError("adoption-provenance-invalid", "Explicit adoption did not produce one final Membership action for every expected Slot."));
+            memberBySlot.add(slotId);
         }
-        return Object.freeze(actions);
+        return undefined;
     });
 }
 /**
- * Performs all generic Evaluation and provenance validation before a writer
- * creates a Run directory. This is the batch's no-business-write boundary.
+ * Performs Core denominator and Member validation before a writer creates a
+ * reference Run. This is the batch's no-business-write boundary.
  */
-function buildExplicitAdoptionRunPlanV1(input) {
+function buildExplicitAdoptionRunPlan(input) {
     return effect_1.Effect.gen(function* () {
         if (input.members.length === 0) {
             return yield* effect_1.Effect.fail(adoptionError("adoption-target-invalid", "Explicit adoption requires at least one reference Member."));
         }
-        const actions = yield* buildExplicitAdoptionActionsV1(input);
-        const provenance = {
-            policy: Object.freeze({
-                name: exports.EXPLICIT_ADOPTION_POLICY_NAME_V1,
-                version: exports.EXPLICIT_ADOPTION_POLICY_VERSION_V1,
-            }),
-            effectiveOptions: membershipOptions(input),
-            actions,
-        };
-        const provenanceWrite = (0, membership_provenance_ts_1.buildMembershipProvenanceAttachmentWriteV1)(provenance);
-        if (effect_1.Either.isLeft(provenanceWrite)) {
-            return yield* effect_1.Effect.fail(adoptionError("adoption-provenance-invalid", "Explicit adoption produced invalid Membership Provenance."));
-        }
-        const plan = yield* evaluation_record_ts_1.EvaluationRecordContractV1.preparePlan({
-            startedAt: input.target.startedAt,
-            completedAt: input.target.startedAt,
-            expectedSlots: input.target.expectedSlots,
-            evaluations: input.target.evaluations,
-            originAttempts: [],
-            references: input.members.map((member) => Object.freeze({
-                slotId: member.target.slotId,
-                attempt: member.source.attempt,
-            })),
-            runWrites: [provenanceWrite.right],
-        }).pipe(effect_1.Effect.mapError(() => adoptionError("adoption-evaluation-plan-invalid", "Explicit adoption failed Evaluation Record contract preflight.")));
+        yield* validateExplicitAdoptionMembers(input);
         return Object.freeze({
             intent: input.intent,
             target: input.target,
             members: Object.freeze([...input.members]),
-            evaluationPlan: plan,
         });
     });
 }
-/** Writes only plans already built from this exact session's frozen view. */
-function commitExplicitAdoptionRunPlansV1(session, plans) {
-    return effect_1.Effect.forEach(plans, (plan) => evaluation_record_ts_1.EvaluationRecordContractV1.writePlan(session, plan.evaluationPlan).pipe(effect_1.Effect.map((receipt) => receiptForPlan(plan, receipt))), { concurrency: 1 });
+/** Writes only plans already built from this exact session's Host reader. */
+function commitExplicitAdoptionRunPlans(_reader, root, plans) {
+    return effect_1.Effect.forEach(plans, (plan) => effect_1.Effect.gen(function* () {
+        const experimentId = yield* decodeBrandedId(identifiers_ts_1.ExperimentIdSchema, plan.target.experimentId, "adoption-target-invalid", "Adoption target Experiment");
+        const writer = yield* runtime_ts_1.recordHost.current.createReferenceRun({
+            root,
+            experimentId,
+            context: plan.target.context,
+            startedAt: plan.target.startedAt,
+            expectedSlots: plan.target.expectedSlots,
+        });
+        const accepted = new Set(plan.members.map((member) => String(member.target.slotId)));
+        for (const member of plan.members) {
+            yield* writer.recordAcceptedMembership({
+                slotId: member.target.slotId,
+                attempt: member.source.attempt,
+            });
+        }
+        for (const slot of plan.target.expectedSlots) {
+            if (accepted.has(String(slot.slotId)))
+                continue;
+            yield* writer.recordTerminalMember({
+                slotId: slot.slotId,
+                action: "not-dispatched",
+            });
+        }
+        const sealed = yield* writer.seal({ completedAt: plan.target.startedAt });
+        return receiptForPlan(plan, sealed.runId);
+    }), { concurrency: 1 });
 }
-function receiptForPlan(plan, receipt) {
+function receiptForPlan(plan, runId) {
     return Object.freeze({
-        runId: receipt.runId,
+        experimentId: plan.target.experimentId,
+        runId,
         members: Object.freeze(plan.members.map((member) => Object.freeze({
             slotId: member.target.slotId,
             locator: member.locator,
-            sourceRunId: member.source.origin.run.runId,
+            sourceRunId: member.source.origin.runId,
             attemptId: member.source.attempt.attemptId,
         }))),
     });
 }
 /** A fresh in-memory invocation identity never enters Record Core. */
-function createExplicitAdoptionInvocationIdV1(mint = node_crypto_1.randomUUID) {
+function createExplicitAdoptionInvocationId(mint = node_crypto_1.randomUUID) {
     return effect_1.Effect.sync(() => `adoption-${mint()}`);
 }
-function adoptionStartedAtV1(input) {
+function adoptionStartedAt(input) {
     return effect_1.Effect.sync(() => input?.() ?? Date.now()).pipe(effect_1.Effect.flatMap((value) => {
         const millis = typeof value === "number" ? value : Date.parse(value);
         return utcMillis(millis);
     }));
 }
-/** Opens a frozen read view only; dry callers must use this rather than a writer session. */
-function withAdoptionReaderV1(input) {
+/** Opens a Host read session only; dry callers must use this rather than a writer. */
+function withAdoptionReader(input) {
     return effect_1.Effect.scoped(effect_1.Effect.gen(function* () {
-        const reader = yield* (0, runtime_ts_1.openRecordReader)({ root: input.root });
+        const reader = yield* runtime_ts_1.recordHost.current.openRead({ root: input.root });
         return yield* input.use(reader);
     }));
 }
-/** Opens the sole scoped write session after an earlier reader preflight passed. */
-function withAdoptionWriteSessionV1(input) {
-    return effect_1.Effect.scoped(effect_1.Effect.gen(function* () {
-        const session = yield* (0, runtime_ts_2.openRecordWriteSession)({ root: input.root });
-        return yield* input.use(session);
-    }));
+/**
+ * One Scope keeps the Host reader live while reference Runs are created, so
+ * SelectedAttemptRefs remain valid through seal. Discovery still happens
+ * before this Scope opens, so the first preflight writes nothing.
+ */
+function withAdoptionCommitScope(input) {
+    return withAdoptionReader(input);
 }
 /**
  * Selects one old Experiment Run without directory-time inference. Multiple
  * matching Runs require the caller to pass an exact RunId.
  */
-function resolveRenameSourceRunV1(input) {
+function resolveRenameSourceRun(input) {
     return effect_1.Effect.gen(function* () {
         if (input.sourceRunId !== undefined) {
             const runId = yield* decodeBrandedId(identifiers_ts_1.RunIdSchema, input.sourceRunId, "adoption-source-run-not-found", "Rename source Run");
-            const run = yield* input.view.run(runId);
-            if (run.state !== "available") {
+            const selected = yield* input.reader.selectRuns({ runIds: Object.freeze([runId]) });
+            if (selected.runRefs.length !== 1) {
                 return yield* effect_1.Effect.fail(adoptionError("adoption-source-run-not-found", `Rename source Run "${input.sourceRunId}" is not a published readable Run.`));
             }
-            const evaluations = yield* input.view.readRunAttachment(run.value, evaluation_ts_1.evaluationsAttachmentFamilyV1);
-            if (evaluations.state !== "available") {
-                return yield* effect_1.Effect.fail(attachmentUnavailable("evaluations", evaluations));
+            const run = yield* input.reader.readRun(selected.runRefs[0]);
+            if (run.state !== "available") {
+                return yield* effect_1.Effect.fail(adoptionError("adoption-source-run-not-found", `Rename source Run "${input.sourceRunId}" is not a published readable Run.`));
             }
-            if ((0, evaluation_ts_1.projectEvaluationsAttachmentV1)(evaluations.value).experimentId !== input.oldId) {
+            if (run.value.document.experimentId !== input.oldId) {
                 return yield* effect_1.Effect.fail(adoptionError("adoption-source-run-mismatch", `Run "${input.sourceRunId}" does not belong to old Experiment "${input.oldId}".`));
             }
-            return run.value;
+            return Object.freeze({
+                runId: run.value.document.runId,
+                experimentId: run.value.document.experimentId,
+                startedAt: run.value.document.startedAt,
+                expectedSlots: run.value.document.expectedSlots,
+            });
         }
-        const matches = yield* effect_1.Stream.runFoldEffect(input.view.runs, { first: undefined, duplicate: false }, (runs, candidate) => {
-            // Keep the scan streaming even after the decision is known, but do not
-            // retain arbitrary historic Runs or perform needless Attachment I/O.
-            if (runs.duplicate || candidate.state !== "available") {
-                return effect_1.Effect.succeed(runs);
+        const selected = yield* input.reader.selectRuns();
+        let first;
+        for (const ref of selected.runRefs) {
+            const run = yield* input.reader.readRun(ref);
+            if (run.state !== "available")
+                continue;
+            if (run.value.document.experimentId !== input.oldId)
+                continue;
+            const current = Object.freeze({
+                runId: run.value.document.runId,
+                experimentId: run.value.document.experimentId,
+                startedAt: run.value.document.startedAt,
+                expectedSlots: run.value.document.expectedSlots,
+            });
+            if (first !== undefined) {
+                return yield* effect_1.Effect.fail(adoptionError("adoption-source-run-required", `Old Experiment "${input.oldId}" has multiple published Runs; select one exact source RunId.`));
             }
-            return input.view.readRunAttachment(candidate.value, evaluation_ts_1.evaluationsAttachmentFamilyV1).pipe(effect_1.Effect.map((evaluations) => {
-                if (evaluations.state === "available"
-                    && (0, evaluation_ts_1.projectEvaluationsAttachmentV1)(evaluations.value).experimentId === input.oldId) {
-                    return runs.first === undefined
-                        ? Object.freeze({ first: candidate.value, duplicate: false })
-                        : Object.freeze({ first: runs.first, duplicate: true });
-                }
-                return runs;
-            }));
-        });
-        if (matches.first === undefined) {
-            return yield* effect_1.Effect.fail(adoptionError("adoption-source-run-not-found", `No published source Run belongs to old Experiment "${input.oldId}".`));
+            first = current;
         }
-        if (matches.duplicate) {
-            return yield* effect_1.Effect.fail(adoptionError("adoption-source-run-required", `Old Experiment "${input.oldId}" has multiple published Runs; select one exact source RunId.`));
+        if (first === undefined) {
+            return yield* effect_1.Effect.fail(adoptionError("adoption-source-run-not-found", `No published source Run belongs to old Experiment "${input.oldId}".`));
         }
-        return matches.first;
+        return first;
     });
 }
 /**
@@ -776,76 +722,68 @@ function resolveRenameSourceRunV1(input) {
  * target are preview exclusions; every source Member that would be adopted is
  * fully validated before the caller is allowed to create a target Run.
  */
-function prepareRenameAdoptionMembersV1(input) {
+function prepareRenameAdoptionMembers(input) {
     return effect_1.Effect.gen(function* () {
-        const port = (0, internal_ts_1.resolveFrozenRecordReaderPort)(input.view);
-        if (port === undefined) {
-            return yield* effect_1.Effect.fail(sourceCoreInvalid("The supplied Record view is not an authentic frozen reader."));
+        if (input.sourceRun.experimentId !== input.oldId) {
+            return yield* effect_1.Effect.fail(adoptionError("adoption-source-run-mismatch", `Selected source Run "${input.sourceRun.runId}" does not belong to old Experiment "${input.oldId}".`));
         }
-        const evaluations = yield* input.view.readRunAttachment(input.sourceRun, evaluation_ts_1.evaluationsAttachmentFamilyV1);
-        if (evaluations.state !== "available") {
-            return yield* effect_1.Effect.fail(attachmentUnavailable("evaluations", evaluations));
+        const selected = yield* input.reader.selectRuns({
+            runIds: Object.freeze([input.sourceRun.runId]),
+        });
+        if (selected.runRefs.length !== 1) {
+            return yield* effect_1.Effect.fail(sourceCoreInvalid(`Selected source Run "${input.sourceRun.runId}" is not a published readable Run.`));
         }
-        const sourceEvaluations = (0, evaluation_ts_1.projectEvaluationsAttachmentV1)(evaluations.value);
-        if (sourceEvaluations.experimentId !== input.oldId) {
-            return yield* effect_1.Effect.fail(adoptionError("adoption-source-run-mismatch", `Selected source Run "${input.sourceRun.runId}" does not belong to old Experiment "${input.oldId}".`));
+        const run = yield* input.reader.readRun(selected.runRefs[0]);
+        if (run.state !== "available") {
+            return yield* effect_1.Effect.fail(sourceCoreInvalid(`Selected source Run "${input.sourceRun.runId}" is not a published readable Run.`));
         }
         const members = [];
         const excluded = [];
         const seenSourceSlots = new Set();
-        for (const slotId of input.sourceRun.expectedSlots) {
+        for (const sourceSlot of input.sourceRun.expectedSlots) {
+            const slotId = sourceSlot.slotId;
             if (seenSourceSlots.has(slotId)) {
                 return yield* effect_1.Effect.fail(sourceCoreInvalid(`Selected source Run "${input.sourceRun.runId}" repeats Slot "${slotId}".`));
             }
             seenSourceSlots.add(slotId);
-            const sourceSlot = sourceEvaluations.evaluationForSlot(slotId);
-            if (sourceSlot === undefined) {
-                return yield* effect_1.Effect.fail(sourceCoreInvalid(`Selected source Run "${input.sourceRun.runId}" has Slot "${slotId}" outside its Evaluations attachment.`));
-            }
-            const targetSlot = input.target.slotFor(sourceSlot.evalId, sourceSlot.attempt);
+            const attemptOrdinal = sourceSlot.attemptOrdinal;
+            const targetSlot = input.target.slotFor(sourceSlot.evalId, attemptOrdinal);
             if (targetSlot === undefined) {
                 const selectedEval = input.target.slots.some((slot) => slot.evalId === sourceSlot.evalId);
                 excluded.push(Object.freeze({
                     evalId: sourceSlot.evalId,
-                    attempt: sourceSlot.attempt,
+                    attempt: attemptOrdinal,
                     reason: selectedEval
                         ? "target-attempt-not-selected"
                         : "target-eval-not-selected",
                 }));
                 continue;
             }
-            const sourceMember = yield* port.member(input.view, input.sourceRun, slotId);
-            if (sourceMember.state === "core-invalid") {
-                return yield* effect_1.Effect.fail(sourceCoreInvalid(`Selected source Run "${input.sourceRun.runId}" has an invalid Member for Slot "${slotId}".`));
-            }
-            if (sourceMember.state === "missing") {
+            const sourceMember = run.value.members.find((member) => member.document.slotId === slotId);
+            if (sourceMember === undefined || sourceMember.attempt === null) {
                 excluded.push(Object.freeze({
                     evalId: sourceSlot.evalId,
-                    attempt: sourceSlot.attempt,
+                    attempt: attemptOrdinal,
                     reason: "source-member-missing",
                 }));
                 continue;
             }
-            const sourceAttempt = yield* input.view.attempt(sourceMember.value.attempt);
-            if (sourceAttempt.state !== "available") {
-                return yield* effect_1.Effect.fail(sourceCoreInvalid(`Selected source Member for Slot "${slotId}" does not retain a readable exact Attempt.`));
-            }
-            const source = yield* resolveAdoptionAttemptV1(input.view, sourceAttempt.value);
+            const source = yield* resolveAdoptionAttempt(input.reader, sourceMember.attempt);
             if (source.originEvalId !== sourceSlot.evalId
-                || source.originAttempt !== sourceSlot.attempt) {
-                return yield* effect_1.Effect.fail(sourceCoreInvalid(`Selected source Member for ${sourceSlot.evalId}/${String(sourceSlot.attempt)} does not retain a matching origin Attempt.`));
+                || source.originAttempt !== attemptOrdinal) {
+                return yield* effect_1.Effect.fail(sourceCoreInvalid(`Selected source Member for ${sourceSlot.evalId}/${String(attemptOrdinal)} does not retain a matching origin Attempt.`));
             }
-            const member = yield* prepareExplicitAdoptionMemberV1({
-                view: input.view,
+            const member = yield* prepareExplicitAdoptionMember({
+                reader: input.reader,
                 target: input.target,
                 source,
                 evalId: sourceSlot.evalId,
-                attempt: sourceSlot.attempt,
+                attempt: attemptOrdinal,
                 operatorReason: input.operatorReason,
             });
             members.push(Object.freeze({
                 evalId: sourceSlot.evalId,
-                attempt: sourceSlot.attempt,
+                attempt: attemptOrdinal,
                 member,
             }));
         }