@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/src/runs/shared/chain-outputs.ts

@@ -1,206 +0,0 @@
-import { isDynamicParallelStep, isParallelStep, type ChainStep } from "../../shared/settings.ts";
-import type { ReadonlyInput, ChainOutputMap, ChainOutputMapEntry } from "../../shared/types.ts";
-import {
-  DynamicFanoutError,
-  hasDynamicFanoutFields,
-  isSafeOutputName,
-  resolveItemTemplate,
-  type DynamicFanoutConfig,
-  validateDynamicStepShape,
-} from "./dynamic-fanout.ts";
-
-const OUTPUT_REF_PATTERN = /\{outputs\.([^}]*)\}/g;
-
-export class ChainOutputValidationError extends Error {}
-
-function outputNamesForStep(step: ReadonlyInput<ChainStep>): string[] {
-  if (isParallelStep(step)) {
-    return step.parallel.map((task) => task.as).filter((name): name is string => Boolean(name));
-  }
-  if (isDynamicParallelStep(step)) {
-    return [step.collect.as];
-  }
-  const name = step.as;
-  return name !== undefined && name.length > 0 ? [name] : [];
-}
-
-function taskTemplatesForStep(step: ReadonlyInput<ChainStep>): string[] {
-  if (isParallelStep(step)) {
-    return step.parallel.map((task) => task.task ?? "{previous}");
-  }
-  if (isDynamicParallelStep(step)) {
-    return [step.parallel.task ?? "{previous}", step.parallel.label ?? ""].filter(Boolean);
-  }
-  return [step.task ?? "{previous}"];
-}
-
-function validateDynamicSource(
-  step: ReadonlyInput<ChainStep>,
-  stepIndex: number,
-  available: readonly string[],
-  config: DynamicFanoutConfig,
-): void {
-  if (!hasDynamicFanoutFields(step)) {
-    return;
-  }
-  if (!isDynamicParallelStep(step)) {
-    throw new ChainOutputValidationError(
-      `Dynamic chain step ${stepIndex + 1} requires expand, a single parallel template object, and collect; dynamic expand/collect cannot be mixed with static parallel arrays.`,
-    );
-  }
-  try {
-    validateDynamicStepShape(step, stepIndex, config);
-  } catch (error) {
-    if (error instanceof DynamicFanoutError) {
-      throw new ChainOutputValidationError(error.message, { cause: error });
-    }
-    throw error;
-  }
-  if (!available.includes(step.expand.from.output)) {
-    throw new ChainOutputValidationError(
-      `Dynamic chain step ${stepIndex + 1} references unknown output '${step.expand.from.output}'. Named outputs are only available after producing step/group completes.`,
-    );
-  }
-}
-
-function validateTemplateBindings(
-  templates: readonly string[],
-  available: readonly string[],
-  stepIndex: number,
-): void {
-  for (const template of templates) {
-    for (const match of template.matchAll(OUTPUT_REF_PATTERN)) {
-      const rawReference = match[0];
-      const name = match[1];
-      if (!isSafeOutputName(name)) {
-        throw new ChainOutputValidationError(
-          `Invalid chain output reference '${rawReference}' at step ${stepIndex + 1}. Use {outputs.name} with /^[A-Za-z_][A-Za-z0-9_]*$/ names.`,
-        );
-      }
-      if (!available.includes(name)) {
-        throw new ChainOutputValidationError(
-          `Unknown chain output reference '${rawReference}' at step ${stepIndex + 1}. Named outputs are only available after producing step/group completes.`,
-        );
-      }
-    }
-  }
-}
-
-export function validateChainOutputBindings(
-  steps: readonly ReadonlyInput<ChainStep>[],
-  dynamicFanoutConfig: DynamicFanoutConfig = {},
-): void {
-  const available: string[] = [];
-  const seen = new Set<string>();
-  for (const [stepIndex, step] of steps.entries()) {
-    validateDynamicSource(step, stepIndex, available, dynamicFanoutConfig);
-    for (const name of outputNamesForStep(step)) {
-      if (!isSafeOutputName(name)) {
-        throw new ChainOutputValidationError(
-          `Invalid chain output name '${name}' at step ${stepIndex + 1}. Use /^[A-Za-z_][A-Za-z0-9_]*$/.`,
-        );
-      }
-      if (seen.has(name)) {
-        throw new ChainOutputValidationError(
-          `Duplicate chain output name '${name}'. Each as name must be unique.`,
-        );
-      }
-      seen.add(name);
-    }
-    validateTemplateBindings(taskTemplatesForStep(step), available, stepIndex);
-    for (const name of outputNamesForStep(step)) {
-      available.push(name);
-    }
-  }
-}
-
-export function resolveOutputReferences(
-  template: string,
-  outputs: ReadonlyInput<ChainOutputMap>,
-): string {
-  return template.replace(OUTPUT_REF_PATTERN, (rawReference, name: string) => {
-    if (!isSafeOutputName(name)) {
-      throw new ChainOutputValidationError(
-        `Invalid chain output reference '${rawReference}'. Use {outputs.name} with /^[A-Za-z_][A-Za-z0-9_]*$/ names.`,
-      );
-    }
-    const entry: ChainOutputMapEntry | undefined = Object.hasOwn(outputs, name)
-      ? outputs[name]
-      : undefined;
-    if (!entry) {
-      throw new ChainOutputValidationError(`Unknown chain output reference '${rawReference}'.`);
-    }
-    return entry.text;
-  });
-}
-
-interface TaskValues {
-  readonly originalTask?: string;
-  readonly previousOutput?: string;
-  readonly chainDir?: string;
-  readonly outputs?: ReadonlyInput<ChainOutputMap>;
-  readonly item?: { readonly name: string; readonly value: unknown };
-}
-
-function isItemPlaceholder(raw: string, name: string): boolean {
-  return raw === `{${name}}` || raw.startsWith(`{${name}.`);
-}
-
-function renderReference(raw: string, reference: string | undefined, values: TaskValues): string {
-  if (values.item && isItemPlaceholder(raw, values.item.name)) {
-    return resolveItemTemplate(raw, values.item.name, values.item.value);
-  }
-  if (reference === "task") {
-    return values.originalTask ?? "";
-  }
-  if (reference === "chain_dir") {
-    return values.chainDir ?? "";
-  }
-  if (reference !== undefined && reference.startsWith("outputs.")) {
-    return resolveOutputReferences(raw, values.outputs ?? {});
-  }
-  return raw;
-}
-
-export function renderChainTask(
-  template: string,
-  values: TaskValues,
-  placeholder = "{previous}",
-): string {
-  const pattern = new RegExp(
-    `${placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}|\\{([^{}]*)\\}`,
-    "g",
-  );
-  const previousOutput = values.previousOutput ?? "";
-  const usedPrevious = [...template.matchAll(pattern)].some(
-    ([raw]) => raw === placeholder && !(values.item && isItemPlaceholder(raw, values.item.name)),
-  );
-  const task = template.replace(pattern, (raw: string, reference: string | undefined) => {
-    // Item placeholders retain precedence if a caller customizes the previous-output placeholder.
-    if (values.item && isItemPlaceholder(raw, values.item.name)) {
-      return renderReference(raw, reference, values);
-    }
-    if (raw === placeholder) {
-      return previousOutput;
-    }
-    return renderReference(raw, reference, values);
-  });
-  return !usedPrevious && previousOutput.trim().length > 0
-    ? `${task}\n\n---\nPrevious step output:\n${previousOutput.trim()}`
-    : task;
-}
-
-export function outputEntryFromResult(
-  result: { readonly agent: string; readonly output: string; readonly structuredOutput?: unknown },
-  stepIndex: number,
-): ChainOutputMapEntry {
-  return {
-    text:
-      result.structuredOutput !== undefined
-        ? JSON.stringify(result.structuredOutput)
-        : result.output,
-    ...(result.structuredOutput !== undefined ? { structured: result.structuredOutput } : {}),
-    agent: result.agent,
-    stepIndex,
-  };
-}

package/src/runs/shared/child-attempt-types.ts

@@ -1,118 +0,0 @@
-import type {
-  AgentProcessExit,
-  ChildMessageHeader,
-  ObservedMessage,
-  ReadonlyInput,
-  ResourceLimitExceeded,
-  Usage,
-  UsageAccumulator,
-} from "../../shared/types.ts";
-import type { StructuredOutputRuntime } from "./structured-output.ts";
-import type { ClaudeCodeInvocation } from "./claude-types.ts";
-import type { NativeFinalizationConfig, NativeFinalizationEvent } from "./native-finalization.ts";
-import type { MutationToolResult } from "./mutating-tool-guard.ts";
-import type { updateStreamingText } from "./streaming-text.ts";
-
-interface ChildEventFields {
-  readonly assistantMessageEvent?: Parameters<
-    typeof updateStreamingText
-  >[1]["assistantMessageEvent"];
-  readonly toolCallId?: string;
-  readonly toolName?: string;
-  readonly args?: Readonly<Record<string, unknown>>;
-  readonly isError?: boolean;
-}
-
-export type ChildEvent = ChildEventFields &
-  (
-    | { readonly type: "message_end"; readonly message?: ObservedMessage }
-    | { readonly type: "message_start" | "message_update"; readonly message?: ChildMessageHeader }
-    | { readonly type?: string; readonly message?: never }
-  );
-
-export interface NativeAttemptSegment {
-  event: NativeFinalizationEvent;
-  messages: ObservedMessage[];
-  usage: Usage;
-  durationMs: number;
-  execution?: Pick<
-    ChildAttemptResult,
-    "exitCode" | "error" | "interrupted" | "timedOut" | "resourceLimitExceeded" | "terminalFailure"
-  >;
-}
-
-export interface ChildAttemptResult {
-  accounting?: { state: "complete" | "incomplete"; error?: string };
-  nativeSessionId?: string;
-  terminalLeafId?: string | null;
-  terminalEntryId?: string;
-  effectiveConfiguration?: { model?: string; thinking?: string; modelRecordedAt?: number };
-  attemptBaseline?: string[];
-  auditPath?: string;
-  auditSaveError?: string;
-  auditRecords?: Array<{ kind: string; messageNumber?: number; offset: number; length: number }>;
-  nativeReferences?: Array<{ messageNumber?: number; entryId: string }>;
-  messageCount?: number;
-  finalization?: NativeAttemptSegment[];
-  stderr: string;
-  agentProcessExit?: AgentProcessExit;
-  exitCode: number;
-  messages: ObservedMessage[];
-  usage: UsageAccumulator;
-  model?: string;
-  error?: string;
-  finalOutput: string;
-  interrupted?: boolean;
-  timedOut?: boolean;
-  terminalFailure?: boolean;
-  observedCompletedMutation: boolean;
-  resourceLimitExceeded?: ResourceLimitExceeded;
-  durationMs: number;
-}
-
-export interface ChildAttemptControl {
-  readonly pid?: number;
-  readonly stopping: boolean;
-  readonly stop: (outcome: Pick<ChildAttemptResult, "error" | "timedOut" | "interrupted">) => void;
-}
-
-export interface ChildAttemptOptions {
-  readonly args: readonly string[];
-  readonly cwd: string;
-  readonly env?: Readonly<Record<string, string | undefined>>;
-  readonly agent: string;
-  readonly model?: string;
-  readonly maxSubagentDepth?: number;
-  readonly maxExecutionTimeMs?: number;
-  readonly maxTokens?: number;
-  readonly claudeCodeInvocation?: ClaudeCodeInvocation;
-  readonly sessionFile?: string;
-  readonly auditPath?: string;
-  readonly structuredOutput?: StructuredOutputRuntime;
-  readonly reportRuntime?: StructuredOutputRuntime;
-  readonly nativeFinalization?: NativeFinalizationConfig;
-  readonly signal?: AbortSignal;
-  readonly interruptSignal?: AbortSignal;
-  readonly onStart?: (
-    control: ChildAttemptControl,
-    result: ReadonlyInput<ChildAttemptResult>,
-  ) => void;
-  readonly onEvent?: (
-    event: ChildEvent,
-    result: ReadonlyInput<ChildAttemptResult>,
-    mutation?: ReadonlyInput<MutationToolResult>,
-  ) => void;
-  readonly onFailure?: (result: ReadonlyInput<ChildAttemptResult>) => void;
-  readonly onOutput?: (text: string) => void;
-  readonly onRawLine?: (stream: "stdout" | "stderr", line: string) => void;
-  readonly onStderr?: (text: string) => void;
-}
-
-export interface ChildObservation {
-  readonly start: number;
-  readonly end: number;
-  readonly kind: string;
-  readonly number?: number;
-  readonly message?: ObservedMessage;
-  readonly nativeEntryId?: string;
-}

package/src/runs/shared/child-attempt.ts

@@ -1,387 +0,0 @@
-import { spawn } from "node:child_process";
-import { addAbortListener } from "node:events";
-import {
-  getSubagentDepthEnv,
-  type ReadonlyInput,
-  type ResourceLimitExceeded,
-} from "../../shared/types.ts";
-import { attachChildProcessLifecycle } from "../../shared/post-exit-stdio-guard.ts";
-import { findLatestSessionFile, formatResourceLimitExceeded } from "../../shared/utils.ts";
-import { resolveExecutionOutcome } from "./acceptance.ts";
-import { snapshotNativeBaseline, type NativeBaseline } from "./native-usage.ts";
-import { getPiSpawnCommand } from "./pi-spawn.ts";
-import { ChildObservationSpool } from "./child-observation-spool.ts";
-import { ChildStreamObserver } from "./child-stream-observer.ts";
-import { ChildEventObserver } from "./child-event-observer.ts";
-import { accountNativeChild } from "./child-native-accounting.ts";
-import { childExecutionOutcome } from "./child-execution-outcome.ts";
-import { errorMessage as errorText } from "../../shared/unknown.ts";
-import { nonempty } from "./child-presence.ts";
-import type { ChildAttemptOptions, ChildAttemptResult } from "./child-attempt-types.ts";
-export { buildChildInvocation } from "./child-invocation.ts";
-export type {
-  ChildEvent,
-  ChildAttemptResult,
-  ChildAttemptControl,
-  NativeAttemptSegment,
-} from "./child-attempt-types.ts";
-
-type StopOutcome = Pick<ChildAttemptResult, "error" | "timedOut" | "interrupted">;
-function initialResult(model?: string): ChildAttemptResult {
-  return {
-    stderr: "",
-    exitCode: 0,
-    messages: [],
-    model,
-    usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-    finalOutput: "",
-    observedCompletedMutation: false,
-    durationMs: 0,
-  };
-}
-function nativeSessionFile(options: ReadonlyInput<ChildAttemptOptions>): string | undefined {
-  if (options.claudeCodeInvocation) {
-    return;
-  }
-  const index = options.args.indexOf("--session-dir");
-  const directory = index >= 0 ? options.args.at(index + 1) : undefined;
-  return (
-    options.sessionFile ??
-    (nonempty(directory) ? (findLatestSessionFile(directory) ?? undefined) : undefined)
-  );
-}
-
-/** One process-group owner; event accounting, observation retention and native review are separate. */
-class ChildAttemptRunner {
-  private readonly options: ReadonlyInput<ChildAttemptOptions>;
-  private readonly completion = Promise.withResolvers<ChildAttemptResult>();
-  private readonly startedAt = Date.now();
-  private readonly spool: ReadonlyInput<Pick<ChildObservationSpool, keyof ChildObservationSpool>>;
-  private readonly events: ChildEventObserver;
-  private readonly stream: ChildStreamObserver;
-  private readonly lifecycle: ReturnType<typeof attachChildProcessLifecycle>;
-  private resourceTimer?: NodeJS.Timeout;
-  private abortListener?: Disposable;
-  private interruptListener?: Disposable;
-  private receiverFailed = false;
-  private settled = false;
-  private readonly pid?: number;
-
-  constructor(
-    options: ReadonlyInput<ChildAttemptOptions>,
-    baseline: NativeBaseline,
-    spool: ReadonlyInput<Pick<ChildObservationSpool, keyof ChildObservationSpool>>,
-  ) {
-    this.options = options;
-    this.spool = spool;
-    const command = options.claudeCodeInvocation ?? getPiSpawnCommand(options.args);
-    const child = spawn(command.command, [...command.args], {
-      cwd: options.cwd,
-      env: {
-        ...process.env,
-        ...options.env,
-        ...getSubagentDepthEnv(options.maxSubagentDepth),
-        PI_SUBAGENT_NATIVE_BASELINE_COUNT: baseline.legacy ? String(baseline.entryCount) : "",
-      },
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: true,
-    });
-    this.pid = child.pid;
-    this.lifecycle = attachChildProcessLifecycle(child);
-    this.events = new ChildEventObserver(
-      options,
-      baseline,
-      {
-        observeLifecycle: (type) => this.lifecycle.observeEvent(type),
-        stopping: () => this.lifecycle.stopping,
-        stop: (outcome) => this.stop(outcome),
-        resourceLimit: (kind, limit, observed) => this.resourceLimit(kind, limit, observed),
-        resetTimer: () => this.resetResourceTimer(),
-        reference: (entry) => this.stream.reference(entry),
-      },
-      this.startedAt,
-    );
-    this.stream = new ChildStreamObserver(this.spool, {
-      claude: options.claudeCodeInvocation !== undefined,
-      sessionFile: options.sessionFile,
-      consume: (value, textWritten) => this.events.process(value, textWritten),
-      output: options.onOutput,
-      rawLine: options.onRawLine,
-    });
-    child.stdout.on("data", (bytes: Buffer) => this.receive(bytes));
-    child.stderr.setEncoding("utf8");
-    child.stderr.on("data", (text: string) => this.receiveStderr(text));
-    child.on("close", (code, signal) => this.finish(code, signal));
-    child.on("error", (error) => this.finish(1, undefined, error));
-  }
-  completed(): Promise<ChildAttemptResult> {
-    return this.completion.promise;
-  }
-
-  start(): void {
-    this.listenForCancellation();
-    this.resetResourceTimer();
-    const lifecycle = this.lifecycle;
-    this.options.onStart?.(
-      {
-        pid: this.pid,
-        get stopping() {
-          return lifecycle.stopping;
-        },
-        stop: (outcome) => this.stop(outcome),
-      },
-      this.events.result,
-    );
-  }
-
-  private stop(outcome: StopOutcome): void {
-    if (this.settled) {
-      return;
-    }
-    Object.assign(this.events.result, outcome);
-    this.events.result.durationMs = Date.now() - this.startedAt;
-    if (nonempty(outcome.error)) {
-      this.options.onOutput?.(`${outcome.error}\n`);
-    }
-    this.options.onFailure?.(this.events.result);
-    this.lifecycle.terminate();
-  }
-  private resourceLimit(
-    kind: ResourceLimitExceeded["kind"],
-    limit: number,
-    observed?: number,
-  ): void {
-    const result = this.events.result;
-    if (
-      this.settled ||
-      result.resourceLimitExceeded ||
-      result.timedOut === true ||
-      this.lifecycle.stopping
-    ) {
-      return;
-    }
-    const message = formatResourceLimitExceeded({
-      agent: this.options.agent,
-      kind,
-      limit,
-      observed,
-    });
-    result.resourceLimitExceeded = {
-      kind,
-      limit,
-      ...(observed !== undefined ? { observed } : {}),
-      message,
-    };
-    this.stop({ error: message });
-  }
-  private resetResourceTimer(): void {
-    clearTimeout(this.resourceTimer);
-    const limit = this.options.maxExecutionTimeMs;
-    if (limit === undefined) {
-      return;
-    }
-    this.resourceTimer = setTimeout(
-      () => {
-        this.events.sync();
-        if (Date.now() - this.events.boundaries.startedAt >= limit) {
-          this.resourceLimit("maxExecutionTimeMs", limit);
-        } else {
-          this.resetResourceTimer();
-        }
-      },
-      Math.max(0, limit - (Date.now() - this.events.boundaries.startedAt)),
-    );
-    this.resourceTimer.unref();
-  }
-  private listenForCancellation(): void {
-    const { signal, interruptSignal } = this.options;
-    if (signal) {
-      this.abortListener = addAbortListener(signal, () => {
-        const reason: unknown = signal.reason;
-        const timedOut = reason instanceof Error && reason.name === "TimeoutError";
-        this.stop({
-          error: timedOut ? reason.message : "Subagent cancelled.",
-          timedOut: timedOut || undefined,
-          interrupted: false,
-        });
-      });
-    }
-    if (interruptSignal) {
-      this.interruptListener = addAbortListener(interruptSignal, () => {
-        if (
-          signal?.aborted === true ||
-          this.events.result.resourceLimitExceeded ||
-          this.events.result.timedOut === true
-        ) {
-          return;
-        }
-        this.stop({ interrupted: true, error: undefined });
-      });
-    }
-  }
-  private receive(bytes: Buffer): void {
-    try {
-      if (this.receiverFailed) {
-        this.stream.saveUnparsed(bytes);
-      } else {
-        this.stream.write(bytes);
-      }
-    } catch (error) {
-      this.receiverFailed = true;
-      this.events.result.terminalFailure = true;
-      this.stop({ error: `Cannot receive child events: ${errorText(error)}` });
-    }
-  }
-  private receiveStderr(text: string): void {
-    try {
-      this.spool.writeStderr(text);
-      this.events.result.stderr = (this.events.result.stderr + text).slice(-16384);
-      this.options.onStderr?.(text);
-    } catch (error) {
-      this.events.result.terminalFailure = true;
-      this.stop({ error: `Cannot save child diagnostics: ${errorText(error)}` });
-    }
-  }
-  private drainObservations(): void {
-    try {
-      if (!this.receiverFailed) {
-        this.stream.finish();
-      }
-    } catch (error) {
-      this.receiverFailed = true;
-      this.events.result.error ??= errorText(error);
-      this.events.result.terminalFailure = true;
-    }
-    try {
-      this.events.sync();
-    } catch (error) {
-      this.events.result.error ??= `Cannot read finalization boundary: ${errorText(error)}`;
-      this.events.result.terminalFailure = true;
-    }
-  }
-  private finish(
-    code: number | null,
-    signal?: NodeJS.Signals | null,
-    spawnError?: Readonly<Error>,
-  ): void {
-    if (this.settled) {
-      return;
-    }
-    this.drainObservations();
-    this.settled = true;
-    clearTimeout(this.resourceTimer);
-    this.abortListener?.[Symbol.dispose]();
-    this.interruptListener?.[Symbol.dispose]();
-    const result = this.events.result;
-    result.agentProcessExit = this.lifecycle.agentProcessExit;
-    result.durationMs = Date.now() - this.startedAt;
-    Object.assign(
-      result,
-      childExecutionOutcome({
-        result,
-        options: this.options,
-        code,
-        signal,
-        spawnError,
-        stopping: this.lifecycle.stopping,
-        settledCleanup: this.lifecycle.settledCleanup,
-        cleanAssistantStop: this.events.cleanAssistantStop,
-        assistantError: this.events.assistantError,
-      }),
-    );
-    result.finalOutput =
-      result.resourceLimitExceeded?.message ??
-      (this.events.lastOutput.length > 0 ? this.events.lastOutput : this.stream.rawOutput.trim());
-    const boundary = this.events.boundaries.finish(result);
-    result.finalization = boundary.finalization;
-    if (boundary.missing) {
-      result.error = "Native self-review boundary did not return a result.";
-      result.exitCode = 1;
-      result.terminalFailure = true;
-    }
-    this.finalizeAccounting();
-    this.completion.resolve(result);
-  }
-  private finalizeAccounting(): void {
-    const result = this.events.result;
-    const native = accountNativeChild({
-      file: nativeSessionFile(this.options),
-      result,
-      baseline: this.events.baseline,
-      acceptedEntries: this.events.acceptedEntries,
-      reference: (entry) => this.stream.reference(entry),
-      observations: () => this.stream.observed(),
-    });
-    result.accounting = native.accounting;
-    result.nativeSessionId = native.nativeSessionId;
-    result.terminalEntryId = native.terminalEntryId;
-    result.terminalLeafId = native.terminalLeafId;
-    result.effectiveConfiguration = native.effectiveConfiguration;
-    if (native.usage) {
-      result.usage = native.usage;
-    }
-    for (const [index, segment] of (result.finalization ?? []).entries()) {
-      const usage = native.segmentUsage?.at(index);
-      if (usage) {
-        segment.usage = usage;
-      }
-    }
-    const retained = this.stream.published(native.publishedIds);
-    for (const item of retained) {
-      if (nonempty(item.nativeEntryId)) {
-        (result.nativeReferences ??= []).push({
-          messageNumber: item.number,
-          entryId: item.nativeEntryId,
-        });
-      }
-    }
-    const audit = this.spool.retain(retained, this.receiverFailed);
-    result.auditPath = audit.auditPath;
-    result.auditSaveError = audit.auditSaveError;
-    result.auditRecords = audit.auditRecords?.slice();
-  }
-}
-
-/** One owned process group and finalized JSON event stream for either native backend. */
-export async function runChildAttempt(
-  options: ReadonlyInput<ChildAttemptOptions>,
-): Promise<ChildAttemptResult> {
-  const result = initialResult(options.model);
-  if (options.signal?.aborted === true || options.interruptSignal?.aborted === true) {
-    Object.assign(
-      result,
-      resolveExecutionOutcome({
-        result,
-        signal: options.signal,
-        interruptSignal: options.interruptSignal,
-      }),
-    );
-    result.finalOutput = result.error ?? "Interrupted. Waiting for explicit next action.";
-    return result;
-  }
-  let baseline: NativeBaseline;
-  try {
-    baseline = snapshotNativeBaseline(nativeSessionFile(options));
-  } catch (error) {
-    return {
-      ...result,
-      exitCode: 1,
-      terminalFailure: true,
-      error: `Cannot capture native usage baseline: ${errorText(error)}`,
-    };
-  }
-  let spool: ChildObservationSpool;
-  try {
-    spool = new ChildObservationSpool(options.auditPath);
-  } catch (error) {
-    return {
-      ...result,
-      exitCode: 1,
-      terminalFailure: true,
-      error: `Cannot prepare child observations: ${errorText(error)}`,
-    };
-  }
-  const runner = new ChildAttemptRunner(options, baseline, spool);
-  runner.start();
-  return runner.completed();
-}