niceeval 0.16.3-canary.99 → 0.17.1

package/dist/o11y/eval-usage.d.ts

@@ -1,13 +1,21 @@
+import { type CacheReadReport } from "./cache-read.js";
+import type { ResolvedModelSlots } from "../model-slots.js";
 import type { NumericMaterial } from "../assertions/match.js";
 import type { ResolvedEvidenceCoverage } from "../assertions/coverage.js";
 import type { PriceOverride, Usage } from "../types.js";
 import type { ReadableAdapterUsageAttachment } from "../record/family/adapter-usage/schema.js";
+/** Frozen cache report with author-facing selection by Experiment model purpose. */
+export interface EvalCacheRead extends CacheReadReport {
+    /** Omit the slot for the total. An undeclared slot throws; missing observations remain unavailable. */
+    rate(modelSlot?: string): NumericMaterial;
+}
 /** Internal source-owned shape; package-root exposure belongs to the author facade. */
 export interface EvalUsage {
     readonly source: "agent" | "adapter" | "unavailable";
     readonly scope: "turn" | "session" | "attempt";
     readonly basis: "reported-sends" | "recorded-calls" | "unbound";
     readonly cut: "call-time";
+    readonly cacheRead: EvalCacheRead;
     readonly inputTokens: NumericMaterial;
     readonly inputTotalTokens: NumericMaterial;
     readonly outputTokens: NumericMaterial;
@@ -37,7 +45,7 @@ export interface AgentUsageContribution {
     readonly usage: Readonly<Usage> | null;
     readonly coverage: ResolvedEvidenceCoverage["usage"];
 }
-export declare function projectAdapterEvalUsage(usage: ReadableAdapterUsageAttachment): EvalUsage;
+export declare function projectAdapterEvalUsage(usage: ReadableAdapterUsageAttachment, models?: ResolvedModelSlots): EvalUsage;
 /** The receiver selects scope membership before calling this pure projection. */
 export declare function projectAgentEvalUsage(input: {
     contributions: readonly AgentUsageContribution[];

package/dist/record/host/sqlite-host.cjs

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.recordHost = void 0;
+exports.detachPlanningReference = detachPlanningReference;
+exports.stagePlanningReference = stagePlanningReference;
+exports.selectPlanningLocator = selectPlanningLocator;
+exports.selectPlanningSources = selectPlanningSources;
 exports.writerGenerationForRunSession = writerGenerationForRunSession;
 exports.discardAttemptWriteSession = discardAttemptWriteSession;
 exports.makeRecordHost = makeRecordHost;
@@ -32,6 +36,7 @@ const errors_ts_3 = require("../writer/errors.cjs");
 const limits_ts_1 = require("../writer/limits.cjs");
 const types_ts_1 = require("./types.cjs");
 const index_ts_5 = require("../sqlite/index.cjs");
+const errors_ts_4 = require("../../run/storage/errors.cjs");
 const WRITE_DEADLINE_MS = 30000;
 const MAILBOX_COMMANDS = 64;
 const COLLECTION_READ_MAX_ROWS = 10000;
@@ -89,48 +94,162 @@ function exactMarker(value, key) {
     return descriptor?.enumerable && "value" in descriptor ? descriptor.value : undefined;
 }
 function hasOwnMarker(value, key) { return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.hasOwnProperty.call(value, key); }
-/** Capture planning facts together, then release SQLite before any dispatch. */
-function captureReaderSnapshot(root) {
+function pinnedRead(read) {
     return effect_1.Effect.try({
-        try: () => {
-            const session = (0, index_ts_5.openOperationalRecordReadSession)(root);
-            try {
-                const summaries = [];
-                const resources = [];
-                const cores = new Map();
-                let afterRunId = "";
-                for (;;) {
-                    const page = session.readSealedRunSummaryPage(afterRunId, 100);
-                    summaries.push(...page.summaries);
-                    if (page.nextAfterRunId === null)
-                        break;
-                    afterRunId = page.nextAfterRunId;
-                }
-                for (const summary of summaries) {
-                    const core = session.readSealedRunCore(summary.runId);
-                    if (core !== undefined)
-                        cores.set(summary.runId, core);
-                }
-                afterRunId = "";
-                for (;;) {
-                    const page = session.listRunResources({ afterRunId, pageSize: 100 });
-                    resources.push(...page.runs);
-                    if (page.nextAfterRunId === null)
-                        break;
-                    afterRunId = page.nextAfterRunId;
-                }
-                return Object.freeze({ summaries: Object.freeze(summaries), resources: Object.freeze(resources), cutoff: session.publicationCutoff(), cores });
-            }
-            finally {
-                session.close();
-            }
-        },
-        catch: (cause) => cause instanceof index_ts_4.SqliteRecordError ? cause : new index_ts_4.SqliteRecordError("record-sqlite-error", "record-reader-snapshot", "Could not capture reader facts", { cause }),
+        try: read,
+        catch: (cause) => cause instanceof index_ts_4.SqliteRecordError ? cause : new index_ts_4.SqliteRecordError(cause instanceof errors_ts_4.RunStorageError && cause.code === "run-storage-invalid" ? "record-database-invalid" : "record-sqlite-error", "record-reader", "Could not read selected facts", { cause }),
     });
 }
+const readers = new WeakMap();
 const runSessions = new WeakMap();
 const attemptSessions = new WeakMap();
 const selectedAttemptCapabilities = new WeakMap();
+const exactReferenceBrand = Symbol("record/planning-reference");
+const exactReferences = new WeakSet();
+function planningCorruption(error) {
+    return error instanceof errors_ts_2.RecordIntegrityFailure || error instanceof index_ts_4.SqliteRecordError &&
+        ["record-database-invalid", "record-content-invalid", "record-seal-incomplete"].includes(error.code);
+}
+function detachPlanningReference(reader, attempt) {
+    const runtime = readers.get(reader), capability = selectedAttemptCapabilities.get(attempt);
+    const publication = attempt.publicationIdentity;
+    if (runtime === undefined || runtime.lifecycle.closed || capability?.lifecycle !== runtime.lifecycle ||
+        publication === undefined || publication.originRunId !== attempt.originRunId || publication.attemptId !== attempt.attemptId)
+        return undefined;
+    const reference = Object.freeze({ record: runtime.root, originRunId: attempt.originRunId,
+        attemptId: attempt.attemptId, publicationIdentity: Object.freeze({ ...publication }), [exactReferenceBrand]: true });
+    exactReferences.add(reference);
+    return reference;
+}
+/** Stages Core membership; the following binding transaction rechecks the publication CAS. */
+function stagePlanningReference(session, input) {
+    const run = runSessions.get(session);
+    if (run === undefined || !exactReferences.has(input.reference) || !sameRoot(run.root, input.reference.record)) {
+        return effect_1.Effect.fail(new record_errors_ts_1.RecordReferenceInvalid({ code: "record-reference-invalid" }));
+    }
+    return run.lock.withPermits(1)(effect_1.Effect.gen(function* () {
+        yield* assertRunOpen(run);
+        if (!run.expectedBySlot.has(input.slotId) || run.reservations.has(input.slotId))
+            return yield* effect_1.Effect.fail(coreInvalid());
+        run.members.set(input.slotId, Object.freeze({ slotId: input.slotId, action: input.action,
+            attempt: Object.freeze({ originRunId: input.reference.originRunId, attemptId: input.reference.attemptId }) }));
+        run.reservations.add(input.slotId);
+    }));
+}
+function selectPlanningLocator(reader, locator) {
+    return effect_1.Effect.gen(function* () {
+        const runtime = readers.get(reader);
+        if (runtime === undefined || runtime.lifecycle.closed)
+            return yield* effect_1.Effect.fail(new errors_ts_2.RecordReaderClosed({ code: "record-reader-closed" }));
+        const candidates = yield* pinnedRead(() => runtime.session.findAttemptLocatorCandidates(locator, 256, false));
+        const runIds = yield* effect_1.Schema.decodeUnknownEffect(effect_1.Schema.Array(identifiers_ts_1.RunIdSchema))([...new Set(candidates.candidates.map((candidate) => candidate.runId))]).pipe(effect_1.Effect.mapError(() => new errors_ts_2.RecordHandleInvalid({ code: "record-handle-invalid" })));
+        return yield* reader.selectRuns({ runIds, includePublishedActive: true });
+    });
+}
+/** Select barriers before loading Core; fetch only those barriers and necessary origins. */
+function selectPlanningSources(reader, positions) {
+    return effect_1.Effect.gen(function* () {
+        const runtime = readers.get(reader);
+        if (runtime === undefined || runtime.lifecycle.closed)
+            return yield* effect_1.Effect.fail(new errors_ts_2.RecordReaderClosed({ code: "record-reader-closed" }));
+        const candidates = yield* pinnedRead(() => positions.flatMap((position) => {
+            const candidate = runtime.session.findSourceBarrierCandidate(position);
+            return candidate === undefined ? [] : [{ ...candidate, position }];
+        }));
+        const sourceIds = [...new Set(candidates.map((candidate) => candidate.runId))];
+        const experimentByRun = new Map(candidates.map((candidate) => [candidate.runId, candidate.position.experimentId]));
+        const issuesByExperiment = new Map();
+        const sourceProblem = (id, error) => {
+            const experiment = experimentByRun.get(id);
+            if (experiment !== undefined)
+                issuesByExperiment.set(experiment, invalidIssues(["run", id, error.code,
+                    ...(error instanceof errors_ts_2.RecordIntegrityFailure ? [error.reason] : [])]));
+        };
+        const resources = [];
+        for (const id of sourceIds) {
+            const result = yield* effect_1.Effect.result(pinnedRead(() => runtime.session.readRunResource(id)));
+            if (effect_1.Result.isFailure(result)) {
+                if (!planningCorruption(result.failure))
+                    return yield* effect_1.Effect.fail(result.failure);
+                sourceProblem(id, result.failure);
+            }
+            else if (result.success !== undefined)
+                resources.push(result.success);
+        }
+        const members = new Map();
+        const ids = new Set(sourceIds);
+        for (const resource of resources) {
+            const runId = yield* effect_1.Schema.decodeUnknownEffect(identifiers_ts_1.RunIdSchema)(resource.runId).pipe(effect_1.Effect.mapError(() => new errors_ts_2.RecordHandleInvalid({ code: "record-handle-invalid" })));
+            const bindings = [];
+            for (const slot of resource.slots) {
+                if (!candidates.some((candidate) => candidate.runId === resource.runId &&
+                    candidate.position.evalId === slot.evalId && candidate.position.attemptOrdinal === slot.attemptOrdinal))
+                    continue;
+                const publication = slot.publication;
+                if (publication.state !== "published")
+                    continue;
+                const decoded = (0, index_ts_2.decodeMemberDocument)({ slotId: slot.slotId, action: publication.action,
+                    attempt: { originRunId: publication.originRunId, attemptId: publication.attemptId } });
+                if (effect_1.Result.isFailure(decoded) || decoded.success.attempt === null)
+                    return yield* effect_1.Effect.fail(new errors_ts_2.RecordIntegrityFailure({ code: "record-integrity-failure", runId, reason: "core-invalid" }));
+                ids.add(publication.originRunId);
+                // A carried rename still needs its earlier accepted membership as
+                // proof. The latest barrier and origin alone cannot establish it.
+                if (publication.action === "carried") {
+                    const witnesses = yield* pinnedRead(() => runtime.session.findAcceptedAttemptRunIds({
+                        experimentId: resource.experimentId,
+                        originRunId: publication.originRunId,
+                        attemptId: publication.attemptId,
+                        bindingRevision: publication.bindingRevision,
+                    }));
+                    for (const witness of witnesses)
+                        ids.add(witness);
+                }
+                bindings.push(Object.freeze({ document: decoded.success, bindingRevision: publication.bindingRevision,
+                    attempt: attemptRef(runtime, decoded.success.attempt.originRunId, decoded.success.attempt.attemptId, publication.publicationIdentity) }));
+            }
+            members.set(runId, Object.freeze(bindings));
+        }
+        // A legacy barrier's members can reference origins outside this Experiment.
+        const selections = [];
+        for (const id of ids) {
+            const runId = yield* effect_1.Schema.decodeUnknownEffect(identifiers_ts_1.RunIdSchema)(id).pipe(effect_1.Effect.mapError(() => new errors_ts_2.RecordHandleInvalid({ code: "record-handle-invalid" })));
+            const result = yield* effect_1.Effect.result(reader.selectRuns({ runIds: [runId], includePublishedActive: true }));
+            if (effect_1.Result.isFailure(result)) {
+                if (!planningCorruption(result.failure))
+                    return yield* effect_1.Effect.fail(result.failure);
+                sourceProblem(id, result.failure);
+                continue;
+            }
+            selections.push(result.success);
+            if (sourceIds.includes(id))
+                for (const ref of result.success.runRefs) {
+                    const run = yield* reader.readRun(ref);
+                    if (run.state !== "available")
+                        continue;
+                    const resource = resources.find((resource) => resource.runId === id);
+                    if (run.value.document.experimentId !== experimentByRun.get(id) || resource !== undefined &&
+                        (resource.slots.length !== run.value.document.expectedSlots.length || resource.slots.some((slot) => !run.value.document.expectedSlots.some((expected) => expected.slotId === slot.slotId && expected.evalId === slot.evalId &&
+                            expected.attemptOrdinal === slot.attemptOrdinal && expected.executionIdentityDigest === slot.executionIdentityDigest)))) {
+                        sourceProblem(id, new errors_ts_2.RecordIntegrityFailure({ code: "record-integrity-failure", runId, reason: "core-invalid" }));
+                    }
+                    for (const member of run.value.members) {
+                        const slot = run.value.document.expectedSlots.find((slot) => slot.slotId === member.document.slotId);
+                        if (slot !== undefined && member.attempt !== null && candidates.some((candidate) => candidate.runId === id &&
+                            candidate.position.evalId === slot.evalId && candidate.position.attemptOrdinal === slot.attemptOrdinal))
+                            ids.add(member.attempt.originRunId);
+                    }
+                }
+        }
+        // Resource-only and missing origins are assessed per slot, never discarded
+        // in favour of an older source barrier.
+        const selection = Object.freeze({ runRefs: Object.freeze(selections.flatMap((selection) => selection.runRefs)),
+            runFacts: Object.freeze(selections.flatMap((selection) => selection.runFacts)),
+            expectedSlots: Object.freeze(selections.flatMap((selection) => selection.expectedSlots)), warnings: Object.freeze([]),
+            problems: Object.freeze(selections.flatMap((selection) => selection.problems).filter((problem) => sourceIds.includes(problem.runId) && !members.has(problem.runId))) });
+        return Object.freeze({ selection, resources: Object.freeze(resources), members, issuesByExperiment, experimentByRun });
+    });
+}
 function writerGenerationForRunSession(session) {
     return runSessions.get(session)?.writerGeneration;
 }
@@ -608,7 +727,7 @@ function openNewRuntime(request, catalog, referenceOnly) {
         const record = decodedRecord !== undefined && effect_1.Result.isSuccess(decodedRecord) ? decodedRecord.success : deterministicRecord(request.root);
         if (record === undefined)
             return yield* effect_1.Effect.fail(coreInvalid());
-        yield* withWriteAdmission(coordination, request.root, (deadlineEpochMs) => client.beginRun({ runId, writerGeneration, startedAt: new Date(request.startedAt).toISOString(), deadlineEpochMs }));
+        yield* withWriteAdmission(coordination, request.root, (deadlineEpochMs) => client.beginRun({ runId, experimentId: request.experimentId, writerGeneration, startedAt: new Date(request.startedAt).toISOString(), deadlineEpochMs }));
         const lock = yield* effect_1.Semaphore.make(1), queue = yield* effect_1.Queue.bounded(MAILBOX_COMMANDS);
         const run = { root: request.root, client, coordination, entropy, catalog, record, writerGeneration, runId, experimentId: request.experimentId, context: context.success, startedAt: request.startedAt, expectedSlots: Object.freeze([...request.expectedSlots]), expectedBySlot: new Map(request.expectedSlots.map((slot) => [slot.slotId, slot])), lock, queue, attempts: new Map(), members: new Map(), reservations: new Set(), families: new Set(), attachments: new Map(), state: "open" };
         yield* effect_1.Effect.forkScoped(collectionWorker(run));
@@ -647,7 +766,15 @@ function decodeCore(core) {
 function readCore(runtime, runId) {
     if (runtime.lifecycle.closed)
         return effect_1.Effect.fail(new errors_ts_2.RecordReaderClosed({ code: "record-reader-closed" }));
-    return effect_1.Effect.succeed(runtime.coreCache.get(runId));
+    return pinnedRead(() => {
+        const cached = runtime.coreCache.get(runId);
+        if (cached !== undefined)
+            return cached;
+        const core = runtime.session.readSealedRunCore(runId, true);
+        if (core !== undefined)
+            runtime.coreCache.set(runId, core);
+        return core;
+    });
 }
 function runRef(runtime, runId) {
     const old = runtime.runRefs.get(runId);
@@ -699,6 +826,11 @@ function readAttempt(runtime, ref) {
         const document = decoded.attempts.find(({ attemptId }) => attemptId === location.attemptId);
         if (document === undefined)
             return effect_1.Effect.fail(new errors_ts_2.RecordIntegrityFailure({ code: "record-integrity-failure", runId: location.runId, reason: "publication-closure-invalid" }));
+        const actual = core.attempts.find((attempt) => attempt.attemptId === document.attemptId)?.publicationIdentity;
+        if (ref.publicationIdentity !== undefined && (actual === undefined ||
+            actual.originRunId !== ref.publicationIdentity.originRunId || actual.attemptId !== ref.publicationIdentity.attemptId ||
+            actual.revision !== ref.publicationIdentity.revision))
+            return effect_1.Effect.fail(new errors_ts_2.RecordIntegrityFailure({ code: "record-integrity-failure", runId: location.runId, reason: "publication-closure-invalid" }));
         return effect_1.Effect.succeed(Object.freeze({ state: "available", value: Object.freeze({ ref, owner: ownerRef(runtime, { kind: "attempt", runId: location.runId, attemptId: location.attemptId }), document, origin: Object.freeze({ owner: ownerRef(runtime, { kind: "run", runId: location.runId }), runId: location.runId, experimentId: decoded.run.experimentId, startedAt: decoded.run.startedAt, context: decoded.run.context }) }) }));
     });
 }
@@ -716,7 +848,7 @@ function contentStream(runtime, handle) {
         return effect_1.Effect.succeed(effect_1.Stream.paginate({ after: -1, ordinal: 0, byteLength: 0 }, (state) => {
             if (runtime.lifecycle.closed)
                 return effect_1.Effect.fail(new errors_ts_2.RecordReaderClosed({ code: "record-reader-closed" }));
-            return sqliteEffect(() => runtime.client.readContentChunkPage(metadata.contentId, state.after, CONTENT_READ_PAGE_ROWS)).pipe(effect_1.Effect.flatMap((page) => {
+            return pinnedRead(() => runtime.session.readContentChunkPage(metadata.contentId, state.after, CONTENT_READ_PAGE_ROWS)).pipe(effect_1.Effect.flatMap((page) => {
                 if (page.chunks.length === 0) {
                     return state.ordinal === metadata.chunkCount && state.byteLength === metadata.byteLength && hash.digest("hex") === metadata.digest
                         ? effect_1.Effect.succeed([[], effect_1.Option.none()])
@@ -823,12 +955,12 @@ function readFamily(runtime, ownerValue, definition) {
     const persistence = runtime.catalog.persistence(resolved);
     if (persistence === undefined)
         return effect_1.Effect.fail(new errors_ts_2.FamilyDefinitionRequired({ code: "family-definition-required", owner: owner.kind, family: resolved.family, revision: 1 }));
-    return effect_1.Effect.map(readCore(runtime, owner.runId), (core) => {
+    return effect_1.Effect.flatMap(readCore(runtime, owner.runId), (core) => pinnedRead(() => {
         if (core === undefined)
             return Object.freeze({ state: "not-recorded" });
         const attachment = findAttachment(core, owner, resolved.family);
         return attachment === undefined ? Object.freeze({ state: "not-recorded" }) : hydrateAttachment(runtime, attachment, persistence);
-    });
+    }));
 }
 function collectionStream(runtime, attachment, authoring, expectedDigest) {
     if (runtime.lifecycle.closed)
@@ -840,7 +972,7 @@ function collectionStream(runtime, attachment, authoring, expectedDigest) {
         return effect_1.Effect.succeed(effect_1.Stream.paginate({ after: -1, ordinal: 0, byteLength: 0 }, (state) => {
             if (runtime.lifecycle.closed)
                 return effect_1.Effect.fail(new errors_ts_2.RecordReaderClosed({ code: "record-reader-closed" }));
-            return sqliteEffect(() => runtime.client.readCollectionItemPage(attachment.attachmentId, state.after, index_ts_4.RECORD_SQLITE_MAX_PAGE_ROWS)).pipe(effect_1.Effect.flatMap((page) => {
+            return pinnedRead(() => runtime.session.readCollectionItemPage(attachment.attachmentId, state.after, index_ts_4.RECORD_SQLITE_MAX_PAGE_ROWS)).pipe(effect_1.Effect.flatMap((page) => {
                 if (page.items.length === 0) {
                     return state.ordinal === attachment.collectionItemCount && state.byteLength === attachment.collectionItemByteLength && hash.digest("hex") === expectedDigest
                         ? effect_1.Effect.succeed([[], effect_1.Option.none()])
@@ -888,7 +1020,7 @@ function openCollection(runtime, ownerValue, definition) {
     const owner = runtime.owners.get(ownerValue), authoring = (0, authoring_ts_1.attemptRecordCollectionRuntime)(definition);
     if (owner === undefined || owner.kind !== "attempt" || authoring === undefined)
         return effect_1.Effect.fail(new errors_ts_2.RecordHandleInvalid({ code: "record-handle-invalid" }));
-    return effect_1.Effect.map(readCore(runtime, owner.runId), (core) => {
+    return effect_1.Effect.flatMap(readCore(runtime, owner.runId), (core) => pinnedRead(() => {
         if (core === undefined)
             return Object.freeze({ state: "not-recorded" });
         const attachment = findAttachment(core, owner, authoring.attachment.family);
@@ -904,7 +1036,7 @@ function openCollection(runtime, ownerValue, definition) {
         if (payload?.collection === undefined || collection === undefined || collection.count !== attachment.collectionItemCount || collection.byteLength !== attachment.collectionItemByteLength || typeof collection.digest !== "string")
             return Object.freeze({ state: "invalid", issues: invalidIssues(["collection"]) });
         return Object.freeze({ state: "available", collection: payload.collection, logicalIdentity: attachment.logicalIdentity, logicalSealIdentity: core.logicalSealIdentity, count: attachment.collectionItemCount, digest: collection.digest, canonicalBytes: attachment.collectionItemByteLength, items: collectionStream(runtime, attachment, authoring, collection.digest) });
-    });
+    }));
 }
 function readCollectionWhole(runtime, owner, definition) {
     return effect_1.Effect.flatMap(openCollection(runtime, owner, definition), (opened) => {
@@ -922,9 +1054,7 @@ function makeReadSession(runtime) {
         const pageSize = input.pageSize ?? 100;
         if (!Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > 256)
             return effect_1.Effect.fail(new errors_ts_2.RecordHandleInvalid({ code: "record-handle-invalid" }));
-        const candidates = runtime.snapshot.resources.filter((run) => run.runId > (input.afterRunId ?? "") && (input.invocationId === undefined || run.invocationId === input.invocationId));
-        const runs = Object.freeze(candidates.slice(0, pageSize));
-        return effect_1.Effect.succeed(Object.freeze({ cutoff: runtime.snapshot.cutoff, runs, nextAfterRunId: candidates.length > pageSize ? runs.at(-1).runId : null }));
+        return pinnedRead(() => runtime.session.listRunResources(input));
     });
     const selectRuns = (request) => effect_1.Effect.gen(function* () {
         if (runtime.lifecycle.closed)
@@ -932,8 +1062,12 @@ function makeReadSession(runtime) {
         const requested = request?.runIds === undefined ? undefined : new Set(request.runIds);
         const cores = [];
         let after = "";
+        const exact = requested === undefined ? undefined : yield* pinnedRead(() => [...requested].flatMap((id) => {
+            const summary = runtime.session.readSealedRunSummary(id);
+            return summary === undefined ? [] : [summary];
+        }));
         while (true) {
-            const page = runtime.snapshot.summaries.filter((summary) => summary.runId > after).slice(0, 100);
+            const page = exact ?? (yield* pinnedRead(() => runtime.session.readSealedRunSummaryPage(after, 100))).summaries;
             if (page.length === 0)
                 break;
             for (const summary of page) {
@@ -952,7 +1086,7 @@ function makeReadSession(runtime) {
                     return yield* effect_1.Effect.fail(new errors_ts_2.RecordIntegrityFailure({ code: "record-integrity-failure", runId, reason: "core-invalid" }));
                 cores.push({ core, decoded });
             }
-            if (page.length < 100)
+            if (exact !== undefined || page.length < 100)
                 break;
         }
         const problems = [];
@@ -1023,10 +1157,11 @@ function openRead(root, catalog) {
         const projectState = yield* index_ts_4.ProjectStateDatabase;
         const client = (yield* projectState.bind(rootPath)).record;
         const lifecycle = { closed: false };
-        const snapshot = yield* captureReaderSnapshot(rootPath);
-        const runtime = { root, client, catalog, lifecycle, snapshot, runs: new WeakMap(), attempts: new WeakMap(), owners: new WeakMap(), selections: new WeakSet(), coreCache: new Map(snapshot.cores), runRefs: new Map(), attemptRefs: new Map(), content: new WeakMap() };
-        yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.sync(() => { lifecycle.closed = true; }));
-        return makeReadSession(runtime);
+        const session = yield* effect_1.Effect.acquireRelease(pinnedRead(() => (0, index_ts_5.openOperationalRecordReadSession)(rootPath)), (session) => effect_1.Effect.sync(() => { lifecycle.closed = true; session.close(); }));
+        const runtime = { root, client, catalog, lifecycle, session, runs: new WeakMap(), attempts: new WeakMap(), owners: new WeakMap(), selections: new WeakSet(), coreCache: new Map(), runRefs: new Map(), attemptRefs: new Map(), content: new WeakMap() };
+        const reader = makeReadSession(runtime);
+        readers.set(reader, runtime);
+        return reader;
     });
 }
 function closeMaintenanceFailure(error) { return Object.freeze({ _tag: "RecordMaintenanceOperationFailed", code: error.code ?? "record-maintenance-failed" }); }