@abot-ai/runtime 1.4.0 → 1.6.0

package/plugins/exec/source/process-output.ts

@@ -0,0 +1,158 @@
+import type { Readable } from "node:stream";
+import type { ExecOutputBody, ExecOutputWriter } from "./output-contracts.js";
+import type { ExecOutputStore } from "./output-snapshot.js";
+import type { ExecProcessSnapshot, ExecStreamSnapshot } from "./types.js";
+
+type OutputReceipt = Pick<
+  ExecProcessSnapshot,
+  "stdout" | "stderr" | "outputFailure"
+>;
+
+function streamReceipt(body?: ExecOutputBody): ExecStreamSnapshot {
+  return {
+    text: "",
+    sawOutput: (body?.endByte ?? 0) > 0,
+    metadata: {
+      truncated: false,
+      originalChars: 0,
+      returnedChars: 0,
+      omittedChars: 0,
+    },
+    ...(body ? { body } : {}),
+  };
+}
+
+/** Pipe backpressure bounds capture RAM; accepted offsets advance separately. */
+export async function createExecProcessOutput(
+  store: ExecOutputStore,
+  ownerId: string,
+) {
+  const stdout = await store.createWriter({ ownerId, stream: "stdout" });
+  let stderr: ExecOutputWriter;
+  try {
+    stderr = await store.createWriter({ ownerId, stream: "stderr" });
+  } catch (error) {
+    await stdout.dispose();
+    throw error;
+  }
+  const offsets = { stdout: 0, stderr: 0 };
+  let settled: OutputReceipt | undefined;
+  let failure: string | undefined;
+  let finished = false;
+  let tail = Promise.resolve();
+  const serialize = async <T>(operation: () => Promise<T>): Promise<T> => {
+    const previous = tail;
+    let release = () => {};
+    tail = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  };
+  const recordFailure = (error: unknown) => {
+    failure ??=
+      error instanceof Error ? error.message : "exec_output_write_failed";
+  };
+  const capture = async (): Promise<OutputReceipt> => {
+    try {
+      const out = await stdout.snapshot({
+        startByte: offsets.stdout,
+        endByte: finished ? stdout.byteLength : stdout.utf8ByteLength,
+      });
+      const err = await stderr.snapshot({
+        startByte: offsets.stderr,
+        endByte: finished ? stderr.byteLength : stderr.utf8ByteLength,
+      });
+      return {
+        stdout: streamReceipt(out),
+        stderr: streamReceipt(err),
+        ...failureReceipt(),
+      };
+    } catch (error) {
+      recordFailure(error);
+      return {
+        stdout: streamReceipt(),
+        stderr: streamReceipt(),
+        ...failureReceipt(),
+      };
+    }
+  };
+  const failureReceipt = () =>
+    failure
+      ? {
+          outputFailure: {
+            code: failure,
+            stdoutBytes: stdout.byteLength,
+            stderrBytes: stderr.byteLength,
+          },
+        }
+      : {};
+  return Object.freeze({
+    attach(
+      streams: { stdout: Readable; stderr: Readable },
+      onActivity: () => void,
+      onFailure: () => void,
+    ) {
+      for (const name of ["stdout", "stderr"] as const) {
+        const source = streams[name];
+        const writer = name === "stdout" ? stdout : stderr;
+        source.on("data", onActivity);
+        const failed = (error: Error) => {
+          recordFailure(error);
+          source.pause();
+          onFailure();
+        };
+        writer.sink.on("error", failed);
+        source.on("error", failed);
+        source.pipe(writer.sink);
+      }
+    },
+    async finish() {
+      if (!stdout.sink.writableEnded) stdout.sink.end();
+      if (!stderr.sink.writableEnded) stderr.sink.end();
+      const outcomes = await Promise.allSettled([
+        stdout.completion,
+        stderr.completion,
+      ]);
+      for (const outcome of outcomes)
+        if (outcome.status === "rejected") recordFailure(outcome.reason);
+      await serialize(async () => {
+        finished = true;
+        settled = await capture();
+      });
+    },
+    peek(): Promise<OutputReceipt> {
+      return serialize(async () => settled ?? (await capture()));
+    },
+    checkpoint(): OutputReceipt {
+      if (!settled) throw new Error("exec_snapshot_not_quiescent");
+      return settled;
+    },
+    accept(snapshot: ExecProcessSnapshot): Promise<void> {
+      return serialize(async () => {
+        if (snapshot.outputFailure)
+          throw new Error("exec_output_not_delivered");
+        for (const name of ["stdout", "stderr"] as const) {
+          const body = snapshot[name].body;
+          const writer = name === "stdout" ? stdout : stderr;
+          if (
+            !body ||
+            body.startByte !== offsets[name] ||
+            body.endByte > writer.byteLength
+          )
+            throw new Error("exec_output_snapshot_mismatch");
+        }
+        offsets.stdout = snapshot.stdout.body!.endByte;
+        offsets.stderr = snapshot.stderr.body!.endByte;
+        if (finished) settled = await capture();
+      });
+    },
+    async dispose() {
+      await Promise.all([stdout.dispose(), stderr.dispose()]);
+    },
+  });
+}

package/plugins/exec/source/request-resources.ts

@@ -0,0 +1,219 @@
+import type {
+  ToolRequestPreparationContext,
+  ToolExecutionContext,
+} from "../../../src/plugin-sdk/index.js";
+import type { ExecProcessManager } from "./process-manager.js";
+import type {
+  ExecProcessSnapshot,
+  PendingExecExecution,
+  ExecFilesystemSnapshot,
+} from "./types.js";
+import { ExecPluginError } from "./errors.js";
+import { ExecTerminalDelivery } from "./terminal-delivery.js";
+import { isExecOutputBody } from "./output-files.js";
+
+type SavedExecution = Readonly<{
+  processId: string;
+  scope: string;
+  cursor: number;
+  snapshot: ExecProcessSnapshot;
+  execution: Omit<PendingExecExecution, "filesystemStateBefore"> & {
+    filesystemStateBefore:
+      | (Omit<ExecFilesystemSnapshot, "entries"> & {
+          entries: readonly (readonly [string, unknown])[];
+        })
+      | null;
+  };
+}>;
+
+/** Serializes only terminal output; a live child is never restored or replayed. */
+export class ExecRequestResources {
+  private readonly owned = new Map<string, string>();
+  private readonly restored = new Map<string, SavedExecution>();
+  private readonly deliveries = new Map<string, ExecTerminalDelivery>();
+  constructor(
+    private readonly manager: ExecProcessManager,
+    private readonly pending: Map<string, PendingExecExecution>,
+    preparation?: ToolRequestPreparationContext,
+  ) {
+    const state = preparation?.requestState;
+    if (!state) return;
+    const saved = state.read("exec.terminal.v1");
+    if (saved !== undefined) this.restore(saved);
+    state.register("exec.terminal.v1", {
+      snapshot: () => this.snapshot(),
+      dispose: () => this.dispose(),
+    });
+  }
+  started(
+    processId: string,
+    scope: string,
+    settled: Promise<void>,
+    context?: ToolExecutionContext,
+  ) {
+    this.owned.set(processId, scope);
+    context?.requestWork?.trackUntil(settled);
+  }
+  forget(processId: string) {
+    this.owned.delete(processId);
+    this.restored.delete(processId);
+    this.deliveries.delete(processId);
+  }
+  isRestored(processId: string): boolean {
+    return this.restored.has(processId);
+  }
+  terminal(
+    processId: string,
+    scope: string,
+    cursor?: number,
+  ): ExecProcessSnapshot | undefined {
+    const entry = this.restored.get(processId);
+    if (!entry) return undefined;
+    if (entry.scope !== scope)
+      throw new ExecPluginError(
+        "unknown_exec_process",
+        "The exec process belongs to a different session.",
+      );
+    if (cursor !== undefined && cursor !== entry.cursor)
+      throw new ExecPluginError(
+        "stale_exec_process_cursor",
+        "The saved exec cursor is stale.",
+      );
+    return this.deliveries.get(processId)!.reserve({
+      ...structuredClone(entry.snapshot),
+      nextCursor: entry.cursor,
+    });
+  }
+  rejectTerminal(snapshot: ExecProcessSnapshot): void {
+    this.deliveries.get(snapshot.processId)?.reject(snapshot);
+  }
+  private snapshot() {
+    for (const delivery of this.deliveries.values()) delivery.assertAvailable();
+    const executions: SavedExecution[] = [...this.restored.values()];
+    for (const [processId, scope] of this.owned) {
+      const execution = this.pending.get(processId);
+      if (!execution) continue;
+      const terminal = this.manager.snapshotSettled(processId, scope);
+      const before = execution.filesystemStateBefore;
+      executions.push({
+        processId,
+        scope,
+        ...terminal,
+        execution: {
+          ...execution,
+          filesystemStateBefore: before
+            ? { ...before, entries: [...before.entries] }
+            : null,
+        },
+      });
+    }
+    return { kind: "exec_terminal_state_v2", executions };
+  }
+  private restore(value: unknown) {
+    if (
+      !isRecord(value) ||
+      (value.kind !== "exec_terminal_state_v1" &&
+        value.kind !== "exec_terminal_state_v2") ||
+      !Array.isArray(value.executions)
+    )
+      throw invalid();
+    for (const entry of value.executions) {
+      if (!isSavedExecution(entry) || this.restored.has(entry.processId))
+        throw invalid();
+      const before = entry.execution.filesystemStateBefore;
+      this.restored.set(entry.processId, structuredClone(entry));
+      this.deliveries.set(entry.processId, new ExecTerminalDelivery());
+      this.pending.set(entry.processId, {
+        ...structuredClone(entry.execution),
+        filesystemStateBefore: before
+          ? { ...before, entries: new Map(before.entries as [string, any][]) }
+          : null,
+      });
+    }
+  }
+  private async dispose() {
+    for (const [processId, scope] of this.owned) {
+      try {
+        await this.manager.cancel({ processId, scope });
+      } catch {}
+      try {
+        await this.manager.release(processId, scope);
+      } catch {}
+      this.pending.delete(processId);
+    }
+    for (const id of this.restored.keys()) this.pending.delete(id);
+    this.owned.clear();
+    this.restored.clear();
+    this.deliveries.clear();
+  }
+}
+function isSavedExecution(value: unknown): value is SavedExecution {
+  if (
+    !isRecord(value) ||
+    typeof value.processId !== "string" ||
+    typeof value.scope !== "string" ||
+    !Number.isSafeInteger(value.cursor) ||
+    value.cursor < 1 ||
+    !isRecord(value.snapshot) ||
+    value.snapshot.processId !== value.processId ||
+    value.snapshot.status !== "settled" ||
+    !isStream(value.snapshot.stdout, "stdout") ||
+    !isStream(value.snapshot.stderr, "stderr") ||
+    !Number.isFinite(value.snapshot.elapsedMs) ||
+    !isRecord(value.execution) ||
+    typeof value.execution.commandPreview !== "string" ||
+    !isRecord(value.execution.cwd) ||
+    typeof value.execution.cwd.absolutePath !== "string" ||
+    typeof value.execution.cwd.logicalPath !== "string"
+  )
+    return false;
+  if (
+    ![value.execution.hardTimeoutMs, value.execution.idleTimeoutMs].every(
+      Number.isFinite,
+    )
+  )
+    return false;
+  const before = value.execution.filesystemStateBefore;
+  return (
+    before === null ||
+    (isRecord(before) &&
+      typeof before.absoluteRoot === "string" &&
+      typeof before.logicalRoot === "string" &&
+      typeof before.rootExists === "boolean" &&
+      typeof before.complete === "boolean" &&
+      Array.isArray(before.entries) &&
+      before.entries.every(
+        (entry: unknown) =>
+          Array.isArray(entry) &&
+          entry.length === 2 &&
+          typeof entry[0] === "string" &&
+          isRecord(entry[1]) &&
+          typeof entry[1].kind === "string" &&
+          [entry[1].mode, entry[1].size, entry[1].mtimeMs].every(
+            Number.isFinite,
+          ),
+      ))
+  );
+}
+function isStream(value: unknown, stream: "stdout" | "stderr"): boolean {
+  return (
+    isRecord(value) &&
+    typeof value.text === "string" &&
+    typeof value.sawOutput === "boolean" &&
+    (value.body === undefined ||
+      (isExecOutputBody(value.body) && value.body.stream === stream)) &&
+    isRecord(value.metadata) &&
+    typeof value.metadata.truncated === "boolean" &&
+    [
+      value.metadata.originalChars,
+      value.metadata.returnedChars,
+      value.metadata.omittedChars,
+    ].every(Number.isFinite)
+  );
+}
+function isRecord(value: unknown): value is Record<string, any> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function invalid() {
+  return new Error("exec_terminal_snapshot_invalid");
+}

package/plugins/exec/source/result-presentation.ts

@@ -0,0 +1,275 @@
+import {
+  deliverPluginTextResult,
+  type ToolImplementationOutput,
+  type ToolResultBudget,
+} from "../../../src/plugin-sdk/index.js";
+import {
+  captureExecFilesystemSnapshot,
+  diffExecFilesystemSnapshots,
+} from "./filesystem-observer.js";
+import type {
+  ExecActionSummary,
+  ExecFilesystemDelta,
+  ExecProcessSnapshot,
+  ExecStreamSnapshot,
+  ExecStreamMetadata,
+  PendingExecExecution,
+} from "./types.js";
+
+const EXEC_CONTEXT_TEXT_FIELDS = Object.freeze(["stdout", "stderr"] as const);
+
+function streamReceipt(
+  snapshot: ExecStreamSnapshot,
+  field: "stdout" | "stderr",
+): string {
+  if (snapshot.text) return `See the ${field} field (${snapshot.text.length} characters).`;
+  return snapshot.sawOutput
+    ? "(no new output; earlier output was already returned)"
+    : "(empty)";
+}
+
+function renderedOutput(lines: readonly string[]): Readonly<{
+  output: string;
+  metadata: ExecStreamMetadata;
+}> {
+  const output = lines.join("\n");
+  return Object.freeze({
+    output,
+    metadata: Object.freeze({
+      truncated: false,
+      originalChars: output.length,
+      returnedChars: output.length,
+      omittedChars: 0,
+    }),
+  });
+}
+
+function outputBoundsData(
+  snapshot: ExecProcessSnapshot,
+  rendered: ExecStreamMetadata,
+) {
+  return Object.freeze({
+    maxChars: null,
+    stdout: snapshot.stdout.metadata,
+    stderr: snapshot.stderr.metadata,
+    rendered,
+  });
+}
+
+export function runningResult(
+  snapshot: ExecProcessSnapshot,
+  execution: PendingExecExecution,
+  resultBudget?: ToolResultBudget,
+): ToolImplementationOutput {
+  const nextCursor = snapshot.nextCursor ?? 1;
+  const rendered = renderedOutput(
+    [
+      `Command: ${execution.commandPreview}`,
+      `CWD: ${execution.cwd.logicalPath}`,
+      "Process status: running",
+      `Process ID: ${snapshot.processId}`,
+      `Next cursor: ${nextCursor}`,
+      "STDOUT since the previous observation:",
+      streamReceipt(snapshot.stdout, "stdout"),
+      "STDERR since the previous observation:",
+      streamReceipt(snapshot.stderr, "stderr"),
+      "Continue this exact process with exec_wait; do not run the command again.",
+    ],
+  );
+  return deliverPluginTextResult({
+    ok: false,
+    producedNewInformation: false,
+    errorCode: "exec_process_running",
+    error:
+      "The command is still running. Continue it with exec_wait using the returned process ID and cursor.",
+    output: rendered.output,
+    stdout: snapshot.stdout.text,
+    stderr: snapshot.stderr.text,
+    data: {
+      processId: snapshot.processId,
+      processStatus: "running",
+      nextCursor,
+      outputBounds: outputBoundsData(snapshot, rendered.metadata),
+      observationMeta: {
+        kind: "volatile_external",
+        carryPolicy: "never",
+      },
+    },
+  }, EXEC_CONTEXT_TEXT_FIELDS, resultBudget);
+}
+
+async function captureFilesystemDelta(
+  execution: PendingExecExecution,
+): Promise<ExecFilesystemDelta | null> {
+  if (!execution.filesystemStateBefore) return null;
+  try {
+    const after = await captureExecFilesystemSnapshot(
+      execution.cwd.absolutePath,
+      execution.cwd.logicalPath,
+    );
+    return diffExecFilesystemSnapshots(execution.filesystemStateBefore, after);
+  } catch {
+    return null;
+  }
+}
+
+type ExecFilesystemEvidenceProjection = Readonly<{
+  outputLines: readonly string[];
+  mutationGrounding: string;
+}>;
+
+function projectExecFilesystemEvidence(
+  delta: ExecFilesystemDelta,
+  logicalRoot: string,
+): ExecFilesystemEvidenceProjection {
+  const effects = delta.actions.map(renderExecFilesystemEffect);
+  const omittedEffectCount = Math.max(
+    0,
+    delta.changedEntryCount - effects.length,
+  );
+  const omittedEffectLine =
+    omittedEffectCount > 0
+      ? `- ${omittedEffectCount} additional changed ${omittedEffectCount === 1 ? "entry" : "entries"} omitted by the ${delta.observation.actionLimit}-effect projection limit.`
+      : undefined;
+  const outputLines = Object.freeze([
+    `Filesystem changes observed: ${delta.changedEntryCount}${delta.observation.complete ? "" : " (bounded observation)"}`,
+    "Filesystem effects observed:",
+    ...effects,
+    ...(omittedEffectLine ? [omittedEffectLine] : []),
+  ]);
+  return Object.freeze({
+    outputLines,
+    mutationGrounding: [
+      "Observed post-command filesystem effects (settled tool evidence; not command intent, semantic verification, or complete artifact content):",
+      `- observation root: ${logicalRoot}`,
+      `- observation complete: ${delta.observation.complete}`,
+      `- changed entries: ${delta.changedEntryCount}`,
+      `- listed effects: ${effects.length}`,
+      `- effects truncated: ${delta.observation.actionsTruncated}`,
+      "Effects:",
+      ...effects,
+      ...(omittedEffectLine ? [omittedEffectLine] : []),
+    ].join("\n"),
+  });
+}
+
+function renderExecFilesystemEffect(action: ExecActionSummary): string {
+  const target = action.target ? `: ${action.target}` : "";
+  const state =
+    action.details === "exec_filesystem_created"
+      ? "created"
+      : action.details === "exec_filesystem_modified"
+        ? "modified"
+        : action.details === "exec_filesystem_removed"
+          ? "removed"
+          : undefined;
+  return `- ${action.type}${target}${state ? ` (${state})` : ""}`;
+}
+
+export async function finalizeExecResult(params: {
+  snapshot: ExecProcessSnapshot;
+  execution: PendingExecExecution;
+  cancellationIsSuccess?: boolean;
+  resultBudget?: ToolResultBudget;
+}): Promise<ToolImplementationOutput> {
+  const { snapshot, execution } = params;
+  const exitCode = snapshot.exitCode ?? -1;
+  const cancellationIsSuccess =
+    params.cancellationIsSuccess === true &&
+    snapshot.terminationReason === "cancelled";
+  const filesystemDelta = await captureFilesystemDelta(execution);
+  const observedStateChange = filesystemDelta?.observedStateChange === true;
+  const filesystemEvidence =
+    observedStateChange && filesystemDelta
+      ? projectExecFilesystemEvidence(
+          filesystemDelta,
+          execution.cwd.logicalPath,
+        )
+      : null;
+  const commandHasData = snapshot.stdout.sawOutput || snapshot.stderr.sawOutput;
+  const ok = exitCode === 0 || cancellationIsSuccess;
+  const inconclusiveSuccess =
+    exitCode === 0 && !commandHasData && !observedStateChange;
+  const producedNewInformation =
+    observedStateChange || cancellationIsSuccess || (ok && commandHasData);
+  const actions = filesystemDelta?.actions ?? [];
+  const resultSummary = cancellationIsSuccess
+    ? "Result summary: the running command was cancelled."
+    : inconclusiveSuccess
+      ? "Result summary: the command completed without observable output or filesystem change. Inspect a concrete target or use a dedicated creation capability."
+      : "";
+  const rendered = renderedOutput(
+    [
+      `Command: ${execution.commandPreview}`,
+      `CWD: ${execution.cwd.logicalPath}`,
+      `Process ID: ${snapshot.processId}`,
+      `Process status: ${snapshot.terminationReason ?? "completed"}`,
+      `Exit code: ${exitCode}`,
+      ...(filesystemEvidence ? filesystemEvidence.outputLines : []),
+      "STDOUT:",
+      streamReceipt(snapshot.stdout, "stdout"),
+      "STDERR:",
+      streamReceipt(snapshot.stderr, "stderr"),
+      ...(resultSummary ? [resultSummary] : []),
+    ],
+  );
+  const processStatus = snapshot.terminationReason ?? "completed";
+  const data = {
+    ...(commandHasData ? { hasData: true } : {}),
+    ...(observedStateChange ? { mutationEvidence: true } : {}),
+    ...(filesystemEvidence
+      ? { mutationGrounding: filesystemEvidence.mutationGrounding }
+      : {}),
+    processId: snapshot.processId,
+    processStatus,
+    outputBounds: outputBoundsData(snapshot, rendered.metadata),
+    ...(filesystemDelta
+      ? { filesystemObservation: filesystemDelta.observation }
+      : { filesystemObservation: { available: false } }),
+    observationMeta: {
+      kind: "volatile_external" as const,
+      carryPolicy: "never" as const,
+    },
+  };
+  const common = {
+    output: rendered.output,
+    progress: observedStateChange || cancellationIsSuccess,
+    producedNewInformation,
+    actions: [...actions],
+    exitCode,
+    stdout: snapshot.stdout.text,
+    stderr: snapshot.stderr.text,
+    data,
+  };
+  if (ok && (!inconclusiveSuccess || cancellationIsSuccess)) {
+    return deliverPluginTextResult({ ok: true, ...common }, EXEC_CONTEXT_TEXT_FIELDS, params.resultBudget);
+  }
+  const errorCode = inconclusiveSuccess
+    ? "no_observable_result"
+    : snapshot.terminationReason === "aborted"
+      ? "exec_aborted"
+      : snapshot.terminationReason === "spawn_failed"
+        ? "exec_spawn_failed"
+        : snapshot.terminationReason === "idle_timeout"
+          ? "exec_idle_timeout"
+          : snapshot.terminationReason === "hard_timeout"
+            ? "exec_hard_timeout"
+            : "non_zero_exit";
+  const error = inconclusiveSuccess
+    ? resultSummary
+    : errorCode === "exec_aborted"
+      ? "The exec request was aborted."
+      : errorCode === "exec_spawn_failed"
+        ? "The runtime could not start the configured non-interactive shell."
+        : errorCode === "exec_idle_timeout"
+          ? `The command produced no output for ${execution.idleTimeoutMs}ms.`
+          : errorCode === "exec_hard_timeout"
+            ? `The command exceeded the ${execution.hardTimeoutMs}ms hard timeout.`
+            : `The command exited with code ${exitCode}.`;
+  return deliverPluginTextResult({
+    ok: false,
+    ...common,
+    error,
+    errorCode,
+  }, EXEC_CONTEXT_TEXT_FIELDS, params.resultBudget);
+}

package/plugins/exec/source/retained-output-failure.ts

@@ -0,0 +1,51 @@
+import {
+  failureResult,
+  type ToolExecutionContext,
+  type ToolImplementationOutput,
+} from "../../../src/plugin-sdk/index.js";
+import type { ExecProcessSnapshot } from "./types.js";
+
+/** Output remains pending; neither an exit nor a size rejection is an acknowledgement. */
+export function retainedOutputFailure(
+  snapshot: ExecProcessSnapshot,
+  context?: ToolExecutionContext,
+): ToolImplementationOutput {
+  const expired = hasUnavailableOutput(snapshot);
+  return failureResult(
+    {
+      errorCode: expired
+        ? "exec_output_expired"
+        : snapshot.outputFailure
+          ? "exec_output_storage_failed"
+          : "exec_output_delivery_pending",
+      message: expired
+        ? "The retained output expired or is no longer available. The command was already started; it has not been run again."
+        : snapshot.outputFailure
+          ? "Output storage or delivery failed. The command was already started; do not run it again. Any committed bytes are retained for the configured retention period; complete output delivery is not confirmed."
+          : "The output exceeds the delivery envelope and remains retained. The command was already executed; do not run it again.",
+      data: {
+        processId: snapshot.processId,
+        processStatus: snapshot.status,
+        nextCursor: snapshot.nextCursor,
+        ...(snapshot.exitCode !== undefined
+          ? { exitCode: snapshot.exitCode }
+          : {}),
+        ...(snapshot.terminationReason
+          ? { terminationReason: snapshot.terminationReason }
+          : {}),
+        outputDelivery: expired ? "expired" : "pending",
+        ...(snapshot.outputFailure
+          ? { outputStorageFailure: snapshot.outputFailure }
+          : {}),
+        retainedCharacters:
+          snapshot.stdout.text.length + snapshot.stderr.text.length,
+      },
+    },
+    context?.resultBudget,
+  );
+}
+
+function hasUnavailableOutput(snapshot: ExecProcessSnapshot): boolean {
+  if (snapshot.outputFailure?.code === "exec_output_expired") return true;
+  return snapshot.outputFailure?.code === "exec_output_expired_or_unavailable";
+}