@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-subagents/src/runs/shared/tool-availability.js

@@ -1,59 +1,21 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-export const REQUIRED_CHILD_TOOLS_ENV = "DM_SUBAGENT_REQUIRED_TOOLS";
-export const MCP_DIRECT_CHILD_TOOLS_ENV = "DM_SUBAGENT_MCP_DIRECT_TOOLS";
-export const CHILD_TOOL_DIAGNOSTIC_PATH_ENV = "DM_SUBAGENT_TOOL_DIAGNOSTIC_PATH";
-export function writeChildToolDiagnostic(filePath, required, available, agent, mcpDirectTools) {
-  const availableNames = new Set(available);
-  const missing = required.filter((name) => !availableNames.has(name));
-  if (missing.length === 0) {
-    fs.rmSync(filePath, { force: true });
-    return;
-  }
-  const missingMcpDirectTools = mcpDirectTools?.length ? missing.filter((name) => mcpDirectTools.includes(name)) : [];
-  const diagnostic = {
-    agent,
-    required,
-    available,
-    missing,
-    ...missingMcpDirectTools.length > 0 ? { missingMcpDirectTools } : {}
-  };
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, JSON.stringify(diagnostic), { mode: 384 });
-  return diagnostic;
-}
-export function readChildToolDiagnostic(filePath) {
-  if (!filePath || !fs.existsSync(filePath))
-    return;
-  const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-  const stringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string" && entry.length > 0);
-  if (!stringArray(parsed.required) || !stringArray(parsed.available) || !stringArray(parsed.missing) || parsed.agent !== undefined && typeof parsed.agent !== "string" || parsed.missingMcpDirectTools !== undefined && !stringArray(parsed.missingMcpDirectTools)) {
-    throw new Error(`Malformed child tool diagnostic at '${filePath}'.`);
-  }
-  return {
-    ...parsed.agent ? { agent: parsed.agent } : {},
-    required: parsed.required,
-    available: parsed.available,
-    missing: parsed.missing,
-    ...parsed.missingMcpDirectTools ? { missingMcpDirectTools: parsed.missingMcpDirectTools } : {}
-  };
-}
-export function formatChildToolDiagnostic(diagnostic) {
+export function formatChildToolDiagnostic(diagnostic, options = {}) {
   const subject = diagnostic.agent ? `Agent '${diagnostic.agent}'` : "Subagent";
+  if (options.host === "parent") {
+    return [
+      `${subject} ran as a foreground child, which never loads the parent's ambient extensions, and these child tools were unavailable: ${diagnostic.missing.join(", ")}.`,
+      "The `tools` field is a strict allowlist; it does not load extension code.",
+      ...diagnostic.missingMcpDirectTools?.length ? [`MCP direct tools missing from the child registry: ${diagnostic.missingMcpDirectTools.join(", ")}.`] : [],
+      "Agents that need MCP tools (`mcpDirectTools`, or MCP tools from an ambient adapter such as dm-mcp-adapter) or models from a provider extension must run as background children (`async: true`), which load the ambient extensions.",
+      "For extension tools a foreground child can load, add the provider path to `subagentOnlyExtensions` (child-only), `extensions`, or as a path-like entry in `tools`, while keeping each registered tool name in `tools`."
+    ].join(`
+`);
+  }
   return [
     `${subject} requested unavailable child tools: ${diagnostic.missing.join(", ")}.`,
     "The `tools` field is a strict allowlist; it does not load extension code.",
-    ...diagnostic.missingMcpDirectTools?.length ? [`Resolved MCP direct tools missing from the child registry: ${diagnostic.missingMcpDirectTools.join(", ")}. This indicates a host/dm-mcp-adapter registration problem, not a tool-call failure.`] : [],
+    ...diagnostic.missingMcpDirectTools?.length ? [`Resolved MCP direct tools missing from the child registry: ${diagnostic.missingMcpDirectTools.join(", ")}. Resolved names must match what the host or dm-mcp-adapter registers; check the MCP direct-tool registration before treating this as a tool-call failure.`] : [],
     "For extension tools, add the provider path to `subagentOnlyExtensions` (child-only), `extensions`, or as a path-like entry in `tools`, while keeping each registered tool name in `tools`.",
     "For MCP tools, verify the MCP adapter configuration and selected tool names. For builtin tools, verify the name against the installed DM version."
   ].join(`
 `);
 }
-export function readChildToolDiagnosticError(filePath) {
-  try {
-    const diagnostic = readChildToolDiagnostic(filePath);
-    return diagnostic ? formatChildToolDiagnostic(diagnostic) : undefined;
-  } catch (error) {
-    return `Failed to read child tool availability diagnostic: ${error instanceof Error ? error.message : String(error)}`;
-  }
-}

package/extensions/dm-subagents/src/runs/shared/tool-budget.js

@@ -1,6 +1,4 @@
 export const DEFAULT_TOOL_BUDGET_BLOCK = ["read", "grep", "find", "ls"];
-export const TOOL_BUDGET_ENV = "DM_SUBAGENT_TOOL_BUDGET";
-export const TOOL_BUDGET_ZERO_AUTH_ENV = "DM_SUBAGENT_TOOL_BUDGET_ZERO_AUTH";
 export function normalizeToolBudgetBlock(block) {
   if (block === "*")
     return "*";
@@ -61,15 +59,14 @@ export function toolBudgetSoftNudge(budget, toolCount) {
 export function toolBudgetBlockedMessage(budget, toolName, toolCount) {
   return `Tool budget hard limit reached after ${toolCount} tool call${toolCount === 1 ? "" : "s"} (hard ${budget.hard}). The '${toolName}' tool is blocked so you can finalize from the context you already have.`;
 }
-export function encodeToolBudgetEnv(budget) {
-  return budget ? JSON.stringify(budget) : undefined;
-}
-export function decodeToolBudgetEnv(value, options = {}) {
-  if (!value?.trim())
-    return;
-  const parsed = JSON.parse(value);
-  const normalized = validateToolBudgetConfig(parsed, TOOL_BUDGET_ENV, options.allowZero ? { minimumHard: 0 } : undefined);
-  if (normalized.error)
-    throw new Error(normalized.error);
-  return normalized.budget;
+const TOOL_BUDGET_BLOCKED_MESSAGE = /^Tool budget hard limit reached after (\d+) tool calls? \(hard (\d+)\)\. The '([^']+)' tool is blocked so you can finalize from the context you already have\.$/;
+export function isToolBudgetBlockedMessage(budget, resultText, blockedTool) {
+  const tool = blockedTool?.trim();
+  if (!tool)
+    return false;
+  const match = TOOL_BUDGET_BLOCKED_MESSAGE.exec(resultText.trim());
+  if (!match)
+    return false;
+  const [, blockedToolCount, hard, namedTool] = match;
+  return Number(hard) === budget.hard && Number(blockedToolCount) > budget.hard && namedTool === tool;
 }

package/extensions/dm-subagents/src/runs/shared/tool-timeout.js

@@ -10,7 +10,7 @@ export const DEFAULT_FAST_TOOL_TIMEOUT_TOOLS = new Set([
   "write",
   "structured_output"
 ]);
-export const TOOL_TIMEOUT_EXEMPT_TOOLS = new Set(["contact_supervisor", "intercom", "bg_wait", "subagent_wait"]);
+export const TOOL_TIMEOUT_EXEMPT_TOOLS = new Set(["contact_supervisor", "intercom", "bg_wait"]);
 export const TOOL_TIMEOUT_ALLOWLIST = TOOL_TIMEOUT_EXEMPT_TOOLS;
 export function isToolTimeoutExempt(toolName) {
   return toolName !== undefined && TOOL_TIMEOUT_EXEMPT_TOOLS.has(toolName);

package/extensions/dm-subagents/src/runs/shared/usage-reconciliation.js

@@ -0,0 +1,69 @@
+const usageFields = ["input", "output", "cacheRead", "cacheWrite", "cost"];
+const aliases = {
+  input: ["input", "inputTokens"],
+  output: ["output", "outputTokens"],
+  cacheRead: ["cacheRead", "cacheReadTokens"],
+  cacheWrite: ["cacheWrite", "cacheWriteTokens"]
+};
+function validNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function fieldValue(usage, field) {
+  if (!usage)
+    return;
+  const values = usage;
+  if (field === "cost") {
+    const direct = validNumber(values.cost);
+    if (direct !== undefined)
+      return direct;
+    const cost = values.cost;
+    return cost && typeof cost === "object" && !Array.isArray(cost) ? validNumber(cost.total) : undefined;
+  }
+  for (const name of aliases[field]) {
+    const value = validNumber(values[name]);
+    if (value !== undefined)
+      return value;
+  }
+  return;
+}
+function validTimestamp(message) {
+  const value = message.timestamp;
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string" && value.length > 0)
+    return value;
+  return;
+}
+export function reconcileAttemptUsage(live, messages, baseline) {
+  if (!Number.isInteger(baseline) || baseline < 0 || messages.length < baseline)
+    return { ...live };
+  const persisted = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+  const complete = { input: true, output: true, cacheRead: true, cacheWrite: true, cost: true };
+  let previous;
+  for (let index = baseline;index < messages.length; index++) {
+    const message = messages[index];
+    if (message.role === "assistant") {
+      const timestamp = validTimestamp(message);
+      const duplicate = previous?.role === "assistant" && timestamp !== undefined && validTimestamp(previous) === timestamp;
+      if (!duplicate) {
+        persisted.turns++;
+        for (const field of usageFields) {
+          const value = fieldValue(message.usage, field);
+          if (value === undefined)
+            complete[field] = false;
+          else
+            persisted[field] += value;
+        }
+      }
+    }
+    previous = message;
+  }
+  if (persisted.turns === 0)
+    return { ...live };
+  const reconciled = { ...live, turns: persisted.turns };
+  for (const field of usageFields) {
+    if (complete[field] && Number.isFinite(persisted[field]))
+      reconciled[field] = persisted[field];
+  }
+  return reconciled;
+}

package/extensions/dm-subagents/src/runs/shared/workflow-async-child-guidance.js

@@ -0,0 +1,11 @@
+export function workflowAsyncChildSteeringGuidance(status, state) {
+  if (status.mode !== "workflow" || status.state !== "running" && status.state !== "queued" || !state?.currentSessionId || status.sessionId !== state.currentSessionId || !state.workflowControllers?.has(status.runId))
+    return [];
+  const ids = new Set((status.steps ?? []).flatMap((step) => step.async === true && step.status === "running" && step.runner?.type !== "external-cli" && step.runner?.type !== "external-job" && typeof step.runId === "string" && /^[A-Za-z0-9_-]+$/.test(step.runId) && step.runId !== status.runId ? [step.runId] : []));
+  if (ids.size === 0)
+    return [];
+  return [
+    "Async children recorded as running; direct steering rechecks controls. Choose an exact child ID (queued does not mean consumed):",
+    ...[...ids].map((id) => `  subagent({ action: "steer", id: "${id}", mode: "follow_up", message: "..." })`)
+  ];
+}

package/extensions/dm-subagents/src/runs/shared/worktree-cleanup-plan.js

@@ -6,7 +6,9 @@ import * as path from "node:path";
 import { writeAtomicJson } from "../../shared/atomic-json.js";
 import { PROJECT_SUBAGENTS_RELATIVE_DIR } from "../../shared/artifacts.js";
 import { DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS, activeRunMarkerAgeMs } from "../background/active-run-index.js";
+import { getAgentDir } from "../../shared/utils.js";
 import { isTerminalParallelHandoffChildStatus } from "./parallel-handoff.js";
+import { MACHINE_DIFF_OPTIONS, validateWorktreePatchRepresentsCurrentWorktree } from "./worktree.js";
 export const WORKTREE_CLEANUP_PLAN_VERSION = 1;
 export const WORKTREE_CLEANUP_PLAN_TTL_MS = 30 * 60 * 1000;
 const MAX_DISCOVERED_HANDOFFS = 256;
@@ -109,12 +111,22 @@ function resolveRepoRoot(repo) {
   return realpathExisting(toplevel);
 }
 function resolveCleanupBaseDir(repoRoot, configuredBaseDir) {
-  const raw = configuredBaseDir ?? process.env.DM_SUBAGENTS_WORKTREE_DIR ?? os.tmpdir();
-  const trimmed = raw.trim();
-  if (!trimmed)
-    throw new Error("worktree base directory cannot be empty");
-  const expanded = trimmed.startsWith("~/") ? path.join(os.homedir(), trimmed.slice(2)) : trimmed;
-  return path.resolve(path.isAbsolute(expanded) ? expanded : path.resolve(repoRoot, expanded));
+  const raw = configuredBaseDir ?? process.env.DM_SUBAGENTS_WORKTREE_DIR;
+  let dedicatedRoot;
+  if (raw === undefined || configuredBaseDir === undefined && !raw.trim()) {
+    dedicatedRoot = path.join(path.dirname(repoRoot), "worktrees");
+  } else {
+    const trimmed = raw.trim();
+    if (!trimmed)
+      throw new Error("worktree base directory cannot be empty");
+    const expanded = trimmed.startsWith("~/") ? path.join(os.homedir(), trimmed.slice(2)) : trimmed;
+    dedicatedRoot = path.isAbsolute(expanded) ? expanded : path.resolve(repoRoot, expanded);
+  }
+  return path.resolve(path.join(dedicatedRoot, path.basename(repoRoot)));
+}
+function cleanupContainmentInvalid(repoRoot, projectDir) {
+  const extensionsDir = path.join(getAgentDir(), "extensions");
+  return samePath(projectDir, repoRoot) || pathInside(repoRoot, projectDir, true) || pathInside(extensionsDir, projectDir);
 }
 export function parseGitWorktreeList(raw) {
   const records = [];
@@ -412,7 +424,7 @@ function resolveBranchTip(repoRoot, branch) {
     return { error: gitFailure(result, `git -C ${repoRoot} rev-parse refs/heads/${branch}`) };
   return { value: result.stdout.trim() };
 }
-function isPatchCaptured(record, worktreePath) {
+function isPatchCaptured(record, worktreePath, baseCommit) {
   const patchPath = metadataPatchPath(record);
   if (!patchPath || record.child.patch?.error !== undefined || record.child.patch?.changed !== true)
     return {};
@@ -433,6 +445,9 @@ function isPatchCaptured(record, worktreePath) {
     return { error: "durable handoff patch lives inside the worktree" };
   if (patchStat.size <= 0)
     return { error: "captured handoff patch is empty" };
+  const validationError = validateWorktreePatchRepresentsCurrentWorktree(worktreePath, baseCommit, patchPath);
+  if (validationError)
+    return { error: `captured handoff patch failed validation: ${validationError}` };
   return { path: patchPath };
 }
 function buildManagedEntry(input) {
@@ -465,7 +480,10 @@ function buildManagedEntry(input) {
     return blockedEntry(entry, "unknown", "unknown", "worktree path is a symlink; cleanup requires a real directory");
   if (!pathInspection.directory || !pathInspection.realpath)
     return blockedEntry(entry, "unknown", "unknown", "worktree path is not a directory");
-  if (!pathInside(baseDir, pathInspection.realpath, true))
+  const extensionsDir = path.join(getAgentDir(), "extensions");
+  if (pathInside(extensionsDir, pathInspection.realpath))
+    return blockedEntry(entry, "ineligible", "keep", `worktree real path is inside DM extensions directory '${extensionsDir}'`);
+  if (input.containmentInvalid || !pathInside(baseDir, pathInspection.realpath, true))
     return blockedEntry(entry, "ineligible", "keep", `worktree real path is outside configured base directory '${baseDir}'`);
   if (rootPath === comparablePath(pathInspection.realpath))
     return blockedEntry(entry, "ineligible", "keep", "worktree is the repository root");
@@ -521,7 +539,7 @@ function buildManagedEntry(input) {
   entry.preconditions.statusDigest = status.digest;
   if (status.output && status.output.trim())
     return blockedEntry(entry, "dirty", "keep", "worktree has uncommitted or untracked changes");
-  const diff = runGit(worktreePath, ["diff", "--quiet", resolvedBase.value, "--"]);
+  const diff = runGit(worktreePath, ["diff", "--quiet", ...MACHINE_DIFF_OPTIONS, resolvedBase.value, "--"]);
   if (diff.status !== 0 && diff.status !== 1)
     return blockedEntry(entry, "unknown", "unknown", `git diff safety check failed: ${gitFailure(diff, "git diff")}`);
   const ancestor = runGit(repoRoot, ["merge-base", "--is-ancestor", git.head, targetHead]);
@@ -530,7 +548,7 @@ function buildManagedEntry(input) {
   const branchTipIsAncestor = ancestor.status === 0;
   let divergenceSafe = diff.status === 0;
   if (!divergenceSafe) {
-    const captured = isPatchCaptured(record, worktreePath);
+    const captured = isPatchCaptured(record, worktreePath, resolvedBase.value);
     if (captured.error)
       return blockedEntry(entry, "ineligible", "keep", captured.error);
     if (captured.path) {
@@ -605,6 +623,7 @@ export function buildWorktreeCleanupPlan(input) {
   if (!Number.isFinite(now))
     throw new Error("worktree cleanup plan timestamp must be finite");
   const baseDir = resolveCleanupBaseDir(repoRoot, input.worktreeBaseDir);
+  const containmentInvalid = cleanupContainmentInvalid(repoRoot, baseDir);
   const gitRecords = listGitWorktrees(repoRoot);
   const targetHead = runGitChecked(repoRoot, ["rev-parse", "HEAD"]);
   const rootPath = comparablePath(repoRoot);
@@ -629,6 +648,7 @@ export function buildWorktreeCleanupPlan(input) {
       entries.push(buildManagedEntry({
         repoRoot,
         baseDir,
+        containmentInvalid,
         targetHead,
         rootPath,
         git,

package/extensions/dm-subagents/src/runs/shared/worktree-setup-command.js

@@ -0,0 +1,195 @@
+import { spawn } from "node:child_process";
+import { createOwnedProcessTreeController } from "../background/owned-process-tree.js";
+function terminateCommandTree(pid, controller) {
+  if (process.platform !== "win32")
+    return controller.terminate();
+  return new Promise((resolve) => {
+    let settled = false;
+    const fallback = () => {
+      if (settled)
+        return;
+      settled = true;
+      controller.terminate().then(resolve);
+    };
+    const cleanup = spawn("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+    cleanup.once("error", fallback);
+    cleanup.once("close", (status) => {
+      if (settled)
+        return;
+      if (status !== 0)
+        return fallback();
+      settled = true;
+      resolve({ state: "observed", mechanism: "windows-taskkill", pid, verifiedAt: Date.now() });
+    });
+  });
+}
+function commandError(message, code) {
+  return Object.assign(new Error(message), { code });
+}
+export async function runSetupCommand(command, args, options) {
+  const result = {
+    stdout: "",
+    stdoutBuffer: Buffer.alloc(0),
+    stderr: "",
+    status: null,
+    signal: null,
+    outputIncomplete: false
+  };
+  const maxBuffer = options.maxBuffer ?? 1024 * 1024;
+  if (!Number.isSafeInteger(maxBuffer) || maxBuffer <= 0)
+    throw new Error("Invalid setup command maxBuffer");
+  if (options.deadlineAt !== undefined && !Number.isFinite(options.deadlineAt))
+    throw new Error("Invalid setup deadline");
+  if (options.hookTimeoutMs !== undefined && (!Number.isSafeInteger(options.hookTimeoutMs) || options.hookTimeoutMs <= 0)) {
+    throw new Error("Invalid setup hook timeout");
+  }
+  const cancellation = () => {
+    if (options.signal?.aborted)
+      return commandError("Worktree setup aborted", "ABORT_ERR");
+    if (options.deadlineAt !== undefined && Date.now() >= options.deadlineAt) {
+      return commandError("Worktree setup deadline exceeded", "ETIMEDOUT");
+    }
+    return;
+  };
+  result.error = cancellation();
+  if (result.error)
+    return result;
+  let child;
+  try {
+    child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env ? { ...process.env, ...options.env } : process.env,
+      stdio: "pipe",
+      shell: false,
+      windowsHide: true,
+      detached: process.platform !== "win32"
+    });
+  } catch (error) {
+    result.error = error instanceof Error ? error : new Error(String(error));
+    return result;
+  }
+  result.pid = child.pid;
+  if (child.pid !== undefined && process.platform !== "win32")
+    result.processGroupId = child.pid;
+  const tree = child.pid === undefined ? undefined : createOwnedProcessTreeController(child.pid);
+  let termination;
+  let directSettled = false;
+  const releaseUnknownIO = () => {
+    if (!directSettled || result.processTree?.state !== "unknown")
+      return;
+    const detail = result.processTree.diagnostic ? `: ${result.processTree.diagnostic}` : "";
+    result.error = commandError(`Worktree setup process tree settlement is unverified${detail}`, "PROCESS_TREE_UNVERIFIED");
+    result.outputIncomplete = true;
+    child.stdin.destroy();
+    child.stdout.destroy();
+    child.stderr.destroy();
+  };
+  const terminate = () => {
+    if (termination || !tree)
+      return;
+    if (directSettled) {
+      result.processTree = {
+        state: "unknown",
+        reason: "verification-failed",
+        diagnostic: "Command exited before termination began; no longer safe to signal its recorded PID."
+      };
+      releaseUnknownIO();
+      return;
+    }
+    termination = terminateCommandTree(result.pid, tree).then((proof) => {
+      result.processTree = proof;
+      releaseUnknownIO();
+      return proof;
+    });
+  };
+  const fail = (error) => {
+    result.error ??= error;
+    terminate();
+  };
+  const onAbort = () => fail(commandError("Worktree setup aborted", "ABORT_ERR"));
+  const stdout = [];
+  const stderr = [];
+  let capturedBytes = 0;
+  const capture = (chunks, chunk) => {
+    const remaining = maxBuffer - capturedBytes;
+    if (remaining > 0) {
+      const saved = Buffer.from(chunk.subarray(0, remaining));
+      chunks.push(saved);
+      capturedBytes += saved.length;
+    }
+    if (chunk.length > remaining) {
+      result.outputIncomplete = true;
+      fail(commandError("Worktree setup command output exceeds maxBuffer", "ENOBUFS"));
+    }
+  };
+  const onStdout = (chunk) => capture(stdout, chunk);
+  const onStderr = (chunk) => capture(stderr, chunk);
+  child.stdout.on("data", onStdout);
+  child.stderr.on("data", onStderr);
+  child.stdin.on("error", fail);
+  const close = new Promise((resolve) => child.once("close", () => resolve()));
+  const directExit = new Promise((resolve) => {
+    child.once("exit", (status, signal) => {
+      directSettled = true;
+      result.status = status;
+      result.signal = signal;
+      if (status === null || !(options.acceptedExitCodes ?? [0]).includes(status))
+        terminate();
+      releaseUnknownIO();
+      resolve();
+    });
+    child.once("error", (error) => {
+      fail(error);
+      if (child.pid === undefined) {
+        directSettled = true;
+        resolve();
+      }
+    });
+  });
+  let timer;
+  const deadlineAt = Math.min(options.deadlineAt ?? 1 / 0, options.hookTimeoutMs === undefined ? 1 / 0 : Date.now() + options.hookTimeoutMs);
+  const armDeadline = () => {
+    if (deadlineAt === 1 / 0)
+      return;
+    const remaining = deadlineAt - Date.now();
+    if (remaining <= 0)
+      fail(commandError("Worktree setup command timed out", "ETIMEDOUT"));
+    else
+      timer = setTimeout(armDeadline, Math.min(remaining, 2 ** 31 - 1));
+  };
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    armDeadline();
+    if (options.signal?.aborted)
+      onAbort();
+    if (child.pid !== undefined) {
+      try {
+        options.onSpawn?.({ pid: child.pid, processGroupId: result.processGroupId });
+      } catch (error) {
+        fail(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+    child.stdin.end(options.input);
+    await directExit;
+    if (termination)
+      result.processTree = await termination;
+    releaseUnknownIO();
+    await close;
+    if (termination)
+      result.processTree = await termination;
+    const cancelled = cancellation();
+    if (cancelled)
+      fail(cancelled);
+    result.stdoutBuffer = Buffer.concat(stdout);
+    result.stdout = result.stdoutBuffer.toString("utf8");
+    result.stderr = Buffer.concat(stderr).toString("utf8");
+    return result;
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+    options.signal?.removeEventListener("abort", onAbort);
+    child.stdout.removeListener("data", onStdout);
+    child.stderr.removeListener("data", onStderr);
+    child.stdin.removeListener("error", fail);
+  }
+}