niceeval 0.17.1 → 0.19.0

package/dist/view/function-runtime.mjs

@@ -98,7 +98,8 @@ var NUMERIC_COMPARATORS = [
 	"less-than",
 	"at-most",
 	"greater-than",
-	"at-least"
+	"at-least",
+	"between"
 ];
 //#endregion
 //#region src/assertions/identity.ts
@@ -349,6 +350,16 @@ var NumericComparisonCriterionSchema = Schema.Struct({
 	data: Schema.Struct({
 		comparator: Schema.Literals(NUMERIC_COMPARATORS),
 		threshold: Schema.Finite,
+		upperThreshold: Schema.optional(Schema.Finite),
+		unit: Schema.optional(Schema.Literals([
+			"ms",
+			"seconds",
+			"tokens",
+			"usd",
+			"ratio",
+			"count",
+			"bytes"
+		])),
 		subject: Schema.Union([
 			Schema.Struct({ kind: Schema.Literal("explicit-value") }),
 			Schema.Struct({
@@ -381,7 +392,7 @@ var NumericComparisonCriterionSchema = Schema.Struct({
 				])
 			})
 		])
-	})
+	}).check(Schema.makeFilter((data) => data.comparator === "between" ? data.upperThreshold !== void 0 && data.upperThreshold >= data.threshold : data.upperThreshold === void 0, { message: "Only between comparisons have an ordered upper threshold." }))
 });
 var ScopeStatusCriterionSchema = Schema.Struct({
 	kind: Schema.Literal("builtin"),
@@ -2481,14 +2492,14 @@ var RunGetDocumentSchema = Schema.Struct({
 });
 Schema.Union([RunListDocumentSchema, RunGetDocumentSchema]);
 //#endregion
-//#region src/model-slots.ts
+//#region src/model-roles.ts
 var modelText = Schema.String.check(Schema.isPattern(/\S/u));
-var slotKey = Schema.String.check(Schema.isPattern(/^[A-Za-z][A-Za-z0-9_-]{0,63}$(?![\s\S])/u));
-Schema.Record(slotKey, Schema.Struct({
+var roleKey = Schema.String.check(Schema.isPattern(/^[A-Za-z][A-Za-z0-9_-]{0,63}$(?![\s\S])/u));
+Schema.Record(roleKey, Schema.Struct({
 	model: modelText,
 	reasoningEffort: Schema.optionalKey(modelText)
 })).check(Schema.makeFilter((value) => Object.keys(value).length > 0 && Object.keys(value).length <= 64));
-var ResolvedModelSlotsSchema = Schema.Record(slotKey, Schema.Struct({
+var ResolvedModelRolesSchema = Schema.Record(roleKey, Schema.Struct({
 	model: Schema.NullOr(modelText),
 	reasoningEffort: Schema.NullOr(modelText)
 })).check(Schema.makeFilter((value) => Object.keys(value).length <= 64));
@@ -2530,8 +2541,14 @@ var AdapterIdentitySchema = Schema.Struct({
 	behaviorRevision: Schema.NullOr(NonEmptyStringSchema),
 	cleanupTimeoutMs: Schema.optionalKey(AdapterCleanupTimeoutMsSchema)
 });
+var RunPluginIdentitySchema = Schema.Struct({
+	name: NonEmptyStringSchema,
+	key: NonEmptyStringSchema,
+	identity: RunContextJsonObjectSchema
+});
 var RunExecutionContextSchema = Schema.Struct({
-	models: Schema.optionalKey(ResolvedModelSlotsSchema),
+	plugins: Schema.optionalKey(Schema.Array(RunPluginIdentitySchema)),
+	models: Schema.optionalKey(ResolvedModelRolesSchema),
 	adapter: AdapterIdentitySchema,
 	model: Schema.NullOr(Schema.String),
 	reasoningEffort: Schema.NullOr(Schema.String),
@@ -3506,6 +3523,76 @@ function readVerifiedRange(source, metadata, offset, limit) {
 	return output;
 }
 //#endregion
+//#region src/inspection/planned-attempt.ts
+var { slotId: plannedAttemptId, ...positionFields } = RecordSlotIdentitySchema.fields;
+var PlannedAttemptSchema = Schema.Struct({
+	plannedAttemptId,
+	...positionFields
+});
+var { slotId: attemptPosition, ...attemptFields } = AttemptDocumentSchema.fields;
+var InspectionAttemptCoreSchema = Schema.Struct({
+	plannedAttemptId: attemptPosition,
+	...attemptFields
+}).check(Schema.makeFilter(({ plannedAttemptId, ...attempt }) => Schema.is(AttemptDocumentSchema)({
+	...attempt,
+	slotId: plannedAttemptId
+})));
+var { expectedSlots: _expectedSlots, ...runFields } = RunDocumentSchema.fields;
+var InspectionRunCoreSchema = Schema.Struct({
+	...runFields,
+	plannedAttempts: Schema.Array(PlannedAttemptSchema)
+}).check(Schema.makeFilter(({ plannedAttempts, ...run }) => Schema.is(RunDocumentSchema)({
+	...run,
+	expectedSlots: plannedAttempts.map(({ plannedAttemptId, ...position }) => ({
+		...position,
+		slotId: plannedAttemptId
+	}))
+})));
+var InspectionMemberSchema = Schema.Union(MemberDocumentSchema.members.map((member) => {
+	const { slotId, ...fields } = member.fields;
+	return Schema.Struct({
+		plannedAttemptId: slotId,
+		...fields
+	});
+})).check(Schema.makeFilter(({ plannedAttemptId, ...member }) => Schema.is(MemberDocumentSchema)({
+	...member,
+	slotId: plannedAttemptId
+})));
+var { originSlotId, ...publicationFields } = RunPublishedPublicationSchema.fields;
+var InspectionPublishedPublicationSchema = Schema.Struct({
+	...publicationFields,
+	originPlannedAttemptId: originSlotId
+});
+var PlannedAttemptPublicationSchema = Schema.Union([
+	RunPendingPublicationSchema,
+	InspectionPublishedPublicationSchema,
+	RunAbsentPublicationSchema
+]);
+function projectPlannedAttempt({ slotId, ...position }) {
+	return Object.freeze(Schema.decodeUnknownSync(PlannedAttemptSchema)({
+		...position,
+		plannedAttemptId: slotId
+	}));
+}
+function projectAttemptCore({ slotId, ...attempt }) {
+	return Object.freeze({
+		...attempt,
+		plannedAttemptId: slotId
+	});
+}
+function projectRunCore({ expectedSlots, ...run }) {
+	return Object.freeze({
+		...run,
+		plannedAttempts: Object.freeze(expectedSlots.map(projectPlannedAttempt))
+	});
+}
+function projectMember({ slotId, ...member }) {
+	return Object.freeze({
+		...member,
+		plannedAttemptId: slotId
+	});
+}
+//#endregion
 //#region src/inspection/artifact-list.ts
 var { content: _content, ...metadataFields } = ArtifactSchema.fields;
 var InspectionArtifactsPageLimitSchema = NonNegativeSafeIntegerSchema$2.pipe(Schema.check(Schema.makeFilter((value) => value > 0 && value <= 128)));
@@ -3936,7 +4023,7 @@ function validateObservabilityCollection(collection) {
 }
 //#endregion
 //#region src/inspection/protocol-values.ts
-var QUERY_PROTOCOL = "niceeval.query/v1";
+var QUERY_PROTOCOL = "niceeval.query/v2";
 /** Selector semantics revision; independent from the wire protocol major. */
 var INSPECTION_BEHAVIOR_VERSION = "2.0.0";
 //#endregion
@@ -4505,6 +4592,40 @@ var AssertionDetailResultSchema = Schema.toType(Schema.Union([Schema.Struct({
 	matcher: MatcherProjectionSchema
 })]));
 //#endregion
+//#region src/inspection/lifecycle.ts
+function projectLifecyclePhase(phase) {
+	return phase.replace(/\.setup$/, ".before").replace(/\.teardown$/, ".after");
+}
+//#endregion
+//#region src/record/family/attempt-note/schema.ts
+var AttemptNoteLimits = Object.freeze({
+	maximumEntries: 64,
+	maximumJsonBytes: 65536
+});
+var NoteJsonSchema = Schema.suspend(() => Schema.Union([
+	Schema.Null,
+	Schema.Boolean,
+	Schema.Finite,
+	Schema.String,
+	Schema.Array(NoteJsonSchema),
+	Schema.Record(Schema.String, NoteJsonSchema)
+]));
+var AttemptNoteSchema = Schema.Struct({
+	label: Schema.String,
+	sequence: NonNegativeSafeIntegerSchema$2,
+	value: NoteJsonSchema,
+	unit: Schema.optional(Schema.Literals([
+		"ms",
+		"seconds",
+		"tokens",
+		"usd",
+		"ratio",
+		"count",
+		"bytes"
+	]))
+});
+var AttemptNotesSchema = Schema.Array(AttemptNoteSchema).check(Schema.makeFilter((notes) => notes.length <= AttemptNoteLimits.maximumEntries && new Set(notes.map((note) => note.label)).size === notes.length && notes.every((note, index) => note.sequence === index && (note.unit === void 0 || typeof note.value === "number") && new TextEncoder().encode(JSON.stringify(note)).byteLength <= AttemptNoteLimits.maximumJsonBytes)));
+//#endregion
 //#region src/o11y/cache-read.ts
 var Reason = Schema.Literals([
 	"usage-not-recorded",
@@ -4541,17 +4662,17 @@ var consistent = (value) => {
 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),
+	roles: Schema.Array(Schema.Struct({
+		modelRole: Schema.NullOr(Schema.String),
 		...fields
 	}).check(Schema.makeFilter(consistent))),
 	models: Schema.Array(Schema.Struct({
-		modelSlot: Schema.NullOr(Schema.String),
+		modelRole: 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));
+}).check(Schema.makeFilter((value) => value.roles.length <= 65 && value.models.length <= 4e3));
 function summary(calls, collectionComplete, absent) {
 	let numerator = 0;
 	let denominator = 0;
@@ -4599,19 +4720,19 @@ function summary(calls, collectionComplete, absent) {
 }
 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") {
+function projectCacheRead(usage, roles, producerCompletenessKnown, absent = "usage-not-recorded") {
 	if (usage === null) return Object.freeze({
 		total: summary([], false, absent),
-		modelSlots: Object.freeze([]),
+		roles: Object.freeze([]),
 		models: Object.freeze([])
 	});
 	const complete = producerCompletenessKnown && usage.collection.state === "complete";
-	const bySlot = new Map(Object.keys(slots ?? {}).map((slot) => [slot, []]));
+	const byRole = new Map(Object.keys(roles ?? {}).map((role) => [role, []]));
 	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 role = byRole.get(call.modelSlot);
+		if (role === void 0) byRole.set(call.modelSlot, [call]);
+		else role.push(call);
 		const key = JSON.stringify([
 			call.modelSlot,
 			call.provider,
@@ -4622,18 +4743,18 @@ function projectCacheRead(usage, slots, producerCompletenessKnown, absent = "usa
 		else model.push(call);
 	}
 	const models = [...byModel.values()].map((calls) => {
-		const { modelSlot, provider, model } = calls[0];
+		const { modelSlot: modelRole, provider, model } = calls[0];
 		return Object.freeze({
-			modelSlot,
+			modelRole,
 			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));
+	}).sort((a, b) => compare$1(a.modelRole, b.modelRole) || 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,
+		roles: Object.freeze([...byRole].sort(([a], [b]) => compare$1(a, b)).map(([modelRole, calls]) => Object.freeze({
+			modelRole,
 			...summary(calls, complete)
 		}))),
 		models: Object.freeze(models)
@@ -5473,8 +5594,10 @@ function effectiveUsageCalls(usage) {
 	const receipts = new Map((usage.priceReceipts ?? []).map((receipt) => [receipt.callId, receipt]));
 	return Object.freeze(usage.calls.map((call) => {
 		const receipt = receipts.get(call.callId);
+		const { modelSlot, ...fields } = call;
 		return Object.freeze({
-			...call,
+			...fields,
+			modelRole: modelSlot,
 			effectiveCost: call.cost !== null ? Object.freeze({
 				...call.cost,
 				state: "complete"
@@ -5577,7 +5700,7 @@ function adapterInspectionTokenTotal(usage, metric) {
 /** Tuple order is stable across hosts, with missing identities before strings. */
 function compareAdapterModelGroups(left, right) {
 	for (const key of [
-		"modelSlot",
+		"modelRole",
 		"provider",
 		"model"
 	]) {
@@ -5600,10 +5723,10 @@ function projectAdapterModelUsage(usage, models, unavailable = {
 	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({
 		state: "available",
-		bindings: Object.freeze(Object.keys(models).sort().map((modelSlot) => Object.freeze({
-			modelSlot,
-			...models[modelSlot],
-			recordedCalls: usage === null ? null : counts.get(modelSlot) ?? 0
+		bindings: Object.freeze(Object.keys(models).sort().map((modelRole) => Object.freeze({
+			modelRole,
+			...models[modelRole],
+			recordedCalls: usage === null ? null : counts.get(modelRole) ?? 0
 		})))
 	});
 	if (usage === null) return Object.freeze({
@@ -5621,7 +5744,7 @@ function projectAdapterModelUsage(usage, models, unavailable = {
 	const grouped = /* @__PURE__ */ new Map();
 	for (const call of effectiveUsageCalls(usage)) {
 		const identity = JSON.stringify([
-			call.modelSlot,
+			call.modelRole,
 			call.provider,
 			call.model
 		]);
@@ -5631,13 +5754,13 @@ function projectAdapterModelUsage(usage, models, unavailable = {
 	}
 	const allGroups = [...grouped.values()].sort((left, right) => compareAdapterModelGroups(left[0], right[0]));
 	const groups = allGroups.slice(0, 64).map((calls) => {
-		const { modelSlot, provider, model } = calls[0];
+		const { modelRole, provider, model } = calls[0];
 		const groupUsage = {
 			...usage,
 			calls
 		};
 		return Object.freeze({
-			modelSlot,
+			modelRole,
 			provider,
 			model,
 			recordedCalls: calls.length,
@@ -6980,7 +7103,7 @@ var OverviewIssueSchema = Schema.Union([
 	Schema.Struct({
 		code: Schema.Literals(["attempt-origin-missing", "attempt-not-observed"]),
 		runId: Schema.String,
-		slotId: Schema.String,
+		plannedAttemptId: Schema.String,
 		evalId: Schema.String,
 		attemptOrdinal: Schema.Number
 	}),
@@ -7008,7 +7131,7 @@ var MetricSchema = Schema.Struct({
 	value: Schema.NullOr(Schema.Number),
 	samples: Schema.Number,
 	total: Schema.Number,
-	basis: Schema.Literals(["slot", "eval"]),
+	basis: Schema.Literals(["planned-attempt", "eval"]),
 	issues: Schema.Array(OverviewIssueSchema),
 	refs: Schema.Array(AttemptRefSchema),
 	unit: Schema.optional(Schema.Literals([
@@ -7096,7 +7219,7 @@ var AggregateFields = {
 	issues: Schema.Array(OverviewIssueSchema)
 };
 var OverviewPublishedMemberSchema = Schema.Struct({
-	...RunPublishedPublicationSchema.fields,
+	...InspectionPublishedPublicationSchema.fields,
 	verdict: Schema.NullOr(Schema.Literals([
 		"passed",
 		"failed",
@@ -7119,7 +7242,7 @@ var InspectionExecutionValueSchema = Schema.Union([
 var InspectionLabelsSchema = Schema.Record(Schema.String, InspectionExecutionValueSchema);
 var OverviewMemberSchema = Schema.Struct({
 	runId: Schema.String,
-	slotId: Schema.String,
+	plannedAttemptId: Schema.String,
 	evalId: Schema.String,
 	attemptOrdinal: Schema.Number,
 	labels: InspectionLabelsSchema,
@@ -7134,6 +7257,7 @@ var OverviewGroupSchema = Schema.Struct({
 	...AggregateFields
 });
 var OverviewExperimentSchema = Schema.Struct({
+	plugins: Schema.suspend(() => Schema.Array(RunPluginIdentitySchema)),
 	experimentId: Schema.String,
 	adapter: Schema.Union([Schema.Struct({
 		state: Schema.Literal("available"),
@@ -7157,6 +7281,15 @@ var InspectionOverviewResultSchema = Schema.Struct({
 	cells: Schema.Array(OverviewCellSchema)
 });
 var InspectionExperimentResultSchema = Schema.Struct({
+	notes: Schema.Array(Schema.Struct({
+		label: Schema.String,
+		unit: AttemptNoteSchema.fields.unit,
+		count: NonNegativeSafeIntegerSchema$2,
+		min: Schema.Finite,
+		median: Schema.Finite,
+		p90: Schema.Finite,
+		max: Schema.Finite
+	})),
 	costSummary: Schema.suspend(() => ExperimentCostSummarySchema),
 	modelUsage: Schema.Struct({
 		attempts: Schema.Array(Schema.Struct({
@@ -7186,7 +7319,7 @@ var InspectionRunValueSchema = Schema.Struct({
 	context: Schema.optional(RunContextSchema),
 	startedAt: UtcMillisSchema,
 	completedAt: Schema.optional(UtcMillisSchema),
-	expectedSlots: Schema.Array(RecordSlotIdentitySchema)
+	plannedAttempts: Schema.Array(PlannedAttemptSchema)
 });
 var InspectionRunListResultSchema = Schema.Array(RunSummarySchema);
 var InspectionScoredValueSchema = Schema.Union([
@@ -7309,12 +7442,13 @@ var AssertionEvidenceSchema = Schema.Union([
 	})
 ]);
 var InspectionAttemptResultSchema = Schema.Struct({
-	core: AttemptDocumentSchema,
+	notes: AttemptNotesSchema,
+	core: InspectionAttemptCoreSchema,
 	locator: Schema.String,
-	originRun: RunDocumentSchema,
+	originRun: InspectionRunCoreSchema,
 	targets: Schema.Array(Schema.Struct({
 		runId: Schema.String,
-		member: MemberDocumentSchema
+		member: InspectionMemberSchema
 	})),
 	evidence: AssertionEvidenceSchema,
 	assertions: AssertionIndexSchema,
@@ -7503,7 +7637,7 @@ var TraceDiagnosticsSchema = Schema.Struct({
 		sequence: Schema.Number,
 		turnId: Schema.NullOr(Schema.String),
 		phase: Schema.Literals([
-			"attempt.setup",
+			"attempt.before",
 			"sandbox.prepare",
 			"agent.ensure",
 			"eval.run",
@@ -7511,7 +7645,7 @@ var TraceDiagnosticsSchema = Schema.Struct({
 			"sandbox.command",
 			"assertion.evaluate",
 			"verdict.fold",
-			"attempt.teardown"
+			"attempt.after"
 		]),
 		kind: Schema.Literals(["advisory", "execution-error"]),
 		code: Schema.String,
@@ -7760,7 +7894,7 @@ var InspectionTraceResultSchema = Schema.Struct({
 		omittedLimitationCount: Schema.Number,
 		items: Schema.Array(Schema.Struct({
 			commandId: CommandIdSchema$1,
-			phase: Schema.Literals(SANDBOX_COMMAND_PHASES),
+			phase: Schema.Literals(SANDBOX_COMMAND_PHASES.map(projectLifecyclePhase)),
 			outcome: CommandOutcomeSchema
 		})),
 		hasMore: Schema.Boolean,
@@ -7939,12 +8073,12 @@ var InspectionTraceDetailResultSchema = Schema.Union([
 		outcome: CommandOutcomeSchema,
 		turnId: Schema.NullOr(Schema.String),
 		phase: Schema.Literals([
-			"attempt.setup",
+			"attempt.before",
 			"sandbox.prepare",
 			"agent.ensure",
 			"eval.run",
 			"sandbox.command",
-			"attempt.teardown"
+			"attempt.after"
 		]),
 		sequence: Schema.Number,
 		stdout: CommandStreamSchema,
@@ -8005,8 +8139,10 @@ var EffectiveCostSchema = Schema.Struct({
 	}),
 	state: Schema.Literals(["complete", "partial"])
 });
+var { modelSlot: persistedModelSlot, ...publicAdapterCallFields } = AdapterUsageCallSchema.fields;
 var AdapterUsageInspectionCallSchema = Schema.Struct({
-	...AdapterUsageCallSchema.fields,
+	...publicAdapterCallFields,
+	modelRole: persistedModelSlot,
 	effectiveCost: Schema.NullOr(EffectiveCostSchema)
 });
 var EffectiveCostTotalSchema = Schema.Struct({
@@ -8047,14 +8183,14 @@ var ModelGroupTokenTotalSchema = Schema.Struct({
 var ConfiguredModelsSchema = Schema.Union([Schema.Struct({ state: Schema.Literal("not-recorded") }), Schema.Struct({
 	state: Schema.Literal("available"),
 	bindings: Schema.Array(Schema.Struct({
-		modelSlot: AdapterUsageModelSlotSchema,
+		modelRole: AdapterUsageModelSlotSchema,
 		model: Schema.NullOr(Schema.String.check(Schema.isPattern(/\S/u))),
 		reasoningEffort: Schema.NullOr(Schema.String.check(Schema.isPattern(/\S/u))),
 		recordedCalls: Schema.NullOr(RecordedCallCountSchema)
-	})).check(Schema.makeFilter((bindings) => bindings.length <= 64 && bindings.every((entry, index) => index === 0 || bindings[index - 1].modelSlot < entry.modelSlot)))
+	})).check(Schema.makeFilter((bindings) => bindings.length <= 64 && bindings.every((entry, index) => index === 0 || bindings[index - 1].modelRole < entry.modelRole)))
 })]);
 var ModelGroupSchema = Schema.Struct({
-	modelSlot: Schema.NullOr(AdapterUsageModelSlotSchema),
+	modelRole: Schema.NullOr(AdapterUsageModelSlotSchema),
 	provider: AdapterUsageCallSchema.fields.provider,
 	model: AdapterUsageCallSchema.fields.model,
 	recordedCalls: RecordedCallCountSchema.check(Schema.isGreaterThan(0)),
@@ -8107,17 +8243,17 @@ var TotalUsageCostsSchema = Schema.Struct({
 	missingSources: Schema.Array(Schema.Literals(["application", "judge"])).check(Schema.makeFilter((sources) => sources.length <= 2 && sources.every((source, index) => index === 0 || sources[index - 1] === "application" && source === "judge")))
 }).check(Schema.makeFilter((value) => value.state === (value.missingSources.length === 0 ? "complete" : value.values.length === 0 ? "unavailable" : "partial") && value.values.every((entry, index) => index === 0 || value.values[index - 1].currency < entry.currency)));
 var ExperimentCostSummarySchema = Schema.Struct({
-	scope: Schema.Literal("latest-recorded-slots"),
+	scope: Schema.Literal("latest-recorded-attempts"),
 	totalCosts: TotalUsageCostsSchema,
 	coverage: Schema.Struct({
-		selectedSlotCount: NonNegativeSafeIntegerSchema$2,
-		resolvedSlotCount: NonNegativeSafeIntegerSchema$2,
+		plannedAttemptCount: NonNegativeSafeIntegerSchema$2,
+		recordedAttemptCount: NonNegativeSafeIntegerSchema$2,
 		originAttemptCount: NonNegativeSafeIntegerSchema$2,
 		completeAttemptCount: NonNegativeSafeIntegerSchema$2,
 		partialAttemptCount: NonNegativeSafeIntegerSchema$2,
 		unavailableAttemptCount: NonNegativeSafeIntegerSchema$2,
-		unresolvedSlotCount: NonNegativeSafeIntegerSchema$2
-	}).check(Schema.makeFilter((value) => value.selectedSlotCount === value.resolvedSlotCount + value.unresolvedSlotCount && value.originAttemptCount <= value.resolvedSlotCount && value.originAttemptCount === value.completeAttemptCount + value.partialAttemptCount + value.unavailableAttemptCount))
+		missingAttemptCount: NonNegativeSafeIntegerSchema$2
+	}).check(Schema.makeFilter((value) => value.plannedAttemptCount === value.recordedAttemptCount + value.missingAttemptCount && value.originAttemptCount <= value.recordedAttemptCount && value.originAttemptCount === value.completeAttemptCount + value.partialAttemptCount + value.unavailableAttemptCount))
 });
 var JudgeCostTotalsSchema = EffectiveCostTotalSchema.check(Schema.makeFilter((costs) => costs.totalCalls <= 4e3 && costs.source === null === (costs.values.length === 0) && costs.values.every((entry, index) => entry.coveredCalls <= entry.reportedCalls + entry.estimatedCalls && entry.reportedCalls + entry.estimatedCalls <= costs.totalCalls && entry.source === (entry.reportedCalls === 0 ? "estimated" : entry.estimatedCalls === 0 ? "reported" : "mixed") && (index === 0 || costs.values[index - 1].currency < entry.currency)) && costs.values.reduce((count, entry) => count + entry.reportedCalls + entry.estimatedCalls, 0) <= costs.totalCalls && (costs.state !== "unavailable" || costs.values.length === 0) && (costs.state !== "complete" || costs.values.reduce((count, entry) => count + entry.coveredCalls, 0) === costs.totalCalls)));
 var JudgeUsageUnavailableSchema = Schema.Union([Schema.Struct({
@@ -8261,8 +8397,8 @@ var RunOverviewMemberLimitationSchema = Schema.Union([
 	})
 ]);
 var RunOverviewMemberSchema = Schema.Struct({
-	...RecordSlotIdentitySchema.fields,
-	publication: RunSlotPublicationSchema,
+	...PlannedAttemptSchema.fields,
+	publication: PlannedAttemptPublicationSchema,
 	state: Schema.Literals([
 		"executed",
 		"carried",
@@ -8286,20 +8422,20 @@ var RunOverviewMemberSchema = Schema.Struct({
 	limitations: Schema.Array(RunOverviewMemberLimitationSchema)
 });
 var RunOverviewLocatedLimitationSchema = Schema.Struct({
-	slotId: Schema.String,
+	plannedAttemptId: Schema.String,
 	locator: Schema.NullOr(Schema.String),
 	limitation: RunOverviewMemberLimitationSchema
 });
 var InspectionRunResultSchema = Schema.Struct({
 	value: InspectionRunValueSchema,
-	members: Schema.Array(MemberDocumentSchema),
-	attempts: Schema.Array(AttemptDocumentSchema),
+	members: Schema.Array(InspectionMemberSchema),
+	attempts: Schema.Array(InspectionAttemptCoreSchema),
 	denominator: Schema.Struct({
 		expected: Schema.Number,
 		published: Schema.Number,
 		missing: Schema.Number
 	}),
-	slots: Schema.Array(RunOverviewMemberSchema),
+	plannedAttempts: Schema.Array(RunOverviewMemberSchema),
 	coverage: Schema.Struct({
 		state: RunOverviewStateSchema,
 		expectedMemberCount: Schema.Number,
@@ -8424,7 +8560,7 @@ var InspectionProjectGapReasonSchema = Schema.Literals([
 	"timeout-exceeded",
 	"adoption-unproven"
 ]);
-var InspectionProjectSlotSchema = Schema.Union([Schema.Struct({
+var InspectionProjectPlannedAttemptSchema = Schema.Union([Schema.Struct({
 	...PositionFields,
 	state: Schema.Literal("reuse"),
 	sourceRunId: RunIdSchema,
@@ -8451,14 +8587,14 @@ var InspectionProjectResultSchema = Schema.Struct({
 		covered: NonNegativeSafeIntegerSchema$2,
 		gaps: NonNegativeSafeIntegerSchema$2
 	}),
-	slots: Schema.Array(InspectionProjectSlotSchema),
+	plannedAttempts: Schema.Array(InspectionProjectPlannedAttemptSchema),
 	...InspectionOverviewResultSchema.fields,
 	history: Schema.Array(Schema.Struct({
 		...PositionFields,
 		sourceRunId: RunIdSchema,
 		locator: Schema.NullOr(LocatorSchema)
 	}))
-}).check(Schema.makeFilter((value) => value.coverage.covered + value.coverage.gaps === value.coverage.expected && value.slots.length === value.coverage.expected && value.slots.filter((slot) => slot.state === "reuse").length === value.coverage.covered));
+}).check(Schema.makeFilter((value) => value.coverage.covered + value.coverage.gaps === value.coverage.expected && value.plannedAttempts.length === value.coverage.expected && value.plannedAttempts.filter((slot) => slot.state === "reuse").length === value.coverage.covered));
 //#endregion
 //#region src/inspection/protocol.ts
 var AttemptLocatorSchema = Schema.String.pipe(Schema.refine((value) => ATTEMPT_LOCATOR_PATTERN.test(value), {
@@ -8539,7 +8675,7 @@ var ArtifactsResultSchema = Schema.Union([Schema.Struct({ state: Schema.Literal(
 var ComparisonMemberSchema = Schema.Struct({
 	key: Schema.String,
 	runId: Schema.String,
-	slotId: Schema.String,
+	plannedAttemptId: Schema.String,
 	evalId: Schema.String,
 	attemptOrdinal: Schema.Number,
 	locator: Schema.String
@@ -8551,11 +8687,11 @@ var RunsCompareResultSchema = Schema.Struct({
 		"paired"
 	]),
 	left: Schema.Struct({
-		runs: Schema.Array(RunDocumentSchema),
+		runs: Schema.Array(InspectionRunCoreSchema),
 		members: Schema.Array(ComparisonMemberSchema)
 	}),
 	right: Schema.Struct({
-		runs: Schema.Array(RunDocumentSchema),
+		runs: Schema.Array(InspectionRunCoreSchema),
 		members: Schema.Array(ComparisonMemberSchema)
 	}),
 	exactMemberSet: Schema.Boolean,
@@ -8592,6 +8728,7 @@ var inspectionProtocolRegistry = Object.freeze({
 		result: { experiment: InspectionExperimentResultSchema },
 		factKinds: [
 			"core",
+			"attempt-note",
 			"assertions",
 			"attempt-cost",
 			"agent-turns",
@@ -8621,7 +8758,11 @@ var inspectionProtocolRegistry = Object.freeze({
 	"attempt.get": spec({
 		request: operation("attempt.get", { locator: AttemptLocatorSchema }),
 		result: { attempt: InspectionAttemptResultSchema },
-		factKinds: ["core", "assertions"]
+		factKinds: [
+			"core",
+			"assertions",
+			"attempt-note"
+		]
 	}),
 	"attempt.assertion.detail": spec({
 		request: operation("attempt.assertion.detail", {
@@ -13110,14 +13251,13 @@ function sourceError(cause) {
 	});
 }
 //#endregion
-//#region src/inspection/project-input.ts
-var preparedInputs = /* @__PURE__ */ new WeakMap();
-function bindProjectInput(source, input) {
-	preparedInputs.set(source, Object.freeze(input));
-}
-function projectInput(source) {
-	return preparedInputs.get(source);
-}
+//#region src/record/family/attempt-note/definition.ts
+var attemptNotesRecordAttachment = defineRecordAttachment({
+	owner: RecordOwner.attempt,
+	family: "niceeval.attempt-note",
+	schema: AttemptNotesSchema,
+	validate: () => []
+});
 //#endregion
 //#region src/record/family/judge-usage/definition.ts
 var judgeUsageRecordAttachment = defineRecordAttachment({
@@ -13958,6 +14098,7 @@ var turnContextsRecordAttachment = defineRecordAttachment({
 //#region src/record/family/current.ts
 /** Browser-neutral logical definitions, grouped only for direct current-reader use. */
 var NiceEvalRecordAttachments = Object.freeze({
+	attemptNotes: attemptNotesRecordAttachment,
 	adapterUsage: adapterUsageRecordAttachment,
 	judgeUsage: judgeUsageRecordAttachment,
 	assertions: assertionsRecordAttachment,
@@ -13987,6 +14128,7 @@ var current = (attachment, revision) => Object.freeze({
 });
 /** Current revisions without importing historical Node-only migration code. */
 var NiceEvalCurrentRecordAttachments = Object.freeze({
+	attemptNotes: current(attemptNotesRecordAttachment, 1),
 	adapterUsage: current(adapterUsageRecordAttachment, 4),
 	judgeUsage: current(judgeUsageRecordAttachment, 1),
 	assertions: current(assertionsRecordAttachment, 4),
@@ -14418,6 +14560,57 @@ function parseVerifiedJson(bytes, digest, label) {
 	return parseJson$1(bytes, label);
 }
 //#endregion
+//#region src/inspection/notes.ts
+function readAttemptNotes(resolved) {
+	const attachment = attemptAttachment(resolved, NiceEvalRecordAttachments.attemptNotes.family);
+	return attachment === void 0 ? [] : Schema.decodeUnknownSync(AttemptNotesSchema)(attachment.value);
+}
+function aggregateAttemptNotes(attempts) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const attempt of attempts) for (const note of readAttemptNotes(attempt)) {
+		if (typeof note.value !== "number") continue;
+		const key = JSON.stringify([note.label, note.unit ?? null]);
+		let group = groups.get(key);
+		if (group === void 0) {
+			group = {
+				label: note.label,
+				...note.unit === void 0 ? {} : { unit: note.unit },
+				values: []
+			};
+			groups.set(key, group);
+		}
+		group.values.push(note.value);
+	}
+	return [...groups.values()].map(({ label, unit, values }) => {
+		values.sort((a, b) => a - b);
+		const quantile = (p) => {
+			const position = (values.length - 1) * p;
+			const lower = values[Math.floor(position)];
+			const upper = values[Math.ceil(position)];
+			const fraction = position - Math.floor(position);
+			return lower * (1 - fraction) + upper * fraction;
+		};
+		return Object.freeze({
+			label,
+			...unit === void 0 ? {} : { unit },
+			count: values.length,
+			min: values[0],
+			median: quantile(.5),
+			p90: quantile(.9),
+			max: values[values.length - 1]
+		});
+	});
+}
+//#endregion
+//#region src/inspection/project-input.ts
+var preparedInputs = /* @__PURE__ */ new WeakMap();
+function bindProjectInput(source, input) {
+	preparedInputs.set(source, Object.freeze(input));
+}
+function projectInput(source) {
+	return preparedInputs.get(source);
+}
+//#endregion
 //#region src/shared/types.ts
 /** 一次 Attempt 的互斥终态；跳过是已结束但不构成可执行结论的结果。 */
 var VERDICTS = [
@@ -15204,7 +15397,7 @@ function projectAttemptTrace(source, attachments, execution, executionFilters =
 	const items = retainedTurns.length > 0 ? retainedTurns.flatMap((turn) => turn.items.map((item) => projectTypedConversationItem(item, turn.turnId))).slice(0, MAX_CONVERSATION_ITEMS) : [];
 	const commandItems = sandboxCommands.state === "available" ? sandboxCommands.value.segments.slice(0, MAX_COMMANDS).map((command) => Object.freeze({
 		commandId: command.commandId,
-		phase: command.phase,
+		phase: projectLifecyclePhase(command.phase),
 		outcome: command.outcome
 	})) : [];
 	const identityIndex = projectTypedTraceIdentityIndex(agentTurns, sandboxCommands);
@@ -15697,7 +15890,7 @@ function projectTraceCommandDetail(source, commands, commandId) {
 		workingDirectory: command.workingDirectory,
 		outcome: command.outcome,
 		turnId: command.turnId,
-		phase: command.phase,
+		phase: projectLifecyclePhase(command.phase),
 		sequence: command.sequence,
 		stdout: stream(command.stdout),
 		stderr: stream(command.stderr)
@@ -16330,8 +16523,8 @@ function projectTiming(activities) {
 		sequence: activity.sequence,
 		parentActivityId: activity.parentActivityId,
 		turnId: activity.turnId,
-		phase: activity.phase,
-		label: activity.label,
+		phase: projectLifecyclePhase(activity.phase),
+		label: projectLifecyclePhase(activity.label),
 		startOffsetMs: activity.startOffsetMs,
 		durationMs: activity.durationMs,
 		outcome: activity.outcome
@@ -16376,7 +16569,7 @@ function projectDiagnostics(diagnostics) {
 			diagnosticId: diagnostic.diagnosticId,
 			sequence: diagnostic.sequence,
 			turnId: diagnostic.turnId,
-			phase: diagnostic.phase,
+			phase: projectLifecyclePhase(diagnostic.phase),
 			kind: diagnostic.kind,
 			code: diagnostic.code,
 			summary: summary.value,
@@ -16636,7 +16829,7 @@ function makeCell(slots, labelKeys) {
 			selected.resolved;
 			return [Object.freeze({
 				runId: selected.target.run.runId,
-				slotId: selected.slot.slotId,
+				plannedAttemptId: selected.slot.slotId,
 				evalId: selected.slot.evalId,
 				attemptOrdinal: selected.slot.attemptOrdinal,
 				labels: inspectionLabels([selected], labelKeys),
@@ -16664,6 +16857,7 @@ function makeExperiment(slots, cells, labelKeys) {
 	}));
 	return Object.freeze({
 		experimentId: first.experimentId,
+		plugins: Object.freeze([...new Map(slots.flatMap(({ target }) => target?.run.context.execution.plugins ?? []).map((plugin) => [JSON.stringify(plugin), plugin])).values()]),
 		adapter: adapterValue(slots.map(({ adapter }) => adapter)),
 		model: executionValue(slots.map(({ model }) => model)),
 		labels: inspectionLabels(slots, labelKeys),
@@ -16740,7 +16934,7 @@ function metricForSlots(slots, key, unit, fold) {
 		state: failed ? "failed" : valued.length === 0 ? "unavailable" : partial ? "partial" : "available",
 		samples: valued.length,
 		total: slots.length,
-		basis: "slot",
+		basis: "planned-attempt",
 		issues: Object.freeze([]),
 		refs: refsOf(valued),
 		unit,
@@ -16764,7 +16958,7 @@ function overviewPublication(selected) {
 		attemptId: member.attempt.attemptId,
 		attemptLocator: resolved.locator,
 		originRunId: member.attempt.originRunId,
-		originSlotId: resolved.attempt.slotId,
+		originPlannedAttemptId: resolved.attempt.slotId,
 		verdict: selected.analysis.verdict,
 		score: scoreForMember(selected),
 		costUSD: costForSlots([selected]),
@@ -16855,7 +17049,7 @@ function costForSlots(slots) {
 		state: source === null ? "unavailable" : valued.length < subjects.length || valued.some(({ analysis }) => analysis.costUSD.state !== "available") ? "partial" : "available",
 		samples: valued.length,
 		total: subjects.length,
-		basis: "slot",
+		basis: "planned-attempt",
 		issues: Object.freeze([]),
 		refs: refsOf(valued),
 		unit: "USD",
@@ -16912,7 +17106,7 @@ function passRateOf(slots, denominator, tally) {
 		}),
 		samples: denominator.classified,
 		total: denominator.expected,
-		basis: "slot",
+		basis: "planned-attempt",
 		issues,
 		refs: refsOf(classified)
 	});
@@ -16924,7 +17118,7 @@ function scoreForMember(selected) {
 		state: "unsupported",
 		samples: 0,
 		total: 0,
-		basis: "slot",
+		basis: "planned-attempt",
 		issues: Object.freeze([]),
 		refs: analysis.ref === null ? Object.freeze([]) : Object.freeze([analysis.ref]),
 		unit: "points",
@@ -16945,7 +17139,7 @@ function scoreForMember(selected) {
 		}),
 		samples: complete ? 1 : 0,
 		total: 1,
-		basis: "slot",
+		basis: "planned-attempt",
 		issues: uniqueJson([...analysis.issues, ...analysis.score.hasPoints && !analysis.score.complete ? [scorePartialIssue(analysis)] : []]),
 		refs: analysis.ref === null ? Object.freeze([]) : Object.freeze([analysis.ref]),
 		unit: "points",
@@ -16965,7 +17159,7 @@ function scoreForCell(slots) {
 		state: slots.length === 0 ? "empty" : "unsupported",
 		samples: 0,
 		total: 0,
-		basis: "slot",
+		basis: "planned-attempt",
 		issues: Object.freeze([]),
 		refs: Object.freeze([]),
 		unit: "points",
@@ -16989,7 +17183,7 @@ function scoreForCell(slots) {
 		}),
 		samples: complete.length,
 		total: eligible.length,
-		basis: "slot",
+		basis: "planned-attempt",
 		issues,
 		refs: refsOf(eligible),
 		unit: "points",
@@ -17118,7 +17312,7 @@ function overviewIssue(code, runId, slot) {
 	return Object.freeze({
 		code,
 		runId,
-		slotId: slot.slotId,
+		plannedAttemptId: slot.slotId,
 		evalId: slot.evalId,
 		attemptOrdinal: slot.attemptOrdinal
 	});
@@ -17174,7 +17368,7 @@ function selectInspectionProject(input, experimentIds) {
 		}));
 	}
 	const currentPositions = new Set(input.target.slots.map((slot) => logicalKey(slot.experimentId, slot.evalId, slot.attempt)));
-	const slots = assessments.map((slot) => {
+	const plannedAttempts = assessments.map((slot) => {
 		const position = {
 			experimentId: slot.experimentId,
 			evalId: slot.evalId,
@@ -17255,16 +17449,16 @@ function selectInspectionProject(input, experimentIds) {
 		labels: {},
 		groups: []
 	});
-	const covered = slots.filter((slot) => slot.state === "reuse").length;
+	const covered = plannedAttempts.filter((slot) => slot.state === "reuse").length;
 	const history = [...previous.values()].filter((slot) => !currentPositions.has(logicalKey(slot.experimentId, slot.evalId, slot.attemptOrdinal)) && (experimentIds === void 0 || selectedIds.has(slot.experimentId))).sort((left, right) => compare(left.experimentId, right.experimentId) || compare(left.evalId, right.evalId) || left.attemptOrdinal - right.attemptOrdinal);
 	return Schema.decodeUnknownSync(InspectionProjectResultSchema)({
 		targetIdentity: input.target.identity,
 		coverage: {
-			expected: slots.length,
+			expected: plannedAttempts.length,
 			covered,
-			gaps: slots.length - covered
+			gaps: plannedAttempts.length - covered
 		},
-		slots,
+		plannedAttempts,
 		totals: overview.totals,
 		experiments,
 		cells: overview.cells,
@@ -19467,14 +19661,14 @@ function selectOperation(source, operation) {
 			const experimentCells = Object.freeze(overview.cells.filter(({ experimentId }) => experimentId === operation.experimentId));
 			const usageAttempts = /* @__PURE__ */ new Map();
 			let unresolvedAttemptCount = 0;
-			let selectedSlotCount = 0;
-			let resolvedSlotCount = 0;
+			let plannedAttemptCount = 0;
+			let recordedAttemptCount = 0;
 			const origins = new Map(selected.map((origin) => [origin.run.runId, {
 				origin,
 				attempts: new Map(origin.attempts.map((attempt) => [attempt.attemptId, attempt]))
 			}]));
 			for (const cell of experimentCells) for (const member of cell.members) {
-				selectedSlotCount++;
+				plannedAttemptCount++;
 				if (member.publication.state !== "published") {
 					unresolvedAttemptCount++;
 					continue;
@@ -19493,7 +19687,7 @@ function selectOperation(source, operation) {
 					locator: encodeAttemptLocator(attempt.attemptId),
 					targets: Object.freeze([])
 				});
-				resolvedSlotCount++;
+				recordedAttemptCount++;
 				usageAttempts.set(`${resolved.attempt.originRunId}\u0000${resolved.attempt.attemptId}`, resolved);
 			}
 			const orderedUsageAttempts = [...usageAttempts.values()].sort((left, right) => left.attempt.originRunId.localeCompare(right.attempt.originRunId) || left.locator.localeCompare(right.locator));
@@ -19514,23 +19708,25 @@ function selectOperation(source, operation) {
 				});
 			}));
 			const costSummary = Object.freeze({
-				scope: "latest-recorded-slots",
+				scope: "latest-recorded-attempts",
 				totalCosts: combineTotalUsageCosts(allAttempts.map(({ usage }) => usage.totalCosts), unresolvedAttemptCount > 0),
 				coverage: Object.freeze({
-					selectedSlotCount,
-					resolvedSlotCount,
+					plannedAttemptCount,
+					recordedAttemptCount,
 					originAttemptCount: allAttempts.length,
 					completeAttemptCount: allAttempts.filter(({ usage }) => usage.totalCosts.state === "complete").length,
 					partialAttemptCount: allAttempts.filter(({ usage }) => usage.totalCosts.state === "partial").length,
 					unavailableAttemptCount: allAttempts.filter(({ usage }) => usage.totalCosts.state === "unavailable").length,
-					unresolvedSlotCount: unresolvedAttemptCount
+					missingAttemptCount: unresolvedAttemptCount
 				})
 			});
 			let attempts = Object.freeze(allAttempts.slice(0, 64));
+			const notes = aggregateAttemptNotes(orderedUsageAttempts);
 			const experimentResult = () => Object.freeze({
 				experiment,
 				cells: experimentCells,
 				costSummary,
+				notes,
 				modelUsage: Object.freeze({
 					attempts,
 					totalAttemptCount: orderedUsageAttempts.length,
@@ -19837,12 +20033,12 @@ function inspectionRunValue(run) {
 		...resource.published > 0 && published !== void 0 ? { context: published.run.context } : {},
 		startedAt: Date.parse(resource.startedAt),
 		...resource.completedAt === void 0 ? {} : { completedAt: Date.parse(resource.completedAt) },
-		expectedSlots: published?.run.expectedSlots ?? resource.slots.map((slot) => Object.freeze({
+		plannedAttempts: (published?.run.expectedSlots ?? resource.slots.map((slot) => Object.freeze({
 			slotId: slot.slotId,
 			evalId: slot.evalId,
 			attemptOrdinal: slot.attemptOrdinal,
 			executionIdentityDigest: slot.executionIdentityDigest
-		}))
+		}))).map(projectPlannedAttempt)
 	}));
 }
 function supportingRunFacts(_source, run) {
@@ -19897,12 +20093,12 @@ function traceAttachments(resolved) {
 function attemptDetail(resolved) {
 	const assertions = readInspectionAssertions(resolved);
 	return Object.freeze({
-		core: resolved.attempt,
+		core: projectAttemptCore(resolved.attempt),
 		locator: resolved.locator,
-		originRun: resolved.origin.run,
+		originRun: projectRunCore(resolved.origin.run),
 		targets: resolved.targets.map(({ run, member }) => Object.freeze({
 			runId: run.run.runId,
-			member
+			member: projectMember(member)
 		})),
 		evidence: assertions.state === "available" ? Object.freeze({
 			state: "available",
@@ -19912,6 +20108,7 @@ function attemptDetail(resolved) {
 			state: assertions.state,
 			entryCount: 0
 		}),
+		notes: readAttemptNotes(resolved),
 		assertions: assertionIndex(assertions),
 		sections: attemptSections(resolved),
 		verdict: attemptVerdict(resolved, assertions),
@@ -20001,23 +20198,23 @@ function runDetail(_all, selectedResource) {
 		facts: Object.freeze([]),
 		limitations: Object.freeze([])
 	});
-	const projected = value.expectedSlots.map((slot) => {
-		const binding = publications.get(slot.slotId);
-		if (binding === void 0) throw new Error(`Run ${value.runId} has no Slot ${slot.slotId}`);
+	const projected = value.plannedAttempts.map((slot) => {
+		const binding = publications.get(slot.plannedAttemptId);
+		if (binding === void 0) throw new Error(`Run ${value.runId} has no Planned attempt ${slot.plannedAttemptId}`);
 		const publication = binding.state === "published" ? Object.freeze({
 			state: "published",
 			action: binding.action,
 			attemptId: binding.attemptId,
 			attemptLocator: binding.attemptLocator,
 			originRunId: binding.originRunId,
-			originSlotId: binding.originSlotId
+			originPlannedAttemptId: binding.originSlotId
 		}) : binding.state === "absent" ? Object.freeze({
 			state: "absent",
 			reason: binding.reason
 		}) : Object.freeze({ state: "pending" });
-		const targetMember = bindings.get(slot.slotId);
+		const targetMember = bindings.get(slot.plannedAttemptId);
 		if (targetMember === void 0) {
-			if (publication.state !== "pending" && publication.state !== "absent") 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 Planned attempt ${slot.plannedAttemptId}`);
 			const limitation = Object.freeze({
 				kind: "member-not-observed",
 				state: publication.state === "absent" ? publication.reason === "interrupted-before-publication" ? "interrupted" : "not-dispatched" : "pending"
@@ -20121,7 +20318,7 @@ function runDetail(_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.slotId,
+		plannedAttemptId: member.plannedAttemptId,
 		locator: member.locator,
 		limitation
 	}))));
@@ -20132,14 +20329,14 @@ function runDetail(_all, selectedResource) {
 	const usageLimitations = Object.freeze(locatedLimitations.filter(({ limitation }) => limitation.kind !== "coverage"));
 	return Object.freeze({
 		value,
-		members: selectedResource.members,
-		attempts: selected?.attempts ?? Object.freeze([]),
+		members: selectedResource.members.map(projectMember),
+		attempts: selected?.attempts.map(projectAttemptCore) ?? Object.freeze([]),
 		denominator: Object.freeze({
 			expected: selectedResource.resource.expected,
 			published: selectedResource.resource.published,
 			missing: selectedResource.resource.missing
 		}),
-		slots: members,
+		plannedAttempts: members,
 		coverage: Object.freeze({
 			state: aggregateRunOverviewState(members.map(({ coverage }) => coverage.state)),
 			expectedMemberCount: members.length,
@@ -20332,11 +20529,11 @@ function comparisonDocument(source, all, operation) {
 		comparison: boundedJson(Object.freeze({
 			mode: operation.mode,
 			left: Object.freeze({
-				runs: left.selected.map(({ run }) => run),
+				runs: left.selected.map(({ run }) => projectRunCore(run)),
 				members: leftMembers
 			}),
 			right: Object.freeze({
-				runs: right.selected.map(({ run }) => run),
+				runs: right.selected.map(({ run }) => projectRunCore(run)),
 				members: rightMembers
 			}),
 			exactMemberSet: exact,
@@ -20353,7 +20550,7 @@ function comparisonMembers(all, runs) {
 		return [Object.freeze({
 			key: `${run.run.experimentId}\u0000${slot.evalId}\u0000${slot.attemptOrdinal}`,
 			runId: run.run.runId,
-			slotId: slot.slotId,
+			plannedAttemptId: slot.slotId,
 			evalId: slot.evalId,
 			attemptOrdinal: slot.attemptOrdinal,
 			locator: resolved.locator