niceeval 0.13.2 → 0.13.3

package/dist/record/family/catalog.d.ts

@@ -8,63 +8,189 @@ export declare const NiceEvalRecordAttachments: Readonly<{
         readonly attempt: {
             readonly schema: Schema.filter<Schema.filter<Schema.filter<Schema.filter<Schema.Struct<{
                 entries: Schema.PropertySignature<":", readonly {
-                    readonly result: import("../../assertions/record/model.js").SealedAssertionResult;
-                    readonly coverage: import("../../assertions/record/model.js").AssertionCoverage;
-                    readonly limitations: readonly import("../../assertions/record/model.js").AssertionLimitation[];
-                    readonly subject: {
-                        readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
-                        readonly kind: "snapshot";
-                    } | {
-                        readonly kind: "blob";
-                        readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
-                        readonly sha256: import("../model/identifiers.js").Sha256Digest;
-                        readonly encoding: "utf-8" | "binary";
-                        readonly preview: string;
-                        readonly byteLength: number;
+                    readonly evaluation: {
+                        readonly receipt?: {
+                            readonly complete: boolean;
+                            readonly unavailable: number;
+                            readonly matched: number;
+                            readonly mismatched: number;
+                            readonly knownTotal: number | null;
+                            readonly examined: number;
+                            readonly exhaustive: boolean;
+                            readonly decisive: boolean;
+                        } | undefined;
+                        readonly observed: import("../../assertions/record/model.js").AssertionFactValue;
                     };
-                    readonly evidence: readonly ({
-                        readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
-                        readonly kind: "snapshot";
-                    } | {
-                        readonly kind: "blob";
-                        readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
-                        readonly sha256: import("../model/identifiers.js").Sha256Digest;
-                        readonly encoding: "utf-8" | "binary";
-                        readonly preview: string;
-                        readonly byteLength: number;
-                    })[];
                     readonly display: import("../../assertions/record/model.js").AssertionDisplay;
-                    readonly criterion: import("../../assertions/record/model.js").BoundedJsonObject;
-                    readonly entryId: import("../../index.js").AssertionEntryId;
-                }[], "entries-data", ":", readonly {
-                    readonly result: import("../../assertions/record/model.js").SealedAssertionResult;
-                    readonly coverage: import("../../assertions/record/model.js").AssertionCoverage;
-                    readonly limitations: readonly import("../../assertions/record/model.js").AssertionLimitation[];
-                    readonly subject: {
-                        readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
-                        readonly kind: "snapshot";
+                    readonly criterion: {
+                        readonly value: import("../../assertions/record/model.js").BoundedJsonObject;
+                        readonly state: "available";
                     } | {
-                        readonly kind: "blob";
-                        readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
-                        readonly sha256: string;
-                        readonly encoding: "utf-8" | "binary";
-                        readonly preview: string;
-                        readonly byteLength: number;
+                        readonly reason: "not-recorded";
+                        readonly state: "unavailable";
+                    };
+                    readonly policy: {
+                        readonly condition: {
+                            readonly value: {
+                                readonly expected: true;
+                                readonly kind: "boolean";
+                            } | {
+                                readonly kind: "at-least";
+                                readonly threshold: number;
+                            } | {
+                                readonly kind: "record-only";
+                            };
+                            readonly state: "available";
+                        } | {
+                            readonly reason: "not-recorded";
+                            readonly state: "unavailable";
+                        };
+                        readonly requirement: {
+                            readonly value: "optional" | "required";
+                            readonly state: "available";
+                        } | {
+                            readonly reason: "not-recorded";
+                            readonly state: "unavailable";
+                        };
+                    };
+                    readonly decision: {
+                        readonly reason: "redacted" | "evidence-unavailable" | "source-unavailable" | "condition-not-met" | "evaluator-failed" | "producer-interrupted" | "invalid-subject" | "coverage-not-applicable" | null;
+                        readonly gate: "failed" | "unavailable" | "not-applicable" | "not-gate" | "satisfied";
+                        readonly result: "errored" | "unavailable" | "matched" | "mismatched" | "not-applicable";
+                    };
+                    readonly contribution: import("../../assertions/record/model.js").NoScoreContribution | import("../../assertions/record/model.js").EarnedScoreContribution | import("../../assertions/record/model.js").UnavailableScoreContribution;
+                    readonly entryId: import("../../index.js").AssertionEntryId;
+                    readonly materials: {
+                        readonly source: {
+                            readonly reason: "not-recorded";
+                            readonly kind: "unavailable";
+                        } | {
+                            readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
+                            readonly kind: "snapshot";
+                        } | {
+                            readonly kind: "blob";
+                            readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
+                            readonly sha256: import("../model/identifiers.js").Sha256Digest;
+                            readonly encoding: "utf-8" | "binary";
+                            readonly preview: string;
+                            readonly byteLength: number;
+                        };
+                        readonly coverage: import("../../assertions/record/model.js").AssertionCoverage;
+                        readonly limitations: readonly import("../../assertions/record/model.js").AssertionLimitation[];
+                        readonly evidence: readonly ({
+                            readonly reason: "not-recorded";
+                            readonly kind: "unavailable";
+                        } | {
+                            readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
+                            readonly kind: "snapshot";
+                        } | {
+                            readonly kind: "blob";
+                            readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
+                            readonly sha256: import("../model/identifiers.js").Sha256Digest;
+                            readonly encoding: "utf-8" | "binary";
+                            readonly preview: string;
+                            readonly byteLength: number;
+                        })[];
                     };
-                    readonly evidence: readonly ({
-                        readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
-                        readonly kind: "snapshot";
+                    readonly explanationRetention: {
+                        readonly value: import("../../assertions/record/model.js").AssertionFactValue;
+                        readonly state: "retained";
                     } | {
-                        readonly kind: "blob";
-                        readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
-                        readonly sha256: string;
-                        readonly encoding: "utf-8" | "binary";
-                        readonly preview: string;
-                        readonly byteLength: number;
-                    })[];
+                        readonly reason: "not-recorded";
+                        readonly state: "unavailable";
+                    };
+                }[], "entries-data", ":", readonly {
+                    readonly evaluation: {
+                        readonly observed: import("../../assertions/record/model.js").AssertionFactValue;
+                        readonly receipt?: {
+                            readonly complete: boolean;
+                            readonly unavailable: number;
+                            readonly matched: number;
+                            readonly mismatched: number;
+                            readonly knownTotal: number | null;
+                            readonly examined: number;
+                            readonly exhaustive: boolean;
+                            readonly decisive: boolean;
+                        } | undefined;
+                    };
                     readonly display: import("../../assertions/record/model.js").AssertionDisplay;
-                    readonly criterion: import("../../assertions/record/model.js").BoundedJsonObject;
+                    readonly criterion: {
+                        readonly value: import("../../assertions/record/model.js").BoundedJsonObject;
+                        readonly state: "available";
+                    } | {
+                        readonly reason: "not-recorded";
+                        readonly state: "unavailable";
+                    };
+                    readonly policy: {
+                        readonly condition: {
+                            readonly value: {
+                                readonly expected: true;
+                                readonly kind: "boolean";
+                            } | {
+                                readonly kind: "at-least";
+                                readonly threshold: number;
+                            } | {
+                                readonly kind: "record-only";
+                            };
+                            readonly state: "available";
+                        } | {
+                            readonly reason: "not-recorded";
+                            readonly state: "unavailable";
+                        };
+                        readonly requirement: {
+                            readonly value: "optional" | "required";
+                            readonly state: "available";
+                        } | {
+                            readonly reason: "not-recorded";
+                            readonly state: "unavailable";
+                        };
+                    };
+                    readonly decision: {
+                        readonly reason: "redacted" | "evidence-unavailable" | "source-unavailable" | "condition-not-met" | "evaluator-failed" | "producer-interrupted" | "invalid-subject" | "coverage-not-applicable" | null;
+                        readonly gate: "failed" | "unavailable" | "not-applicable" | "not-gate" | "satisfied";
+                        readonly result: "errored" | "unavailable" | "matched" | "mismatched" | "not-applicable";
+                    };
+                    readonly contribution: import("../../assertions/record/model.js").NoScoreContribution | import("../../assertions/record/model.js").EarnedScoreContribution | import("../../assertions/record/model.js").UnavailableScoreContribution;
                     readonly entryId: string;
+                    readonly materials: {
+                        readonly source: {
+                            readonly reason: "not-recorded";
+                            readonly kind: "unavailable";
+                        } | {
+                            readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
+                            readonly kind: "snapshot";
+                        } | {
+                            readonly kind: "blob";
+                            readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
+                            readonly sha256: string;
+                            readonly encoding: "utf-8" | "binary";
+                            readonly preview: string;
+                            readonly byteLength: number;
+                        };
+                        readonly coverage: import("../../assertions/record/model.js").AssertionCoverage;
+                        readonly limitations: readonly import("../../assertions/record/model.js").AssertionLimitation[];
+                        readonly evidence: readonly ({
+                            readonly reason: "not-recorded";
+                            readonly kind: "unavailable";
+                        } | {
+                            readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
+                            readonly kind: "snapshot";
+                        } | {
+                            readonly kind: "blob";
+                            readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
+                            readonly sha256: string;
+                            readonly encoding: "utf-8" | "binary";
+                            readonly preview: string;
+                            readonly byteLength: number;
+                        })[];
+                    };
+                    readonly explanationRetention: {
+                        readonly value: import("../../assertions/record/model.js").AssertionFactValue;
+                        readonly state: "retained";
+                    } | {
+                        readonly reason: "not-recorded";
+                        readonly state: "unavailable";
+                    };
                 }[], false, never>;
                 sourceSites: Schema.PropertySignature<":", readonly {
                     readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
@@ -77,9 +203,9 @@ export declare const NiceEvalRecordAttachments: Readonly<{
                         readonly line: number;
                         readonly column: number;
                     };
+                    readonly entryId: import("../../index.js").AssertionEntryId;
                     readonly sourceItemId: import("../model/identifiers.js").SourceItemId;
                     readonly sourceOrder: number;
-                    readonly entryId: import("../../index.js").AssertionEntryId;
                 }[], "source-sites-data", ":", readonly {
                     readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
                     readonly sha256: string;
@@ -91,9 +217,9 @@ export declare const NiceEvalRecordAttachments: Readonly<{
                         readonly line: number;
                         readonly column: number;
                     };
+                    readonly entryId: string;
                     readonly sourceItemId: string;
                     readonly sourceOrder: number;
-                    readonly entryId: string;
                 }[], false, never>;
             }>>>>>;
             readonly limits: Readonly<{
@@ -1902,37 +2028,101 @@ export interface FixedRecordFamilyDescriptor<Family extends NiceEvalFamily, Owne
     readonly write: FixedAttachmentWriteSpec<Owner, Payload>;
     /** Declared adjacent upgrade graph; implementations remain lazy. */
     readonly adjacentMigrationLinks: readonly RecordAttachmentAdjacentMigrationLink[];
+    readonly maintenance: RecordAttachmentDefinition["maintenance"];
 }
 export declare const assertionsRecordFamily: FixedRecordFamilyDescriptor<"niceeval.assertions", "attempt", {
     readonly entries: readonly {
-        readonly result: import("../../assertions/record/model.js").SealedAssertionResult;
-        readonly coverage: import("../../assertions/record/model.js").AssertionCoverage;
-        readonly limitations: readonly import("../../assertions/record/model.js").AssertionLimitation[];
-        readonly subject: {
-            readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
-            readonly kind: "snapshot";
-        } | {
-            readonly kind: "blob";
-            readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
-            readonly sha256: import("../model/identifiers.js").Sha256Digest;
-            readonly encoding: "utf-8" | "binary";
-            readonly preview: string;
-            readonly byteLength: number;
+        readonly evaluation: {
+            readonly receipt?: {
+                readonly complete: boolean;
+                readonly unavailable: number;
+                readonly matched: number;
+                readonly mismatched: number;
+                readonly knownTotal: number | null;
+                readonly examined: number;
+                readonly exhaustive: boolean;
+                readonly decisive: boolean;
+            } | undefined;
+            readonly observed: import("../../assertions/record/model.js").AssertionFactValue;
         };
-        readonly evidence: readonly ({
-            readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
-            readonly kind: "snapshot";
-        } | {
-            readonly kind: "blob";
-            readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
-            readonly sha256: import("../model/identifiers.js").Sha256Digest;
-            readonly encoding: "utf-8" | "binary";
-            readonly preview: string;
-            readonly byteLength: number;
-        })[];
         readonly display: import("../../assertions/record/model.js").AssertionDisplay;
-        readonly criterion: import("../../assertions/record/model.js").BoundedJsonObject;
+        readonly criterion: {
+            readonly value: import("../../assertions/record/model.js").BoundedJsonObject;
+            readonly state: "available";
+        } | {
+            readonly reason: "not-recorded";
+            readonly state: "unavailable";
+        };
+        readonly policy: {
+            readonly condition: {
+                readonly value: {
+                    readonly expected: true;
+                    readonly kind: "boolean";
+                } | {
+                    readonly kind: "at-least";
+                    readonly threshold: number;
+                } | {
+                    readonly kind: "record-only";
+                };
+                readonly state: "available";
+            } | {
+                readonly reason: "not-recorded";
+                readonly state: "unavailable";
+            };
+            readonly requirement: {
+                readonly value: "optional" | "required";
+                readonly state: "available";
+            } | {
+                readonly reason: "not-recorded";
+                readonly state: "unavailable";
+            };
+        };
+        readonly decision: {
+            readonly reason: "redacted" | "evidence-unavailable" | "source-unavailable" | "condition-not-met" | "evaluator-failed" | "producer-interrupted" | "invalid-subject" | "coverage-not-applicable" | null;
+            readonly gate: "failed" | "unavailable" | "not-applicable" | "not-gate" | "satisfied";
+            readonly result: "errored" | "unavailable" | "matched" | "mismatched" | "not-applicable";
+        };
+        readonly contribution: import("../../assertions/record/model.js").NoScoreContribution | import("../../assertions/record/model.js").EarnedScoreContribution | import("../../assertions/record/model.js").UnavailableScoreContribution;
         readonly entryId: import("../../index.js").AssertionEntryId;
+        readonly materials: {
+            readonly source: {
+                readonly reason: "not-recorded";
+                readonly kind: "unavailable";
+            } | {
+                readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
+                readonly kind: "snapshot";
+            } | {
+                readonly kind: "blob";
+                readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
+                readonly sha256: import("../model/identifiers.js").Sha256Digest;
+                readonly encoding: "utf-8" | "binary";
+                readonly preview: string;
+                readonly byteLength: number;
+            };
+            readonly coverage: import("../../assertions/record/model.js").AssertionCoverage;
+            readonly limitations: readonly import("../../assertions/record/model.js").AssertionLimitation[];
+            readonly evidence: readonly ({
+                readonly reason: "not-recorded";
+                readonly kind: "unavailable";
+            } | {
+                readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
+                readonly kind: "snapshot";
+            } | {
+                readonly kind: "blob";
+                readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
+                readonly sha256: import("../model/identifiers.js").Sha256Digest;
+                readonly encoding: "utf-8" | "binary";
+                readonly preview: string;
+                readonly byteLength: number;
+            })[];
+        };
+        readonly explanationRetention: {
+            readonly value: import("../../assertions/record/model.js").AssertionFactValue;
+            readonly state: "retained";
+        } | {
+            readonly reason: "not-recorded";
+            readonly state: "unavailable";
+        };
     }[];
     readonly sourceSites: readonly {
         readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
@@ -1945,9 +2135,9 @@ export declare const assertionsRecordFamily: FixedRecordFamilyDescriptor<"niceev
             readonly line: number;
             readonly column: number;
         };
+        readonly entryId: import("../../index.js").AssertionEntryId;
         readonly sourceItemId: import("../model/identifiers.js").SourceItemId;
         readonly sourceOrder: number;
-        readonly entryId: import("../../index.js").AssertionEntryId;
     }[];
 }>;
 export declare const attemptObservabilityRecordFamily: FixedRecordFamilyDescriptor<"niceeval.observability", "attempt", {
@@ -2782,34 +2972,97 @@ export declare const runArtifactsRecordFamily: FixedRecordFamilyDescriptor<"nice
 export declare const NiceEvalRecordFamilyCatalog: Readonly<{
     assertions: FixedRecordFamilyDescriptor<"niceeval.assertions", "attempt", {
         readonly entries: readonly {
-            readonly result: import("../../assertions/record/model.js").SealedAssertionResult;
-            readonly coverage: import("../../assertions/record/model.js").AssertionCoverage;
-            readonly limitations: readonly import("../../assertions/record/model.js").AssertionLimitation[];
-            readonly subject: {
-                readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
-                readonly kind: "snapshot";
-            } | {
-                readonly kind: "blob";
-                readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
-                readonly sha256: import("../model/identifiers.js").Sha256Digest;
-                readonly encoding: "utf-8" | "binary";
-                readonly preview: string;
-                readonly byteLength: number;
+            readonly evaluation: {
+                readonly receipt?: {
+                    readonly complete: boolean;
+                    readonly unavailable: number;
+                    readonly matched: number;
+                    readonly mismatched: number;
+                    readonly knownTotal: number | null;
+                    readonly examined: number;
+                    readonly exhaustive: boolean;
+                    readonly decisive: boolean;
+                } | undefined;
+                readonly observed: import("../../assertions/record/model.js").AssertionFactValue;
             };
-            readonly evidence: readonly ({
-                readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
-                readonly kind: "snapshot";
-            } | {
-                readonly kind: "blob";
-                readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
-                readonly sha256: import("../model/identifiers.js").Sha256Digest;
-                readonly encoding: "utf-8" | "binary";
-                readonly preview: string;
-                readonly byteLength: number;
-            })[];
             readonly display: import("../../assertions/record/model.js").AssertionDisplay;
-            readonly criterion: import("../../assertions/record/model.js").BoundedJsonObject;
+            readonly criterion: {
+                readonly value: import("../../assertions/record/model.js").BoundedJsonObject;
+                readonly state: "available";
+            } | {
+                readonly reason: "not-recorded";
+                readonly state: "unavailable";
+            };
+            readonly policy: {
+                readonly condition: {
+                    readonly value: {
+                        readonly expected: true;
+                        readonly kind: "boolean";
+                    } | {
+                        readonly kind: "at-least";
+                        readonly threshold: number;
+                    } | {
+                        readonly kind: "record-only";
+                    };
+                    readonly state: "available";
+                } | {
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
+                readonly requirement: {
+                    readonly value: "optional" | "required";
+                    readonly state: "available";
+                } | {
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
+            };
+            readonly decision: {
+                readonly reason: "redacted" | "evidence-unavailable" | "source-unavailable" | "condition-not-met" | "evaluator-failed" | "producer-interrupted" | "invalid-subject" | "coverage-not-applicable" | null;
+                readonly gate: "failed" | "unavailable" | "not-applicable" | "not-gate" | "satisfied";
+                readonly result: "errored" | "unavailable" | "matched" | "mismatched" | "not-applicable";
+            };
+            readonly contribution: import("../../assertions/record/model.js").NoScoreContribution | import("../../assertions/record/model.js").EarnedScoreContribution | import("../../assertions/record/model.js").UnavailableScoreContribution;
             readonly entryId: import("../../index.js").AssertionEntryId;
+            readonly materials: {
+                readonly source: {
+                    readonly reason: "not-recorded";
+                    readonly kind: "unavailable";
+                } | {
+                    readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
+                    readonly kind: "snapshot";
+                } | {
+                    readonly kind: "blob";
+                    readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
+                    readonly sha256: import("../model/identifiers.js").Sha256Digest;
+                    readonly encoding: "utf-8" | "binary";
+                    readonly preview: string;
+                    readonly byteLength: number;
+                };
+                readonly coverage: import("../../assertions/record/model.js").AssertionCoverage;
+                readonly limitations: readonly import("../../assertions/record/model.js").AssertionLimitation[];
+                readonly evidence: readonly ({
+                    readonly reason: "not-recorded";
+                    readonly kind: "unavailable";
+                } | {
+                    readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
+                    readonly kind: "snapshot";
+                } | {
+                    readonly kind: "blob";
+                    readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
+                    readonly sha256: import("../model/identifiers.js").Sha256Digest;
+                    readonly encoding: "utf-8" | "binary";
+                    readonly preview: string;
+                    readonly byteLength: number;
+                })[];
+            };
+            readonly explanationRetention: {
+                readonly value: import("../../assertions/record/model.js").AssertionFactValue;
+                readonly state: "retained";
+            } | {
+                readonly reason: "not-recorded";
+                readonly state: "unavailable";
+            };
         }[];
         readonly sourceSites: readonly {
             readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
@@ -2822,9 +3075,9 @@ export declare const NiceEvalRecordFamilyCatalog: Readonly<{
                 readonly line: number;
                 readonly column: number;
             };
+            readonly entryId: import("../../index.js").AssertionEntryId;
             readonly sourceItemId: import("../model/identifiers.js").SourceItemId;
             readonly sourceOrder: number;
-            readonly entryId: import("../../index.js").AssertionEntryId;
         }[];
     }>;
     observability: Readonly<{
@@ -3660,6 +3913,941 @@ export declare const NiceEvalRecordFamilyCatalog: Readonly<{
         }>;
     }>;
 }>;
+/** Host discovery iterates this closed catalog; maintenance never names a family. */
+export declare const NiceEvalRecordFamilyDescriptorsByOwner: Readonly<{
+    attempt: readonly (FixedRecordFamilyDescriptor<"niceeval.observability", "attempt", {
+        readonly owner: "attempt";
+        readonly usage: {
+            readonly collection: {
+                readonly state: "complete";
+                readonly limitations: readonly [];
+            } | {
+                readonly state: "partial";
+                readonly limitations: readonly [{
+                    readonly code: "capture-failed" | "capture-interrupted";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly stage: "adapter" | "command-capture" | "usage-capture" | "timing-capture" | "diagnostic-capture" | "attempt-finalizer" | "run-teardown";
+                } | {
+                    readonly code: "collection-cap-reached" | "unsupported-input";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly omittedAtLeast: number;
+                } | {
+                    readonly code: "redacted" | "text-truncated";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly replacementOrOmittedCount: number;
+                } | {
+                    readonly code: "stream-truncated";
+                    readonly stream: "stderr" | "stdout";
+                    readonly omittedBytes: number;
+                    readonly commandId: string;
+                    readonly retainedBytes: number;
+                } | {
+                    readonly code: "invalid-utf8-replaced" | "unsafe-control-stripped";
+                    readonly stream: "stderr" | "stdout";
+                    readonly count: number;
+                    readonly commandId: string;
+                }, ...({
+                    readonly code: "capture-failed" | "capture-interrupted";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly stage: "adapter" | "command-capture" | "usage-capture" | "timing-capture" | "diagnostic-capture" | "attempt-finalizer" | "run-teardown";
+                } | {
+                    readonly code: "collection-cap-reached" | "unsupported-input";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly omittedAtLeast: number;
+                } | {
+                    readonly code: "redacted" | "text-truncated";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly replacementOrOmittedCount: number;
+                } | {
+                    readonly code: "stream-truncated";
+                    readonly stream: "stderr" | "stdout";
+                    readonly omittedBytes: number;
+                    readonly commandId: string;
+                    readonly retainedBytes: number;
+                } | {
+                    readonly code: "invalid-utf8-replaced" | "unsafe-control-stripped";
+                    readonly stream: "stderr" | "stdout";
+                    readonly count: number;
+                    readonly commandId: string;
+                })[]];
+            };
+            readonly observations: readonly ({
+                readonly kind: "token-bucket";
+                readonly provider: string;
+                readonly usageObservationId: string;
+                readonly bucket: "other" | "input" | "output" | "cache-read" | "cache-write" | "reasoning";
+                readonly tokens: number;
+            } | {
+                readonly kind: "request";
+                readonly provider: string;
+                readonly usageObservationId: string;
+                readonly requestKind: "model" | "tool";
+            } | {
+                readonly kind: "provider-cost";
+                readonly provider: string;
+                readonly usageObservationId: string;
+                readonly amount: string;
+                readonly currency: string;
+            })[];
+        };
+        readonly commands: {
+            readonly commands: readonly {
+                readonly result: {
+                    readonly outcome: {
+                        readonly kind: "exited";
+                        readonly exitCode: number;
+                    } | {
+                        readonly reason: "cancelled" | "timeout" | "transport-lost";
+                        readonly kind: "terminated";
+                    } | {
+                        readonly reason: "spawn-failed" | "cancelled-before-start";
+                        readonly kind: "not-started";
+                    };
+                    readonly stderr: {
+                        readonly sha256: import("../model/identifiers.js").Sha256Digest;
+                        readonly retainedBytes: number;
+                        readonly storage: {
+                            readonly kind: "inline";
+                            readonly text: string;
+                        } | {
+                            readonly kind: "blob";
+                            readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
+                        };
+                        readonly totalSafeUtf8Bytes: number;
+                    };
+                    readonly stdout: {
+                        readonly sha256: import("../model/identifiers.js").Sha256Digest;
+                        readonly retainedBytes: number;
+                        readonly storage: {
+                            readonly kind: "inline";
+                            readonly text: string;
+                        } | {
+                            readonly kind: "blob";
+                            readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
+                        };
+                        readonly totalSafeUtf8Bytes: number;
+                    };
+                };
+                readonly commandId: string;
+                readonly manifest: {
+                    readonly phase: "agent.ensure" | "sandbox.prepare" | "eval.run" | "sandbox.command" | "attempt.setup" | "attempt.teardown";
+                    readonly invocation: {
+                        readonly kind: "argv";
+                        readonly executable: string;
+                        readonly arguments: readonly string[];
+                    } | {
+                        readonly kind: "shell";
+                        readonly command: string;
+                    };
+                    readonly workingDirectory: {
+                        readonly kind: "sandbox-default";
+                    } | {
+                        readonly path: import("../model/identifiers.js").CanonicalProjectRelativePath;
+                        readonly kind: "project-relative";
+                    } | {
+                        readonly kind: "redacted";
+                    };
+                };
+            }[];
+            readonly collection: {
+                readonly state: "complete";
+                readonly limitations: readonly [];
+            } | {
+                readonly state: "partial";
+                readonly limitations: readonly [{
+                    readonly code: "capture-failed" | "capture-interrupted";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly stage: "adapter" | "command-capture" | "usage-capture" | "timing-capture" | "diagnostic-capture" | "attempt-finalizer" | "run-teardown";
+                } | {
+                    readonly code: "collection-cap-reached" | "unsupported-input";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly omittedAtLeast: number;
+                } | {
+                    readonly code: "redacted" | "text-truncated";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly replacementOrOmittedCount: number;
+                } | {
+                    readonly code: "stream-truncated";
+                    readonly stream: "stderr" | "stdout";
+                    readonly omittedBytes: number;
+                    readonly commandId: string;
+                    readonly retainedBytes: number;
+                } | {
+                    readonly code: "invalid-utf8-replaced" | "unsafe-control-stripped";
+                    readonly stream: "stderr" | "stdout";
+                    readonly count: number;
+                    readonly commandId: string;
+                }, ...({
+                    readonly code: "capture-failed" | "capture-interrupted";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly stage: "adapter" | "command-capture" | "usage-capture" | "timing-capture" | "diagnostic-capture" | "attempt-finalizer" | "run-teardown";
+                } | {
+                    readonly code: "collection-cap-reached" | "unsupported-input";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly omittedAtLeast: number;
+                } | {
+                    readonly code: "redacted" | "text-truncated";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly replacementOrOmittedCount: number;
+                } | {
+                    readonly code: "stream-truncated";
+                    readonly stream: "stderr" | "stdout";
+                    readonly omittedBytes: number;
+                    readonly commandId: string;
+                    readonly retainedBytes: number;
+                } | {
+                    readonly code: "invalid-utf8-replaced" | "unsafe-control-stripped";
+                    readonly stream: "stderr" | "stdout";
+                    readonly count: number;
+                    readonly commandId: string;
+                })[]];
+            };
+        };
+        readonly conversation: {
+            readonly collection: {
+                readonly state: "complete";
+                readonly limitations: readonly [];
+            } | {
+                readonly state: "partial";
+                readonly limitations: readonly [{
+                    readonly code: "capture-failed" | "capture-interrupted";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly stage: "adapter" | "command-capture" | "usage-capture" | "timing-capture" | "diagnostic-capture" | "attempt-finalizer" | "run-teardown";
+                } | {
+                    readonly code: "collection-cap-reached" | "unsupported-input";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly omittedAtLeast: number;
+                } | {
+                    readonly code: "redacted" | "text-truncated";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly replacementOrOmittedCount: number;
+                } | {
+                    readonly code: "stream-truncated";
+                    readonly stream: "stderr" | "stdout";
+                    readonly omittedBytes: number;
+                    readonly commandId: string;
+                    readonly retainedBytes: number;
+                } | {
+                    readonly code: "invalid-utf8-replaced" | "unsafe-control-stripped";
+                    readonly stream: "stderr" | "stdout";
+                    readonly count: number;
+                    readonly commandId: string;
+                }, ...({
+                    readonly code: "capture-failed" | "capture-interrupted";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly stage: "adapter" | "command-capture" | "usage-capture" | "timing-capture" | "diagnostic-capture" | "attempt-finalizer" | "run-teardown";
+                } | {
+                    readonly code: "collection-cap-reached" | "unsupported-input";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly omittedAtLeast: number;
+                } | {
+                    readonly code: "redacted" | "text-truncated";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly replacementOrOmittedCount: number;
+                } | {
+                    readonly code: "stream-truncated";
+                    readonly stream: "stderr" | "stdout";
+                    readonly omittedBytes: number;
+                    readonly commandId: string;
+                    readonly retainedBytes: number;
+                } | {
+                    readonly code: "invalid-utf8-replaced" | "unsafe-control-stripped";
+                    readonly stream: "stderr" | "stdout";
+                    readonly count: number;
+                    readonly commandId: string;
+                })[]];
+            };
+            readonly items: readonly ({
+                readonly kind: "message";
+                readonly role: "assistant" | "user";
+                readonly text: string;
+                readonly turnId: string;
+                readonly sequence: number;
+                readonly itemId: string;
+            } | {
+                readonly kind: "tool-call";
+                readonly tool: string;
+                readonly turnId: string;
+                readonly sequence: number;
+                readonly itemId: string;
+                readonly callId: string;
+                readonly inputSummary: string;
+            } | {
+                readonly kind: "tool-result";
+                readonly outcome: "rejected" | "completed" | "cancelled" | "failed";
+                readonly turnId: string;
+                readonly sequence: number;
+                readonly itemId: string;
+                readonly callId: string;
+                readonly outputSummary: string;
+            } | {
+                readonly kind: "compaction" | "thinking-summary" | "context-injection";
+                readonly summary: string;
+                readonly turnId: string;
+                readonly sequence: number;
+                readonly itemId: string;
+            } | {
+                readonly kind: "subagent";
+                readonly state: "completed" | "failed" | "started";
+                readonly label: string;
+                readonly summary: string;
+                readonly turnId: string;
+                readonly sequence: number;
+                readonly itemId: string;
+            } | {
+                readonly kind: "input-request";
+                readonly state: "requested" | "cancelled" | "answered";
+                readonly turnId: string;
+                readonly sequence: number;
+                readonly itemId: string;
+                readonly promptSummary: string;
+                readonly responseSummary: string | null;
+            } | {
+                readonly code: string;
+                readonly kind: "skill-load" | "conversation-error";
+                readonly summary: string;
+                readonly turnId: string;
+                readonly sequence: number;
+                readonly itemId: string;
+            })[];
+            readonly turns: readonly {
+                readonly outcome: "completed" | "cancelled" | "interrupted" | "failed";
+                readonly turnId: string;
+                readonly sequence: number;
+            }[];
+        };
+        readonly timing: {
+            readonly collection: {
+                readonly state: "complete";
+                readonly limitations: readonly [];
+            } | {
+                readonly state: "partial";
+                readonly limitations: readonly [{
+                    readonly code: "capture-failed" | "capture-interrupted";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly stage: "adapter" | "command-capture" | "usage-capture" | "timing-capture" | "diagnostic-capture" | "attempt-finalizer" | "run-teardown";
+                } | {
+                    readonly code: "collection-cap-reached" | "unsupported-input";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly omittedAtLeast: number;
+                } | {
+                    readonly code: "redacted" | "text-truncated";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly replacementOrOmittedCount: number;
+                } | {
+                    readonly code: "stream-truncated";
+                    readonly stream: "stderr" | "stdout";
+                    readonly omittedBytes: number;
+                    readonly commandId: string;
+                    readonly retainedBytes: number;
+                } | {
+                    readonly code: "invalid-utf8-replaced" | "unsafe-control-stripped";
+                    readonly stream: "stderr" | "stdout";
+                    readonly count: number;
+                    readonly commandId: string;
+                }, ...({
+                    readonly code: "capture-failed" | "capture-interrupted";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly stage: "adapter" | "command-capture" | "usage-capture" | "timing-capture" | "diagnostic-capture" | "attempt-finalizer" | "run-teardown";
+                } | {
+                    readonly code: "collection-cap-reached" | "unsupported-input";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly omittedAtLeast: number;
+                } | {
+                    readonly code: "redacted" | "text-truncated";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly replacementOrOmittedCount: number;
+                } | {
+                    readonly code: "stream-truncated";
+                    readonly stream: "stderr" | "stdout";
+                    readonly omittedBytes: number;
+                    readonly commandId: string;
+                    readonly retainedBytes: number;
+                } | {
+                    readonly code: "invalid-utf8-replaced" | "unsafe-control-stripped";
+                    readonly stream: "stderr" | "stdout";
+                    readonly count: number;
+                    readonly commandId: string;
+                })[]];
+            };
+            readonly intervals: readonly ({
+                readonly outcome: "completed" | "cancelled" | "interrupted" | "failed" | "unknown";
+                readonly label: string;
+                readonly phase: "agent.send";
+                readonly startOffsetMs: number;
+                readonly durationMs: number;
+                readonly intervalId: string;
+                readonly parentIntervalId: string | null;
+            } | {
+                readonly outcome: "completed" | "cancelled" | "interrupted" | "failed" | "unknown";
+                readonly label: string;
+                readonly phase: "agent.ensure" | "sandbox.prepare" | "eval.run" | "sandbox.command" | "attempt.setup" | "attempt.teardown" | "assertion.evaluate" | "verdict.fold";
+                readonly startOffsetMs: number;
+                readonly durationMs: number;
+                readonly intervalId: string;
+                readonly parentIntervalId: string | null;
+            })[];
+        };
+        readonly diagnostics: {
+            readonly collection: {
+                readonly state: "complete";
+                readonly limitations: readonly [];
+            } | {
+                readonly state: "partial";
+                readonly limitations: readonly [{
+                    readonly code: "capture-failed" | "capture-interrupted";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly stage: "adapter" | "command-capture" | "usage-capture" | "timing-capture" | "diagnostic-capture" | "attempt-finalizer" | "run-teardown";
+                } | {
+                    readonly code: "collection-cap-reached" | "unsupported-input";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly omittedAtLeast: number;
+                } | {
+                    readonly code: "redacted" | "text-truncated";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly replacementOrOmittedCount: number;
+                } | {
+                    readonly code: "stream-truncated";
+                    readonly stream: "stderr" | "stdout";
+                    readonly omittedBytes: number;
+                    readonly commandId: string;
+                    readonly retainedBytes: number;
+                } | {
+                    readonly code: "invalid-utf8-replaced" | "unsafe-control-stripped";
+                    readonly stream: "stderr" | "stdout";
+                    readonly count: number;
+                    readonly commandId: string;
+                }, ...({
+                    readonly code: "capture-failed" | "capture-interrupted";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly stage: "adapter" | "command-capture" | "usage-capture" | "timing-capture" | "diagnostic-capture" | "attempt-finalizer" | "run-teardown";
+                } | {
+                    readonly code: "collection-cap-reached" | "unsupported-input";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly omittedAtLeast: number;
+                } | {
+                    readonly code: "redacted" | "text-truncated";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly replacementOrOmittedCount: number;
+                } | {
+                    readonly code: "stream-truncated";
+                    readonly stream: "stderr" | "stdout";
+                    readonly omittedBytes: number;
+                    readonly commandId: string;
+                    readonly retainedBytes: number;
+                } | {
+                    readonly code: "invalid-utf8-replaced" | "unsafe-control-stripped";
+                    readonly stream: "stderr" | "stdout";
+                    readonly count: number;
+                    readonly commandId: string;
+                })[]];
+            };
+            readonly diagnostics: readonly {
+                readonly code: string;
+                readonly kind: "advisory" | "execution-error";
+                readonly phase: "agent.ensure" | "sandbox.prepare" | "eval.run" | "sandbox.command" | "attempt.setup" | "attempt.teardown" | "agent.send" | "assertion.evaluate" | "verdict.fold";
+                readonly summary: string;
+                readonly redaction: {
+                    readonly state: "none";
+                } | {
+                    readonly state: "applied";
+                    readonly replacements: number;
+                };
+                readonly diagnosticId: string;
+                readonly causes: readonly {
+                    readonly code: string;
+                    readonly summary: string;
+                }[];
+                readonly sourceFrame: {
+                    readonly sha256: import("../model/identifiers.js").Sha256Digest;
+                    readonly start: {
+                        readonly line: number;
+                        readonly column: number;
+                    };
+                    readonly end: {
+                        readonly line: number;
+                        readonly column: number;
+                    };
+                    readonly sourceItemId: import("../model/identifiers.js").SourceItemId;
+                } | null;
+            }[];
+        };
+    }> | FixedRecordFamilyDescriptor<"niceeval.assertions", "attempt", {
+        readonly entries: readonly {
+            readonly evaluation: {
+                readonly receipt?: {
+                    readonly complete: boolean;
+                    readonly unavailable: number;
+                    readonly matched: number;
+                    readonly mismatched: number;
+                    readonly knownTotal: number | null;
+                    readonly examined: number;
+                    readonly exhaustive: boolean;
+                    readonly decisive: boolean;
+                } | undefined;
+                readonly observed: import("../../assertions/record/model.js").AssertionFactValue;
+            };
+            readonly display: import("../../assertions/record/model.js").AssertionDisplay;
+            readonly criterion: {
+                readonly value: import("../../assertions/record/model.js").BoundedJsonObject;
+                readonly state: "available";
+            } | {
+                readonly reason: "not-recorded";
+                readonly state: "unavailable";
+            };
+            readonly policy: {
+                readonly condition: {
+                    readonly value: {
+                        readonly expected: true;
+                        readonly kind: "boolean";
+                    } | {
+                        readonly kind: "at-least";
+                        readonly threshold: number;
+                    } | {
+                        readonly kind: "record-only";
+                    };
+                    readonly state: "available";
+                } | {
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
+                readonly requirement: {
+                    readonly value: "optional" | "required";
+                    readonly state: "available";
+                } | {
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
+            };
+            readonly decision: {
+                readonly reason: "redacted" | "evidence-unavailable" | "source-unavailable" | "condition-not-met" | "evaluator-failed" | "producer-interrupted" | "invalid-subject" | "coverage-not-applicable" | null;
+                readonly gate: "failed" | "unavailable" | "not-applicable" | "not-gate" | "satisfied";
+                readonly result: "errored" | "unavailable" | "matched" | "mismatched" | "not-applicable";
+            };
+            readonly contribution: import("../../assertions/record/model.js").NoScoreContribution | import("../../assertions/record/model.js").EarnedScoreContribution | import("../../assertions/record/model.js").UnavailableScoreContribution;
+            readonly entryId: import("../../index.js").AssertionEntryId;
+            readonly materials: {
+                readonly source: {
+                    readonly reason: "not-recorded";
+                    readonly kind: "unavailable";
+                } | {
+                    readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
+                    readonly kind: "snapshot";
+                } | {
+                    readonly kind: "blob";
+                    readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
+                    readonly sha256: import("../model/identifiers.js").Sha256Digest;
+                    readonly encoding: "utf-8" | "binary";
+                    readonly preview: string;
+                    readonly byteLength: number;
+                };
+                readonly coverage: import("../../assertions/record/model.js").AssertionCoverage;
+                readonly limitations: readonly import("../../assertions/record/model.js").AssertionLimitation[];
+                readonly evidence: readonly ({
+                    readonly reason: "not-recorded";
+                    readonly kind: "unavailable";
+                } | {
+                    readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
+                    readonly kind: "snapshot";
+                } | {
+                    readonly kind: "blob";
+                    readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
+                    readonly sha256: import("../model/identifiers.js").Sha256Digest;
+                    readonly encoding: "utf-8" | "binary";
+                    readonly preview: string;
+                    readonly byteLength: number;
+                })[];
+            };
+            readonly explanationRetention: {
+                readonly value: import("../../assertions/record/model.js").AssertionFactValue;
+                readonly state: "retained";
+            } | {
+                readonly reason: "not-recorded";
+                readonly state: "unavailable";
+            };
+        }[];
+        readonly sourceSites: readonly {
+            readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
+            readonly sha256: import("../model/identifiers.js").Sha256Digest;
+            readonly start: {
+                readonly line: number;
+                readonly column: number;
+            };
+            readonly end: {
+                readonly line: number;
+                readonly column: number;
+            };
+            readonly entryId: import("../../index.js").AssertionEntryId;
+            readonly sourceItemId: import("../model/identifiers.js").SourceItemId;
+            readonly sourceOrder: number;
+        }[];
+    }> | FixedRecordFamilyDescriptor<"niceeval.file-changes", "attempt", {
+        readonly attribution: {
+            readonly kind: "agent-send-window-endpoints";
+            readonly policy: {
+                readonly ignore: readonly string[];
+                readonly include: readonly string[];
+                readonly defaultPolicy: "niceeval.sandbox-ledger/default-excludes/v1";
+            };
+        };
+        readonly windows: readonly {
+            readonly windowId: string;
+            readonly sequence: number;
+            readonly changes: readonly {
+                readonly path: import("../model/identifiers.js").CanonicalProjectRelativePath;
+                readonly kind: "modified" | "deleted" | "created";
+                readonly changeId: import("../model/identifiers.js").FileChangeId;
+                readonly before: {
+                    readonly state: "absent";
+                } | {
+                    readonly state: "present";
+                    readonly revision: {
+                        readonly kind: "text";
+                        readonly sha256: import("../model/identifiers.js").Sha256Digest;
+                        readonly content: {
+                            readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
+                            readonly state: "available";
+                        } | {
+                            readonly reason: "collection-cap";
+                            readonly state: "omitted";
+                        };
+                        readonly byteLength: number;
+                    } | {
+                        readonly reason: "binary" | "oversized-text";
+                        readonly kind: "elided";
+                        readonly byteLength: number;
+                    } | {
+                        readonly reason: "capture-failed" | "capture-interrupted" | "unsupported-input";
+                        readonly kind: "unavailable";
+                    };
+                };
+                readonly after: {
+                    readonly state: "absent";
+                } | {
+                    readonly state: "present";
+                    readonly revision: {
+                        readonly kind: "text";
+                        readonly sha256: import("../model/identifiers.js").Sha256Digest;
+                        readonly content: {
+                            readonly ref: import("../attachment/blob-ref.js").RecordBlobRef;
+                            readonly state: "available";
+                        } | {
+                            readonly reason: "collection-cap";
+                            readonly state: "omitted";
+                        };
+                        readonly byteLength: number;
+                    } | {
+                        readonly reason: "binary" | "oversized-text";
+                        readonly kind: "elided";
+                        readonly byteLength: number;
+                    } | {
+                        readonly reason: "capture-failed" | "capture-interrupted" | "unsupported-input";
+                        readonly kind: "unavailable";
+                    };
+                };
+            }[];
+        }[];
+        readonly collection: {
+            readonly state: "complete";
+            readonly limitations: readonly [];
+        } | {
+            readonly state: "partial";
+            readonly limitations: readonly [{
+                readonly code: "capture-failed" | "capture-interrupted";
+                readonly stage: "normalize" | "export" | "checkpoint" | "finalizer-export";
+                readonly atWindowId: string | null;
+            } | {
+                readonly code: "collection-cap-reached";
+                readonly target: "window" | "change" | "content-blob" | "content-byte" | "json-byte";
+                readonly omittedAtLeast: number;
+                readonly atWindowId: string | null;
+            } | {
+                readonly code: "unsupported-input";
+                readonly target: "endpoint-metadata";
+                readonly omittedAtLeast: number;
+            }, ...({
+                readonly code: "capture-failed" | "capture-interrupted";
+                readonly stage: "normalize" | "export" | "checkpoint" | "finalizer-export";
+                readonly atWindowId: string | null;
+            } | {
+                readonly code: "collection-cap-reached";
+                readonly target: "window" | "change" | "content-blob" | "content-byte" | "json-byte";
+                readonly omittedAtLeast: number;
+                readonly atWindowId: string | null;
+            } | {
+                readonly code: "unsupported-input";
+                readonly target: "endpoint-metadata";
+                readonly omittedAtLeast: number;
+            })[]];
+        };
+    }> | FixedRecordFamilyDescriptor<"niceeval.source-navigation", "attempt", {
+        readonly collection: {
+            readonly state: "complete";
+            readonly limitations: readonly [];
+        } | {
+            readonly state: "partial";
+            readonly limitations: readonly [{
+                readonly code: "collection-cap-reached";
+                readonly target: "navigation-row";
+                readonly omittedAtLeast: number;
+            } | {
+                readonly code: "capture-unrecoverable";
+                readonly target: "timing-link";
+                readonly omittedAtLeast: number;
+            }, ...({
+                readonly code: "collection-cap-reached";
+                readonly target: "navigation-row";
+                readonly omittedAtLeast: number;
+            } | {
+                readonly code: "capture-unrecoverable";
+                readonly target: "timing-link";
+                readonly omittedAtLeast: number;
+            })[]];
+        };
+        readonly rows: readonly {
+            readonly source: {
+                readonly state: "mapped";
+                readonly sha256: import("../model/identifiers.js").Sha256Digest;
+                readonly start: {
+                    readonly line: number;
+                    readonly column: number;
+                };
+                readonly end: {
+                    readonly line: number;
+                    readonly column: number;
+                };
+                readonly sourceItemId: import("../model/identifiers.js").SourceItemId;
+            } | {
+                readonly reason: "location-not-captured" | "source-snapshot-not-recorded" | "position-unrepresentable";
+                readonly state: "unmapped";
+            };
+            readonly turnId: import("../../o11y/record/model.js").TurnId;
+            readonly timing: {
+                readonly state: "linked";
+                readonly intervalId: import("../../o11y/record/model.js").IntervalId;
+            } | {
+                readonly reason: "timing-not-recorded";
+                readonly state: "unavailable";
+            };
+            readonly sourceOrder: number | null;
+        }[];
+    }> | FixedRecordFamilyDescriptor<"niceeval.artifacts", "attempt", {
+        readonly collection: {
+            readonly state: "complete";
+            readonly limitations: readonly [];
+        } | {
+            readonly state: "partial";
+            readonly limitations: readonly [{
+                readonly code: "capture-failed" | "capture-interrupted";
+                readonly stage: string;
+            } | {
+                readonly code: "collection-cap-reached" | "unsupported-input";
+                readonly omittedAtLeast: number;
+            }, ...({
+                readonly code: "capture-failed" | "capture-interrupted";
+                readonly stage: string;
+            } | {
+                readonly code: "collection-cap-reached" | "unsupported-input";
+                readonly omittedAtLeast: number;
+            })[]];
+        };
+        readonly artifacts: readonly {
+            readonly label: string;
+            readonly sha256: import("../model/identifiers.js").Sha256Digest;
+            readonly content: import("../attachment/blob-ref.js").RecordBlobRef;
+            readonly artifactId: import("../model/identifiers.js").ArtifactId;
+            readonly mediaType: string;
+            readonly byteLength: number;
+        }[];
+    }>)[];
+    run: readonly (FixedRecordFamilyDescriptor<"niceeval.sources", "run", {
+        readonly items: readonly {
+            readonly path: import("../model/identifiers.js").CanonicalProjectRelativePath;
+            readonly sha256: import("../model/identifiers.js").Sha256Digest;
+            readonly content: import("../attachment/blob-ref.js").RecordBlobRef;
+            readonly byteLength: number;
+            readonly sourceItemId: import("../model/identifiers.js").SourceItemId;
+        }[];
+    }> | FixedRecordFamilyDescriptor<"niceeval.observability", "run", {
+        readonly owner: "run";
+        readonly timing: {
+            readonly collection: {
+                readonly state: "complete";
+                readonly limitations: readonly [];
+            } | {
+                readonly state: "partial";
+                readonly limitations: readonly [{
+                    readonly code: "capture-failed" | "capture-interrupted";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly stage: "adapter" | "command-capture" | "usage-capture" | "timing-capture" | "diagnostic-capture" | "attempt-finalizer" | "run-teardown";
+                } | {
+                    readonly code: "collection-cap-reached" | "unsupported-input";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly omittedAtLeast: number;
+                } | {
+                    readonly code: "redacted" | "text-truncated";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly replacementOrOmittedCount: number;
+                } | {
+                    readonly code: "stream-truncated";
+                    readonly stream: "stderr" | "stdout";
+                    readonly omittedBytes: number;
+                    readonly commandId: string;
+                    readonly retainedBytes: number;
+                } | {
+                    readonly code: "invalid-utf8-replaced" | "unsafe-control-stripped";
+                    readonly stream: "stderr" | "stdout";
+                    readonly count: number;
+                    readonly commandId: string;
+                }, ...({
+                    readonly code: "capture-failed" | "capture-interrupted";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly stage: "adapter" | "command-capture" | "usage-capture" | "timing-capture" | "diagnostic-capture" | "attempt-finalizer" | "run-teardown";
+                } | {
+                    readonly code: "collection-cap-reached" | "unsupported-input";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly omittedAtLeast: number;
+                } | {
+                    readonly code: "redacted" | "text-truncated";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly replacementOrOmittedCount: number;
+                } | {
+                    readonly code: "stream-truncated";
+                    readonly stream: "stderr" | "stdout";
+                    readonly omittedBytes: number;
+                    readonly commandId: string;
+                    readonly retainedBytes: number;
+                } | {
+                    readonly code: "invalid-utf8-replaced" | "unsafe-control-stripped";
+                    readonly stream: "stderr" | "stdout";
+                    readonly count: number;
+                    readonly commandId: string;
+                })[]];
+            };
+            readonly intervals: readonly {
+                readonly outcome: "completed" | "cancelled" | "interrupted" | "failed" | "unknown";
+                readonly label: string;
+                readonly phase: "run.setup" | "run.discovery" | "run.plan" | "run.dispatch" | "run.teardown";
+                readonly startOffsetMs: number;
+                readonly durationMs: number;
+                readonly intervalId: string;
+                readonly parentIntervalId: string | null;
+            }[];
+        };
+        readonly diagnostics: {
+            readonly collection: {
+                readonly state: "complete";
+                readonly limitations: readonly [];
+            } | {
+                readonly state: "partial";
+                readonly limitations: readonly [{
+                    readonly code: "capture-failed" | "capture-interrupted";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly stage: "adapter" | "command-capture" | "usage-capture" | "timing-capture" | "diagnostic-capture" | "attempt-finalizer" | "run-teardown";
+                } | {
+                    readonly code: "collection-cap-reached" | "unsupported-input";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly omittedAtLeast: number;
+                } | {
+                    readonly code: "redacted" | "text-truncated";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly replacementOrOmittedCount: number;
+                } | {
+                    readonly code: "stream-truncated";
+                    readonly stream: "stderr" | "stdout";
+                    readonly omittedBytes: number;
+                    readonly commandId: string;
+                    readonly retainedBytes: number;
+                } | {
+                    readonly code: "invalid-utf8-replaced" | "unsafe-control-stripped";
+                    readonly stream: "stderr" | "stdout";
+                    readonly count: number;
+                    readonly commandId: string;
+                }, ...({
+                    readonly code: "capture-failed" | "capture-interrupted";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly stage: "adapter" | "command-capture" | "usage-capture" | "timing-capture" | "diagnostic-capture" | "attempt-finalizer" | "run-teardown";
+                } | {
+                    readonly code: "collection-cap-reached" | "unsupported-input";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly omittedAtLeast: number;
+                } | {
+                    readonly code: "redacted" | "text-truncated";
+                    readonly target: "command" | "diagnostic" | "usage" | "conversation" | "timing";
+                    readonly replacementOrOmittedCount: number;
+                } | {
+                    readonly code: "stream-truncated";
+                    readonly stream: "stderr" | "stdout";
+                    readonly omittedBytes: number;
+                    readonly commandId: string;
+                    readonly retainedBytes: number;
+                } | {
+                    readonly code: "invalid-utf8-replaced" | "unsafe-control-stripped";
+                    readonly stream: "stderr" | "stdout";
+                    readonly count: number;
+                    readonly commandId: string;
+                })[]];
+            };
+            readonly diagnostics: readonly {
+                readonly code: string;
+                readonly kind: "advisory" | "execution-error";
+                readonly phase: "run.setup" | "run.discovery" | "run.plan" | "run.dispatch" | "run.teardown";
+                readonly summary: string;
+                readonly redaction: {
+                    readonly state: "none";
+                } | {
+                    readonly state: "applied";
+                    readonly replacements: number;
+                };
+                readonly diagnosticId: string;
+                readonly causes: readonly {
+                    readonly code: string;
+                    readonly summary: string;
+                }[];
+                readonly sourceFrame: {
+                    readonly sha256: import("../model/identifiers.js").Sha256Digest;
+                    readonly start: {
+                        readonly line: number;
+                        readonly column: number;
+                    };
+                    readonly end: {
+                        readonly line: number;
+                        readonly column: number;
+                    };
+                    readonly sourceItemId: import("../model/identifiers.js").SourceItemId;
+                } | null;
+            }[];
+        };
+    }> | FixedRecordFamilyDescriptor<"niceeval.artifacts", "run", {
+        readonly collection: {
+            readonly state: "complete";
+            readonly limitations: readonly [];
+        } | {
+            readonly state: "partial";
+            readonly limitations: readonly [{
+                readonly code: "capture-failed" | "capture-interrupted";
+                readonly stage: string;
+            } | {
+                readonly code: "collection-cap-reached" | "unsupported-input";
+                readonly omittedAtLeast: number;
+            }, ...({
+                readonly code: "capture-failed" | "capture-interrupted";
+                readonly stage: string;
+            } | {
+                readonly code: "collection-cap-reached" | "unsupported-input";
+                readonly omittedAtLeast: number;
+            })[]];
+        };
+        readonly artifacts: readonly {
+            readonly label: string;
+            readonly sha256: import("../model/identifiers.js").Sha256Digest;
+            readonly content: import("../attachment/blob-ref.js").RecordBlobRef;
+            readonly artifactId: import("../model/identifiers.js").ArtifactId;
+            readonly mediaType: string;
+            readonly byteLength: number;
+        }[];
+    }>)[];
+}>;
 export declare const FixedRecordAttachmentEnvelopeSchema: Schema.Schema<{
     readonly family: NiceEvalFamily;
     readonly schemaVersion: number;