niceeval 0.12.2-canary.31 → 0.13.0

package/dist/runner/record.cjs

@@ -3,25 +3,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.prepareRunnerRecordReuse = prepareRunnerRecordReuse;
 exports.withRunnerCurrentReusePreview = withRunnerCurrentReusePreview;
 exports.openRunnerRecordCoordinator = openRunnerRecordCoordinator;
-const node_path_1 = require("node:path");
+const node_crypto_1 = require("node:crypto");
+const execution_identity_ts_1 = require("./execution-identity.cjs");
 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 index_ts_1 = require("../eval/record/index.cjs");
+const attachment_ts_1 = require("../assertions/record/attachment.cjs");
+const diff_ts_1 = require("../assertions/record/diff.cjs");
+const index_ts_1 = require("../record/attachment/index.cjs");
+const internal_ts_1 = require("../record/attachment/internal.cjs");
+const core_ts_1 = require("../record/codec/core.cjs");
+const catalog_ts_1 = require("../record/family/catalog.cjs");
+const artifacts_ts_1 = require("../record/family/artifacts.cjs");
+const family_writers_ts_1 = require("../o11y/record/family-writers.cjs");
+const runner_producer_ts_1 = require("../o11y/record/runner-producer.cjs");
 const identifiers_ts_1 = require("../record/codec/identifiers.cjs");
-const identifiers_ts_2 = require("../record/model/identifiers.cjs");
+const runtime_ts_1 = require("../record/host/runtime.cjs");
+const run_context_ts_1 = require("../record/model/run-context.cjs");
 const services_ts_1 = require("../record/platform/services.cjs");
-const root_ts_1 = require("../record/platform/root.cjs");
-const runtime_ts_1 = require("../record/reader/runtime.cjs");
-const runtime_ts_2 = require("../record/writer/runtime.cjs");
 const fingerprint_ts_1 = require("./fingerprint.cjs");
 const eval_selection_ts_1 = require("./eval-selection.cjs");
 const timeout_ts_1 = require("./timeout.cjs");
 const reuse_plan_ts_1 = require("./reuse-plan.cjs");
 const reuse_readback_ts_1 = require("./reuse-readback.cjs");
-const evaluation_record_ts_1 = require("../eval/record/evaluation-record.cjs");
-const family_writers_ts_1 = require("../o11y/record/family-writers.cjs");
-const runner_producer_ts_1 = require("../o11y/record/runner-producer.cjs");
 const source_producer_ts_1 = require("./source-producer.cjs");
 const sandbox_record_producer_ts_1 = require("./sandbox-record-producer.cjs");
 const runnerReuseContract = Object.freeze({
@@ -29,8 +32,8 @@ const runnerReuseContract = Object.freeze({
     value: "project-target/v1",
 });
 /**
- * Builds the one current-policy input used by both the writer coordinator and
- * the dry reader. It never reads historical result files or creates legacy results.
+ * Builds all current identity facts before any Record read. These values feed
+ * the deterministic Core execution digest; they are not an Eligibility write.
  */
 function prepareRunnerRecordReuse(input) {
     return effect_1.Effect.suspend(() => {
@@ -41,10 +44,7 @@ function prepareRunnerRecordReuse(input) {
                 const fingerprint = input.plannedFingerprints.get(key);
                 const configHash = input.plannedConfigHashes.get(key);
                 if (fingerprint === undefined || configHash === undefined) {
-                    return effect_1.Effect.fail(Object.freeze({
-                        code: "runner-record-target-input-missing",
-                        key,
-                    }));
+                    return effect_1.Effect.fail({ code: "runner-record-target-input-missing", key });
                 }
                 const timeout = (0, timeout_ts_1.resolveAttemptTimeout)(run, evalDef, input.config);
                 slotsByKey.set(key, Object.freeze({
@@ -56,14 +56,12 @@ function prepareRunnerRecordReuse(input) {
                         domain: "niceeval.config/identity-v1",
                         value: configHash,
                     }),
-                    ...(timeout === undefined
-                        ? {}
-                        : {
-                            timeout: Object.freeze({
-                                domain: index_ts_1.EXECUTION_DURATION_DOMAIN_V1,
-                                milliseconds: timeout.timeoutMs,
-                            }),
+                    ...(timeout === undefined ? {} : {
+                        timeout: Object.freeze({
+                            domain: "niceeval.execution-duration/v1",
+                            milliseconds: timeout.timeoutMs,
                         }),
+                    }),
                 }));
             }
         }
@@ -81,801 +79,795 @@ function prepareRunnerRecordReuse(input) {
 function slotKey(evalId, attempt) {
     return `${evalId}\u0000${attempt}`;
 }
-function asSlotId(value) {
-    const decoded = effect_1.Schema.decodeUnknownEither(identifiers_ts_1.SlotIdSchema)(value);
+function decodeId(input) {
+    const decoded = effect_1.Schema.decodeUnknownEither(input.schema)(input.value);
     return effect_1.Either.isLeft(decoded)
         ? effect_1.Either.left(Object.freeze({
             code: "runner-record-target-identity-invalid",
-            kind: "slot",
-            value,
+            kind: input.kind,
+            value: input.value,
         }))
         : effect_1.Either.right(decoded.right);
 }
 function asUtcMillis(value) {
     const decoded = effect_1.Schema.decodeUnknownEither(identifiers_ts_1.UtcMillisSchema)(value);
-    if (effect_1.Either.isLeft(decoded)) {
-        throw new Error(`Runner produced an invalid Record timestamp: ${value}`);
-    }
-    return decoded.right;
-}
-function asRunId(value) {
-    const decoded = effect_1.Schema.decodeUnknownEither(identifiers_ts_1.RunIdSchema)(value);
     return effect_1.Either.isLeft(decoded)
         ? effect_1.Either.left(Object.freeze({
             code: "runner-record-target-identity-invalid",
             kind: "invocation",
-            value,
+            value: String(value),
         }))
         : effect_1.Either.right(decoded.right);
 }
-/** Target Slot identity is invocation-local opaque data, minted through RecordEntropy. */
-function mintTargetSlotId(entropy, used) {
-    return effect_1.Effect.gen(function* () {
-        for (let attempts = 0; attempts < 16; attempts += 1) {
-            const uuid = yield* entropy.uuid;
-            const slotId = asSlotId(`slot-${uuid}`);
-            if (effect_1.Either.isLeft(slotId))
-                return yield* effect_1.Effect.fail(slotId.left);
-            if (!used.has(slotId.right))
-                return slotId.right;
-        }
-        return yield* effect_1.Effect.fail(Object.freeze({
-            code: "runner-record-target-identity-invalid",
-            kind: "slot",
-            value: "RecordEntropy produced duplicate Slot identities",
-        }));
+function runContextFor(run, experimentId) {
+    const context = (0, run_context_ts_1.canonicalizeRunContext)({
+        experimentId,
+        execution: {
+            agentId: run.agent.name,
+            model: run.model ?? null,
+            reasoningEffort: run.reasoningEffort ?? null,
+            flags: run.flags,
+        },
+        labels: run.labels ?? {},
     });
-}
-function mintInvocationId(entropy) {
-    return effect_1.Effect.flatMap(entropy.uuid, (uuid) => uuid.length > 0 && uuid.length <= 255
-        ? effect_1.Effect.succeed(uuid)
-        : effect_1.Effect.fail(Object.freeze({
+    return effect_1.Either.isLeft(context)
+        ? effect_1.Either.left(Object.freeze({
             code: "runner-record-target-identity-invalid",
-            kind: "invocation",
-            value: uuid,
-        })));
+            kind: "context",
+            value: `invalid Run context for ${run.experimentId}`,
+        }))
+        : effect_1.Either.right(context.right);
 }
-/** A preview target needs valid ephemeral Run IDs but never creates a draft or writer lock. */
-function mintPreviewRunId(entropy, used) {
-    return effect_1.Effect.gen(function* () {
-        for (let attempts = 0; attempts < 16; attempts += 1) {
-            const uuid = yield* entropy.uuid;
-            const runId = asRunId(`preview-run-${uuid}`);
-            if (effect_1.Either.isLeft(runId))
-                return yield* effect_1.Effect.fail(runId.left);
-            if (!used.has(runId.right))
-                return runId.right;
-        }
-        return yield* effect_1.Effect.fail(Object.freeze({
-            code: "runner-record-target-identity-invalid",
-            kind: "invocation",
-            value: "RecordEntropy produced duplicate preview Run identities",
-        }));
+function executionIdentityDigest(input) {
+    const value = (0, execution_identity_ts_1.slotExecutionIdentityDigestHex)({
+        experimentId: input.run.experimentId,
+        evalId: input.eval.id,
+        attempt: input.attempt,
+        input: { domain: input.reuse.inputIdentity.domain, value: input.reuse.inputIdentity.value },
+        config: { domain: input.reuse.configIdentity.domain, value: input.reuse.configIdentity.value },
+        timeout: input.reuse.timeout === undefined
+            ? null
+            : { domain: input.reuse.timeout.domain, milliseconds: input.reuse.timeout.milliseconds },
     });
-}
-function nonEmptySlots(slots) {
-    const [first, ...rest] = slots;
-    if (first === undefined) {
-        throw new Error("Runner planned an Eval without Record Slots");
-    }
-    return Object.freeze([first, ...rest]);
+    return decodeId({ schema: identifiers_ts_1.ExecutionIdentityDigestSchema, value, kind: "digest" });
 }
 function planRun(input) {
-    return effect_1.Effect.gen(function* () {
+    return effect_1.Effect.suspend(() => {
+        const experimentId = decodeId({
+            schema: identifiers_ts_1.ExperimentIdSchema,
+            value: input.run.experimentId,
+            kind: "experiment",
+        });
+        if (effect_1.Either.isLeft(experimentId))
+            return effect_1.Effect.fail(experimentId.left);
+        const context = runContextFor(input.run, experimentId.right);
+        if (effect_1.Either.isLeft(context))
+            return effect_1.Effect.fail(context.left);
         const slots = new Map();
-        const slotEntries = [];
-        const definitions = [];
+        const entries = [];
         for (const evalDef of (0, eval_selection_ts_1.selectedEvalsForRun)(input.evals, input.run)) {
-            const slotInput = input.reuse.slotsByKey.get((0, fingerprint_ts_1.cacheKey)(input.run, evalDef.id));
-            if (slotInput === undefined) {
-                return yield* effect_1.Effect.fail({
+            const reuse = input.reuse.slotsByKey.get((0, fingerprint_ts_1.cacheKey)(input.run, evalDef.id));
+            if (reuse === undefined) {
+                return effect_1.Effect.fail({
                     code: "runner-record-target-input-missing",
                     key: (0, fingerprint_ts_1.cacheKey)(input.run, evalDef.id),
                 });
             }
-            const evaluationSlots = [];
+            const evalId = decodeId({ schema: identifiers_ts_1.EvalIdSchema, value: evalDef.id, kind: "eval" });
+            if (effect_1.Either.isLeft(evalId))
+                return effect_1.Effect.fail(evalId.left);
             for (let attempt = 0; attempt < input.run.attempts; attempt += 1) {
+                const digest = executionIdentityDigest({ run: input.run, eval: evalDef, attempt, reuse });
+                if (effect_1.Either.isLeft(digest))
+                    return effect_1.Effect.fail(digest.left);
+                const slotId = decodeId({
+                    schema: identifiers_ts_1.SlotIdSchema,
+                    value: `slot-${digest.right}`,
+                    kind: "slot",
+                });
+                if (effect_1.Either.isLeft(slotId))
+                    return effect_1.Effect.fail(slotId.left);
                 const key = slotKey(evalDef.id, attempt);
-                const slotId = yield* mintTargetSlotId(input.entropy, input.usedSlotIds);
-                input.usedSlotIds.add(slotId);
                 if (slots.has(key)) {
-                    return yield* effect_1.Effect.fail({
+                    return effect_1.Effect.fail({
                         code: "runner-record-target-identity-invalid",
                         kind: "slot",
-                        value: `duplicate ${key}`,
+                        value: key,
                     });
                 }
-                slots.set(key, slotId);
-                slotEntries.push(Object.freeze({ evalDef, attempt, slotId, reuse: slotInput }));
-                evaluationSlots.push(Object.freeze({ slotId, attempt }));
+                const entry = Object.freeze({
+                    evalDef,
+                    attempt,
+                    slot: Object.freeze({
+                        slotId: slotId.right,
+                        evalId: evalId.right,
+                        attemptOrdinal: attempt,
+                        executionIdentityDigest: digest.right,
+                    }),
+                    reuse,
+                });
+                slots.set(key, entry);
+                entries.push(entry);
             }
-            definitions.push(Object.freeze({
-                evalId: evalDef.id,
-                evaluationKind: evalDef.evaluationKind,
-                slots: nonEmptySlots(evaluationSlots),
-            }));
         }
-        return Object.freeze({
+        return effect_1.Effect.succeed(Object.freeze({
             run: input.run,
-            // Record Core stores the Run denominator in canonical identity order;
-            // target slot IDs are entropy-backed and therefore cannot rely on
-            // execution/ordinal construction order for that invariant.
-            expectedSlots: Object.freeze(slotEntries.map((entry) => entry.slotId).sort(identifiers_ts_2.compareCanonicalIdentity)),
-            evaluations: Object.freeze({
-                experimentId: input.run.experimentId,
-                evaluations: Object.freeze(definitions),
-            }),
+            experimentId: experimentId.right,
+            context: context.right,
+            expectedSlots: Object.freeze([...entries]
+                .map((entry) => entry.slot)
+                .sort((left, right) => left.slotId < right.slotId ? -1 : left.slotId > right.slotId ? 1 : 0)),
             slots,
-            slotEntries: Object.freeze(slotEntries),
-        });
+            slotEntries: Object.freeze(entries),
+        }));
     });
 }
-/**
- * Current dry/readback capability. Its callback runs while the FrozenRecordView
- * remains open, so callers must project readbacks before returning from `use`.
- * It deliberately never opens a write session, creates a draft, or takes the
- * writer lock.
- */
+function previewRunId(run) {
+    const hash = (0, node_crypto_1.createHash)("sha256").update(run.experimentId, "utf8").digest("hex");
+    return decodeId({ schema: identifiers_ts_1.RunIdSchema, value: `preview-${hash}`, kind: "invocation" });
+}
+function targetFor(input) {
+    return Object.freeze({
+        runId: input.runId,
+        experimentId: input.planned.run.experimentId,
+        startedAt: input.startedAt,
+        slots: Object.freeze(input.planned.slotEntries.map((entry) => Object.freeze({
+            runId: input.runId,
+            slotId: entry.slot.slotId,
+            experimentId: input.planned.run.experimentId,
+            evalId: entry.evalDef.id,
+            attempt: entry.attempt,
+            evaluationKind: entry.evalDef.evaluationKind,
+            executionIdentityDigest: entry.slot.executionIdentityDigest,
+            inputIdentity: entry.reuse.inputIdentity,
+            configIdentity: entry.reuse.configIdentity,
+            ...(entry.reuse.timeout === undefined ? {} : { timeout: entry.reuse.timeout }),
+        }))),
+    });
+}
+/** Current preview preserves the read Scope and never creates a Run directory. */
 function withRunnerCurrentReusePreview(input) {
     return effect_1.Effect.scoped(effect_1.Effect.gen(function* () {
-        const rootResult = (0, root_ts_1.makeRecordRoot)((0, node_path_1.resolve)(input.niceevalRoot, "record"));
-        if (effect_1.Either.isLeft(rootResult))
-            return yield* effect_1.Effect.fail(rootResult.left);
-        const root = rootResult.right;
+        const startedAt = asUtcMillis(input.startedAt);
+        if (effect_1.Either.isLeft(startedAt))
+            return yield* effect_1.Effect.fail(startedAt.left);
+        const planned = yield* effect_1.Effect.forEach(input.runs, (run) => planRun({
+            run,
+            evals: input.evals,
+            reuse: input.reuse,
+        }), { concurrency: 1 });
+        const previewRuns = [];
+        for (const plan of planned) {
+            const runId = previewRunId(plan.run);
+            if (effect_1.Either.isLeft(runId))
+                return yield* effect_1.Effect.fail(runId.left);
+            previewRuns.push(targetFor({ planned: plan, runId: runId.right, startedAt: startedAt.right }));
+        }
+        const target = Object.freeze({
+            invocationId: `preview-${(0, node_crypto_1.createHash)("sha256").update(String(input.startedAt), "utf8").digest("hex")}`,
+            runs: Object.freeze(previewRuns),
+        });
         const fileSystem = yield* services_ts_1.RecordFileSystem;
-        if ((yield* fileSystem.pathKind((0, services_ts_1.recordPortablePath)(root))) === "missing") {
-            const target = yield* previewExecutionTarget({
-                startedAt: input.startedAt,
-                evals: input.evals,
-                runs: input.runs,
-                reuse: input.reuse,
-            });
-            const reusePlan = yield* (0, reuse_plan_ts_1.planProjectTargetReuseWithoutSources)({
-                target,
-                policy: input.reuse.policy,
-            });
+        const recordDocument = (0, services_ts_1.recordPortablePath)(input.recordRoot, "record.json");
+        if ((yield* fileSystem.pathKind(recordDocument)) === "missing") {
+            const reusePlan = yield* (0, reuse_plan_ts_1.planProjectTargetReuseWithoutSources)({ target, policy: input.reuse.policy });
             return yield* input.use({
                 reusePlan,
                 readReadbacks: () => effect_1.Effect.succeed(Object.freeze([])),
             });
         }
-        const reader = yield* (0, runtime_ts_1.openRecordReader)({ root });
-        const target = yield* previewExecutionTarget({
-            startedAt: input.startedAt,
-            evals: input.evals,
-            runs: input.runs,
-            reuse: input.reuse,
-        });
-        const reusePlan = yield* (0, reuse_plan_ts_1.planProjectTargetReuse)({
-            view: reader,
-            target,
-            policy: input.reuse.policy,
-        });
+        const reader = yield* runtime_ts_1.recordHost.current.openRead({ root: input.recordRoot });
+        const reusePlan = yield* (0, reuse_plan_ts_1.planProjectTargetReuse)({ reader, target, policy: input.reuse.policy });
         return yield* input.use({
             reusePlan,
-            readReadbacks: () => (0, reuse_readback_ts_1.readCurrentExecutionReusePlanReadbacks)({
-                view: reader,
-                plan: reusePlan,
-            }),
+            readReadbacks: () => (0, reuse_readback_ts_1.readCurrentExecutionReusePlanReadbacks)({ reader, plan: reusePlan }),
         });
     }));
 }
-function previewExecutionTarget(input) {
-    return effect_1.Effect.gen(function* () {
-        const entropy = yield* services_ts_1.RecordEntropy;
-        const experimentIds = new Set();
-        for (const run of input.runs) {
-            if (experimentIds.has(run.experimentId)) {
-                return yield* effect_1.Effect.fail(Object.freeze({
-                    code: "runner-record-target-identity-invalid",
-                    kind: "invocation",
-                    value: `duplicate experimentId ${JSON.stringify(run.experimentId)}`,
-                }));
-            }
-            experimentIds.add(run.experimentId);
-        }
-        const plannedRuns = [];
-        const usedSlotIds = new Set();
-        for (const run of input.runs) {
-            plannedRuns.push(yield* planRun({
-                run,
-                evals: input.evals,
-                reuse: input.reuse,
-                usedSlotIds,
-                entropy,
-            }));
-        }
-        const usedRunIds = new Set();
-        const targetRuns = [];
-        for (const planned of plannedRuns) {
-            const runId = yield* mintPreviewRunId(entropy, usedRunIds);
-            usedRunIds.add(runId);
-            targetRuns.push(Object.freeze({
-                runId,
-                experimentId: planned.run.experimentId,
-                startedAt: asUtcMillis(input.startedAt),
-                slots: Object.freeze(planned.slotEntries.map((entry) => Object.freeze({
-                    runId,
-                    slotId: entry.slotId,
-                    experimentId: planned.run.experimentId,
-                    evalId: entry.evalDef.id,
-                    attempt: entry.attempt,
-                    inputIdentity: entry.reuse.inputIdentity,
-                    configIdentity: entry.reuse.configIdentity,
-                    ...(entry.reuse.timeout === undefined ? {} : { timeout: entry.reuse.timeout }),
-                }))),
+function assertionsWrite(sealed, input = {}) {
+    let entryIndex = 0;
+    const entryIds = [];
+    const producer = (0, attachment_ts_1.createAssertionsAttachmentProducer)({
+        entryIds: {
+            next: () => input.entryIds?.[entryIndex++] ?? `ae_${(0, node_crypto_1.randomBytes)(10).toString("hex")}`,
+        },
+        write: catalog_ts_1.assertionsRecordFamily.write,
+    });
+    for (const entry of sealed.entries) {
+        const appended = producer.append((0, attachment_ts_1.encodeSealedAssertionEntry)(entry));
+        if (effect_1.Either.isLeft(appended)) {
+            return effect_1.Either.left(Object.freeze({
+                code: "runner-record-assertions-invalid",
+                issue: appended.left,
             }));
         }
-        return Object.freeze({
-            invocationId: yield* mintInvocationId(entropy),
-            runs: Object.freeze(targetRuns),
-        });
-    });
-}
-function attemptInvalid() {
-    return Object.freeze({ code: "runner-record-attempt-invalid" });
-}
-function locatorCollision(locator) {
-    return Object.freeze({ code: "attempt-locator-collision", locator });
-}
-function unsealedAttempt(slotId) {
-    return Object.freeze({
-        code: "runner-record-attempt-unsealed",
-        slotId,
-    });
-}
-function executionDurationInvalid(slotId) {
-    return Object.freeze({
-        code: "runner-record-execution-duration-invalid",
-        slotId,
-    });
-}
-function membershipStateInvalid(slotId) {
-    return Object.freeze({
-        code: "runner-record-membership-state-invalid",
-        slotId,
-    });
+        entryIds.push(appended.right);
+    }
+    const complete = producer.seal({ sourceSites: input.sourceSites });
+    return effect_1.Either.isLeft(complete)
+        ? effect_1.Either.left(Object.freeze({
+            code: "runner-record-assertions-invalid",
+            issue: complete.left,
+        }))
+        : effect_1.Either.right(Object.freeze({
+            write: complete.right,
+            entryIds: Object.freeze(entryIds),
+        }));
 }
-function observabilityContractInvalid(errors) {
-    return Object.freeze({
-        code: "runner-record-observability-contract-invalid",
-        errors: Object.freeze([...errors]),
+function artifactsWrite(input) {
+    const write = (0, index_ts_1.makeFixedRecordAttachmentWrite)(input.write, (blobs) => {
+        const drafts = [];
+        const artifacts = input.artifacts.map((artifact) => {
+            const bytes = new Uint8Array(artifact.bytes);
+            const draft = blobs.add((0, index_ts_1.makeRecordBlobSource)(effect_1.Stream.succeed(bytes)));
+            drafts.push(draft);
+            return Object.freeze({
+                artifactId: `art_${(0, node_crypto_1.randomBytes)(10).toString("hex")}`,
+                mediaType: artifact.mediaType,
+                label: artifact.label,
+                byteLength: bytes.byteLength,
+                sha256: (0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex"),
+                content: draft.ref,
+            });
+        }).sort((left, right) => left.artifactId.localeCompare(right.artifactId));
+        const decoded = effect_1.Schema.validateEither(artifacts_ts_1.ArtifactsAttachmentSchema, core_ts_1.RecordExactParseOptions)(Object.freeze({
+            collection: input.omittedAtLeast === undefined
+                ? Object.freeze({ state: "complete", limitations: [] })
+                : Object.freeze({
+                    state: "partial",
+                    limitations: Object.freeze([Object.freeze({
+                            code: "unsupported-input",
+                            omittedAtLeast: input.omittedAtLeast,
+                        })]),
+                }),
+            artifacts: Object.freeze(artifacts),
+        }));
+        if (effect_1.Either.isLeft(decoded)) {
+            throw new Error("Artifacts collector produced an invalid fixed-family payload");
+        }
+        return Object.freeze({ payload: decoded.right, blobs: Object.freeze(drafts) });
     });
+    const closure = (0, index_ts_1.validateRecordAttachmentWrite)(write);
+    return effect_1.Either.isLeft(closure)
+        ? effect_1.Either.left(Object.freeze({
+            code: "runner-record-artifacts-invalid",
+            owner: input.owner,
+            reason: "attachment-closure-invalid",
+        }))
+        : effect_1.Either.right(write);
 }
-/** The Record writer is the only boundary that reintroduces durable payload shapes. */
-function durableExecutionIdentity(identity) {
-    return Object.freeze({
-        domain: identity.domain,
-        value: identity.value,
+function attemptArtifactsWrite(result) {
+    const captures = [];
+    let omittedAtLeast = 0;
+    const appendJson = (label, value) => {
+        let encoded;
+        try {
+            encoded = JSON.stringify(value);
+        }
+        catch {
+            omittedAtLeast += 1;
+            return;
+        }
+        if (encoded === undefined) {
+            omittedAtLeast += 1;
+            return;
+        }
+        const bytes = new TextEncoder().encode(encoded);
+        if (bytes.byteLength > 64 * 1024 * 1024) {
+            omittedAtLeast += 1;
+            return;
+        }
+        captures.push(Object.freeze({
+            mediaType: "application/json",
+            label,
+            bytes,
+        }));
+    };
+    // This is the host-side receipt from a sandbox Agent setup callback. It is
+    // deliberately an Artifact rather than Observability: it answers what was
+    // installed, without making a sixth family or reconstructing sandbox files.
+    if (result.agentSetup !== undefined)
+        appendJson("agent-setup.json", result.agentSetup);
+    if (result.trace !== undefined && result.trace.length > 0) {
+        appendJson("otel-trace.json", result.trace);
+    }
+    // No collector input means the outer Host state stays `not-recorded`;
+    // a known empty artifact collection would instead claim that one ran.
+    if (captures.length === 0 && omittedAtLeast === 0)
+        return effect_1.Either.right(undefined);
+    return artifactsWrite({
+        owner: "attempt",
+        write: catalog_ts_1.attemptArtifactsRecordFamily.write,
+        artifacts: Object.freeze(captures),
+        ...(omittedAtLeast === 0 ? {} : { omittedAtLeast }),
     });
 }
-function durableExecutionDuration(limit) {
-    return Object.freeze({
-        domain: limit.domain,
-        milliseconds: limit.milliseconds,
+function runArtifactsWrite() {
+    return artifactsWrite({
+        owner: "run",
+        write: catalog_ts_1.runArtifactsRecordFamily.write,
+        artifacts: Object.freeze([]),
     });
 }
-function durableEligibility(input) {
-    return Object.freeze({
-        reuseContract: durableExecutionIdentity(input.reuseContract),
-        inputIdentity: durableExecutionIdentity(input.inputIdentity),
-        configIdentity: durableExecutionIdentity(input.configIdentity),
-        executionDuration: durableExecutionDuration(input.executionDuration),
+function attemptObservabilityWrite(input) {
+    return effect_1.Effect.gen(function* () {
+        const capture = yield* (0, runner_producer_ts_1.createRunnerAttemptObservabilityCapture)(input).pipe(effect_1.Effect.mapError(() => Object.freeze({
+            code: "runner-record-observability-invalid",
+            owner: "attempt",
+            stage: "capture",
+        })));
+        const write = (0, family_writers_ts_1.createAttemptObservabilityAttachmentWrite)(capture);
+        if (effect_1.Either.isLeft(write)) {
+            return yield* effect_1.Effect.fail(Object.freeze({
+                code: "runner-record-observability-invalid",
+                owner: "attempt",
+                stage: "attachment",
+            }));
+        }
+        return write.right;
     });
 }
-function durableMembershipPolicy(identity) {
-    return Object.freeze({ name: identity.name, version: identity.version });
-}
-function durableMembershipOrigin(origin) {
-    return Object.freeze({ runId: origin.runId, slotId: origin.slotId });
-}
-function durableMembershipBarrier(barrier) {
-    return Object.freeze({ runId: barrier.runId, startedAt: barrier.startedAt });
-}
-function durableMembershipComparison(comparison) {
-    return Object.freeze({
-        attachment: comparison.attachment,
-        recordedClaim: comparison.recordedClaim,
-        sourceState: comparison.sourceState,
-        result: comparison.result,
-        reason: comparison.reason,
+function runObservabilityWrite(run) {
+    return effect_1.Effect.gen(function* () {
+        const capture = yield* (0, runner_producer_ts_1.createRunnerRunObservabilityCapture)({ run }).pipe(effect_1.Effect.mapError(() => Object.freeze({
+            code: "runner-record-observability-invalid",
+            owner: "run",
+            stage: "capture",
+        })));
+        const write = (0, family_writers_ts_1.createRunObservabilityAttachmentWrite)(capture);
+        if (effect_1.Either.isLeft(write)) {
+            return yield* effect_1.Effect.fail(Object.freeze({
+                code: "runner-record-observability-invalid",
+                owner: "run",
+                stage: "attachment",
+            }));
+        }
+        return write.right;
     });
 }
-function durableMembershipComparisons(comparisons) {
-    return Object.freeze(comparisons.map(durableMembershipComparison));
+function outcomeFor(result) {
+    switch (result.verdict) {
+        case "passed":
+        case "failed":
+            return "completed";
+        case "errored":
+            return "errored";
+        case "skipped":
+            return "cancelled";
+    }
 }
-function durableMembershipEffectiveOptions(options) {
-    return Object.freeze({
-        rerun: options.rerun,
-        keepSandbox: options.keepSandbox,
-        reuseContract: Object.freeze({
-            domain: options.reuseContract.domain,
-            value: options.reuseContract.value,
-        }),
-    });
+function attemptInvalid() {
+    return Object.freeze({ code: "runner-record-attempt-invalid" });
 }
-function gapFromPlan(slot) {
-    return Object.freeze({
-        reason: slot.reason,
-        scope: slot.scope,
-        issues: Object.freeze([...slot.issues]),
-        ...(slot.sourceBarrier === undefined
-            ? {}
-            : { sourceBarrier: durableMembershipBarrier(slot.sourceBarrier) }),
-    });
+function unsealedAttempt(slotId) {
+    return Object.freeze({ code: "runner-record-attempt-unsealed", slotId });
 }
-function executionDuration(result) {
-    // runAttemptEffect's final map guarantees executionMs for executed attempts.
-    const duration = result.executionMs;
-    return typeof duration === "number" && Number.isFinite(duration) && duration >= 0
-        ? duration
-        : undefined;
+function membershipStateInvalid(slotId) {
+    return Object.freeze({ code: "runner-record-membership-state-invalid", slotId });
 }
-function resultMatchesAttempt(result, attempt) {
-    return result.id === attempt.evalDef.id
-        && result.attempt === attempt.attempt
-        && result.experimentId === attempt.run.experimentId
-        && result.fingerprint === attempt.fingerprint
-        && result.configHash === attempt.configHash;
+function publishStateInvalid(runId) {
+    return Object.freeze({ code: "runner-record-publish-state-invalid", runId });
 }
 /**
- * Opens one scoped Record writer before expensive work, allocates all target
- * identities, and uses only its frozen view to decide exact references.
+ * Opens one new per-Experiment Run session, selects only sealed historical
+ * Runs, and writes carry references before dispatch. No global Record writer
+ * lock or legacy draft/attachment contract participates in this boundary.
  */
 function openRunnerRecordCoordinator(input) {
     return effect_1.Effect.gen(function* () {
-        // Product scope is one selected Experiment to one durable Run. Reject this
-        // before opening a writer so a duplicate input cannot leave partial drafts
-        // or silently overwrite the public run-id mapping.
-        const experimentIds = new Set();
+        const seenExperiments = new Set();
         for (const run of input.runs) {
-            if (experimentIds.has(run.experimentId)) {
+            if (seenExperiments.has(run.experimentId)) {
                 return yield* effect_1.Effect.fail({
                     code: "runner-record-target-identity-invalid",
                     kind: "invocation",
                     value: `duplicate experimentId ${JSON.stringify(run.experimentId)}`,
                 });
             }
-            experimentIds.add(run.experimentId);
-        }
-        const rootResult = (0, root_ts_1.makeRecordRoot)((0, node_path_1.resolve)(input.niceevalRoot, "record"));
-        if (effect_1.Either.isLeft(rootResult)) {
-            return yield* effect_1.Effect.fail(rootResult.left);
-        }
-        const session = yield* (0, runtime_ts_2.openRecordWriteSession)({ root: rootResult.right });
-        const entropy = yield* services_ts_1.RecordEntropy;
-        const plannedRuns = [];
-        const usedSlotIds = new Set();
-        for (const run of input.runs) {
-            const planned = yield* planRun({
-                run,
-                evals: input.evals,
-                reuse: input.reuse,
-                usedSlotIds,
-                entropy,
-            });
-            plannedRuns.push(planned);
+            seenExperiments.add(run.experimentId);
         }
+        const startedAt = asUtcMillis(input.startedAt);
+        if (effect_1.Either.isLeft(startedAt))
+            return yield* effect_1.Effect.fail(startedAt.left);
+        const planned = yield* effect_1.Effect.forEach(input.runs, (run) => planRun({
+            run,
+            evals: input.evals,
+            reuse: input.reuse,
+        }), { concurrency: 1 });
+        const openedRuns = yield* effect_1.Effect.forEach(planned, (plan) => runtime_ts_1.recordHost.current.createRun({
+            root: input.recordRoot,
+            experimentId: plan.experimentId,
+            context: plan.context,
+            startedAt: startedAt.right,
+            expectedSlots: plan.expectedSlots,
+        }).pipe(effect_1.Effect.map((session) => Object.freeze({ plan, session }))), { concurrency: 1 });
+        const reader = yield* runtime_ts_1.recordHost.current.openRead({ root: input.recordRoot });
+        const fileSystem = yield* services_ts_1.RecordFileSystem;
         const byRun = new Map();
         const byRecordRunId = new Map();
         const runIdsByExperiment = new Map();
         const targetRuns = [];
-        for (const planned of plannedRuns) {
-            const draft = yield* session.createRun({
-                startedAt: asUtcMillis(input.startedAt),
-                expectedSlots: planned.expectedSlots,
-            });
-            const target = Object.freeze({
-                runId: draft.runId,
-                experimentId: planned.run.experimentId,
-                startedAt: asUtcMillis(input.startedAt),
-                slots: Object.freeze(planned.slotEntries.map((entry) => Object.freeze({
-                    runId: draft.runId,
-                    slotId: entry.slotId,
-                    experimentId: planned.run.experimentId,
-                    evalId: entry.evalDef.id,
-                    attempt: entry.attempt,
-                    inputIdentity: entry.reuse.inputIdentity,
-                    configIdentity: entry.reuse.configIdentity,
-                    ...(entry.reuse.timeout === undefined ? {} : { timeout: entry.reuse.timeout }),
-                }))),
-            });
+        for (const { plan, session } of openedRuns) {
+            const target = targetFor({ planned: plan, runId: session.runId, startedAt: startedAt.right });
             const recordRun = {
-                ...planned,
-                draft,
+                ...plan,
+                session,
                 target,
                 attempts: new Map(),
                 planSlots: new Map(),
                 gapActions: new Map(),
             };
-            byRun.set(planned.run, recordRun);
-            byRecordRunId.set(draft.runId, recordRun);
-            runIdsByExperiment.set(planned.run.experimentId, draft.runId);
+            byRun.set(plan.run, recordRun);
+            byRecordRunId.set(session.runId, recordRun);
+            runIdsByExperiment.set(plan.run.experimentId, session.runId);
             targetRuns.push(target);
         }
         const target = Object.freeze({
-            invocationId: yield* mintInvocationId(entropy),
+            invocationId: (0, node_crypto_1.createHash)("sha256")
+                .update(`${input.startedAt}\u0000${planned.map((entry) => entry.run.experimentId).join("\u0000")}`, "utf8")
+                .digest("hex"),
             runs: Object.freeze(targetRuns),
         });
-        const reusePlan = yield* (0, reuse_plan_ts_1.planProjectTargetReuse)({
-            view: session.view,
-            target,
-            policy: input.reuse.policy,
-        });
+        const reusePlan = yield* (0, reuse_plan_ts_1.planProjectTargetReuse)({ reader, target, policy: input.reuse.policy });
         const carriedAttemptsByKey = new Map();
         for (const slot of reusePlan.slots) {
             const recordRun = byRecordRunId.get(slot.runId);
-            if (recordRun === undefined) {
+            if (recordRun === undefined)
                 return yield* effect_1.Effect.fail(membershipStateInvalid(slot.slotId));
-            }
             recordRun.planSlots.set(slot.slotId, slot);
-            if (slot.state === "gap") {
+            if (slot.state === "reuse") {
+                yield* recordRun.session.referenceAttempt({
+                    slotId: slot.slotId,
+                    action: "carried",
+                    attempt: slot.source.attempt,
+                });
+                const entry = recordRun.slots.get(slotKey(slot.evalId, slot.attempt));
+                if (entry === undefined)
+                    return yield* effect_1.Effect.fail(membershipStateInvalid(slot.slotId));
+                const key = (0, fingerprint_ts_1.cacheKey)(recordRun.run, entry.evalDef.id);
+                const carried = carriedAttemptsByKey.get(key) ?? new Set();
+                carried.add(entry.attempt);
+                carriedAttemptsByKey.set(key, carried);
+            }
+            else {
                 recordRun.gapActions.set(slot.slotId, "pending");
-                continue;
             }
-            const entry = recordRun.slotEntries.find((candidate) => candidate.slotId === slot.slotId);
-            if (entry === undefined)
-                return yield* effect_1.Effect.fail(membershipStateInvalid(slot.slotId));
-            const key = (0, fingerprint_ts_1.cacheKey)(recordRun.run, entry.evalDef.id);
-            const carried = carriedAttemptsByKey.get(key) ?? new Set();
-            carried.add(entry.attempt);
-            carriedAttemptsByKey.set(key, carried);
-        }
-        for (const recordRun of byRun.values()) {
-            const references = recordRun.target.slots.flatMap((targetSlot) => {
-                const slot = recordRun.planSlots.get(targetSlot.slotId);
-                return slot?.state === "reuse"
-                    ? [Object.freeze({ slotId: targetSlot.slotId, attempt: slot.source.attempt })]
-                    : [];
-            });
-            const runWrites = yield* effect_1.Effect.sync(() => input.attachments?.runWrites?.({ run: recordRun.run, evals: input.evals }) ?? []);
-            const plan = yield* index_ts_1.EvaluationRecordContractV1.preparePlan({
-                startedAt: asUtcMillis(input.startedAt),
-                completedAt: asUtcMillis(input.startedAt),
-                expectedSlots: recordRun.expectedSlots,
-                evaluations: recordRun.evaluations,
-                originAttempts: [],
-                references,
-                runWrites,
-            });
-            yield* index_ts_1.EvaluationRecordContractV1.writePlanRunToDraft(recordRun.draft, plan);
-            yield* index_ts_1.EvaluationRecordContractV1.writePlanReferencesToDraft(recordRun.draft, plan);
         }
-        let writeFailure;
-        let interruptionObserved = false;
-        const noteWriteFailure = (error) => {
-            if (writeFailure === undefined)
-                writeFailure = Object.freeze({ error });
+        let invocationWriteFailure;
+        const writeFailuresByRun = new Map();
+        const noteFailure = (error, recordRun) => {
+            if (recordRun === undefined) {
+                if (invocationWriteFailure === undefined)
+                    invocationWriteFailure = error;
+                return;
+            }
+            if (!writeFailuresByRun.has(recordRun))
+                writeFailuresByRun.set(recordRun, error);
         };
-        const locatorMutex = yield* effect_1.Effect.makeSemaphore(1);
-        const invocationLocators = new Map();
-        const recordRunForAttempt = (attempt) => byRun.get(attempt.run);
-        const targetSlotForAttempt = (attempt) => {
-            const recordRun = recordRunForAttempt(attempt);
+        const lock = yield* effect_1.Effect.makeSemaphore(1);
+        const runForAttempt = (attempt) => byRun.get(attempt.run);
+        const targetForAttempt = (attempt) => {
+            const recordRun = runForAttempt(attempt);
             if (recordRun === undefined)
                 return undefined;
-            const slotId = recordRun.slots.get(slotKey(attempt.evalDef.id, attempt.attempt));
-            if (slotId === undefined)
+            const entry = recordRun.slots.get(slotKey(attempt.evalDef.id, attempt.attempt));
+            if (entry === undefined)
                 return undefined;
-            const plan = recordRun.planSlots.get(slotId);
-            return plan === undefined ? undefined : { recordRun, slotId, plan };
+            const plan = recordRun.planSlots.get(entry.slot.slotId);
+            return plan === undefined ? undefined : { recordRun, slotId: entry.slot.slotId, plan };
         };
-        const reserveAttempt = (attempt) => locatorMutex.withPermits(1)(effect_1.Effect.gen(function* () {
-            const targetSlot = targetSlotForAttempt(attempt);
-            if (targetSlot === undefined
-                || targetSlot.plan.state !== "gap"
-                || targetSlot.recordRun.gapActions.get(targetSlot.slotId) !== "pending"
-                || targetSlot.recordRun.attempts.has(targetSlot.slotId)) {
-                return yield* effect_1.Effect.fail(attemptInvalid());
-            }
-            const draft = yield* targetSlot.recordRun.draft.createAttempt({
-                slotId: targetSlot.slotId,
-            });
-            const locator = (0, attempt_locator_ts_1.encodeAttemptLocator)(draft.attemptId);
-            const issued = Object.freeze({
-                slotId: targetSlot.slotId,
-                attemptId: draft.attemptId,
-                locator,
+        const adoptLatePublishedAttempt = (attempt) => lock.withPermits(1)(effect_1.Effect.gen(function* () {
+            const current = targetForAttempt(attempt);
+            if (current === undefined
+                || current.plan.state !== "gap"
+                || current.recordRun.gapActions.get(current.slotId) !== "pending")
+                return false;
+            const freshReader = yield* runtime_ts_1.recordHost.current.openRead({ root: input.recordRoot });
+            const refreshed = yield* (0, reuse_plan_ts_1.planProjectTargetReuse)({
+                reader: freshReader,
+                target,
+                policy: input.reuse.policy,
             });
-            targetSlot.recordRun.attempts.set(targetSlot.slotId, {
-                attempt,
-                draft,
-                public: issued,
-                completed: false,
+            const replacement = refreshed.slots.find((slot) => slot.runId === current.recordRun.target.runId && slot.slotId === current.slotId);
+            if (replacement?.state !== "reuse")
+                return false;
+            yield* current.recordRun.session.referenceAttempt({
+                slotId: current.slotId,
+                action: "carried",
+                attempt: replacement.source.attempt,
             });
-            targetSlot.recordRun.gapActions.set(targetSlot.slotId, "reserved");
-            const existing = yield* (0, attempt_locator_resolution_ts_1.resolveAttemptLocator)(session.view, locator);
-            if (existing.kind !== "not-found") {
-                const same = existing.kind === "found"
-                    && existing.attempt.originRunId === targetSlot.recordRun.draft.runId
-                    && existing.attempt.attemptId === draft.attemptId;
-                if (!same)
-                    return yield* effect_1.Effect.fail(locatorCollision(locator));
-            }
-            const local = invocationLocators.get(locator);
-            if (local !== undefined
-                && (local.originRunId !== targetSlot.recordRun.draft.runId
-                    || local.attemptId !== draft.attemptId)) {
-                return yield* effect_1.Effect.fail(locatorCollision(locator));
-            }
-            invocationLocators.set(locator, Object.freeze({
-                originRunId: targetSlot.recordRun.draft.runId,
-                attemptId: draft.attemptId,
-            }));
-            return issued;
-        })).pipe(effect_1.Effect.tapError((error) => effect_1.Effect.sync(() => noteWriteFailure(error))));
+            current.recordRun.planSlots.set(current.slotId, replacement);
+            current.recordRun.gapActions.delete(current.slotId);
+            return true;
+        }));
+        const reserveAttempt = (attempt) => {
+            const targetSlot = targetForAttempt(attempt);
+            return lock.withPermits(1)(effect_1.Effect.gen(function* () {
+                if (targetSlot === undefined
+                    || targetSlot.plan.state !== "gap"
+                    || targetSlot.recordRun.gapActions.get(targetSlot.slotId) !== "pending") {
+                    return yield* effect_1.Effect.fail(attemptInvalid());
+                }
+                const session = yield* targetSlot.recordRun.session.createAttempt({ slotId: targetSlot.slotId });
+                const publicAttempt = Object.freeze({
+                    slotId: targetSlot.slotId,
+                    attemptId: session.attemptId,
+                    locator: (0, attempt_locator_ts_1.encodeAttemptLocator)(session.attemptId),
+                });
+                targetSlot.recordRun.attempts.set(targetSlot.slotId, {
+                    attempt,
+                    session,
+                    public: publicAttempt,
+                    completed: false,
+                });
+                targetSlot.recordRun.gapActions.set(targetSlot.slotId, "reserved");
+                return publicAttempt;
+            })).pipe(effect_1.Effect.tapError((error) => effect_1.Effect.sync(() => noteFailure(error, targetSlot?.recordRun ?? runForAttempt(attempt)))));
+        };
         const noteSealedOrMarkIncomplete = (attempt, sealed) => effect_1.Effect.sync(() => {
-            const targetSlot = targetSlotForAttempt(attempt);
+            const targetSlot = targetForAttempt(attempt);
+            const active = targetSlot === undefined
+                ? undefined
+                : targetSlot.recordRun.attempts.get(targetSlot.slotId);
             if (targetSlot === undefined
                 || targetSlot.plan.state !== "gap"
-                || targetSlot.recordRun.gapActions.get(targetSlot.slotId) !== "reserved") {
-                noteWriteFailure(attemptInvalid());
-                return;
-            }
-            const active = targetSlot.recordRun.attempts.get(targetSlot.slotId);
-            if (active === undefined || active.attempt !== attempt || active.sealed !== undefined) {
-                noteWriteFailure(attemptInvalid());
+                || targetSlot.recordRun.gapActions.get(targetSlot.slotId) !== "reserved"
+                || active === undefined
+                || active.attempt !== attempt
+                || active.sealed !== undefined) {
+                noteFailure(attemptInvalid(), targetSlot?.recordRun ?? runForAttempt(attempt));
                 return;
             }
             active.sealed = sealed;
-            targetSlot.recordRun.gapActions.set(targetSlot.slotId, "sealed");
         });
         const completeAttempt = (attempt, result) => effect_1.Effect.suspend(() => {
-            const targetSlot = targetSlotForAttempt(attempt);
-            if (targetSlot === undefined)
-                return effect_1.Effect.fail(attemptInvalid());
-            const active = targetSlot.recordRun.attempts.get(targetSlot.slotId);
-            if (targetSlot.plan.state !== "gap"
+            const targetSlot = targetForAttempt(attempt);
+            const active = targetSlot === undefined
+                ? undefined
+                : targetSlot.recordRun.attempts.get(targetSlot.slotId);
+            if (targetSlot === undefined
+                || targetSlot.plan.state !== "gap"
+                || targetSlot.recordRun.gapActions.get(targetSlot.slotId) !== "reserved"
                 || active === undefined
-                || targetSlot.recordRun.gapActions.get(targetSlot.slotId) !== "sealed"
                 || active.attempt !== attempt
-                || active.sealed === undefined
-                || active.completed
-                || !resultMatchesAttempt(result, attempt)) {
+                || active.completed) {
                 return effect_1.Effect.fail(attemptInvalid());
             }
-            const sealed = active.sealed;
-            const duration = executionDuration(result);
-            if (duration === undefined)
-                return effect_1.Effect.fail(executionDurationInvalid(targetSlot.slotId));
-            const eligibility = (0, index_ts_1.buildEligibilityAttachmentWriteV1)(durableEligibility({
-                reuseContract: input.reuse.policy.reuseContract,
-                inputIdentity: targetSlot.plan.inputIdentity,
-                configIdentity: targetSlot.plan.configIdentity,
-                executionDuration: {
-                    domain: index_ts_1.EXECUTION_DURATION_DOMAIN_V1,
-                    milliseconds: duration,
-                },
-            }));
-            if (effect_1.Either.isLeft(eligibility))
-                return effect_1.Effect.fail(eligibility.left);
-            return effect_1.Effect.gen(function* () {
-                const writes = yield* effect_1.Effect.sync(() => input.attachments?.attemptWrites?.({
-                    attempt,
-                    result,
-                    sealed,
-                    sources: Object.freeze([...(result.sources ?? [])]),
-                }) ?? []);
-                const origin = (0, evaluation_record_ts_1.evaluationRecordOriginInputFromSealedAssertions)(targetSlot.slotId, sealed);
-                if (effect_1.Either.isLeft(origin))
-                    return yield* effect_1.Effect.fail(origin.left);
-                // This is the only Runner → Record boundary that sees both the sealed
-                // Assert-first outcome and its final EvalResult. The producer returns
-                // normalized owner facts; the Record adapter constructs the official
-                // typed writes without exposing attachment names or paths to Runner.
-                const observabilityCapture = yield* (0, runner_producer_ts_1.createRunnerAttemptObservabilityCaptureV1)({
-                    result,
-                    sealed,
-                });
-                const observability = (0, family_writers_ts_1.createAttemptObservabilityAttachmentWritesV1)(observabilityCapture);
-                if (effect_1.Either.isLeft(observability))
-                    return yield* effect_1.Effect.fail(observability.left);
-                return yield* effect_1.Effect.uninterruptible(effect_1.Effect.gen(function* () {
-                    active.durable = Object.freeze({
-                        result,
-                        origin: origin.right,
-                        eligibility: eligibility.right,
-                        observability: observability.right,
-                        pluginWrites: Object.freeze([...writes]),
-                        draft: active.draft,
-                    });
-                    active.completed = true;
-                    targetSlot.recordRun.gapActions.set(targetSlot.slotId, "executed");
-                    return active.public;
-                }));
+            const assertions = active.sealed === undefined ? undefined : assertionsWrite(active.sealed);
+            if (assertions !== undefined && effect_1.Either.isLeft(assertions))
+                return effect_1.Effect.fail(assertions.left);
+            return effect_1.Effect.sync(() => {
+                // Sources is Run-owned, so its exact closure and the dependent
+                // Assertion source-site joins can only be fixed after all concurrent
+                // origins in this Run have finished. The real Attempt is still
+                // completed only after its fixed writes have been accepted below.
+                active.result = result;
+                if (assertions !== undefined && effect_1.Either.isRight(assertions)) {
+                    active.assertionEntryIds = assertions.right.entryIds;
+                }
+                active.completed = true;
+                targetSlot.recordRun.gapActions.set(targetSlot.slotId, "executed");
+                return active.public;
             });
         });
-        const completeAttemptOrMarkIncomplete = (attempt, result) => completeAttempt(attempt, result).pipe(effect_1.Effect.catchAll((error) => effect_1.Effect.sync(() => {
-            noteWriteFailure(error);
-            return undefined;
-        })));
-        const markNotDispatched = (attempt) => {
-            const targetSlot = targetSlotForAttempt(attempt);
-            if (targetSlot === undefined || targetSlot.plan.state !== "gap")
-                return;
-            if (targetSlot.recordRun.gapActions.get(targetSlot.slotId) === "pending") {
-                targetSlot.recordRun.gapActions.set(targetSlot.slotId, "not-dispatched");
+        const writeFixedFamiliesForRun = (recordRun, mode) => effect_1.Effect.gen(function* () {
+            const origins = [];
+            const terminalAttempts = [];
+            for (const [slotId, state] of recordRun.gapActions) {
+                if (state !== "executed" && !(mode === "interrupted" && state === "reserved"))
+                    continue;
+                const active = recordRun.attempts.get(slotId);
+                if (active === undefined)
+                    return yield* effect_1.Effect.fail(membershipStateInvalid(slotId));
+                const result = active.result;
+                terminalAttempts.push(Object.freeze({ slotId, active, result }));
+                const sealed = active?.sealed;
+                const assertionEntryIds = active?.assertionEntryIds;
+                if (result === undefined || sealed === undefined || assertionEntryIds === undefined)
+                    continue;
+                origins.push(Object.freeze({ slotId, active, result, sealed, assertionEntryIds }));
             }
-        };
-        const markInterrupted = () => {
-            interruptionObserved = true;
-            for (const recordRun of byRun.values()) {
-                for (const [slotId, state] of recordRun.gapActions) {
-                    if (state === "pending") {
-                        recordRun.gapActions.set(slotId, "interrupted");
-                    }
-                }
+            const sources = (0, source_producer_ts_1.createRunnerSourceWritePlan)(origins.map(({ slotId, result, assertionEntryIds }) => Object.freeze({
+                slotId,
+                result,
+                assertionEntryIds,
+            })));
+            if (effect_1.Either.isLeft(sources)) {
+                return yield* effect_1.Effect.fail(Object.freeze({
+                    code: "runner-record-sources-invalid",
+                    issue: sources.left,
+                }));
             }
-        };
-        const membershipActionsFor = (recordRun) => {
-            const actions = [];
-            for (const targetSlot of recordRun.target.slots) {
-                const slot = recordRun.planSlots.get(targetSlot.slotId);
-                if (slot === undefined)
-                    return effect_1.Either.left(membershipStateInvalid(targetSlot.slotId));
-                if (slot.state === "reuse") {
-                    actions.push(Object.freeze({
-                        action: "carried",
-                        slotId: slot.slotId,
-                        attemptId: slot.source.attemptId,
-                        origin: durableMembershipOrigin(slot.source.origin),
-                        sourceBarrier: durableMembershipBarrier(slot.source.sourceBarrier),
-                        comparisons: durableMembershipComparisons(slot.comparisons),
-                    }));
+            yield* recordRun.session.writeSources(sources.right.runWrite);
+            const richBySlot = new Map(origins.map((origin) => [origin.slotId, origin]));
+            for (const terminal of terminalAttempts) {
+                const { slotId, active, result } = terminal;
+                const rich = richBySlot.get(slotId);
+                if (rich === undefined) {
+                    if (result === undefined && mode !== "interrupted") {
+                        return yield* effect_1.Effect.fail(membershipStateInvalid(slotId));
+                    }
+                    yield* active.session.complete(result === undefined ? "interrupted" : outcomeFor(result));
+                    recordRun.gapActions.set(slotId, "executed");
                     continue;
                 }
-                const state = recordRun.gapActions.get(slot.slotId) ?? "pending";
-                const gap = gapFromPlan(slot);
-                if (state === "reserved" || state === "sealed") {
-                    return effect_1.Either.left(unsealedAttempt(slot.slotId));
+                const { result: richResult, sealed, assertionEntryIds } = rich;
+                const assertions = assertionsWrite(sealed, {
+                    entryIds: assertionEntryIds,
+                    sourceSites: sources.right.sourceSitesBySlot.get(slotId) ?? Object.freeze([]),
+                });
+                if (effect_1.Either.isLeft(assertions))
+                    return yield* effect_1.Effect.fail(assertions.left);
+                yield* active.session.writeAssertions(assertions.right.write);
+                const observability = yield* attemptObservabilityWrite({ result: richResult, sealed });
+                yield* active.session.writeAttemptObservability(observability);
+                const observabilityContents = (0, internal_ts_1.recordAttachmentWriteContents)(observability);
+                if (effect_1.Either.isLeft(observabilityContents)) {
+                    return yield* effect_1.Effect.fail(Object.freeze({
+                        code: "runner-record-observability-invalid",
+                        owner: "attempt",
+                        stage: "attachment",
+                    }));
                 }
-                if (state === "executed") {
-                    const active = recordRun.attempts.get(slot.slotId);
-                    if (active === undefined || !active.completed) {
-                        return effect_1.Either.left(membershipStateInvalid(slot.slotId));
-                    }
-                    actions.push(Object.freeze({
-                        action: "executed",
-                        slotId: slot.slotId,
-                        attemptId: active.public.attemptId,
-                        gap,
-                        comparisons: durableMembershipComparisons(slot.comparisons),
+                const navigation = (0, source_producer_ts_1.createRunnerSourceNavigationWrite)({
+                    result: richResult,
+                    sources: sources.right.sources,
+                    observability: observabilityContents.right.payload,
+                });
+                if (effect_1.Either.isLeft(navigation)) {
+                    return yield* effect_1.Effect.fail(Object.freeze({
+                        code: "runner-record-sources-invalid",
+                        issue: navigation.left,
                     }));
-                    continue;
                 }
-                actions.push(Object.freeze({
-                    action: state === "interrupted" ? "interrupted" : "not-dispatched",
-                    slotId: slot.slotId,
-                    gap,
-                    comparisons: durableMembershipComparisons(slot.comparisons),
-                }));
+                yield* active.session.writeSourceNavigation(navigation.right);
+                const fileChangesCapture = (0, sandbox_record_producer_ts_1.runnerAttemptFileChangesCaptureForResult)(richResult);
+                if (fileChangesCapture !== undefined) {
+                    yield* active.session.writeFileChanges((0, diff_ts_1.createFileChangesCaptureAttachmentWrite)(fileChangesCapture));
+                }
+                const artifacts = attemptArtifactsWrite(richResult);
+                if (effect_1.Either.isLeft(artifacts))
+                    return yield* effect_1.Effect.fail(artifacts.left);
+                if (artifacts.right !== undefined) {
+                    yield* active.session.writeAttemptArtifacts(artifacts.right);
+                }
+                yield* active.session.complete(outcomeFor(richResult));
+                recordRun.gapActions.set(slotId, "executed");
+            }
+            const observability = yield* runObservabilityWrite(recordRun.run);
+            yield* recordRun.session.writeRunObservability(observability);
+            const artifacts = runArtifactsWrite();
+            if (effect_1.Either.isLeft(artifacts))
+                return yield* effect_1.Effect.fail(artifacts.left);
+            yield* recordRun.session.writeRunArtifacts(artifacts.right);
+        });
+        const pendingGap = (recordRun) => {
+            for (const [slotId, state] of recordRun.gapActions) {
+                if (state === "pending")
+                    return slotId;
             }
-            return effect_1.Either.right(Object.freeze(actions));
+            return undefined;
         };
         return Object.freeze({
             reusePlan,
-            readCarriedResults: () => (0, reuse_readback_ts_1.readCurrentExecutionReusePlanResults)({
-                view: session.view,
-                plan: reusePlan,
-            }),
+            readCarriedResults: () => (0, reuse_readback_ts_1.readCurrentExecutionReusePlanResults)({ reader, plan: reusePlan }),
             runIdsByExperiment: new Map(runIdsByExperiment),
             carriedAttemptsByKey: new Map([...carriedAttemptsByKey].map(([key, attempts]) => [key, new Set(attempts)])),
+            adoptLatePublishedAttempt,
             reserveAttempt,
             noteSealedOrMarkIncomplete,
-            completeAttemptOrMarkIncomplete,
-            markNotDispatched,
-            markInterrupted,
-            publish: (completedAt) => effect_1.Effect.gen(function* () {
-                if (writeFailure !== undefined)
-                    return yield* effect_1.Effect.fail(writeFailure.error);
-                // A reserved origin already has a Core Member. If SIGINT arrives before
-                // its assertions and final result close, that draft must remain
-                // incomplete rather than publishing a Member without complete Attempt
-                // facts. Independent drafts still take the ordinary publish validation.
-                const publishableRuns = [...byRun.values()].filter((recordRun) => !interruptionObserved || ![...recordRun.gapActions.values()].some((state) => state === "reserved" || state === "sealed"));
-                for (const recordRun of publishableRuns) {
-                    const runObservabilityCapture = yield* (0, runner_producer_ts_1.createRunnerRunObservabilityCaptureV1)({
-                        run: recordRun.run,
-                    });
-                    const runObservability = (0, family_writers_ts_1.createRunObservabilityAttachmentWritesV1)(runObservabilityCapture);
-                    if (effect_1.Either.isLeft(runObservability))
-                        return yield* effect_1.Effect.fail(runObservability.left);
-                    const attemptObservability = [];
-                    for (const active of recordRun.attempts.values()) {
-                        if (!active.completed)
-                            continue;
-                        if (active.durable === undefined)
-                            return yield* effect_1.Effect.fail(attemptInvalid());
-                        attemptObservability.push(active.durable.observability);
+            completeAttemptOrMarkIncomplete: (attempt, result) => completeAttempt(attempt, result).pipe(effect_1.Effect.catchAll((error) => effect_1.Effect.sync(() => {
+                noteFailure(error, targetForAttempt(attempt)?.recordRun ?? runForAttempt(attempt));
+                return undefined;
+            }))),
+            markNotDispatched: (attempt) => {
+                const targetSlot = targetForAttempt(attempt);
+                if (targetSlot !== undefined
+                    && targetSlot.plan.state === "gap"
+                    && targetSlot.recordRun.gapActions.get(targetSlot.slotId) === "pending") {
+                    targetSlot.recordRun.gapActions.set(targetSlot.slotId, "not-dispatched");
+                }
+            },
+            publish: (completedAt, mode) => effect_1.Effect.gen(function* () {
+                const recordRuns = [...byRun.values()];
+                if (invocationWriteFailure !== undefined)
+                    return yield* effect_1.Effect.fail(invocationWriteFailure);
+                if (mode === "normal") {
+                    // A normal finish remains invocation-strict: a failure which can be
+                    // attributed to one Run still fails the call rather than allowing a
+                    // partial receipt to disguise it as ordinary completion.
+                    for (const recordRun of recordRuns) {
+                        const failure = writeFailuresByRun.get(recordRun);
+                        if (failure !== undefined)
+                            return yield* effect_1.Effect.fail(failure);
                     }
-                    const observabilityErrors = (0, family_writers_ts_1.validateObservabilityAttachmentWriteBundlesV1)({
-                        run: runObservability.right,
-                        attempts: Object.freeze(attemptObservability),
-                    });
-                    if (observabilityErrors.length > 0) {
-                        return yield* effect_1.Effect.fail(observabilityContractInvalid(observabilityErrors));
+                }
+                const completion = asUtcMillis(completedAt);
+                if (effect_1.Either.isLeft(completion))
+                    return yield* effect_1.Effect.fail(completion.left);
+                // A controlled interruption closes every reserved Attempt as
+                // `interrupted` and every never-started gap as an interrupted terminal
+                // Member. Only a Run-local writer failure remains non-publishable.
+                // Abrupt process loss still has no opportunity to create `complete`.
+                const incompleteRuns = mode === "interrupted"
+                    ? new Set(recordRuns.filter((recordRun) => writeFailuresByRun.has(recordRun)))
+                    : new Set();
+                if (mode === "normal") {
+                    // Normal completion is deliberately invocation-strict. A pending
+                    // gap means the scheduler failed to account for a Slot; a reserved
+                    // or otherwise unsettled Attempt is likewise not publishable.
+                    for (const recordRun of recordRuns) {
+                        const unsettledSlot = [...recordRun.gapActions.keys()].find((slotId) => {
+                            const active = recordRun.attempts.get(slotId);
+                            return recordRun.gapActions.get(slotId) === "reserved"
+                                || (active !== undefined && !active.completed);
+                        });
+                        if (unsettledSlot !== undefined)
+                            return yield* effect_1.Effect.fail(unsealedAttempt(unsettledSlot));
+                        const unaccountedSlot = pendingGap(recordRun);
+                        if (unaccountedSlot !== undefined)
+                            return yield* effect_1.Effect.fail(unsealedAttempt(unaccountedSlot));
                     }
-                    const sourceOrigins = [];
-                    const sandboxOrigins = [];
-                    for (const [slotId, active] of recordRun.attempts) {
-                        if (!active.completed)
+                }
+                else {
+                    for (const recordRun of recordRuns) {
+                        if (incompleteRuns.has(recordRun))
                             continue;
-                        if (active.durable === undefined)
-                            return yield* effect_1.Effect.fail(attemptInvalid());
-                        sourceOrigins.push(Object.freeze({
-                            slotId,
-                            result: active.durable.result,
-                            assertions: active.durable.origin.assertions,
-                        }));
-                        sandboxOrigins.push(Object.freeze({
-                            slotId,
-                            sandbox: active.durable.result.sandbox,
-                        }));
+                        for (const [slotId, state] of recordRun.gapActions) {
+                            if (state === "pending")
+                                recordRun.gapActions.set(slotId, "interrupted");
+                        }
                     }
-                    const sourcePlan = (0, source_producer_ts_1.createRunnerSourceWritePlan)(sourceOrigins);
-                    if (effect_1.Either.isLeft(sourcePlan))
-                        return yield* effect_1.Effect.fail(sourcePlan.left);
-                    const sandboxPlan = (0, sandbox_record_producer_ts_1.createRunnerSandboxWritePlan)(sandboxOrigins);
-                    if (effect_1.Either.isLeft(sandboxPlan))
-                        return yield* effect_1.Effect.fail(sandboxPlan.left);
-                    const originPlans = [];
-                    for (const [slotId, active] of recordRun.attempts) {
-                        if (!active.completed)
-                            continue;
-                        const durable = active.durable;
-                        if (durable === undefined || sourcePlan.right === undefined) {
-                            return yield* effect_1.Effect.fail(attemptInvalid());
+                }
+                const publishableRuns = recordRuns.filter((recordRun) => !incompleteRuns.has(recordRun));
+                const publishOne = (recordRun) => effect_1.Effect.gen(function* () {
+                    yield* writeFixedFamiliesForRun(recordRun, mode);
+                    for (const [slotId, state] of recordRun.gapActions) {
+                        if (state === "not-dispatched" || state === "interrupted") {
+                            yield* recordRun.session.recordTerminalMember({ slotId, action: state });
                         }
-                        const sourceSites = sourcePlan.right.attemptWrites.get(slotId);
-                        if (sourceSites === undefined)
-                            return yield* effect_1.Effect.fail(attemptInvalid());
-                        const sandboxWrite = sandboxPlan.right.attemptWrites.get(slotId);
-                        if (sandboxWrite === undefined)
-                            return yield* effect_1.Effect.fail(attemptInvalid());
-                        const plan = yield* index_ts_1.EvaluationRecordContractV1.preparePlan({
-                            startedAt: asUtcMillis(input.startedAt),
-                            completedAt: asUtcMillis(completedAt),
-                            expectedSlots: recordRun.expectedSlots,
-                            evaluations: recordRun.evaluations,
-                            originAttempts: [Object.freeze({
-                                    ...durable.origin,
-                                    writes: Object.freeze([
-                                        durable.eligibility,
-                                        ...(durable.origin.writes ?? []),
-                                        durable.observability.conversation,
-                                        durable.observability.commands,
-                                        durable.observability.usage,
-                                        durable.observability.timing,
-                                        durable.observability.diagnostics,
-                                        ...durable.pluginWrites,
-                                        sourceSites,
-                                        sandboxWrite,
-                                    ]),
-                                })],
-                        });
-                        originPlans.push(Object.freeze({ slotId, draft: durable.draft, plan }));
                     }
-                    const actions = membershipActionsFor(recordRun);
-                    if (effect_1.Either.isLeft(actions))
-                        return yield* effect_1.Effect.fail(actions.left);
-                    const provenance = (0, index_ts_1.buildMembershipProvenanceAttachmentWriteV1)({
-                        policy: durableMembershipPolicy(reusePlan.policy),
-                        effectiveOptions: durableMembershipEffectiveOptions(reusePlan.effectiveOptions),
-                        actions: actions.right,
-                    });
-                    if (effect_1.Either.isLeft(provenance))
-                        return yield* effect_1.Effect.fail(provenance.left);
-                    yield* recordRun.draft.record(runObservability.right.timing);
-                    yield* recordRun.draft.record(runObservability.right.diagnostics);
-                    if (sourcePlan.right !== undefined) {
-                        yield* recordRun.draft.record(sourcePlan.right.runWrite);
+                    return yield* recordRun.session.seal({ completedAt: completion.right });
+                });
+                if (mode === "normal") {
+                    // Normal completion remains typed and strict: the first Run failure
+                    // is an invocation failure, never a partial success receipt.
+                    return yield* effect_1.Effect.forEach(publishableRuns, publishOne, { concurrency: 1 });
+                }
+                // SIGINT is different: each clean sibling receives its own complete
+                // attempt. We deliberately observe an Exit per Run so one fixed-family
+                // or seal error cannot short-circuit subsequent safe siblings.
+                const receipts = [];
+                for (const recordRun of publishableRuns) {
+                    const exit = yield* effect_1.Effect.exit(publishOne(recordRun));
+                    if (!effect_1.Exit.isSuccess(exit)) {
+                        const failure = effect_1.Cause.failureOption(exit.cause);
+                        if (effect_1.Option.isSome(failure))
+                            noteFailure(failure.value, recordRun);
+                    }
+                    const markerExit = yield* effect_1.Effect.exit(fileSystem.pathKind((0, services_ts_1.recordPortablePath)(input.recordRoot, "runs", recordRun.session.runId, "complete")));
+                    if (effect_1.Exit.isSuccess(markerExit) && markerExit.value === "file") {
+                        // `seal` can fail during a post-marker directory sync. The marker,
+                        // not its return value, is the durable publication truth.
+                        receipts.push(Object.freeze({ runId: recordRun.session.runId, state: "sealed" }));
+                    }
+                    else if (!effect_1.Exit.isSuccess(markerExit)) {
+                        const markerFailure = effect_1.Cause.failureOption(markerExit.cause);
+                        if (effect_1.Option.isSome(markerFailure)) {
+                            noteFailure(markerFailure.value, recordRun);
+                        }
+                        else {
+                            noteFailure(publishStateInvalid(recordRun.session.runId), recordRun);
+                        }
+                    }
+                    else if (effect_1.Exit.isSuccess(exit)) {
+                        noteFailure(publishStateInvalid(recordRun.session.runId), recordRun);
                     }
-                    for (const origin of originPlans) {
-                        yield* index_ts_1.EvaluationRecordContractV1.writePlanOriginsToAttempts(new Map([[origin.slotId, origin.draft]]), origin.plan);
+                    else if (effect_1.Cause.isEmpty(exit.cause)) {
+                        noteFailure(publishStateInvalid(recordRun.session.runId), recordRun);
                     }
-                    yield* recordRun.draft.record(provenance.right);
                 }
-                return yield* effect_1.Effect.forEach(publishableRuns, (recordRun) => recordRun.draft.publish({ completedAt: asUtcMillis(completedAt) }), { concurrency: 1 });
+                return Object.freeze(receipts);
             }),
         });
     });