niceeval 0.12.2-canary.31 → 0.13.0

package/dist/o11y/record/family-projectors.js

@@ -11,8 +11,14 @@ const __niceevalExport3 = __niceevalCanonical["attemptTimingProjector"];
 export { __niceevalExport3 as attemptTimingProjector };
 const __niceevalExport4 = __niceevalCanonical["attemptUsageProjector"];
 export { __niceevalExport4 as attemptUsageProjector };
-const __niceevalExport5 = __niceevalCanonical["runDiagnosticsProjector"];
-export { __niceevalExport5 as runDiagnosticsProjector };
-const __niceevalExport6 = __niceevalCanonical["runTimingProjector"];
-export { __niceevalExport6 as runTimingProjector };
+const __niceevalExport5 = __niceevalCanonical["projectAttemptCommands"];
+export { __niceevalExport5 as projectAttemptCommands };
+const __niceevalExport6 = __niceevalCanonical["projectAttemptObservabilityAttachment"];
+export { __niceevalExport6 as projectAttemptObservabilityAttachment };
+const __niceevalExport7 = __niceevalCanonical["projectRunObservabilityAttachment"];
+export { __niceevalExport7 as projectRunObservabilityAttachment };
+const __niceevalExport8 = __niceevalCanonical["runDiagnosticsProjector"];
+export { __niceevalExport8 as runDiagnosticsProjector };
+const __niceevalExport9 = __niceevalCanonical["runTimingProjector"];
+export { __niceevalExport9 as runTimingProjector };
 //# sourceMappingURL=family-projectors.js.map

package/dist/o11y/record/family-writers.cjs

@@ -1,371 +1,242 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NormalizedCommandsCaptureV1Schema = exports.NormalizedCommandStreamCaptureV1Schema = exports.builtInObservabilityAttachmentFamiliesV1 = exports.runDiagnosticsAttachmentV1 = exports.runTimingAttachmentV1 = exports.attemptDiagnosticsAttachmentV1 = exports.attemptTimingAttachmentV1 = exports.attemptUsageAttachmentV1 = exports.attemptCommandsAttachmentV1 = exports.attemptConversationAttachmentV1 = exports.runDiagnosticsAttachmentDefinitionV1 = exports.runTimingAttachmentDefinitionV1 = exports.attemptDiagnosticsAttachmentDefinitionV1 = exports.attemptTimingAttachmentDefinitionV1 = exports.attemptUsageAttachmentDefinitionV1 = exports.attemptCommandsAttachmentDefinitionV1 = exports.attemptConversationAttachmentDefinitionV1 = void 0;
-exports.commandAttachmentBlobRefsV1 = commandAttachmentBlobRefsV1;
-exports.createAttemptConversationAttachmentWriteV1 = createAttemptConversationAttachmentWriteV1;
-exports.createAttemptUsageAttachmentWriteV1 = createAttemptUsageAttachmentWriteV1;
-exports.createAttemptTimingAttachmentWriteV1 = createAttemptTimingAttachmentWriteV1;
-exports.createAttemptDiagnosticsAttachmentWriteV1 = createAttemptDiagnosticsAttachmentWriteV1;
-exports.createRunTimingAttachmentWriteV1 = createRunTimingAttachmentWriteV1;
-exports.createRunDiagnosticsAttachmentWriteV1 = createRunDiagnosticsAttachmentWriteV1;
-exports.createAttemptCommandsAttachmentWriteV1 = createAttemptCommandsAttachmentWriteV1;
-exports.createAttemptObservabilityAttachmentWritesV1 = createAttemptObservabilityAttachmentWritesV1;
-exports.createRunObservabilityAttachmentWritesV1 = createRunObservabilityAttachmentWritesV1;
-exports.validateObservabilityAttachmentWriteBundlesV1 = validateObservabilityAttachmentWriteBundlesV1;
+exports.runObservabilityAttachmentWrite = exports.attemptObservabilityAttachmentWrite = void 0;
+exports.createAttemptObservabilityAttachmentWrite = createAttemptObservabilityAttachmentWrite;
+exports.createRunObservabilityAttachmentWrite = createRunObservabilityAttachmentWrite;
+exports.createAttemptObservabilityAttachmentWrites = createAttemptObservabilityAttachmentWrites;
+exports.createRunObservabilityAttachmentWrites = createRunObservabilityAttachmentWrites;
+exports.validateObservabilityAttachmentWriteBundles = validateObservabilityAttachmentWriteBundles;
+const node_crypto_1 = require("node:crypto");
 const effect_1 = require("effect");
 const index_ts_1 = require("../../record/attachment/index.cjs");
 const internal_ts_1 = require("../../record/attachment/internal.cjs");
-const codec_ts_1 = require("./codec.cjs");
+const core_ts_1 = require("../../record/codec/core.cjs");
+const catalog_ts_1 = require("../../record/family/catalog.cjs");
+const observability_ts_1 = require("../../record/family/observability.cjs");
 const limits_ts_1 = require("./limits.cjs");
 const model_ts_1 = require("./model.cjs");
-const families_ts_1 = require("./families.cjs");
-const validation_ts_1 = require("./validation.cjs");
-function attachmentInputInvalid(family) {
-    return Object.freeze({
-        code: "observability-attachment-input-invalid",
-        family,
-    });
-}
-function requireAttachmentCapability(result, message) {
-    if (effect_1.Either.isLeft(result))
-        throw new Error(message);
-    return result.right;
-}
-function freezeArray(values) {
-    return Object.freeze([...values]);
-}
-function commandAttachmentBlobRefsV1(payload) {
-    const refs = [];
-    for (const command of payload.commands) {
-        for (const stream of [command.result.stdout, command.result.stderr]) {
-            if (stream.storage.kind === "blob")
-                refs.push(stream.storage.ref);
-        }
+const errors_ts_1 = require("./errors.cjs");
+function invalid() {
+    return Object.freeze({ code: "observability-attachment-input-invalid", family: "observability" });
+}
+function fixedTarget(target) {
+    switch (target) {
+        case "conversation-item":
+        case "conversation-text": return "conversation";
+        case "command-manifest":
+        case "command-stdout":
+        case "command-stderr": return "command";
+        case "usage-observation": return "usage";
+        case "timing-interval": return "timing";
+        case "diagnostic": return "diagnostic";
     }
-    return freezeArray(refs);
-}
-function noObservabilityBlobRefs() {
-    return Object.freeze([]);
 }
-exports.attemptConversationAttachmentDefinitionV1 = requireAttachmentCapability((0, internal_ts_1.defineBuiltinJsonRecordAttachment)({
-    owner: "attempt",
-    name: "niceeval.conversation",
-    schemaId: "niceeval.conversation/v1",
-    schema: families_ts_1.ConversationAttachmentV1Schema,
-    blobRefs: noObservabilityBlobRefs,
-}), "Attempt conversation v1 RecordAttachment definition must be valid");
-exports.attemptCommandsAttachmentDefinitionV1 = requireAttachmentCapability((0, internal_ts_1.defineBuiltinJsonRecordAttachment)({
-    owner: "attempt",
-    name: "niceeval.commands",
-    schemaId: "niceeval.commands/v1",
-    schema: families_ts_1.CommandsAttachmentV1Schema,
-    blobRefs: commandAttachmentBlobRefsV1,
-}), "Attempt commands v1 RecordAttachment definition must be valid");
-exports.attemptUsageAttachmentDefinitionV1 = requireAttachmentCapability((0, internal_ts_1.defineBuiltinJsonRecordAttachment)({
-    owner: "attempt",
-    name: "niceeval.usage",
-    schemaId: "niceeval.usage/v1",
-    schema: families_ts_1.UsageAttachmentV1Schema,
-    blobRefs: noObservabilityBlobRefs,
-}), "Attempt usage v1 RecordAttachment definition must be valid");
-exports.attemptTimingAttachmentDefinitionV1 = requireAttachmentCapability((0, internal_ts_1.defineBuiltinJsonRecordAttachment)({
-    owner: "attempt",
-    name: "niceeval.timing",
-    schemaId: "niceeval.timing/v1",
-    schema: families_ts_1.AttemptTimingAttachmentV1Schema,
-    blobRefs: noObservabilityBlobRefs,
-}), "Attempt timing v1 RecordAttachment definition must be valid");
-exports.attemptDiagnosticsAttachmentDefinitionV1 = requireAttachmentCapability((0, internal_ts_1.defineBuiltinJsonRecordAttachment)({
-    owner: "attempt",
-    name: "niceeval.diagnostics",
-    schemaId: "niceeval.diagnostics/v1",
-    schema: families_ts_1.AttemptDiagnosticsAttachmentV1Schema,
-    blobRefs: noObservabilityBlobRefs,
-}), "Attempt diagnostics v1 RecordAttachment definition must be valid");
-exports.runTimingAttachmentDefinitionV1 = requireAttachmentCapability((0, internal_ts_1.defineBuiltinJsonRecordAttachment)({
-    owner: "run",
-    name: "niceeval.timing",
-    schemaId: "niceeval.timing/v1",
-    schema: families_ts_1.RunTimingAttachmentV1Schema,
-    blobRefs: noObservabilityBlobRefs,
-}), "Run timing v1 RecordAttachment definition must be valid");
-exports.runDiagnosticsAttachmentDefinitionV1 = requireAttachmentCapability((0, internal_ts_1.defineBuiltinJsonRecordAttachment)({
-    owner: "run",
-    name: "niceeval.diagnostics",
-    schemaId: "niceeval.diagnostics/v1",
-    schema: families_ts_1.RunDiagnosticsAttachmentV1Schema,
-    blobRefs: noObservabilityBlobRefs,
-}), "Run diagnostics v1 RecordAttachment definition must be valid");
-exports.attemptConversationAttachmentV1 = requireAttachmentCapability((0, index_ts_1.defineRecordAttachmentFamily)({
-    current: exports.attemptConversationAttachmentDefinitionV1,
-    migrations: [],
-}), "Attempt conversation v1 RecordAttachment family must be valid");
-exports.attemptCommandsAttachmentV1 = requireAttachmentCapability((0, index_ts_1.defineRecordAttachmentFamily)({
-    current: exports.attemptCommandsAttachmentDefinitionV1,
-    migrations: [],
-}), "Attempt commands v1 RecordAttachment family must be valid");
-exports.attemptUsageAttachmentV1 = requireAttachmentCapability((0, index_ts_1.defineRecordAttachmentFamily)({
-    current: exports.attemptUsageAttachmentDefinitionV1,
-    migrations: [],
-}), "Attempt usage v1 RecordAttachment family must be valid");
-exports.attemptTimingAttachmentV1 = requireAttachmentCapability((0, index_ts_1.defineRecordAttachmentFamily)({
-    current: exports.attemptTimingAttachmentDefinitionV1,
-    migrations: [],
-}), "Attempt timing v1 RecordAttachment family must be valid");
-exports.attemptDiagnosticsAttachmentV1 = requireAttachmentCapability((0, index_ts_1.defineRecordAttachmentFamily)({
-    current: exports.attemptDiagnosticsAttachmentDefinitionV1,
-    migrations: [],
-}), "Attempt diagnostics v1 RecordAttachment family must be valid");
-exports.runTimingAttachmentV1 = requireAttachmentCapability((0, index_ts_1.defineRecordAttachmentFamily)({
-    current: exports.runTimingAttachmentDefinitionV1,
-    migrations: [],
-}), "Run timing v1 RecordAttachment family must be valid");
-exports.runDiagnosticsAttachmentV1 = requireAttachmentCapability((0, index_ts_1.defineRecordAttachmentFamily)({
-    current: exports.runDiagnosticsAttachmentDefinitionV1,
-    migrations: [],
-}), "Run diagnostics v1 RecordAttachment family must be valid");
-exports.builtInObservabilityAttachmentFamiliesV1 = Object.freeze([
-    exports.attemptConversationAttachmentV1,
-    exports.attemptCommandsAttachmentV1,
-    exports.attemptUsageAttachmentV1,
-    exports.attemptTimingAttachmentV1,
-    exports.attemptDiagnosticsAttachmentV1,
-    exports.runTimingAttachmentV1,
-    exports.runDiagnosticsAttachmentV1,
-]);
-exports.NormalizedCommandStreamCaptureV1Schema = effect_1.Schema.Struct({
-    text: codec_ts_1.SafeTextV1Schema,
-    totalSafeUtf8Bytes: codec_ts_1.NonNegativeSafeIntegerV1Schema,
-});
-const NormalizedCommandResultCaptureV1Schema = effect_1.Schema.Struct({
-    outcome: families_ts_1.CommandOutcomeV1Schema,
-    stdout: exports.NormalizedCommandStreamCaptureV1Schema,
-    stderr: exports.NormalizedCommandStreamCaptureV1Schema,
-});
-const NormalizedCommandObservationCaptureV1Schema = effect_1.Schema.Struct({
-    commandId: codec_ts_1.CommandIdV1Schema,
-    manifest: families_ts_1.CommandManifestV1Schema,
-    result: NormalizedCommandResultCaptureV1Schema,
-    refs: codec_ts_1.CommandsReferencesV1Schema,
-});
-const NormalizedCommandsCaptureV1StructuralSchema = effect_1.Schema.Struct({
-    collection: codec_ts_1.CollectionV1Schema,
-    commands: effect_1.Schema.Array(NormalizedCommandObservationCaptureV1Schema),
-});
-function retainedTextBytes(stream) {
-    return new TextEncoder().encode(stream.text).byteLength;
-}
-function isAllowedCommandsCollection(collection) {
-    return collection.limitations.every((limitation) => ["command-manifest", "command-stdout", "command-stderr"].some((target) => (0, model_ts_1.limitationTargetV1)(limitation) === target));
-}
-function hasExactStreamTruncation(collection, commandId, stream, retainedBytes, totalSafeUtf8Bytes) {
-    const omittedBytes = totalSafeUtf8Bytes - retainedBytes;
-    return collection.limitations.some((limitation) => limitation.code === "stream-truncated" &&
-        limitation.commandId === commandId &&
-        limitation.stream === stream &&
-        limitation.retainedBytes === retainedBytes &&
-        limitation.omittedBytes === omittedBytes);
-}
-function commandManifestTextLengths(manifest) {
-    const encoder = new TextEncoder();
-    const invocation = manifest.invocation.kind === "argv"
-        ? [manifest.invocation.executable, ...manifest.invocation.arguments]
-        : [manifest.invocation.command];
-    const directory = manifest.workingDirectory.kind === "project-relative"
-        ? [manifest.workingDirectory.path]
-        : [];
-    return freezeArray([...invocation, ...directory].map((value) => encoder.encode(value).byteLength));
-}
-function isCanonicalNormalizedCommandStreamV1(stream, collection, commandId, streamName) {
-    const retainedBytes = retainedTextBytes(stream);
-    return (retainedBytes <= limits_ts_1.MAX_COMMAND_STREAM_BYTES_V1 &&
-        stream.totalSafeUtf8Bytes >= retainedBytes &&
-        (stream.totalSafeUtf8Bytes === retainedBytes ||
-            hasExactStreamTruncation(collection, commandId, streamName, retainedBytes, stream.totalSafeUtf8Bytes)));
-}
-function isCanonicalNormalizedCommandsCaptureV1(value) {
-    if (value.commands.length > limits_ts_1.MAX_COMMANDS_V1 ||
-        !isAllowedCommandsCollection(value.collection)) {
-        return false;
-    }
-    let previousCommandId;
-    let closureBytes = 0;
-    for (const command of value.commands) {
-        if (previousCommandId !== undefined &&
-            (0, model_ts_1.compareObservabilityTextV1)(previousCommandId, command.commandId) >= 0) {
-            return false;
-        }
-        previousCommandId = command.commandId;
-        for (const [name, stream] of [
-            ["stdout", command.result.stdout],
-            ["stderr", command.result.stderr],
-        ]) {
-            if (!isCanonicalNormalizedCommandStreamV1(stream, value.collection, command.commandId, name)) {
-                return false;
-            }
-            if (retainedTextBytes(stream) > limits_ts_1.MAX_COMMAND_INLINE_STREAM_BYTES_V1) {
-                closureBytes += retainedTextBytes(stream);
-            }
-        }
+function fixedLimitation(limitation) {
+    const target = fixedTarget((0, model_ts_1.limitationTarget)(limitation));
+    switch (limitation.code) {
+        case "capture-failed":
+        case "capture-interrupted":
+            return Object.freeze({ code: limitation.code, stage: limitation.stage, target });
+        case "collection-cap-reached":
+        case "unsupported-input":
+            return Object.freeze({ code: limitation.code, target, omittedAtLeast: limitation.omittedAtLeast });
+        case "text-truncated":
+            return Object.freeze({ code: "text-truncated", target, replacementOrOmittedCount: limitation.omittedBytes });
+        case "redacted":
+            return Object.freeze({ code: "redacted", target, replacementOrOmittedCount: limitation.replacementCount });
+        case "stream-truncated":
+            return Object.freeze({
+                code: "stream-truncated",
+                commandId: limitation.commandId,
+                stream: limitation.stream,
+                retainedBytes: limitation.retainedBytes,
+                omittedBytes: limitation.omittedBytes,
+            });
+        case "invalid-utf8-replaced":
+            return Object.freeze({ code: "invalid-utf8-replaced", commandId: limitation.commandId, stream: limitation.stream, count: limitation.replacementCount });
+        case "unsafe-control-stripped":
+            return Object.freeze({ code: "unsafe-control-stripped", commandId: limitation.commandId, stream: limitation.stream, count: limitation.strippedCount });
     }
-    if (closureBytes > limits_ts_1.MAX_COMMANDS_CLOSURE_BYTES_V1)
-        return false;
-    return value.collection.limitations.every((limitation) => {
-        if (limitation.code !== "text-truncated" || limitation.target !== "command-manifest") {
-            return true;
-        }
-        const command = value.commands.find((candidate) => candidate.commandId === limitation.commandId);
-        return command !== undefined && commandManifestTextLengths(command.manifest).some((length) => length === limitation.retainedBytes);
-    });
 }
-exports.NormalizedCommandsCaptureV1Schema = NormalizedCommandsCaptureV1StructuralSchema.pipe(effect_1.Schema.filter(isCanonicalNormalizedCommandsCaptureV1, {
-    identifier: "NormalizedObservabilityCommandsCaptureV1",
-    description: "bounded normalized command capture facts",
-}));
-const noObservabilityBlobDraftsV1 = Object.freeze([]);
-function decodeNormalized(schema, input) {
-    const decoded = effect_1.Schema.decodeUnknownEither(schema, codec_ts_1.ObservabilityExactParseOptions)(input);
-    return effect_1.Either.isLeft(decoded) ? undefined : decoded.right;
+function fixedCollection(collection) {
+    return Object.freeze({
+        state: collection.state,
+        limitations: Object.freeze(collection.limitations.map(fixedLimitation)),
+    });
 }
-function makeNoBlobObservabilityWriteV1(family, schema, input, familyName) {
-    const payload = decodeNormalized(schema, input);
-    if (payload === undefined)
-        return effect_1.Either.left(attachmentInputInvalid(familyName));
-    const write = (0, index_ts_1.makeRecordAttachmentWrite)(family, () => Object.freeze({ payload, blobs: noObservabilityBlobDraftsV1 }));
-    const closure = (0, index_ts_1.validateRecordAttachmentWrite)(write);
-    if (effect_1.Either.isLeft(closure)) {
-        throw new Error("A generated no-blob Observability RecordAttachment write was invalid");
+function fixedConversationItem(item) {
+    const base = { itemId: item.itemId, turnId: item.turnId, sequence: item.sequence };
+    switch (item.kind) {
+        case "message": return Object.freeze({ ...base, kind: item.kind, role: item.role, text: item.text });
+        case "tool-call": return Object.freeze({ ...base, kind: item.kind, callId: item.callId, tool: item.tool, inputSummary: item.inputSummary });
+        case "tool-result": return Object.freeze({ ...base, kind: item.kind, callId: item.callId, outcome: item.outcome, outputSummary: item.outputSummary });
+        case "thinking-summary": return Object.freeze({ ...base, kind: item.kind, summary: item.summary });
+        case "subagent": return Object.freeze({ ...base, kind: item.kind, state: item.state, label: item.label, summary: item.summary });
+        case "input-request": return Object.freeze({ ...base, kind: item.kind, state: item.state, promptSummary: item.promptSummary, responseSummary: item.responseSummary });
+        case "skill-load": return Object.freeze({ ...base, kind: item.kind, code: item.skill, summary: item.outcome });
+        case "context-injection": return Object.freeze({ ...base, kind: item.kind, summary: item.summary });
+        case "compaction": return Object.freeze({ ...base, kind: item.kind, summary: item.summary });
+        case "conversation-error": return Object.freeze({ ...base, kind: item.kind, code: item.code, summary: item.summary });
     }
-    return effect_1.Either.right(write);
-}
-function createAttemptConversationAttachmentWriteV1(input) {
-    return makeNoBlobObservabilityWriteV1(exports.attemptConversationAttachmentV1, families_ts_1.ConversationAttachmentV1Schema, input, "conversation");
-}
-function createAttemptUsageAttachmentWriteV1(input) {
-    return makeNoBlobObservabilityWriteV1(exports.attemptUsageAttachmentV1, families_ts_1.UsageAttachmentV1Schema, input, "usage");
-}
-function createAttemptTimingAttachmentWriteV1(input) {
-    return makeNoBlobObservabilityWriteV1(exports.attemptTimingAttachmentV1, families_ts_1.AttemptTimingAttachmentV1Schema, input, "attempt-timing");
-}
-function createAttemptDiagnosticsAttachmentWriteV1(input) {
-    return makeNoBlobObservabilityWriteV1(exports.attemptDiagnosticsAttachmentV1, families_ts_1.AttemptDiagnosticsAttachmentV1Schema, input, "attempt-diagnostics");
-}
-function createRunTimingAttachmentWriteV1(input) {
-    return makeNoBlobObservabilityWriteV1(exports.runTimingAttachmentV1, families_ts_1.RunTimingAttachmentV1Schema, input, "run-timing");
 }
-function createRunDiagnosticsAttachmentWriteV1(input) {
-    return makeNoBlobObservabilityWriteV1(exports.runDiagnosticsAttachmentV1, families_ts_1.RunDiagnosticsAttachmentV1Schema, input, "run-diagnostics");
-}
-function commandStreamPayloadV1(stream, blobs, drafts) {
-    const retainedBytes = (0, model_ts_1.makeNonNegativeSafeIntegerV1)(retainedTextBytes(stream));
-    if (retainedBytes === undefined) {
-        throw new Error("A bounded command stream must have a safe retained byte length");
-    }
-    if (retainedBytes <= limits_ts_1.MAX_COMMAND_INLINE_STREAM_BYTES_V1) {
+function commandStream(stream, blobs, drafts) {
+    const bytes = new TextEncoder().encode(stream.text);
+    const sha256 = (0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex");
+    if (bytes.byteLength <= limits_ts_1.MAX_COMMAND_INLINE_STREAM_BYTES) {
         return Object.freeze({
             storage: Object.freeze({ kind: "inline", text: stream.text }),
-            retainedBytes,
+            retainedBytes: bytes.byteLength,
             totalSafeUtf8Bytes: stream.totalSafeUtf8Bytes,
+            sha256,
         });
     }
-    const source = (0, index_ts_1.makeRecordBlobSource)(effect_1.Stream.fromEffect(effect_1.Effect.sync(() => new TextEncoder().encode(stream.text))));
-    const draft = blobs.add(source);
+    const draft = blobs.add((0, index_ts_1.makeRecordBlobSource)(effect_1.Stream.fromEffect(effect_1.Effect.sync(() => bytes))));
     drafts.push(draft);
     return Object.freeze({
         storage: Object.freeze({ kind: "blob", ref: draft.ref }),
-        retainedBytes,
+        retainedBytes: bytes.byteLength,
         totalSafeUtf8Bytes: stream.totalSafeUtf8Bytes,
+        sha256,
     });
 }
-function createAttemptCommandsAttachmentWriteV1(input) {
-    const normalized = decodeNormalized(exports.NormalizedCommandsCaptureV1Schema, input);
-    if (normalized === undefined)
-        return effect_1.Either.left(attachmentInputInvalid("commands"));
-    const write = (0, index_ts_1.makeRecordAttachmentWrite)(exports.attemptCommandsAttachmentV1, (blobs) => {
+function fixedRedaction(redaction) {
+    if (redaction.state === "none")
+        return Object.freeze({ state: "none" });
+    return Object.freeze({
+        state: "applied",
+        replacements: redaction.summaryReplacements + redaction.causeReplacements + redaction.contextReplacements,
+    });
+}
+function fixedAttemptDiagnostic(diagnostic) {
+    return Object.freeze({
+        diagnosticId: diagnostic.diagnosticId,
+        kind: diagnostic.kind,
+        code: diagnostic.code,
+        phase: diagnostic.phase === "collection" ? "attempt.teardown" : diagnostic.phase,
+        summary: diagnostic.summary,
+        causes: Object.freeze(diagnostic.causes.map((cause) => Object.freeze({ code: cause.code, summary: cause.summary }))),
+        redaction: fixedRedaction(diagnostic.redaction),
+        sourceFrame: diagnostic.sourceFrame,
+    });
+}
+function fixedRunDiagnostic(diagnostic) {
+    return Object.freeze({
+        diagnosticId: diagnostic.diagnosticId,
+        kind: diagnostic.kind,
+        code: diagnostic.code,
+        phase: diagnostic.phase === "collection" ? "run.teardown" : diagnostic.phase,
+        summary: diagnostic.summary,
+        causes: Object.freeze(diagnostic.causes.map((cause) => Object.freeze({ code: cause.code, summary: cause.summary }))),
+        redaction: fixedRedaction(diagnostic.redaction),
+        sourceFrame: diagnostic.sourceFrame,
+    });
+}
+function decodeAttempt(value) {
+    const decoded = effect_1.Schema.validateEither(observability_ts_1.AttemptObservabilityAttachmentSchema, core_ts_1.RecordExactParseOptions)(value);
+    return effect_1.Either.isLeft(decoded) ? effect_1.Either.left(invalid()) : effect_1.Either.right(decoded.right);
+}
+function decodeRun(value) {
+    const decoded = effect_1.Schema.validateEither(observability_ts_1.RunObservabilityAttachmentSchema, core_ts_1.RecordExactParseOptions)(value);
+    return effect_1.Either.isLeft(decoded) ? effect_1.Either.left(invalid()) : effect_1.Either.right(decoded.right);
+}
+/** Builds exactly one fixed Attempt Observability write, including command blobs. */
+function createAttemptObservabilityAttachmentWrite(input) {
+    const preflight = decodeAttempt(Object.freeze({
+        owner: "attempt",
+        conversation: Object.freeze({
+            collection: fixedCollection(input.conversation.collection),
+            turns: Object.freeze(input.conversation.turns.map((turn) => Object.freeze({ turnId: turn.turnId, sequence: turn.sequence, outcome: turn.outcome }))),
+            items: Object.freeze(input.conversation.items.map(fixedConversationItem)),
+        }),
+        commands: Object.freeze({ collection: fixedCollection(input.commands.collection), commands: Object.freeze([]) }),
+        usage: Object.freeze({ collection: fixedCollection(input.usage.collection), observations: Object.freeze(input.usage.observations.map(({ refs: _refs, ...value }) => Object.freeze(value))) }),
+        timing: Object.freeze({ collection: fixedCollection(input.timing.collection), intervals: Object.freeze(input.timing.intervals.map(({ refs: _refs, ...value }) => Object.freeze(value))) }),
+        diagnostics: Object.freeze({ collection: fixedCollection(input.diagnostics.collection), diagnostics: Object.freeze(input.diagnostics.diagnostics.map(fixedAttemptDiagnostic)) }),
+    }));
+    // Empty commands can be decoded eagerly. Non-empty commands are checked in
+    // the write builder after its owner-local blob refs have been minted.
+    if (input.commands.commands.length === 0 && effect_1.Either.isLeft(preflight))
+        return effect_1.Either.left(preflight.left);
+    const write = (0, index_ts_1.makeFixedRecordAttachmentWrite)(catalog_ts_1.attemptObservabilityRecordFamily.write, (blobs) => {
         const drafts = [];
-        const commands = normalized.commands.map((command) => Object.freeze({
-            commandId: command.commandId,
-            manifest: command.manifest,
-            result: Object.freeze({
-                outcome: command.result.outcome,
-                stdout: commandStreamPayloadV1(command.result.stdout, blobs, drafts),
-                stderr: commandStreamPayloadV1(command.result.stderr, blobs, drafts),
+        const candidate = Object.freeze({
+            owner: "attempt",
+            conversation: Object.freeze({
+                collection: fixedCollection(input.conversation.collection),
+                turns: Object.freeze(input.conversation.turns.map((turn) => Object.freeze({ turnId: turn.turnId, sequence: turn.sequence, outcome: turn.outcome }))),
+                items: Object.freeze(input.conversation.items.map(fixedConversationItem)),
             }),
-            refs: command.refs,
-        }));
-        const decoded = effect_1.Schema.decodeUnknownEither(families_ts_1.CommandsAttachmentV1Schema, codec_ts_1.ObservabilityExactParseOptions)(Object.freeze({
-            collection: normalized.collection,
-            commands: Object.freeze(commands),
-        }));
-        if (effect_1.Either.isLeft(decoded)) {
-            throw new Error("Normalized commands capture produced an invalid durable payload");
-        }
+            commands: Object.freeze({
+                collection: fixedCollection(input.commands.collection),
+                commands: Object.freeze(input.commands.commands.map((command) => Object.freeze({
+                    commandId: command.commandId,
+                    manifest: command.manifest,
+                    result: Object.freeze({
+                        outcome: command.result.outcome,
+                        stdout: commandStream(command.result.stdout, blobs, drafts),
+                        stderr: commandStream(command.result.stderr, blobs, drafts),
+                    }),
+                }))),
+            }),
+            usage: Object.freeze({ collection: fixedCollection(input.usage.collection), observations: Object.freeze(input.usage.observations.map(({ refs: _refs, ...value }) => Object.freeze(value))) }),
+            timing: Object.freeze({ collection: fixedCollection(input.timing.collection), intervals: Object.freeze(input.timing.intervals.map(({ refs: _refs, ...value }) => Object.freeze(value))) }),
+            diagnostics: Object.freeze({ collection: fixedCollection(input.diagnostics.collection), diagnostics: Object.freeze(input.diagnostics.diagnostics.map(fixedAttemptDiagnostic)) }),
+        });
+        const decoded = decodeAttempt(candidate);
+        if (effect_1.Either.isLeft(decoded))
+            throw new Error("Observability capture does not satisfy the fixed v1 payload");
         return Object.freeze({ payload: decoded.right, blobs: Object.freeze(drafts) });
     });
     const closure = (0, index_ts_1.validateRecordAttachmentWrite)(write);
-    if (effect_1.Either.isLeft(closure)) {
-        throw new Error("A generated commands Observability RecordAttachment closure was invalid");
-    }
+    if (effect_1.Either.isLeft(closure))
+        throw new Error("Fixed Observability write closure was invalid");
     return effect_1.Either.right(write);
 }
-function createAttemptObservabilityAttachmentWritesV1(input) {
-    const conversation = createAttemptConversationAttachmentWriteV1(input.conversation);
-    if (effect_1.Either.isLeft(conversation))
-        return effect_1.Either.left(conversation.left);
-    const commands = createAttemptCommandsAttachmentWriteV1(input.commands);
-    if (effect_1.Either.isLeft(commands))
-        return effect_1.Either.left(commands.left);
-    const usage = createAttemptUsageAttachmentWriteV1(input.usage);
-    if (effect_1.Either.isLeft(usage))
-        return effect_1.Either.left(usage.left);
-    const timing = createAttemptTimingAttachmentWriteV1(input.timing);
-    if (effect_1.Either.isLeft(timing))
-        return effect_1.Either.left(timing.left);
-    const diagnostics = createAttemptDiagnosticsAttachmentWriteV1(input.diagnostics);
-    if (effect_1.Either.isLeft(diagnostics))
-        return effect_1.Either.left(diagnostics.left);
-    return effect_1.Either.right(Object.freeze({
-        conversation: conversation.right,
-        commands: commands.right,
-        usage: usage.right,
-        timing: timing.right,
-        diagnostics: diagnostics.right,
-        validations: Object.freeze([
-            (0, families_ts_1.makeAttemptConversationAttachmentFamilyValidationV1)(input.conversation),
-            (0, families_ts_1.makeAttemptCommandsAttachmentFamilyValidationV1)(input.commands),
-            (0, families_ts_1.makeAttemptUsageAttachmentFamilyValidationV1)(input.usage),
-            (0, families_ts_1.makeAttemptTimingAttachmentFamilyValidationV1)(input.timing),
-            (0, families_ts_1.makeAttemptDiagnosticsAttachmentFamilyValidationV1)(input.diagnostics),
-        ]),
-    }));
-}
-function createRunObservabilityAttachmentWritesV1(input) {
-    const timing = createRunTimingAttachmentWriteV1(input.timing);
-    if (effect_1.Either.isLeft(timing))
-        return effect_1.Either.left(timing.left);
-    const diagnostics = createRunDiagnosticsAttachmentWriteV1(input.diagnostics);
-    if (effect_1.Either.isLeft(diagnostics))
-        return effect_1.Either.left(diagnostics.left);
-    return effect_1.Either.right(Object.freeze({
-        timing: timing.right,
-        diagnostics: diagnostics.right,
-        validations: Object.freeze([
-            (0, families_ts_1.makeRunTimingAttachmentFamilyValidationV1)(input.timing),
-            (0, families_ts_1.makeRunDiagnosticsAttachmentFamilyValidationV1)(input.diagnostics),
-        ]),
-    }));
+/** Builds the fixed Run Observability payload (timing and diagnostics only). */
+function createRunObservabilityAttachmentWrite(input) {
+    const candidate = Object.freeze({
+        owner: "run",
+        timing: Object.freeze({ collection: fixedCollection(input.timing.collection), intervals: Object.freeze(input.timing.intervals.map(({ refs: _refs, ...value }) => Object.freeze(value))) }),
+        diagnostics: Object.freeze({ collection: fixedCollection(input.diagnostics.collection), diagnostics: Object.freeze(input.diagnostics.diagnostics.map(fixedRunDiagnostic)) }),
+    });
+    const decoded = decodeRun(candidate);
+    if (effect_1.Either.isLeft(decoded))
+        return effect_1.Either.left(decoded.left);
+    const write = (0, index_ts_1.makeFixedRecordAttachmentWrite)(catalog_ts_1.runObservabilityRecordFamily.write, () => Object.freeze({ payload: decoded.right, blobs: Object.freeze([]) }));
+    const closure = (0, index_ts_1.validateRecordAttachmentWrite)(write);
+    if (effect_1.Either.isLeft(closure))
+        throw new Error("Fixed Run Observability write closure was invalid");
+    return effect_1.Either.right(write);
 }
-/**
- * Joint validation is intentionally separate from individual writes: an
- * otherwise valid owner-local Attachment is never invalidated just because a
- * sibling family is absent or corrupt. The coordinator calls this after all
- * owner-local builders have frozen their values and before generic writing.
- */
-function validateObservabilityAttachmentWriteBundlesV1(input) {
-    const contractInput = {
-        run: { families: input.run.validations },
-        attempts: input.attempts.map((attempt) => ({ families: attempt.validations })),
-    };
-    return (0, validation_ts_1.validateObservabilityRecordContractV1)(contractInput);
+/** Legacy plural names now deliberately return a one-write fixed bundle. */
+function createAttemptObservabilityAttachmentWrites(input) {
+    const write = createAttemptObservabilityAttachmentWrite(input);
+    return effect_1.Either.isLeft(write)
+        ? effect_1.Either.left(write.left)
+        : effect_1.Either.right(Object.freeze({ write: write.right }));
+}
+function createRunObservabilityAttachmentWrites(input) {
+    const write = createRunObservabilityAttachmentWrite(input);
+    return effect_1.Either.isLeft(write)
+        ? effect_1.Either.left(write.left)
+        : effect_1.Either.right(Object.freeze({ write: write.right }));
+}
+/** Boundary check used by Runner before passing bundles to the fixed collector. */
+function validateObservabilityAttachmentWriteBundles(input) {
+    const errors = [];
+    const run = (0, internal_ts_1.recordAttachmentWriteContents)(input.run.write);
+    if (effect_1.Either.isLeft(run) || run.right.fixed !== catalog_ts_1.runObservabilityRecordFamily.write) {
+        errors.push((0, errors_ts_1.observabilityOwnerOrSchemaInvalidError)("run", "niceeval.observability"));
+    }
+    for (const attempt of input.attempts) {
+        const captured = (0, internal_ts_1.recordAttachmentWriteContents)(attempt.write);
+        if (effect_1.Either.isLeft(captured) || captured.right.fixed !== catalog_ts_1.attemptObservabilityRecordFamily.write) {
+            errors.push((0, errors_ts_1.observabilityOwnerOrSchemaInvalidError)("attempt", "niceeval.observability"));
+        }
+    }
+    return Object.freeze(errors);
 }
+/** Fixed owner primitives; no caller can define or register a new family. */
+exports.attemptObservabilityAttachmentWrite = catalog_ts_1.attemptObservabilityRecordFamily.write;
+exports.runObservabilityAttachmentWrite = catalog_ts_1.runObservabilityRecordFamily.write;
 //# sourceMappingURL=family-writers.cjs.map