@desplega.ai/agent-swarm 2.5.3 → 2.5.4

package/src/providers/codex-adapter.ts

@@ -31,6 +31,7 @@
 import { existsSync as nodeExistsSync } from "node:fs";
 import { join } from "node:path";
 import { buildRatingsFromLlm, fetchRetrievalsForTask, postRatings } from "../be/memory/raters/llm";
+import { contextBoundNoteThreshold, createContextBoundNote } from "../hooks/context-bound-note";
 import { getApiKey } from "../utils/api-key";
 import {
   CONTEXT_FORMULA,
@@ -995,6 +996,8 @@ export class CodexSession implements ProviderSession {
    * summary path which materially relies on this ordering for testability.
    */
   private pendingResult: ProviderResult | null = null;
+  /** Fed each main-thread request's prompt size; steers the one-time context-bound note. */
+  private readonly observeContextBound: (contextTokens: number | undefined) => Promise<void>;
 
   constructor(
     thread: CodexThread,
@@ -1015,6 +1018,13 @@ export class CodexSession implements ProviderSession {
       skillsDir ?? process.env.CODEX_SKILLS_DIR ?? join(codexUserHome(), ".codex", "skills");
     this.summarizeDeps = summarizeDeps;
     this.logFileHandle = Bun.file(config.logFile).writer();
+    this.observeContextBound = createContextBoundNote({
+      threshold: contextBoundNoteThreshold(config.env ?? process.env),
+      model: () => this.resolvedModel,
+      // `turn/steer` only joins the active turn, so a late note never starts one.
+      canDeliver: () => this.acceptsSteering && !this.settled && !this.aborted,
+      inject: (note) => this.deliverSteering({ mode: "steer", text: note }),
+    });
     // Mirrors the resolution `buildCodexConfig` already applied when
     // constructing `mergedConfig` — cheap, pure, and keeps the applied-level
     // feedback co-located with `settle()` rather than threading an extra
@@ -1425,6 +1435,8 @@ export class CodexSession implements ProviderSession {
         break;
       case "context.updated":
         this.emitContextUsage(event.usage, event.contextWindow ?? this.contextWindow);
+        // Codex input tokens already include the cached read and write subsets.
+        void this.observeContextBound(event.usage.input_tokens);
         break;
       case "error": {
         const { message } = this.formatTerminalError(event.message, event.codexErrorInfo);

package/src/providers/opencode-adapter.ts

@@ -21,6 +21,7 @@ import {
   providerKeyVars,
 } from "@desplega/model-catalog";
 import type { OpenCode, OpenCodeEvent } from "@opencode/sdk";
+import { contextBoundNoteThreshold, createContextBoundNote } from "../hooks/context-bound-note";
 import {
   CONTEXT_FORMULA,
   clampContextPercent,
@@ -534,6 +535,8 @@ export class OpencodeSession implements ProviderSession {
   // Assistant text by message, in part order; the runner keeps the last emit.
   private textByMessage = new Map<string, string[]>();
   private transcript: string[] = [];
+  /** Fed each step's prompt size; steers the one-time context-bound note. */
+  private readonly observeContextBound: (contextTokens: number | undefined) => Promise<void>;
 
   constructor(
     private readonly host: OpenCode.Interface,
@@ -547,6 +550,20 @@ export class OpencodeSession implements ProviderSession {
     this.completionPromise = new Promise<ProviderResult>((resolve) => {
       this.completionResolve = resolve;
     });
+    this.observeContextBound = createContextBoundNote({
+      threshold: contextBoundNoteThreshold(swarm.env ?? process.env),
+      model: () => this.model,
+      canDeliver: () => !this.completed && !this.aborted,
+      // A steer is promoted at the next step boundary mid-work; `resume: false`
+      // leaves an idle session idle. Same route as OpenCode's own Plan reminder.
+      inject: (note) =>
+        host.sessions.synthetic({
+          sessionID: _sessionId,
+          text: note,
+          delivery: "steer",
+          resume: false,
+        }),
+    });
   }
 
   get sessionId(): string {
@@ -685,6 +702,7 @@ export class OpencodeSession implements ProviderSession {
         // Per-step usage drives the dashboard's context gauge.
         const t = ev.data.tokens;
         const contextUsed = t.input + t.cache.read + t.cache.write + t.output;
+        void this.observeContextBound(t.input + t.cache.read + t.cache.write);
         const contextTotal = getContextWindowSize(this.model || "default");
         if (contextTotal > 0 && contextUsed > 0) {
           this.emit({

package/src/providers/pi-mono-adapter.ts

@@ -61,6 +61,7 @@ import { type TSchema, Type } from "typebox";
 import "./pi-codemode-runtime";
 // Registers the reprompt template in the code registry (the runner loads it too).
 import "../commands/templates";
+import { contextBoundNoteThreshold, createContextBoundNote } from "../hooks/context-bound-note";
 import { resolveTemplateAsync } from "../prompts/resolver";
 import { CORE_TOOLS } from "../tools/tool-config";
 import { classifyAwsSdkError } from "../utils/aws-error-classifier";
@@ -907,6 +908,17 @@ function safeLabel(value: unknown): string {
   return typeof value === "string" && /^[A-Za-z0-9_-]{1,32}$/.test(value) ? value : "other";
 }
 
+/** Prompt size of the request behind an assistant message: input + cache read + cache write. */
+function requestContextTokens(message: unknown): number | undefined {
+  const usage = (
+    message as { usage?: { input?: unknown; cacheRead?: unknown; cacheWrite?: unknown } }
+  )?.usage;
+  if (typeof usage?.input !== "number") return undefined;
+  const cacheRead = typeof usage.cacheRead === "number" ? usage.cacheRead : 0;
+  const cacheWrite = typeof usage.cacheWrite === "number" ? usage.cacheWrite : 0;
+  return usage.input + cacheRead + cacheWrite;
+}
+
 function describeAssistantTurn(message: unknown): AssistantTurnShape {
   const msg = (message ?? {}) as {
     content?: unknown;
@@ -1008,6 +1020,14 @@ export class PiMonoSession implements ProviderSession {
   private abortRequested = false;
   /** Removes this session's own models.json once the session ends. */
   private disposeModels: () => Promise<void>;
+  /** Fed each assistant request's prompt size; steers the one-time context-bound note. */
+  private readonly observeContextBound: (contextTokens: number | undefined) => Promise<void>;
+  /**
+   * From a tool-call reply until its turn ends. Pi reads steering after the
+   * turn's tool results; a steer queued later waits for the next reply, and
+   * when that is the final one it starts another turn.
+   */
+  private toolTurnOpen = false;
 
   constructor(
     agentSession: AgentSession,
@@ -1024,6 +1044,12 @@ export class PiMonoSession implements ProviderSession {
     this.logFileHandle = Bun.file(config.logFile).writer();
     this._sessionId = agentSession.sessionId;
     this.sessionStartedAt = Date.now();
+    this.observeContextBound = createContextBoundNote({
+      threshold: contextBoundNoteThreshold(config.env ?? process.env),
+      model: () => this.reportedModel(),
+      canDeliver: () => this.toolTurnOpen && !this.sessionEnded && !this.abortRequested,
+      inject: (note) => this.deliverSteering({ mode: "steer", text: note }),
+    });
 
     // Emit session_init immediately
     const piVersion = readPkgVersion("@earendil-works/pi-coding-agent");
@@ -1098,6 +1124,12 @@ export class PiMonoSession implements ProviderSession {
           }
           // A successful assistant turn means any prior error has recovered.
           this.terminalError = null;
+          // Only on tool-call turns: a steer after the final reply would start
+          // another turn.
+          if (turn.hasToolCall) {
+            this.toolTurnOpen = true;
+            void this.observeContextBound(requestContextTokens(event.message));
+          }
           if (!turn.hasText && !turn.hasToolCall) {
             // Nothing else records these turns: no text and no tool call leaves
             // no trace in session logs. Block types only, never content.
@@ -1152,6 +1184,9 @@ export class PiMonoSession implements ProviderSession {
         }
         break;
       }
+      case "turn_end":
+        this.toolTurnOpen = false;
+        break;
       case "tool_execution_start": {
         const status = (event.args as { status?: unknown } | null)?.status;
         if (

package/src/runtime-providers/docker.ts

@@ -177,7 +177,9 @@ export class DockerRuntimeProvider implements RuntimeProvider {
       try {
         await dockerApi(target, "POST", `/containers/${created.Id}/start`);
       } catch (err) {
-        await dockerApi(target, "DELETE", `/containers/${created.Id}?force=true`).catch(() => {});
+        await dockerApi(target, "DELETE", `/containers/${created.Id}?force=true&v=true`).catch(
+          () => {},
+        );
         throw err;
       }
       return { kind: "docker", externalId: created.Id };
@@ -188,7 +190,9 @@ export class DockerRuntimeProvider implements RuntimeProvider {
 
   async terminate(target: RuntimeTargetConfig, handle: RuntimeHandle): Promise<void> {
     try {
-      await dockerApi(target, "DELETE", `/containers/${handle.externalId}?force=true`);
+      // v=true also removes the container's anonymous volumes (the worker image declares
+      // VOLUME /logs); named volumes are never removed by it.
+      await dockerApi(target, "DELETE", `/containers/${handle.externalId}?force=true&v=true`);
     } catch (err) {
       if (!(err instanceof DockerApiError) || err.statusCode !== 404) throw err;
     }

package/src/scripts-runtime/types/swarm-extension.d.ts

@@ -402,6 +402,36 @@ declare module "swarm-extension" {
     origin: TaskCreateOrigin;
     requestInfo?: RequestInfo;
   }
+  /** A pre.task.create hook blocked a task before it was created. */
+  export interface TaskBlockedEvent {
+    /** The extension that blocked, or whose model/agent rewrite was rejected. */
+    extension: {
+      id: string;
+      name: string;
+    };
+    /** The scrubbed block reason. */
+    reason: string;
+    origin: TaskCreateOrigin;
+    source?: AgentTask["source"];
+    requester: {
+      userId?: string;
+      agentId?: string;
+      slackUserId?: string;
+    };
+    context?: {
+      contextKey?: string;
+      scheduleId?: string;
+      workflowRunId?: string;
+      workflowRunStepId?: string;
+      parentTaskId?: string;
+      vcsRepo?: string;
+      vcsNumber?: number;
+      slackChannelId?: string;
+      slackThreadTs?: string;
+    };
+    /** The original task description, scrubbed and cut to 500 characters. */
+    description: string;
+  }
   export type TaskCreateModify = Partial<
     Pick<
       CreateTaskOptions,
@@ -704,6 +734,11 @@ declare module "swarm-extension" {
       modify: never;
       result: void;
     };
+    "post.task.blocked": {
+      event: TaskBlockedEvent;
+      modify: never;
+      result: void;
+    };
     "post.task.completed": {
       event: TaskCompletedEvent;
       modify: never;

package/src/tests/amp-adapter.test.ts

@@ -8,6 +8,7 @@ import {
   validateProviderCredentials,
 } from "../commands/provider-credentials";
 import { recomputeSessionCost } from "../http/session-cost-recompute";
+import { renderContextBoundNote } from "../prompts/context-bound-note";
 import { createProviderAdapter } from "../providers";
 import {
   AMP_PACKAGE,
@@ -31,6 +32,7 @@ import { getModelAwareCredentialVars } from "../utils/credentials";
 import { resolveHarnessProvider } from "../utils/harness-provider";
 import { clearVolatileSecretsForTesting } from "../utils/secret-scrubber";
 import { ampPricingLookup } from "./amp-pricing-helpers";
+import { holdTemplateRender } from "./fixtures/held-template-render";
 
 const KEY = "sgamp_test_credential_value";
 
@@ -769,6 +771,101 @@ describe("amp session", () => {
   }, 20_000);
 });
 
+describe("amp context-bound note", () => {
+  // Each fake request is 4 input + 200 cache read + 1000 cache write = 1204 tokens.
+  async function toolResults(
+    mode: string,
+    env: Record<string, string>,
+    overrides: Partial<ProviderSessionConfig> = {},
+  ) {
+    const { config } = await fixture(mode, overrides, env);
+    const { events, result } = await runToCompletion(config);
+    const results = events.flatMap((e) => (e.type === "tool_end" ? [e.result] : []));
+    return { results, result };
+  }
+
+  test("queues the note into the first tool result at the threshold, then never again", async () => {
+    const { results, result } = await toolResults("steer-twice", {
+      CONTEXT_BOUND_NOTE_TOKENS: "1204",
+    });
+    expect(results).toEqual([`2\n\n${await renderContextBoundNote(1204)}`, "2"]);
+    // Carried inside the turn: no extra turn replays it.
+    expect(result).toMatchObject({ isError: false, output: "DONE1" });
+    expect(result.cost?.numTurns).toBe(1);
+  });
+
+  test("a pinned model gets the window share; a mode names no model and gets none", async () => {
+    const pin = "anthropic/claude-sonnet-4-6";
+    const pinned = await toolResults(
+      "steer-twice",
+      { CONTEXT_BOUND_NOTE_TOKENS: "1204" },
+      { model: pin },
+    );
+    const note = await renderContextBoundNote(1204, pin);
+    expect(note).toContain("of the 1,000,000-token window)");
+    expect(pinned.results).toEqual([`2\n\n${note}`, "2"]);
+    const mode = await toolResults("steer-twice", { CONTEXT_BOUND_NOTE_TOKENS: "1204" });
+    expect(mode.results[0]).not.toContain("token window");
+  });
+
+  test("no-op below the threshold and when disabled at 0", async () => {
+    for (const threshold of ["1205", "0"]) {
+      const { results } = await toolResults("steer-twice", {
+        CONTEXT_BOUND_NOTE_TOKENS: threshold,
+      });
+      expect(results).toEqual(["2", "2"]);
+    }
+  });
+
+  test("fails open on missing or corrupt request usage", async () => {
+    for (const usage of ["missing", "corrupt"]) {
+      const { results, result } = await toolResults("steer", {
+        CONTEXT_BOUND_NOTE_TOKENS: "1",
+        AMP_TEST_REQUEST_USAGE: usage,
+      });
+      expect(results).toEqual(["2"]);
+      expect(result).toMatchObject({ isError: false, output: "DONE1" });
+    }
+  });
+
+  test("a final reply with no tool call never queues it, so no new turn starts", async () => {
+    const { results, result } = await toolResults("steer-no-tool", {
+      CONTEXT_BOUND_NOTE_TOKENS: "1",
+    });
+    expect(results).toEqual([]);
+    expect(result).toMatchObject({ isError: false, output: "DONE1" });
+    expect(result.cost?.numTurns).toBe(1);
+  });
+
+  test("a note rendered after the last tool result is dropped, not replayed as a new turn", async () => {
+    const held = holdTemplateRender();
+    try {
+      const { config } = await fixture(
+        "steer",
+        {},
+        {
+          CONTEXT_BOUND_NOTE_TOKENS: "1204",
+          AMP_TEST_POST_RESULT_DELAY_MS: "150",
+        },
+      );
+      const session = await new AmpAdapter().createSession(config);
+      const results: unknown[] = [];
+      session.onEvent((event) => {
+        if (event.type !== "tool_end") return;
+        results.push(event.result);
+        // Ready while the final reply is pending.
+        held.release();
+      });
+      const result = await session.waitForCompletion();
+      expect(results).toEqual(["2"]);
+      expect(result).toMatchObject({ isError: false, output: "DONE1" });
+      expect(result.cost?.numTurns).toBe(1);
+    } finally {
+      held.stop();
+    }
+  });
+});
+
 describe("amp live test", () => {
   const env = async (mode: string) => {
     const { config } = await fixture(mode);

package/src/tests/approval-requests.test.ts

@@ -418,7 +418,7 @@ describe("Approval Requests", () => {
       expect(result).toBeNull();
     });
 
-    test("does not resolve a workflow approval after its run and HITL step are cancelled", async () => {
+    test("does not resolve a workflow approval after its run is cancelled", async () => {
       const workflow = await createWorkflow({
         name: `approval-cancel-${crypto.randomUUID()}`,
         definition: { nodes: [] },
@@ -432,11 +432,12 @@ describe("Approval Requests", () => {
         nodeId: "approval",
         nodeType: "human-in-the-loop",
       });
-      await updateWorkflowRun(runId, { status: "cancelled" });
-      await updateWorkflowRunStep(stepId, { status: "cancelled" });
+      // Asked while the run was live; the run was cancelled after, leaving
+      // the request pending (a cancelled step's trigger would close it).
       const approval = await createApprovalRequest(
         makeApprovalData({ workflowRunId: runId, workflowRunStepId: stepId }),
       );
+      await updateWorkflowRun(runId, { status: "cancelled" });
 
       const result = await resolveApprovalRequest(
         approval.id,
@@ -1864,15 +1865,17 @@ describe("Approval Requests", () => {
 
     test("cancel on a waiting run cancels the run, its step, and its task", async () => {
       const { runId, stepId, approvalId } = await makeRun("waiting");
+      // Linked directly: the engine binds a step's task while the step is
+      // still running, and this step is already parked.
       const task = await createTaskExtended("step task", {
         agentId: owner.id,
         source: "mcp",
         workflowRunId: runId,
-        workflowRunStepId: stepId,
       });
-      await getDbClient().run("UPDATE agent_tasks SET status = 'in_progress' WHERE id = ?", [
-        task.id,
-      ]);
+      await getDbClient().run(
+        "UPDATE agent_tasks SET status = 'in_progress', workflowRunStepId = ? WHERE id = ?",
+        [stepId, task.id],
+      );
 
       const res = await post(
         `/api/approval-requests/${approvalId}/cancel`,

package/src/tests/approval-sweeps.test.ts

@@ -223,15 +223,17 @@ describe("approval sweeps", () => {
 
     test("cancels the waiting run, its step, and its linked task", async () => {
       const { runId, stepId } = await makeRun("waiting");
+      // Linked directly: the engine binds a step's task while the step is
+      // still running, and this step is already parked.
       const task = await createTaskExtended("step task", {
         agentId,
         source: "mcp",
         workflowRunId: runId,
-        workflowRunStepId: stepId,
       });
-      await getDbClient().run("UPDATE agent_tasks SET status = 'in_progress' WHERE id = ?", [
-        task.id,
-      ]);
+      await getDbClient().run(
+        "UPDATE agent_tasks SET status = 'in_progress', workflowRunStepId = ? WHERE id = ?",
+        [stepId, task.id],
+      );
       const id = await makeRequest({ ageDays: 8, workflowRunId: runId, workflowRunStepId: stepId });
 
       const result = await autoCancelStaleApprovalRequests();
@@ -300,8 +302,10 @@ describe("approval sweeps", () => {
     });
 
     test("leaves a failed run as it is", async () => {
-      const { runId, stepId } = await makeRun("failed");
+      // The request was asked while the run was live; the run failed after.
+      const { runId, stepId } = await makeRun("waiting");
       const id = await makeRequest({ ageDays: 8, workflowRunId: runId, workflowRunStepId: stepId });
+      await updateWorkflowRun(runId, { status: "failed" });
 
       const result = await autoCancelStaleApprovalRequests();
 
@@ -415,13 +419,15 @@ describe("approval sweeps", () => {
     });
 
     test("times out a request on a completed run", async () => {
-      const { runId, stepId } = await makeRun("completed");
+      // The request was asked while the run was live; the run completed after.
+      const { runId, stepId } = await makeRun("waiting");
       const id = await makeRequest({
         ageDays: 0,
         expiresInMs: -60_000,
         workflowRunId: runId,
         workflowRunStepId: stepId,
       });
+      await updateWorkflowRun(runId, { status: "completed" });
       await timeoutExpiredApprovalRequests();
       expect((await getApprovalRequestById(id))!.status).toBe("timeout");
     });

package/src/tests/base-prompt.test.ts

@@ -490,7 +490,7 @@ describe("getBasePrompt: outputs section", () => {
     expect(result).toContain("## Outputs");
     expect(result).toContain(AGENT_FS_LINE);
     expect(result).toContain(
-      "For a file anyone outside the swarm opens, use an `agent-fs share-create` link; `AGENT_FS_LIVE_URL` links are for signed-in teammates.",
+      `Give people the live app link \`\${AGENT_FS_LIVE_URL}/file/~/<org>/<drive>/<path>\`. Make an \`agent-fs share-create\` link only when the requester asks for one or the reader has no agent-fs login.`,
     );
     expect(result).not.toContain(NO_AGENT_FS_LINE);
   });

package/src/tests/claude-hook-output.test.ts

@@ -82,7 +82,11 @@ afterAll(async () => {
   await rm(projectDir, { recursive: true, force: true });
 });
 
-async function runHook(event: Record<string, unknown>, taskId: string) {
+async function runHook(
+  event: Record<string, unknown>,
+  taskId: string,
+  extraEnv: Record<string, string> = {},
+) {
   const taskFile = join(projectDir, `task-${taskId}.json`);
   await Bun.write(
     taskFile,
@@ -92,6 +96,8 @@ async function runHook(event: Record<string, unknown>, taskId: string) {
     ...process.env,
     CLAUDE_PROJECT_DIR: projectDir,
     TASK_FILE: taskFile,
+    CONTEXT_BOUND_NOTE_TOKENS: undefined,
+    ...extraEnv,
   };
   return runChild(["bun", HOOK_PATH], {
     cwd: projectDir,
@@ -107,6 +113,9 @@ function parseSoleJson(stdout: string): Record<string, unknown> {
   return JSON.parse(trimmed) as Record<string, unknown>;
 }
 
+/** The note is off unless CONTEXT_BOUND_NOTE_TOKENS is set. */
+const noteOn = { CONTEXT_BOUND_NOTE_TOKENS: "200000" };
+
 const bashTouch = {
   tool_name: "Bash",
   tool_input: { command: "touch /tmp/probe" },
@@ -230,4 +239,73 @@ describe("claude hook stdout", () => {
     },
     CHILD_PROCESS_TEST_BUDGET_MS,
   );
+
+  test(
+    "worker context-bound note fires once as PostToolUse additionalContext",
+    async () => {
+      Object.assign(state, { isLead: false, cancelledTaskId: null, shouldBlockPolling: false });
+      const taskId = crypto.randomUUID();
+      await Bun.write(
+        join(projectDir, `task-${taskId}.json.context.json`),
+        JSON.stringify({ contextTokens: 250_000, model: "claude-opus-5-5" }),
+      );
+      const event = { hook_event_name: "PostToolUse", ...bashTouch, tool_response: {} };
+
+      const first = await runHook(event, taskId, noteOn);
+      const out = parseSoleJson(first.stdout) as { hookSpecificOutput: Record<string, string> };
+      expect(out.hookSpecificOutput.hookEventName).toBe("PostToolUse");
+      expect(out.hookSpecificOutput.additionalContext).toStartWith(
+        "Context is 250,000 tokens (25% of the 1,000,000-token window). Keep this task bounded",
+      );
+
+      const second = await runHook(event, taskId, noteOn);
+      expect(second.exitCode).toBe(0);
+      expect(second.stdout.trim()).toBe("");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS * 2,
+  );
+
+  test(
+    "a subagent tool call does not consume the context-bound note",
+    async () => {
+      Object.assign(state, { isLead: false, cancelledTaskId: null, shouldBlockPolling: false });
+      const taskId = crypto.randomUUID();
+      await Bun.write(
+        join(projectDir, `task-${taskId}.json.context.json`),
+        JSON.stringify({ contextTokens: 250_000, model: "made-up-model" }),
+      );
+      const event = { hook_event_name: "PostToolUse", ...bashTouch, tool_response: {} };
+
+      const child = await runHook({ ...event, agent_id: "child" }, taskId, noteOn);
+      expect(child.exitCode).toBe(0);
+      expect(child.stdout.trim()).toBe("");
+
+      // Unknown model: no window share rather than a percent of the 200k fallback.
+      const main = await runHook(event, taskId, noteOn);
+      const out = parseSoleJson(main.stdout) as { hookSpecificOutput: Record<string, string> };
+      expect(out.hookSpecificOutput.additionalContext).toStartWith(
+        "Context is 250,000 tokens. Keep this task bounded",
+      );
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS * 2,
+  );
+
+  test(
+    "the context-bound note is off when CONTEXT_BOUND_NOTE_TOKENS is unset",
+    async () => {
+      Object.assign(state, { isLead: false, cancelledTaskId: null, shouldBlockPolling: false });
+      const taskId = crypto.randomUUID();
+      await Bun.write(
+        join(projectDir, `task-${taskId}.json.context.json`),
+        JSON.stringify({ contextTokens: 900_000, model: "claude-opus-5-5" }),
+      );
+      const result = await runHook(
+        { hook_event_name: "PostToolUse", ...bashTouch, tool_response: {} },
+        taskId,
+      );
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout.trim()).toBe("");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
 });