niceeval 0.16.3-canary.99 → 0.17.1

package/dist/view/function-runtime.mjs

@@ -4504,6 +4504,141 @@ var AssertionDetailResultSchema = Schema.toType(Schema.Union([Schema.Struct({
 	check: DiagnosticNodeSchema,
 	matcher: MatcherProjectionSchema
 })]));
+//#endregion
+//#region src/o11y/cache-read.ts
+var Reason = Schema.Literals([
+	"usage-not-recorded",
+	"source-invalid",
+	"adapter-usage-required",
+	"collection-incomplete",
+	"call-status-unknown",
+	"no-calls",
+	"cache-read-missing",
+	"input-total-missing",
+	"zero-input-total",
+	"unsafe-token-total"
+]);
+var fields = {
+	rate: Schema.Union([Schema.Struct({
+		state: Schema.Literal("exact"),
+		value: Schema.Number.check(Schema.makeFilter((value) => Number.isFinite(value) && value >= 0 && value <= 1))
+	}), Schema.Struct({
+		state: Schema.Literal("unavailable"),
+		reason: Reason
+	})]),
+	recordedCalls: NonNegativeSafeIntegerSchema$2,
+	coveredCalls: NonNegativeSafeIntegerSchema$2,
+	missingCacheReadCalls: NonNegativeSafeIntegerSchema$2,
+	missingInputTotalCalls: NonNegativeSafeIntegerSchema$2,
+	unknownStatusCalls: NonNegativeSafeIntegerSchema$2,
+	collectionComplete: Schema.Boolean,
+	reasons: Schema.Array(Reason)
+};
+var consistent = (value) => {
+	const count = value.recordedCalls;
+	return count <= 4e3 && value.coveredCalls <= count && value.unknownStatusCalls <= count && value.missingCacheReadCalls <= count && value.missingInputTotalCalls <= count && value.coveredCalls <= count - Math.max(value.missingCacheReadCalls, value.missingInputTotalCalls) && value.coveredCalls >= count - value.missingCacheReadCalls - value.missingInputTotalCalls && new Set(value.reasons).size === value.reasons.length && (value.rate.state === "exact" ? value.reasons.length === 0 && value.collectionComplete && count > 0 && value.coveredCalls === count && value.unknownStatusCalls === 0 : value.rate.reason === value.reasons[0]);
+};
+var Summary = Schema.Struct(fields).check(Schema.makeFilter(consistent));
+var CacheReadReportSchema = Schema.Struct({
+	total: Summary,
+	modelSlots: Schema.Array(Schema.Struct({
+		modelSlot: Schema.NullOr(Schema.String),
+		...fields
+	}).check(Schema.makeFilter(consistent))),
+	models: Schema.Array(Schema.Struct({
+		modelSlot: Schema.NullOr(Schema.String),
+		provider: Schema.NullOr(Schema.String),
+		model: Schema.NullOr(Schema.String),
+		...fields
+	}).check(Schema.makeFilter(consistent)))
+}).check(Schema.makeFilter((value) => value.modelSlots.length <= 65 && value.models.length <= 4e3));
+function summary(calls, collectionComplete, absent) {
+	let numerator = 0;
+	let denominator = 0;
+	let coveredCalls = 0;
+	let missingCacheReadCalls = 0;
+	let missingInputTotalCalls = 0;
+	let unknownStatusCalls = 0;
+	let unsafe = false;
+	for (const call of calls) {
+		const total = call.inputTotalTokens ?? (call.inputTokens !== null && call.cacheReadTokens !== null && call.cacheWriteTokens !== null ? call.inputTokens + call.cacheReadTokens + call.cacheWriteTokens : null);
+		if (call.status === "unknown") unknownStatusCalls++;
+		if (call.cacheReadTokens === null) missingCacheReadCalls++;
+		else numerator += call.cacheReadTokens;
+		if (total === null) missingInputTotalCalls++;
+		else denominator += total;
+		if (total !== null && call.cacheReadTokens !== null) coveredCalls++;
+		if (total !== null && !Number.isSafeInteger(total) || !Number.isSafeInteger(numerator) || !Number.isSafeInteger(denominator)) unsafe = true;
+	}
+	const reasons = absent === void 0 ? [
+		...!collectionComplete ? ["collection-incomplete"] : [],
+		...unknownStatusCalls > 0 ? ["call-status-unknown"] : [],
+		...calls.length === 0 ? ["no-calls"] : [],
+		...missingCacheReadCalls > 0 ? ["cache-read-missing"] : [],
+		...missingInputTotalCalls > 0 ? ["input-total-missing"] : [],
+		...calls.length > 0 && missingInputTotalCalls === 0 && denominator === 0 ? ["zero-input-total"] : [],
+		...unsafe ? ["unsafe-token-total"] : []
+	] : [absent];
+	const rate = reasons.length === 0 ? Object.freeze({
+		state: "exact",
+		value: numerator / denominator
+	}) : Object.freeze({
+		state: "unavailable",
+		reason: reasons[0]
+	});
+	return Object.freeze({
+		rate,
+		recordedCalls: calls.length,
+		coveredCalls,
+		missingCacheReadCalls,
+		missingInputTotalCalls,
+		unknownStatusCalls,
+		collectionComplete,
+		reasons: Object.freeze(reasons)
+	});
+}
+var compare$1 = (a, b) => a === b ? 0 : a === null ? -1 : b === null ? 1 : a < b ? -1 : 1;
+/** A historical collection marked complete is not proof of an explicit producer seal. */
+function projectCacheRead(usage, slots, producerCompletenessKnown, absent = "usage-not-recorded") {
+	if (usage === null) return Object.freeze({
+		total: summary([], false, absent),
+		modelSlots: Object.freeze([]),
+		models: Object.freeze([])
+	});
+	const complete = producerCompletenessKnown && usage.collection.state === "complete";
+	const bySlot = new Map(Object.keys(slots ?? {}).map((slot) => [slot, []]));
+	const byModel = /* @__PURE__ */ new Map();
+	for (const call of usage.calls) {
+		const slot = bySlot.get(call.modelSlot);
+		if (slot === void 0) bySlot.set(call.modelSlot, [call]);
+		else slot.push(call);
+		const key = JSON.stringify([
+			call.modelSlot,
+			call.provider,
+			call.model
+		]);
+		const model = byModel.get(key);
+		if (model === void 0) byModel.set(key, [call]);
+		else model.push(call);
+	}
+	const models = [...byModel.values()].map((calls) => {
+		const { modelSlot, provider, model } = calls[0];
+		return Object.freeze({
+			modelSlot,
+			provider,
+			model,
+			...summary(calls, complete)
+		});
+	}).sort((a, b) => compare$1(a.modelSlot, b.modelSlot) || compare$1(a.provider, b.provider) || compare$1(a.model, b.model));
+	return Object.freeze({
+		total: summary(usage.calls, complete),
+		modelSlots: Object.freeze([...bySlot].sort(([a], [b]) => compare$1(a, b)).map(([modelSlot, calls]) => Object.freeze({
+			modelSlot,
+			...summary(calls, complete)
+		}))),
+		models: Object.freeze(models)
+	});
+}
 Object.freeze({
 	errors: "all",
 	onExcessProperty: "error"
@@ -5459,7 +5594,8 @@ function compareAdapterModelGroups(left, right) {
 function projectAdapterModelUsage(usage, models, unavailable = {
 	basis: "unavailable",
 	reason: "usage-not-recorded"
-}) {
+}, producerCompletenessKnown = true) {
+	const cacheRead = projectCacheRead(usage, models, producerCompletenessKnown, unavailable.reason === "physical-call-identity-not-recorded" ? "adapter-usage-required" : unavailable.reason);
 	const counts = /* @__PURE__ */ new Map();
 	for (const call of usage?.calls ?? []) if (call.modelSlot !== null) counts.set(call.modelSlot, (counts.get(call.modelSlot) ?? 0) + 1);
 	const configuredModels = models === void 0 ? Object.freeze({ state: "not-recorded" }) : Object.freeze({
@@ -5471,6 +5607,7 @@ function projectAdapterModelUsage(usage, models, unavailable = {
 		})))
 	});
 	if (usage === null) return Object.freeze({
+		cacheRead,
 		configuredModels,
 		modelGroups: Object.freeze({
 			state: "unavailable",
@@ -5513,6 +5650,7 @@ function projectAdapterModelUsage(usage, models, unavailable = {
 		});
 	});
 	return Object.freeze({
+		cacheRead,
 		configuredModels,
 		modelGroups: Object.freeze({
 			state: "available",
@@ -7050,23 +7188,7 @@ var InspectionRunValueSchema = Schema.Struct({
 	completedAt: Schema.optional(UtcMillisSchema),
 	expectedSlots: Schema.Array(RecordSlotIdentitySchema)
 });
-var InspectionRunResultSchema = Schema.Struct({
-	value: InspectionRunValueSchema,
-	members: Schema.Array(MemberDocumentSchema),
-	attempts: Schema.Array(AttemptDocumentSchema)
-});
-Schema.Array(Schema.Struct({
-	runId: RunIdSchema,
-	state: Schema.Literal("completed"),
-	experimentId: ExperimentIdSchema,
-	invocationId: Schema.Null,
-	startedAt: UtcMillisSchema,
-	completedAt: UtcMillisSchema,
-	coverage: Schema.Struct({
-		published: Schema.Number,
-		expected: Schema.Number
-	})
-}));
+var InspectionRunListResultSchema = Schema.Array(RunSummarySchema);
 var InspectionScoredValueSchema = Schema.Union([
 	Schema.Struct({ state: Schema.Literal("not-scored") }),
 	Schema.Struct({
@@ -7087,37 +7209,6 @@ var VerdictSchema = Schema.NullOr(Schema.Literals([
 	"errored",
 	"skipped"
 ]));
-var InspectionRunSummaryResultSchema = Schema.Struct({
-	runs: Schema.Array(RunDocumentSchema),
-	denominator: Schema.Struct({
-		expected: Schema.Number,
-		observed: Schema.Number
-	}),
-	members: Schema.Array(Schema.Struct({
-		runId: Schema.String,
-		slotId: Schema.String,
-		evalId: Schema.String,
-		attemptOrdinal: Schema.Number,
-		executionIdentityDigest: Schema.String,
-		state: Schema.Literals([
-			"executed",
-			"carried",
-			"accepted",
-			"not-dispatched",
-			"interrupted",
-			"missing"
-		]),
-		locator: Schema.NullOr(Schema.String),
-		outcome: Schema.NullOr(Schema.Literals([
-			"completed",
-			"errored",
-			"cancelled",
-			"interrupted"
-		])),
-		verdict: VerdictSchema,
-		score: Schema.optional(InspectionScoredValueSchema)
-	}))
-});
 var AttemptCoverageFactSchema = Schema.Struct({
 	channel: Schema.Literals([
 		"events",
@@ -8097,6 +8188,7 @@ var UsageTotalsSchema = Schema.Struct({
 	costs: Schema.optional(EffectiveCostTotalSchema)
 });
 var InspectionAttemptUsageResultSchema = Schema.Struct({
+	cacheRead: CacheReadReportSchema,
 	configuredModels: ConfiguredModelsSchema,
 	modelGroups: ModelGroupsSchema,
 	judgeUsage: JudgeUsageSchema,
@@ -8169,7 +8261,8 @@ var RunOverviewMemberLimitationSchema = Schema.Union([
 	})
 ]);
 var RunOverviewMemberSchema = Schema.Struct({
-	slot: RecordSlotIdentitySchema,
+	...RecordSlotIdentitySchema.fields,
+	publication: RunSlotPublicationSchema,
 	state: Schema.Literals([
 		"executed",
 		"carried",
@@ -8197,20 +8290,16 @@ var RunOverviewLocatedLimitationSchema = Schema.Struct({
 	locator: Schema.NullOr(Schema.String),
 	limitation: RunOverviewMemberLimitationSchema
 });
-var InspectionRunOverviewResultSchema = Schema.Struct({
-	identity: Schema.Struct({
-		runId: RunIdSchema,
-		experimentId: ExperimentIdSchema,
-		adapter: Schema.NullOr(AdapterIdentitySchema)
-	}),
-	state: RunStateSchema,
-	startedAt: UtcMillisSchema,
-	completedAt: Schema.optional(UtcMillisSchema),
+var InspectionRunResultSchema = Schema.Struct({
+	value: InspectionRunValueSchema,
+	members: Schema.Array(MemberDocumentSchema),
+	attempts: Schema.Array(AttemptDocumentSchema),
 	denominator: Schema.Struct({
 		expected: Schema.Number,
-		observed: Schema.Number
+		published: Schema.Number,
+		missing: Schema.Number
 	}),
-	members: Schema.Array(RunOverviewMemberSchema),
+	slots: Schema.Array(RunOverviewMemberSchema),
 	coverage: Schema.Struct({
 		state: RunOverviewStateSchema,
 		expectedMemberCount: Schema.Number,
@@ -8387,16 +8476,11 @@ var operation = (kind, fields) => Schema.Struct({
 });
 var SourceSchema = Schema.Struct({
 	kind: Schema.Literals(["project-record", "external-record"]),
-	sealedCutoffIdentity: Schema.String
+	publicationCutoffIdentity: Schema.String
 });
-var SealedCutoffSchema = Schema.Struct({
-	kind: Schema.Literal("inspection-sealed-cutoff"),
-	identity: Schema.String,
-	runCount: Schema.Number,
-	runs: Schema.Array(Schema.Struct({
-		runId: Schema.String,
-		logicalSealIdentity: Schema.String
-	}))
+var PublicationCutoffSchema = Schema.Struct({
+	storeGeneration: Schema.String,
+	revision: Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0))
 });
 var SelectionSchema = Schema.Struct({
 	requestedRunIds: Schema.Array(Schema.String),
@@ -8408,7 +8492,7 @@ var SuccessMetadataSchema = Schema.Struct({
 	outcome: Schema.Literal("success"),
 	behaviorVersion: Schema.Literal(INSPECTION_BEHAVIOR_VERSION),
 	source: SourceSchema,
-	sealedCutoff: SealedCutoffSchema,
+	publicationCutoff: PublicationCutoffSchema,
 	selection: SelectionSchema,
 	issues: Schema.Tuple([]),
 	evidence: Schema.Struct({ refs: Schema.Array(Schema.String) })
@@ -8418,17 +8502,12 @@ var RunsListSuccessMetadataSchema = Schema.Struct({
 	outcome: Schema.Literal("success"),
 	behaviorVersion: Schema.Literal(INSPECTION_BEHAVIOR_VERSION),
 	source: SourceSchema,
-	sealedCutoff: Schema.Struct({
-		kind: Schema.Literal("inspection-sealed-cutoff"),
-		identity: Schema.String,
-		runCount: Schema.Number
-	}),
+	publicationCutoff: PublicationCutoffSchema,
 	selection: Schema.Struct({
 		requestedRunIds: Schema.Array(Schema.String),
 		selectedRunIds: Schema.Array(Schema.String),
 		missingRunIds: Schema.Array(Schema.String),
 		returnedRunCount: Schema.Number,
-		totalRunCount: Schema.Number,
 		truncated: Schema.Boolean
 	}),
 	issues: Schema.Tuple([]),
@@ -8457,19 +8536,6 @@ var ArtifactsResultSchema = Schema.Union([Schema.Struct({ state: Schema.Literal(
 	})),
 	contentsTruncated: Schema.Boolean
 })]);
-var SealedRunSummarySchema = Schema.Struct({
-	runId: Schema.String,
-	writerGeneration: Schema.String,
-	startedAt: Schema.String,
-	logicalSealIdentity: Schema.String,
-	slotCount: Schema.Number,
-	memberCount: Schema.Number,
-	attemptCount: Schema.Number,
-	attachmentCount: Schema.Number,
-	contentCount: Schema.Number,
-	contentByteLength: Schema.Number,
-	sealEntryCount: Schema.Number
-});
 var ComparisonMemberSchema = Schema.Struct({
 	key: Schema.String,
 	runId: Schema.String,
@@ -8533,10 +8599,10 @@ var inspectionProtocolRegistry = Object.freeze({
 			"judge-usage"
 		]
 	}),
-	"runs.list": spec({
-		request: operation("runs.list", { continuation: Schema.optional(Schema.String) }),
+	"run.list": spec({
+		request: operation("run.list", { continuation: Schema.optional(Schema.String) }),
 		result: {
-			runs: Schema.Array(SealedRunSummarySchema),
+			runs: InspectionRunListResultSchema,
 			continuation: Schema.optional(Schema.String)
 		},
 		factKinds: ["core"]
@@ -8544,24 +8610,12 @@ var inspectionProtocolRegistry = Object.freeze({
 	"run.get": spec({
 		request: operation("run.get", { runId: RunIdSchema }),
 		result: { run: InspectionRunResultSchema },
-		factKinds: ["core"]
-	}),
-	"run.summary": spec({
-		request: operation("run.summary", { runId: RunIdSchema }),
-		result: { summary: InspectionRunSummaryResultSchema },
-		factKinds: [
-			"core",
-			"assertions",
-			"agent-turns"
-		]
-	}),
-	"run.overview": spec({
-		request: operation("run.overview", { runId: RunIdSchema }),
-		result: { runOverview: InspectionRunOverviewResultSchema },
 		factKinds: [
 			"core",
 			"assertions",
-			"agent-turns"
+			"agent-turns",
+			"adapter-usage",
+			"judge-usage"
 		]
 	}),
 	"attempt.get": spec({
@@ -8716,7 +8770,7 @@ var successSchema = (id, entry) => {
 		operation: Schema.Literal(id),
 		...entry.result
 	});
-	return id === "runs.list" ? RunsListSuccessMetadataSchema.pipe(fields) : id === "runs.compare" ? CompareSuccessMetadataSchema.pipe(fields) : SuccessMetadataSchema.pipe(fields);
+	return id === "run.list" ? RunsListSuccessMetadataSchema.pipe(fields) : id === "runs.compare" ? CompareSuccessMetadataSchema.pipe(fields) : SuccessMetadataSchema.pipe(fields);
 };
 var InspectionSuccessDocumentSchema = Schema.Union(specs.map(([id, entry]) => successSchema(id, entry)));
 var explanationSchema = (id, entry) => {
@@ -8725,7 +8779,7 @@ var explanationSchema = (id, entry) => {
 		operation: Schema.Literal(id),
 		factKinds: Schema.Tuple(entry.factKinds.map((value) => Schema.Literal(value)))
 	});
-	if (id === "runs.list") return RunsListSuccessMetadataSchema.pipe(fields);
+	if (id === "run.list") return RunsListSuccessMetadataSchema.pipe(fields);
 	return SuccessMetadataSchema.pipe(fields);
 };
 var InspectionExplanationDocumentSchema = Schema.Union(specs.map(([id, entry]) => explanationSchema(id, entry)));
@@ -8958,11 +9012,456 @@ function encodeRecordJsonUtf8(value) {
 //#endregion
 //#region src/record/sqlite/current-schema.ts
 /**
-* Exact current ProjectDatabase 0.18 schema, independent of frozen historical
+* Exact current ProjectDatabase 0.19 schema, independent of frozen historical
 * baselines. Keep these bytes stable within this format: they own its fingerprint.
-* The disjoint namespace fences writers prepared against the 0.17 tables.
+* The disjoint namespace fences writers prepared against the 0.18 tables.
 */
 var RECORD_SQLITE_BASELINE_SQL = `
+CREATE TABLE ne19_record_metadata (
+  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+  format TEXT NOT NULL,
+  storage_revision INTEGER NOT NULL CHECK (storage_revision > 0),
+  storage_generation TEXT NOT NULL,
+  schema_fingerprint TEXT NOT NULL CHECK (length(schema_fingerprint) = 64),
+  created_at TEXT NOT NULL,
+  barrier_state TEXT NOT NULL CHECK (barrier_state IN ('open','draining','portable')),
+  portable_generation TEXT,
+  portable_revision INTEGER CHECK (portable_revision IS NULL OR portable_revision >= 0),
+  portable_gate_id TEXT,
+  record_payload BLOB,
+  record_digest TEXT,
+  CHECK ((record_payload IS NULL) = (record_digest IS NULL)),
+  CHECK (record_digest IS NULL OR length(record_digest) = 64),
+  CHECK ((barrier_state = 'portable') = (portable_generation IS NOT NULL)),
+  CHECK ((barrier_state = 'portable') = (portable_revision IS NOT NULL)),
+  CHECK ((barrier_state = 'open') = (portable_gate_id IS NULL))
+) STRICT;
+CREATE TABLE ne19_coordination_state (
+  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+  revision INTEGER NOT NULL CHECK (revision >= 0),
+  operational_generation TEXT NOT NULL,
+  next_writer_sequence INTEGER NOT NULL CHECK (next_writer_sequence > 0),
+  writer_ticket_id TEXT,
+  writer_sequence INTEGER CHECK (writer_sequence IS NULL OR writer_sequence > 0),
+  writer_host TEXT,
+  writer_pid INTEGER CHECK (writer_pid IS NULL OR writer_pid > 0),
+  writer_boot_id TEXT,
+  writer_process_start TEXT,
+  writer_deadline INTEGER CHECK (writer_deadline IS NULL OR writer_deadline > 0),
+  writer_enqueued_at INTEGER CHECK (writer_enqueued_at IS NULL OR writer_enqueued_at > 0),
+  writer_nonce TEXT,
+  writer_admitted_at INTEGER CHECK (writer_admitted_at IS NULL OR writer_admitted_at > 0),
+  writer_lease_expires_at INTEGER CHECK (writer_lease_expires_at IS NULL OR writer_lease_expires_at > 0),
+  barrier_id TEXT,
+  barrier_nonce TEXT,
+  barrier_host TEXT,
+  barrier_pid INTEGER CHECK (barrier_pid IS NULL OR barrier_pid > 0),
+  barrier_boot_id TEXT,
+  barrier_process_start TEXT,
+  barrier_deadline INTEGER CHECK (barrier_deadline IS NULL OR barrier_deadline > 0),
+  barrier_requested_at INTEGER CHECK (barrier_requested_at IS NULL OR barrier_requested_at > 0),
+  barrier_lease_expires_at INTEGER CHECK (barrier_lease_expires_at IS NULL OR barrier_lease_expires_at > 0),
+  barrier_status TEXT CHECK (barrier_status IS NULL OR barrier_status IN ('requested','active')),
+  barrier_active_at INTEGER CHECK (barrier_active_at IS NULL OR barrier_active_at > 0),
+  CHECK ((writer_ticket_id IS NULL) = (writer_sequence IS NULL)),
+  CHECK ((writer_ticket_id IS NULL) = (writer_host IS NULL)),
+  CHECK ((writer_ticket_id IS NULL) = (writer_pid IS NULL)),
+  CHECK ((writer_ticket_id IS NULL) = (writer_boot_id IS NULL)),
+  CHECK ((writer_ticket_id IS NULL) = (writer_process_start IS NULL)),
+  CHECK ((writer_ticket_id IS NULL) = (writer_deadline IS NULL)),
+  CHECK ((writer_ticket_id IS NULL) = (writer_enqueued_at IS NULL)),
+  CHECK ((writer_ticket_id IS NULL) = (writer_nonce IS NULL)),
+  CHECK ((writer_ticket_id IS NULL) = (writer_admitted_at IS NULL)),
+  CHECK ((writer_ticket_id IS NULL) = (writer_lease_expires_at IS NULL)),
+  CHECK ((barrier_id IS NULL) = (barrier_nonce IS NULL)),
+  CHECK ((barrier_id IS NULL) = (barrier_host IS NULL)),
+  CHECK ((barrier_id IS NULL) = (barrier_pid IS NULL)),
+  CHECK ((barrier_id IS NULL) = (barrier_boot_id IS NULL)),
+  CHECK ((barrier_id IS NULL) = (barrier_process_start IS NULL)),
+  CHECK ((barrier_id IS NULL) = (barrier_deadline IS NULL)),
+  CHECK ((barrier_id IS NULL) = (barrier_requested_at IS NULL)),
+  CHECK ((barrier_id IS NULL) = (barrier_lease_expires_at IS NULL)),
+  CHECK ((barrier_id IS NULL) = (barrier_status IS NULL)),
+  CHECK (
+    (barrier_status IS NULL AND barrier_active_at IS NULL) OR
+    (barrier_status = 'requested' AND barrier_active_at IS NULL) OR
+    (barrier_status = 'active' AND barrier_active_at IS NOT NULL)
+  )
+) STRICT;
+CREATE TABLE ne19_coordination_tickets (
+  ticket_id TEXT PRIMARY KEY,
+  sequence INTEGER NOT NULL UNIQUE CHECK (sequence > 0),
+  host TEXT NOT NULL,
+  pid INTEGER NOT NULL CHECK (pid > 0),
+  boot_id TEXT NOT NULL,
+  process_start TEXT NOT NULL,
+  deadline INTEGER NOT NULL CHECK (deadline > 0),
+  enqueued_at INTEGER NOT NULL CHECK (enqueued_at > 0)
+) STRICT;
+CREATE TABLE ne19_runs (
+  run_id TEXT PRIMARY KEY,
+  experiment_id TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('open','sealing','sealed')),
+  writer_generation TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  core_payload BLOB,
+  core_digest TEXT CHECK (core_digest IS NULL OR length(core_digest) = 64),
+  mutation_sequence INTEGER NOT NULL DEFAULT 0 CHECK (mutation_sequence >= 0),
+  candidate_seal_identity TEXT CHECK (candidate_seal_identity IS NULL OR length(candidate_seal_identity) = 64),
+  candidate_seal_entry_count INTEGER CHECK (candidate_seal_entry_count IS NULL OR candidate_seal_entry_count >= 0),
+  candidate_seal_staged_count INTEGER NOT NULL DEFAULT 0 CHECK (candidate_seal_staged_count >= 0),
+  logical_seal_identity TEXT,
+  CHECK ((core_payload IS NULL) = (core_digest IS NULL)),
+  CHECK ((candidate_seal_identity IS NULL) = (candidate_seal_entry_count IS NULL)),
+  CHECK ((status = 'open') = (candidate_seal_identity IS NULL)),
+  CHECK (candidate_seal_entry_count IS NULL OR candidate_seal_staged_count <= candidate_seal_entry_count),
+  CHECK (status != 'open' OR candidate_seal_staged_count = 0),
+  CHECK ((status = 'sealed') = (logical_seal_identity IS NOT NULL)),
+  CHECK (status = 'open' OR core_payload IS NOT NULL)
+) STRICT;
+CREATE TABLE ne19_slots (
+  run_id TEXT NOT NULL REFERENCES ne19_runs(run_id) ON DELETE CASCADE,
+  slot_id TEXT NOT NULL,
+  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
+  core_payload BLOB NOT NULL,
+  core_digest TEXT NOT NULL CHECK (length(core_digest) = 64),
+  PRIMARY KEY (run_id, slot_id),
+  UNIQUE (run_id, ordinal)
+) STRICT;
+CREATE TABLE ne19_attempts (
+  origin_run_id TEXT NOT NULL REFERENCES ne19_runs(run_id) ON DELETE CASCADE,
+  attempt_id TEXT NOT NULL,
+  attempt_locator TEXT NOT NULL CHECK (length(attempt_locator) = 14 AND substr(attempt_locator,1,2) = '@1'),
+  publication_state TEXT NOT NULL DEFAULT 'staging' CHECK (publication_state IN ('staging','sealing','published')),
+  core_payload BLOB,
+  core_digest TEXT CHECK (core_digest IS NULL OR length(core_digest) = 64),
+  CHECK ((core_payload IS NULL) = (core_digest IS NULL)),
+  PRIMARY KEY (origin_run_id, attempt_id)
+) STRICT;
+CREATE TABLE ne19_members (
+  target_run_id TEXT NOT NULL,
+  slot_id TEXT NOT NULL,
+  origin_run_id TEXT,
+  attempt_id TEXT,
+  action TEXT NOT NULL CHECK (action IN ('executed','carried','accepted','not-dispatched','interrupted')),
+  core_payload BLOB NOT NULL,
+  core_digest TEXT NOT NULL CHECK (length(core_digest) = 64),
+  PRIMARY KEY (target_run_id, slot_id),
+  CHECK (
+    (action IN ('executed','carried','accepted') AND origin_run_id IS NOT NULL AND attempt_id IS NOT NULL) OR
+    (action IN ('not-dispatched','interrupted') AND origin_run_id IS NULL AND attempt_id IS NULL)
+  ),
+  FOREIGN KEY (target_run_id, slot_id) REFERENCES ne19_slots(run_id, slot_id) ON DELETE CASCADE
+) STRICT;
+CREATE TABLE ne19_attachments (
+  attachment_id TEXT PRIMARY KEY,
+  owner_kind TEXT NOT NULL CHECK (owner_kind IN ('run','attempt')),
+  owner_run_id TEXT NOT NULL REFERENCES ne19_runs(run_id) ON DELETE CASCADE,
+  owner_attempt_id TEXT,
+  family TEXT NOT NULL,
+  family_revision INTEGER NOT NULL CHECK (family_revision > 0),
+  logical_identity TEXT,
+  canonical_payload BLOB,
+  canonical_digest TEXT CHECK (canonical_digest IS NULL OR length(canonical_digest) = 64),
+  logical_inventory BLOB,
+  inventory_digest TEXT CHECK (inventory_digest IS NULL OR length(inventory_digest) = 64),
+  CHECK ((canonical_payload IS NULL) = (canonical_digest IS NULL)),
+  CHECK ((logical_inventory IS NULL) = (inventory_digest IS NULL)),
+  CHECK ((owner_kind = 'run' AND owner_attempt_id IS NULL) OR (owner_kind = 'attempt' AND owner_attempt_id IS NOT NULL)),
+  UNIQUE (owner_kind, owner_run_id, owner_attempt_id, family),
+  FOREIGN KEY (owner_run_id, owner_attempt_id) REFERENCES ne19_attempts(origin_run_id, attempt_id) ON DELETE CASCADE
+) STRICT;
+CREATE TABLE ne19_attachment_references (
+  attachment_id TEXT NOT NULL REFERENCES ne19_attachments(attachment_id) ON DELETE CASCADE,
+  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
+  target_owner_kind TEXT NOT NULL CHECK (target_owner_kind IN ('run','attempt')),
+  target_family TEXT NOT NULL,
+  canonical_payload BLOB NOT NULL,
+  reference_digest TEXT NOT NULL CHECK (length(reference_digest) = 64),
+  PRIMARY KEY (attachment_id, ordinal)
+) STRICT;
+CREATE TABLE ne19_collection_items (
+  attachment_id TEXT NOT NULL REFERENCES ne19_attachments(attachment_id) ON DELETE CASCADE,
+  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
+  logical_identity TEXT NOT NULL,
+  canonical_payload BLOB NOT NULL,
+  canonical_digest TEXT NOT NULL CHECK (length(canonical_digest) = 64),
+  PRIMARY KEY (attachment_id, ordinal),
+  UNIQUE (attachment_id, logical_identity)
+) STRICT;
+CREATE TABLE ne19_contents (
+  content_id TEXT PRIMARY KEY,
+  attachment_id TEXT NOT NULL REFERENCES ne19_attachments(attachment_id) ON DELETE CASCADE,
+  logical_handle TEXT NOT NULL,
+  byte_length INTEGER CHECK (byte_length IS NULL OR byte_length >= 0),
+  overall_digest TEXT CHECK (overall_digest IS NULL OR length(overall_digest) = 64),
+  chunk_count INTEGER CHECK (chunk_count IS NULL OR chunk_count >= 0),
+  CHECK ((byte_length IS NULL) = (overall_digest IS NULL) AND (overall_digest IS NULL) = (chunk_count IS NULL)),
+  UNIQUE (attachment_id, logical_handle)
+) STRICT;
+CREATE TABLE ne19_content_chunks (
+  content_id TEXT NOT NULL REFERENCES ne19_contents(content_id) ON DELETE CASCADE,
+  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
+  bytes BLOB NOT NULL CHECK (length(bytes) <= 262144),
+  chunk_digest TEXT NOT NULL CHECK (length(chunk_digest) = 64),
+  PRIMARY KEY (content_id, ordinal)
+) STRICT;
+CREATE TABLE ne19_run_seal_entries (
+  run_id TEXT NOT NULL REFERENCES ne19_runs(run_id) ON DELETE CASCADE,
+  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
+  entry_kind TEXT NOT NULL CHECK (entry_kind IN ('record','run','slot','member','attempt','attachment','attachment-reference','collection-item','content','content-chunk')),
+  logical_identity TEXT NOT NULL,
+  digest TEXT NOT NULL CHECK (length(digest) = 64),
+  PRIMARY KEY (run_id, ordinal),
+  UNIQUE (run_id, entry_kind, logical_identity)
+) STRICT;
+CREATE INDEX ne19_attachments_owner_family ON ne19_attachments(owner_kind, owner_run_id, owner_attempt_id, family);
+CREATE UNIQUE INDEX ne19_attachments_owner_family_unique ON ne19_attachments(owner_kind, owner_run_id, coalesce(owner_attempt_id,''), family);
+CREATE INDEX ne19_members_origin_attempt ON ne19_members(origin_run_id, attempt_id, target_run_id);
+CREATE INDEX ne19_attempts_locator ON ne19_attempts(attempt_locator, origin_run_id, attempt_id);
+CREATE INDEX ne19_references_target_family ON ne19_attachment_references(target_owner_kind, target_family);
+CREATE INDEX ne19_content_chunks_page ON ne19_content_chunks(content_id, ordinal);
+CREATE INDEX ne19_coordination_tickets_fifo ON ne19_coordination_tickets(sequence);
+CREATE TRIGGER ne19_coordination_ticket_barrier_insert BEFORE INSERT ON ne19_coordination_tickets WHEN (SELECT barrier_state FROM ne19_record_metadata WHERE singleton=1)!='open' BEGIN SELECT RAISE(ABORT, 'ProjectDatabase writer barrier is not open'); END;
+CREATE TRIGGER ne19_coordination_writer_barrier_update BEFORE UPDATE ON ne19_coordination_state WHEN NEW.writer_ticket_id IS NOT NULL AND (SELECT barrier_state FROM ne19_record_metadata WHERE singleton=1)!='open' BEGIN SELECT RAISE(ABORT, 'ProjectDatabase writer barrier is not open'); END;
+CREATE TRIGGER ne19_runs_sealed_update BEFORE UPDATE ON ne19_runs WHEN OLD.status = 'sealed' BEGIN SELECT RAISE(ABORT, 'sealed run is immutable'); END;
+CREATE TRIGGER ne19_runs_sealed_delete BEFORE DELETE ON ne19_runs WHEN OLD.status = 'sealed' BEGIN SELECT RAISE(ABORT, 'sealed run is immutable'); END;
+CREATE TRIGGER ne19_slots_sealed_insert BEFORE INSERT ON ne19_slots WHEN (SELECT status FROM ne19_runs WHERE run_id = NEW.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_slots_sealed_update BEFORE UPDATE ON ne19_slots WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_slots_sealed_delete BEFORE DELETE ON ne19_slots WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_attempts_sealed_insert BEFORE INSERT ON ne19_attempts WHEN (SELECT status FROM ne19_runs WHERE run_id = NEW.origin_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_attempts_sealed_update BEFORE UPDATE ON ne19_attempts WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.origin_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_attempts_sealed_delete BEFORE DELETE ON ne19_attempts WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.origin_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_members_sealed_insert BEFORE INSERT ON ne19_members WHEN (SELECT status FROM ne19_runs WHERE run_id = NEW.target_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_members_sealed_update BEFORE UPDATE ON ne19_members WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.target_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_members_sealed_delete BEFORE DELETE ON ne19_members WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.target_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_attachments_sealed_insert BEFORE INSERT ON ne19_attachments WHEN (SELECT status FROM ne19_runs WHERE run_id = NEW.owner_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_attachments_attempt_published_insert BEFORE INSERT ON ne19_attachments WHEN NEW.owner_kind='attempt' AND (SELECT publication_state FROM ne19_attempts WHERE origin_run_id=NEW.owner_run_id AND attempt_id=NEW.owner_attempt_id)='published' BEGIN SELECT RAISE(ABORT, 'published attempt is immutable'); END;
+CREATE TRIGGER ne19_attachments_sealed_update BEFORE UPDATE ON ne19_attachments WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.owner_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_attachments_attempt_published_update BEFORE UPDATE ON ne19_attachments WHEN OLD.owner_kind='attempt' AND (SELECT publication_state FROM ne19_attempts WHERE origin_run_id=OLD.owner_run_id AND attempt_id=OLD.owner_attempt_id)='published' BEGIN SELECT RAISE(ABORT, 'published attempt is immutable'); END;
+CREATE TRIGGER ne19_attachments_sealed_delete BEFORE DELETE ON ne19_attachments WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.owner_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_attachments_attempt_published_delete BEFORE DELETE ON ne19_attachments WHEN OLD.owner_kind='attempt' AND (SELECT publication_state FROM ne19_attempts WHERE origin_run_id=OLD.owner_run_id AND attempt_id=OLD.owner_attempt_id)='published' BEGIN SELECT RAISE(ABORT, 'published attempt is immutable'); END;
+CREATE TRIGGER ne19_references_sealed_insert BEFORE INSERT ON ne19_attachment_references WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=NEW.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_references_sealed_update BEFORE UPDATE ON ne19_attachment_references WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_references_sealed_delete BEFORE DELETE ON ne19_attachment_references WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_items_sealed_insert BEFORE INSERT ON ne19_collection_items WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=NEW.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_items_sealed_update BEFORE UPDATE ON ne19_collection_items WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_items_sealed_delete BEFORE DELETE ON ne19_collection_items WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_contents_sealed_insert BEFORE INSERT ON ne19_contents WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=NEW.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_contents_sealed_update BEFORE UPDATE ON ne19_contents WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_contents_sealed_delete BEFORE DELETE ON ne19_contents WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_chunks_sealed_insert BEFORE INSERT ON ne19_content_chunks WHEN (SELECT r.status FROM ne19_contents c JOIN ne19_attachments a ON a.attachment_id=c.attachment_id JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE c.content_id=NEW.content_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_chunks_sealed_update BEFORE UPDATE ON ne19_content_chunks WHEN (SELECT r.status FROM ne19_contents c JOIN ne19_attachments a ON a.attachment_id=c.attachment_id JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE c.content_id=OLD.content_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_chunks_sealed_delete BEFORE DELETE ON ne19_content_chunks WHEN (SELECT r.status FROM ne19_contents c JOIN ne19_attachments a ON a.attachment_id=c.attachment_id JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE c.content_id=OLD.content_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_seal_entries_sealed_insert BEFORE INSERT ON ne19_run_seal_entries WHEN (SELECT status FROM ne19_runs WHERE run_id = NEW.run_id) != 'sealing' BEGIN SELECT RAISE(ABORT, 'Seal candidates require sealing state'); END;
+CREATE TRIGGER ne19_seal_entries_sealed_update BEFORE UPDATE ON ne19_run_seal_entries BEGIN SELECT RAISE(ABORT, 'Seal entries are immutable'); END;
+CREATE TRIGGER ne19_seal_entries_sealed_delete BEFORE DELETE ON ne19_run_seal_entries WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'Seal entries are immutable'); END;
+
+
+CREATE TABLE ne19_run_publication_clock (
+  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+  revision INTEGER NOT NULL CHECK (revision >= 0)
+) STRICT;
+CREATE TABLE ne19_run_resources (
+  run_id TEXT PRIMARY KEY,
+  invocation_id TEXT NOT NULL,
+  experiment_id TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  initial_writer_generation TEXT NOT NULL,
+  current_writer_generation TEXT NOT NULL,
+  terminal_state TEXT CHECK (terminal_state IS NULL OR terminal_state IN ('completed','interrupted','failed')),
+  completed_at TEXT,
+  created_revision INTEGER NOT NULL UNIQUE CHECK (created_revision > 0),
+  close_revision INTEGER UNIQUE CHECK (close_revision IS NULL OR close_revision > created_revision),
+  CHECK ((terminal_state IS NULL) = (completed_at IS NULL)),
+  CHECK ((terminal_state IS NULL) = (close_revision IS NULL))
+) STRICT;
+CREATE TABLE ne19_run_expected_slots (
+  run_id TEXT NOT NULL REFERENCES ne19_run_resources(run_id) ON DELETE RESTRICT,
+  slot_id TEXT NOT NULL,
+  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
+  eval_id TEXT NOT NULL,
+  attempt_ordinal INTEGER NOT NULL CHECK (attempt_ordinal >= 0),
+  execution_identity_digest TEXT NOT NULL CHECK (length(execution_identity_digest) = 64),
+  PRIMARY KEY (run_id, slot_id),
+  UNIQUE (run_id, ordinal)
+) STRICT;
+CREATE TABLE ne19_attempt_publications (
+  attempt_id TEXT PRIMARY KEY,
+  attempt_locator TEXT NOT NULL CHECK (length(attempt_locator) = 14 AND substr(attempt_locator,1,2) = '@1'),
+  origin_run_id TEXT NOT NULL,
+  origin_slot_id TEXT NOT NULL,
+  closure_payload BLOB NOT NULL,
+  closure_digest TEXT NOT NULL CHECK (length(closure_digest) = 64),
+  published_revision INTEGER NOT NULL UNIQUE CHECK (published_revision > 0),
+  FOREIGN KEY (origin_run_id, origin_slot_id) REFERENCES ne19_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT
+) STRICT;
+CREATE TABLE ne19_run_slot_bindings (
+  target_run_id TEXT NOT NULL,
+  slot_id TEXT NOT NULL,
+  attempt_id TEXT NOT NULL REFERENCES ne19_attempt_publications(attempt_id) ON DELETE RESTRICT,
+  origin_run_id TEXT NOT NULL,
+  origin_slot_id TEXT NOT NULL,
+  attempt_publication_revision INTEGER NOT NULL CHECK (attempt_publication_revision > 0),
+  action TEXT NOT NULL CHECK (action IN ('executed','carried','accepted')),
+  binding_revision INTEGER NOT NULL UNIQUE CHECK (binding_revision > 0),
+  PRIMARY KEY (target_run_id, slot_id),
+  FOREIGN KEY (target_run_id, slot_id) REFERENCES ne19_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT,
+  FOREIGN KEY (origin_run_id, origin_slot_id) REFERENCES ne19_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT
+) STRICT;
+CREATE TABLE ne19_run_slot_absences (
+  run_id TEXT NOT NULL,
+  slot_id TEXT NOT NULL,
+  reason TEXT NOT NULL CHECK (reason IN ('early-exit-satisfied','budget-exhausted','stopped-by-failure','interrupted-before-publication','dispatch-failed')),
+  absence_revision INTEGER NOT NULL CHECK (absence_revision > 0),
+  PRIMARY KEY (run_id, slot_id),
+  FOREIGN KEY (run_id, slot_id) REFERENCES ne19_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT
+) STRICT;
+CREATE TABLE ne19_run_recoveries (
+  run_id TEXT PRIMARY KEY REFERENCES ne19_run_resources(run_id) ON DELETE RESTRICT,
+  previous_writer_generation TEXT NOT NULL,
+  recovery_writer_generation TEXT NOT NULL,
+  evidence_kind TEXT NOT NULL,
+  evidence_identity TEXT NOT NULL,
+  evidence_observed_at TEXT NOT NULL,
+  recovery_revision INTEGER NOT NULL UNIQUE CHECK (recovery_revision > 0)
+) STRICT;
+CREATE TABLE ne19_run_deletion_tombstones (
+  run_id TEXT PRIMARY KEY REFERENCES ne19_run_resources(run_id) ON DELETE RESTRICT,
+  terminal_state TEXT NOT NULL CHECK (terminal_state IN ('completed','interrupted','failed')),
+  deleted_at TEXT NOT NULL,
+  deletion_revision INTEGER NOT NULL UNIQUE CHECK (deletion_revision > 0)
+) STRICT;
+CREATE INDEX ne19_runs_experiment ON ne19_runs(experiment_id,run_id);
+CREATE INDEX ne19_run_resources_experiment ON ne19_run_resources(experiment_id,created_revision,run_id);
+CREATE INDEX ne19_run_expected_slots_position ON ne19_run_expected_slots(eval_id,attempt_ordinal,run_id);
+CREATE INDEX ne19_run_resources_list ON ne19_run_resources(created_revision, run_id);
+CREATE INDEX ne19_run_resources_invocation ON ne19_run_resources(invocation_id, created_revision, run_id);
+CREATE INDEX ne19_attempt_publications_origin ON ne19_attempt_publications(origin_run_id, origin_slot_id);
+CREATE INDEX ne19_attempt_publications_locator ON ne19_attempt_publications(attempt_locator, origin_run_id, attempt_id);
+CREATE INDEX ne19_run_slot_bindings_attempt ON ne19_run_slot_bindings(attempt_id, target_run_id, slot_id);
+CREATE INDEX ne19_run_deletion_revision ON ne19_run_deletion_tombstones(deletion_revision, run_id);
+INSERT INTO ne19_run_publication_clock(singleton,revision) VALUES (1,0);
+
+
+CREATE TABLE ne19_invocation_sessions (
+  invocation_id TEXT PRIMARY KEY,
+  state TEXT NOT NULL CHECK (state IN ('active','recovering','completed','interrupted','failed')),
+  owner_id TEXT NOT NULL,
+  owner_generation INTEGER NOT NULL CHECK (owner_generation > 0),
+  owner_host TEXT NOT NULL,
+  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),
+  owner_boot_id TEXT NOT NULL,
+  owner_process_start TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  heartbeat_at TEXT NOT NULL,
+  active_projection BLOB,
+  recovering_at TEXT,
+  closed_at TEXT,
+  terminal_projection BLOB,
+  CHECK ((state IN ('completed','interrupted','failed')) = (closed_at IS NOT NULL)),
+  CHECK ((state IN ('completed','interrupted','failed')) = (terminal_projection IS NOT NULL)),
+  CHECK (state IN ('active','recovering') OR active_projection IS NULL),
+  CHECK ((state = 'recovering') = (recovering_at IS NOT NULL))
+) STRICT;
+CREATE TABLE ne19_invocation_session_experiments (
+  invocation_id TEXT NOT NULL REFERENCES ne19_invocation_sessions(invocation_id) ON DELETE RESTRICT,
+  experiment_id TEXT NOT NULL,
+  run_id TEXT NOT NULL UNIQUE REFERENCES ne19_run_resources(run_id) ON DELETE RESTRICT,
+  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
+  PRIMARY KEY (invocation_id, experiment_id),
+  UNIQUE (invocation_id, ordinal)
+) STRICT;
+CREATE TABLE ne19_invocation_session_queued_attempts (
+  invocation_id TEXT NOT NULL REFERENCES ne19_invocation_sessions(invocation_id) ON DELETE RESTRICT,
+  attempt_id TEXT NOT NULL,
+  run_id TEXT NOT NULL REFERENCES ne19_run_resources(run_id) ON DELETE RESTRICT,
+  slot_id TEXT NOT NULL,
+  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
+  PRIMARY KEY (invocation_id, attempt_id),
+  UNIQUE (invocation_id, ordinal),
+  FOREIGN KEY (run_id, slot_id) REFERENCES ne19_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT
+) STRICT;
+CREATE TABLE ne19_case_locks (
+  case_id TEXT PRIMARY KEY,
+  owner_id TEXT NOT NULL,
+  owner_generation INTEGER NOT NULL CHECK (owner_generation > 0),
+  owner_host TEXT NOT NULL,
+  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),
+  owner_boot_id TEXT NOT NULL,
+  owner_process_start TEXT NOT NULL,
+  acquired_at TEXT NOT NULL,
+  heartbeat_at TEXT NOT NULL
+) STRICT;
+CREATE INDEX ne19_invocation_sessions_state ON ne19_invocation_sessions(state, started_at, invocation_id);
+CREATE INDEX ne19_invocation_session_experiments_invocation ON ne19_invocation_session_experiments(invocation_id, ordinal);
+CREATE INDEX ne19_invocation_session_queued_attempts_run ON ne19_invocation_session_queued_attempts(run_id, slot_id);
+CREATE INDEX ne19_case_locks_owner ON ne19_case_locks(owner_id, owner_generation);
+CREATE TABLE ne19_teardown_obligations (
+  obligation_id TEXT PRIMARY KEY,
+  experiment_id TEXT NOT NULL,
+  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),
+  owner_host TEXT NOT NULL,
+  generation INTEGER NOT NULL DEFAULT 1 CHECK (generation > 0),
+  payload BLOB NOT NULL,
+  UNIQUE (experiment_id, owner_pid)
+) STRICT;
+CREATE TABLE ne19_shared_state_generations (
+  state_key TEXT NOT NULL,
+  generation INTEGER NOT NULL CHECK (generation > 0),
+  parent_generation INTEGER NOT NULL CHECK (parent_generation >= 0),
+  state_kind TEXT NOT NULL CHECK (state_kind IN ('active','recovering','free')),
+  owner_token TEXT NOT NULL,
+  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),
+  owner_host TEXT NOT NULL,
+  owner_process_identity TEXT NOT NULL,
+  heartbeat_at TEXT NOT NULL,
+  payload BLOB NOT NULL,
+  PRIMARY KEY (state_key, generation),
+  CHECK (parent_generation = generation - 1)
+) STRICT;
+CREATE TABLE ne19_kept_sandboxes (
+  entry_id TEXT PRIMARY KEY,
+  provider TEXT NOT NULL,
+  sandbox_id TEXT NOT NULL,
+  kept_at TEXT NOT NULL,
+  operation_generation INTEGER NOT NULL DEFAULT 0 CHECK (operation_generation >= 0),
+  payload BLOB NOT NULL,
+  UNIQUE (provider, sandbox_id)
+) STRICT;
+CREATE TABLE ne19_kept_sandbox_operation_leases (
+  entry_id TEXT PRIMARY KEY REFERENCES ne19_kept_sandboxes(entry_id) ON DELETE CASCADE,
+  generation INTEGER NOT NULL CHECK (generation > 0),
+  token TEXT NOT NULL,
+  holder TEXT NOT NULL,
+  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),
+  owner_host TEXT NOT NULL,
+  owner_process_identity TEXT NOT NULL,
+  operation TEXT NOT NULL,
+  acquired_at TEXT NOT NULL,
+  ttl_ms INTEGER NOT NULL CHECK (ttl_ms > 0)
+) STRICT;
+CREATE INDEX ne19_teardown_obligations_experiment ON ne19_teardown_obligations(experiment_id, owner_pid);
+CREATE INDEX ne19_shared_state_generations_head ON ne19_shared_state_generations(state_key, generation DESC);
+CREATE INDEX ne19_kept_sandboxes_kept_at ON ne19_kept_sandboxes(kept_at, entry_id);
+
+
+CREATE TABLE ne19_migration_state (
+  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+  state TEXT NOT NULL CHECK (state IN ('committed','ready')),
+  source_format TEXT,
+  source_digest TEXT CHECK (source_digest IS NULL OR length(source_digest) = 64),
+  CHECK ((source_format IS NULL) = (source_digest IS NULL)),
+  CHECK (state != 'committed' OR source_format IS NOT NULL)
+) STRICT;`;
+//#endregion
+//#region src/record/sqlite/legacy-schema-018.ts
+/**
+* Frozen ProjectDatabase 0.18 schema. Keep the SQL bytes stable:
+* they own the historical format fingerprint.
+* The disjoint namespace fences writers prepared against the 0.17 tables.
+*/
+var RECORD_SQLITE_018_BASELINE_SQL = `
 CREATE TABLE ne18_record_metadata (
   singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
   format TEXT NOT NULL,
@@ -10302,7 +10801,8 @@ Object.freeze([
 	"kept_sandboxes",
 	"kept_sandbox_operation_leases"
 ]);
-Object.freeze([
+/** Complete fixed table allowlist for the historical 0.17 `ne_` namespace. */
+var RECORD_SQLITE_017_TABLE_NAMES = Object.freeze([
 	"ne_record_metadata",
 	"ne_coordination_state",
 	"ne_coordination_tickets",
@@ -10334,15 +10834,17 @@ Object.freeze([
 	"ne_kept_sandbox_operation_leases",
 	"ne_migration_state"
 ]);
-var RECORD_SQLITE_BASELINE_FINGERPRINT = createHash("sha256").update("niceeval.project-database.bootstrap/0.18\0").update(RECORD_SQLITE_BASELINE_SQL).digest("hex");
+var RECORD_SQLITE_BASELINE_FINGERPRINT = createHash("sha256").update("niceeval.project-database.bootstrap/0.19\0").update(RECORD_SQLITE_BASELINE_SQL).digest("hex");
 createHash("sha256").update("niceeval.project-database.bootstrap/0.17\0").update(RECORD_SQLITE_017_BASELINE_SQL).digest("hex");
 Object.freeze({
 	"niceeval.project-database/0.15": createHash("sha256").update("niceeval.project-database.bootstrap/0.15\0").update(RECORD_SQLITE_LEGACY_BASELINE_SQL).digest("hex"),
 	"niceeval.project-database/0.16": createHash("sha256").update("niceeval.project-database.bootstrap/0.16\0").update(RECORD_SQLITE_LEGACY_BASELINE_SQL).digest("hex")
 });
+Object.freeze(RECORD_SQLITE_017_TABLE_NAMES.map((table) => table.replace(/^ne_/u, "ne18_")));
+createHash("sha256").update("niceeval.project-database.bootstrap/0.18\0").update(RECORD_SQLITE_018_BASELINE_SQL).digest("hex");
 //#endregion
 //#region src/record/sqlite/types.ts
-var RECORD_SQLITE_FORMAT = "niceeval.project-database/0.18";
+var RECORD_SQLITE_FORMAT = "niceeval.project-database/0.19";
 var RECORD_SQLITE_MAX_ROW_BYTES = 1048576;
 var RECORD_SQLITE_MAX_VALIDATION_RUNS = 1e5;
 var RECORD_SQLITE_VALIDATION_DEADLINE_MS = 3e4;
@@ -10634,7 +11136,7 @@ function validateSchemaObjects(connection, sql) {
 	if (actual.length !== expected.length || actual.some((row, index) => row !== expected[index])) throw sqliteError("record-schema-unsupported", "validate-schema", "database objects do not match the exact Project Record schema allowlist");
 }
 function storageRevision(connection) {
-	const row = currentStatement(connection.db, "SELECT storage_revision FROM ne18_record_metadata WHERE singleton=1").get();
+	const row = currentStatement(connection.db, "SELECT storage_revision FROM ne19_record_metadata WHERE singleton=1").get();
 	if (row === void 0) throw sqliteError("record-schema-unsupported", "validate-schema", "ProjectDatabase identity is missing");
 	return decodeInteger(row.storage_revision, "record_metadata.storage_revision");
 }
@@ -10660,12 +11162,12 @@ function validateCurrentRecordDomain(connection) {
 	let metadata;
 	try {
 		metadata = currentStatement(connection.db, `SELECT format,storage_revision,storage_generation,schema_fingerprint,barrier_state
-      FROM ne18_record_metadata WHERE singleton=1`).get();
+      FROM ne19_record_metadata WHERE singleton=1`).get();
 	} catch (cause) {
 		throw sqliteError("record-schema-unsupported", "validate-schema", "database does not expose the ProjectDatabase identity", cause);
 	}
 	if (metadata === void 0) throw sqliteError("record-schema-unsupported", "validate-schema", "ProjectDatabase identity is missing");
-	if (decodeText(metadata.format, "record_metadata.format") !== "niceeval.project-database/0.18") throw sqliteError("record-schema-unsupported", "validate-schema", "record format is unsupported");
+	if (decodeText(metadata.format, "record_metadata.format") !== "niceeval.project-database/0.19") throw sqliteError("record-schema-unsupported", "validate-schema", "record format is unsupported");
 	const revision = decodeInteger(metadata.storage_revision, "record_metadata.storage_revision");
 	if (revision !== 1) throw sqliteError("record-schema-unsupported", "validate-schema", `record storage revision ${revision} is not 1`);
 	if (decodeText(metadata.schema_fingerprint, "record_metadata.schema_fingerprint") !== RECORD_SQLITE_BASELINE_FINGERPRINT) throw sqliteError("record-schema-unsupported", "validate-schema", "ProjectDatabase baseline fingerprint is unsupported");
@@ -10673,16 +11175,16 @@ function validateCurrentRecordDomain(connection) {
 	if (barrierState !== "open" && barrierState !== "draining" && barrierState !== "portable") throw sqliteError("record-database-invalid", "validate-schema", "ProjectDatabase barrier state is invalid");
 	validateSchemaObjects(connection);
 	const coordination = currentStatement(connection.db, `SELECT revision,operational_generation,next_writer_sequence,
-    writer_ticket_id,barrier_id FROM ne18_coordination_state WHERE singleton=1`).get();
+    writer_ticket_id,barrier_id FROM ne19_coordination_state WHERE singleton=1`).get();
 	if (coordination === void 0) throw sqliteError("record-database-invalid", "validate-schema", "host coordination generation is missing");
 	if (decodeText(coordination.operational_generation, "coordination_state.operational_generation") !== decodeText(metadata.storage_generation, "record_metadata.storage_generation")) throw sqliteError("record-database-invalid", "validate-schema", "operational coordination generation does not match ProjectDatabase");
-	const migration = currentStatement(connection.db, "SELECT state FROM ne18_migration_state WHERE singleton=1").get();
+	const migration = currentStatement(connection.db, "SELECT state FROM ne19_migration_state WHERE singleton=1").get();
 	if (migration === void 0) throw sqliteError("record-database-invalid", "validate-schema", "ProjectDatabase migration state is missing");
 	const migrationState = decodeText(migration.state, "migration_state.state");
 	if (migrationState !== "committed" && migrationState !== "ready") throw sqliteError("record-database-invalid", "validate-schema", "ProjectDatabase migration state is invalid");
 }
 function requireMigrationReady(connection) {
-	const row = currentStatement(connection.db, "SELECT state FROM ne18_migration_state WHERE singleton=1").get();
+	const row = currentStatement(connection.db, "SELECT state FROM ne19_migration_state WHERE singleton=1").get();
 	if (row === void 0 || decodeText(row.state, "migration_state.state") !== "ready") throw sqliteError("record-schema-migration-required", "open", "ProjectDatabase migration committed but requires Host verification");
 }
 function validateExactSchema(connection) {
@@ -10735,12 +11237,12 @@ function openRecordWriter(path, busyTimeoutMs = 5e3) {
 				db.exec("BEGIN IMMEDIATE");
 				try {
 					db.exec(RECORD_SQLITE_BASELINE_SQL);
-					currentStatement(db, `INSERT INTO ne18_record_metadata(singleton,format,storage_revision,storage_generation,schema_fingerprint,
+					currentStatement(db, `INSERT INTO ne19_record_metadata(singleton,format,storage_revision,storage_generation,schema_fingerprint,
             created_at,barrier_state,portable_generation,portable_revision,portable_gate_id,record_payload,record_digest)
             VALUES (1,?,?,?,?,?,'open',NULL,NULL,NULL,NULL,NULL)`).run(RECORD_SQLITE_FORMAT, 1, generation, RECORD_SQLITE_BASELINE_FINGERPRINT, appliedAt);
-					currentStatement(db, `INSERT INTO ne18_coordination_state(singleton,revision,operational_generation,next_writer_sequence)
+					currentStatement(db, `INSERT INTO ne19_coordination_state(singleton,revision,operational_generation,next_writer_sequence)
             VALUES (1,0,?,1)`).run(generation);
-					currentStatement(db, `INSERT INTO ne18_migration_state(singleton,state,source_format,source_digest)
+					currentStatement(db, `INSERT INTO ne19_migration_state(singleton,state,source_format,source_digest)
             VALUES (1,'ready',NULL,NULL)`).run();
 					db.exec("COMMIT");
 					created = true;
@@ -10826,7 +11328,7 @@ function makeProjectDatabasePortable(path) {
 	let connection = openRecordWriter(path);
 	try {
 		connection.db.exec("BEGIN IMMEDIATE");
-		const metadata = currentStatement(connection.db, "SELECT barrier_state,portable_gate_id FROM ne18_record_metadata WHERE singleton=1").get();
+		const metadata = currentStatement(connection.db, "SELECT barrier_state,portable_gate_id FROM ne19_record_metadata WHERE singleton=1").get();
 		if (metadata === void 0) throw sqliteError("record-database-invalid", "portable-gate", "ProjectDatabase barrier is missing");
 		const barrierState = decodeText(metadata.barrier_state, "barrier_state");
 		if (barrierState === "portable") {
@@ -10835,7 +11337,7 @@ function makeProjectDatabasePortable(path) {
 		}
 		if (barrierState === "draining") {
 			const previous = currentStatement(connection.db, `SELECT barrier_id,barrier_nonce,barrier_host,barrier_pid,
-        barrier_boot_id,barrier_process_start FROM ne18_coordination_state WHERE singleton=1`).get();
+        barrier_boot_id,barrier_process_start FROM ne19_coordination_state WHERE singleton=1`).get();
 			if (previous === void 0 || previous.barrier_id === null || previous.barrier_nonce === null) throw sqliteError("record-database-invalid", "portable-gate", "draining portable gate has no fenced owner");
 			const previousOwner = {
 				ownerId: decodeText(previous.barrier_id, "barrier_id"),
@@ -10845,58 +11347,58 @@ function makeProjectDatabasePortable(path) {
 				processStart: decodeText(previous.barrier_process_start, "barrier_process_start")
 			};
 			if (!(previousOwner.host === gateOwner.host && previousOwner.pid === gateOwner.pid && previousOwner.bootId === gateOwner.bootId && previousOwner.processStart === gateOwner.processStart) && exactProcessState(previousOwner) !== "dead") throw sqliteError("record-command-conflict", "portable-gate", "draining portable gate owner is not proven dead");
-			const fenced = currentStatement(connection.db, `UPDATE ne18_coordination_state SET barrier_id=?,barrier_nonce=?,barrier_host=?,
+			const fenced = currentStatement(connection.db, `UPDATE ne19_coordination_state SET barrier_id=?,barrier_nonce=?,barrier_host=?,
         barrier_pid=?,barrier_boot_id=?,barrier_process_start=?,barrier_deadline=?,barrier_requested_at=?,
         barrier_lease_expires_at=?,barrier_status='active',barrier_active_at=?,revision=revision+1
         WHERE singleton=1 AND barrier_id=? AND barrier_nonce=?`).run(gateId, gateNonce, gateOwner.host, gateOwner.pid, gateOwner.bootId, gateOwner.processStart, admissionDrainDeadline, Date.now(), admissionDrainDeadline, Date.now(), previous.barrier_id, previous.barrier_nonce);
-			const metadataFenced = currentStatement(connection.db, `UPDATE ne18_record_metadata SET portable_gate_id=?
+			const metadataFenced = currentStatement(connection.db, `UPDATE ne19_record_metadata SET portable_gate_id=?
         WHERE singleton=1 AND barrier_state='draining' AND portable_gate_id=?`).run(gateId, metadata.portable_gate_id);
 			if (Number(fenced.changes) !== 1 || Number(metadataFenced.changes) !== 1) throw sqliteError("record-command-conflict", "portable-gate", "draining portable gate changed during recovery");
 		} else if (barrierState === "open") {
-			const entered = recordStatement(connection, `UPDATE ne18_record_metadata SET barrier_state='draining',portable_gate_id=?
+			const entered = recordStatement(connection, `UPDATE ne19_record_metadata SET barrier_state='draining',portable_gate_id=?
         WHERE singleton=1 AND barrier_state='open' AND portable_gate_id IS NULL`).run(gateId);
-			const established = currentStatement(connection.db, `UPDATE ne18_coordination_state SET barrier_id=?,barrier_nonce=?,barrier_host=?,
+			const established = currentStatement(connection.db, `UPDATE ne19_coordination_state SET barrier_id=?,barrier_nonce=?,barrier_host=?,
         barrier_pid=?,barrier_boot_id=?,barrier_process_start=?,barrier_deadline=?,barrier_requested_at=?,
         barrier_lease_expires_at=?,barrier_status='active',barrier_active_at=?,revision=revision+1
         WHERE singleton=1 AND barrier_id IS NULL`).run(gateId, gateNonce, gateOwner.host, gateOwner.pid, gateOwner.bootId, gateOwner.processStart, admissionDrainDeadline, Date.now(), admissionDrainDeadline, Date.now());
 			if (Number(entered.changes) !== 1 || Number(established.changes) !== 1) throw sqliteError("record-command-conflict", "portable-gate", "ProjectDatabase barrier is not open");
 		} else throw sqliteError("record-database-invalid", "portable-gate", "ProjectDatabase barrier state is invalid");
 		if (decodeInteger(currentStatement(connection.db, `SELECT
-      (SELECT count(*) FROM ne18_run_resources WHERE terminal_state IS NULL)+
-      (SELECT count(*) FROM ne18_invocation_sessions WHERE state IN ('active','recovering'))+
-      (SELECT count(*) FROM ne18_case_locks)+
-      (SELECT count(*) FROM ne18_teardown_obligations)+
-      (SELECT count(*) FROM ne18_shared_state_generations s WHERE state_kind!='free' AND generation=(SELECT max(generation) FROM ne18_shared_state_generations WHERE state_key=s.state_key))+
-      (SELECT count(*) FROM ne18_kept_sandbox_operation_leases) AS count`).get().count, "active_runs") !== 0) {
-			currentStatement(connection.db, `UPDATE ne18_record_metadata SET barrier_state='open',portable_gate_id=NULL
+      (SELECT count(*) FROM ne19_run_resources WHERE terminal_state IS NULL)+
+      (SELECT count(*) FROM ne19_invocation_sessions WHERE state IN ('active','recovering'))+
+      (SELECT count(*) FROM ne19_case_locks)+
+      (SELECT count(*) FROM ne19_teardown_obligations)+
+      (SELECT count(*) FROM ne19_shared_state_generations s WHERE state_kind!='free' AND generation=(SELECT max(generation) FROM ne19_shared_state_generations WHERE state_key=s.state_key))+
+      (SELECT count(*) FROM ne19_kept_sandbox_operation_leases) AS count`).get().count, "active_runs") !== 0) {
+			currentStatement(connection.db, `UPDATE ne19_record_metadata SET barrier_state='open',portable_gate_id=NULL
         WHERE singleton=1 AND barrier_state='draining' AND portable_gate_id=?`).run(gateId);
-			currentStatement(connection.db, `UPDATE ne18_coordination_state SET barrier_id=NULL,barrier_nonce=NULL,barrier_host=NULL,
+			currentStatement(connection.db, `UPDATE ne19_coordination_state SET barrier_id=NULL,barrier_nonce=NULL,barrier_host=NULL,
         barrier_pid=NULL,barrier_boot_id=NULL,barrier_process_start=NULL,barrier_deadline=NULL,
         barrier_requested_at=NULL,barrier_lease_expires_at=NULL,barrier_status=NULL,barrier_active_at=NULL,
         revision=revision+1 WHERE singleton=1 AND barrier_id=? AND barrier_nonce=?`).run(gateId, gateNonce);
 			connection.db.exec("COMMIT");
 			return false;
 		}
-		currentStatement(connection.db, "DELETE FROM ne18_coordination_tickets").run();
+		currentStatement(connection.db, "DELETE FROM ne19_coordination_tickets").run();
 		connection.db.exec("COMMIT");
 		while (true) {
 			const coordination = currentStatement(connection.db, `SELECT
         (writer_ticket_id IS NOT NULL OR (barrier_id IS NOT NULL AND barrier_id!=?)) AS active
-        FROM ne18_coordination_state WHERE singleton=1`).get(gateId);
+        FROM ne19_coordination_state WHERE singleton=1`).get(gateId);
 			if (coordination === void 0) throw sqliteError("record-database-invalid", "portable-gate", "coordination singleton is missing");
 			if (decodeInteger(coordination.active, "portable_admission") === 0) break;
 			if (Date.now() >= admissionDrainDeadline) throw sqliteError("record-write-busy", "portable-gate", "admitted writer did not drain before the portable deadline");
 			Atomics.wait(waitCell, 0, 0, 15);
 		}
 		connection.db.exec("BEGIN IMMEDIATE");
-		if (decodeInteger(currentStatement(connection.db, "SELECT count(*) AS count FROM ne18_run_resources WHERE terminal_state IS NULL").get().count, "active_runs") !== 0) throw sqliteError("record-command-conflict", "portable-gate", "active Run owners prevent portable close");
+		if (decodeInteger(currentStatement(connection.db, "SELECT count(*) AS count FROM ne19_run_resources WHERE terminal_state IS NULL").get().count, "active_runs") !== 0) throw sqliteError("record-command-conflict", "portable-gate", "active Run owners prevent portable close");
 		if (decodeInteger(currentStatement(connection.db, `SELECT
-      (SELECT count(*) FROM ne18_invocation_sessions WHERE state IN ('active','recovering'))+
-      (SELECT count(*) FROM ne18_invocation_session_queued_attempts)+
-      (SELECT count(*) FROM ne18_case_locks) AS count`).get().count, "invocation_work") !== 0) throw sqliteError("record-command-conflict", "portable-gate", "invocation coordination work prevents portable close");
-		currentExec(connection.db, `DELETE FROM ne18_runs WHERE status!='sealed' AND NOT EXISTS
-      (SELECT 1 FROM ne18_attempt_publications WHERE origin_run_id=ne18_runs.run_id); DELETE FROM ne18_coordination_tickets;`);
-		currentStatement(connection.db, `UPDATE ne18_coordination_state SET revision=revision+1,next_writer_sequence=1,
+      (SELECT count(*) FROM ne19_invocation_sessions WHERE state IN ('active','recovering'))+
+      (SELECT count(*) FROM ne19_invocation_session_queued_attempts)+
+      (SELECT count(*) FROM ne19_case_locks) AS count`).get().count, "invocation_work") !== 0) throw sqliteError("record-command-conflict", "portable-gate", "invocation coordination work prevents portable close");
+		currentExec(connection.db, `DELETE FROM ne19_runs WHERE status!='sealed' AND NOT EXISTS
+      (SELECT 1 FROM ne19_attempt_publications WHERE origin_run_id=ne19_runs.run_id); DELETE FROM ne19_coordination_tickets;`);
+		currentStatement(connection.db, `UPDATE ne19_coordination_state SET revision=revision+1,next_writer_sequence=1,
       writer_ticket_id=NULL,writer_sequence=NULL,writer_host=NULL,writer_pid=NULL,writer_deadline=NULL,
       writer_boot_id=NULL,writer_process_start=NULL,
       writer_enqueued_at=NULL,writer_nonce=NULL,writer_admitted_at=NULL,writer_lease_expires_at=NULL,
@@ -10904,9 +11406,9 @@ function makeProjectDatabasePortable(path) {
       barrier_boot_id=NULL,barrier_process_start=NULL,
       barrier_requested_at=NULL,barrier_lease_expires_at=NULL,barrier_status=NULL,barrier_active_at=NULL
       WHERE singleton=1`).run();
-		const clock = currentStatement(connection.db, "SELECT revision FROM ne18_run_publication_clock WHERE singleton=1").get();
-		const generation = currentStatement(connection.db, "SELECT storage_generation FROM ne18_record_metadata WHERE singleton=1").get();
-		currentStatement(connection.db, `UPDATE ne18_record_metadata SET barrier_state='portable',portable_generation=?,portable_revision=?
+		const clock = currentStatement(connection.db, "SELECT revision FROM ne19_run_publication_clock WHERE singleton=1").get();
+		const generation = currentStatement(connection.db, "SELECT storage_generation FROM ne19_record_metadata WHERE singleton=1").get();
+		currentStatement(connection.db, `UPDATE ne19_record_metadata SET barrier_state='portable',portable_generation=?,portable_revision=?
       WHERE singleton=1 AND barrier_state='draining' AND portable_gate_id=?`).run(decodeText(generation.storage_generation, "storage_generation"), decodeInteger(clock.revision, "publication_revision"), gateId);
 		connection.db.exec("COMMIT");
 		checkpointRecordDatabase(connection);
@@ -10919,23 +11421,23 @@ function makeProjectDatabasePortable(path) {
 	connection = openRecordReader(path);
 	try {
 		const state = currentStatement(connection.db, `SELECT barrier_state,portable_generation,portable_revision,storage_generation
-      FROM ne18_record_metadata WHERE singleton=1`).get();
+      FROM ne19_record_metadata WHERE singleton=1`).get();
 		const active = currentStatement(connection.db, `SELECT
-      (SELECT count(*) FROM ne18_run_resources WHERE terminal_state IS NULL)+
-      (SELECT count(*) FROM ne18_runs r WHERE status!='sealed' AND
-        (EXISTS (SELECT 1 FROM ne18_attempts a WHERE a.origin_run_id=r.run_id AND a.publication_state!='published') OR
-         EXISTS (SELECT 1 FROM ne18_run_resources rr WHERE rr.run_id=r.run_id AND rr.terminal_state IS NULL)))+
-      (SELECT count(*) FROM ne18_coordination_tickets) AS count`).get();
+      (SELECT count(*) FROM ne19_run_resources WHERE terminal_state IS NULL)+
+      (SELECT count(*) FROM ne19_runs r WHERE status!='sealed' AND
+        (EXISTS (SELECT 1 FROM ne19_attempts a WHERE a.origin_run_id=r.run_id AND a.publication_state!='published') OR
+         EXISTS (SELECT 1 FROM ne19_run_resources rr WHERE rr.run_id=r.run_id AND rr.terminal_state IS NULL)))+
+      (SELECT count(*) FROM ne19_coordination_tickets) AS count`).get();
 		const invocationWork = currentStatement(connection.db, `SELECT
-      (SELECT count(*) FROM ne18_invocation_sessions WHERE state IN ('active','recovering'))+
-      (SELECT count(*) FROM ne18_invocation_session_queued_attempts)+
-      (SELECT count(*) FROM ne18_case_locks) AS count`).get();
+      (SELECT count(*) FROM ne19_invocation_sessions WHERE state IN ('active','recovering'))+
+      (SELECT count(*) FROM ne19_invocation_session_queued_attempts)+
+      (SELECT count(*) FROM ne19_case_locks) AS count`).get();
 		const registryWork = currentStatement(connection.db, `SELECT
-      (SELECT count(*) FROM ne18_teardown_obligations)+
-      (SELECT count(*) FROM ne18_shared_state_generations s WHERE state_kind!='free' AND generation=(SELECT max(generation) FROM ne18_shared_state_generations WHERE state_key=s.state_key))+
-      (SELECT count(*) FROM ne18_kept_sandbox_operation_leases) AS count`).get();
-		const coordination = currentStatement(connection.db, `SELECT writer_ticket_id,barrier_id FROM ne18_coordination_state WHERE singleton=1`).get();
-		const clock = currentStatement(connection.db, "SELECT revision FROM ne18_run_publication_clock WHERE singleton=1").get();
+      (SELECT count(*) FROM ne19_teardown_obligations)+
+      (SELECT count(*) FROM ne19_shared_state_generations s WHERE state_kind!='free' AND generation=(SELECT max(generation) FROM ne19_shared_state_generations WHERE state_key=s.state_key))+
+      (SELECT count(*) FROM ne19_kept_sandbox_operation_leases) AS count`).get();
+		const coordination = currentStatement(connection.db, `SELECT writer_ticket_id,barrier_id FROM ne19_coordination_state WHERE singleton=1`).get();
+		const clock = currentStatement(connection.db, "SELECT revision FROM ne19_run_publication_clock WHERE singleton=1").get();
 		if (state === void 0 || decodeText(state.barrier_state, "barrier_state") !== "portable" || decodeText(state.portable_generation, "portable_generation") !== decodeText(state.storage_generation, "storage_generation") || clock === void 0 || decodeInteger(state.portable_revision, "portable_revision") !== decodeInteger(clock.revision, "publication_revision") || decodeInteger(active.count, "portable_work") !== 0 || decodeInteger(invocationWork.count, "portable_invocation_work") !== 0 || decodeInteger(registryWork.count, "portable_registry_work") !== 0 || coordination === void 0 || coordination.writer_ticket_id !== null || coordination.barrier_id !== null) throw sqliteError("record-database-invalid", "portable-gate", "hostile reopen did not prove a portable ProjectDatabase");
 	} finally {
 		closeRecordDatabase(connection);
@@ -11083,30 +11585,30 @@ function assertBoundedBatch(operation, rowCount, byteCount) {
 function readSealedRunSummary(connection, runId) {
 	const row = recordStatement(connection, `SELECT r.run_id,r.writer_generation,r.started_at,
     coalesce(r.logical_seal_identity,'published:' || (SELECT max(p.published_revision)
-      FROM ne18_attempt_publications p WHERE p.origin_run_id=r.run_id)) logical_seal_identity,
-    (SELECT count(*) FROM ne18_slots WHERE run_id=r.run_id) slot_count,
-    CASE WHEN EXISTS (SELECT 1 FROM ne18_run_resources WHERE run_id=r.run_id) THEN
-      (SELECT count(*) FROM ne18_run_slot_bindings WHERE target_run_id=r.run_id)+
-      (SELECT count(*) FROM ne18_run_slot_absences WHERE run_id=r.run_id)
-      ELSE (SELECT count(*) FROM ne18_members WHERE target_run_id=r.run_id) END member_count,
-    (SELECT count(*) FROM ne18_attempts a WHERE a.origin_run_id=r.run_id AND
-      (NOT EXISTS (SELECT 1 FROM ne18_run_resources WHERE run_id=r.run_id) OR EXISTS
-       (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=a.origin_run_id AND p.attempt_id=a.attempt_id))) attempt_count,
-    (SELECT count(*) FROM ne18_attachments a WHERE a.owner_run_id=r.run_id AND a.canonical_payload IS NOT NULL AND
-      (a.owner_kind='run' OR NOT EXISTS (SELECT 1 FROM ne18_run_resources WHERE run_id=r.run_id) OR EXISTS
-       (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=a.owner_run_id AND p.attempt_id=a.owner_attempt_id))) attachment_count,
-    (SELECT count(*) FROM ne18_contents c JOIN ne18_attachments a ON a.attachment_id=c.attachment_id
+      FROM ne19_attempt_publications p WHERE p.origin_run_id=r.run_id)) logical_seal_identity,
+    (SELECT count(*) FROM ne19_slots WHERE run_id=r.run_id) slot_count,
+    CASE WHEN EXISTS (SELECT 1 FROM ne19_run_resources WHERE run_id=r.run_id) THEN
+      (SELECT count(*) FROM ne19_run_slot_bindings WHERE target_run_id=r.run_id)+
+      (SELECT count(*) FROM ne19_run_slot_absences WHERE run_id=r.run_id)
+      ELSE (SELECT count(*) FROM ne19_members WHERE target_run_id=r.run_id) END member_count,
+    (SELECT count(*) FROM ne19_attempts a WHERE a.origin_run_id=r.run_id AND
+      (NOT EXISTS (SELECT 1 FROM ne19_run_resources WHERE run_id=r.run_id) OR EXISTS
+       (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=a.origin_run_id AND p.attempt_id=a.attempt_id))) attempt_count,
+    (SELECT count(*) FROM ne19_attachments a WHERE a.owner_run_id=r.run_id AND a.canonical_payload IS NOT NULL AND
+      (a.owner_kind='run' OR NOT EXISTS (SELECT 1 FROM ne19_run_resources WHERE run_id=r.run_id) OR EXISTS
+       (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=a.owner_run_id AND p.attempt_id=a.owner_attempt_id))) attachment_count,
+    (SELECT count(*) FROM ne19_contents c JOIN ne19_attachments a ON a.attachment_id=c.attachment_id
       WHERE a.owner_run_id=r.run_id AND a.canonical_payload IS NOT NULL AND
-      (a.owner_kind='run' OR NOT EXISTS (SELECT 1 FROM ne18_run_resources WHERE run_id=r.run_id) OR EXISTS
-       (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=a.owner_run_id AND p.attempt_id=a.owner_attempt_id))) content_count,
-    (SELECT coalesce(sum(c.byte_length),0) FROM ne18_contents c JOIN ne18_attachments a ON a.attachment_id=c.attachment_id
+      (a.owner_kind='run' OR NOT EXISTS (SELECT 1 FROM ne19_run_resources WHERE run_id=r.run_id) OR EXISTS
+       (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=a.owner_run_id AND p.attempt_id=a.owner_attempt_id))) content_count,
+    (SELECT coalesce(sum(c.byte_length),0) FROM ne19_contents c JOIN ne19_attachments a ON a.attachment_id=c.attachment_id
       WHERE a.owner_run_id=r.run_id AND a.canonical_payload IS NOT NULL AND
-      (a.owner_kind='run' OR NOT EXISTS (SELECT 1 FROM ne18_run_resources WHERE run_id=r.run_id) OR EXISTS
-       (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=a.owner_run_id AND p.attempt_id=a.owner_attempt_id))) content_bytes,
-    (SELECT count(*) FROM ne18_run_seal_entries WHERE run_id=r.run_id) seal_count
-    FROM ne18_runs r WHERE r.run_id=? AND NOT EXISTS
-      (SELECT 1 FROM ne18_run_deletion_tombstones d WHERE d.run_id=r.run_id)
-      AND (r.status='sealed' OR EXISTS (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=r.run_id))`).get(runId);
+      (a.owner_kind='run' OR NOT EXISTS (SELECT 1 FROM ne19_run_resources WHERE run_id=r.run_id) OR EXISTS
+       (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=a.owner_run_id AND p.attempt_id=a.owner_attempt_id))) content_bytes,
+    (SELECT count(*) FROM ne19_run_seal_entries WHERE run_id=r.run_id) seal_count
+    FROM ne19_runs r WHERE r.run_id=? AND NOT EXISTS
+      (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=r.run_id)
+      AND (r.status='sealed' OR EXISTS (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=r.run_id))`).get(runId);
 	if (row === void 0) return void 0;
 	return Object.freeze({
 		runId: text$2(row, "run_id"),
@@ -11124,22 +11626,64 @@ function readSealedRunSummary(connection, runId) {
 }
 /** Pinned publication identity, plus a metadata-only count; no Seal hashing. */
 function readSealedRunCutoff(connection, identity) {
-	const row = recordStatement(connection, `SELECT count(*) count FROM ne18_runs r
-    WHERE NOT EXISTS (SELECT 1 FROM ne18_run_deletion_tombstones d WHERE d.run_id=r.run_id)
-      AND (status='sealed' OR EXISTS (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=r.run_id))`).get();
+	const row = recordStatement(connection, `SELECT count(*) count FROM ne19_runs r
+    WHERE NOT EXISTS (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=r.run_id)
+      AND (status='sealed' OR EXISTS (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=r.run_id))`).get();
 	return Object.freeze({
 		identity,
 		runCount: integer$1(row, "count")
 	});
 }
 /** Filter lightweight Run metadata before loading any selected Core or payload. */
+function findSourceBarrierCandidate(connection, request, cutoffRevision) {
+	requireIdentity$1(request.experimentId, "experimentId");
+	requireIdentity$1(request.evalId, "evalId");
+	if (!Number.isSafeInteger(request.attemptOrdinal) || request.attemptOrdinal < 0) throw sqliteError("record-content-invalid", "find-source-barrier", "Attempt ordinal must be non-negative");
+	const current = rows(connection, `SELECT r.run_id,r.created_revision
+    FROM ne19_run_resources r
+    WHERE r.experiment_id=? AND r.created_revision<=? AND r.run_id<>?
+      AND NOT EXISTS (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=r.run_id)
+      AND EXISTS (SELECT 1 FROM ne19_run_expected_slots s
+        WHERE s.eval_id=? AND s.attempt_ordinal=? AND s.run_id=r.run_id)
+    ORDER BY r.created_revision DESC,r.run_id COLLATE BINARY DESC LIMIT 1`, request.experimentId, cutoffRevision, request.excludeRunId ?? "", request.evalId, request.attemptOrdinal)[0];
+	if (current !== void 0) return Object.freeze({
+		runId: text$2(current, "run_id"),
+		createdRevision: integer$1(current, "created_revision")
+	});
+	const legacy = rows(connection, `SELECT r.run_id FROM ne19_runs r
+    WHERE r.experiment_id=? AND r.status='sealed' AND r.run_id<>?
+      AND NOT EXISTS (SELECT 1 FROM ne19_run_resources rr WHERE rr.run_id=r.run_id)
+      AND NOT EXISTS (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=r.run_id)
+      AND EXISTS (SELECT 1 FROM ne19_slots s WHERE s.run_id=r.run_id AND
+        CASE WHEN json_valid(CAST(s.core_payload AS TEXT)) THEN
+          CASE WHEN json_type(CAST(s.core_payload AS TEXT),'$.evalId') IS NOT 'text' OR
+            json_type(CAST(s.core_payload AS TEXT),'$.attemptOrdinal') IS NOT 'integer' THEN 1
+          ELSE (json_extract(CAST(s.core_payload AS TEXT),'$.evalId')=? AND
+           json_extract(CAST(s.core_payload AS TEXT),'$.attemptOrdinal')=?) END
+        ELSE 1 END)
+    ORDER BY r.run_id COLLATE BINARY DESC LIMIT 1`, request.experimentId, request.excludeRunId ?? "", request.evalId, request.attemptOrdinal)[0];
+	return legacy === void 0 ? void 0 : Object.freeze({
+		runId: text$2(legacy, "run_id"),
+		createdRevision: 0
+	});
+}
+/** Locate adoption proofs for one exact Attempt without scanning Run Core. */
+function findAcceptedAttemptRunIds(connection, request, cutoffRevision) {
+	const selected = rows(connection, `SELECT b.target_run_id FROM ne19_run_slot_bindings b
+    JOIN ne19_run_resources r ON r.run_id=b.target_run_id
+    WHERE b.attempt_id=? AND b.origin_run_id=? AND b.action='accepted'
+      AND r.experiment_id=? AND b.binding_revision<=? AND b.binding_revision<=?
+      AND NOT EXISTS (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=b.target_run_id)
+    ORDER BY b.target_run_id LIMIT ?`, request.attemptId, request.originRunId, request.experimentId, request.bindingRevision, cutoffRevision, RECORD_SQLITE_MAX_VALIDATION_RUNS + 1);
+	if (selected.length > 1e5) throw sqliteError("record-resource-limit-exceeded", "find-accepted-attempt-runs", "Attempt exceeds its adoption proof ceiling");
+	return Object.freeze(selected.map((row) => text$2(row, "target_run_id")));
+}
 function findExperimentRunIds(connection, experimentId) {
 	requireIdentity$1(experimentId, "experimentId");
-	const selected = rows(connection, `SELECT r.run_id FROM ne18_runs r
-    LEFT JOIN ne18_run_resources resource ON resource.run_id=r.run_id
-    WHERE coalesce(resource.experiment_id,json_extract(r.core_payload,'$.experimentId'))=?
-      AND NOT EXISTS (SELECT 1 FROM ne18_run_deletion_tombstones d WHERE d.run_id=r.run_id)
-      AND (r.status='sealed' OR EXISTS (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=r.run_id))
+	const selected = rows(connection, `SELECT r.run_id FROM ne19_runs r
+    WHERE r.experiment_id=?
+      AND NOT EXISTS (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=r.run_id)
+      AND (r.status='sealed' OR EXISTS (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=r.run_id))
     ORDER BY r.run_id LIMIT ?`, experimentId, RECORD_SQLITE_MAX_VALIDATION_RUNS + 1);
 	if (selected.length > 1e5) throw sqliteError("record-resource-limit-exceeded", "find-experiment-runs", "Experiment exceeds its Run ceiling");
 	return Object.freeze(selected.map((row) => text$2(row, "run_id")));
@@ -11156,11 +11700,11 @@ function readSealedRunSummaryPage(connection, afterRunId = "", pageSize = 100, e
 		cutoffHash.update("[");
 		let runCount = 0;
 		const inventory = recordStatement(connection, `SELECT run_id,
-      coalesce(logical_seal_identity,'published:' || (SELECT max(p.published_revision) FROM ne18_attempt_publications p
-        WHERE p.origin_run_id=ne18_runs.run_id)) logical_seal_identity
-      FROM ne18_runs WHERE NOT EXISTS (SELECT 1 FROM ne18_run_deletion_tombstones d WHERE d.run_id=ne18_runs.run_id)
+      coalesce(logical_seal_identity,'published:' || (SELECT max(p.published_revision) FROM ne19_attempt_publications p
+        WHERE p.origin_run_id=ne19_runs.run_id)) logical_seal_identity
+      FROM ne19_runs WHERE NOT EXISTS (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=ne19_runs.run_id)
         AND (status='sealed' OR EXISTS
-          (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=ne18_runs.run_id))
+          (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=ne19_runs.run_id))
       ORDER BY run_id`).iterate();
 		for (const row of inventory) {
 			if (runCount >= 1e5) throw sqliteError("record-resource-limit-exceeded", "page-sealed-runs", "sealed cutoff exceeds its Run ceiling");
@@ -11180,10 +11724,10 @@ function readSealedRunSummaryPage(connection, afterRunId = "", pageSize = 100, e
 		});
 	})();
 	if (expectedCutoffIdentity !== void 0 && expectedCutoffIdentity !== identity) throw sqliteError("record-command-conflict", "page-sealed-runs", "sealed cutoff changed; restart pagination");
-	const pageRows = rows(connection, `SELECT run_id FROM ne18_runs WHERE run_id>?
-    AND NOT EXISTS (SELECT 1 FROM ne18_run_deletion_tombstones d WHERE d.run_id=ne18_runs.run_id)
+	const pageRows = rows(connection, `SELECT run_id FROM ne19_runs WHERE run_id>?
+    AND NOT EXISTS (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=ne19_runs.run_id)
     AND (status='sealed' OR EXISTS
-    (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=ne18_runs.run_id)) ORDER BY run_id LIMIT ?`, afterRunId, pageSize + 1);
+    (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=ne19_runs.run_id)) ORDER BY run_id LIMIT ?`, afterRunId, pageSize + 1);
 	const summaries = pageRows.slice(0, pageSize).map((row) => {
 		const summary = readSealedRunSummary(connection, text$2(row, "run_id"));
 		if (summary === void 0) throw sqliteError("record-database-invalid", "page-sealed-runs", "sealed Run disappeared inside pinned read generation");
@@ -11201,11 +11745,11 @@ function readSealedRunSummaryPage(connection, afterRunId = "", pageSize = 100, e
 	});
 }
 /** Indexed, bounded locator projection. No Core or attachment payload is selected. */
-function findAttemptLocatorCandidates(connection, locator, maximumCandidateRuns) {
+function findAttemptLocatorCandidates(connection, locator, maximumCandidateRuns, includeTargets = true) {
 	if (!parseAttemptLocator(locator).valid) throw sqliteError("record-content-invalid", "find-attempt-locator", "Attempt locator is malformed");
 	if (!Number.isSafeInteger(maximumCandidateRuns) || maximumCandidateRuns < 1 || maximumCandidateRuns > 256) throw sqliteError("record-resource-limit-exceeded", "find-attempt-locator", "candidate Run limit must be between 1 and 256");
-	const matching = rows(connection, `SELECT a.origin_run_id,a.attempt_id FROM ne18_attempts a
-    JOIN ne18_runs origin ON origin.run_id=a.origin_run_id
+	const matching = rows(connection, `SELECT a.origin_run_id,a.attempt_id FROM ne19_attempts a
+    JOIN ne19_runs origin ON origin.run_id=a.origin_run_id
     WHERE a.attempt_locator=? ORDER BY a.origin_run_id,a.attempt_id LIMIT ?`, locator, maximumCandidateRuns + 1);
 	const identities = /* @__PURE__ */ new Set();
 	const candidates = [];
@@ -11216,9 +11760,9 @@ function findAttemptLocatorCandidates(connection, locator, maximumCandidateRuns)
 	for (const row of matching) {
 		const originRunId = text$2(row, "origin_run_id");
 		const attemptId = text$2(row, "attempt_id");
-		if (recordStatement(connection, `SELECT 1 FROM ne18_runs r WHERE r.run_id=? AND
-      ((r.status='sealed' AND NOT EXISTS (SELECT 1 FROM ne18_run_resources rr WHERE rr.run_id=r.run_id)) OR
-       EXISTS (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=r.run_id AND p.attempt_id=?))`).get(originRunId, attemptId) === void 0) continue;
+		if (recordStatement(connection, `SELECT 1 FROM ne19_runs r WHERE r.run_id=? AND
+      ((r.status='sealed' AND NOT EXISTS (SELECT 1 FROM ne19_run_resources rr WHERE rr.run_id=r.run_id)) OR
+       EXISTS (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=r.run_id AND p.attempt_id=?))`).get(originRunId, attemptId) === void 0) continue;
 		identities.add(hashCanonicalTuple("niceeval.record.attempt-candidate/v1", [originRunId, attemptId]));
 		add({
 			locator,
@@ -11227,8 +11771,9 @@ function findAttemptLocatorCandidates(connection, locator, maximumCandidateRuns)
 			relation: "origin",
 			runId: originRunId
 		});
-		const targets = rows(connection, `SELECT DISTINCT m.target_run_id FROM ne18_members m
-      JOIN ne18_runs target ON target.run_id=m.target_run_id AND target.status='sealed'
+		if (!includeTargets) continue;
+		const targets = rows(connection, `SELECT DISTINCT m.target_run_id FROM ne19_members m
+      JOIN ne19_runs target ON target.run_id=m.target_run_id AND target.status='sealed'
       WHERE m.origin_run_id=? AND m.attempt_id=? ORDER BY m.target_run_id LIMIT ?`, originRunId, attemptId, maximumCandidateRuns - candidates.length + 1);
 		for (const target of targets) add({
 			locator,
@@ -11252,12 +11797,12 @@ function readCollectionItemPage(connection, attachmentId, afterOrdinal, pageSize
 	let pageBytes = 0;
 	let hasMore = false;
 	const pageRows = recordStatement(connection, `SELECT i.ordinal,i.logical_identity,i.canonical_payload,i.canonical_digest,
-      EXISTS(SELECT 1 FROM ne18_collection_items more WHERE more.attachment_id=i.attachment_id AND more.ordinal>i.ordinal) AS has_more
-      FROM ne18_collection_items i
-      JOIN ne18_attachments a ON a.attachment_id=i.attachment_id JOIN ne18_runs r ON r.run_id=a.owner_run_id
+      EXISTS(SELECT 1 FROM ne19_collection_items more WHERE more.attachment_id=i.attachment_id AND more.ordinal>i.ordinal) AS has_more
+      FROM ne19_collection_items i
+      JOIN ne19_attachments a ON a.attachment_id=i.attachment_id JOIN ne19_runs r ON r.run_id=a.owner_run_id
       WHERE i.attachment_id=? AND i.ordinal>? AND
-        ((r.status='sealed' AND (NOT EXISTS (SELECT 1 FROM ne18_run_resources rr WHERE rr.run_id=r.run_id) OR a.owner_kind='run')) OR
-         (a.owner_kind='attempt' AND EXISTS (SELECT 1 FROM ne18_attempt_publications p
+        ((r.status='sealed' AND (NOT EXISTS (SELECT 1 FROM ne19_run_resources rr WHERE rr.run_id=r.run_id) OR a.owner_kind='run')) OR
+         (a.owner_kind='attempt' AND EXISTS (SELECT 1 FROM ne19_attempt_publications p
            WHERE p.origin_run_id=a.owner_run_id AND p.attempt_id=a.owner_attempt_id)))
       ORDER BY i.ordinal LIMIT ?`).iterate(attachmentId, afterOrdinal, pageSize);
 	for (const row of pageRows) {
@@ -11307,14 +11852,14 @@ function memoRecordRead(read, defer) {
 }
 function readPublishedSealedRun(connection, runId, defer) {
 	const run = recordStatement(connection, `SELECT run_id,writer_generation,started_at,status,
-    coalesce(logical_seal_identity,'published:' || (SELECT max(p.published_revision) FROM ne18_attempt_publications p
-      WHERE p.origin_run_id=ne18_runs.run_id)) logical_seal_identity,core_payload,core_digest,
-    (SELECT p.closure_payload FROM ne18_attempt_publications p WHERE p.origin_run_id=ne18_runs.run_id
+    coalesce(logical_seal_identity,'published:' || (SELECT max(p.published_revision) FROM ne19_attempt_publications p
+      WHERE p.origin_run_id=ne19_runs.run_id)) logical_seal_identity,core_payload,core_digest,
+    (SELECT p.closure_payload FROM ne19_attempt_publications p WHERE p.origin_run_id=ne19_runs.run_id
       ORDER BY p.published_revision DESC LIMIT 1) publication_closure
-    FROM ne18_runs WHERE run_id=?
-      AND NOT EXISTS (SELECT 1 FROM ne18_run_deletion_tombstones d WHERE d.run_id=ne18_runs.run_id)
+    FROM ne19_runs WHERE run_id=?
+      AND NOT EXISTS (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=ne19_runs.run_id)
       AND (status='sealed' OR EXISTS
-      (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=ne18_runs.run_id))`).get(runId);
+      (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=ne19_runs.run_id))`).get(runId);
 	if (run === void 0) return void 0;
 	let runCoreBytes;
 	let runCoreDigest;
@@ -11334,32 +11879,32 @@ function readPublishedSealedRun(connection, runId, defer) {
 		runCoreDigest = digestBytes(runCoreBytes);
 	}
 	const admission = recordStatement(connection, `SELECT
-    1+(SELECT count(*) FROM ne18_slots WHERE run_id=?)+(SELECT count(*) FROM ne18_attempts WHERE origin_run_id=?)+
-      (SELECT count(*) FROM ne18_members WHERE target_run_id=?)+(SELECT count(*) FROM ne18_attachments WHERE owner_run_id=?)+
-      (SELECT count(*) FROM ne18_attachment_references rr JOIN ne18_attachments aa ON aa.attachment_id=rr.attachment_id WHERE aa.owner_run_id=?)+
-      (SELECT count(*) FROM ne18_contents cc JOIN ne18_attachments aa ON aa.attachment_id=cc.attachment_id WHERE aa.owner_run_id=?) row_count,
-    coalesce(length(r.core_payload),(SELECT max(length(p.closure_payload)) FROM ne18_attempt_publications p WHERE p.origin_run_id=r.run_id),0)+
-      (SELECT coalesce(sum(length(core_payload)),0) FROM ne18_slots WHERE run_id=?)+
-      (SELECT coalesce(sum(length(core_payload)),0) FROM ne18_attempts WHERE origin_run_id=?)+
-      (SELECT coalesce(sum(length(core_payload)),0) FROM ne18_members WHERE target_run_id=?)+
-      (SELECT coalesce(sum(length(canonical_payload)+length(logical_inventory)),0) FROM ne18_attachments WHERE owner_run_id=?)+
-      (SELECT coalesce(sum(length(rr.canonical_payload)),0) FROM ne18_attachment_references rr JOIN ne18_attachments aa ON aa.attachment_id=rr.attachment_id WHERE aa.owner_run_id=?) byte_count
-    FROM ne18_runs r WHERE r.run_id=? AND (r.status='sealed' OR EXISTS
-      (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=r.run_id))`).get(runId, runId, runId, runId, runId, runId, runId, runId, runId, runId, runId, runId);
+    1+(SELECT count(*) FROM ne19_slots WHERE run_id=?)+(SELECT count(*) FROM ne19_attempts WHERE origin_run_id=?)+
+      (SELECT count(*) FROM ne19_members WHERE target_run_id=?)+(SELECT count(*) FROM ne19_attachments WHERE owner_run_id=?)+
+      (SELECT count(*) FROM ne19_attachment_references rr JOIN ne19_attachments aa ON aa.attachment_id=rr.attachment_id WHERE aa.owner_run_id=?)+
+      (SELECT count(*) FROM ne19_contents cc JOIN ne19_attachments aa ON aa.attachment_id=cc.attachment_id WHERE aa.owner_run_id=?) row_count,
+    coalesce(length(r.core_payload),(SELECT max(length(p.closure_payload)) FROM ne19_attempt_publications p WHERE p.origin_run_id=r.run_id),0)+
+      (SELECT coalesce(sum(length(core_payload)),0) FROM ne19_slots WHERE run_id=?)+
+      (SELECT coalesce(sum(length(core_payload)),0) FROM ne19_attempts WHERE origin_run_id=?)+
+      (SELECT coalesce(sum(length(core_payload)),0) FROM ne19_members WHERE target_run_id=?)+
+      (SELECT coalesce(sum(length(canonical_payload)+length(logical_inventory)),0) FROM ne19_attachments WHERE owner_run_id=?)+
+      (SELECT coalesce(sum(length(rr.canonical_payload)),0) FROM ne19_attachment_references rr JOIN ne19_attachments aa ON aa.attachment_id=rr.attachment_id WHERE aa.owner_run_id=?) byte_count
+    FROM ne19_runs r WHERE r.run_id=? AND (r.status='sealed' OR EXISTS
+      (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=r.run_id))`).get(runId, runId, runId, runId, runId, runId, runId, runId, runId, runId, runId, runId);
 	assertBoundedBatch("read-sealed-run-core", integer$1(admission, "row_count"), integer$1(admission, "byte_count"));
-	const record = recordStatement(connection, "SELECT record_payload,record_digest FROM ne18_record_metadata WHERE singleton=1").get();
-	const slots = rows(connection, "SELECT slot_id,ordinal,core_payload,core_digest FROM ne18_slots WHERE run_id=? ORDER BY ordinal", runId).map((row) => Object.freeze({
+	const record = recordStatement(connection, "SELECT record_payload,record_digest FROM ne19_record_metadata WHERE singleton=1").get();
+	const slots = rows(connection, "SELECT slot_id,ordinal,core_payload,core_digest FROM ne19_slots WHERE run_id=? ORDER BY ordinal", runId).map((row) => Object.freeze({
 		slotId: text$2(row, "slot_id"),
 		ordinal: integer$1(row, "ordinal"),
 		coreBytes: transferableBytes(bytes(row, "core_payload")),
 		coreDigest: text$2(row, "core_digest")
 	}));
-	const publicationResource = recordStatement(connection, "SELECT created_revision FROM ne18_run_resources WHERE run_id=?").get(runId);
+	const publicationResource = recordStatement(connection, "SELECT created_revision FROM ne19_run_resources WHERE run_id=?").get(runId);
 	const publicationManaged = publicationResource !== void 0;
-	const attempts = rows(connection, publicationManaged ? `SELECT a.attempt_id,a.attempt_locator,a.core_payload,a.core_digest,p.published_revision FROM ne18_attempts a
-      JOIN ne18_attempt_publications p ON p.origin_run_id=a.origin_run_id AND p.attempt_id=a.attempt_id
-      WHERE a.origin_run_id=? AND EXISTS (SELECT 1 FROM ne18_attempt_publications p
-        WHERE p.origin_run_id=a.origin_run_id AND p.attempt_id=a.attempt_id) ORDER BY a.attempt_id` : "SELECT attempt_id,attempt_locator,core_payload,core_digest FROM ne18_attempts WHERE origin_run_id=? ORDER BY attempt_id", runId).map((row) => {
+	const attempts = rows(connection, publicationManaged ? `SELECT a.attempt_id,a.attempt_locator,a.core_payload,a.core_digest,p.published_revision FROM ne19_attempts a
+      JOIN ne19_attempt_publications p ON p.origin_run_id=a.origin_run_id AND p.attempt_id=a.attempt_id
+      WHERE a.origin_run_id=? AND EXISTS (SELECT 1 FROM ne19_attempt_publications p
+        WHERE p.origin_run_id=a.origin_run_id AND p.attempt_id=a.attempt_id) ORDER BY a.attempt_id` : "SELECT attempt_id,attempt_locator,core_payload,core_digest FROM ne19_attempts WHERE origin_run_id=? ORDER BY attempt_id", runId).map((row) => {
 		if (!(row.core_payload instanceof Uint8Array)) throw sqliteError("record-database-invalid", "read-published-run-core", `Attempt ${text$2(row, "attempt_id")} Core is not published`);
 		const attemptId = text$2(row, "attempt_id");
 		return Object.freeze({
@@ -11377,16 +11922,17 @@ function readPublishedSealedRun(connection, runId, defer) {
 	const members = (publicationManaged ? [...rows(connection, `SELECT 'binding' publication_kind,b.slot_id,b.origin_run_id,b.attempt_id,b.action,b.attempt_publication_revision,b.binding_revision,
       m.origin_run_id member_origin_run_id,m.attempt_id member_attempt_id,m.action member_action,
       m.core_payload,m.core_digest,p.published_revision
-      FROM ne18_run_slot_bindings b
-      LEFT JOIN ne18_members m ON m.target_run_id=b.target_run_id AND m.slot_id=b.slot_id
-      LEFT JOIN ne18_attempt_publications p ON p.attempt_id=b.attempt_id AND p.origin_run_id=b.origin_run_id
+      FROM ne19_run_slot_bindings b
+      LEFT JOIN ne19_members m ON m.target_run_id=b.target_run_id AND m.slot_id=b.slot_id
+      LEFT JOIN ne19_attempt_publications p ON p.attempt_id=b.attempt_id AND p.origin_run_id=b.origin_run_id
         AND p.published_revision=b.attempt_publication_revision
       WHERE b.target_run_id=?`, runId), ...rows(connection, `SELECT 'absence' publication_kind,a.slot_id,NULL origin_run_id,NULL attempt_id,
         NULL action,NULL attempt_publication_revision,NULL member_origin_run_id,NULL member_attempt_id,
         NULL member_action,NULL core_payload,NULL core_digest,NULL published_revision,a.reason absence_reason
-        FROM ne18_run_slot_absences a
-        WHERE a.run_id=?`, runId)].sort((left, right) => text$2(left, "slot_id").localeCompare(text$2(right, "slot_id"))) : rows(connection, "SELECT slot_id,origin_run_id,attempt_id,action,core_payload,core_digest FROM ne18_members WHERE target_run_id=? ORDER BY slot_id", runId)).map((row) => {
+        FROM ne19_run_slot_absences a
+        WHERE a.run_id=?`, runId)].sort((left, right) => text$2(left, "slot_id").localeCompare(text$2(right, "slot_id"))) : rows(connection, "SELECT slot_id,origin_run_id,attempt_id,action,core_payload,core_digest FROM ne19_members WHERE target_run_id=? ORDER BY slot_id", runId)).map((row) => {
 		const attemptId = optionalText$1(row, "attempt_id");
+		let referenceCore;
 		if (publicationManaged) {
 			const kind = text$2(row, "publication_kind");
 			if (kind === "absence") {
@@ -11399,7 +11945,26 @@ function readPublishedSealedRun(connection, runId, defer) {
 					coreDigest: projected.coreDigest
 				});
 			}
-			if (kind === "binding" && (attemptId === void 0 || optionalInteger(row, "published_revision") !== optionalInteger(row, "attempt_publication_revision") || optionalText$1(row, "member_origin_run_id") !== optionalText$1(row, "origin_run_id") || optionalText$1(row, "member_attempt_id") !== attemptId || optionalText$1(row, "member_action") !== optionalText$1(row, "action"))) throw sqliteError("record-database-invalid", "read-published-run", `Published Slot ${text$2(row, "slot_id")} does not close over one matching Member`);
+			const projectReference = (row.action === "carried" || row.action === "accepted") && row.core_payload == null;
+			if (kind === "binding" && (attemptId === void 0 || optionalInteger(row, "published_revision") !== optionalInteger(row, "attempt_publication_revision") || !projectReference && (optionalText$1(row, "member_origin_run_id") !== optionalText$1(row, "origin_run_id") || optionalText$1(row, "member_attempt_id") !== attemptId || optionalText$1(row, "member_action") !== optionalText$1(row, "action")))) throw sqliteError("record-database-invalid", "read-published-run", `Published Slot ${text$2(row, "slot_id")} does not close over one matching Member`);
+			if (projectReference) {
+				const decoded = decodeMemberDocument({
+					slotId: text$2(row, "slot_id"),
+					action: text$2(row, "action"),
+					attempt: {
+						originRunId: text$2(row, "origin_run_id"),
+						attemptId
+					}
+				});
+				if (Result.isFailure(decoded)) throw sqliteError("record-database-invalid", "read-published-run", "Reference binding cannot project a Member");
+				const encoded = encodeMemberDocument(decoded.success);
+				if (Result.isFailure(encoded)) throw sqliteError("record-database-invalid", "read-published-run", "Reference Member cannot be encoded");
+				const projectedBytes = encodeRecordJsonUtf8(encoded.success);
+				referenceCore = {
+					bytes: projectedBytes,
+					digest: digestBytes(projectedBytes)
+				};
+			}
 		}
 		return Object.freeze({
 			slotId: text$2(row, "slot_id"),
@@ -11412,25 +11977,25 @@ function readPublishedSealedRun(connection, runId, defer) {
 				attemptId,
 				revision: integer$1(row, "published_revision")
 			}) } : {},
-			coreBytes: transferableBytes(bytes(row, "core_payload")),
-			coreDigest: text$2(row, "core_digest")
+			coreBytes: transferableBytes(referenceCore?.bytes ?? bytes(row, "core_payload")),
+			coreDigest: referenceCore?.digest ?? text$2(row, "core_digest")
 		});
 	});
 	const attachments = rows(connection, `SELECT attachment_id,owner_kind,owner_run_id,owner_attempt_id,family,family_revision,
     logical_identity,canonical_digest,inventory_digest
-    FROM ne18_attachments a WHERE owner_run_id=?${publicationManaged ? ` AND canonical_payload IS NOT NULL AND
-      (owner_kind='run' OR EXISTS (SELECT 1 FROM ne18_attempt_publications p
+    FROM ne19_attachments a WHERE owner_run_id=?${publicationManaged ? ` AND canonical_payload IS NOT NULL AND
+      (owner_kind='run' OR EXISTS (SELECT 1 FROM ne19_attempt_publications p
         WHERE p.origin_run_id=a.owner_run_id AND p.attempt_id=a.owner_attempt_id))` : ""} ORDER BY attachment_id`, runId).map((row) => {
 		const attachmentId = text$2(row, "attachment_id");
 		const payload = memoRecordRead(() => {
-			const stored = recordStatement(connection, `SELECT canonical_payload,logical_inventory FROM ne18_attachments WHERE attachment_id=?`).get(attachmentId);
+			const stored = recordStatement(connection, `SELECT canonical_payload,logical_inventory FROM ne19_attachments WHERE attachment_id=?`).get(attachmentId);
 			return {
 				canonicalBytes: transferableBytes(bytes(stored, "canonical_payload")),
 				logicalInventoryBytes: transferableBytes(bytes(stored, "logical_inventory"))
 			};
 		}, defer);
 		const references = memoRecordRead(() => Object.freeze(rows(connection, `SELECT ordinal,target_owner_kind,target_family,canonical_payload,reference_digest
-      FROM ne18_attachment_references WHERE attachment_id=? ORDER BY ordinal`, attachmentId).map((reference) => Object.freeze({
+      FROM ne19_attachment_references WHERE attachment_id=? ORDER BY ordinal`, attachmentId).map((reference) => Object.freeze({
 			ordinal: integer$1(reference, "ordinal"),
 			owner: ownerKind(reference, "target_owner_kind"),
 			family: text$2(reference, "target_family"),
@@ -11438,7 +12003,7 @@ function readPublishedSealedRun(connection, runId, defer) {
 			referenceDigest: text$2(reference, "reference_digest")
 		}))), defer);
 		const contents = memoRecordRead(() => Object.freeze(rows(connection, `SELECT content_id,logical_handle,byte_length,overall_digest,chunk_count
-      FROM ne18_contents WHERE attachment_id=? ORDER BY content_id`, attachmentId).map((content) => Object.freeze({
+      FROM ne19_contents WHERE attachment_id=? ORDER BY content_id`, attachmentId).map((content) => Object.freeze({
 			contentId: text$2(content, "content_id"),
 			logicalHandle: text$2(content, "logical_handle"),
 			byteLength: integer$1(content, "byte_length"),
@@ -11447,7 +12012,7 @@ function readPublishedSealedRun(connection, runId, defer) {
 		}))), defer);
 		const collection = memoRecordRead(() => {
 			const aggregate = recordStatement(connection, `SELECT count(*) item_count,coalesce(sum(length(canonical_payload)),0) item_bytes
-        FROM ne18_collection_items WHERE attachment_id=?`).get(attachmentId);
+        FROM ne19_collection_items WHERE attachment_id=?`).get(attachmentId);
 			return {
 				count: integer$1(aggregate, "item_count"),
 				byteLength: integer$1(aggregate, "item_bytes")
@@ -11515,25 +12080,25 @@ function readSealedRunCore(connection, runId, defer) {
 /** Fixed, decoded projection sufficient to rebuild sealed Core and attachment metadata. */
 function readSealedRunDocument(connection, runId) {
 	const run = recordStatement(connection, `SELECT run_id,writer_generation,started_at,logical_seal_identity,core_payload,core_digest
-    FROM ne18_runs WHERE run_id=? AND status='sealed'`).get(runId);
+    FROM ne19_runs WHERE run_id=? AND status='sealed'`).get(runId);
 	if (run === void 0) return void 0;
 	const whole = recordStatement(connection, `SELECT count(*) row_count,coalesce(sum(length(i.canonical_payload)),0) byte_count
-    FROM ne18_collection_items i JOIN ne18_attachments a ON a.attachment_id=i.attachment_id WHERE a.owner_run_id=?`).get(runId);
+    FROM ne19_collection_items i JOIN ne19_attachments a ON a.attachment_id=i.attachment_id WHERE a.owner_run_id=?`).get(runId);
 	assertBoundedBatch("read-sealed-run-document", integer$1(whole, "row_count"), integer$1(whole, "byte_count"));
-	const record = recordStatement(connection, "SELECT record_payload,record_digest FROM ne18_record_metadata WHERE singleton=1").get();
-	const slots = rows(connection, "SELECT slot_id,ordinal,core_payload,core_digest FROM ne18_slots WHERE run_id=? ORDER BY ordinal", runId).map((row) => Object.freeze({
+	const record = recordStatement(connection, "SELECT record_payload,record_digest FROM ne19_record_metadata WHERE singleton=1").get();
+	const slots = rows(connection, "SELECT slot_id,ordinal,core_payload,core_digest FROM ne19_slots WHERE run_id=? ORDER BY ordinal", runId).map((row) => Object.freeze({
 		slotId: text$2(row, "slot_id"),
 		ordinal: integer$1(row, "ordinal"),
 		coreBytes: transferableBytes(bytes(row, "core_payload")),
 		coreDigest: text$2(row, "core_digest")
 	}));
-	const attempts = rows(connection, "SELECT attempt_id,attempt_locator,core_payload,core_digest FROM ne18_attempts WHERE origin_run_id=? ORDER BY attempt_id", runId).map((row) => Object.freeze({
+	const attempts = rows(connection, "SELECT attempt_id,attempt_locator,core_payload,core_digest FROM ne19_attempts WHERE origin_run_id=? ORDER BY attempt_id", runId).map((row) => Object.freeze({
 		attemptId: text$2(row, "attempt_id"),
 		attemptLocator: text$2(row, "attempt_locator"),
 		coreBytes: transferableBytes(bytes(row, "core_payload")),
 		coreDigest: text$2(row, "core_digest")
 	}));
-	const members = rows(connection, `SELECT slot_id,origin_run_id,attempt_id,action,core_payload,core_digest FROM ne18_members
+	const members = rows(connection, `SELECT slot_id,origin_run_id,attempt_id,action,core_payload,core_digest FROM ne19_members
     WHERE target_run_id=? ORDER BY slot_id`, runId).map((row) => Object.freeze({
 		slotId: text$2(row, "slot_id"),
 		...optionalText$1(row, "origin_run_id") === void 0 ? {} : { originRunId: optionalText$1(row, "origin_run_id") },
@@ -11543,11 +12108,11 @@ function readSealedRunDocument(connection, runId) {
 		coreDigest: text$2(row, "core_digest")
 	}));
 	const attachments = rows(connection, `SELECT attachment_id,owner_kind,owner_run_id,owner_attempt_id,family,family_revision,
-    logical_identity,canonical_payload,canonical_digest,logical_inventory,inventory_digest FROM ne18_attachments
+    logical_identity,canonical_payload,canonical_digest,logical_inventory,inventory_digest FROM ne19_attachments
     WHERE owner_run_id=? ORDER BY attachment_id`, runId).map((row) => {
 		const attachmentId = text$2(row, "attachment_id");
 		const references = rows(connection, `SELECT ordinal,target_owner_kind,target_family,
-      canonical_payload,reference_digest FROM ne18_attachment_references WHERE attachment_id=? ORDER BY ordinal`, attachmentId).map((reference) => Object.freeze({
+      canonical_payload,reference_digest FROM ne19_attachment_references WHERE attachment_id=? ORDER BY ordinal`, attachmentId).map((reference) => Object.freeze({
 			ordinal: integer$1(reference, "ordinal"),
 			owner: ownerKind(reference, "target_owner_kind"),
 			family: text$2(reference, "target_family"),
@@ -11555,14 +12120,14 @@ function readSealedRunDocument(connection, runId) {
 			referenceDigest: text$2(reference, "reference_digest")
 		}));
 		const collectionItems = rows(connection, `SELECT ordinal,logical_identity,canonical_payload,canonical_digest
-      FROM ne18_collection_items WHERE attachment_id=? ORDER BY ordinal`, attachmentId).map((item) => Object.freeze({
+      FROM ne19_collection_items WHERE attachment_id=? ORDER BY ordinal`, attachmentId).map((item) => Object.freeze({
 			ordinal: integer$1(item, "ordinal"),
 			logicalIdentity: text$2(item, "logical_identity"),
 			canonicalBytes: transferableBytes(bytes(item, "canonical_payload")),
 			canonicalDigest: text$2(item, "canonical_digest")
 		}));
 		const contents = rows(connection, `SELECT content_id,logical_handle,byte_length,overall_digest,chunk_count
-      FROM ne18_contents WHERE attachment_id=? ORDER BY content_id`, attachmentId).map((content) => Object.freeze({
+      FROM ne19_contents WHERE attachment_id=? ORDER BY content_id`, attachmentId).map((content) => Object.freeze({
 			contentId: text$2(content, "content_id"),
 			logicalHandle: text$2(content, "logical_handle"),
 			byteLength: integer$1(content, "byte_length"),
@@ -11610,12 +12175,12 @@ function readContentChunkPage(connection, contentId, afterOrdinal, pageSize) {
 	let pageBytes = 0;
 	let hasMore = false;
 	const pageRows = recordStatement(connection, `SELECT c.ordinal,c.bytes,c.chunk_digest,
-      EXISTS(SELECT 1 FROM ne18_content_chunks more WHERE more.content_id=c.content_id AND more.ordinal>c.ordinal) AS has_more
-      FROM ne18_content_chunks c
-      JOIN ne18_contents n ON n.content_id=c.content_id JOIN ne18_attachments a ON a.attachment_id=n.attachment_id
-      JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE c.content_id=? AND c.ordinal>? AND
-        ((r.status='sealed' AND (NOT EXISTS (SELECT 1 FROM ne18_run_resources rr WHERE rr.run_id=r.run_id) OR a.owner_kind='run')) OR
-         (a.owner_kind='attempt' AND EXISTS (SELECT 1 FROM ne18_attempt_publications p
+      EXISTS(SELECT 1 FROM ne19_content_chunks more WHERE more.content_id=c.content_id AND more.ordinal>c.ordinal) AS has_more
+      FROM ne19_content_chunks c
+      JOIN ne19_contents n ON n.content_id=c.content_id JOIN ne19_attachments a ON a.attachment_id=n.attachment_id
+      JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE c.content_id=? AND c.ordinal>? AND
+        ((r.status='sealed' AND (NOT EXISTS (SELECT 1 FROM ne19_run_resources rr WHERE rr.run_id=r.run_id) OR a.owner_kind='run')) OR
+         (a.owner_kind='attempt' AND EXISTS (SELECT 1 FROM ne19_attempt_publications p
            WHERE p.origin_run_id=a.owner_run_id AND p.attempt_id=a.owner_attempt_id)))
       ORDER BY c.ordinal LIMIT ?`).iterate(contentId, afterOrdinal, pageSize);
 	for (const row of pageRows) {
@@ -12256,12 +12821,12 @@ function requireAbsenceReason(value) {
 	if (!RUN_ABSENCE_REASONS.includes(value)) throw invalid$2(`Run absence reason ${value} is invalid`);
 }
 function metadataGeneration(connection) {
-	const row = recordStatement(connection, "SELECT storage_generation FROM ne18_record_metadata WHERE singleton=1").get();
+	const row = recordStatement(connection, "SELECT storage_generation FROM ne19_record_metadata WHERE singleton=1").get();
 	if (row === void 0) throw invalid$2("ProjectDatabase storage generation is missing");
 	return text$1(row, "storage_generation");
 }
 function currentRevision(connection) {
-	const row = recordStatement(connection, "SELECT revision FROM ne18_run_publication_clock WHERE singleton=1").get();
+	const row = recordStatement(connection, "SELECT revision FROM ne19_run_publication_clock WHERE singleton=1").get();
 	if (row === void 0) throw invalid$2("Run publication clock is missing");
 	return integer(row, "revision");
 }
@@ -12289,8 +12854,8 @@ function publicationIdentity(row) {
 }
 function readSlotPublication(connection, runId, slotId, cutoff) {
 	const binding = recordStatement(connection, `SELECT b.action,b.binding_revision,b.attempt_id,b.origin_run_id,b.origin_slot_id,
-    b.attempt_publication_revision,a.attempt_locator FROM ne18_run_slot_bindings b
-    JOIN ne18_attempt_publications a ON a.attempt_id=b.attempt_id
+    b.attempt_publication_revision,a.attempt_locator FROM ne19_run_slot_bindings b
+    JOIN ne19_attempt_publications a ON a.attempt_id=b.attempt_id
     WHERE b.target_run_id=? AND b.slot_id=? AND b.binding_revision<=?`).get(runId, slotId, cutoff.revision);
 	if (binding !== void 0) {
 		const action = text$1(binding, "action");
@@ -12306,7 +12871,7 @@ function readSlotPublication(connection, runId, slotId, cutoff) {
 			bindingRevision: integer(binding, "binding_revision")
 		});
 	}
-	const absence = recordStatement(connection, `SELECT reason,absence_revision FROM ne18_run_slot_absences
+	const absence = recordStatement(connection, `SELECT reason,absence_revision FROM ne19_run_slot_absences
     WHERE run_id=? AND slot_id=? AND absence_revision<=?`).get(runId, slotId, cutoff.revision);
 	if (absence !== void 0) {
 		const reason = text$1(absence, "reason");
@@ -12322,7 +12887,7 @@ function readSlotPublication(connection, runId, slotId, cutoff) {
 function readRunAtCutoff(connection, runId, cutoff) {
 	const row = recordStatement(connection, `SELECT r.run_id,r.invocation_id,r.experiment_id,r.started_at,r.initial_writer_generation,r.current_writer_generation,
     r.terminal_state,r.completed_at,r.created_revision,r.close_revision,d.deletion_revision
-    FROM ne18_run_resources r LEFT JOIN ne18_run_deletion_tombstones d ON d.run_id=r.run_id WHERE r.run_id=?`).get(runId);
+    FROM ne19_run_resources r LEFT JOIN ne19_run_deletion_tombstones d ON d.run_id=r.run_id WHERE r.run_id=?`).get(runId);
 	if (row === void 0 || integer(row, "created_revision") > cutoff.revision || row.deletion_revision !== null && row.deletion_revision !== void 0 && integer(row, "deletion_revision") <= cutoff.revision) return;
 	const closeRevision = row.close_revision === null ? void 0 : integer(row, "close_revision");
 	const closeVisible = closeRevision !== void 0 && closeRevision <= cutoff.revision;
@@ -12332,7 +12897,7 @@ function readRunAtCutoff(connection, runId, cutoff) {
 		throw invalid$2(`Run ${runId} close revision lacks terminal state`);
 	})() : "active";
 	const slotRows = recordStatement(connection, `SELECT slot_id,eval_id,attempt_ordinal,execution_identity_digest
-    FROM ne18_run_expected_slots WHERE run_id=? ORDER BY ordinal LIMIT ?`).all(runId, Math.trunc(RECORD_SQLITE_MAX_ROW_BYTES / 256) + 1);
+    FROM ne19_run_expected_slots WHERE run_id=? ORDER BY ordinal LIMIT ?`).all(runId, Math.trunc(RECORD_SQLITE_MAX_ROW_BYTES / 256) + 1);
 	if (slotRows.length > 4096) throw invalid$2(`Run ${runId} expected slot inventory exceeds its bounded read`);
 	const slots = slotRows.map((slot) => Object.freeze({
 		slotId: text$1(slot, "slot_id"),
@@ -12368,11 +12933,11 @@ function listRunResourcesOnConnection(connection, input = {}) {
 	const pageSize = input.pageSize ?? 100;
 	if (input.invocationId !== void 0) requireIdentity(input.invocationId, "invocationId");
 	if (!Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > 256) throw invalid$2("Run page size must be between 1 and 256");
-	const rows = input.invocationId === void 0 ? recordStatement(connection, `SELECT r.run_id FROM ne18_run_resources r
-        LEFT JOIN ne18_run_deletion_tombstones d ON d.run_id=r.run_id
+	const rows = input.invocationId === void 0 ? recordStatement(connection, `SELECT r.run_id FROM ne19_run_resources r
+        LEFT JOIN ne19_run_deletion_tombstones d ON d.run_id=r.run_id
         WHERE r.created_revision<=? AND (d.deletion_revision IS NULL OR d.deletion_revision>?) AND r.run_id>?
-        ORDER BY r.run_id LIMIT ?`).all(cutoff.revision, cutoff.revision, afterRunId, pageSize + 1) : recordStatement(connection, `SELECT r.run_id FROM ne18_run_resources r
-        LEFT JOIN ne18_run_deletion_tombstones d ON d.run_id=r.run_id
+        ORDER BY r.run_id LIMIT ?`).all(cutoff.revision, cutoff.revision, afterRunId, pageSize + 1) : recordStatement(connection, `SELECT r.run_id FROM ne19_run_resources r
+        LEFT JOIN ne19_run_deletion_tombstones d ON d.run_id=r.run_id
         WHERE r.created_revision<=? AND (d.deletion_revision IS NULL OR d.deletion_revision>?) AND r.invocation_id=? AND r.run_id>?
         ORDER BY r.run_id LIMIT ?`).all(cutoff.revision, cutoff.revision, input.invocationId, afterRunId, pageSize + 1);
 	const selected = rows.slice(0, pageSize);
@@ -12448,7 +13013,9 @@ function openPinnedRecordReadSession(path, kind, deadlineEpochMs) {
 					})
 				});
 			}),
-			findAttemptLocatorCandidates: (locator, maximumCandidateRuns) => readBounded("find-attempt-locator", () => findAttemptLocatorCandidates(connection, locator, maximumCandidateRuns)),
+			findSourceBarrierCandidate: (request) => readBounded("find-source-barrier", () => findSourceBarrierCandidate(connection, request, publicationCutoff.revision)),
+			findAcceptedAttemptRunIds: (request) => readBounded("find-accepted-attempt-runs", () => findAcceptedAttemptRunIds(connection, request, publicationCutoff.revision)),
+			findAttemptLocatorCandidates: (locator, maximumCandidateRuns, includeTargets = true) => readBounded("find-attempt-locator", () => findAttemptLocatorCandidates(connection, locator, maximumCandidateRuns, includeTargets)),
 			readSealedRunDocument: (runId) => readBounded("read-sealed-run-document", () => readSealedRunDocument(connection, runId)),
 			readSealedRunCore: (runId, lazyAttachments = false) => readBounded("read-sealed-run-core", () => readSealedRunCore(connection, runId, lazyAttachments ? (read) => readBounded("read-sealed-attachment", read) : void 0)),
 			readContentChunkPage: (contentId, afterOrdinal, pageSize) => readBounded("read-content-page", () => readContentChunkPage(connection, contentId, afterOrdinal, pageSize)),
@@ -12505,24 +13072,25 @@ function openHostOwnedInspectionSource(recordPath) {
 }
 Object.freeze({
 	identity: EMPTY_PUBLICATION_CUTOFF_IDENTITY,
-	runCount: 0
+	storeGeneration: EMPTY_PUBLICATION_CUTOFF_IDENTITY,
+	revision: 0
 });
 function sessionFacts(session, kind) {
-	let observedCutoff;
-	const remember = (page) => {
-		if (observedCutoff !== void 0 && observedCutoff.identity !== page.cutoff.identity) throw new InspectionSourceError({
-			code: "inspection-source-invalid",
-			reason: "Pinned Record session changed its sealed cutoff."
-		});
-		observedCutoff = page.cutoff;
-		return page;
-	};
-	const readPage = (afterRunId = "", pageSize = 100, expectedCutoffIdentity) => remember(session.readSealedRunSummaryPage(afterRunId, pageSize, expectedCutoffIdentity ?? observedCutoff?.identity));
+	const publication = session.publicationCutoff();
+	const cutoff = Object.freeze({
+		...publication,
+		identity: publicationCutoffIdentity(publication)
+	});
+	const readPage = (afterRunId = "", pageSize = 100, expectedCutoffIdentity) => session.readSealedRunSummaryPage(afterRunId, pageSize, expectedCutoffIdentity ?? cutoff.identity);
 	return Object.freeze({
 		kind,
-		cutoff: () => observedCutoff ??= session.sealedCutoff(),
+		cutoff: () => cutoff,
 		findExperimentRunIds: session.findExperimentRunIds,
 		readRunResource: (runId) => session.readRunResource(runId),
+		readRunResourcePage: (afterRunId = "", pageSize = 100) => session.listRunResources({
+			afterRunId,
+			pageSize
+		}),
 		readSealedRunSummaryPage: readPage,
 		findAttemptLocatorCandidates: (locator, maximumCandidateRuns) => session.findAttemptLocatorCandidates(locator, maximumCandidateRuns),
 		readSealedRunCore: (runId) => session.readSealedRunCore(runId, true),
@@ -13467,10 +14035,12 @@ function loadInspectionRuns(source) {
 	const cutoff = source.cutoff();
 	const summaries = [];
 	const seen = /* @__PURE__ */ new Set();
+	let expectedRunCount;
 	let afterRunId = "";
 	for (;;) {
 		const page = source.readSealedRunSummaryPage(afterRunId, RUN_PAGE_SIZE, cutoff.identity);
-		requireCutoff(page.cutoff, cutoff);
+		if (page.cutoff.identity !== cutoff.identity || expectedRunCount !== void 0 && page.cutoff.runCount !== expectedRunCount) throw factsError("Run inventory changed its pinned cutoff or count");
+		expectedRunCount ??= page.cutoff.runCount;
 		if (page.afterRunId !== afterRunId) throw factsError("Run pagination returned a different cursor");
 		let previous = afterRunId;
 		for (const summary of page.summaries) {
@@ -13483,7 +14053,7 @@ function loadInspectionRuns(source) {
 		if (page.summaries.length === 0 || page.nextAfterRunId !== page.summaries.at(-1).runId || page.nextAfterRunId === afterRunId) throw factsError("Run pagination returned an invalid continuation cursor");
 		afterRunId = page.nextAfterRunId;
 	}
-	if (summaries.length !== cutoff.runCount) throw factsError("Run pagination did not close the pinned sealed cutoff");
+	if (summaries.length !== expectedRunCount) throw factsError("Run pagination did not close the pinned sealed cutoff");
 	return Object.freeze(summaries.map((summary) => {
 		const run = readInspectionRun(source, summary.runId);
 		if (run === void 0) throw factsError(`Sealed Run ${summary.runId} disappeared from the pinned cutoff`);
@@ -13507,12 +14077,37 @@ function loadInspectionRunResource(source, runId) {
 	const resource = source.readRunResource(runId);
 	if (resource === void 0) return void 0;
 	const published = readInspectionRun(source, runId);
-	requireCutoff(source.cutoff(), cutoff);
-	if (resource.published > 0 && published === void 0) throw factsError(`Run ${runId} has published bindings without a readable Core`);
 	if (published !== void 0) validateRunResourceCore(resource, published);
+	const originIds = resource.slots.flatMap(({ publication }) => publication.state === "published" ? [publication.originRunId] : []);
+	const supporting = loadSelectedInspectionRuns(source, [...published === void 0 ? [] : [runId], ...originIds]);
+	const index = memberIndex(supporting);
+	const publications = new Map(supporting.flatMap((origin) => origin.physical.attempts.map((attempt) => [`${origin.run.runId}\u0000${attempt.attemptId}`, attempt])));
+	const members = resource.slots.flatMap(({ slotId, publication }) => {
+		if (publication.state === "pending") return [];
+		if (publication.state === "absent") return [decodedRight(decodeMemberDocument({
+			slotId,
+			action: publication.reason === "interrupted-before-publication" || publication.reason === "dispatch-failed" ? "interrupted" : "not-dispatched",
+			attempt: null,
+			absenceReason: publication.reason
+		}), "Run resource absence is invalid")];
+		const attempt = index.origins.get(publication.originRunId)?.attempts.get(publication.attemptId);
+		const stored = publications.get(`${publication.originRunId}\u0000${publication.attemptId}`);
+		if (attempt === void 0 || stored === void 0 || attempt.slotId !== publication.originSlotId || stored.attemptLocator !== publication.attemptLocator || stored.publicationIdentity?.originRunId !== publication.publicationIdentity.originRunId || stored.publicationIdentity?.attemptId !== publication.publicationIdentity.attemptId || stored.publicationIdentity?.revision !== publication.publicationIdentity.revision || publication.publicationIdentity.originRunId !== publication.originRunId || publication.publicationIdentity.attemptId !== publication.attemptId || publication.action === "executed" && publication.originRunId !== runId) throw factsError(`Run ${runId} Slot ${slotId} does not bind a matching published origin Attempt`);
+		return [decodedRight(decodeMemberDocument({
+			slotId,
+			action: publication.action,
+			attempt: {
+				originRunId: publication.originRunId,
+				attemptId: publication.attemptId
+			}
+		}), "Run resource binding is invalid")];
+	}).sort((left, right) => compareText$1(left.slotId, right.slotId));
+	requireCutoff(source.cutoff(), cutoff);
 	return Object.freeze({
 		source,
 		resource,
+		members: Object.freeze(members),
+		supporting,
 		...published === void 0 ? {} : { published }
 	});
 }
@@ -13653,6 +14248,21 @@ function resolveInspectionMemberAttempt(runs, target, member) {
 		targets
 	});
 }
+/** A target binding does not require the target to have published its own Run Core. */
+function resolveInspectionResourceMemberAttempt(target, member) {
+	if (member.attempt === null) return void 0;
+	const index = memberIndex(target.supporting);
+	const origin = index.origins.get(member.attempt.originRunId);
+	const attempt = origin?.attempts.get(member.attempt.attemptId);
+	if (origin === void 0 || attempt === void 0) return void 0;
+	const targets = index.targets.get(attempt.originRunId)?.get(attempt.attemptId) ?? [];
+	return Object.freeze({
+		attempt,
+		origin: origin.run,
+		locator: encodeAttemptLocator(attempt.attemptId),
+		targets
+	});
+}
 function attemptAttachment(resolved, family) {
 	return resolved.origin.attachments.find(({ physical }) => physical.ownerKind === "attempt" && physical.ownerAttemptId === resolved.attempt.attemptId && physical.family === family);
 }
@@ -13760,7 +14370,7 @@ function targetMembers(run, attempt) {
 	return run.members.filter((member) => member.attempt !== null && member.attempt.originRunId === attempt.originRunId && member.attempt.attemptId === attempt.attemptId);
 }
 function requireCutoff(actual, expected) {
-	if (actual.identity !== expected.identity || actual.runCount !== expected.runCount) throw factsError("Inspection source changed its pinned sealed cutoff");
+	if (actual.storeGeneration !== expected.storeGeneration || actual.revision !== expected.revision) throw factsError("Inspection source changed its pinned sealed cutoff");
 }
 function parseJson$1(bytes, owner) {
 	try {
@@ -13880,6 +14490,8 @@ var INSPECTION_RESULT_BYTE_LIMIT = 524288;
 var INSPECTION_EXPERIMENT_RESULT_BYTE_LIMIT = 4194304;
 /** Full source content, Judge audit and base64 encoding for assertion detail only. */
 var INSPECTION_ASSERTION_DETAIL_BYTE_LIMIT = 33554432;
+/** Complete cache groups for all 4000 admitted physical calls, including maximum escaped identities. */
+var INSPECTION_ATTEMPT_USAGE_RESULT_BYTE_LIMIT = 16777216;
 var PAGE_ROWS = 64;
 var IDENTITY_INDEX_LIMIT = 256;
 var TARGET_LIMITS = Object.freeze({
@@ -15381,7 +15993,7 @@ function projectApplicationUsage(attachments, models) {
 		const modelUsage = projectAdapterModelUsage(read.state === "available" ? read.value : null, models, {
 			basis: "recorded-calls",
 			reason: read.state === "invalid" ? "source-invalid" : "usage-not-recorded"
-		});
+		}, attachments.adapterUsage.physical.familyRevision === 4);
 		const empty = {
 			source: "adapter",
 			coverage: "recorded-calls",
@@ -18935,34 +19547,13 @@ function selectOperation(source, operation) {
 				experiment: decodeRequiredResult(operation.kind, InspectionExperimentResultSchema, experimentResult())
 			}));
 		}
-		case "runs.list": return runsListDocument(source, operation);
+		case "run.list": return runsListDocument(source, operation);
 		case "run.get": {
 			const run = requireRunResource(source, operation.kind, operation.runId);
 			const supporting = supportingRunFacts(source, run);
 			return Object.freeze({
 				...runResourceMetadata(source, operation.kind, run, supporting),
-				run: decodeRequiredResult(operation.kind, InspectionRunResultSchema, Object.freeze({
-					value: inspectionRunValue(run),
-					members: run.published?.members ?? Object.freeze([]),
-					attempts: run.published?.attempts ?? Object.freeze([])
-				}))
-			});
-		}
-		case "run.summary": {
-			const selected = selectRuns(loadRuns(source, [operation.runId]), [operation.runId]);
-			const run = requireOne(operation.kind, selected.selected, operation.runId);
-			const all = loadSummaryFacts(source, run);
-			return Object.freeze({
-				...resultMetadata(source, operation.kind, all, [operation.runId], selected.missing, locators(all)),
-				summary: decodeRequiredResult(operation.kind, InspectionRunSummaryResultSchema, runSummary(all, run))
-			});
-		}
-		case "run.overview": {
-			const run = requireRunResource(source, operation.kind, operation.runId);
-			const all = supportingRunFacts(source, run);
-			return Object.freeze({
-				...runResourceMetadata(source, operation.kind, run, all),
-				runOverview: decodeRequiredResult(operation.kind, InspectionRunOverviewResultSchema, runOverview(all, run))
+				run: decodeRequiredResult(operation.kind, InspectionRunResultSchema, runDetail(supporting, run))
 			});
 		}
 		case "attempt.get": {
@@ -19036,7 +19627,7 @@ function selectOperation(source, operation) {
 			while (utf8ByteLength$2(JSON.stringify({
 				...metadata,
 				usage
-			})) > 524288 && (usage.judgeUsage.state === "complete" || usage.judgeUsage.state === "partial") && usage.judgeUsage.calls.length > 0) usage = Object.freeze({
+			})) > 16777216 && (usage.judgeUsage.state === "complete" || usage.judgeUsage.state === "partial") && usage.judgeUsage.calls.length > 0) usage = Object.freeze({
 				...usage,
 				judgeUsage: takeJudgeUsagePreview(usage.judgeUsage, usage.judgeUsage.calls.length - 1)
 			});
@@ -19142,24 +19733,38 @@ function selectOperation(source, operation) {
 function runsListDocument(source, operation) {
 	const page = runSummaryPage(source, operation.continuation);
 	return Object.freeze({
-		...runsListBase(source, page.cutoff, page.items, page.truncated),
+		...runsListBase(source, source.cutoff(), page.items, page.truncated),
 		runs: closeJson(page.items),
 		...page.continuation === void 0 ? {} : { continuation: page.continuation }
 	});
 }
 function runSummaryPage(source, continuation) {
 	const binding = continuation === void 0 ? void 0 : decodeContinuation(continuation);
+	const cutoff = source.cutoff();
 	let page;
 	try {
-		page = source.readSealedRunSummaryPage(binding?.afterRunId ?? "", RUN_LIST_PAGE_SIZE, binding?.cutoffIdentity);
+		if (binding !== void 0 && binding.cutoffIdentity !== cutoff.identity) throw new Error("Publication cutoff changed");
+		page = source.readRunResourcePage(binding?.afterRunId ?? "", RUN_LIST_PAGE_SIZE);
 	} catch (cause) {
-		throw operationFailure("runs.list", "Continuation is invalid or its sealed cutoff changed; restart runs.list", cause);
+		throw operationFailure("run.list", "Continuation is invalid or its publication cutoff changed; restart run.list", cause);
 	}
 	return Object.freeze({
-		cutoff: page.cutoff,
-		items: page.summaries,
+		cutoff,
+		items: Object.freeze(page.runs.map((run) => Object.freeze({
+			runId: run.runId,
+			invocationId: run.invocationId,
+			experimentId: run.experimentId,
+			state: run.state,
+			startedAt: run.startedAt,
+			...run.completedAt === void 0 ? {} : { completedAt: run.completedAt },
+			coverage: Object.freeze({
+				expected: run.expected,
+				published: run.published,
+				missing: run.missing
+			})
+		}))),
 		truncated: page.nextAfterRunId !== null,
-		continuation: page.nextAfterRunId === null ? void 0 : encodeContinuation(page.nextAfterRunId, page.cutoff.identity)
+		continuation: page.nextAfterRunId === null ? void 0 : encodeContinuation(page.nextAfterRunId, cutoff.identity)
 	});
 }
 function runsListBase(source, cutoff, selected, truncated) {
@@ -19167,19 +19772,17 @@ function runsListBase(source, cutoff, selected, truncated) {
 		protocol: QUERY_PROTOCOL,
 		behaviorVersion: INSPECTION_BEHAVIOR_VERSION,
 		outcome: "success",
-		operation: "runs.list",
+		operation: "run.list",
 		source: sourceProvenance(source, cutoff),
-		sealedCutoff: Object.freeze({
-			kind: "inspection-sealed-cutoff",
-			identity: cutoff.identity,
-			runCount: cutoff.runCount
+		publicationCutoff: Object.freeze({
+			storeGeneration: cutoff.storeGeneration,
+			revision: cutoff.revision
 		}),
 		selection: Object.freeze({
 			requestedRunIds: Object.freeze([]),
 			selectedRunIds: Object.freeze(selected.map(({ runId }) => runId)),
 			missingRunIds: Object.freeze([]),
 			returnedRunCount: selected.length,
-			totalRunCount: cutoff.runCount,
 			truncated
 		}),
 		issues: Object.freeze([]),
@@ -19188,7 +19791,7 @@ function runsListBase(source, cutoff, selected, truncated) {
 }
 function encodeContinuation(afterRunId, cutoffIdentity) {
 	return encodeBase64UrlUtf8(JSON.stringify([
-		"runs.list",
+		"run.list",
 		cutoffIdentity,
 		afterRunId
 	]));
@@ -19196,13 +19799,13 @@ function encodeContinuation(afterRunId, cutoffIdentity) {
 function decodeContinuation(token) {
 	try {
 		const decoded = JSON.parse(decodeBase64UrlUtf8(token));
-		if (!Array.isArray(decoded) || decoded.length !== 3 || decoded[0] !== "runs.list" || typeof decoded[1] !== "string" || typeof decoded[2] !== "string") throw new Error("continuation binding changed");
+		if (!Array.isArray(decoded) || decoded.length !== 3 || decoded[0] !== "run.list" || typeof decoded[1] !== "string" || typeof decoded[2] !== "string") throw new Error("continuation binding changed");
 		return Object.freeze({
 			cutoffIdentity: decoded[1],
 			afterRunId: decoded[2]
 		});
 	} catch (cause) {
-		throw operationFailure("runs.list", "Continuation is invalid or its sealed cutoff changed; restart runs.list", cause);
+		throw operationFailure("run.list", "Continuation is invalid or its sealed cutoff changed; restart run.list", cause);
 	}
 }
 function requireCurrentProject(source, experimentIds) {
@@ -19242,8 +19845,8 @@ function inspectionRunValue(run) {
 		}))
 	}));
 }
-function supportingRunFacts(source, run) {
-	return run.published === void 0 ? Object.freeze([]) : loadSummaryFacts(source, run.published);
+function supportingRunFacts(_source, run) {
+	return run.supporting;
 }
 function runResourceMetadata(source, operation, run, supporting) {
 	const metadata = resultMetadata(source, operation, supporting, [run.resource.runId], [], locators(supporting));
@@ -19260,9 +19863,6 @@ function loadReferencedOrigins(source, targets) {
 	const originIds = [...new Set(targets.flatMap(({ members }) => members.flatMap(({ attempt }) => attempt === null || targetIds.has(attempt.originRunId) ? [] : [attempt.originRunId])))];
 	return uniqueRuns([...targets, ...loadRuns(source, originIds)]);
 }
-function loadSummaryFacts(source, target) {
-	return loadReferencedOrigins(source, [target]);
-}
 function selectRuns(all, runIds) {
 	const byId = new Map(all.map((run) => [run.run.runId, run]));
 	const requested = [...new Set(runIds)];
@@ -19274,11 +19874,6 @@ function selectRuns(all, runIds) {
 		missing: Object.freeze(requested.filter((runId) => !byId.has(runId)))
 	});
 }
-function requireOne(operation, selected, runId) {
-	const run = selected[0];
-	if (run === void 0) throw selectionMissing(operation, `Run ${runId} was not found`);
-	return run;
-}
 function requireAttemptFromSource(source, operation, locator) {
 	const resolved = resolveInspectionAttempt(source, locator);
 	if (resolved === void 0) throw selectionMissing(operation, `Attempt ${locator} was not found or is ambiguous`);
@@ -19388,49 +19983,11 @@ function containsState(value, expected) {
 	const record = value;
 	return record.state === expected || Object.values(record).some((entry) => containsState(entry, expected));
 }
-function runSummary(all, selected) {
-	const slots = selected.run.expectedSlots.map((slot) => {
-		const member = selected.members.find((candidate) => candidate.slotId === slot.slotId);
-		if (member === void 0 || member.attempt === null) return Object.freeze({
-			runId: selected.run.runId,
-			...slot,
-			state: member?.action ?? "missing",
-			locator: null,
-			outcome: null,
-			verdict: null
-		});
-		const resolved = resolveInspectionMemberAttempt(all, selected, member);
-		if (resolved === void 0) return Object.freeze({
-			runId: selected.run.runId,
-			...slot,
-			state: "missing",
-			locator: null,
-			outcome: null,
-			verdict: null
-		});
-		const assertions = readInspectionAssertions(resolved);
-		return Object.freeze({
-			runId: selected.run.runId,
-			...slot,
-			state: member.action,
-			locator: resolved.locator,
-			outcome: resolved.attempt.outcome,
-			verdict: attemptVerdict(resolved, assertions),
-			score: assertionScore(assertions.state === "available" ? assertions.value.entries : [])
-		});
-	});
-	return Object.freeze({
-		runs: Object.freeze([selected.run]),
-		denominator: Object.freeze({
-			expected: slots.length,
-			observed: slots.filter(({ locator }) => locator !== null).length
-		}),
-		members: Object.freeze(slots)
-	});
-}
-function runOverview(all, selectedResource) {
+function runDetail(_all, selectedResource) {
 	const selected = selectedResource.published;
 	const value = inspectionRunValue(selectedResource);
+	const publications = new Map(selectedResource.resource.slots.map((slot) => [slot.slotId, slot.publication]));
+	const bindings = new Map(selectedResource.members.map((member) => [member.slotId, member]));
 	const unavailableUsage = () => Object.freeze({
 		state: "unavailable",
 		summary: null,
@@ -19445,16 +20002,30 @@ function runOverview(all, selectedResource) {
 		limitations: Object.freeze([])
 	});
 	const projected = value.expectedSlots.map((slot) => {
-		const targetMember = selected?.members.find((candidate) => candidate.slotId === slot.slotId);
+		const binding = publications.get(slot.slotId);
+		if (binding === void 0) throw new Error(`Run ${value.runId} has no Slot ${slot.slotId}`);
+		const publication = binding.state === "published" ? Object.freeze({
+			state: "published",
+			action: binding.action,
+			attemptId: binding.attemptId,
+			attemptLocator: binding.attemptLocator,
+			originRunId: binding.originRunId,
+			originSlotId: binding.originSlotId
+		}) : binding.state === "absent" ? Object.freeze({
+			state: "absent",
+			reason: binding.reason
+		}) : Object.freeze({ state: "pending" });
+		const targetMember = bindings.get(slot.slotId);
 		if (targetMember === void 0) {
-			if (value.state !== "active") throw new Error(`Terminal Run ${value.runId} has no binding or absence for Slot ${slot.slotId}`);
+			if (publication.state !== "pending" && publication.state !== "absent") throw new Error(`Terminal Run ${value.runId} has no binding or absence for Slot ${slot.slotId}`);
 			const limitation = Object.freeze({
 				kind: "member-not-observed",
-				state: "pending"
+				state: publication.state === "absent" ? publication.reason === "interrupted-before-publication" ? "interrupted" : "not-dispatched" : "pending"
 			});
 			return Object.freeze({ member: Object.freeze({
-				slot,
-				state: "pending",
+				...slot,
+				publication,
+				state: limitation.state,
 				locator: null,
 				relation: null,
 				outcome: null,
@@ -19471,7 +20042,8 @@ function runOverview(all, selectedResource) {
 				state: targetMember.action
 			});
 			return Object.freeze({ member: Object.freeze({
-				slot,
+				...slot,
+				publication,
 				state: targetMember.action,
 				locator: null,
 				relation: null,
@@ -19483,8 +20055,7 @@ function runOverview(all, selectedResource) {
 				limitations: Object.freeze([limitation])
 			}) });
 		}
-		if (selected === void 0) throw new Error(`Run ${value.runId} has a Member without a published Core`);
-		const resolved = resolveInspectionMemberAttempt(all, selected, targetMember);
+		const resolved = resolveInspectionResourceMemberAttempt(selectedResource, targetMember);
 		if (resolved === void 0) {
 			const limitation = Object.freeze({
 				kind: "attempt-unresolved",
@@ -19492,7 +20063,8 @@ function runOverview(all, selectedResource) {
 				attemptId: targetMember.attempt.attemptId
 			});
 			return Object.freeze({ member: Object.freeze({
-				slot,
+				...slot,
+				publication,
 				state: targetMember.action,
 				locator: null,
 				relation: null,
@@ -19519,7 +20091,8 @@ function runOverview(all, selectedResource) {
 		return Object.freeze({
 			usage,
 			member: Object.freeze({
-				slot,
+				...slot,
+				publication,
 				state: targetMember.action,
 				locator: resolved.locator,
 				relation: resolved.attempt.originRunId === value.runId ? "origin" : "reference",
@@ -19548,7 +20121,7 @@ function runOverview(all, selectedResource) {
 	});
 	const members = Object.freeze(projected.map(({ member }) => member));
 	const locatedLimitations = Object.freeze(members.flatMap((member) => member.limitations.map((limitation) => Object.freeze({
-		slotId: member.slot.slotId,
+		slotId: member.slotId,
 		locator: member.locator,
 		limitation
 	}))));
@@ -19558,19 +20131,15 @@ function runOverview(all, selectedResource) {
 	const coverageLimitations = Object.freeze(locatedLimitations.filter(({ limitation }) => limitation.kind !== "usage"));
 	const usageLimitations = Object.freeze(locatedLimitations.filter(({ limitation }) => limitation.kind !== "coverage"));
 	return Object.freeze({
-		identity: Object.freeze({
-			runId: value.runId,
-			experimentId: value.experimentId,
-			adapter: value.context?.execution.adapter ?? null
-		}),
-		state: value.state,
-		startedAt: value.startedAt,
-		...value.completedAt === void 0 ? {} : { completedAt: value.completedAt },
+		value,
+		members: selectedResource.members,
+		attempts: selected?.attempts ?? Object.freeze([]),
 		denominator: Object.freeze({
-			expected: members.length,
-			observed
+			expected: selectedResource.resource.expected,
+			published: selectedResource.resource.published,
+			missing: selectedResource.resource.missing
 		}),
-		members,
+		slots: members,
 		coverage: Object.freeze({
 			state: aggregateRunOverviewState(members.map(({ coverage }) => coverage.state)),
 			expectedMemberCount: members.length,
@@ -19793,10 +20362,6 @@ function comparisonMembers(all, runs) {
 }
 function baseDocument(source, operation, selectedInput, requestedRunIds, missingRunIds, evidence, issues = []) {
 	const selected = uniqueRuns(selectedInput);
-	const seals = selected.map(({ run, physical }) => Object.freeze({
-		runId: run.runId,
-		logicalSealIdentity: physical.logicalSealIdentity
-	}));
 	const cutoff = source.cutoff();
 	return Object.freeze({
 		protocol: QUERY_PROTOCOL,
@@ -19804,11 +20369,9 @@ function baseDocument(source, operation, selectedInput, requestedRunIds, missing
 		outcome: "success",
 		operation,
 		source: sourceProvenance(source, cutoff),
-		sealedCutoff: Object.freeze({
-			kind: "inspection-sealed-cutoff",
-			identity: cutoff.identity,
-			runCount: cutoff.runCount,
-			runs: Object.freeze(seals)
+		publicationCutoff: Object.freeze({
+			storeGeneration: cutoff.storeGeneration,
+			revision: cutoff.revision
 		}),
 		selection: Object.freeze({
 			requestedRunIds: Object.freeze([...requestedRunIds]),
@@ -19828,14 +20391,9 @@ function resultMetadata(source, operation, selectedInput, requestedRunIds, missi
 		outcome: "success",
 		operation,
 		source: sourceProvenance(source, cutoff),
-		sealedCutoff: Object.freeze({
-			kind: "inspection-sealed-cutoff",
-			identity: cutoff.identity,
-			runCount: cutoff.runCount,
-			runs: Object.freeze(selected.map(({ run, physical }) => Object.freeze({
-				runId: run.runId,
-				logicalSealIdentity: physical.logicalSealIdentity
-			})))
+		publicationCutoff: Object.freeze({
+			storeGeneration: cutoff.storeGeneration,
+			revision: cutoff.revision
 		}),
 		selection: Object.freeze({
 			requestedRunIds: Object.freeze([...requestedRunIds]),
@@ -19856,7 +20414,7 @@ function decodeRequiredResult(operation, schema, input) {
 	return decoded.success;
 }
 function requireInspectionResultBudget(operation, value) {
-	const byteLimit = operation === "experiment.get" ? INSPECTION_EXPERIMENT_RESULT_BYTE_LIMIT : INSPECTION_RESULT_BYTE_LIMIT;
+	const byteLimit = operation === "experiment.get" ? INSPECTION_EXPERIMENT_RESULT_BYTE_LIMIT : operation === "attempt.usage" ? INSPECTION_ATTEMPT_USAGE_RESULT_BYTE_LIMIT : INSPECTION_RESULT_BYTE_LIMIT;
 	if (utf8ByteLength$2(JSON.stringify(value)) > byteLimit) throw new InspectionOperationError({
 		code: "evidence-budget-exceeded",
 		operation,
@@ -19890,7 +20448,7 @@ function arraysEqual(left, right) {
 function sourceProvenance(source, cutoff) {
 	return Object.freeze({
 		kind: source.kind,
-		sealedCutoffIdentity: cutoff.identity
+		publicationCutoffIdentity: cutoff.identity
 	});
 }
 function evaluateInspectionSuccess(operation, evaluate) {
@@ -19953,32 +20511,37 @@ function integrityFailure(operation, cause) {
 }
 //#endregion
 //#region src/view/inspection-host.ts
-async function inspectViewGeneration(generation, input) {
-	const decoded = decodeInspectionRequest(input);
-	if (Result.isFailure(decoded)) throw decoded.failure;
-	return Effect.runPromise(Effect.scoped(Effect.gen(function* () {
-		const opened = yield* openHostOwnedInspectionSource(generation.recordPath);
-		const facts = decoded.success.operation.kind === "project.get" && generation.target.kind === "current" ? Object.freeze({
-			...opened,
-			kind: "project-record"
-		}) : opened;
-		const cutoff = facts.cutoff();
-		if (cutoff.identity !== generation.sourceCutoffIdentity) return yield* Effect.fail(/* @__PURE__ */ new Error("Pinned generation cutoff did not match its descriptor"));
-		if (decoded.success.operation.kind === "project.get" && generation.target.kind === "current") {
-			if (generation.target.input.cutoffIdentity !== cutoff.identity || generation.target.input.target.identity !== generation.target.identity) return yield* Effect.fail(/* @__PURE__ */ new Error("Pinned current target did not match its descriptor"));
-			bindProjectInput(facts, generation.target.input);
-		}
-		return selectInspectionOperation(facts, decoded.success.operation);
-	})).pipe(Effect.catch((cause) => Effect.succeed(Object.freeze({
-		protocol: QUERY_PROTOCOL,
-		outcome: "failure",
-		operation: decoded.success.operation.kind,
-		failure: Object.freeze({
-			code: "inspection-operation-failed",
-			reason: "Inspection could not be completed for this generation.",
-			correction: "retry"
-		})
-	})))));
+function inspectViewGeneration(generation, input) {
+	return Effect.suspend(() => {
+		const decoded = decodeInspectionRequest(input);
+		if (Result.isFailure(decoded)) return Effect.fail(decoded.failure);
+		return Effect.scoped(Effect.gen(function* () {
+			const opened = yield* openHostOwnedInspectionSource(generation.recordPath);
+			const facts = decoded.success.operation.kind === "project.get" && generation.target.kind === "current" ? Object.freeze({
+				...opened,
+				kind: "project-record"
+			}) : opened;
+			const cutoff = facts.cutoff();
+			if (cutoff.identity !== generation.sourceCutoffIdentity) return yield* Effect.fail(/* @__PURE__ */ new Error("Pinned generation cutoff did not match its descriptor"));
+			if (decoded.success.operation.kind === "project.get" && generation.target.kind === "current") {
+				if (generation.target.input.cutoffIdentity !== cutoff.identity || generation.target.input.target.identity !== generation.target.identity) return yield* Effect.fail(/* @__PURE__ */ new Error("Pinned current target did not match its descriptor"));
+				bindProjectInput(facts, {
+					...generation.target.input,
+					runs: loadSelectedInspectionRuns(facts, generation.target.input.runs.map((run) => run.run.runId))
+				});
+			}
+			return selectInspectionOperation(facts, decoded.success.operation);
+		})).pipe(Effect.catch(() => Effect.succeed(Object.freeze({
+			protocol: QUERY_PROTOCOL,
+			outcome: "failure",
+			operation: decoded.success.operation.kind,
+			failure: Object.freeze({
+				code: "inspection-operation-failed",
+				reason: "Inspection could not be completed for this generation.",
+				correction: "retry"
+			})
+		}))));
+	});
 }
 //#endregion
 export { ViewGenerationDescriptorSchema, decodeGenerationCommitRequest, decodeViewInspectionRequest, inspectViewGeneration };