niceeval 0.12.2-canary.31 → 0.13.0

package/dist/o11y/record/families.cjs

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunDiagnosticsAttachmentV1Schema = exports.AttemptDiagnosticsAttachmentV1Schema = exports.RunDiagnosticV1Schema = exports.AttemptDiagnosticV1Schema = exports.SourceFrameV1Schema = exports.SourcePositionV1Schema = exports.RunDiagnosticPhaseV1Schema = exports.AttemptDiagnosticPhaseV1Schema = exports.RunTimingAttachmentV1Schema = exports.AttemptTimingAttachmentV1Schema = exports.RunTimingIntervalV1Schema = exports.AttemptTimingIntervalV1Schema = exports.RunTimingPhaseV1Schema = exports.AttemptTimingPhaseV1Schema = exports.UsageAttachmentV1Schema = exports.UsageObservationV1Schema = exports.CommandsAttachmentV1Schema = exports.CommandObservationV1Schema = exports.CommandResultV1Schema = exports.CommandOutcomeV1Schema = exports.CommandStreamV1Schema = exports.CommandManifestV1Schema = exports.ConversationAttachmentV1Schema = exports.ConversationItemV1Schema = exports.ConversationTurnV1Schema = void 0;
-exports.makeAttemptConversationAttachmentFamilyValidationV1 = makeAttemptConversationAttachmentFamilyValidationV1;
-exports.makeAttemptCommandsAttachmentFamilyValidationV1 = makeAttemptCommandsAttachmentFamilyValidationV1;
-exports.makeAttemptUsageAttachmentFamilyValidationV1 = makeAttemptUsageAttachmentFamilyValidationV1;
-exports.makeAttemptTimingAttachmentFamilyValidationV1 = makeAttemptTimingAttachmentFamilyValidationV1;
-exports.makeAttemptDiagnosticsAttachmentFamilyValidationV1 = makeAttemptDiagnosticsAttachmentFamilyValidationV1;
-exports.makeRunTimingAttachmentFamilyValidationV1 = makeRunTimingAttachmentFamilyValidationV1;
-exports.makeRunDiagnosticsAttachmentFamilyValidationV1 = makeRunDiagnosticsAttachmentFamilyValidationV1;
+exports.RunDiagnosticsAttachmentSchema = exports.AttemptDiagnosticsAttachmentSchema = exports.RunDiagnosticSchema = exports.AttemptDiagnosticSchema = exports.SourceFrameSchema = exports.SourcePositionSchema = exports.RunDiagnosticPhaseSchema = exports.AttemptDiagnosticPhaseSchema = exports.RunTimingAttachmentSchema = exports.AttemptTimingAttachmentSchema = exports.RunTimingIntervalSchema = exports.AttemptTimingIntervalSchema = exports.RunTimingPhaseSchema = exports.AttemptTimingPhaseSchema = exports.UsageAttachmentSchema = exports.UsageObservationSchema = exports.CommandsAttachmentSchema = exports.CommandObservationSchema = exports.CommandResultSchema = exports.CommandOutcomeSchema = exports.CommandStreamSchema = exports.CommandManifestSchema = exports.ConversationAttachmentSchema = exports.ConversationItemSchema = exports.ConversationTurnSchema = void 0;
+exports.makeAttemptConversationAttachmentFamilyValidation = makeAttemptConversationAttachmentFamilyValidation;
+exports.makeAttemptCommandsAttachmentFamilyValidation = makeAttemptCommandsAttachmentFamilyValidation;
+exports.makeAttemptUsageAttachmentFamilyValidation = makeAttemptUsageAttachmentFamilyValidation;
+exports.makeAttemptTimingAttachmentFamilyValidation = makeAttemptTimingAttachmentFamilyValidation;
+exports.makeAttemptDiagnosticsAttachmentFamilyValidation = makeAttemptDiagnosticsAttachmentFamilyValidation;
+exports.makeRunTimingAttachmentFamilyValidation = makeRunTimingAttachmentFamilyValidation;
+exports.makeRunDiagnosticsAttachmentFamilyValidation = makeRunDiagnosticsAttachmentFamilyValidation;
 const effect_1 = require("effect");
 const codec_ts_1 = require("../../sources/codec.cjs");
 const codec_ts_2 = require("./codec.cjs");
@@ -18,7 +18,7 @@ function freezeArray(values) {
     return Object.freeze([...values]);
 }
 function payloadFits(value, maximumBytes) {
-    const length = (0, model_ts_1.jsonUtf8ByteLengthV1)(value);
+    const length = (0, model_ts_1.jsonUtf8ByteLength)(value);
     return length !== undefined && length <= maximumBytes;
 }
 function isStrictlyOrderedById(values, idOf) {
@@ -26,7 +26,7 @@ function isStrictlyOrderedById(values, idOf) {
     const seen = new Set();
     for (const value of values) {
         const id = idOf(value);
-        if (seen.has(id) || (previous !== undefined && (0, model_ts_1.compareObservabilityTextV1)(previous, id) >= 0)) {
+        if (seen.has(id) || (previous !== undefined && (0, model_ts_1.compareObservabilityText)(previous, id) >= 0)) {
             return false;
         }
         seen.add(id);
@@ -35,7 +35,7 @@ function isStrictlyOrderedById(values, idOf) {
     return true;
 }
 function isAllowedCollection(collection, targets) {
-    return collection.limitations.every((limitation) => targets.some((target) => (0, model_ts_1.limitationTargetV1)(limitation) === target));
+    return collection.limitations.every((limitation) => targets.some((target) => (0, model_ts_1.limitationTarget)(limitation) === target));
 }
 function hasExactStreamTruncation(collection, commandId, stream, retainedBytes, totalSafeUtf8Bytes) {
     const omittedBytes = totalSafeUtf8Bytes - retainedBytes;
@@ -46,89 +46,89 @@ function hasExactStreamTruncation(collection, commandId, stream, retainedBytes,
         limitation.omittedBytes === omittedBytes);
 }
 function isProjectRelativePath(value) {
-    return ((0, model_ts_1.isSafeTextV1)(value) &&
+    return ((0, model_ts_1.isSafeText)(value) &&
         value.length > 0 &&
         !value.startsWith("/") &&
         value.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..") &&
-        new TextEncoder().encode(value).byteLength <= limits_ts_1.MAX_COMMAND_PROJECT_RELATIVE_PATH_BYTES_V1);
+        new TextEncoder().encode(value).byteLength <= limits_ts_1.MAX_COMMAND_PROJECT_RELATIVE_PATH_BYTES);
 }
-const ProjectRelativePathV1Schema = effect_1.Schema.String.pipe(effect_1.Schema.filter(isProjectRelativePath, {
-    identifier: "ObservabilityProjectRelativePathV1",
+const ProjectRelativePathSchema = effect_1.Schema.String.pipe(effect_1.Schema.filter(isProjectRelativePath, {
+    identifier: "ObservabilityProjectRelativePath",
     description: "a portable project-relative path without dot segments",
 }));
-const ExitCodeV1Schema = effect_1.Schema.JsonNumber.pipe(effect_1.Schema.filter((value) => Number.isSafeInteger(value) &&
+const ExitCodeSchema = effect_1.Schema.JsonNumber.pipe(effect_1.Schema.filter((value) => Number.isSafeInteger(value) &&
     value >= -2147483648 &&
     value <= 2147483647, {
-    identifier: "ObservabilityCommandExitCodeV1",
+    identifier: "ObservabilityCommandExitCode",
     description: "a signed 32-bit command exit code",
 }));
 /** Record's opaque ref position is the only non-JSON value in a durable command payload. */
-const RecordBlobRefPositionV1Schema = effect_1.Schema.declare((value) => typeof value === "object" && value !== null);
-const ConversationItemBaseV1Fields = {
-    itemId: codec_ts_2.ItemIdV1Schema,
-    turnId: codec_ts_2.TurnIdV1Schema,
-    sequence: codec_ts_2.PositiveSafeIntegerV1Schema,
-    refs: codec_ts_2.ConversationReferencesV1Schema,
+const RecordBlobRefPositionSchema = effect_1.Schema.declare((value) => typeof value === "object" && value !== null);
+const ConversationItemBaseFields = {
+    itemId: codec_ts_2.ItemIdSchema,
+    turnId: codec_ts_2.TurnIdSchema,
+    sequence: codec_ts_2.PositiveSafeIntegerSchema,
+    refs: codec_ts_2.ConversationReferencesSchema,
 };
-exports.ConversationTurnV1Schema = effect_1.Schema.Struct({
-    turnId: codec_ts_2.TurnIdV1Schema,
-    sequence: codec_ts_2.PositiveSafeIntegerV1Schema,
+exports.ConversationTurnSchema = effect_1.Schema.Struct({
+    turnId: codec_ts_2.TurnIdSchema,
+    sequence: codec_ts_2.PositiveSafeIntegerSchema,
     outcome: effect_1.Schema.Literal("completed", "failed", "cancelled", "interrupted"),
-    refs: codec_ts_2.ConversationReferencesV1Schema,
+    refs: codec_ts_2.ConversationReferencesSchema,
 });
-exports.ConversationItemV1Schema = effect_1.Schema.Union(effect_1.Schema.Struct({
-    ...ConversationItemBaseV1Fields,
+exports.ConversationItemSchema = effect_1.Schema.Union(effect_1.Schema.Struct({
+    ...ConversationItemBaseFields,
     kind: effect_1.Schema.Literal("message"),
     role: effect_1.Schema.Literal("user", "assistant"),
-    text: (0, codec_ts_2.boundedSafeTextV1Schema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES_V1),
+    text: (0, codec_ts_2.boundedSafeTextSchema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES),
 }), effect_1.Schema.Struct({
-    ...ConversationItemBaseV1Fields,
+    ...ConversationItemBaseFields,
     kind: effect_1.Schema.Literal("tool-call"),
-    callId: codec_ts_2.CallIdV1Schema,
-    tool: codec_ts_2.SourceNativeToolNameV1Schema,
-    inputSummary: (0, codec_ts_2.boundedSafeTextV1Schema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES_V1),
+    callId: codec_ts_2.CallIdSchema,
+    tool: codec_ts_2.SourceNativeToolNameSchema,
+    inputSummary: (0, codec_ts_2.boundedSafeTextSchema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES),
 }), effect_1.Schema.Struct({
-    ...ConversationItemBaseV1Fields,
+    ...ConversationItemBaseFields,
     kind: effect_1.Schema.Literal("tool-result"),
-    callId: codec_ts_2.CallIdV1Schema,
+    callId: codec_ts_2.CallIdSchema,
     outcome: effect_1.Schema.Literal("completed", "rejected", "failed", "cancelled"),
-    outputSummary: (0, codec_ts_2.boundedSafeTextV1Schema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES_V1),
+    outputSummary: (0, codec_ts_2.boundedSafeTextSchema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES),
 }), effect_1.Schema.Struct({
-    ...ConversationItemBaseV1Fields,
+    ...ConversationItemBaseFields,
     kind: effect_1.Schema.Literal("thinking-summary"),
-    summary: (0, codec_ts_2.boundedSafeTextV1Schema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES_V1),
+    summary: (0, codec_ts_2.boundedSafeTextSchema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES),
 }), effect_1.Schema.Struct({
-    ...ConversationItemBaseV1Fields,
+    ...ConversationItemBaseFields,
     kind: effect_1.Schema.Literal("subagent"),
     state: effect_1.Schema.Literal("started", "completed", "failed"),
-    label: codec_ts_2.SafeIdentifierV1Schema,
-    summary: (0, codec_ts_2.boundedSafeTextV1Schema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES_V1),
+    label: codec_ts_2.SafeIdentifierSchema,
+    summary: (0, codec_ts_2.boundedSafeTextSchema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES),
 }), effect_1.Schema.Struct({
-    ...ConversationItemBaseV1Fields,
+    ...ConversationItemBaseFields,
     kind: effect_1.Schema.Literal("input-request"),
     state: effect_1.Schema.Literal("requested", "answered", "cancelled"),
-    promptSummary: (0, codec_ts_2.boundedSafeTextV1Schema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES_V1),
-    responseSummary: effect_1.Schema.NullOr((0, codec_ts_2.boundedSafeTextV1Schema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES_V1)),
+    promptSummary: (0, codec_ts_2.boundedSafeTextSchema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES),
+    responseSummary: effect_1.Schema.NullOr((0, codec_ts_2.boundedSafeTextSchema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES)),
 }), effect_1.Schema.Struct({
-    ...ConversationItemBaseV1Fields,
+    ...ConversationItemBaseFields,
     kind: effect_1.Schema.Literal("skill-load"),
-    skill: codec_ts_2.SafeIdentifierV1Schema,
+    skill: codec_ts_2.SafeIdentifierSchema,
     outcome: effect_1.Schema.Literal("loaded", "failed"),
 }), effect_1.Schema.Struct({
-    ...ConversationItemBaseV1Fields,
+    ...ConversationItemBaseFields,
     kind: effect_1.Schema.Literal("context-injection"),
     source: effect_1.Schema.Literal("system", "memory", "skill", "user"),
-    summary: (0, codec_ts_2.boundedSafeTextV1Schema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES_V1),
+    summary: (0, codec_ts_2.boundedSafeTextSchema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES),
 }), effect_1.Schema.Struct({
-    ...ConversationItemBaseV1Fields,
+    ...ConversationItemBaseFields,
     kind: effect_1.Schema.Literal("compaction"),
-    summary: (0, codec_ts_2.boundedSafeTextV1Schema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES_V1),
-    compactedItemCount: codec_ts_2.NonNegativeSafeIntegerV1Schema,
+    summary: (0, codec_ts_2.boundedSafeTextSchema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES),
+    compactedItemCount: codec_ts_2.NonNegativeSafeIntegerSchema,
 }), effect_1.Schema.Struct({
-    ...ConversationItemBaseV1Fields,
+    ...ConversationItemBaseFields,
     kind: effect_1.Schema.Literal("conversation-error"),
-    code: codec_ts_2.SafeIdentifierV1Schema,
-    summary: (0, codec_ts_2.boundedSafeTextV1Schema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES_V1),
+    code: codec_ts_2.SafeIdentifierSchema,
+    summary: (0, codec_ts_2.boundedSafeTextSchema)(limits_ts_1.MAX_CONVERSATION_TEXT_BYTES),
 }));
 function conversationTextLengths(item) {
     switch (item.kind) {
@@ -155,10 +155,10 @@ function conversationTextLengths(item) {
             return freezeArray([]);
     }
 }
-function isCanonicalConversationAttachmentV1(value) {
-    if (value.turns.length > limits_ts_1.MAX_CONVERSATION_TURNS_V1 ||
-        value.items.length > limits_ts_1.MAX_CONVERSATION_ITEMS_V1 ||
-        !payloadFits(value, limits_ts_1.MAX_CONVERSATION_ATTACHMENT_BYTES_V1) ||
+function isCanonicalConversationAttachment(value) {
+    if (value.turns.length > limits_ts_1.MAX_CONVERSATION_TURNS ||
+        value.items.length > limits_ts_1.MAX_CONVERSATION_ITEMS ||
+        !payloadFits(value, limits_ts_1.MAX_CONVERSATION_ATTACHMENT_BYTES) ||
         !isAllowedCollection(value.collection, ["conversation-item", "conversation-text"])) {
         return false;
     }
@@ -186,7 +186,7 @@ function isCanonicalConversationAttachmentV1(value) {
         if (previous !== undefined &&
             (previous.sequence > item.sequence ||
                 (previous.sequence === item.sequence &&
-                    (0, model_ts_1.compareObservabilityTextV1)(previous.itemId, item.itemId) >= 0))) {
+                    (0, model_ts_1.compareObservabilityText)(previous.itemId, item.itemId) >= 0))) {
             return false;
         }
         itemIds.add(item.itemId);
@@ -215,49 +215,49 @@ function isCanonicalConversationAttachmentV1(value) {
         return item !== undefined && conversationTextLengths(item).some((length) => length === limitation.retainedBytes);
     });
 }
-const ConversationAttachmentV1StructuralSchema = effect_1.Schema.Struct({
-    collection: codec_ts_2.CollectionV1Schema,
-    turns: effect_1.Schema.Array(exports.ConversationTurnV1Schema),
-    items: effect_1.Schema.Array(exports.ConversationItemV1Schema),
+const ConversationAttachmentStructuralSchema = effect_1.Schema.Struct({
+    collection: codec_ts_2.CollectionSchema,
+    turns: effect_1.Schema.Array(exports.ConversationTurnSchema),
+    items: effect_1.Schema.Array(exports.ConversationItemSchema),
 });
-exports.ConversationAttachmentV1Schema = ConversationAttachmentV1StructuralSchema.pipe(effect_1.Schema.filter(isCanonicalConversationAttachmentV1, {
-    identifier: "ObservabilityConversationAttachmentV1",
+exports.ConversationAttachmentSchema = ConversationAttachmentStructuralSchema.pipe(effect_1.Schema.filter(isCanonicalConversationAttachment, {
+    identifier: "ObservabilityConversationAttachment",
     description: "a canonical, bounded conversation attachment",
 }));
-const CommandInvocationV1Schema = effect_1.Schema.Union(effect_1.Schema.Struct({
+const CommandInvocationSchema = effect_1.Schema.Union(effect_1.Schema.Struct({
     kind: effect_1.Schema.Literal("argv"),
-    executable: (0, codec_ts_2.boundedSafeTextV1Schema)(limits_ts_1.MAX_COMMAND_EXECUTABLE_BYTES_V1),
-    arguments: effect_1.Schema.Array((0, codec_ts_2.boundedSafeTextV1Schema)(limits_ts_1.MAX_COMMAND_ARGUMENT_BYTES_V1)).pipe(effect_1.Schema.filter((arguments_) => arguments_.length <= limits_ts_1.MAX_COMMAND_ARGUMENTS_V1, {
-        identifier: "ObservabilityCommandArgumentsV1",
+    executable: (0, codec_ts_2.boundedSafeTextSchema)(limits_ts_1.MAX_COMMAND_EXECUTABLE_BYTES),
+    arguments: effect_1.Schema.Array((0, codec_ts_2.boundedSafeTextSchema)(limits_ts_1.MAX_COMMAND_ARGUMENT_BYTES)).pipe(effect_1.Schema.filter((arguments_) => arguments_.length <= limits_ts_1.MAX_COMMAND_ARGUMENTS, {
+        identifier: "ObservabilityCommandArguments",
         description: "at most 64 safe command arguments",
     })),
 }), effect_1.Schema.Struct({
     kind: effect_1.Schema.Literal("shell"),
-    command: (0, codec_ts_2.boundedSafeTextV1Schema)(limits_ts_1.MAX_COMMAND_SHELL_BYTES_V1),
+    command: (0, codec_ts_2.boundedSafeTextSchema)(limits_ts_1.MAX_COMMAND_SHELL_BYTES),
 }));
-const CommandWorkingDirectoryV1Schema = effect_1.Schema.Union(effect_1.Schema.Struct({ kind: effect_1.Schema.Literal("sandbox-default") }), effect_1.Schema.Struct({
+const CommandWorkingDirectorySchema = effect_1.Schema.Union(effect_1.Schema.Struct({ kind: effect_1.Schema.Literal("sandbox-default") }), effect_1.Schema.Struct({
     kind: effect_1.Schema.Literal("project-relative"),
-    path: ProjectRelativePathV1Schema,
+    path: ProjectRelativePathSchema,
 }), effect_1.Schema.Struct({ kind: effect_1.Schema.Literal("redacted") }));
-exports.CommandManifestV1Schema = effect_1.Schema.Struct({
+exports.CommandManifestSchema = effect_1.Schema.Struct({
     phase: effect_1.Schema.Literal("attempt.setup", "sandbox.prepare", "agent.ensure", "eval.run", "sandbox.command", "attempt.teardown"),
-    invocation: CommandInvocationV1Schema,
-    workingDirectory: CommandWorkingDirectoryV1Schema,
+    invocation: CommandInvocationSchema,
+    workingDirectory: CommandWorkingDirectorySchema,
 });
-exports.CommandStreamV1Schema = effect_1.Schema.Struct({
+exports.CommandStreamSchema = effect_1.Schema.Struct({
     storage: effect_1.Schema.Union(effect_1.Schema.Struct({
         kind: effect_1.Schema.Literal("inline"),
-        text: codec_ts_2.SafeTextV1Schema,
+        text: codec_ts_2.SafeTextSchema,
     }), effect_1.Schema.Struct({
         kind: effect_1.Schema.Literal("blob"),
-        ref: RecordBlobRefPositionV1Schema,
+        ref: RecordBlobRefPositionSchema,
     })),
-    retainedBytes: codec_ts_2.NonNegativeSafeIntegerV1Schema,
-    totalSafeUtf8Bytes: codec_ts_2.NonNegativeSafeIntegerV1Schema,
+    retainedBytes: codec_ts_2.NonNegativeSafeIntegerSchema,
+    totalSafeUtf8Bytes: codec_ts_2.NonNegativeSafeIntegerSchema,
 });
-exports.CommandOutcomeV1Schema = effect_1.Schema.Union(effect_1.Schema.Struct({
+exports.CommandOutcomeSchema = effect_1.Schema.Union(effect_1.Schema.Struct({
     kind: effect_1.Schema.Literal("exited"),
-    exitCode: ExitCodeV1Schema,
+    exitCode: ExitCodeSchema,
 }), effect_1.Schema.Struct({
     kind: effect_1.Schema.Literal("terminated"),
     reason: effect_1.Schema.Literal("timeout", "cancelled", "transport-lost"),
@@ -265,37 +265,37 @@ exports.CommandOutcomeV1Schema = effect_1.Schema.Union(effect_1.Schema.Struct({
     kind: effect_1.Schema.Literal("not-started"),
     reason: effect_1.Schema.Literal("spawn-failed", "cancelled-before-start"),
 }));
-exports.CommandResultV1Schema = effect_1.Schema.Struct({
-    outcome: exports.CommandOutcomeV1Schema,
-    stdout: exports.CommandStreamV1Schema,
-    stderr: exports.CommandStreamV1Schema,
+exports.CommandResultSchema = effect_1.Schema.Struct({
+    outcome: exports.CommandOutcomeSchema,
+    stdout: exports.CommandStreamSchema,
+    stderr: exports.CommandStreamSchema,
 });
-exports.CommandObservationV1Schema = effect_1.Schema.Struct({
-    commandId: codec_ts_2.CommandIdV1Schema,
-    manifest: exports.CommandManifestV1Schema,
-    result: exports.CommandResultV1Schema,
-    refs: codec_ts_2.CommandsReferencesV1Schema,
+exports.CommandObservationSchema = effect_1.Schema.Struct({
+    commandId: codec_ts_2.CommandIdSchema,
+    manifest: exports.CommandManifestSchema,
+    result: exports.CommandResultSchema,
+    refs: codec_ts_2.CommandsReferencesSchema,
 });
-const CommandsAttachmentV1StructuralSchema = effect_1.Schema.Struct({
-    collection: codec_ts_2.CollectionV1Schema,
-    commands: effect_1.Schema.Array(exports.CommandObservationV1Schema),
+const CommandsAttachmentStructuralSchema = effect_1.Schema.Struct({
+    collection: codec_ts_2.CollectionSchema,
+    commands: effect_1.Schema.Array(exports.CommandObservationSchema),
 });
-function isCanonicalCommandStreamV1(stream, collection, commandId, streamName) {
-    if (stream.retainedBytes > limits_ts_1.MAX_COMMAND_STREAM_BYTES_V1 ||
+function isCanonicalCommandStream(stream, collection, commandId, streamName) {
+    if (stream.retainedBytes > limits_ts_1.MAX_COMMAND_STREAM_BYTES ||
         stream.totalSafeUtf8Bytes < stream.retainedBytes) {
         return false;
     }
     if (stream.storage.kind === "inline") {
         const bytes = new TextEncoder().encode(stream.storage.text).byteLength;
         if (bytes !== stream.retainedBytes ||
-            stream.retainedBytes > limits_ts_1.MAX_COMMAND_INLINE_STREAM_BYTES_V1) {
+            stream.retainedBytes > limits_ts_1.MAX_COMMAND_INLINE_STREAM_BYTES) {
             return false;
         }
     }
     if (stream.totalSafeUtf8Bytes === stream.retainedBytes) {
         return stream.storage.kind === "inline"
-            ? stream.retainedBytes <= limits_ts_1.MAX_COMMAND_INLINE_STREAM_BYTES_V1
-            : stream.retainedBytes > limits_ts_1.MAX_COMMAND_INLINE_STREAM_BYTES_V1;
+            ? stream.retainedBytes <= limits_ts_1.MAX_COMMAND_INLINE_STREAM_BYTES
+            : stream.retainedBytes > limits_ts_1.MAX_COMMAND_INLINE_STREAM_BYTES;
     }
     return hasExactStreamTruncation(collection, commandId, streamName, stream.retainedBytes, stream.totalSafeUtf8Bytes);
 }
@@ -309,9 +309,9 @@ function commandManifestTextLengths(manifest) {
         : [];
     return freezeArray([...invocation, ...directory].map((value) => encoder.encode(value).byteLength));
 }
-function isCanonicalCommandsAttachmentV1(value) {
-    if (value.commands.length > limits_ts_1.MAX_COMMANDS_V1 ||
-        !payloadFits(value, limits_ts_1.MAX_COMMANDS_ATTACHMENT_BYTES_V1) ||
+function isCanonicalCommandsAttachment(value) {
+    if (value.commands.length > limits_ts_1.MAX_COMMANDS ||
+        !payloadFits(value, limits_ts_1.MAX_COMMANDS_ATTACHMENT_BYTES) ||
         !isAllowedCollection(value.collection, [
             "command-manifest",
             "command-stdout",
@@ -326,7 +326,7 @@ function isCanonicalCommandsAttachmentV1(value) {
             ["stdout", command.result.stdout],
             ["stderr", command.result.stderr],
         ]) {
-            if (!isCanonicalCommandStreamV1(stream, value.collection, command.commandId, name)) {
+            if (!isCanonicalCommandStream(stream, value.collection, command.commandId, name)) {
                 return false;
             }
             if (stream.storage.kind === "blob") {
@@ -334,7 +334,7 @@ function isCanonicalCommandsAttachmentV1(value) {
             }
         }
     }
-    if (closureBytes > limits_ts_1.MAX_COMMANDS_CLOSURE_BYTES_V1)
+    if (closureBytes > limits_ts_1.MAX_COMMANDS_CLOSURE_BYTES)
         return false;
     return value.collection.limitations.every((limitation) => {
         if (limitation.code !== "text-truncated" || limitation.target !== "command-manifest") {
@@ -344,77 +344,77 @@ function isCanonicalCommandsAttachmentV1(value) {
         return command !== undefined && commandManifestTextLengths(command.manifest).some((length) => length === limitation.retainedBytes);
     });
 }
-exports.CommandsAttachmentV1Schema = CommandsAttachmentV1StructuralSchema.pipe(effect_1.Schema.filter(isCanonicalCommandsAttachmentV1, {
-    identifier: "ObservabilityCommandsAttachmentV1",
+exports.CommandsAttachmentSchema = CommandsAttachmentStructuralSchema.pipe(effect_1.Schema.filter(isCanonicalCommandsAttachment, {
+    identifier: "ObservabilityCommandsAttachment",
     description: "a canonical, bounded commands attachment",
 }));
-exports.UsageObservationV1Schema = effect_1.Schema.Union(effect_1.Schema.Struct({
-    usageObservationId: codec_ts_2.UsageObservationIdV1Schema,
-    provider: codec_ts_2.SafeIdentifierV1Schema,
-    refs: codec_ts_2.UsageReferencesV1Schema,
+exports.UsageObservationSchema = effect_1.Schema.Union(effect_1.Schema.Struct({
+    usageObservationId: codec_ts_2.UsageObservationIdSchema,
+    provider: codec_ts_2.SafeIdentifierSchema,
+    refs: codec_ts_2.UsageReferencesSchema,
     kind: effect_1.Schema.Literal("token-bucket"),
     bucket: effect_1.Schema.Literal("input", "output", "cache-read", "cache-write", "reasoning", "other"),
-    tokens: codec_ts_2.NonNegativeSafeIntegerV1Schema,
+    tokens: codec_ts_2.NonNegativeSafeIntegerSchema,
 }), effect_1.Schema.Struct({
-    usageObservationId: codec_ts_2.UsageObservationIdV1Schema,
-    provider: codec_ts_2.SafeIdentifierV1Schema,
-    refs: codec_ts_2.UsageReferencesV1Schema,
+    usageObservationId: codec_ts_2.UsageObservationIdSchema,
+    provider: codec_ts_2.SafeIdentifierSchema,
+    refs: codec_ts_2.UsageReferencesSchema,
     kind: effect_1.Schema.Literal("request"),
     requestKind: effect_1.Schema.Literal("model", "tool"),
 }), effect_1.Schema.Struct({
-    usageObservationId: codec_ts_2.UsageObservationIdV1Schema,
-    provider: codec_ts_2.SafeIdentifierV1Schema,
-    refs: codec_ts_2.UsageReferencesV1Schema,
+    usageObservationId: codec_ts_2.UsageObservationIdSchema,
+    provider: codec_ts_2.SafeIdentifierSchema,
+    refs: codec_ts_2.UsageReferencesSchema,
     kind: effect_1.Schema.Literal("provider-cost"),
     amount: effect_1.Schema.String.pipe(effect_1.Schema.filter((value) => /^(?:0|[1-9][0-9]*)(?:\.[0-9]*[1-9])?$/u.test(value) &&
         new TextEncoder().encode(value).byteLength <= 64, {
-        identifier: "ObservabilityCanonicalDecimalV1",
+        identifier: "ObservabilityCanonicalDecimal",
         description: "a non-negative canonical decimal string",
     })),
-    currency: codec_ts_2.CurrencyCodeV1Schema,
+    currency: codec_ts_2.CurrencyCodeSchema,
 }));
-const UsageAttachmentV1StructuralSchema = effect_1.Schema.Struct({
-    collection: codec_ts_2.CollectionV1Schema,
-    observations: effect_1.Schema.Array(exports.UsageObservationV1Schema),
+const UsageAttachmentStructuralSchema = effect_1.Schema.Struct({
+    collection: codec_ts_2.CollectionSchema,
+    observations: effect_1.Schema.Array(exports.UsageObservationSchema),
 });
-function isCanonicalUsageAttachmentV1(value) {
-    return (value.observations.length <= limits_ts_1.MAX_USAGE_OBSERVATIONS_V1 &&
-        payloadFits(value, limits_ts_1.MAX_USAGE_ATTACHMENT_BYTES_V1) &&
+function isCanonicalUsageAttachment(value) {
+    return (value.observations.length <= limits_ts_1.MAX_USAGE_OBSERVATIONS &&
+        payloadFits(value, limits_ts_1.MAX_USAGE_ATTACHMENT_BYTES) &&
         isAllowedCollection(value.collection, ["usage-observation"]) &&
         isStrictlyOrderedById(value.observations, (observation) => observation.usageObservationId));
 }
-exports.UsageAttachmentV1Schema = UsageAttachmentV1StructuralSchema.pipe(effect_1.Schema.filter(isCanonicalUsageAttachmentV1, {
-    identifier: "ObservabilityUsageAttachmentV1",
+exports.UsageAttachmentSchema = UsageAttachmentStructuralSchema.pipe(effect_1.Schema.filter(isCanonicalUsageAttachment, {
+    identifier: "ObservabilityUsageAttachment",
     description: "a canonical, bounded usage attachment",
 }));
-exports.AttemptTimingPhaseV1Schema = effect_1.Schema.Literal("attempt.setup", "sandbox.prepare", "agent.ensure", "eval.run", "agent.send", "sandbox.command", "assertion.evaluate", "verdict.fold", "attempt.teardown");
-exports.RunTimingPhaseV1Schema = effect_1.Schema.Literal("run.setup", "run.discovery", "run.plan", "run.dispatch", "run.teardown");
-const TimingOutcomeV1Schema = effect_1.Schema.Literal("completed", "failed", "cancelled", "interrupted", "unknown");
-exports.AttemptTimingIntervalV1Schema = effect_1.Schema.Struct({
-    intervalId: codec_ts_2.IntervalIdV1Schema,
-    phase: exports.AttemptTimingPhaseV1Schema,
-    label: codec_ts_2.StableLabelV1Schema,
-    startOffsetMs: codec_ts_2.NonNegativeSafeIntegerV1Schema,
-    durationMs: codec_ts_2.NonNegativeSafeIntegerV1Schema,
-    parentIntervalId: effect_1.Schema.NullOr(codec_ts_2.IntervalIdV1Schema),
-    outcome: TimingOutcomeV1Schema,
-    refs: codec_ts_2.AttemptTimingReferencesV1Schema,
+exports.AttemptTimingPhaseSchema = effect_1.Schema.Literal("attempt.setup", "sandbox.prepare", "agent.ensure", "eval.run", "agent.send", "sandbox.command", "assertion.evaluate", "verdict.fold", "attempt.teardown");
+exports.RunTimingPhaseSchema = effect_1.Schema.Literal("run.setup", "run.discovery", "run.plan", "run.dispatch", "run.teardown");
+const TimingOutcomeSchema = effect_1.Schema.Literal("completed", "failed", "cancelled", "interrupted", "unknown");
+exports.AttemptTimingIntervalSchema = effect_1.Schema.Struct({
+    intervalId: codec_ts_2.IntervalIdSchema,
+    phase: exports.AttemptTimingPhaseSchema,
+    label: codec_ts_2.StableLabelSchema,
+    startOffsetMs: codec_ts_2.NonNegativeSafeIntegerSchema,
+    durationMs: codec_ts_2.NonNegativeSafeIntegerSchema,
+    parentIntervalId: effect_1.Schema.NullOr(codec_ts_2.IntervalIdSchema),
+    outcome: TimingOutcomeSchema,
+    refs: codec_ts_2.AttemptTimingReferencesSchema,
 });
-exports.RunTimingIntervalV1Schema = effect_1.Schema.Struct({
-    intervalId: codec_ts_2.IntervalIdV1Schema,
-    phase: exports.RunTimingPhaseV1Schema,
-    label: codec_ts_2.StableLabelV1Schema,
-    startOffsetMs: codec_ts_2.NonNegativeSafeIntegerV1Schema,
-    durationMs: codec_ts_2.NonNegativeSafeIntegerV1Schema,
-    parentIntervalId: effect_1.Schema.NullOr(codec_ts_2.IntervalIdV1Schema),
-    outcome: TimingOutcomeV1Schema,
-    refs: codec_ts_2.RunTimingReferencesV1Schema,
+exports.RunTimingIntervalSchema = effect_1.Schema.Struct({
+    intervalId: codec_ts_2.IntervalIdSchema,
+    phase: exports.RunTimingPhaseSchema,
+    label: codec_ts_2.StableLabelSchema,
+    startOffsetMs: codec_ts_2.NonNegativeSafeIntegerSchema,
+    durationMs: codec_ts_2.NonNegativeSafeIntegerSchema,
+    parentIntervalId: effect_1.Schema.NullOr(codec_ts_2.IntervalIdSchema),
+    outcome: TimingOutcomeSchema,
+    refs: codec_ts_2.RunTimingReferencesSchema,
 });
 function timingEnd(start, duration) {
     const end = start + duration;
     return Number.isSafeInteger(end) ? end : undefined;
 }
-function isCanonicalTimingTreeV1(intervals) {
+function isCanonicalTimingTree(intervals) {
     if (!isStrictlyOrderedById(intervals, (interval) => interval.intervalId))
         return false;
     const byId = new Map(intervals.map((interval) => [interval.intervalId, interval]));
@@ -443,115 +443,115 @@ function isCanonicalTimingTreeV1(intervals) {
     }
     return true;
 }
-const AttemptTimingAttachmentV1StructuralSchema = effect_1.Schema.Struct({
-    collection: codec_ts_2.CollectionV1Schema,
-    intervals: effect_1.Schema.Array(exports.AttemptTimingIntervalV1Schema),
+const AttemptTimingAttachmentStructuralSchema = effect_1.Schema.Struct({
+    collection: codec_ts_2.CollectionSchema,
+    intervals: effect_1.Schema.Array(exports.AttemptTimingIntervalSchema),
 });
-function isCanonicalAttemptTimingAttachmentV1(value) {
-    return (value.intervals.length <= limits_ts_1.MAX_TIMING_INTERVALS_V1 &&
-        payloadFits(value, limits_ts_1.MAX_TIMING_ATTACHMENT_BYTES_V1) &&
+function isCanonicalAttemptTimingAttachment(value) {
+    return (value.intervals.length <= limits_ts_1.MAX_TIMING_INTERVALS &&
+        payloadFits(value, limits_ts_1.MAX_TIMING_ATTACHMENT_BYTES) &&
         isAllowedCollection(value.collection, ["timing-interval"]) &&
-        isCanonicalTimingTreeV1(value.intervals) &&
+        isCanonicalTimingTree(value.intervals) &&
         (!value.intervals.some((interval) => interval.outcome === "unknown") ||
             value.collection.state === "partial"));
 }
-exports.AttemptTimingAttachmentV1Schema = AttemptTimingAttachmentV1StructuralSchema.pipe(effect_1.Schema.filter(isCanonicalAttemptTimingAttachmentV1, {
-    identifier: "ObservabilityAttemptTimingAttachmentV1",
+exports.AttemptTimingAttachmentSchema = AttemptTimingAttachmentStructuralSchema.pipe(effect_1.Schema.filter(isCanonicalAttemptTimingAttachment, {
+    identifier: "ObservabilityAttemptTimingAttachment",
     description: "a canonical, bounded attempt timing tree",
 }));
-const RunTimingAttachmentV1StructuralSchema = effect_1.Schema.Struct({
-    collection: codec_ts_2.CollectionV1Schema,
-    intervals: effect_1.Schema.Array(exports.RunTimingIntervalV1Schema),
+const RunTimingAttachmentStructuralSchema = effect_1.Schema.Struct({
+    collection: codec_ts_2.CollectionSchema,
+    intervals: effect_1.Schema.Array(exports.RunTimingIntervalSchema),
 });
-function isCanonicalRunTimingAttachmentV1(value) {
-    return (value.intervals.length <= limits_ts_1.MAX_TIMING_INTERVALS_V1 &&
-        payloadFits(value, limits_ts_1.MAX_TIMING_ATTACHMENT_BYTES_V1) &&
+function isCanonicalRunTimingAttachment(value) {
+    return (value.intervals.length <= limits_ts_1.MAX_TIMING_INTERVALS &&
+        payloadFits(value, limits_ts_1.MAX_TIMING_ATTACHMENT_BYTES) &&
         isAllowedCollection(value.collection, ["timing-interval"]) &&
-        isCanonicalTimingTreeV1(value.intervals) &&
+        isCanonicalTimingTree(value.intervals) &&
         (!value.intervals.some((interval) => interval.outcome === "unknown") ||
             value.collection.state === "partial"));
 }
-exports.RunTimingAttachmentV1Schema = RunTimingAttachmentV1StructuralSchema.pipe(effect_1.Schema.filter(isCanonicalRunTimingAttachmentV1, {
-    identifier: "ObservabilityRunTimingAttachmentV1",
+exports.RunTimingAttachmentSchema = RunTimingAttachmentStructuralSchema.pipe(effect_1.Schema.filter(isCanonicalRunTimingAttachment, {
+    identifier: "ObservabilityRunTimingAttachment",
     description: "a canonical, bounded run timing tree",
 }));
-exports.AttemptDiagnosticPhaseV1Schema = effect_1.Schema.Literal("attempt.setup", "sandbox.prepare", "agent.ensure", "eval.run", "agent.send", "sandbox.command", "assertion.evaluate", "verdict.fold", "attempt.teardown", "collection");
-exports.RunDiagnosticPhaseV1Schema = effect_1.Schema.Literal("run.setup", "run.discovery", "run.plan", "run.dispatch", "run.teardown", "collection");
-exports.SourcePositionV1Schema = effect_1.Schema.Struct({
-    line: codec_ts_2.PositiveSafeIntegerV1Schema,
-    column: codec_ts_2.PositiveSafeIntegerV1Schema,
+exports.AttemptDiagnosticPhaseSchema = effect_1.Schema.Literal("attempt.setup", "sandbox.prepare", "agent.ensure", "eval.run", "agent.send", "sandbox.command", "assertion.evaluate", "verdict.fold", "attempt.teardown", "collection");
+exports.RunDiagnosticPhaseSchema = effect_1.Schema.Literal("run.setup", "run.discovery", "run.plan", "run.dispatch", "run.teardown", "collection");
+exports.SourcePositionSchema = effect_1.Schema.Struct({
+    line: codec_ts_2.PositiveSafeIntegerSchema,
+    column: codec_ts_2.PositiveSafeIntegerSchema,
 });
-exports.SourceFrameV1Schema = effect_1.Schema.Struct({
+exports.SourceFrameSchema = effect_1.Schema.Struct({
     sourceItemId: codec_ts_1.SourceFileItemIdSchema,
     sha256: codec_ts_1.Sha256DigestSchema,
-    start: exports.SourcePositionV1Schema,
-    end: exports.SourcePositionV1Schema,
+    start: exports.SourcePositionSchema,
+    end: exports.SourcePositionSchema,
 });
-const SafeDiagnosticCauseV1Schema = effect_1.Schema.Struct({
-    code: codec_ts_2.SafeIdentifierV1Schema,
-    summary: (0, codec_ts_2.boundedSafeTextV1Schema)(limits_ts_1.MAX_DIAGNOSTIC_CAUSE_SUMMARY_BYTES_V1),
+const SafeDiagnosticCauseSchema = effect_1.Schema.Struct({
+    code: codec_ts_2.SafeIdentifierSchema,
+    summary: (0, codec_ts_2.boundedSafeTextSchema)(limits_ts_1.MAX_DIAGNOSTIC_CAUSE_SUMMARY_BYTES),
 });
-const DiagnosticRedactionV1Schema = effect_1.Schema.Union(effect_1.Schema.Struct({ state: effect_1.Schema.Literal("none") }), effect_1.Schema.Struct({
+const DiagnosticRedactionSchema = effect_1.Schema.Union(effect_1.Schema.Struct({ state: effect_1.Schema.Literal("none") }), effect_1.Schema.Struct({
     state: effect_1.Schema.Literal("applied"),
-    summaryReplacements: codec_ts_2.NonNegativeSafeIntegerV1Schema,
-    causeReplacements: codec_ts_2.NonNegativeSafeIntegerV1Schema,
-    contextReplacements: codec_ts_2.NonNegativeSafeIntegerV1Schema,
+    summaryReplacements: codec_ts_2.NonNegativeSafeIntegerSchema,
+    causeReplacements: codec_ts_2.NonNegativeSafeIntegerSchema,
+    contextReplacements: codec_ts_2.NonNegativeSafeIntegerSchema,
 }));
-const DiagnosticLimitContextV1Schema = effect_1.Schema.Struct({
+const DiagnosticLimitContextSchema = effect_1.Schema.Struct({
     kind: effect_1.Schema.Literal("limit"),
     limit: effect_1.Schema.Literal("conversation-items", "commands", "usage-observations", "timing-intervals", "diagnostics", "command-stream-bytes"),
-    maximum: codec_ts_2.NonNegativeSafeIntegerV1Schema,
-    observedAtLeast: codec_ts_2.NonNegativeSafeIntegerV1Schema,
+    maximum: codec_ts_2.NonNegativeSafeIntegerSchema,
+    observedAtLeast: codec_ts_2.NonNegativeSafeIntegerSchema,
 });
-const DiagnosticProviderContextV1Schema = effect_1.Schema.Struct({
+const DiagnosticProviderContextSchema = effect_1.Schema.Struct({
     kind: effect_1.Schema.Literal("provider"),
-    provider: codec_ts_2.SafeIdentifierV1Schema,
+    provider: codec_ts_2.SafeIdentifierSchema,
 });
 /**
  * The entity context is a single target rather than an array. Schema's generic
  * ref-array constructors cannot express the exclusion while preserving the
  * direct triple, so these declarations keep the exact input check local.
  */
-const AttemptDiagnosticEntityContextV1Schema = effect_1.Schema.Struct({
+const AttemptDiagnosticEntityContextSchema = effect_1.Schema.Struct({
     kind: effect_1.Schema.Literal("entity"),
-    target: codec_ts_2.AttemptReferenceTargetV1Schema.pipe(effect_1.Schema.filter((target) => target.family !== "niceeval.diagnostics/v1")),
+    target: codec_ts_2.AttemptReferenceTargetSchema.pipe(effect_1.Schema.filter((target) => target.kind !== "diagnostic")),
 });
-const RunDiagnosticEntityContextV1Schema = effect_1.Schema.Struct({
+const RunDiagnosticEntityContextSchema = effect_1.Schema.Struct({
     kind: effect_1.Schema.Literal("entity"),
-    target: codec_ts_2.RunReferenceTargetV1Schema.pipe(effect_1.Schema.filter((target) => target.family !== "niceeval.diagnostics/v1")),
+    target: codec_ts_2.RunReferenceTargetSchema.pipe(effect_1.Schema.filter((target) => target.kind !== "diagnostic")),
 });
-const AttemptDiagnosticContextExactV1Schema = effect_1.Schema.Union(AttemptDiagnosticEntityContextV1Schema, DiagnosticLimitContextV1Schema, DiagnosticProviderContextV1Schema);
-const RunDiagnosticContextExactV1Schema = effect_1.Schema.Union(RunDiagnosticEntityContextV1Schema, DiagnosticLimitContextV1Schema, DiagnosticProviderContextV1Schema);
-exports.AttemptDiagnosticV1Schema = effect_1.Schema.Struct({
-    diagnosticId: codec_ts_2.DiagnosticIdV1Schema,
+const AttemptDiagnosticContextExactSchema = effect_1.Schema.Union(AttemptDiagnosticEntityContextSchema, DiagnosticLimitContextSchema, DiagnosticProviderContextSchema);
+const RunDiagnosticContextExactSchema = effect_1.Schema.Union(RunDiagnosticEntityContextSchema, DiagnosticLimitContextSchema, DiagnosticProviderContextSchema);
+exports.AttemptDiagnosticSchema = effect_1.Schema.Struct({
+    diagnosticId: codec_ts_2.DiagnosticIdSchema,
     kind: effect_1.Schema.Literal("advisory", "execution-error"),
-    code: codec_ts_2.SafeIdentifierV1Schema,
-    phase: exports.AttemptDiagnosticPhaseV1Schema,
-    summary: (0, codec_ts_2.boundedSafeTextV1Schema)(limits_ts_1.MAX_DIAGNOSTIC_SUMMARY_BYTES_V1),
-    causes: effect_1.Schema.Array(SafeDiagnosticCauseV1Schema),
-    context: effect_1.Schema.Array(AttemptDiagnosticContextExactV1Schema),
-    redaction: DiagnosticRedactionV1Schema,
-    sourceFrame: effect_1.Schema.NullOr(exports.SourceFrameV1Schema),
-    refs: codec_ts_2.AttemptDiagnosticsReferencesV1Schema,
+    code: codec_ts_2.SafeIdentifierSchema,
+    phase: exports.AttemptDiagnosticPhaseSchema,
+    summary: (0, codec_ts_2.boundedSafeTextSchema)(limits_ts_1.MAX_DIAGNOSTIC_SUMMARY_BYTES),
+    causes: effect_1.Schema.Array(SafeDiagnosticCauseSchema),
+    context: effect_1.Schema.Array(AttemptDiagnosticContextExactSchema),
+    redaction: DiagnosticRedactionSchema,
+    sourceFrame: effect_1.Schema.NullOr(exports.SourceFrameSchema),
+    refs: codec_ts_2.AttemptDiagnosticsReferencesSchema,
 });
-exports.RunDiagnosticV1Schema = effect_1.Schema.Struct({
-    diagnosticId: codec_ts_2.DiagnosticIdV1Schema,
+exports.RunDiagnosticSchema = effect_1.Schema.Struct({
+    diagnosticId: codec_ts_2.DiagnosticIdSchema,
     kind: effect_1.Schema.Literal("advisory", "execution-error"),
-    code: codec_ts_2.SafeIdentifierV1Schema,
-    phase: exports.RunDiagnosticPhaseV1Schema,
-    summary: (0, codec_ts_2.boundedSafeTextV1Schema)(limits_ts_1.MAX_DIAGNOSTIC_SUMMARY_BYTES_V1),
-    causes: effect_1.Schema.Array(SafeDiagnosticCauseV1Schema),
-    context: effect_1.Schema.Array(RunDiagnosticContextExactV1Schema),
-    redaction: DiagnosticRedactionV1Schema,
-    sourceFrame: effect_1.Schema.NullOr(exports.SourceFrameV1Schema),
-    refs: codec_ts_2.RunDiagnosticsReferencesV1Schema,
+    code: codec_ts_2.SafeIdentifierSchema,
+    phase: exports.RunDiagnosticPhaseSchema,
+    summary: (0, codec_ts_2.boundedSafeTextSchema)(limits_ts_1.MAX_DIAGNOSTIC_SUMMARY_BYTES),
+    causes: effect_1.Schema.Array(SafeDiagnosticCauseSchema),
+    context: effect_1.Schema.Array(RunDiagnosticContextExactSchema),
+    redaction: DiagnosticRedactionSchema,
+    sourceFrame: effect_1.Schema.NullOr(exports.SourceFrameSchema),
+    refs: codec_ts_2.RunDiagnosticsReferencesSchema,
 });
 function sourcePositionBeforeOrEqual(left, right) {
     return left.line < right.line || (left.line === right.line && left.column <= right.column);
 }
 function hasValidDiagnosticShape(diagnostic) {
-    if (diagnostic.causes.length > limits_ts_1.MAX_DIAGNOSTIC_CAUSES_V1 ||
-        diagnostic.context.length > limits_ts_1.MAX_DIAGNOSTIC_CONTEXT_ITEMS_V1) {
+    if (diagnostic.causes.length > limits_ts_1.MAX_DIAGNOSTIC_CAUSES ||
+        diagnostic.context.length > limits_ts_1.MAX_DIAGNOSTIC_CONTEXT_ITEMS) {
         return false;
     }
     if (diagnostic.redaction.state === "applied" &&
@@ -563,63 +563,68 @@ function hasValidDiagnosticShape(diagnostic) {
     return (diagnostic.sourceFrame === null ||
         sourcePositionBeforeOrEqual(diagnostic.sourceFrame.start, diagnostic.sourceFrame.end));
 }
-const AttemptDiagnosticsAttachmentV1StructuralSchema = effect_1.Schema.Struct({
-    collection: codec_ts_2.CollectionV1Schema,
-    diagnostics: effect_1.Schema.Array(exports.AttemptDiagnosticV1Schema),
+const AttemptDiagnosticsAttachmentStructuralSchema = effect_1.Schema.Struct({
+    collection: codec_ts_2.CollectionSchema,
+    diagnostics: effect_1.Schema.Array(exports.AttemptDiagnosticSchema),
 });
-function isCanonicalAttemptDiagnosticsAttachmentV1(value) {
-    return (value.diagnostics.length <= limits_ts_1.MAX_DIAGNOSTICS_V1 &&
-        payloadFits(value, limits_ts_1.MAX_DIAGNOSTICS_ATTACHMENT_BYTES_V1) &&
+function isCanonicalAttemptDiagnosticsAttachment(value) {
+    return (value.diagnostics.length <= limits_ts_1.MAX_DIAGNOSTICS &&
+        payloadFits(value, limits_ts_1.MAX_DIAGNOSTICS_ATTACHMENT_BYTES) &&
         isAllowedCollection(value.collection, ["diagnostic"]) &&
         isStrictlyOrderedById(value.diagnostics, (diagnostic) => diagnostic.diagnosticId) &&
         value.diagnostics.every(hasValidDiagnosticShape));
 }
-exports.AttemptDiagnosticsAttachmentV1Schema = AttemptDiagnosticsAttachmentV1StructuralSchema.pipe(effect_1.Schema.filter(isCanonicalAttemptDiagnosticsAttachmentV1, {
-    identifier: "ObservabilityAttemptDiagnosticsAttachmentV1",
+exports.AttemptDiagnosticsAttachmentSchema = AttemptDiagnosticsAttachmentStructuralSchema.pipe(effect_1.Schema.filter(isCanonicalAttemptDiagnosticsAttachment, {
+    identifier: "ObservabilityAttemptDiagnosticsAttachment",
     description: "a canonical, bounded attempt diagnostics attachment",
 }));
-const RunDiagnosticsAttachmentV1StructuralSchema = effect_1.Schema.Struct({
-    collection: codec_ts_2.CollectionV1Schema,
-    diagnostics: effect_1.Schema.Array(exports.RunDiagnosticV1Schema),
+const RunDiagnosticsAttachmentStructuralSchema = effect_1.Schema.Struct({
+    collection: codec_ts_2.CollectionSchema,
+    diagnostics: effect_1.Schema.Array(exports.RunDiagnosticSchema),
 });
-function isCanonicalRunDiagnosticsAttachmentV1(value) {
-    return (value.diagnostics.length <= limits_ts_1.MAX_DIAGNOSTICS_V1 &&
-        payloadFits(value, limits_ts_1.MAX_DIAGNOSTICS_ATTACHMENT_BYTES_V1) &&
+function isCanonicalRunDiagnosticsAttachment(value) {
+    return (value.diagnostics.length <= limits_ts_1.MAX_DIAGNOSTICS &&
+        payloadFits(value, limits_ts_1.MAX_DIAGNOSTICS_ATTACHMENT_BYTES) &&
         isAllowedCollection(value.collection, ["diagnostic"]) &&
         isStrictlyOrderedById(value.diagnostics, (diagnostic) => diagnostic.diagnosticId) &&
         value.diagnostics.every(hasValidDiagnosticShape));
 }
-exports.RunDiagnosticsAttachmentV1Schema = RunDiagnosticsAttachmentV1StructuralSchema.pipe(effect_1.Schema.filter(isCanonicalRunDiagnosticsAttachmentV1, {
-    identifier: "ObservabilityRunDiagnosticsAttachmentV1",
+exports.RunDiagnosticsAttachmentSchema = RunDiagnosticsAttachmentStructuralSchema.pipe(effect_1.Schema.filter(isCanonicalRunDiagnosticsAttachment, {
+    identifier: "ObservabilityRunDiagnosticsAttachment",
     description: "a canonical, bounded run diagnostics attachment",
 }));
-const [attemptConversationFamilySchemaIdV1, attemptCommandsFamilySchemaIdV1, attemptUsageFamilySchemaIdV1, attemptTimingFamilySchemaIdV1, attemptDiagnosticsFamilySchemaIdV1,] = model_ts_1.ATTEMPT_OBSERVABILITY_FAMILY_SCHEMA_IDS_V1;
-const [runTimingFamilySchemaIdV1, runDiagnosticsFamilySchemaIdV1] = model_ts_1.RUN_OBSERVABILITY_FAMILY_SCHEMA_IDS_V1;
+const attemptConversationFamilySchemaId = "niceeval.observability";
+const attemptCommandsFamilySchemaId = "niceeval.observability";
+const attemptUsageFamilySchemaId = "niceeval.observability";
+const attemptTimingFamilySchemaId = "niceeval.observability";
+const attemptDiagnosticsFamilySchemaId = "niceeval.observability";
+const runTimingFamilySchemaId = "niceeval.observability";
+const runDiagnosticsFamilySchemaId = "niceeval.observability";
 /** Semantic cross-family facts intentionally remain independent of writes. */
-function makeAttemptConversationAttachmentFamilyValidationV1(payload) {
+function makeAttemptConversationAttachmentFamilyValidation(payload) {
     const entities = [
         ...payload.turns.map((turn) => Object.freeze({
-            family: attemptConversationFamilySchemaIdV1,
+            family: attemptConversationFamilySchemaId,
             kind: "turn",
             id: turn.turnId,
         })),
         ...payload.items.map((item) => Object.freeze({
-            family: attemptConversationFamilySchemaIdV1,
+            family: attemptConversationFamilySchemaId,
             kind: "item",
             id: item.itemId,
         })),
         ...payload.items.flatMap((item) => item.kind === "tool-call"
             ? [
                 Object.freeze({
-                    family: attemptConversationFamilySchemaIdV1,
+                    family: attemptConversationFamilySchemaId,
                     kind: "call",
                     id: item.callId,
                 }),
             ]
             : []),
     ];
-    return (0, validation_ts_1.makeAttemptObservabilityFamilyValidationV1)({
-        schemaId: attemptConversationFamilySchemaIdV1,
+    return (0, validation_ts_1.makeAttemptObservabilityFamilyValidation)({
+        schemaId: attemptConversationFamilySchemaId,
         entities,
         references: [
             ...payload.turns.map((turn) => Object.freeze({ sourceId: turn.turnId, refs: turn.refs })),
@@ -627,22 +632,22 @@ function makeAttemptConversationAttachmentFamilyValidationV1(payload) {
         ],
     });
 }
-function makeAttemptCommandsAttachmentFamilyValidationV1(input) {
-    return (0, validation_ts_1.makeAttemptObservabilityFamilyValidationV1)({
-        schemaId: attemptCommandsFamilySchemaIdV1,
+function makeAttemptCommandsAttachmentFamilyValidation(input) {
+    return (0, validation_ts_1.makeAttemptObservabilityFamilyValidation)({
+        schemaId: attemptCommandsFamilySchemaId,
         entities: input.commands.map((command) => Object.freeze({
-            family: attemptCommandsFamilySchemaIdV1,
+            family: attemptCommandsFamilySchemaId,
             kind: "command",
             id: command.commandId,
         })),
         references: input.commands.map((command) => Object.freeze({ sourceId: command.commandId, refs: command.refs })),
     });
 }
-function makeAttemptUsageAttachmentFamilyValidationV1(payload) {
-    return (0, validation_ts_1.makeAttemptObservabilityFamilyValidationV1)({
-        schemaId: attemptUsageFamilySchemaIdV1,
+function makeAttemptUsageAttachmentFamilyValidation(payload) {
+    return (0, validation_ts_1.makeAttemptObservabilityFamilyValidation)({
+        schemaId: attemptUsageFamilySchemaId,
         entities: payload.observations.map((observation) => Object.freeze({
-            family: attemptUsageFamilySchemaIdV1,
+            family: attemptUsageFamilySchemaId,
             kind: "usage-observation",
             id: observation.usageObservationId,
         })),
@@ -652,44 +657,44 @@ function makeAttemptUsageAttachmentFamilyValidationV1(payload) {
         })),
     });
 }
-function makeAttemptTimingAttachmentFamilyValidationV1(payload) {
-    return (0, validation_ts_1.makeAttemptObservabilityFamilyValidationV1)({
-        schemaId: attemptTimingFamilySchemaIdV1,
+function makeAttemptTimingAttachmentFamilyValidation(payload) {
+    return (0, validation_ts_1.makeAttemptObservabilityFamilyValidation)({
+        schemaId: attemptTimingFamilySchemaId,
         entities: payload.intervals.map((interval) => Object.freeze({
-            family: attemptTimingFamilySchemaIdV1,
+            family: attemptTimingFamilySchemaId,
             kind: "interval",
             id: interval.intervalId,
         })),
         references: payload.intervals.map((interval) => Object.freeze({ sourceId: interval.intervalId, refs: interval.refs })),
     });
 }
-function makeAttemptDiagnosticsAttachmentFamilyValidationV1(payload) {
-    return (0, validation_ts_1.makeAttemptObservabilityFamilyValidationV1)({
-        schemaId: attemptDiagnosticsFamilySchemaIdV1,
+function makeAttemptDiagnosticsAttachmentFamilyValidation(payload) {
+    return (0, validation_ts_1.makeAttemptObservabilityFamilyValidation)({
+        schemaId: attemptDiagnosticsFamilySchemaId,
         entities: payload.diagnostics.map((diagnostic) => Object.freeze({
-            family: attemptDiagnosticsFamilySchemaIdV1,
+            family: attemptDiagnosticsFamilySchemaId,
             kind: "diagnostic",
             id: diagnostic.diagnosticId,
         })),
         references: payload.diagnostics.map((diagnostic) => Object.freeze({ sourceId: diagnostic.diagnosticId, refs: diagnostic.refs })),
     });
 }
-function makeRunTimingAttachmentFamilyValidationV1(payload) {
-    return (0, validation_ts_1.makeRunObservabilityFamilyValidationV1)({
-        schemaId: runTimingFamilySchemaIdV1,
+function makeRunTimingAttachmentFamilyValidation(payload) {
+    return (0, validation_ts_1.makeRunObservabilityFamilyValidation)({
+        schemaId: runTimingFamilySchemaId,
         entities: payload.intervals.map((interval) => Object.freeze({
-            family: runTimingFamilySchemaIdV1,
+            family: runTimingFamilySchemaId,
             kind: "interval",
             id: interval.intervalId,
         })),
         references: payload.intervals.map((interval) => Object.freeze({ sourceId: interval.intervalId, refs: interval.refs })),
     });
 }
-function makeRunDiagnosticsAttachmentFamilyValidationV1(payload) {
-    return (0, validation_ts_1.makeRunObservabilityFamilyValidationV1)({
-        schemaId: runDiagnosticsFamilySchemaIdV1,
+function makeRunDiagnosticsAttachmentFamilyValidation(payload) {
+    return (0, validation_ts_1.makeRunObservabilityFamilyValidation)({
+        schemaId: runDiagnosticsFamilySchemaId,
         entities: payload.diagnostics.map((diagnostic) => Object.freeze({
-            family: runDiagnosticsFamilySchemaIdV1,
+            family: runDiagnosticsFamilySchemaId,
             kind: "diagnostic",
             id: diagnostic.diagnosticId,
         })),