niceeval 0.12.2-canary.31 → 0.13.0

package/dist/o11y/record/runner-producer.cjs

@@ -1,16 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRunnerAttemptObservabilityRuntimeV1 = createRunnerAttemptObservabilityRuntimeV1;
-exports.bindRunnerAttemptObservabilityCaptureV1 = bindRunnerAttemptObservabilityCaptureV1;
-exports.bindRunnerRunObservabilityDiagnosticsV1 = bindRunnerRunObservabilityDiagnosticsV1;
-exports.captureRunnerCommandStartV1 = captureRunnerCommandStartV1;
-exports.captureRunnerCommandResultV1 = captureRunnerCommandResultV1;
-exports.captureRunnerCommandTimeoutV1 = captureRunnerCommandTimeoutV1;
-exports.captureRunnerCommandInterruptedV1 = captureRunnerCommandInterruptedV1;
-exports.captureRunnerCommandCaptureFailedV1 = captureRunnerCommandCaptureFailedV1;
-exports.captureRunnerTurnUsageV1 = captureRunnerTurnUsageV1;
-exports.createRunnerAttemptObservabilityCaptureV1 = createRunnerAttemptObservabilityCaptureV1;
-exports.createRunnerRunObservabilityCaptureV1 = createRunnerRunObservabilityCaptureV1;
+exports.createRunnerAttemptObservabilityRuntime = createRunnerAttemptObservabilityRuntime;
+exports.bindRunnerAttemptObservabilityCapture = bindRunnerAttemptObservabilityCapture;
+exports.runnerAttemptConversationTimingForResult = runnerAttemptConversationTimingForResult;
+exports.captureRunnerPhysicalConversationTurn = captureRunnerPhysicalConversationTurn;
+exports.bindRunnerRunObservabilityDiagnostics = bindRunnerRunObservabilityDiagnostics;
+exports.captureRunnerCommandStart = captureRunnerCommandStart;
+exports.captureRunnerCommandResult = captureRunnerCommandResult;
+exports.captureRunnerCommandTimeout = captureRunnerCommandTimeout;
+exports.captureRunnerCommandInterrupted = captureRunnerCommandInterrupted;
+exports.captureRunnerCommandCaptureFailed = captureRunnerCommandCaptureFailed;
+exports.captureRunnerTurnUsage = captureRunnerTurnUsage;
+exports.createRunnerAttemptObservabilityCapture = createRunnerAttemptObservabilityCapture;
+exports.createRunnerRunObservabilityCapture = createRunnerRunObservabilityCapture;
 const node_crypto_1 = require("node:crypto");
 const effect_1 = require("effect");
 const redaction_ts_1 = require("../../sandbox/redaction.cjs");
@@ -36,25 +38,25 @@ function producerCommandRegistrationInvalid() {
     return Object.freeze({ code: "runner-observability-command-registration-invalid" });
 }
 function requiredPositive(value) {
-    const positive = (0, model_ts_1.makePositiveSafeIntegerV1)(value);
+    const positive = (0, model_ts_1.makePositiveSafeInteger)(value);
     if (positive !== undefined)
         return positive;
-    const fallback = (0, model_ts_1.makePositiveSafeIntegerV1)(1);
+    const fallback = (0, model_ts_1.makePositiveSafeInteger)(1);
     if (fallback === undefined)
         throw new Error("One must be a positive safe integer");
     return fallback;
 }
 function requiredNonNegative(value) {
-    const nonNegative = (0, model_ts_1.makeNonNegativeSafeIntegerV1)(value);
+    const nonNegative = (0, model_ts_1.makeNonNegativeSafeInteger)(value);
     if (nonNegative !== undefined)
         return nonNegative;
-    const fallback = (0, model_ts_1.makeNonNegativeSafeIntegerV1)(0);
+    const fallback = (0, model_ts_1.makeNonNegativeSafeInteger)(0);
     if (fallback === undefined)
         throw new Error("Zero must be a non-negative safe integer");
     return fallback;
 }
 /** Coalesces and canonically orders the closed durable limitation union. */
-class RunnerCollectionLimitationsV1 {
+class RunnerCollectionLimitations {
     captureFailed = new Map();
     captureInterrupted = new Map();
     unsupported = new Map();
@@ -154,7 +156,7 @@ class RunnerCollectionLimitationsV1 {
             }));
         }
         limitations.push(...this.textTruncations);
-        limitations.sort(model_ts_1.compareObservabilityLimitationV1);
+        limitations.sort(model_ts_1.compareObservabilityLimitation);
         if (limitations.length === 0) {
             return Object.freeze({
                 state: "complete",
@@ -171,26 +173,26 @@ class RunnerCollectionLimitationsV1 {
     }
 }
 /** Never split a Unicode scalar or retain a non-SafeText source value. */
-function retainSafeTextV1(value, maximumBytes) {
-    if ((0, model_ts_1.makeBoundedSafeTextV1)(value, maximumBytes) !== undefined) {
+function retainSafeText(value, maximumBytes) {
+    if ((0, model_ts_1.makeBoundedSafeText)(value, maximumBytes) !== undefined) {
         return Object.freeze({
-            text: (0, model_ts_1.makeBoundedSafeTextV1)(value, maximumBytes),
-            retainedBytes: requiredNonNegative((0, model_ts_1.utf8ByteLengthV1)(value)),
+            text: (0, model_ts_1.makeBoundedSafeText)(value, maximumBytes),
+            retainedBytes: requiredNonNegative((0, model_ts_1.utf8ByteLength)(value)),
         });
     }
-    const totalBytes = (0, model_ts_1.utf8ByteLengthV1)(value);
+    const totalBytes = (0, model_ts_1.utf8ByteLength)(value);
     if (totalBytes <= maximumBytes)
         return undefined;
     let retained = "";
     let retainedBytes = 0;
     for (const scalar of value) {
-        const scalarBytes = (0, model_ts_1.utf8ByteLengthV1)(scalar);
+        const scalarBytes = (0, model_ts_1.utf8ByteLength)(scalar);
         if (retainedBytes + scalarBytes > maximumBytes)
             break;
         retained += scalar;
         retainedBytes += scalarBytes;
     }
-    const safe = (0, model_ts_1.makeBoundedSafeTextV1)(retained, maximumBytes);
+    const safe = (0, model_ts_1.makeBoundedSafeText)(retained, maximumBytes);
     const omittedBytes = totalBytes - retainedBytes;
     if (safe === undefined || omittedBytes <= 0)
         return undefined;
@@ -200,7 +202,7 @@ function retainSafeTextV1(value, maximumBytes) {
         omittedBytes: requiredPositive(omittedBytes),
     });
 }
-function jsonSummaryV1(value) {
+function jsonSummary(value) {
     let summary;
     try {
         const encoded = JSON.stringify(value);
@@ -211,9 +213,9 @@ function jsonSummaryV1(value) {
     }
     return summary === undefined
         ? undefined
-        : retainSafeTextV1(summary, limits_ts_1.MAX_CONVERSATION_TEXT_BYTES_V1);
+        : retainSafeText(summary, limits_ts_1.MAX_CONVERSATION_TEXT_BYTES);
 }
-function uuidEntropyBytesV1(uuid) {
+function uuidEntropyBytes(uuid) {
     const hex = uuid.replaceAll("-", "");
     if (!/^[0-9a-f]{32}$/iu.test(hex))
         return undefined;
@@ -226,143 +228,163 @@ function uuidEntropyBytesV1(uuid) {
     }
     return bytes;
 }
-function attemptTargetForEntityV1(kind, id) {
+function attemptTargetForEntity(kind, id) {
     switch (kind) {
         case "turn":
             return Object.freeze({
-                family: "niceeval.conversation/v1",
+                family: "niceeval.observability",
                 kind: "turn",
                 id: id,
             });
         case "item":
             return Object.freeze({
-                family: "niceeval.conversation/v1",
+                family: "niceeval.observability",
                 kind: "item",
                 id: id,
             });
         case "call":
             return Object.freeze({
-                family: "niceeval.conversation/v1",
+                family: "niceeval.observability",
                 kind: "call",
                 id: id,
             });
         case "command":
             return Object.freeze({
-                family: "niceeval.commands/v1",
+                family: "niceeval.observability",
                 kind: "command",
                 id: id,
             });
         case "usage-observation":
             return Object.freeze({
-                family: "niceeval.usage/v1",
+                family: "niceeval.observability",
                 kind: "usage-observation",
                 id: id,
             });
         case "interval":
             return Object.freeze({
-                family: "niceeval.timing/v1",
+                family: "niceeval.observability",
                 kind: "interval",
                 id: id,
             });
         case "diagnostic":
             return Object.freeze({
-                family: "niceeval.diagnostics/v1",
+                family: "niceeval.observability",
                 kind: "diagnostic",
                 id: id,
             });
     }
 }
-const runnerAttemptObservabilityRuntimeTypeId = Symbol("@niceeval/o11y/RunnerAttemptObservabilityRuntimeV1");
-const runnerCommandCaptureHandleTypeId = Symbol("@niceeval/o11y/RunnerCommandCaptureHandleV1");
-const runnerAttemptRuntimeStatesV1 = new WeakMap();
-const runnerAttemptResultStatesV1 = new WeakMap();
-const runnerCommandHandleStatesV1 = new WeakMap();
-const runnerRunDiagnosticsV1 = new WeakMap();
-function runtimeStateV1(runtime) {
-    return runnerAttemptRuntimeStatesV1.get(runtime);
+const runnerAttemptObservabilityRuntimeTypeId = Symbol("@niceeval/o11y/RunnerAttemptObservabilityRuntime");
+const runnerCommandCaptureHandleTypeId = Symbol("@niceeval/o11y/RunnerCommandCaptureHandle");
+const runnerAttemptRuntimeStates = new WeakMap();
+const runnerAttemptResultStates = new WeakMap();
+const runnerAttemptResultTurnIntervals = new WeakMap();
+const runnerCommandHandleStates = new WeakMap();
+const runnerRunDiagnostics = new WeakMap();
+function runtimeState(runtime) {
+    return runnerAttemptRuntimeStates.get(runtime);
 }
-function markRuntimeFailureV1(runtime, failure) {
+function markRuntimeFailure(runtime, failure) {
     if (runtime.failure === undefined)
         runtime.failure = failure;
 }
-function mintRuntimeEntityV1(runtime, kind) {
+function mintRuntimeEntity(runtime, kind) {
     let uuid;
     try {
         uuid = (0, node_crypto_1.randomUUID)();
     }
     catch {
-        markRuntimeFailureV1(runtime, producerEntityIdInvalid(kind));
+        markRuntimeFailure(runtime, producerEntityIdInvalid(kind));
         return undefined;
     }
-    const bytes = uuidEntropyBytesV1(uuid);
-    const id = bytes === undefined ? undefined : (0, model_ts_1.entityIdFromEntropyV1)(kind, bytes);
+    const bytes = orderedRuntimeEntityEntropy(runtime, uuid);
+    const id = bytes === undefined ? undefined : (0, model_ts_1.entityIdFromEntropy)(kind, bytes);
     if (id === undefined) {
-        markRuntimeFailureV1(runtime, producerEntityIdInvalid(kind));
+        markRuntimeFailure(runtime, producerEntityIdInvalid(kind));
         return undefined;
     }
-    const minted = (0, capture_ts_1.mintAttemptObservabilityEntityV1)(runtime.capture, attemptTargetForEntityV1(kind, id));
+    const minted = (0, capture_ts_1.mintAttemptObservabilityEntity)(runtime.capture, attemptTargetForEntity(kind, id));
     if (minted === undefined) {
-        markRuntimeFailureV1(runtime, producerEntityIdInvalid(kind));
+        markRuntimeFailure(runtime, producerEntityIdInvalid(kind));
         return undefined;
     }
     return id;
 }
-function mintRuntimeCommandV1(runtime) {
+/**
+ * The durable entity suffix remains mostly UUID entropy while a bounded
+ * big-endian ordinal makes creation order lexicographic order. Every v1
+ * Attempt collector has much smaller caps than this counter's range.
+ */
+function orderedRuntimeEntityEntropy(runtime, uuid) {
+    const bytes = uuidEntropyBytes(uuid);
+    const ordinal = runtime.nextEntityOrdinal + 1;
+    if (bytes === undefined
+        || !Number.isSafeInteger(ordinal)
+        || ordinal > 4294967295)
+        return undefined;
+    runtime.nextEntityOrdinal = ordinal;
+    bytes[0] = (ordinal >>> 24) & 0xff;
+    bytes[1] = (ordinal >>> 16) & 0xff;
+    bytes[2] = (ordinal >>> 8) & 0xff;
+    bytes[3] = ordinal & 0xff;
+    return bytes;
+}
+function mintRuntimeCommand(runtime) {
     let uuid;
     try {
         uuid = (0, node_crypto_1.randomUUID)();
     }
     catch {
-        markRuntimeFailureV1(runtime, producerEntityIdInvalid("command"));
+        markRuntimeFailure(runtime, producerEntityIdInvalid("command"));
         return undefined;
     }
-    const bytes = uuidEntropyBytesV1(uuid);
-    const commandId = bytes === undefined ? undefined : (0, model_ts_1.entityIdFromEntropyV1)("command", bytes);
+    const bytes = orderedRuntimeEntityEntropy(runtime, uuid);
+    const commandId = bytes === undefined ? undefined : (0, model_ts_1.entityIdFromEntropy)("command", bytes);
     if (commandId === undefined) {
-        markRuntimeFailureV1(runtime, producerEntityIdInvalid("command"));
+        markRuntimeFailure(runtime, producerEntityIdInvalid("command"));
         return undefined;
     }
-    const entity = (0, capture_ts_1.mintAttemptObservabilityEntityV1)(runtime.capture, {
-        family: "niceeval.commands/v1",
+    const entity = (0, capture_ts_1.mintAttemptObservabilityEntity)(runtime.capture, {
+        family: "niceeval.observability",
         kind: "command",
         id: commandId,
     });
     if (entity === undefined) {
-        markRuntimeFailureV1(runtime, producerEntityIdInvalid("command"));
+        markRuntimeFailure(runtime, producerEntityIdInvalid("command"));
         return undefined;
     }
     return Object.freeze({ commandId, entity });
 }
-function makeAttemptEntityMinterV1(runtime) {
+function makeAttemptEntityMinter(runtime) {
     return Object.freeze({
         mint: (kind) => effect_1.Effect.suspend(() => {
             if (runtime.failure !== undefined)
                 return effect_1.Effect.fail(runtime.failure);
-            const id = mintRuntimeEntityV1(runtime, kind);
+            const id = mintRuntimeEntity(runtime, kind);
             return id === undefined
                 ? effect_1.Effect.fail(runtime.failure ?? producerEntityIdInvalid(kind))
                 : effect_1.Effect.succeed(id);
         }),
-        seal: () => (0, capture_ts_1.sealAttemptObservabilityCaptureIdentityV1)(runtime.capture),
+        seal: () => (0, capture_ts_1.sealAttemptObservabilityCaptureIdentity)(runtime.capture),
     });
 }
-function runTargetForEntityV1(kind, id) {
+function runTargetForEntity(kind, id) {
     switch (kind) {
         case "interval":
             return Object.freeze({
-                family: "niceeval.timing/v1",
+                family: "niceeval.observability",
                 kind: "interval",
                 id: id,
             });
         case "diagnostic":
             return Object.freeze({
-                family: "niceeval.diagnostics/v1",
+                family: "niceeval.observability",
                 kind: "diagnostic",
                 id: id,
             });
     }
 }
-function mintRunEntityV1(capture, kind) {
+function mintRunEntity(capture, kind) {
     let uuid;
     try {
         uuid = (0, node_crypto_1.randomUUID)();
@@ -370,37 +392,40 @@ function mintRunEntityV1(capture, kind) {
     catch {
         return undefined;
     }
-    const bytes = uuidEntropyBytesV1(uuid);
-    const id = bytes === undefined ? undefined : (0, model_ts_1.entityIdFromEntropyV1)(kind, bytes);
+    const bytes = uuidEntropyBytes(uuid);
+    const id = bytes === undefined ? undefined : (0, model_ts_1.entityIdFromEntropy)(kind, bytes);
     if (id === undefined)
         return undefined;
-    const minted = (0, capture_ts_1.mintRunObservabilityEntityV1)(capture, runTargetForEntityV1(kind, id));
+    const minted = (0, capture_ts_1.mintRunObservabilityEntity)(capture, runTargetForEntity(kind, id));
     return minted === undefined ? undefined : id;
 }
-function makeRunEntityMinterV1(capture) {
+function makeRunEntityMinter(capture) {
     return Object.freeze({
         mint: (kind) => effect_1.Effect.suspend(() => {
-            const id = mintRunEntityV1(capture, kind);
+            const id = mintRunEntity(capture, kind);
             return id === undefined
                 ? effect_1.Effect.fail(producerEntityIdInvalid(kind))
                 : effect_1.Effect.succeed(id);
         }),
-        seal: () => (0, capture_ts_1.sealRunObservabilityCaptureIdentityV1)(capture),
+        seal: () => (0, capture_ts_1.sealRunObservabilityCaptureIdentity)(capture),
     });
 }
 /** Creates one private capture for a real Runner Attempt. */
-function createRunnerAttemptObservabilityRuntimeV1(input) {
+function createRunnerAttemptObservabilityRuntime(input) {
     const runtime = Object.freeze({
         [runnerAttemptObservabilityRuntimeTypeId]: () => undefined,
     });
-    runnerAttemptRuntimeStatesV1.set(runtime, {
-        capture: (0, capture_ts_1.makeAttemptObservabilityCaptureIdentityV1)(),
+    runnerAttemptRuntimeStates.set(runtime, {
+        capture: (0, capture_ts_1.makeAttemptObservabilityCaptureIdentity)(),
         providerName: input.providerName,
         sensitiveValues: input.sensitiveValues,
+        nextEntityOrdinal: 0,
         commands: [],
-        commandLimitations: new RunnerCollectionLimitationsV1(),
+        commandLimitations: new RunnerCollectionLimitations(),
         usage: [],
-        usageLimitations: new RunnerCollectionLimitationsV1(),
+        usageLimitations: new RunnerCollectionLimitations(),
+        conversationTurns: [],
+        conversationLimitations: new RunnerCollectionLimitations(),
     });
     return runtime;
 }
@@ -409,16 +434,44 @@ function createRunnerAttemptObservabilityRuntimeV1(input) {
  * capture. Result shape stays public-contract-neutral; Record later looks up
  * this identity rather than reading an added field.
  */
-function bindRunnerAttemptObservabilityCaptureV1(result, runtime) {
-    const state = runtimeStateV1(runtime);
+function bindRunnerAttemptObservabilityCapture(result, runtime) {
+    const state = runtimeState(runtime);
     if (state === undefined)
         return;
-    const existing = runnerAttemptResultStatesV1.get(result);
+    const existing = runnerAttemptResultStates.get(result);
     if (existing !== undefined && existing !== state) {
-        markRuntimeFailureV1(state, producerCaptureSealInvalid("attempt"));
+        markRuntimeFailure(state, producerCaptureSealInvalid("attempt"));
         return;
     }
-    runnerAttemptResultStatesV1.set(result, state);
+    runnerAttemptResultStates.set(result, state);
+}
+/** Exact physical-turn timing joins produced during the same final seal. */
+function runnerAttemptConversationTimingForResult(result) {
+    return runnerAttemptResultTurnIntervals.get(result);
+}
+/**
+ * Captures the terminal fact of one physical public `t.send` at the exact
+ * Effect Exit boundary. IDs are minted here, not reconstructed from the
+ * later aggregate event stream, so repeated source locations remain distinct.
+ */
+function captureRunnerPhysicalConversationTurn(input) {
+    const runtime = runtimeState(input.runtime);
+    if (runtime === undefined || runtime.failure !== undefined)
+        return undefined;
+    if (runtime.conversationTurns.length >= limits_ts_1.MAX_CONVERSATION_TURNS) {
+        runtime.conversationLimitations.addCap("conversation-item", runtime.conversationTurns.length);
+        return undefined;
+    }
+    const turnId = mintRuntimeEntity(runtime, "turn");
+    if (turnId === undefined)
+        return undefined;
+    runtime.conversationTurns.push(Object.freeze({
+        turnId,
+        sequence: requiredPositive(runtime.conversationTurns.length + 1),
+        outcome: input.outcome,
+        events: Object.freeze([...input.events]),
+    }));
+    return turnId;
 }
 /**
  * Associates only the settled diagnostics that belong to this exact Run. The
@@ -426,10 +479,10 @@ function bindRunnerAttemptObservabilityCaptureV1(result, runtime) {
  * have no safe per-experiment owner attribution when an invocation has more
  * than one Run.
  */
-function bindRunnerRunObservabilityDiagnosticsV1(input) {
-    runnerRunDiagnosticsV1.set(input.run, Object.freeze([...input.diagnostics]));
+function bindRunnerRunObservabilityDiagnostics(input) {
+    runnerRunDiagnostics.set(input.run, Object.freeze([...input.diagnostics]));
 }
-function commandManifestPhaseV1(phase) {
+function commandManifestPhase(phase) {
     switch (phase) {
         case "sandbox.create":
         case "workspace.baseline":
@@ -451,35 +504,36 @@ function commandManifestPhaseV1(phase) {
         case "sandbox.cleanup":
         case "sandbox.suspend":
         case "sandbox.stop":
+        case "experiment.teardown":
+        case "workspace.diff":
+        case "telemetry.collect":
             return "attempt.teardown";
         case "assertions.evaluate":
         case "judge.precheck":
+            return "eval.run";
         case "experiment.setup":
-        case "experiment.teardown":
         case "sandbox.queue":
-        case "workspace.diff":
-        case "telemetry.collect":
-            return undefined;
+            return "attempt.setup";
     }
 }
 /** Registers the manifest authority before the wrapped Sandbox call starts. */
-function captureRunnerCommandStartV1(input) {
-    const runtime = runtimeStateV1(input.runtime);
+function captureRunnerCommandStart(input) {
+    const runtime = runtimeState(input.runtime);
     if (runtime === undefined)
         return undefined;
     if (runtime.failure !== undefined)
         return undefined;
-    if (runtime.commands.length >= limits_ts_1.MAX_COMMANDS_V1) {
+    if (runtime.commands.length >= limits_ts_1.MAX_COMMANDS) {
         runtime.commandLimitations.addCap("command-manifest", runtime.commands.length);
         return undefined;
     }
-    const minted = mintRuntimeCommandV1(runtime);
+    const minted = mintRuntimeCommand(runtime);
     if (minted === undefined)
         return undefined;
     const { commandId } = minted;
-    const registered = (0, capture_ts_1.registerCommandCaptureV1)(runtime.capture, minted.entity);
-    if (registered === undefined || (0, capture_ts_1.registeredCommandIdV1)(registered) !== commandId) {
-        markRuntimeFailureV1(runtime, producerCommandRegistrationInvalid());
+    const registered = (0, capture_ts_1.registerCommandCapture)(runtime.capture, minted.entity);
+    if (registered === undefined || (0, capture_ts_1.registeredCommandId)(registered) !== commandId) {
+        markRuntimeFailure(runtime, producerCommandRegistrationInvalid());
         return undefined;
     }
     const command = {
@@ -495,24 +549,47 @@ function captureRunnerCommandStartV1(input) {
     const handle = Object.freeze({
         [runnerCommandCaptureHandleTypeId]: () => undefined,
     });
-    runnerCommandHandleStatesV1.set(handle, Object.freeze({ runtime, command }));
+    runnerCommandHandleStates.set(handle, Object.freeze({ runtime, command }));
     return handle;
 }
-function commandHandleStateV1(handle) {
-    return handle === undefined ? undefined : runnerCommandHandleStatesV1.get(handle);
+function commandHandleState(handle) {
+    return handle === undefined ? undefined : runnerCommandHandleStates.get(handle);
+}
+function acceptRegisteredCommandResult(state) {
+    const registration = (0, capture_ts_1.recordRegisteredCommandResult)(state.runtime.capture, state.command.registered);
+    if (registration.state !== "recorded") {
+        markRuntimeFailure(state.runtime, producerCommandRegistrationInvalid());
+        return false;
+    }
+    return true;
+}
+function recordTerminalCommandResult(state, outcome) {
+    if (!acceptRegisteredCommandResult(state))
+        return;
+    state.command.result = Object.freeze({
+        outcome: Object.freeze(outcome),
+        stdout: "",
+        stderr: "",
+    });
 }
 /** Records a real returned/CommandExitError result against its prior manifest. */
-function captureRunnerCommandResultV1(input) {
-    const state = commandHandleStateV1(input.handle);
+function captureRunnerCommandResult(input) {
+    const state = commandHandleState(input.handle);
     if (state === undefined)
         return;
-    const registration = (0, capture_ts_1.recordRegisteredCommandResultV1)(state.runtime.capture, state.command.registered);
-    if (registration.state !== "recorded") {
-        markRuntimeFailureV1(state.runtime, producerCommandRegistrationInvalid());
+    if (!acceptRegisteredCommandResult(state))
         return;
-    }
     if (!Number.isSafeInteger(input.exitCode) || input.exitCode < -2147483648 || input.exitCode > 2147483647) {
-        state.runtime.commandLimitations.addUnsupported("command-manifest");
+        // A provider value without a valid command result is not a normal exit.
+        // Keep the registered manifest with its explicit transport terminal fact.
+        state.runtime.commandLimitations.addCaptureFailed("command-capture", "command-manifest");
+        state.runtime.commandLimitations.addCaptureFailed("command-capture", "command-stdout");
+        state.runtime.commandLimitations.addCaptureFailed("command-capture", "command-stderr");
+        state.command.result = Object.freeze({
+            outcome: Object.freeze({ kind: "terminated", reason: "transport-lost" }),
+            stdout: "",
+            stderr: "",
+        });
         return;
     }
     const stdout = typeof input.stdout === "string" ? input.stdout : "";
@@ -528,55 +605,60 @@ function captureRunnerCommandResultV1(input) {
     });
 }
 /** A command timeout is a real terminal fact, unlike external interruption. */
-function captureRunnerCommandTimeoutV1(handle) {
-    const state = commandHandleStateV1(handle);
+function captureRunnerCommandTimeout(handle) {
+    const state = commandHandleState(handle);
     if (state === undefined)
         return;
-    const registration = (0, capture_ts_1.recordRegisteredCommandResultV1)(state.runtime.capture, state.command.registered);
-    if (registration.state !== "recorded") {
-        markRuntimeFailureV1(state.runtime, producerCommandRegistrationInvalid());
-        return;
-    }
     state.runtime.commandLimitations.addCaptureFailed("command-capture", "command-stdout");
     state.runtime.commandLimitations.addCaptureFailed("command-capture", "command-stderr");
-    state.command.result = Object.freeze({
-        outcome: Object.freeze({ kind: "terminated", reason: "timeout" }),
-        stdout: "",
-        stderr: "",
-    });
-}
-/** External interruption has no invented command result. */
-function captureRunnerCommandInterruptedV1(handle) {
-    const state = commandHandleStateV1(handle);
+    recordTerminalCommandResult(state, Object.freeze({
+        kind: "terminated",
+        reason: "timeout",
+    }));
+}
+/** A command call interrupted after registration is durably terminal/cancelled. */
+function captureRunnerCommandInterrupted(handle) {
+    const state = commandHandleState(handle);
     if (state === undefined)
         return;
     state.runtime.commandLimitations.addCaptureInterrupted("command-capture", "command-manifest");
-}
-/** A non-terminal transport/spawn failure has no fabricated command outcome. */
-function captureRunnerCommandCaptureFailedV1(handle) {
-    const state = commandHandleStateV1(handle);
+    state.runtime.commandLimitations.addCaptureInterrupted("command-capture", "command-stdout");
+    state.runtime.commandLimitations.addCaptureInterrupted("command-capture", "command-stderr");
+    recordTerminalCommandResult(state, Object.freeze({
+        kind: "terminated",
+        reason: "cancelled",
+    }));
+}
+/** Retains a registered command when the provider cannot return a normal result. */
+function captureRunnerCommandCaptureFailed(handle, reason = "transport-lost") {
+    const state = commandHandleState(handle);
     if (state === undefined)
         return;
     state.runtime.commandLimitations.addCaptureFailed("command-capture", "command-manifest");
+    state.runtime.commandLimitations.addCaptureFailed("command-capture", "command-stdout");
+    state.runtime.commandLimitations.addCaptureFailed("command-capture", "command-stderr");
+    recordTerminalCommandResult(state, reason === "spawn-failed"
+        ? Object.freeze({ kind: "not-started", reason: "spawn-failed" })
+        : Object.freeze({ kind: "terminated", reason: "transport-lost" }));
 }
-function usageNonNegativeIntegerV1(value) {
-    return typeof value === "number" ? (0, model_ts_1.makeNonNegativeSafeIntegerV1)(value) : undefined;
+function usageNonNegativeInteger(value) {
+    return typeof value === "number" ? (0, model_ts_1.makeNonNegativeSafeInteger)(value) : undefined;
 }
-function canonicalDecimalFromNumberV1(value) {
+function canonicalDecimalFromNumber(value) {
     if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
         return undefined;
     const source = String(value);
     const plain = source.includes("e") || source.includes("E")
-        ? expandExponentialDecimalV1(source)
+        ? expandExponentialDecimal(source)
         : source;
     if (plain === undefined)
         return undefined;
     const normalized = plain.includes(".")
         ? plain.replace(/0+$/u, "").replace(/\.$/u, "")
         : plain;
-    return (0, model_ts_1.makeCanonicalDecimalV1)(normalized);
+    return (0, model_ts_1.makeCanonicalDecimal)(normalized);
 }
-function expandExponentialDecimalV1(value) {
+function expandExponentialDecimal(value) {
     const match = /^(\d+)(?:\.(\d+))?[eE]([+-]?\d+)$/u.exec(value);
     if (match === null)
         return undefined;
@@ -595,17 +677,17 @@ function expandExponentialDecimalV1(value) {
         return `${digits}${"0".repeat(decimalIndex - digits.length)}`;
     return `${digits.slice(0, decimalIndex)}.${digits.slice(decimalIndex)}`;
 }
-function appendUsageObservationV1(runtime, create) {
-    if (runtime.usage.length >= limits_ts_1.MAX_USAGE_OBSERVATIONS_V1) {
+function appendUsageObservation(runtime, create) {
+    if (runtime.usage.length >= limits_ts_1.MAX_USAGE_OBSERVATIONS) {
         runtime.usageLimitations.addCap("usage-observation", runtime.usage.length);
         return;
     }
-    const provider = (0, model_ts_1.makeSafeIdentifierV1)(runtime.providerName);
+    const provider = (0, model_ts_1.makeSafeIdentifier)(runtime.providerName);
     if (provider === undefined) {
         runtime.usageLimitations.addUnsupported("usage-observation");
         return;
     }
-    const usageObservationId = mintRuntimeEntityV1(runtime, "usage-observation");
+    const usageObservationId = mintRuntimeEntity(runtime, "usage-observation");
     if (usageObservationId === undefined)
         return;
     runtime.usage.push(create(usageObservationId, provider));
@@ -615,8 +697,8 @@ function appendUsageObservationV1(runtime, create) {
  * callback. It never looks at an Attempt aggregate or derives a request from
  * a token count.
  */
-function captureRunnerTurnUsageV1(runtimeHandle, usage) {
-    const runtime = runtimeStateV1(runtimeHandle);
+function captureRunnerTurnUsage(runtimeHandle, usage) {
+    const runtime = runtimeState(runtimeHandle);
     if (runtime === undefined || runtime.failure !== undefined)
         return;
     const tokenBuckets = [
@@ -630,12 +712,12 @@ function captureRunnerTurnUsageV1(runtimeHandle, usage) {
         const raw = usage[field];
         if (raw === undefined)
             continue;
-        const tokens = usageNonNegativeIntegerV1(raw);
+        const tokens = usageNonNegativeInteger(raw);
         if (tokens === undefined) {
             runtime.usageLimitations.addUnsupported("usage-observation");
             continue;
         }
-        appendUsageObservationV1(runtime, (usageObservationId, provider) => Object.freeze({
+        appendUsageObservation(runtime, (usageObservationId, provider) => Object.freeze({
             usageObservationId,
             provider,
             kind: "token-bucket",
@@ -645,34 +727,34 @@ function captureRunnerTurnUsageV1(runtimeHandle, usage) {
         }));
     }
     if (usage.requests !== undefined) {
-        const requests = usageNonNegativeIntegerV1(usage.requests);
+        const requests = usageNonNegativeInteger(usage.requests);
         if (requests === undefined) {
             runtime.usageLimitations.addUnsupported("usage-observation");
         }
         else {
             for (let request = 0; request < requests; request += 1) {
-                appendUsageObservationV1(runtime, (usageObservationId, provider) => Object.freeze({
+                appendUsageObservation(runtime, (usageObservationId, provider) => Object.freeze({
                     usageObservationId,
                     provider,
                     kind: "request",
                     requestKind: "model",
                     refs: Object.freeze([]),
                 }));
-                if (runtime.usage.length >= limits_ts_1.MAX_USAGE_OBSERVATIONS_V1)
+                if (runtime.usage.length >= limits_ts_1.MAX_USAGE_OBSERVATIONS)
                     break;
             }
         }
     }
     if (usage.costUSD !== undefined) {
-        const amount = canonicalDecimalFromNumberV1(usage.costUSD);
+        const amount = canonicalDecimalFromNumber(usage.costUSD);
         if (amount === undefined) {
             runtime.usageLimitations.addUnsupported("usage-observation");
         }
         else {
-            const currency = (0, model_ts_1.makeCurrencyCodeV1)("USD");
+            const currency = (0, model_ts_1.makeCurrencyCode)("USD");
             if (currency === undefined)
                 throw new Error("USD must be a CurrencyCode");
-            appendUsageObservationV1(runtime, (usageObservationId, provider) => Object.freeze({
+            appendUsageObservation(runtime, (usageObservationId, provider) => Object.freeze({
                 usageObservationId,
                 provider,
                 kind: "provider-cost",
@@ -683,33 +765,16 @@ function captureRunnerTurnUsageV1(runtimeHandle, usage) {
         }
     }
 }
-function attemptConversationOutcomeV1(result, sealed) {
-    if (sealed.evaluation.explicitlySkipped)
-        return "cancelled";
-    return result.error === undefined && sealed.evaluation.execution === "completed"
-        ? "completed"
-        : "failed";
-}
-function standardEventUnavailableV1(result, limitations) {
-    if (result.events === undefined) {
-        limitations.addCaptureFailed("adapter", "conversation-item");
-        return true;
-    }
-    if (result.evidenceCoverage.events.status !== "complete") {
-        limitations.addCaptureFailed("adapter", "conversation-item");
-    }
-    return false;
-}
-function safeIdentifierV1(value) {
-    return (0, model_ts_1.makeSafeIdentifierV1)(value);
+function safeIdentifier(value) {
+    return (0, model_ts_1.makeSafeIdentifier)(value);
 }
-function sourceNativeToolNameV1(value) {
-    return (0, model_ts_1.makeSourceNativeToolNameV1)(value);
+function sourceNativeToolName(value) {
+    return (0, model_ts_1.makeSourceNativeToolName)(value);
 }
-function stableLabelV1(value) {
-    return (0, model_ts_1.makeStableLabelV1)(value);
+function stableLabel(value) {
+    return (0, model_ts_1.makeStableLabel)(value);
 }
-function eventCannotBePersistedV1(event, limitations) {
+function eventCannotBePersisted(event, limitations) {
     if ((event.redacted?.length ?? 0) > 0) {
         limitations.addRedacted("conversation-item", event.redacted.length);
         return true;
@@ -720,28 +785,25 @@ function eventCannotBePersistedV1(event, limitations) {
     }
     return false;
 }
-function hasConversationCapacityV1(input) {
-    if (input.itemCount >= limits_ts_1.MAX_CONVERSATION_ITEMS_V1) {
+function hasConversationCapacity(input) {
+    if (input.itemCount >= limits_ts_1.MAX_CONVERSATION_ITEMS) {
         input.limitations.addCap("conversation-item", input.itemCount);
         return false;
     }
-    if (!input.hasTurn && input.itemCount >= limits_ts_1.MAX_CONVERSATION_TURNS_V1) {
+    if (!input.hasTurn && input.itemCount >= limits_ts_1.MAX_CONVERSATION_TURNS) {
         input.limitations.addCap("conversation-item", input.itemCount);
         return false;
     }
     return true;
 }
-function appendConversationTextLimitationV1(item, text, limitations) {
+function appendConversationTextLimitation(item, text, limitations) {
     if (item !== undefined && text.omittedBytes !== undefined) {
         limitations.addConversationTextTruncated(item.itemId, text.retainedBytes, text.omittedBytes);
     }
 }
-function normalizeConversationV1(input) {
+function normalizeConversation(input) {
     return effect_1.Effect.gen(function* () {
-        const limitations = new RunnerCollectionLimitationsV1();
-        if (standardEventUnavailableV1(input.result, limitations)) {
-            return Object.freeze({ collection: limitations.collection(), turns: Object.freeze([]), items: Object.freeze([]) });
-        }
+        const limitations = input.runtime.conversationLimitations;
         const items = [];
         let turnId;
         const openTools = new Map();
@@ -749,20 +811,10 @@ function normalizeConversationV1(input) {
         const ensureTurn = () => {
             if (turnId !== undefined)
                 return effect_1.Effect.succeed(turnId);
-            if (!hasConversationCapacityV1({
-                itemCount: items.length,
-                hasTurn: false,
-                limitations,
-            })) {
-                return effect_1.Effect.succeed(undefined);
-            }
-            return effect_1.Effect.map(input.mint("turn"), (id) => {
-                turnId = id;
-                return id;
-            });
+            return effect_1.Effect.succeed(undefined);
         };
         const appendItem = (create) => {
-            if (!hasConversationCapacityV1({
+            if (!hasConversationCapacity({
                 itemCount: items.length,
                 hasTurn: turnId !== undefined,
                 limitations,
@@ -783,209 +835,210 @@ function normalizeConversationV1(input) {
                 return item;
             });
         };
-        for (const event of input.result.events ?? []) {
-            if (eventCannotBePersistedV1(event, limitations))
-                continue;
-            switch (event.type) {
-                case "message": {
-                    const text = retainSafeTextV1(event.text, limits_ts_1.MAX_CONVERSATION_TEXT_BYTES_V1);
-                    if (text === undefined) {
-                        limitations.addUnsupported("conversation-item");
-                        continue;
-                    }
-                    const item = yield* appendItem((ids) => Object.freeze({
-                        ...ids,
-                        kind: "message",
-                        role: event.role,
-                        text: text.text,
-                        refs: Object.freeze([]),
-                    }));
-                    appendConversationTextLimitationV1(item, text, limitations);
-                    break;
-                }
-                case "operation.started": {
-                    if (event.operation.kind === "tool") {
-                        // Conversation is the source-native execution record. Canonical
-                        // ToolName is useful to runtime assertions, but must never replace
-                        // or rescue the provider's real identity in durable evidence.
-                        const tool = sourceNativeToolNameV1(event.operation.name);
-                        const summary = jsonSummaryV1(event.operation.input);
-                        if (tool === undefined || summary === undefined) {
+        for (const capturedTurn of input.runtime.conversationTurns) {
+            turnId = capturedTurn.turnId;
+            for (const event of capturedTurn.events) {
+                if (eventCannotBePersisted(event, limitations))
+                    continue;
+                switch (event.type) {
+                    case "message": {
+                        const text = retainSafeText(event.text, limits_ts_1.MAX_CONVERSATION_TEXT_BYTES);
+                        if (text === undefined) {
                             limitations.addUnsupported("conversation-item");
                             continue;
                         }
-                        if (!hasConversationCapacityV1({
-                            itemCount: items.length,
-                            hasTurn: turnId !== undefined,
-                            limitations,
-                        }))
-                            continue;
-                        const callId = yield* input.mint("call");
                         const item = yield* appendItem((ids) => Object.freeze({
                             ...ids,
-                            kind: "tool-call",
-                            callId,
-                            tool,
-                            inputSummary: summary.text,
+                            kind: "message",
+                            role: event.role,
+                            text: text.text,
                             refs: Object.freeze([]),
                         }));
-                        if (item !== undefined) {
-                            openTools.set(event.operationId, Object.freeze({ callId, turnId: item.turnId }));
-                        }
-                        appendConversationTextLimitationV1(item, summary, limitations);
+                        appendConversationTextLimitation(item, text, limitations);
                         break;
                     }
-                    const label = safeIdentifierV1(event.operation.name);
-                    if (label === undefined) {
-                        limitations.addUnsupported("conversation-item");
-                        continue;
+                    case "operation.started": {
+                        if (event.operation.kind === "tool") {
+                            // Conversation is the source-native execution record. Canonical
+                            // ToolName is useful to runtime assertions, but must never replace
+                            // or rescue the provider's real identity in durable evidence.
+                            const tool = sourceNativeToolName(event.operation.name);
+                            const summary = jsonSummary(event.operation.input);
+                            if (tool === undefined || summary === undefined) {
+                                limitations.addUnsupported("conversation-item");
+                                continue;
+                            }
+                            if (!hasConversationCapacity({
+                                itemCount: items.length,
+                                hasTurn: turnId !== undefined,
+                                limitations,
+                            }))
+                                continue;
+                            const callId = yield* input.mint("call");
+                            const item = yield* appendItem((ids) => Object.freeze({
+                                ...ids,
+                                kind: "tool-call",
+                                callId,
+                                tool,
+                                inputSummary: summary.text,
+                                refs: Object.freeze([]),
+                            }));
+                            if (item !== undefined) {
+                                openTools.set(event.operationId, Object.freeze({ callId, turnId: item.turnId }));
+                            }
+                            appendConversationTextLimitation(item, summary, limitations);
+                            break;
+                        }
+                        const label = safeIdentifier(event.operation.name);
+                        if (label === undefined) {
+                            limitations.addUnsupported("conversation-item");
+                            continue;
+                        }
+                        const item = yield* appendItem((ids) => Object.freeze({
+                            ...ids,
+                            kind: "subagent",
+                            state: "started",
+                            label,
+                            summary: (0, model_ts_1.makeBoundedSafeText)("Subagent started.", limits_ts_1.MAX_CONVERSATION_TEXT_BYTES),
+                            refs: Object.freeze([]),
+                        }));
+                        if (item !== undefined)
+                            openSubagents.set(event.operationId, Object.freeze({ label }));
+                        break;
                     }
-                    const item = yield* appendItem((ids) => Object.freeze({
-                        ...ids,
-                        kind: "subagent",
-                        state: "started",
-                        label,
-                        summary: (0, model_ts_1.makeBoundedSafeTextV1)("Subagent started.", limits_ts_1.MAX_CONVERSATION_TEXT_BYTES_V1),
-                        refs: Object.freeze([]),
-                    }));
-                    if (item !== undefined)
-                        openSubagents.set(event.operationId, Object.freeze({ label }));
-                    break;
-                }
-                case "operation.finished": {
-                    if (event.kind === "tool") {
-                        const open = openTools.get(event.operationId);
-                        const summary = event.output === undefined ? undefined : jsonSummaryV1(event.output);
-                        if (open === undefined || summary === undefined) {
+                    case "operation.finished": {
+                        if (event.kind === "tool") {
+                            const open = openTools.get(event.operationId);
+                            const summary = event.output === undefined ? undefined : jsonSummary(event.output);
+                            if (open === undefined || summary === undefined) {
+                                limitations.addUnsupported("conversation-item");
+                                continue;
+                            }
+                            const item = yield* appendItem((ids) => Object.freeze({
+                                ...ids,
+                                turnId: open.turnId,
+                                kind: "tool-result",
+                                callId: open.callId,
+                                outcome: event.status,
+                                outputSummary: summary.text,
+                                refs: Object.freeze([]),
+                            }));
+                            if (item !== undefined)
+                                openTools.delete(event.operationId);
+                            appendConversationTextLimitation(item, summary, limitations);
+                            break;
+                        }
+                        const open = openSubagents.get(event.operationId);
+                        if (open === undefined) {
                             limitations.addUnsupported("conversation-item");
                             continue;
                         }
                         const item = yield* appendItem((ids) => Object.freeze({
                             ...ids,
-                            turnId: open.turnId,
-                            kind: "tool-result",
-                            callId: open.callId,
-                            outcome: event.status,
-                            outputSummary: summary.text,
+                            kind: "subagent",
+                            state: event.status,
+                            label: open.label,
+                            summary: (0, model_ts_1.makeBoundedSafeText)(event.status === "completed" ? "Subagent completed." : "Subagent failed.", limits_ts_1.MAX_CONVERSATION_TEXT_BYTES),
                             refs: Object.freeze([]),
                         }));
                         if (item !== undefined)
-                            openTools.delete(event.operationId);
-                        appendConversationTextLimitationV1(item, summary, limitations);
+                            openSubagents.delete(event.operationId);
                         break;
                     }
-                    const open = openSubagents.get(event.operationId);
-                    if (open === undefined) {
-                        limitations.addUnsupported("conversation-item");
-                        continue;
+                    case "skill.loaded": {
+                        const skill = safeIdentifier(event.skill);
+                        if (skill === undefined) {
+                            limitations.addUnsupported("conversation-item");
+                            continue;
+                        }
+                        yield* appendItem((ids) => Object.freeze({
+                            ...ids,
+                            kind: "skill-load",
+                            skill,
+                            outcome: "loaded",
+                            refs: Object.freeze([]),
+                        }));
+                        break;
                     }
-                    const item = yield* appendItem((ids) => Object.freeze({
-                        ...ids,
-                        kind: "subagent",
-                        state: event.status,
-                        label: open.label,
-                        summary: (0, model_ts_1.makeBoundedSafeTextV1)(event.status === "completed" ? "Subagent completed." : "Subagent failed.", limits_ts_1.MAX_CONVERSATION_TEXT_BYTES_V1),
-                        refs: Object.freeze([]),
-                    }));
-                    if (item !== undefined)
-                        openSubagents.delete(event.operationId);
-                    break;
-                }
-                case "skill.loaded": {
-                    const skill = safeIdentifierV1(event.skill);
-                    if (skill === undefined) {
-                        limitations.addUnsupported("conversation-item");
-                        continue;
+                    case "input.requested": {
+                        const source = event.request.prompt ?? event.request.display;
+                        const summary = source === undefined
+                            ? (event.request.input === undefined ? undefined : jsonSummary(event.request.input))
+                            : retainSafeText(source, limits_ts_1.MAX_CONVERSATION_TEXT_BYTES);
+                        if (summary === undefined) {
+                            limitations.addUnsupported("conversation-item");
+                            continue;
+                        }
+                        const item = yield* appendItem((ids) => Object.freeze({
+                            ...ids,
+                            kind: "input-request",
+                            state: "requested",
+                            promptSummary: summary.text,
+                            responseSummary: null,
+                            refs: Object.freeze([]),
+                        }));
+                        appendConversationTextLimitation(item, summary, limitations);
+                        // StreamEvent has no corresponding response event, so null cannot
+                        // claim a complete request/response capture.
+                        limitations.addCaptureFailed("adapter", "conversation-item");
+                        break;
                     }
-                    yield* appendItem((ids) => Object.freeze({
-                        ...ids,
-                        kind: "skill-load",
-                        skill,
-                        outcome: "loaded",
-                        refs: Object.freeze([]),
-                    }));
-                    break;
-                }
-                case "input.requested": {
-                    const source = event.request.prompt ?? event.request.display;
-                    const summary = source === undefined
-                        ? (event.request.input === undefined ? undefined : jsonSummaryV1(event.request.input))
-                        : retainSafeTextV1(source, limits_ts_1.MAX_CONVERSATION_TEXT_BYTES_V1);
-                    if (summary === undefined) {
-                        limitations.addUnsupported("conversation-item");
-                        continue;
+                    case "context.injected": {
+                        const source = event.source;
+                        const summary = retainSafeText(event.text, limits_ts_1.MAX_CONVERSATION_TEXT_BYTES);
+                        if (summary === undefined ||
+                            (source !== "system" && source !== "memory" && source !== "skill" && source !== "user")) {
+                            limitations.addUnsupported("conversation-item");
+                            continue;
+                        }
+                        const item = yield* appendItem((ids) => Object.freeze({
+                            ...ids,
+                            kind: "context-injection",
+                            source,
+                            summary: summary.text,
+                            refs: Object.freeze([]),
+                        }));
+                        appendConversationTextLimitation(item, summary, limitations);
+                        break;
                     }
-                    const item = yield* appendItem((ids) => Object.freeze({
-                        ...ids,
-                        kind: "input-request",
-                        state: "requested",
-                        promptSummary: summary.text,
-                        responseSummary: null,
-                        refs: Object.freeze([]),
-                    }));
-                    appendConversationTextLimitationV1(item, summary, limitations);
-                    // StreamEvent has no corresponding response event, so null cannot
-                    // claim a complete request/response capture.
-                    limitations.addCaptureFailed("adapter", "conversation-item");
-                    break;
-                }
-                case "context.injected": {
-                    const source = event.source;
-                    const summary = retainSafeTextV1(event.text, limits_ts_1.MAX_CONVERSATION_TEXT_BYTES_V1);
-                    if (summary === undefined ||
-                        (source !== "system" && source !== "memory" && source !== "skill" && source !== "user")) {
-                        limitations.addUnsupported("conversation-item");
-                        continue;
+                    case "error": {
+                        const redacted = (0, redaction_ts_1.redactSensitiveText)(event.message, input.runtime.sensitiveValues);
+                        if (redacted !== event.message)
+                            limitations.addRedacted("conversation-text");
+                        const summary = retainSafeText(redacted, limits_ts_1.MAX_CONVERSATION_TEXT_BYTES);
+                        if (summary === undefined) {
+                            limitations.addUnsupported("conversation-item");
+                            continue;
+                        }
+                        const item = yield* appendItem((ids) => Object.freeze({
+                            ...ids,
+                            kind: "conversation-error",
+                            code: (0, model_ts_1.makeSafeIdentifier)("stream-error"),
+                            summary: summary.text,
+                            refs: Object.freeze([]),
+                        }));
+                        appendConversationTextLimitation(item, summary, limitations);
+                        break;
                     }
-                    const item = yield* appendItem((ids) => Object.freeze({
-                        ...ids,
-                        kind: "context-injection",
-                        source,
-                        summary: summary.text,
-                        refs: Object.freeze([]),
-                    }));
-                    appendConversationTextLimitationV1(item, summary, limitations);
-                    break;
-                }
-                case "error": {
-                    const redacted = (0, redaction_ts_1.redactSensitiveText)(event.message, input.runtime.sensitiveValues);
-                    if (redacted !== event.message)
-                        limitations.addRedacted("conversation-text");
-                    const summary = retainSafeTextV1(redacted, limits_ts_1.MAX_CONVERSATION_TEXT_BYTES_V1);
-                    if (summary === undefined) {
+                    // Thinking can contain hidden reasoning, and compaction has no safe
+                    // item count in StreamEvent. Both are deliberately retained only as
+                    // structured partial coverage, never as invented summaries.
+                    case "thinking":
+                    case "compaction":
                         limitations.addUnsupported("conversation-item");
-                        continue;
-                    }
-                    const item = yield* appendItem((ids) => Object.freeze({
-                        ...ids,
-                        kind: "conversation-error",
-                        code: (0, model_ts_1.makeSafeIdentifierV1)("stream-error"),
-                        summary: summary.text,
-                        refs: Object.freeze([]),
-                    }));
-                    appendConversationTextLimitationV1(item, summary, limitations);
-                    break;
+                        break;
                 }
-                // Thinking can contain hidden reasoning, and compaction has no safe
-                // item count in StreamEvent. Both are deliberately retained only as
-                // structured partial coverage, never as invented summaries.
-                case "thinking":
-                case "compaction":
-                    limitations.addUnsupported("conversation-item");
-                    break;
             }
         }
         if (openTools.size > 0 || openSubagents.size > 0) {
             limitations.addUnsupported("conversation-item", openTools.size + openSubagents.size);
         }
-        const turns = turnId === undefined
-            ? Object.freeze([])
-            : Object.freeze([Object.freeze({
-                    turnId,
-                    sequence: requiredPositive(1),
-                    outcome: attemptConversationOutcomeV1(input.result, input.sealed),
-                    refs: Object.freeze([]),
-                })]);
+        const turns = Object.freeze(input.runtime.conversationTurns.map((capturedTurn) => Object.freeze({
+            turnId: capturedTurn.turnId,
+            sequence: capturedTurn.sequence,
+            outcome: capturedTurn.outcome,
+            refs: Object.freeze([]),
+        })));
         return Object.freeze({
             collection: limitations.collection(),
             turns,
@@ -993,29 +1046,36 @@ function normalizeConversationV1(input) {
         });
     });
 }
-function commandSafeTextV1(input) {
+function commandSafeText(input) {
     const redacted = (0, redaction_ts_1.redactSensitiveText)(input.value, input.runtime.sensitiveValues);
     if (redacted !== input.value)
         input.runtime.commandLimitations.addRedacted(input.target);
-    const retained = retainSafeTextV1(redacted, input.maximumBytes);
+    const retained = retainSafeText(redacted, input.maximumBytes);
     if (retained === undefined) {
-        input.runtime.commandLimitations.addUnsupported("command-manifest");
-        return undefined;
+        // A registered command must retain its manifest even when a provider text
+        // field cannot be represented safely. The partial collection records the
+        // replacement rather than dropping the command.
+        input.runtime.commandLimitations.addCaptureFailed("command-capture", input.target);
+        const replacement = (0, model_ts_1.makeBoundedSafeText)("[unavailable]", input.maximumBytes);
+        if (replacement === undefined) {
+            throw new Error("The fixed unavailable command marker must be SafeText");
+        }
+        return replacement;
     }
     if (retained.omittedBytes !== undefined) {
         input.runtime.commandLimitations.addCommandManifestTextTruncated(input.commandId, retained.retainedBytes, retained.omittedBytes);
     }
     return retained.text;
 }
-function isProjectRelativeCommandPathV1(value) {
-    return ((0, model_ts_1.makeBoundedSafeTextV1)(value, limits_ts_1.MAX_COMMAND_PROJECT_RELATIVE_PATH_BYTES_V1) !== undefined &&
+function isProjectRelativeCommandPath(value) {
+    return ((0, model_ts_1.makeBoundedSafeText)(value, limits_ts_1.MAX_COMMAND_PROJECT_RELATIVE_PATH_BYTES) !== undefined &&
         value.length > 0 &&
         !value.startsWith("/") &&
         !value.includes("\\") &&
         !value.includes(":") &&
         value.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== ".."));
 }
-function commandWorkingDirectoryV1(options, runtime) {
+function commandWorkingDirectory(options, runtime) {
     const candidate = options;
     const cwd = candidate?.cwd;
     if (cwd === undefined || cwd === ".")
@@ -1027,7 +1087,7 @@ function commandWorkingDirectoryV1(options, runtime) {
     const redacted = (0, redaction_ts_1.redactSensitiveText)(cwd, runtime.sensitiveValues);
     if (redacted !== cwd)
         runtime.commandLimitations.addRedacted("command-manifest");
-    if (isProjectRelativeCommandPathV1(redacted)) {
+    if (isProjectRelativeCommandPath(redacted)) {
         return Object.freeze({ kind: "project-relative", path: redacted });
     }
     // Absolute, dot-segment and otherwise unsafe cwd values are deliberately
@@ -1035,53 +1095,43 @@ function commandWorkingDirectoryV1(options, runtime) {
     runtime.commandLimitations.addRedacted("command-manifest");
     return Object.freeze({ kind: "redacted" });
 }
-function commandManifestV1(command, runtime) {
-    const phase = commandManifestPhaseV1(command.phase);
-    if (phase === undefined) {
-        runtime.commandLimitations.addUnsupported("command-manifest");
-        return undefined;
-    }
-    const workingDirectory = commandWorkingDirectoryV1(command.options, runtime);
+function commandManifest(command, runtime) {
+    const phase = commandManifestPhase(command.phase);
+    const workingDirectory = commandWorkingDirectory(command.options, runtime);
     if (command.invocationKind === "shell") {
-        const script = commandSafeTextV1({
+        const script = commandSafeText({
             commandId: command.commandId,
             value: command.command,
-            maximumBytes: limits_ts_1.MAX_COMMAND_SHELL_BYTES_V1,
+            maximumBytes: limits_ts_1.MAX_COMMAND_SHELL_BYTES,
             target: "command-manifest",
             runtime,
         });
-        return script === undefined
-            ? undefined
-            : Object.freeze({
-                phase,
-                invocation: Object.freeze({ kind: "shell", command: script }),
-                workingDirectory,
-            });
+        return Object.freeze({
+            phase,
+            invocation: Object.freeze({ kind: "shell", command: script }),
+            workingDirectory,
+        });
     }
-    if ((command.args?.length ?? 0) > limits_ts_1.MAX_COMMAND_ARGUMENTS_V1) {
+    const sourceArguments = command.args ?? [];
+    if (sourceArguments.length > limits_ts_1.MAX_COMMAND_ARGUMENTS) {
         runtime.commandLimitations.addUnsupported("command-manifest");
-        return undefined;
     }
-    const executable = commandSafeTextV1({
+    const executable = commandSafeText({
         commandId: command.commandId,
         value: command.command,
-        maximumBytes: limits_ts_1.MAX_COMMAND_EXECUTABLE_BYTES_V1,
+        maximumBytes: limits_ts_1.MAX_COMMAND_EXECUTABLE_BYTES,
         target: "command-manifest",
         runtime,
     });
-    if (executable === undefined)
-        return undefined;
     const arguments_ = [];
-    for (const raw of command.args ?? []) {
-        const argument = commandSafeTextV1({
+    for (const raw of sourceArguments.slice(0, limits_ts_1.MAX_COMMAND_ARGUMENTS)) {
+        const argument = commandSafeText({
             commandId: command.commandId,
             value: raw,
-            maximumBytes: limits_ts_1.MAX_COMMAND_ARGUMENT_BYTES_V1,
+            maximumBytes: limits_ts_1.MAX_COMMAND_ARGUMENT_BYTES,
             target: "command-manifest",
             runtime,
         });
-        if (argument === undefined)
-            return undefined;
         arguments_.push(argument);
     }
     return Object.freeze({
@@ -1094,7 +1144,7 @@ function commandManifestV1(command, runtime) {
         workingDirectory,
     });
 }
-function stripUnsafeCommandControlsV1(value) {
+function stripUnsafeCommandControls(value) {
     let text = "";
     let count = 0;
     for (const scalar of value) {
@@ -1108,25 +1158,25 @@ function stripUnsafeCommandControlsV1(value) {
     }
     return Object.freeze({ text, count });
 }
-function emptyCommandStreamV1() {
-    const text = (0, model_ts_1.makeBoundedSafeTextV1)("", limits_ts_1.MAX_COMMAND_STREAM_BYTES_V1);
+function emptyCommandStream() {
+    const text = (0, model_ts_1.makeBoundedSafeText)("", limits_ts_1.MAX_COMMAND_STREAM_BYTES);
     if (text === undefined)
         throw new Error("An empty command stream must be SafeText");
     return Object.freeze({ text, totalSafeUtf8Bytes: requiredNonNegative(0) });
 }
-function commandStreamV1(input) {
+function commandStream(input) {
     const target = input.stream === "stdout" ? "command-stdout" : "command-stderr";
     const redacted = (0, redaction_ts_1.redactSensitiveText)(input.value, input.runtime.sensitiveValues);
     if (redacted !== input.value)
         input.runtime.commandLimitations.addRedacted(target);
-    const stripped = stripUnsafeCommandControlsV1(redacted);
+    const stripped = stripUnsafeCommandControls(redacted);
     if (stripped.count > 0) {
         input.runtime.commandLimitations.addUnsafeCommandControlStripped(input.commandId, input.stream, stripped.count);
     }
-    const retained = retainSafeTextV1(stripped.text, limits_ts_1.MAX_COMMAND_STREAM_BYTES_V1);
+    const retained = retainSafeText(stripped.text, limits_ts_1.MAX_COMMAND_STREAM_BYTES);
     if (retained === undefined) {
         input.runtime.commandLimitations.addCaptureFailed("command-capture", target);
-        return emptyCommandStreamV1();
+        return emptyCommandStream();
     }
     if (retained.omittedBytes !== undefined) {
         input.runtime.commandLimitations.addCommandStreamTruncated(input.commandId, input.stream, retained.retainedBytes, retained.omittedBytes);
@@ -1136,41 +1186,49 @@ function commandStreamV1(input) {
         : requiredNonNegative(retained.retainedBytes + retained.omittedBytes);
     return Object.freeze({ text: retained.text, totalSafeUtf8Bytes });
 }
-function normalizeCommandsV1(runtime) {
+function normalizeCommands(runtime) {
     const commands = [];
     for (const captured of runtime.commands) {
         if (captured.result === undefined) {
+            // The manifest was registered before the sandbox call. If its normal
+            // result never arrived, retain it with the only accurate fallback: the
+            // transport did not provide a terminal command result.
             runtime.commandLimitations.addCaptureFailed("command-capture", "command-manifest");
-            continue;
+            runtime.commandLimitations.addCaptureFailed("command-capture", "command-stdout");
+            runtime.commandLimitations.addCaptureFailed("command-capture", "command-stderr");
+            recordTerminalCommandResult(Object.freeze({ runtime, command: captured }), Object.freeze({ kind: "terminated", reason: "transport-lost" }));
         }
-        const manifest = commandManifestV1(captured, runtime);
-        if (manifest === undefined)
+        const result = captured.result;
+        if (result === undefined) {
+            markRuntimeFailure(runtime, producerCommandRegistrationInvalid());
             continue;
-        const stdout = commandStreamV1({
+        }
+        const manifest = commandManifest(captured, runtime);
+        const stdout = commandStream({
             commandId: captured.commandId,
             stream: "stdout",
-            value: captured.result.stdout,
+            value: result.stdout,
             runtime,
         });
-        const stderr = commandStreamV1({
+        const stderr = commandStream({
             commandId: captured.commandId,
             stream: "stderr",
-            value: captured.result.stderr,
+            value: result.stderr,
             runtime,
         });
         commands.push(Object.freeze({
             commandId: captured.commandId,
             manifest,
-            result: Object.freeze({ outcome: captured.result.outcome, stdout, stderr }),
+            result: Object.freeze({ outcome: result.outcome, stdout, stderr }),
             refs: Object.freeze([]),
         }));
     }
     return Object.freeze({
         collection: runtime.commandLimitations.collection(),
-        commands: Object.freeze([...commands].sort((left, right) => (0, model_ts_1.compareObservabilityTextV1)(left.commandId, right.commandId))),
+        commands: Object.freeze([...commands].sort((left, right) => (0, model_ts_1.compareObservabilityText)(left.commandId, right.commandId))),
     });
 }
-function normalizeUsageV1(input) {
+function normalizeUsage(input) {
     // EvalResult.usage remains an aggregate for legacy consumers. Only records
     // captured from actual Session onTurn values above enter this family.
     if (input.result.evidenceCoverage.usage.status !== "complete") {
@@ -1184,70 +1242,85 @@ function normalizeUsageV1(input) {
     }
     return Object.freeze({
         collection: input.runtime.usageLimitations.collection(),
-        observations: Object.freeze([...input.runtime.usage].sort((left, right) => (0, model_ts_1.compareObservabilityTextV1)(left.usageObservationId, right.usageObservationId))),
+        observations: Object.freeze([...input.runtime.usage].sort((left, right) => (0, model_ts_1.compareObservabilityText)(left.usageObservationId, right.usageObservationId))),
     });
 }
-function attemptTimingProjectionV1(phase) {
-    const label = stableLabelV1(phase);
+function attemptTimingProjection(phase) {
+    const label = stableLabel(phase);
     if (label === undefined)
-        return undefined;
+        return Object.freeze({ kind: "unsupported" });
     switch (phase) {
         case "sandbox.create":
         case "workspace.baseline":
         case "agent.setup":
         case "telemetry.configure":
-            return Object.freeze({ phase: "attempt.setup", label });
+        case "sandbox.queue":
+            return Object.freeze({ kind: "attempt", phase: "attempt.setup", label });
         case "sandbox.prepare":
         case "sandbox.prepare.eval":
         case "sandbox.prepare.group":
         case "sandbox.prepare.experiment":
-            return Object.freeze({ phase: "sandbox.prepare", label });
+            return Object.freeze({ kind: "attempt", phase: "sandbox.prepare", label });
         case "agent.ensure":
-            return Object.freeze({ phase: "agent.ensure", label });
+            return Object.freeze({ kind: "attempt", phase: "agent.ensure", label });
         case "eval.run":
-            return Object.freeze({ phase: "eval.run", label });
+            return Object.freeze({ kind: "attempt", phase: "eval.run", label });
         case "assertions.evaluate":
-            return Object.freeze({ phase: "assertion.evaluate", label });
+            return Object.freeze({ kind: "attempt", phase: "assertion.evaluate", label });
         case "agent.teardown":
         case "sandbox.cleanup":
         case "sandbox.suspend":
         case "sandbox.stop":
-            return Object.freeze({ phase: "attempt.teardown", label });
+        case "workspace.diff":
+        case "telemetry.collect":
+            return Object.freeze({ kind: "attempt", phase: "attempt.teardown", label });
         case "judge.precheck":
         case "experiment.setup":
         case "experiment.teardown":
-        case "sandbox.queue":
         case "agent.run":
-        case "workspace.diff":
-        case "telemetry.collect":
-            return undefined;
-    }
-}
-function validPhaseDurationV1(value) {
-    return (0, model_ts_1.makeNonNegativeSafeIntegerV1)(value.durationMs);
-}
-function timingActivityProjectionV1(activity) {
-    const label = stableLabelV1(activity.label);
+            return Object.freeze({ kind: "outside-attempt-domain" });
+        default:
+            return Object.freeze({ kind: "unsupported" });
+    }
+}
+function validPhaseDuration(value) {
+    return (0, model_ts_1.makeNonNegativeSafeInteger)(value.durationMs);
+}
+function validPhaseStartOffset(value) {
+    return (0, model_ts_1.makeNonNegativeSafeInteger)(value.startOffsetMs);
+}
+function timingActivityProjection(activity) {
+    const phase = (() => {
+        switch (activity.key) {
+            case "agent.turn":
+                return "agent.send";
+            case "sandbox.command":
+                return "sandbox.command";
+            case "sandbox.prepare":
+                return "sandbox.prepare";
+            case "workspace.diff.export":
+                return "attempt.teardown";
+            default:
+                return undefined;
+        }
+    })();
+    if (phase === undefined)
+        return undefined;
+    // Runner's activity label is human-facing and can contain spaces or other
+    // SafeText punctuation. v1 persists only StableLabel, so standard activities
+    // retain a stable key when their display label cannot cross that boundary.
+    const label = stableLabel(activity.label) ?? stableLabel(activity.key);
     if (label === undefined)
         return undefined;
-    switch (activity.key) {
-        case "agent.turn":
-            return Object.freeze({ phase: "agent.send", label });
-        case "sandbox.command":
-            return Object.freeze({ phase: "sandbox.command", label });
-        case "sandbox.prepare":
-            return Object.freeze({ phase: "sandbox.prepare", label });
-        default:
-            return undefined;
-    }
+    return Object.freeze({ phase, label });
 }
-function validTimingActivityStartV1(activity) {
-    return (0, model_ts_1.makeNonNegativeSafeIntegerV1)(activity.startOffsetMs);
+function validTimingActivityStart(activity) {
+    return (0, model_ts_1.makeNonNegativeSafeInteger)(activity.startOffsetMs);
 }
-function validTimingActivityDurationV1(activity) {
-    return (0, model_ts_1.makeNonNegativeSafeIntegerV1)(activity.durationMs);
+function validTimingActivityDuration(activity) {
+    return (0, model_ts_1.makeNonNegativeSafeInteger)(activity.durationMs);
 }
-function timingSpanContainsV1(input) {
+function timingSpanContains(input) {
     const parentEnd = input.parentStartOffsetMs + input.parentDurationMs;
     const childEnd = input.childStartOffsetMs + input.childDurationMs;
     return (Number.isSafeInteger(parentEnd) &&
@@ -1255,13 +1328,19 @@ function timingSpanContainsV1(input) {
         input.parentStartOffsetMs <= input.childStartOffsetMs &&
         childEnd <= parentEnd);
 }
-function normalizeAttemptTimingV1(input) {
+function normalizeAttemptTiming(input) {
     return effect_1.Effect.gen(function* () {
-        const limitations = new RunnerCollectionLimitationsV1();
+        const limitations = new RunnerCollectionLimitations();
+        const turnsById = new Map(input.turns.map((turn) => [turn.turnId, turn]));
+        const intervalByTurnId = new Map();
+        const ambiguousTurnIntervals = new Set();
         const phases = input.result.phases;
         if (phases === undefined) {
             limitations.addCaptureFailed("timing-capture", "timing-interval");
-            return Object.freeze({ collection: limitations.collection(), intervals: Object.freeze([]) });
+            return Object.freeze({
+                timing: Object.freeze({ collection: limitations.collection(), intervals: Object.freeze([]) }),
+                intervalByTurnId: new Map(),
+            });
         }
         const intervals = [];
         const appendActivities = (activities, parent, ancestors) => effect_1.Effect.gen(function* () {
@@ -1270,21 +1349,35 @@ function normalizeAttemptTimingV1(input) {
                     limitations.addUnsupported("timing-interval");
                     continue;
                 }
-                const projection = timingActivityProjectionV1(activity);
-                const startOffsetMs = validTimingActivityStartV1(activity);
-                const durationMs = validTimingActivityDurationV1(activity);
-                if (projection === undefined || startOffsetMs === undefined || durationMs === undefined) {
+                const projection = timingActivityProjection(activity);
+                const sourceStartOffsetMs = validTimingActivityStart(activity);
+                const durationMs = validTimingActivityDuration(activity);
+                const relativeStartOffsetMs = parent === undefined || sourceStartOffsetMs === undefined
+                    ? sourceStartOffsetMs
+                    : (0, model_ts_1.makeNonNegativeSafeInteger)(sourceStartOffsetMs - parent.sourceStartOffsetMs);
+                const translatedStartOffsetMs = parent === undefined || relativeStartOffsetMs === undefined
+                    ? relativeStartOffsetMs
+                    : (0, model_ts_1.makeNonNegativeSafeInteger)(parent.startOffsetMs + relativeStartOffsetMs);
+                // A known activity with safe source-clock values remains a fact even
+                // when this parent-relative conversion cannot be proven. Persist its
+                // original interval as a root rather than turning a missing causal
+                // edge into an unsupported-input limitation.
+                const startOffsetMs = translatedStartOffsetMs ?? sourceStartOffsetMs;
+                if (projection === undefined
+                    || sourceStartOffsetMs === undefined
+                    || startOffsetMs === undefined
+                    || durationMs === undefined) {
                     limitations.addUnsupported("timing-interval");
                     continue;
                 }
-                if (intervals.length >= limits_ts_1.MAX_TIMING_INTERVALS_V1) {
+                if (intervals.length >= limits_ts_1.MAX_TIMING_INTERVALS) {
                     limitations.addCap("timing-interval", intervals.length);
                     continue;
                 }
                 const intervalId = yield* input.mint("interval");
-                const parentIntervalId = parent === undefined
+                const parentIntervalId = parent === undefined || translatedStartOffsetMs === undefined
                     ? null
-                    : timingSpanContainsV1({
+                    : timingSpanContains({
                         parentStartOffsetMs: parent.startOffsetMs,
                         parentDurationMs: parent.durationMs,
                         childStartOffsetMs: startOffsetMs,
@@ -1292,12 +1385,6 @@ function normalizeAttemptTimingV1(input) {
                     })
                         ? parent.intervalId
                         : null;
-                if (parent !== undefined && parentIntervalId === null) {
-                    // Phase and child offsets are independently rounded at the Runner
-                    // boundary. When their measured ranges do not prove containment,
-                    // retain the factual child as a root rather than inventing a tree.
-                    limitations.addUnsupported("timing-interval");
-                }
                 intervals.push(Object.freeze({
                     intervalId,
                     phase: projection.phase,
@@ -1308,51 +1395,87 @@ function normalizeAttemptTimingV1(input) {
                     outcome: activity.failed ? "failed" : "completed",
                     refs: Object.freeze([]),
                 }));
+                if (activity.key === "agent.turn" && activity.turnId !== undefined) {
+                    const turnId = turnsById.get(activity.turnId)?.turnId;
+                    if (turnId !== undefined) {
+                        if (intervalByTurnId.has(turnId) || ambiguousTurnIntervals.has(turnId)) {
+                            intervalByTurnId.delete(turnId);
+                            ambiguousTurnIntervals.add(turnId);
+                        }
+                        else {
+                            intervalByTurnId.set(turnId, intervalId);
+                        }
+                    }
+                }
                 const nextAncestors = new Set(ancestors);
                 nextAncestors.add(activity);
-                yield* appendActivities(activity.children, Object.freeze({ intervalId, startOffsetMs, durationMs }), nextAncestors);
+                yield* appendActivities(activity.children, Object.freeze({
+                    intervalId,
+                    startOffsetMs,
+                    sourceStartOffsetMs,
+                    durationMs,
+                }), nextAncestors);
             }
         });
-        let offset = requiredNonNegative(0);
+        // `phases` also carries a few known Run-owned anchors for first-dispatched
+        // work. Keep their raw clock for child translation, but do not let them
+        // create gaps in the Attempt execution-duration clock.
+        let attemptOffset = requiredNonNegative(0);
         for (const source of phases) {
-            const duration = validPhaseDurationV1(source);
-            const projection = attemptTimingProjectionV1(source.name);
-            if (duration === undefined || projection === undefined || offset === undefined) {
+            const duration = validPhaseDuration(source);
+            const sourceStartOffsetMs = validPhaseStartOffset(source);
+            const projection = attemptTimingProjection(source.name);
+            if (duration === undefined
+                || sourceStartOffsetMs === undefined
+                || projection.kind === "unsupported"
+                || attemptOffset === undefined) {
                 limitations.addUnsupported("timing-interval");
             }
-            else if (intervals.length >= limits_ts_1.MAX_TIMING_INTERVALS_V1) {
+            else if (projection.kind === "attempt" && intervals.length >= limits_ts_1.MAX_TIMING_INTERVALS) {
                 limitations.addCap("timing-interval", intervals.length);
             }
-            else {
+            else if (projection.kind === "attempt") {
                 const intervalId = yield* input.mint("interval");
                 intervals.push(Object.freeze({
                     intervalId,
                     phase: projection.phase,
                     label: projection.label,
-                    startOffsetMs: offset,
+                    startOffsetMs: attemptOffset,
                     durationMs: duration,
                     parentIntervalId: null,
                     outcome: source.failed ? "failed" : "completed",
                     refs: Object.freeze([]),
                 }));
-                yield* appendActivities(source.children, Object.freeze({ intervalId, startOffsetMs: offset, durationMs: duration }), new Set());
+                yield* appendActivities(source.children, Object.freeze({
+                    intervalId,
+                    startOffsetMs: attemptOffset,
+                    sourceStartOffsetMs,
+                    durationMs: duration,
+                }), new Set());
             }
-            if (duration === undefined || offset === undefined) {
-                offset = undefined;
+            if (duration === undefined
+                || sourceStartOffsetMs === undefined
+                || attemptOffset === undefined) {
+                attemptOffset = undefined;
             }
             else {
-                offset = (0, model_ts_1.makeNonNegativeSafeIntegerV1)(offset + duration);
+                if (projection.kind !== "outside-attempt-domain") {
+                    attemptOffset = (0, model_ts_1.makeNonNegativeSafeInteger)(attemptOffset + duration);
+                }
             }
         }
         return Object.freeze({
-            collection: limitations.collection(),
-            // The durable timing family canonically orders by opaque entity id; the
-            // offsets retain the Runner's actual lifecycle order.
-            intervals: Object.freeze([...intervals].sort((left, right) => (0, model_ts_1.compareObservabilityTextV1)(left.intervalId, right.intervalId))),
+            timing: Object.freeze({
+                collection: limitations.collection(),
+                // The durable timing family canonically orders by opaque entity id; the
+                // offsets retain the Runner's actual lifecycle order.
+                intervals: Object.freeze([...intervals].sort((left, right) => (0, model_ts_1.compareObservabilityText)(left.intervalId, right.intervalId))),
+            }),
+            intervalByTurnId: new Map(intervalByTurnId),
         });
     });
 }
-function attemptDiagnosticPhaseV1(origin) {
+function attemptDiagnosticPhase(origin) {
     if (origin === undefined || origin.scope !== "attempt")
         return "collection";
     switch (origin.phase) {
@@ -1388,21 +1511,21 @@ function attemptDiagnosticPhaseV1(origin) {
             return "collection";
     }
 }
-function normalizeAttemptDiagnosticsV1(input) {
+function normalizeAttemptDiagnostics(input) {
     return effect_1.Effect.gen(function* () {
-        const limitations = new RunnerCollectionLimitationsV1();
+        const limitations = new RunnerCollectionLimitations();
         const diagnostics = [];
         const append = (value) => {
-            const code = (0, model_ts_1.makeSafeIdentifierV1)(value.code);
+            const code = (0, model_ts_1.makeSafeIdentifier)(value.code);
             if (code === undefined) {
                 limitations.addUnsupported("diagnostic");
                 return effect_1.Effect.void;
             }
-            const retainedSummary = (0, model_ts_1.makeBoundedSafeTextV1)(value.detail, limits_ts_1.MAX_DIAGNOSTIC_SUMMARY_BYTES_V1);
+            const retainedSummary = (0, model_ts_1.makeBoundedSafeText)(value.detail, limits_ts_1.MAX_DIAGNOSTIC_SUMMARY_BYTES);
             if (retainedSummary === undefined) {
                 limitations.addUnsupported("diagnostic");
             }
-            if (diagnostics.length >= limits_ts_1.MAX_DIAGNOSTICS_V1) {
+            if (diagnostics.length >= limits_ts_1.MAX_DIAGNOSTICS) {
                 limitations.addCap("diagnostic", diagnostics.length);
                 return effect_1.Effect.void;
             }
@@ -1411,14 +1534,14 @@ function normalizeAttemptDiagnosticsV1(input) {
                     diagnosticId: diagnosticId,
                     kind: value.kind,
                     code,
-                    phase: attemptDiagnosticPhaseV1(value.origin),
+                    phase: attemptDiagnosticPhase(value.origin),
                     // The result's one-line detail is already Runner-redacted. Causes,
                     // stacks, paths, and arbitrary context remain outside this durable
                     // family. An unsafe or oversized detail is deliberately replaced by
                     // a generic bounded summary and represented as partial coverage.
-                    summary: retainedSummary ?? (0, model_ts_1.makeBoundedSafeTextV1)(value.kind === "execution-error"
+                    summary: retainedSummary ?? (0, model_ts_1.makeBoundedSafeText)(value.kind === "execution-error"
                         ? "Runner recorded an execution error."
-                        : "Runner recorded an advisory diagnostic.", limits_ts_1.MAX_DIAGNOSTIC_SUMMARY_BYTES_V1),
+                        : "Runner recorded an advisory diagnostic.", limits_ts_1.MAX_DIAGNOSTIC_SUMMARY_BYTES),
                     causes: Object.freeze([]),
                     context: Object.freeze([]),
                     redaction: Object.freeze({ state: "none" }),
@@ -1445,11 +1568,11 @@ function normalizeAttemptDiagnosticsV1(input) {
         }
         return Object.freeze({
             collection: limitations.collection(),
-            diagnostics: Object.freeze([...diagnostics].sort((left, right) => (0, model_ts_1.compareObservabilityTextV1)(left.diagnosticId, right.diagnosticId))),
+            diagnostics: Object.freeze([...diagnostics].sort((left, right) => (0, model_ts_1.compareObservabilityText)(left.diagnosticId, right.diagnosticId))),
         });
     });
 }
-function runDiagnosticPhaseV1(origin) {
+function runDiagnosticPhase(origin) {
     // Runner's existing experiment diagnostic accumulator predates the
     // owner-local Attachment and represents its lifecycle anchor as an Attempt
     // origin. Its phase is still a real Run fact; no timing-node or provider
@@ -1466,24 +1589,24 @@ function runDiagnosticPhaseV1(origin) {
             return "collection";
     }
 }
-function normalizeRunDiagnosticsV1(input) {
+function normalizeRunDiagnostics(input) {
     return effect_1.Effect.gen(function* () {
-        const limitations = new RunnerCollectionLimitationsV1();
+        const limitations = new RunnerCollectionLimitations();
         if (input.diagnostics === undefined) {
             limitations.addCaptureFailed("run-teardown", "diagnostic");
             return Object.freeze({ collection: limitations.collection(), diagnostics: Object.freeze([]) });
         }
         const diagnostics = [];
         for (const source of input.diagnostics) {
-            const code = (0, model_ts_1.makeSafeIdentifierV1)(source.code);
+            const code = (0, model_ts_1.makeSafeIdentifier)(source.code);
             if (code === undefined) {
                 limitations.addUnsupported("diagnostic");
                 continue;
             }
-            const summary = (0, model_ts_1.makeBoundedSafeTextV1)(source.detail, limits_ts_1.MAX_DIAGNOSTIC_SUMMARY_BYTES_V1);
+            const summary = (0, model_ts_1.makeBoundedSafeText)(source.detail, limits_ts_1.MAX_DIAGNOSTIC_SUMMARY_BYTES);
             if (summary === undefined)
                 limitations.addUnsupported("diagnostic");
-            if (diagnostics.length >= limits_ts_1.MAX_DIAGNOSTICS_V1) {
+            if (diagnostics.length >= limits_ts_1.MAX_DIAGNOSTICS) {
                 limitations.addCap("diagnostic", diagnostics.length);
                 continue;
             }
@@ -1492,10 +1615,10 @@ function normalizeRunDiagnosticsV1(input) {
                 diagnosticId: diagnosticId,
                 kind: source.level === "error" ? "execution-error" : "advisory",
                 code,
-                phase: runDiagnosticPhaseV1(source.origin),
-                summary: summary ?? (0, model_ts_1.makeBoundedSafeTextV1)(source.level === "error"
+                phase: runDiagnosticPhase(source.origin),
+                summary: summary ?? (0, model_ts_1.makeBoundedSafeText)(source.level === "error"
                     ? "Runner recorded an execution error."
-                    : "Runner recorded an advisory diagnostic.", limits_ts_1.MAX_DIAGNOSTIC_SUMMARY_BYTES_V1),
+                    : "Runner recorded an advisory diagnostic.", limits_ts_1.MAX_DIAGNOSTIC_SUMMARY_BYTES),
                 causes: Object.freeze([]),
                 context: Object.freeze([]),
                 redaction: Object.freeze({ state: "none" }),
@@ -1505,7 +1628,7 @@ function normalizeRunDiagnosticsV1(input) {
         }
         return Object.freeze({
             collection: limitations.collection(),
-            diagnostics: Object.freeze([...diagnostics].sort((left, right) => (0, model_ts_1.compareObservabilityTextV1)(left.diagnosticId, right.diagnosticId))),
+            diagnostics: Object.freeze([...diagnostics].sort((left, right) => (0, model_ts_1.compareObservabilityText)(left.diagnosticId, right.diagnosticId))),
         });
     });
 }
@@ -1513,33 +1636,39 @@ function normalizeRunDiagnosticsV1(input) {
  * Normalizes only facts already sealed by Runner. It never reads legacy
  * result.json, raw transcript/provider data, Report/Sample data, or paths.
  */
-function createRunnerAttemptObservabilityCaptureV1(input) {
+function createRunnerAttemptObservabilityCapture(input) {
     return effect_1.Effect.gen(function* () {
-        const runtime = runnerAttemptResultStatesV1.get(input.result);
+        const runtime = runnerAttemptResultStates.get(input.result);
         if (runtime === undefined)
             return yield* effect_1.Effect.fail(producerCaptureMissing());
         if (runtime.failure !== undefined)
             return yield* effect_1.Effect.fail(runtime.failure);
-        const minter = makeAttemptEntityMinterV1(runtime);
-        const commands = normalizeCommandsV1(runtime);
-        const usage = normalizeUsageV1({ result: input.result, runtime });
-        const conversation = yield* normalizeConversationV1({
+        const minter = makeAttemptEntityMinter(runtime);
+        const commands = normalizeCommands(runtime);
+        const usage = normalizeUsage({ result: input.result, runtime });
+        const timingNormalization = yield* normalizeAttemptTiming({
             result: input.result,
-            sealed: input.sealed,
+            mint: minter.mint,
+            turns: runtime.conversationTurns,
+        });
+        if (runtime.conversationTurns.some((turn) => !timingNormalization.intervalByTurnId.has(turn.turnId))) {
+            runtime.conversationLimitations.addCaptureFailed("timing-capture", "conversation-item");
+        }
+        const conversation = yield* normalizeConversation({
             mint: minter.mint,
             runtime,
         });
-        const timing = yield* normalizeAttemptTimingV1({ result: input.result, mint: minter.mint });
-        const diagnostics = yield* normalizeAttemptDiagnosticsV1({ result: input.result, mint: minter.mint });
+        const diagnostics = yield* normalizeAttemptDiagnostics({ result: input.result, mint: minter.mint });
         if (runtime.failure !== undefined)
             return yield* effect_1.Effect.fail(runtime.failure);
         if (!minter.seal())
             return yield* effect_1.Effect.fail(producerCaptureSealInvalid("attempt"));
+        runnerAttemptResultTurnIntervals.set(input.result, new Map(timingNormalization.intervalByTurnId));
         return Object.freeze({
             conversation,
             commands,
             usage,
-            timing,
+            timing: timingNormalization.timing,
             diagnostics,
         });
     });
@@ -1551,14 +1680,14 @@ function createRunnerAttemptObservabilityCaptureV1(input) {
  * attribution. Settled Run diagnostics are bound by run.ts immediately before
  * this same publish boundary.
  */
-function createRunnerRunObservabilityCaptureV1(input) {
+function createRunnerRunObservabilityCapture(input) {
     return effect_1.Effect.gen(function* () {
-        const capture = (0, capture_ts_1.makeRunObservabilityCaptureIdentityV1)();
-        const minter = makeRunEntityMinterV1(capture);
-        const timingLimitations = new RunnerCollectionLimitationsV1();
+        const capture = (0, capture_ts_1.makeRunObservabilityCaptureIdentity)();
+        const minter = makeRunEntityMinter(capture);
+        const timingLimitations = new RunnerCollectionLimitations();
         timingLimitations.addCaptureFailed("run-teardown", "timing-interval");
-        const diagnostics = yield* normalizeRunDiagnosticsV1({
-            diagnostics: runnerRunDiagnosticsV1.get(input.run),
+        const diagnostics = yield* normalizeRunDiagnostics({
+            diagnostics: runnerRunDiagnostics.get(input.run),
             mint: minter.mint,
         });
         if (!minter.seal())