@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/src/runs/shared/owned-run-results.ts

@@ -1,289 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { compactForegroundResult, getSingleResultOutput } from "../../shared/utils.ts";
-import { readAsyncResultFile } from "../background/async-result-file.ts";
-import { exactAsyncRunLocation } from "../background/async-resume.ts";
-import { getRunMetadataDir } from "./supervisor-questions.ts";
-import {
-  ASYNC_DIR,
-  DEFAULT_MAX_OUTPUT,
-  RESULTS_DIR,
-  truncateOutput,
-  type OwnedRun,
-  type OwnedRunView,
-  type ReadonlyAsyncResultFile,
-  type ReadonlySingleResult,
-  type MaxOutputConfig,
-  type SubagentExecutionResult,
-} from "../../shared/types.ts";
-import { repairOwnedRunAccounting } from "./run-persistence.ts";
-import type { OwnedRunReadState } from "./owned-run-read-state.ts";
-import { ownedRunView } from "./owned-run-view.ts";
-import { ownedRunProgressResult } from "./owned-run-progress.ts";
-import { workflowDetails } from "./owned-workflow-details.ts";
-export { ownedRunProgressResult } from "./owned-run-progress.ts";
-
-type ChildView = OwnedRunView["children"][number];
-type Limits = Readonly<Required<MaxOutputConfig>>;
-
-function initialOutput(
-  result: ReadonlySingleResult,
-  limits: Limits,
-  artifactPath?: string,
-): Pick<ReadonlySingleResult, "initialOutput"> {
-  const initial = result.initialOutput;
-  return initial !== undefined && initial !== ""
-    ? { initialOutput: truncateOutput(initial, limits, artifactPath).text }
-    : {};
-}
-
-function projectChild(child: ChildView, limits: Limits): ChildView {
-  if (!child.result) {
-    return { ...child, result: undefined };
-  }
-  const { artifactPaths, ...result } = child.result;
-  const truncation =
-    result.outputMode === "file-only" && result.exitCode === 0 && result.outputReference
-      ? { text: result.outputReference.message, truncated: false }
-      : truncateOutput(getSingleResultOutput(result), limits, artifactPaths?.outputPath);
-  const compacted = compactForegroundResult({
-    ...result,
-    finalOutput: truncation.text,
-    ...(truncation.truncated ? { truncation } : {}),
-    ...initialOutput(result, limits, artifactPaths?.outputPath),
-  });
-  return { ...child, result: { ...compacted, ...(artifactPaths ? { artifactPaths } : {}) } };
-}
-
-function publicResult(child: ChildView): ReadonlySingleResult[] {
-  if (!child.result) {
-    return [];
-  }
-  const { artifactPaths, ...result } = child.result;
-  if (
-    artifactPaths?.inputPath !== undefined &&
-    artifactPaths.inputPath !== "" &&
-    artifactPaths.outputPath !== undefined &&
-    artifactPaths.outputPath !== "" &&
-    artifactPaths.metadataPath !== undefined &&
-    artifactPaths.metadataPath !== ""
-  ) {
-    return [
-      {
-        ...result,
-        artifactPaths: {
-          inputPath: artifactPaths.inputPath,
-          outputPath: artifactPaths.outputPath,
-          metadataPath: artifactPaths.metadataPath,
-        },
-      },
-    ];
-  }
-  return [result];
-}
-
-function resultFailed(view: OwnedRunView, children: readonly ChildView[], index?: number): boolean {
-  return index === undefined
-    ? ["failed", "unknown"].includes(view.state)
-    : children.length === 0 ||
-        children.some((child) => ["failed", "unknown"].includes(child.state));
-}
-
-function resultText(
-  view: OwnedRunView,
-  children: readonly ChildView[],
-  saved: ReadonlyAsyncResultFile | undefined,
-  index?: number,
-): string {
-  const summary = index === undefined ? saved?.summary : undefined;
-  let text =
-    summary !== undefined && summary !== ""
-      ? summary
-      : [
-          ...children.map((child) => {
-            if (!child.result) {
-              return;
-            }
-            const output = getSingleResultOutput(child.result);
-            return output !== "" ? output : child.result.error;
-          }),
-          view.diagnosis,
-        ]
-          .filter((part) => part !== undefined && part !== "")
-          .join("\n\n");
-  const error = saved?.error;
-  if (
-    resultFailed(view, children, index) &&
-    error !== undefined &&
-    error !== "" &&
-    !text.includes(error)
-  ) {
-    text = `${error}\n\n${text}`;
-  }
-  return text;
-}
-
-function outputArtifact(
-  run: OwnedRun,
-  results: readonly ReadonlySingleResult[],
-  directory: string,
-): string | undefined {
-  if (run.mode === "single") {
-    return results[0]?.artifactPaths?.outputPath;
-  }
-  const logPath = path.join(directory, `subagent-log-${run.runId}.md`);
-  return fs.existsSync(logPath) ? logPath : undefined;
-}
-
-function summaryTruncation(
-  view: OwnedRunView,
-  results: readonly ReadonlySingleResult[],
-  output: { readonly text: string; readonly limits: Limits },
-): ReturnType<typeof truncateOutput> {
-  const { text, limits } = output;
-  const only = results.length === 1 ? results[0] : undefined;
-  if (
-    view.state === "completed" &&
-    view.mode === "single" &&
-    only?.outputMode === "file-only" &&
-    only.outputReference
-  ) {
-    return { text: only.outputReference.message, truncated: false };
-  }
-  if (view.state === "blocked") {
-    return { text, truncated: false };
-  }
-  const directory = view.asyncDir ?? getRunMetadataDir(view.runId);
-  return truncateOutput(text, limits, outputArtifact(view, results, directory));
-}
-
-function progressSummary(
-  results: readonly ReadonlySingleResult[],
-  duration?: number,
-): SubagentExecutionResult["details"]["progressSummary"] {
-  return {
-    toolCount: results.reduce(
-      (total, result) => total + (result.progressSummary?.toolCount ?? 0),
-      0,
-    ),
-    tokens: results.reduce((total, result) => total + (result.progressSummary?.tokens ?? 0), 0),
-    durationMs:
-      duration ?? Math.max(0, ...results.map((result) => result.progressSummary?.durationMs ?? 0)),
-  };
-}
-
-function resultIdentity(run: OwnedRun): string[] {
-  return (run.predecessorRunId ?? "") !== ""
-    ? [
-        `Run: ${run.runId}\nPredecessor: ${run.predecessorRunId ?? ""} (child ${run.predecessorIndex ?? 0})`,
-      ]
-    : [];
-}
-
-function sharingText(saved: ReadonlyAsyncResultFile | undefined): string[] {
-  if (saved?.shareUrl !== undefined && saved.shareUrl !== "") {
-    return [`Session: ${saved.shareUrl}`];
-  }
-  return saved?.shareError !== undefined && saved.shareError !== ""
-    ? [`Session share error: ${saved.shareError}`]
-    : [];
-}
-
-function savedDetails(
-  saved: ReadonlyAsyncResultFile | undefined,
-  results: readonly ReadonlySingleResult[],
-): Pick<
-  SubagentExecutionResult["details"],
-  | "artifacts"
-  | "shareUrl"
-  | "gistUrl"
-  | "shareError"
-  | "outputs"
-  | "workflowGraph"
-  | "chainAgents"
-  | "totalSteps"
-  | "currentStepIndex"
-> {
-  if (!saved) {
-    return resultArtifacts(results);
-  }
-  return {
-    ...((saved.shareUrl ?? "") !== "" ? { shareUrl: saved.shareUrl } : {}),
-    ...((saved.gistUrl ?? "") !== "" ? { gistUrl: saved.gistUrl } : {}),
-    ...((saved.shareError ?? "") !== "" ? { shareError: saved.shareError } : {}),
-    ...(saved.outputs ? { outputs: saved.outputs } : {}),
-    ...workflowDetails(saved.workflowGraph),
-    ...resultArtifacts(results, saved.artifactsDir),
-  };
-}
-
-function resultArtifacts(
-  results: readonly ReadonlySingleResult[],
-  directory?: string,
-): Pick<SubagentExecutionResult["details"], "artifacts"> {
-  const files = results.flatMap((result) => (result.artifactPaths ? [result.artifactPaths] : []));
-  const first = files.at(0);
-  return first ? { artifacts: { dir: directory ?? path.dirname(first.outputPath), files } } : {};
-}
-
-function loadSavedResult(file: string | null): ReadonlyAsyncResultFile | undefined {
-  return file !== null && file !== "" ? readAsyncResultFile(file) : undefined;
-}
-
-function outputLimits(saved: ReadonlyAsyncResultFile | undefined, view: OwnedRunView): Limits {
-  return { ...DEFAULT_MAX_OUTPUT, ...(saved?.maxOutput ?? view.children.at(0)?.launch?.maxOutput) };
-}
-
-export function ownedRunExecutionResult(
-  run: OwnedRun,
-  state: OwnedRunReadState,
-  index?: number,
-  includeProgress = false,
-): SubagentExecutionResult {
-  try {
-    repairOwnedRunAccounting(run);
-  } catch (error) {
-    console.error(`Native accounting for ${run.runId} remains incomplete:`, error);
-  }
-  const view = ownedRunView(run, state);
-  const location = exactAsyncRunLocation(run.runId, ASYNC_DIR, RESULTS_DIR);
-  const saved = loadSavedResult(location.resultPath);
-  const limits = outputLimits(saved, view);
-  const children = view.children.filter((child) => index === undefined || child.index === index);
-  const projected = view.children.map((child) => projectChild(child, limits));
-  const results = projected
-    .filter((child) => index === undefined || child.index === index)
-    .flatMap(publicResult);
-  const truncation = summaryTruncation(
-    { ...view, asyncDir: location.asyncDir ?? view.asyncDir },
-    results,
-    { text: resultText(view, children, saved, index), limits },
-  );
-  return {
-    content: [
-      {
-        type: "text",
-        text: [
-          ...resultIdentity(run),
-          truncation.text !== "" ? truncation.text : `Run ${run.runId}: ${view.state}.`,
-          ...sharingText(saved),
-        ].join("\n\n"),
-      },
-    ],
-    ...(resultFailed(view, children, index) ? { isError: true } : {}),
-    details: {
-      mode: run.mode,
-      runId: run.runId,
-      asyncId: run.runId,
-      asyncDir: location.asyncDir ?? run.asyncDir,
-      results,
-      run: { ...view, children: projected },
-      progressSummary: progressSummary(results, saved?.durationMs),
-      ...(includeProgress
-        ? { progress: ownedRunProgressResult(run, state, index).details.progress }
-        : {}),
-      ...savedDetails(saved, results),
-      ...(truncation.truncated ? { truncation } : {}),
-    },
-  };
-}

package/src/runs/shared/owned-run-status.ts

@@ -1,239 +0,0 @@
-import * as fs from "node:fs";
-import { getSingleResultOutput } from "../../shared/utils.ts";
-import {
-  buildManagementControl,
-  formatAgentProcessExit,
-  formatRunAction,
-} from "../../shared/status-format.ts";
-import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
-import { acceptanceHumanAction } from "./acceptance-evaluation.ts";
-import type {
-  ManagementControl,
-  OwnedRun,
-  OwnedRunView,
-  SubagentExecutionResult,
-  ReadonlyInput,
-} from "../../shared/types.ts";
-import type { OwnedRunReadState } from "./owned-run-read-state.ts";
-import { ownedRunView } from "./owned-run-view.ts";
-
-type StatusOptions = { readonly full?: boolean; readonly childSafe?: boolean };
-type ChildView = OwnedRunView["children"][number];
-
-export function compact(value: string, max = 180): string {
-  const text = value.replace(/\s+/g, " ").trim();
-  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
-}
-
-export function ownedRunControl(view: OwnedRunView): ManagementControl {
-  const active = view.children.find(
-    (child) => child.state === "live" && child.activity?.status !== "pending",
-  );
-  const resumable =
-    active ??
-    view.children.find(
-      (child) =>
-        child.state !== "live" && (child.sessionFile ?? "") !== "" && child.missingSession !== true,
-    );
-  return buildManagementControl({
-    state: view.state,
-    runId: view.runId,
-    index: resumable?.index,
-    canReview: view.state !== "live",
-    canResume: resumable !== undefined,
-    canNudge: active !== undefined,
-    canInterrupt: view.canInterrupt,
-    intercomTarget: active
-      ? resolveSubagentIntercomTarget(view.runId, active.agent, active.index)
-      : undefined,
-  });
-}
-
-function reviewDescription(run: OwnedRun, full: boolean): string {
-  const message = run.review?.message;
-  const suffix =
-    message !== undefined && message !== "" ? ` — ${full ? message : compact(message)}` : "";
-  return `Parent review (not sent to child): ${run.review?.decision ?? "unreviewed"}${suffix}`;
-}
-
-function notificationDescription(run: OwnedRun): string {
-  if (!run.delivery) {
-    return "Notification: not recorded";
-  }
-  return `Notification: recorded ${new Date(run.delivery.notifiedAt).toISOString()}; intercom ${run.delivery.intercomDelivered ? "delivered" : "not confirmed"}`;
-}
-
-function optionalLine(prefix: string, value: string | undefined): string[] {
-  return value !== undefined && value !== "" ? [`${prefix}${value}`] : [];
-}
-
-function runDescription(run: OwnedRun, view: OwnedRunView, full: boolean): string[] {
-  return [
-    `Run: ${run.runId}`,
-    `State: ${view.state}`,
-    `Mode: ${run.mode} (${run.source})`,
-    `Task: ${full ? run.task : compact(run.task)}`,
-    `Launch cwd: ${run.cwd}`,
-    `Root: ${run.rootRunId}`,
-    ...((run.predecessorRunId ?? "") !== ""
-      ? [`Predecessor: ${run.predecessorRunId ?? ""} (child ${run.predecessorIndex ?? 0})`]
-      : []),
-    reviewDescription(run, full),
-    notificationDescription(run),
-    ...(view.attention.length > 0 ? [`Attention: ${view.attention.join(", ")}`] : []),
-    ...optionalLine("Result: ", view.resultPath),
-    ...optionalLine("", view.diagnosis),
-  ];
-}
-
-function fileDescription(label: string, file?: string): string[] {
-  if (file === undefined || file === "") {
-    return [];
-  }
-  return [`  ${label}: ${file}${fs.existsSync(file) ? "" : " (missing)"}`];
-}
-
-function childEvidence(child: ChildView): string[] {
-  const result = child.result;
-  const output = result ? getSingleResultOutput(result) : "";
-  const humanAction = acceptanceHumanAction(result?.acceptance);
-  return [
-    ...optionalLine("  Needs your action — acceptance incomplete:\n", humanAction),
-    ...(child.state !== "live" ? [`  ${formatAgentProcessExit(result?.agentProcessExit)}`] : []),
-    ...childOutputPaths(child),
-    ...(output !== "" ? [`  Result: ${compact(output, 600)}`] : []),
-    ...optionalLine("  Error: ", result?.error),
-  ];
-}
-
-function childOutputPaths(child: ChildView): string[] {
-  const result = child.result;
-  return [
-    ...optionalLine("  Child observations / uncommitted output: ", result?.auditPath),
-    ...optionalLine("  Full output: ", result?.fullOutputPath),
-    ...fileDescription("Artifact", result?.artifactPaths?.outputPath),
-    ...fileDescription(
-      "Result metadata (acceptance details when configured)",
-      result?.artifactPaths?.metadataPath,
-    ),
-  ];
-}
-
-function childConfiguration(child: ChildView, full: boolean): string[] {
-  const launch = child.launch;
-  if (!launch) {
-    return ["  Configuration: legacy-partial; original profile snapshot was not recorded."];
-  }
-  return [
-    `  Effective model: ${launch.model ?? "native default"}; thinking: ${launch.thinking ?? "native default"}`,
-    `  Output: ${launch.output === false || launch.output === "" ? "disabled" : launch.output} (${launch.outputMode}); configuration: saved launch snapshot`,
-    ...(full ? [`  Saved launch configuration:\n${JSON.stringify(launch, null, 2)}`] : []),
-  ];
-}
-
-function childSession(child: ChildView): string[] {
-  const file = child.sessionFile;
-  if (file === undefined || file === "") {
-    return [];
-  }
-  return [
-    `  Session: ${file}${child.missingSession === true ? " (missing; continuation unavailable)" : ""}`,
-  ];
-}
-
-function childAccounting(child: ChildView): string[] {
-  const accounting = child.result?.accounting;
-  return accounting?.state === "incomplete"
-    ? [
-        `  Accounting incomplete: ${accounting.error ?? "Native billing evidence is unavailable; no work was repeated."}`,
-      ]
-    : [];
-}
-
-function childDescription(child: ChildView, full: boolean): string[] {
-  const result = child.result;
-  return [
-    `Child ${child.index}: ${child.agent} | ${child.state}${result?.acceptance ? ` | validation: ${result.acceptance.status}` : ""}`,
-    ...childEvidence(child),
-    ...childSession(child),
-    ...childAccounting(child),
-    ...childConfiguration(child, full),
-  ];
-}
-
-function actionDescription(
-  view: OwnedRunView,
-  control: ManagementControl,
-  options: StatusOptions,
-): string[] {
-  const resumeIndex = control.nextActions.find((action) => action.action === "resume")?.index ?? 0;
-  return [
-    ...(control.capabilities.includes("review")
-      ? [
-          `Review (parent-only, not sent to child): ${formatRunAction("review", view.runId, { decision: "accepted" }, options.childSafe)} or decision: "needs_changes".`,
-        ]
-      : []),
-    ...(view.continuations.length > 0
-      ? [
-          "Continuation history:",
-          ...view.continuations.map(
-            (next) => `  ${next.predecessorRunId}:${next.predecessorIndex ?? 0} -> ${next.runId}`,
-          ),
-        ]
-      : []),
-    ...(control.capabilities.includes("resume")
-      ? [
-          `Continue: ${formatRunAction("resume", view.runId, { ...(view.children.length > 1 ? { index: resumeIndex } : {}), message: "..." }, options.childSafe)}`,
-        ]
-      : []),
-    ...(options.full !== true
-      ? [
-          `Full task/configuration: ${formatRunAction("status", view.runId, { full: true }, options.childSafe)}`,
-        ]
-      : []),
-  ];
-}
-
-function runtimeDescription(
-  runtime: ReadonlyInput<SubagentExecutionResult> | undefined,
-  include: boolean,
-): string[] {
-  if (!runtime || runtime.isError === true || !include) {
-    return [];
-  }
-  return runtime.content.flatMap((part) => (part.type === "text" ? [part.text] : []));
-}
-
-export function ownedRunStatusResult(
-  run: OwnedRun,
-  state: OwnedRunReadState,
-  runtime?: ReadonlyInput<SubagentExecutionResult>,
-  options: StatusOptions = {},
-): SubagentExecutionResult {
-  const view = ownedRunView(run, state);
-  const liveControl =
-    view.state === "live" && runtime?.details.managementControl?.state === "live"
-      ? runtime.details.managementControl
-      : undefined;
-  const control = liveControl ?? ownedRunControl(view);
-  const runtimeText = runtimeDescription(
-    runtime,
-    run.source === "async" || liveControl !== undefined,
-  );
-  const lines = [
-    ...runDescription(run, view, options.full === true),
-    ...runtimeText,
-    ...view.children.flatMap((child) => childDescription(child, options.full === true)),
-    ...actionDescription(view, control, options),
-  ];
-  return {
-    content: [{ type: "text", text: lines.join("\n") }],
-    details: {
-      ...runtime?.details,
-      mode: "management",
-      results: [],
-      run: view,
-      managementControl: control,
-    },
-  };
-}

package/src/runs/shared/owned-run-view.ts

@@ -1,65 +0,0 @@
-import * as path from "node:path";
-import { listOwnedRunQuestions } from "./supervisor-questions.ts";
-import type { ManagementRunState, OwnedRun, OwnedRunView } from "../../shared/types.ts";
-import type { OwnedRunReadState } from "./owned-run-read-state.ts";
-import { RunObservation, type OwnedRunViewOptions } from "./owned-run-observation.ts";
-
-function runAttention(run: OwnedRun, state: ManagementRunState, pendingInput: boolean): string[] {
-  return [
-    ...(pendingInput ? ["awaiting_input"] : []),
-    ...(run.review?.decision === "needs_changes" ? ["needs_changes"] : []),
-    ...(run.review?.decision !== "accepted" &&
-    ["failed", "blocked", "paused", "unknown"].includes(state)
-      ? [state]
-      : []),
-    ...(state === "completed" && !run.review ? ["unreviewed"] : []),
-  ];
-}
-
-function continuations(run: OwnedRun, state: OwnedRunReadState): OwnedRunView["continuations"] {
-  return [...(state.ownedRuns?.values() ?? [])]
-    .filter((candidate) => candidate.rootRunId === run.rootRunId)
-    .sort((a, b) => a.startedAt - b.startedAt)
-    .flatMap((candidate) =>
-      candidate.predecessorRunId !== undefined && candidate.predecessorRunId !== ""
-        ? [
-            {
-              runId: candidate.runId,
-              predecessorRunId: candidate.predecessorRunId,
-              predecessorIndex: candidate.predecessorIndex,
-            },
-          ]
-        : [],
-    );
-}
-
-export function ownedRunView(
-  requestedRun: OwnedRun,
-  state: OwnedRunReadState,
-  options: OwnedRunViewOptions = {},
-): OwnedRunView {
-  const run = state.ownedRuns?.get(requestedRun.runId) ?? requestedRun;
-  const observed = new RunObservation(run, state, options);
-  const children = observed.indices.map((index) => observed.child(index));
-  const pendingInput =
-    options.pendingInput ??
-    listOwnedRunQuestions(run.ownerSessionId, run.runId).some(
-      (question) => question.state === "awaiting_input" || question.state === "answer_pending",
-    );
-  const summary = observed.summary(children, pendingInput);
-  const resultPath = observed.result ? observed.resultPath : undefined;
-  return {
-    ...run,
-    state: summary.state,
-    children,
-    attention: runAttention(run, summary.state, pendingInput),
-    canInterrupt: summary.canInterrupt,
-    updatedAt: summary.updatedAt,
-    continuations: options.includeContinuations === false ? [] : continuations(run, state),
-    ...(resultPath !== undefined ? { resultPath } : {}),
-    ...(!observed.result && observed.foreground
-      ? { resultPath: path.join(observed.root, "foreground.json") }
-      : {}),
-    diagnosis: summary.diagnosis,
-  };
-}

package/src/runs/shared/owned-workflow-details.ts

@@ -1,24 +0,0 @@
-import type { Details, WorkflowGraphSnapshot } from "../../shared/types.ts";
-
-/** Saved graph facts shared by result and activity projections, never workflow execution. */
-export function workflowDetails(
-  graph: WorkflowGraphSnapshot | undefined,
-): Pick<Details, "workflowGraph" | "chainAgents" | "totalSteps" | "currentStepIndex"> {
-  if (!graph) {
-    return {};
-  }
-  if (graph.mode !== "chain") {
-    return { workflowGraph: graph };
-  }
-  const current = graph.nodes.find(
-    (node) =>
-      node.id === graph.currentNodeId ||
-      node.children?.some((child) => child.id === graph.currentNodeId) === true,
-  );
-  return {
-    workflowGraph: graph,
-    chainAgents: graph.nodes.map((node) => node.agent ?? node.label),
-    totalSteps: graph.nodes.length,
-    ...(current?.stepIndex !== undefined ? { currentStepIndex: current.stepIndex } : {}),
-  };
-}

package/src/runs/shared/owner-output.ts

@@ -1,73 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { ReadonlyInput } from "../../shared/types.ts";
-import { getRunMetadataDir, QUESTIONS_DIR } from "./run-metadata-paths.ts";
-
-interface OwnerOutput {
-  readonly finalOutput?: string;
-  readonly output?: string;
-  readonly initialOutput?: string;
-  readonly initialOutputPath?: string;
-  readonly messages?: unknown;
-  readonly artifactPaths?: { readonly outputPath?: string };
-  readonly fullOutputPath?: string;
-}
-interface OutputSlot {
-  readonly runId: string;
-  readonly index: number;
-  readonly root: string;
-}
-
-function writeOwnedOutput(slot: OutputSlot, text: string, initial: boolean): string {
-  const name = initial ? `${slot.index}.initial.txt` : `${slot.index}.txt`;
-  const file = path.join(getRunMetadataDir(slot.runId, slot.root), "outputs", name);
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, text, { mode: 0o600 });
-  return file;
-}
-
-function terminalOutputPath(result: OwnerOutput, slot: OutputSlot): string | undefined {
-  const output = result.finalOutput ?? result.output;
-  let file = result.fullOutputPath;
-  if (output === undefined || output.length <= 8192) {
-    return file;
-  }
-  file ??= result.artifactPaths?.outputPath;
-  return file === undefined || file === "" ? writeOwnedOutput(slot, output, false) : file;
-}
-function initialOutputPath(result: OwnerOutput, slot: OutputSlot): string | undefined {
-  const output = result.initialOutput;
-  const file = result.initialOutputPath;
-  if (output === undefined || output.length <= 8192) {
-    return file;
-  }
-  return file === undefined || file === "" ? writeOwnedOutput(slot, output, true) : file;
-}
-
-export function compactOwnerResult<T extends OwnerOutput>(
-  runId: string,
-  index: number,
-  result: ReadonlyInput<T>,
-  root?: string,
-): ReadonlyInput<T>;
-export function compactOwnerResult(
-  runId: string,
-  index: number,
-  result: OwnerOutput,
-  root = QUESTIONS_DIR,
-): OwnerOutput {
-  const slot = { runId, index, root };
-  const fullOutputPath = terminalOutputPath(result, slot);
-  const initialPath = initialOutputPath(result, slot);
-  return {
-    ...result,
-    messages: undefined,
-    ...((fullOutputPath ?? "") !== "" ? { fullOutputPath } : {}),
-    ...((initialPath ?? "") !== "" ? { initialOutputPath: initialPath } : {}),
-    ...(result.finalOutput !== undefined ? { finalOutput: result.finalOutput.slice(-8192) } : {}),
-    ...(result.output !== undefined ? { output: result.output.slice(-8192) } : {}),
-    ...(result.initialOutput !== undefined
-      ? { initialOutput: result.initialOutput.slice(-8192) }
-      : {}),
-  };
-}