niceeval 0.19.0 → 0.19.1-canary.102

package/dist/inspection/protocol.d.mts

@@ -1,6 +1,6 @@
 import { Schema } from "effect";
 declare const SuccessMetadataSchema: Schema.Struct<{
-    readonly protocol: Schema.Literal<"niceeval.query/v2">;
+    readonly protocol: Schema.Literal<"niceeval.query/v3">;
     readonly outcome: Schema.Literal<"success">;
     readonly behaviorVersion: Schema.Literal<"2.0.0">;
     readonly source: Schema.Struct<{
@@ -22,7 +22,7 @@ declare const SuccessMetadataSchema: Schema.Struct<{
     }>;
 }>;
 declare const RunsListSuccessMetadataSchema: Schema.Struct<{
-    readonly protocol: Schema.Literal<"niceeval.query/v2">;
+    readonly protocol: Schema.Literal<"niceeval.query/v3">;
     readonly outcome: Schema.Literal<"success">;
     readonly behaviorVersion: Schema.Literal<"2.0.0">;
     readonly source: Schema.Struct<{
@@ -46,7 +46,7 @@ declare const RunsListSuccessMetadataSchema: Schema.Struct<{
     }>;
 }>;
 declare const CompareSuccessMetadataSchema: Schema.Struct<{
-    readonly protocol: Schema.Literal<"niceeval.query/v2">;
+    readonly protocol: Schema.Literal<"niceeval.query/v3">;
     readonly source: Schema.Struct<{
         readonly kind: Schema.Literals<readonly ["project-record", "external-record"]>;
         readonly publicationCutoffIdentity: Schema.String;
@@ -1119,9 +1119,6 @@ export declare const inspectionProtocolRegistry: Readonly<{
                     readonly groupPath: Schema.$Array<Schema.String>;
                     readonly members: Schema.$Array<Schema.Struct<{
                         readonly runId: Schema.String;
-                        readonly plannedAttemptId: Schema.String;
-                        readonly evalId: Schema.String;
-                        readonly attemptOrdinal: Schema.Number;
                         readonly labels: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
                             readonly state: Schema.Literal<"available">;
                             readonly value: Schema.String;
@@ -1130,155 +1127,158 @@ export declare const inspectionProtocolRegistry: Readonly<{
                         }>, Schema.Struct<{
                             readonly state: Schema.Literal<"unavailable">;
                         }>]>>;
-                        readonly publication: Schema.Union<readonly [Schema.Struct<{
-                            readonly state: Schema.Literal<"pending">;
-                        }>, Schema.Struct<{
-                            readonly verdict: Schema.NullOr<Schema.Literals<readonly ["passed", "failed", "errored", "skipped"]>>;
-                            readonly score: Schema.Struct<{
-                                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
-                                readonly value: Schema.NullOr<Schema.Number>;
-                                readonly samples: Schema.Number;
-                                readonly total: Schema.Number;
-                                readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
-                                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
-                                    readonly locator: Schema.String;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
-                                    readonly runId: Schema.String;
-                                    readonly plannedAttemptId: Schema.String;
-                                    readonly evalId: Schema.String;
-                                    readonly attemptOrdinal: Schema.Number;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-contribution-unavailable">;
-                                    readonly locator: Schema.String;
-                                    readonly entryId: Schema.String;
-                                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-partial">;
-                                    readonly locator: Schema.NullOr<Schema.String>;
-                                }>]>>;
-                                readonly refs: Schema.$Array<Schema.Struct<{
-                                    readonly identity: Schema.Struct<{
-                                        readonly kind: Schema.Literal<"attempt">;
-                                        readonly locator: Schema.String;
-                                    }>;
-                                }>>;
-                                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
-                                readonly bounds: Schema.optional<Schema.Struct<{
-                                    readonly min: Schema.Number;
-                                    readonly max: Schema.Number;
-                                }>>;
-                            }>;
-                            readonly costUSD: Schema.Struct<{
-                                readonly source: Schema.NullOr<Schema.Literals<readonly ["reported", "estimated", "mixed"]>>;
-                                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
-                                readonly value: Schema.NullOr<Schema.Number>;
-                                readonly samples: Schema.Number;
-                                readonly total: Schema.Number;
-                                readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
-                                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
-                                    readonly locator: Schema.String;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
-                                    readonly runId: Schema.String;
-                                    readonly plannedAttemptId: Schema.String;
-                                    readonly evalId: Schema.String;
-                                    readonly attemptOrdinal: Schema.Number;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-contribution-unavailable">;
-                                    readonly locator: Schema.String;
-                                    readonly entryId: Schema.String;
-                                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-partial">;
-                                    readonly locator: Schema.NullOr<Schema.String>;
-                                }>]>>;
-                                readonly refs: Schema.$Array<Schema.Struct<{
-                                    readonly identity: Schema.Struct<{
-                                        readonly kind: Schema.Literal<"attempt">;
-                                        readonly locator: Schema.String;
-                                    }>;
-                                }>>;
-                                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
-                                readonly bounds: Schema.optional<Schema.Struct<{
-                                    readonly min: Schema.Number;
-                                    readonly max: Schema.Number;
-                                }>>;
-                            }>;
-                            readonly durationMs: Schema.Struct<{
-                                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
-                                readonly value: Schema.NullOr<Schema.Number>;
-                                readonly samples: Schema.Number;
-                                readonly total: Schema.Number;
-                                readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
-                                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                        readonly verdict: Schema.NullOr<Schema.Literals<readonly ["passed", "failed", "errored", "skipped"]>>;
+                        readonly score: Schema.Struct<{
+                            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                            readonly value: Schema.NullOr<Schema.Number>;
+                            readonly samples: Schema.Number;
+                            readonly total: Schema.Number;
+                            readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
+                            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                                readonly locator: Schema.String;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                                readonly runId: Schema.String;
+                                readonly plannedAttemptId: Schema.String;
+                                readonly evalId: Schema.String;
+                                readonly attemptOrdinal: Schema.Number;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                                readonly locator: Schema.String;
+                                readonly entryId: Schema.String;
+                                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-partial">;
+                                readonly locator: Schema.NullOr<Schema.String>;
+                            }>]>>;
+                            readonly refs: Schema.$Array<Schema.Struct<{
+                                readonly identity: Schema.Struct<{
+                                    readonly kind: Schema.Literal<"attempt">;
                                     readonly locator: Schema.String;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
-                                    readonly runId: Schema.String;
-                                    readonly plannedAttemptId: Schema.String;
-                                    readonly evalId: Schema.String;
-                                    readonly attemptOrdinal: Schema.Number;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-contribution-unavailable">;
+                                }>;
+                            }>>;
+                            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                            readonly bounds: Schema.optional<Schema.Struct<{
+                                readonly min: Schema.Number;
+                                readonly max: Schema.Number;
+                            }>>;
+                        }>;
+                        readonly costUSD: Schema.Struct<{
+                            readonly source: Schema.NullOr<Schema.Literals<readonly ["reported", "estimated", "mixed"]>>;
+                            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                            readonly value: Schema.NullOr<Schema.Number>;
+                            readonly samples: Schema.Number;
+                            readonly total: Schema.Number;
+                            readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
+                            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                                readonly locator: Schema.String;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                                readonly runId: Schema.String;
+                                readonly plannedAttemptId: Schema.String;
+                                readonly evalId: Schema.String;
+                                readonly attemptOrdinal: Schema.Number;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                                readonly locator: Schema.String;
+                                readonly entryId: Schema.String;
+                                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-partial">;
+                                readonly locator: Schema.NullOr<Schema.String>;
+                            }>]>>;
+                            readonly refs: Schema.$Array<Schema.Struct<{
+                                readonly identity: Schema.Struct<{
+                                    readonly kind: Schema.Literal<"attempt">;
                                     readonly locator: Schema.String;
-                                    readonly entryId: Schema.String;
-                                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-partial">;
-                                    readonly locator: Schema.NullOr<Schema.String>;
-                                }>]>>;
-                                readonly refs: Schema.$Array<Schema.Struct<{
-                                    readonly identity: Schema.Struct<{
-                                        readonly kind: Schema.Literal<"attempt">;
-                                        readonly locator: Schema.String;
-                                    }>;
-                                }>>;
-                                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
-                                readonly bounds: Schema.optional<Schema.Struct<{
-                                    readonly min: Schema.Number;
-                                    readonly max: Schema.Number;
-                                }>>;
-                            }>;
-                            readonly tokens: Schema.Struct<{
-                                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
-                                readonly value: Schema.NullOr<Schema.Number>;
-                                readonly samples: Schema.Number;
-                                readonly total: Schema.Number;
-                                readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
-                                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                                }>;
+                            }>>;
+                            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                            readonly bounds: Schema.optional<Schema.Struct<{
+                                readonly min: Schema.Number;
+                                readonly max: Schema.Number;
+                            }>>;
+                        }>;
+                        readonly durationMs: Schema.Struct<{
+                            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                            readonly value: Schema.NullOr<Schema.Number>;
+                            readonly samples: Schema.Number;
+                            readonly total: Schema.Number;
+                            readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
+                            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                                readonly locator: Schema.String;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                                readonly runId: Schema.String;
+                                readonly plannedAttemptId: Schema.String;
+                                readonly evalId: Schema.String;
+                                readonly attemptOrdinal: Schema.Number;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                                readonly locator: Schema.String;
+                                readonly entryId: Schema.String;
+                                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-partial">;
+                                readonly locator: Schema.NullOr<Schema.String>;
+                            }>]>>;
+                            readonly refs: Schema.$Array<Schema.Struct<{
+                                readonly identity: Schema.Struct<{
+                                    readonly kind: Schema.Literal<"attempt">;
                                     readonly locator: Schema.String;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
-                                    readonly runId: Schema.String;
-                                    readonly plannedAttemptId: Schema.String;
-                                    readonly evalId: Schema.String;
-                                    readonly attemptOrdinal: Schema.Number;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-contribution-unavailable">;
+                                }>;
+                            }>>;
+                            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                            readonly bounds: Schema.optional<Schema.Struct<{
+                                readonly min: Schema.Number;
+                                readonly max: Schema.Number;
+                            }>>;
+                        }>;
+                        readonly tokens: Schema.Struct<{
+                            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                            readonly value: Schema.NullOr<Schema.Number>;
+                            readonly samples: Schema.Number;
+                            readonly total: Schema.Number;
+                            readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
+                            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                                readonly locator: Schema.String;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                                readonly runId: Schema.String;
+                                readonly plannedAttemptId: Schema.String;
+                                readonly evalId: Schema.String;
+                                readonly attemptOrdinal: Schema.Number;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                                readonly locator: Schema.String;
+                                readonly entryId: Schema.String;
+                                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-partial">;
+                                readonly locator: Schema.NullOr<Schema.String>;
+                            }>]>>;
+                            readonly refs: Schema.$Array<Schema.Struct<{
+                                readonly identity: Schema.Struct<{
+                                    readonly kind: Schema.Literal<"attempt">;
                                     readonly locator: Schema.String;
-                                    readonly entryId: Schema.String;
-                                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-partial">;
-                                    readonly locator: Schema.NullOr<Schema.String>;
-                                }>]>>;
-                                readonly refs: Schema.$Array<Schema.Struct<{
-                                    readonly identity: Schema.Struct<{
-                                        readonly kind: Schema.Literal<"attempt">;
-                                        readonly locator: Schema.String;
-                                    }>;
-                                }>>;
-                                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
-                                readonly bounds: Schema.optional<Schema.Struct<{
-                                    readonly min: Schema.Number;
-                                    readonly max: Schema.Number;
-                                }>>;
-                            }>;
+                                }>;
+                            }>>;
+                            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                            readonly bounds: Schema.optional<Schema.Struct<{
+                                readonly min: Schema.Number;
+                                readonly max: Schema.Number;
+                            }>>;
+                        }>;
+                        readonly plannedAttemptId: Schema.Codec<import("../record/model/identifiers.mjs").SlotId, string, never, never>;
+                        readonly evalId: Schema.Codec<import("../record/model/identifiers.mjs").EvalId, string, never, never>;
+                        readonly attemptOrdinal: Schema.Number;
+                        readonly publication: Schema.Union<readonly [Schema.Struct<{
+                            readonly state: Schema.Literal<"pending">;
+                        }>, Schema.Struct<{
                             readonly originPlannedAttemptId: Schema.String;
                             readonly state: Schema.Literal<"published">;
                             readonly action: Schema.Literals<readonly ["executed", "carried", "accepted"]>;
@@ -2360,9 +2360,6 @@ export declare const inspectionProtocolRegistry: Readonly<{
                     readonly groupPath: Schema.$Array<Schema.String>;
                     readonly members: Schema.$Array<Schema.Struct<{
                         readonly runId: Schema.String;
-                        readonly plannedAttemptId: Schema.String;
-                        readonly evalId: Schema.String;
-                        readonly attemptOrdinal: Schema.Number;
                         readonly labels: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
                             readonly state: Schema.Literal<"available">;
                             readonly value: Schema.String;
@@ -2371,155 +2368,158 @@ export declare const inspectionProtocolRegistry: Readonly<{
                         }>, Schema.Struct<{
                             readonly state: Schema.Literal<"unavailable">;
                         }>]>>;
-                        readonly publication: Schema.Union<readonly [Schema.Struct<{
-                            readonly state: Schema.Literal<"pending">;
-                        }>, Schema.Struct<{
-                            readonly verdict: Schema.NullOr<Schema.Literals<readonly ["passed", "failed", "errored", "skipped"]>>;
-                            readonly score: Schema.Struct<{
-                                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
-                                readonly value: Schema.NullOr<Schema.Number>;
-                                readonly samples: Schema.Number;
-                                readonly total: Schema.Number;
-                                readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
-                                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
-                                    readonly locator: Schema.String;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
-                                    readonly runId: Schema.String;
-                                    readonly plannedAttemptId: Schema.String;
-                                    readonly evalId: Schema.String;
-                                    readonly attemptOrdinal: Schema.Number;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-contribution-unavailable">;
-                                    readonly locator: Schema.String;
-                                    readonly entryId: Schema.String;
-                                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-partial">;
-                                    readonly locator: Schema.NullOr<Schema.String>;
-                                }>]>>;
-                                readonly refs: Schema.$Array<Schema.Struct<{
-                                    readonly identity: Schema.Struct<{
-                                        readonly kind: Schema.Literal<"attempt">;
-                                        readonly locator: Schema.String;
-                                    }>;
-                                }>>;
-                                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
-                                readonly bounds: Schema.optional<Schema.Struct<{
-                                    readonly min: Schema.Number;
-                                    readonly max: Schema.Number;
-                                }>>;
-                            }>;
-                            readonly costUSD: Schema.Struct<{
-                                readonly source: Schema.NullOr<Schema.Literals<readonly ["reported", "estimated", "mixed"]>>;
-                                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
-                                readonly value: Schema.NullOr<Schema.Number>;
-                                readonly samples: Schema.Number;
-                                readonly total: Schema.Number;
-                                readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
-                                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
-                                    readonly locator: Schema.String;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
-                                    readonly runId: Schema.String;
-                                    readonly plannedAttemptId: Schema.String;
-                                    readonly evalId: Schema.String;
-                                    readonly attemptOrdinal: Schema.Number;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-contribution-unavailable">;
-                                    readonly locator: Schema.String;
-                                    readonly entryId: Schema.String;
-                                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-partial">;
-                                    readonly locator: Schema.NullOr<Schema.String>;
-                                }>]>>;
-                                readonly refs: Schema.$Array<Schema.Struct<{
-                                    readonly identity: Schema.Struct<{
-                                        readonly kind: Schema.Literal<"attempt">;
-                                        readonly locator: Schema.String;
-                                    }>;
-                                }>>;
-                                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
-                                readonly bounds: Schema.optional<Schema.Struct<{
-                                    readonly min: Schema.Number;
-                                    readonly max: Schema.Number;
-                                }>>;
-                            }>;
-                            readonly durationMs: Schema.Struct<{
-                                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
-                                readonly value: Schema.NullOr<Schema.Number>;
-                                readonly samples: Schema.Number;
-                                readonly total: Schema.Number;
-                                readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
-                                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                        readonly verdict: Schema.NullOr<Schema.Literals<readonly ["passed", "failed", "errored", "skipped"]>>;
+                        readonly score: Schema.Struct<{
+                            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                            readonly value: Schema.NullOr<Schema.Number>;
+                            readonly samples: Schema.Number;
+                            readonly total: Schema.Number;
+                            readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
+                            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                                readonly locator: Schema.String;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                                readonly runId: Schema.String;
+                                readonly plannedAttemptId: Schema.String;
+                                readonly evalId: Schema.String;
+                                readonly attemptOrdinal: Schema.Number;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                                readonly locator: Schema.String;
+                                readonly entryId: Schema.String;
+                                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-partial">;
+                                readonly locator: Schema.NullOr<Schema.String>;
+                            }>]>>;
+                            readonly refs: Schema.$Array<Schema.Struct<{
+                                readonly identity: Schema.Struct<{
+                                    readonly kind: Schema.Literal<"attempt">;
                                     readonly locator: Schema.String;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
-                                    readonly runId: Schema.String;
-                                    readonly plannedAttemptId: Schema.String;
-                                    readonly evalId: Schema.String;
-                                    readonly attemptOrdinal: Schema.Number;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-contribution-unavailable">;
+                                }>;
+                            }>>;
+                            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                            readonly bounds: Schema.optional<Schema.Struct<{
+                                readonly min: Schema.Number;
+                                readonly max: Schema.Number;
+                            }>>;
+                        }>;
+                        readonly costUSD: Schema.Struct<{
+                            readonly source: Schema.NullOr<Schema.Literals<readonly ["reported", "estimated", "mixed"]>>;
+                            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                            readonly value: Schema.NullOr<Schema.Number>;
+                            readonly samples: Schema.Number;
+                            readonly total: Schema.Number;
+                            readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
+                            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                                readonly locator: Schema.String;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                                readonly runId: Schema.String;
+                                readonly plannedAttemptId: Schema.String;
+                                readonly evalId: Schema.String;
+                                readonly attemptOrdinal: Schema.Number;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                                readonly locator: Schema.String;
+                                readonly entryId: Schema.String;
+                                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-partial">;
+                                readonly locator: Schema.NullOr<Schema.String>;
+                            }>]>>;
+                            readonly refs: Schema.$Array<Schema.Struct<{
+                                readonly identity: Schema.Struct<{
+                                    readonly kind: Schema.Literal<"attempt">;
                                     readonly locator: Schema.String;
-                                    readonly entryId: Schema.String;
-                                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-partial">;
-                                    readonly locator: Schema.NullOr<Schema.String>;
-                                }>]>>;
-                                readonly refs: Schema.$Array<Schema.Struct<{
-                                    readonly identity: Schema.Struct<{
-                                        readonly kind: Schema.Literal<"attempt">;
-                                        readonly locator: Schema.String;
-                                    }>;
-                                }>>;
-                                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
-                                readonly bounds: Schema.optional<Schema.Struct<{
-                                    readonly min: Schema.Number;
-                                    readonly max: Schema.Number;
-                                }>>;
-                            }>;
-                            readonly tokens: Schema.Struct<{
-                                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
-                                readonly value: Schema.NullOr<Schema.Number>;
-                                readonly samples: Schema.Number;
-                                readonly total: Schema.Number;
-                                readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
-                                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                                }>;
+                            }>>;
+                            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                            readonly bounds: Schema.optional<Schema.Struct<{
+                                readonly min: Schema.Number;
+                                readonly max: Schema.Number;
+                            }>>;
+                        }>;
+                        readonly durationMs: Schema.Struct<{
+                            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                            readonly value: Schema.NullOr<Schema.Number>;
+                            readonly samples: Schema.Number;
+                            readonly total: Schema.Number;
+                            readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
+                            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                                readonly locator: Schema.String;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                                readonly runId: Schema.String;
+                                readonly plannedAttemptId: Schema.String;
+                                readonly evalId: Schema.String;
+                                readonly attemptOrdinal: Schema.Number;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                                readonly locator: Schema.String;
+                                readonly entryId: Schema.String;
+                                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-partial">;
+                                readonly locator: Schema.NullOr<Schema.String>;
+                            }>]>>;
+                            readonly refs: Schema.$Array<Schema.Struct<{
+                                readonly identity: Schema.Struct<{
+                                    readonly kind: Schema.Literal<"attempt">;
                                     readonly locator: Schema.String;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
-                                    readonly runId: Schema.String;
-                                    readonly plannedAttemptId: Schema.String;
-                                    readonly evalId: Schema.String;
-                                    readonly attemptOrdinal: Schema.Number;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-contribution-unavailable">;
+                                }>;
+                            }>>;
+                            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                            readonly bounds: Schema.optional<Schema.Struct<{
+                                readonly min: Schema.Number;
+                                readonly max: Schema.Number;
+                            }>>;
+                        }>;
+                        readonly tokens: Schema.Struct<{
+                            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                            readonly value: Schema.NullOr<Schema.Number>;
+                            readonly samples: Schema.Number;
+                            readonly total: Schema.Number;
+                            readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
+                            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                                readonly locator: Schema.String;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                                readonly runId: Schema.String;
+                                readonly plannedAttemptId: Schema.String;
+                                readonly evalId: Schema.String;
+                                readonly attemptOrdinal: Schema.Number;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                                readonly locator: Schema.String;
+                                readonly entryId: Schema.String;
+                                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-partial">;
+                                readonly locator: Schema.NullOr<Schema.String>;
+                            }>]>>;
+                            readonly refs: Schema.$Array<Schema.Struct<{
+                                readonly identity: Schema.Struct<{
+                                    readonly kind: Schema.Literal<"attempt">;
                                     readonly locator: Schema.String;
-                                    readonly entryId: Schema.String;
-                                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-partial">;
-                                    readonly locator: Schema.NullOr<Schema.String>;
-                                }>]>>;
-                                readonly refs: Schema.$Array<Schema.Struct<{
-                                    readonly identity: Schema.Struct<{
-                                        readonly kind: Schema.Literal<"attempt">;
-                                        readonly locator: Schema.String;
-                                    }>;
-                                }>>;
-                                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
-                                readonly bounds: Schema.optional<Schema.Struct<{
-                                    readonly min: Schema.Number;
-                                    readonly max: Schema.Number;
-                                }>>;
-                            }>;
+                                }>;
+                            }>>;
+                            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                            readonly bounds: Schema.optional<Schema.Struct<{
+                                readonly min: Schema.Number;
+                                readonly max: Schema.Number;
+                            }>>;
+                        }>;
+                        readonly plannedAttemptId: Schema.Codec<import("../record/model/identifiers.mjs").SlotId, string, never, never>;
+                        readonly evalId: Schema.Codec<import("../record/model/identifiers.mjs").EvalId, string, never, never>;
+                        readonly attemptOrdinal: Schema.Number;
+                        readonly publication: Schema.Union<readonly [Schema.Struct<{
+                            readonly state: Schema.Literal<"pending">;
+                        }>, Schema.Struct<{
                             readonly originPlannedAttemptId: Schema.String;
                             readonly state: Schema.Literal<"published">;
                             readonly action: Schema.Literals<readonly ["executed", "carried", "accepted"]>;
@@ -3538,9 +3538,6 @@ export declare const inspectionProtocolRegistry: Readonly<{
                     readonly groupPath: Schema.$Array<Schema.String>;
                     readonly members: Schema.$Array<Schema.Struct<{
                         readonly runId: Schema.String;
-                        readonly plannedAttemptId: Schema.String;
-                        readonly evalId: Schema.String;
-                        readonly attemptOrdinal: Schema.Number;
                         readonly labels: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
                             readonly state: Schema.Literal<"available">;
                             readonly value: Schema.String;
@@ -3549,155 +3546,158 @@ export declare const inspectionProtocolRegistry: Readonly<{
                         }>, Schema.Struct<{
                             readonly state: Schema.Literal<"unavailable">;
                         }>]>>;
-                        readonly publication: Schema.Union<readonly [Schema.Struct<{
-                            readonly state: Schema.Literal<"pending">;
-                        }>, Schema.Struct<{
-                            readonly verdict: Schema.NullOr<Schema.Literals<readonly ["passed", "failed", "errored", "skipped"]>>;
-                            readonly score: Schema.Struct<{
-                                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
-                                readonly value: Schema.NullOr<Schema.Number>;
-                                readonly samples: Schema.Number;
-                                readonly total: Schema.Number;
-                                readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
-                                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
-                                    readonly locator: Schema.String;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
-                                    readonly runId: Schema.String;
-                                    readonly plannedAttemptId: Schema.String;
-                                    readonly evalId: Schema.String;
-                                    readonly attemptOrdinal: Schema.Number;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-contribution-unavailable">;
-                                    readonly locator: Schema.String;
-                                    readonly entryId: Schema.String;
-                                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-partial">;
-                                    readonly locator: Schema.NullOr<Schema.String>;
-                                }>]>>;
-                                readonly refs: Schema.$Array<Schema.Struct<{
-                                    readonly identity: Schema.Struct<{
-                                        readonly kind: Schema.Literal<"attempt">;
-                                        readonly locator: Schema.String;
-                                    }>;
-                                }>>;
-                                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
-                                readonly bounds: Schema.optional<Schema.Struct<{
-                                    readonly min: Schema.Number;
-                                    readonly max: Schema.Number;
-                                }>>;
-                            }>;
-                            readonly costUSD: Schema.Struct<{
-                                readonly source: Schema.NullOr<Schema.Literals<readonly ["reported", "estimated", "mixed"]>>;
-                                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
-                                readonly value: Schema.NullOr<Schema.Number>;
-                                readonly samples: Schema.Number;
-                                readonly total: Schema.Number;
-                                readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
-                                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
-                                    readonly locator: Schema.String;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
-                                    readonly runId: Schema.String;
-                                    readonly plannedAttemptId: Schema.String;
-                                    readonly evalId: Schema.String;
-                                    readonly attemptOrdinal: Schema.Number;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-contribution-unavailable">;
-                                    readonly locator: Schema.String;
-                                    readonly entryId: Schema.String;
-                                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-partial">;
-                                    readonly locator: Schema.NullOr<Schema.String>;
-                                }>]>>;
-                                readonly refs: Schema.$Array<Schema.Struct<{
-                                    readonly identity: Schema.Struct<{
-                                        readonly kind: Schema.Literal<"attempt">;
-                                        readonly locator: Schema.String;
-                                    }>;
-                                }>>;
-                                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
-                                readonly bounds: Schema.optional<Schema.Struct<{
-                                    readonly min: Schema.Number;
-                                    readonly max: Schema.Number;
-                                }>>;
-                            }>;
-                            readonly durationMs: Schema.Struct<{
-                                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
-                                readonly value: Schema.NullOr<Schema.Number>;
-                                readonly samples: Schema.Number;
-                                readonly total: Schema.Number;
-                                readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
-                                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                        readonly verdict: Schema.NullOr<Schema.Literals<readonly ["passed", "failed", "errored", "skipped"]>>;
+                        readonly score: Schema.Struct<{
+                            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                            readonly value: Schema.NullOr<Schema.Number>;
+                            readonly samples: Schema.Number;
+                            readonly total: Schema.Number;
+                            readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
+                            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                                readonly locator: Schema.String;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                                readonly runId: Schema.String;
+                                readonly plannedAttemptId: Schema.String;
+                                readonly evalId: Schema.String;
+                                readonly attemptOrdinal: Schema.Number;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                                readonly locator: Schema.String;
+                                readonly entryId: Schema.String;
+                                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-partial">;
+                                readonly locator: Schema.NullOr<Schema.String>;
+                            }>]>>;
+                            readonly refs: Schema.$Array<Schema.Struct<{
+                                readonly identity: Schema.Struct<{
+                                    readonly kind: Schema.Literal<"attempt">;
                                     readonly locator: Schema.String;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
-                                    readonly runId: Schema.String;
-                                    readonly plannedAttemptId: Schema.String;
-                                    readonly evalId: Schema.String;
-                                    readonly attemptOrdinal: Schema.Number;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-contribution-unavailable">;
+                                }>;
+                            }>>;
+                            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                            readonly bounds: Schema.optional<Schema.Struct<{
+                                readonly min: Schema.Number;
+                                readonly max: Schema.Number;
+                            }>>;
+                        }>;
+                        readonly costUSD: Schema.Struct<{
+                            readonly source: Schema.NullOr<Schema.Literals<readonly ["reported", "estimated", "mixed"]>>;
+                            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                            readonly value: Schema.NullOr<Schema.Number>;
+                            readonly samples: Schema.Number;
+                            readonly total: Schema.Number;
+                            readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
+                            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                                readonly locator: Schema.String;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                                readonly runId: Schema.String;
+                                readonly plannedAttemptId: Schema.String;
+                                readonly evalId: Schema.String;
+                                readonly attemptOrdinal: Schema.Number;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                                readonly locator: Schema.String;
+                                readonly entryId: Schema.String;
+                                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-partial">;
+                                readonly locator: Schema.NullOr<Schema.String>;
+                            }>]>>;
+                            readonly refs: Schema.$Array<Schema.Struct<{
+                                readonly identity: Schema.Struct<{
+                                    readonly kind: Schema.Literal<"attempt">;
                                     readonly locator: Schema.String;
-                                    readonly entryId: Schema.String;
-                                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-partial">;
-                                    readonly locator: Schema.NullOr<Schema.String>;
-                                }>]>>;
-                                readonly refs: Schema.$Array<Schema.Struct<{
-                                    readonly identity: Schema.Struct<{
-                                        readonly kind: Schema.Literal<"attempt">;
-                                        readonly locator: Schema.String;
-                                    }>;
-                                }>>;
-                                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
-                                readonly bounds: Schema.optional<Schema.Struct<{
-                                    readonly min: Schema.Number;
-                                    readonly max: Schema.Number;
-                                }>>;
-                            }>;
-                            readonly tokens: Schema.Struct<{
-                                readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
-                                readonly value: Schema.NullOr<Schema.Number>;
-                                readonly samples: Schema.Number;
-                                readonly total: Schema.Number;
-                                readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
-                                readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                                }>;
+                            }>>;
+                            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                            readonly bounds: Schema.optional<Schema.Struct<{
+                                readonly min: Schema.Number;
+                                readonly max: Schema.Number;
+                            }>>;
+                        }>;
+                        readonly durationMs: Schema.Struct<{
+                            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                            readonly value: Schema.NullOr<Schema.Number>;
+                            readonly samples: Schema.Number;
+                            readonly total: Schema.Number;
+                            readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
+                            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                                readonly locator: Schema.String;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                                readonly runId: Schema.String;
+                                readonly plannedAttemptId: Schema.String;
+                                readonly evalId: Schema.String;
+                                readonly attemptOrdinal: Schema.Number;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                                readonly locator: Schema.String;
+                                readonly entryId: Schema.String;
+                                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-partial">;
+                                readonly locator: Schema.NullOr<Schema.String>;
+                            }>]>>;
+                            readonly refs: Schema.$Array<Schema.Struct<{
+                                readonly identity: Schema.Struct<{
+                                    readonly kind: Schema.Literal<"attempt">;
                                     readonly locator: Schema.String;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
-                                    readonly runId: Schema.String;
-                                    readonly plannedAttemptId: Schema.String;
-                                    readonly evalId: Schema.String;
-                                    readonly attemptOrdinal: Schema.Number;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-contribution-unavailable">;
+                                }>;
+                            }>>;
+                            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                            readonly bounds: Schema.optional<Schema.Struct<{
+                                readonly min: Schema.Number;
+                                readonly max: Schema.Number;
+                            }>>;
+                        }>;
+                        readonly tokens: Schema.Struct<{
+                            readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                            readonly value: Schema.NullOr<Schema.Number>;
+                            readonly samples: Schema.Number;
+                            readonly total: Schema.Number;
+                            readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
+                            readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                                readonly locator: Schema.String;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                                readonly runId: Schema.String;
+                                readonly plannedAttemptId: Schema.String;
+                                readonly evalId: Schema.String;
+                                readonly attemptOrdinal: Schema.Number;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-contribution-unavailable">;
+                                readonly locator: Schema.String;
+                                readonly entryId: Schema.String;
+                                readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                            }>, Schema.Struct<{
+                                readonly code: Schema.Literal<"score-partial">;
+                                readonly locator: Schema.NullOr<Schema.String>;
+                            }>]>>;
+                            readonly refs: Schema.$Array<Schema.Struct<{
+                                readonly identity: Schema.Struct<{
+                                    readonly kind: Schema.Literal<"attempt">;
                                     readonly locator: Schema.String;
-                                    readonly entryId: Schema.String;
-                                    readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
-                                }>, Schema.Struct<{
-                                    readonly code: Schema.Literal<"score-partial">;
-                                    readonly locator: Schema.NullOr<Schema.String>;
-                                }>]>>;
-                                readonly refs: Schema.$Array<Schema.Struct<{
-                                    readonly identity: Schema.Struct<{
-                                        readonly kind: Schema.Literal<"attempt">;
-                                        readonly locator: Schema.String;
-                                    }>;
-                                }>>;
-                                readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
-                                readonly bounds: Schema.optional<Schema.Struct<{
-                                    readonly min: Schema.Number;
-                                    readonly max: Schema.Number;
-                                }>>;
-                            }>;
+                                }>;
+                            }>>;
+                            readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                            readonly bounds: Schema.optional<Schema.Struct<{
+                                readonly min: Schema.Number;
+                                readonly max: Schema.Number;
+                            }>>;
+                        }>;
+                        readonly plannedAttemptId: Schema.Codec<import("../record/model/identifiers.mjs").SlotId, string, never, never>;
+                        readonly evalId: Schema.Codec<import("../record/model/identifiers.mjs").EvalId, string, never, never>;
+                        readonly attemptOrdinal: Schema.Number;
+                        readonly publication: Schema.Union<readonly [Schema.Struct<{
+                            readonly state: Schema.Literal<"pending">;
+                        }>, Schema.Struct<{
                             readonly originPlannedAttemptId: Schema.String;
                             readonly state: Schema.Literal<"published">;
                             readonly action: Schema.Literals<readonly ["executed", "carried", "accepted"]>;
@@ -3791,36 +3791,9 @@ export declare const inspectionProtocolRegistry: Readonly<{
                     readonly missing: Schema.Number;
                 }>;
                 readonly plannedAttempts: Schema.$Array<Schema.Struct<{
-                    readonly publication: Schema.Union<readonly [Schema.Struct<{
-                        readonly state: Schema.Literal<"pending">;
-                    }>, Schema.Struct<{
-                        readonly originPlannedAttemptId: Schema.String;
-                        readonly state: Schema.Literal<"published">;
-                        readonly action: Schema.Literals<readonly ["executed", "carried", "accepted"]>;
-                        readonly attemptId: Schema.String;
-                        readonly attemptLocator: Schema.String;
-                        readonly originRunId: Schema.String;
-                    }>, Schema.Struct<{
-                        readonly state: Schema.Literal<"absent">;
-                        readonly reason: Schema.Literals<readonly ["early-exit-satisfied", "budget-exhausted", "stopped-by-failure", "interrupted-before-publication", "dispatch-failed"]>;
-                    }>]>;
                     readonly state: Schema.Literals<readonly ["executed", "carried", "accepted", "not-dispatched", "interrupted", "pending"]>;
-                    readonly locator: Schema.NullOr<Schema.String>;
                     readonly relation: Schema.NullOr<Schema.Literals<readonly ["origin", "reference"]>>;
                     readonly outcome: Schema.NullOr<Schema.Literals<readonly ["completed", "errored", "cancelled", "interrupted"]>>;
-                    readonly verdict: Schema.NullOr<Schema.Literals<readonly ["passed", "failed", "errored", "skipped"]>>;
-                    readonly score: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
-                        readonly state: Schema.Literal<"not-scored">;
-                    }>, Schema.Struct<{
-                        readonly state: Schema.Literal<"complete">;
-                        readonly earned: Schema.Number;
-                        readonly possible: Schema.Number;
-                    }>, Schema.Struct<{
-                        readonly state: Schema.Literal<"unavailable">;
-                        readonly earned: Schema.Number;
-                        readonly possible: Schema.Number;
-                        readonly unavailable: Schema.Number;
-                    }>]>>;
                     readonly coverage: Schema.Struct<{
                         readonly state: Schema.Literals<readonly ["complete", "partial", "not-recorded", "invalid", "unavailable"]>;
                         readonly facts: Schema.$Array<Schema.Struct<{
@@ -4078,10 +4051,169 @@ export declare const inspectionProtocolRegistry: Readonly<{
                             readonly reason: Schema.String;
                         }>]>;
                     }>]>>;
+                    readonly verdict: Schema.NullOr<Schema.Literals<readonly ["passed", "failed", "errored", "skipped"]>>;
+                    readonly score: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                        readonly value: Schema.NullOr<Schema.Number>;
+                        readonly samples: Schema.Number;
+                        readonly total: Schema.Number;
+                        readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
+                        readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                            readonly locator: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                            readonly runId: Schema.String;
+                            readonly plannedAttemptId: Schema.String;
+                            readonly evalId: Schema.String;
+                            readonly attemptOrdinal: Schema.Number;
+                        }>, Schema.Struct<{
+                            readonly code: Schema.Literal<"score-contribution-unavailable">;
+                            readonly locator: Schema.String;
+                            readonly entryId: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                        }>, Schema.Struct<{
+                            readonly code: Schema.Literal<"score-partial">;
+                            readonly locator: Schema.NullOr<Schema.String>;
+                        }>]>>;
+                        readonly refs: Schema.$Array<Schema.Struct<{
+                            readonly identity: Schema.Struct<{
+                                readonly kind: Schema.Literal<"attempt">;
+                                readonly locator: Schema.String;
+                            }>;
+                        }>>;
+                        readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                        readonly bounds: Schema.optional<Schema.Struct<{
+                            readonly min: Schema.Number;
+                            readonly max: Schema.Number;
+                        }>>;
+                    }>;
+                    readonly costUSD: Schema.Struct<{
+                        readonly source: Schema.NullOr<Schema.Literals<readonly ["reported", "estimated", "mixed"]>>;
+                        readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                        readonly value: Schema.NullOr<Schema.Number>;
+                        readonly samples: Schema.Number;
+                        readonly total: Schema.Number;
+                        readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
+                        readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                            readonly locator: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                            readonly runId: Schema.String;
+                            readonly plannedAttemptId: Schema.String;
+                            readonly evalId: Schema.String;
+                            readonly attemptOrdinal: Schema.Number;
+                        }>, Schema.Struct<{
+                            readonly code: Schema.Literal<"score-contribution-unavailable">;
+                            readonly locator: Schema.String;
+                            readonly entryId: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                        }>, Schema.Struct<{
+                            readonly code: Schema.Literal<"score-partial">;
+                            readonly locator: Schema.NullOr<Schema.String>;
+                        }>]>>;
+                        readonly refs: Schema.$Array<Schema.Struct<{
+                            readonly identity: Schema.Struct<{
+                                readonly kind: Schema.Literal<"attempt">;
+                                readonly locator: Schema.String;
+                            }>;
+                        }>>;
+                        readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                        readonly bounds: Schema.optional<Schema.Struct<{
+                            readonly min: Schema.Number;
+                            readonly max: Schema.Number;
+                        }>>;
+                    }>;
+                    readonly durationMs: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                        readonly value: Schema.NullOr<Schema.Number>;
+                        readonly samples: Schema.Number;
+                        readonly total: Schema.Number;
+                        readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
+                        readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                            readonly locator: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                            readonly runId: Schema.String;
+                            readonly plannedAttemptId: Schema.String;
+                            readonly evalId: Schema.String;
+                            readonly attemptOrdinal: Schema.Number;
+                        }>, Schema.Struct<{
+                            readonly code: Schema.Literal<"score-contribution-unavailable">;
+                            readonly locator: Schema.String;
+                            readonly entryId: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                        }>, Schema.Struct<{
+                            readonly code: Schema.Literal<"score-partial">;
+                            readonly locator: Schema.NullOr<Schema.String>;
+                        }>]>>;
+                        readonly refs: Schema.$Array<Schema.Struct<{
+                            readonly identity: Schema.Struct<{
+                                readonly kind: Schema.Literal<"attempt">;
+                                readonly locator: Schema.String;
+                            }>;
+                        }>>;
+                        readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                        readonly bounds: Schema.optional<Schema.Struct<{
+                            readonly min: Schema.Number;
+                            readonly max: Schema.Number;
+                        }>>;
+                    }>;
+                    readonly tokens: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["available", "partial", "unavailable", "empty", "unsupported", "failed"]>;
+                        readonly value: Schema.NullOr<Schema.Number>;
+                        readonly samples: Schema.Number;
+                        readonly total: Schema.Number;
+                        readonly basis: Schema.Literals<readonly ["planned-attempt", "eval"]>;
+                        readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly code: Schema.Literals<readonly ["assertions-not-recorded", "assertions-revision-unsupported", "assertions-current-invalid"]>;
+                            readonly locator: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly code: Schema.Literals<readonly ["attempt-origin-missing", "attempt-not-observed"]>;
+                            readonly runId: Schema.String;
+                            readonly plannedAttemptId: Schema.String;
+                            readonly evalId: Schema.String;
+                            readonly attemptOrdinal: Schema.Number;
+                        }>, Schema.Struct<{
+                            readonly code: Schema.Literal<"score-contribution-unavailable">;
+                            readonly locator: Schema.String;
+                            readonly entryId: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["source-unavailable", "evaluation-errored", "not-applicable"]>;
+                        }>, Schema.Struct<{
+                            readonly code: Schema.Literal<"score-partial">;
+                            readonly locator: Schema.NullOr<Schema.String>;
+                        }>]>>;
+                        readonly refs: Schema.$Array<Schema.Struct<{
+                            readonly identity: Schema.Struct<{
+                                readonly kind: Schema.Literal<"attempt">;
+                                readonly locator: Schema.String;
+                            }>;
+                        }>>;
+                        readonly unit: Schema.optional<Schema.Literals<readonly ["points", "USD", "ms", "tokens"]>>;
+                        readonly bounds: Schema.optional<Schema.Struct<{
+                            readonly min: Schema.Number;
+                            readonly max: Schema.Number;
+                        }>>;
+                    }>;
+                    readonly plannedAttemptId: Schema.Codec<import("../record/model/identifiers.mjs").SlotId, string, never, never>;
                     readonly evalId: Schema.Codec<import("../record/model/identifiers.mjs").EvalId, string, never, never>;
                     readonly attemptOrdinal: Schema.Number;
+                    readonly publication: Schema.Union<readonly [Schema.Struct<{
+                        readonly state: Schema.Literal<"pending">;
+                    }>, Schema.Struct<{
+                        readonly originPlannedAttemptId: Schema.String;
+                        readonly state: Schema.Literal<"published">;
+                        readonly action: Schema.Literals<readonly ["executed", "carried", "accepted"]>;
+                        readonly attemptId: Schema.String;
+                        readonly attemptLocator: Schema.String;
+                        readonly originRunId: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly state: Schema.Literal<"absent">;
+                        readonly reason: Schema.Literals<readonly ["early-exit-satisfied", "budget-exhausted", "stopped-by-failure", "interrupted-before-publication", "dispatch-failed"]>;
+                    }>]>;
                     readonly executionIdentityDigest: Schema.Codec<import("../record/model/identifiers.mjs").ExecutionIdentityDigest, string, never, never>;
-                    readonly plannedAttemptId: Schema.Codec<import("../record/model/identifiers.mjs").SlotId, string, never, never>;
                 }>>;
                 readonly coverage: Schema.Struct<{
                     readonly state: Schema.Literals<readonly ["complete", "partial", "not-recorded", "invalid", "unavailable"]>;
@@ -7394,7 +7526,7 @@ export type InspectionOperationId = keyof typeof inspectionProtocolRegistry;
 export declare const INSPECTION_OPERATION_IDS: readonly ("run.list" | "run.get" | "project.get" | "overview.get" | "experiment.get" | "attempt.get" | "attempt.assertion.detail" | "attempt.assertion.image" | "attempt.trace" | "attempt.trace.detail" | "attempt.timing" | "attempt.usage" | "attempt.diff" | "attempt.sources" | "attempt.artifacts" | "attempt.artifact" | "runs.compare")[];
 export declare const InspectionOperationIdSchema: Schema.Literals<readonly ("run.list" | "run.get" | "project.get" | "overview.get" | "experiment.get" | "attempt.get" | "attempt.assertion.detail" | "attempt.assertion.image" | "attempt.trace" | "attempt.trace.detail" | "attempt.timing" | "attempt.usage" | "attempt.diff" | "attempt.sources" | "attempt.artifacts" | "attempt.artifact" | "runs.compare")[]>;
 export declare const InspectionRequestSchema: Schema.Struct<{
-    readonly protocol: Schema.Literal<"niceeval.query/v2">;
+    readonly protocol: Schema.Literal<"niceeval.query/v3">;
     readonly operation: Schema.Union<(Schema.Struct<{
         readonly kind: Schema.Literal<"project.get">;
     } & {
@@ -7512,7 +7644,7 @@ export type InspectionOperationFor<Kind extends InspectionOperationId> = Extract
 }>;
 export declare const InspectionSuccessDocumentSchema: Schema.Union<readonly Schema.Codec<InspectionSuccessDocument, InspectionSuccessEncoded>[]>;
 export declare const InspectionExplanationDocumentSchema: Schema.Union<Schema.Struct<{
-    readonly protocol: Schema.Literal<"niceeval.query/v2">;
+    readonly protocol: Schema.Literal<"niceeval.query/v3">;
     readonly source: Schema.Struct<{
         readonly kind: Schema.Literals<readonly ["project-record", "external-record"]>;
         readonly publicationCutoffIdentity: Schema.String;
@@ -7536,14 +7668,14 @@ export declare const InspectionExplanationDocumentSchema: Schema.Union<Schema.St
     readonly factKinds: Schema.Tuple<Schema.Literal<"assertions" | "core" | "sources" | "artifacts" | "runner-activities" | "adapter-usage" | "file-changes" | "agent-turns" | "sandbox-commands" | "runner-diagnostics" | "turn-contexts" | "current-project" | "attempt-cost" | "attempt-note" | "judge-usage" | "execution-traces">[]>;
 }>[]>;
 export declare const InspectionDiscoveryDocumentSchema: Schema.Struct<{
-    readonly protocol: Schema.Literal<"niceeval.query/v2">;
+    readonly protocol: Schema.Literal<"niceeval.query/v3">;
     readonly outcome: Schema.Literal<"discovery">;
     readonly operations: Schema.$Array<Schema.Union<Schema.Struct<{
         readonly id: Schema.Literal<"run.list" | "run.get" | "project.get" | "overview.get" | "experiment.get" | "attempt.get" | "attempt.assertion.detail" | "attempt.assertion.image" | "attempt.trace" | "attempt.trace.detail" | "attempt.timing" | "attempt.usage" | "attempt.diff" | "attempt.sources" | "attempt.artifacts" | "attempt.artifact" | "runs.compare">;
     }>[]>>;
 }>;
 export declare const InspectionFailureDocumentSchema: Schema.Struct<{
-    readonly protocol: Schema.Literal<"niceeval.query/v2">;
+    readonly protocol: Schema.Literal<"niceeval.query/v3">;
     readonly outcome: Schema.Literal<"failure">;
     readonly operation: Schema.NullOr<Schema.Literals<readonly ("run.list" | "run.get" | "project.get" | "overview.get" | "experiment.get" | "attempt.get" | "attempt.assertion.detail" | "attempt.assertion.image" | "attempt.trace" | "attempt.trace.detail" | "attempt.timing" | "attempt.usage" | "attempt.diff" | "attempt.sources" | "attempt.artifacts" | "attempt.artifact" | "runs.compare")[]>>;
     readonly failure: Schema.Struct<{