@zgeoff/atc 3.3.1 → 3.4.1

package/src/test-utils/build-stub-fleet-caller.ts

@@ -0,0 +1,60 @@
+import type { FleetCaller, FleetFeature } from '../mcp/types';
+import type { DaemonFeature } from '../protocol/daemon-features';
+import { DAEMON_FEATURES } from '../protocol/daemon-features';
+
+/**
+ * One request a stub fleet caller received: the method and each further
+ * argument the sender passed, with an argument left undefined left out.
+ */
+interface StubFleetRequest {
+  readonly m: string;
+  readonly p?: Readonly<Record<string, unknown>>;
+  readonly required?: readonly DaemonFeature[];
+  readonly principal?: string;
+}
+
+type StubFleetAnswer = (
+  request: StubFleetRequest,
+) => Readonly<Record<string, unknown>> | Promise<Readonly<Record<string, unknown>>>;
+
+interface StubFleetCallerConfig {
+  // Gives the reply to one request: a value, a promise, or a throw, which
+  // the caller turns into a rejection, as a daemon refusal arrives.
+  readonly answer?: StubFleetAnswer;
+
+  // The features the caller reports its daemon announced.
+  readonly features?: readonly FleetFeature[];
+}
+
+/**
+ * A fleet caller that stands in for a daemon connection: it records every
+ * request in `requests`, in the order sent, and replies through the
+ * config's `answer`, by default an empty record. It reports the config's
+ * `features`, by default every feature a current daemon announces, and it
+ * checks no request's required features against them, so a test that needs
+ * that refusal uses a real connection.
+ */
+export function buildStubFleetCaller(
+  config: StubFleetCallerConfig = {},
+): FleetCaller & { readonly requests: readonly StubFleetRequest[] } {
+  const answer: StubFleetAnswer = config.answer ?? (() => ({}));
+  const features: readonly FleetFeature[] = config.features ?? DAEMON_FEATURES;
+  const requests: StubFleetRequest[] = [];
+
+  return {
+    requests,
+    sendRequest: (m, p, required, principal) => {
+      const request: StubFleetRequest = {
+        m,
+        ...(p === undefined ? {} : { p }),
+        ...(required === undefined ? {} : { required }),
+        ...(principal === undefined ? {} : { principal }),
+      };
+
+      requests.push(request);
+
+      return Promise.try(() => answer(request));
+    },
+    readFeatures: () => Promise.resolve(new Set(features)),
+  };
+}

package/src/test-utils/build-stub-forking-gh.ts

@@ -0,0 +1,10 @@
+/**
+ * The script of a stand-in `gh` that starts a child of its own and waits on
+ * it, as a gh extension might. It writes its own process ID, which is also
+ * the ID of the process group it leads when started detached, and its
+ * child's ID to `pidsFile`, one per line, moving the file into place so it
+ * appears whole. The child runs until it is killed.
+ */
+export function buildStubForkingGH(pidsFile: string): string {
+  return `#!/bin/sh\nsh -c 'sleep 30' &\nprintf '%s\\n%s\\n' $$ $! > '${pidsFile}.tmp'\nmv '${pidsFile}.tmp' '${pidsFile}'\nwait\n`;
+}

package/src/test-utils/build-stub-gh.ts

@@ -0,0 +1,50 @@
+interface StubGHReply {
+  readonly stdout?: string;
+  readonly stderr?: string;
+  readonly exitCode?: number;
+}
+
+interface StubGHOptions {
+  // What each command prints and exits with, keyed by its first argument,
+  // such as `repo` or `config`; `hang` waits until the command is killed.
+  // A command without a reply prints nothing and exits 0.
+  readonly replies: Readonly<Record<string, StubGHReply | 'hang'>>;
+
+  // A file each run appends its arguments to, as one line.
+  readonly argvFile?: string;
+}
+
+/**
+ * The script of a stand-in `gh` that answers each command with the reply
+ * the test gave for its first argument: the stdout and stderr verbatim,
+ * then the exit code, 0 when unset. A `hang` reply waits until it is
+ * killed, as a gh that never answers does.
+ */
+export function buildStubGH(options: StubGHOptions): string {
+  const record =
+    options.argvFile === undefined
+      ? ''
+      : `printf '%s\\n' "$*" >> ${toShellLiteral(options.argvFile)}\n`;
+
+  const cases = Object.entries(options.replies)
+    .map(([command, reply]) => `  ${toShellLiteral(command)}) ${renderReply(reply)} ;;\n`)
+    .join('');
+
+  return `#!/bin/sh\n${record}case "$1" in\n${cases}esac\n`;
+}
+
+function toShellLiteral(value: string): string {
+  return `'${value.replaceAll("'", String.raw`'\''`)}'`;
+}
+
+function renderReply(reply: StubGHReply | 'hang'): string {
+  if (reply === 'hang') {
+    return 'exec sleep 30';
+  }
+
+  return [
+    `printf '%s' ${toShellLiteral(reply.stdout ?? '')}`,
+    `printf '%s' ${toShellLiteral(reply.stderr ?? '')} >&2`,
+    `exit ${reply.exitCode ?? 0}`,
+  ].join('; ');
+}

package/src/test-utils/build-stub-handoff-daemon.ts

@@ -0,0 +1,11 @@
+/**
+ * The script of a stand-in `atc` whose daemon hands its socket to a
+ * replacement: it moves the socket listening at `listeningPath` to
+ * `$HOME/atc-daemon.sock`, where a client of a daemon on that home dials,
+ * and exits 0. Write it with `createStubBin`.
+ */
+export function buildStubHandoffDaemon(listeningPath: string): string {
+  return `#!/usr/bin/env bash
+mv '${listeningPath}' "$HOME/atc-daemon.sock"
+`;
+}

package/src/test-utils/build-stub-harness-relay.ts

@@ -0,0 +1,50 @@
+import type { HarnessRelay } from '../daemon/execution-provider';
+
+/**
+ * A harness relay held in memory, as a provider hands one to the daemon for
+ * a guest's connection. `sendLine` delivers a value as one JSON line from
+ * the guest to every line listener, `written` holds every line written back
+ * to the guest, parsed, in order, and `isClosed` turns true once the relay
+ * is closed. A write settles at once, as a relay with room does. `hangUp`
+ * runs every close listener, as a guest that hangs up does; closing the
+ * relay from the daemon's end runs none.
+ */
+export function buildStubHarnessRelay() {
+  const lineListeners: ((line: string) => void)[] = [];
+  const closeListeners: (() => void)[] = [];
+  const written: unknown[] = [];
+  let closed = false;
+
+  const relay: HarnessRelay = {
+    onLine: (listener) => {
+      lineListeners.push(listener);
+    },
+    onClose: (listener) => {
+      closeListeners.push(listener);
+    },
+    writeLine: (line) => {
+      written.push(JSON.parse(line));
+
+      return Promise.resolve();
+    },
+    close: () => {
+      closed = true;
+    },
+  };
+
+  return {
+    relay,
+    written,
+    isClosed: () => closed,
+    sendLine: (value: Readonly<Record<string, unknown>>) => {
+      for (const listener of lineListeners) {
+        listener(JSON.stringify(value));
+      }
+    },
+    hangUp: () => {
+      for (const listener of closeListeners) {
+        listener();
+      }
+    },
+  };
+}

package/src/test-utils/build-stub-headless-runner.ts

@@ -0,0 +1,60 @@
+import type {
+  HeadlessRunEvents,
+  HeadlessRunRequest,
+  HeadlessRunner,
+} from '../agents/agent-adapter';
+
+interface StubHeadlessRun {
+  readonly request: HeadlessRunRequest;
+
+  // The events the daemon listens on, which the test calls to play the run.
+  readonly events: HeadlessRunEvents;
+  stopped: boolean;
+}
+
+interface StubHeadlessRunner {
+  readonly runner: HeadlessRunner;
+
+  // Every run the daemon started, in order, and whether it stopped it.
+  readonly runs: readonly StubHeadlessRun[];
+
+  // Resolves with the run at the index, counting from zero, once the
+  // daemon starts it.
+  readonly waitForRun: (index: number) => Promise<StubHeadlessRun>;
+}
+
+/**
+ * A headless runner for daemon tests that starts no process. Each run the
+ * daemon starts is recorded in `runs`, in order, and does nothing until
+ * the test plays it by calling the run's events: output, a finished turn,
+ * or a turn that needs the user. A stop marks the run stopped and plays
+ * nothing, as a killed turn reports nothing more.
+ */
+export function buildStubHeadlessRunner(): StubHeadlessRunner {
+  const runs: StubHeadlessRun[] = [];
+  const started: PromiseWithResolvers<StubHeadlessRun>[] = [];
+
+  const getStarted = (index: number) => {
+    started[index] ??= Promise.withResolvers<StubHeadlessRun>();
+
+    return started[index];
+  };
+
+  return {
+    runner: (request, events) => {
+      const run: StubHeadlessRun = { request, events, stopped: false };
+
+      runs.push(run);
+
+      getStarted(runs.length - 1).resolve(run);
+
+      return {
+        stop: () => {
+          run.stopped = true;
+        },
+      };
+    },
+    runs,
+    waitForRun: (index) => getStarted(index).promise,
+  };
+}

package/src/test-utils/build-stub-held-gh.ts

@@ -0,0 +1,19 @@
+/**
+ * The script of a stand-in `gh` whose repository listing waits for the
+ * test. `gh config …` prints `https`. Any other command touches
+ * `$HOME/gh-held` and waits while `$HOME/gh-hold` exists, then prints one
+ * repository, `me/dots`, in the JSON shape `gh repo list` prints.
+ */
+export function buildStubHeldGH(): string {
+  return `#!/bin/sh
+case "$1" in
+  config) echo https ;;
+  *)
+    if [ -f "$HOME/gh-hold" ]; then
+      touch "$HOME/gh-held"
+      while [ -f "$HOME/gh-hold" ]; do sleep 0.05; done
+    fi
+    echo '[{"nameWithOwner":"me/dots","description":"dotfiles","isPrivate":false,"url":"https://github.com/me/dots","sshUrl":"git@github.com:me/dots.git"}]' ;;
+esac
+`;
+}

package/src/test-utils/build-stub-held-inbox-source.ts

@@ -0,0 +1,36 @@
+import type { TapClient } from '../daemon/daemon-context';
+import type { InboxSource } from '../daemon/drain-inbox';
+import { TapRegistry } from '../daemon/tap-registry';
+import type { AgentSessionID } from '../shared/agent-session-id';
+import type { SessionID } from '../shared/session-id';
+import type { MessageRecord } from '../store/message-record';
+
+/**
+ * An inbox source over a real, empty tap registry, standing in for the
+ * daemon's store. It holds every session under the given agent session id,
+ * and its pending-message read waits until the test answers it: `reading`
+ * settles once a read starts, `read` answers the read with the given
+ * messages whatever owner it asked for.
+ */
+export function buildStubHeldInboxSource(agentSessionID: AgentSessionID) {
+  const pending = Promise.withResolvers<MessageRecord[]>();
+  const reading = Promise.withResolvers<void>();
+
+  const source: InboxSource = {
+    taps: new TapRegistry<TapClient>(),
+    findLinkedOwner: (sessionID: SessionID) => ({ atcID: sessionID, agentSessionID }),
+    collectPendingMessages: () => {
+      reading.resolve();
+
+      return pending.promise;
+    },
+  };
+
+  return {
+    source,
+    reading: reading.promise,
+    read: (records: readonly MessageRecord[]) => {
+      pending.resolve([...records]);
+    },
+  };
+}

package/src/test-utils/build-stub-held-provider.ts

@@ -0,0 +1,58 @@
+import type { ExecutionProvider, HarnessSpec, HostRequest } from '../daemon/execution-provider';
+import { LocalPTYProvider } from '../daemon/local-pty-provider';
+
+/**
+ * An execution provider that runs on this machine as the local
+ * pseudo-terminal provider does, except that each host preparation holds
+ * until the test calls `release` with that host, so a test can act while a
+ * harness is still starting. `prepares` holds the host of each preparation
+ * in the order it began, and `harnesses` each harness spec in the order it
+ * started.
+ */
+export function buildStubHeldProvider() {
+  const local = new LocalPTYProvider();
+  const gates = new Map<string, PromiseWithResolvers<void>>();
+
+  const prepares: string[] = [];
+  const harnesses: HarnessSpec[] = [];
+
+  const getGate = (host: string): PromiseWithResolvers<void> => {
+    const gate = gates.get(host) ?? Promise.withResolvers<void>();
+
+    gates.set(host, gate);
+
+    return gate;
+  };
+
+  const provider: ExecutionProvider = {
+    kind: local.kind,
+    remote: local.remote,
+    capabilities: local.capabilities,
+    prepareHost: async (request: HostRequest) => {
+      prepares.push(request.host);
+
+      await getGate(request.host).promise;
+
+      await local.prepareHost();
+    },
+    spawnHarness: (spec) => {
+      harnesses.push(spec);
+
+      return local.spawnHarness(spec);
+    },
+    transferArchive: local.transferArchive,
+    runCommand: local.runCommand,
+    suspendHost: local.suspendHost,
+    destroyHost: local.destroyHost,
+    dispose: local.dispose,
+  };
+
+  return {
+    provider,
+    prepares,
+    harnesses,
+    release: (host: string) => {
+      getGate(host).resolve();
+    },
+  };
+}

package/src/test-utils/build-stub-held-zoxide.ts

@@ -0,0 +1,13 @@
+/**
+ * The script of a stand-in `zoxide` that lists no directories, and waits
+ * for the test first: while `$HOME/zoxide-hold` exists, it touches
+ * `$HOME/zoxide-held` and waits for the file to go.
+ */
+export function buildStubHeldZoxide(): string {
+  return `#!/bin/sh
+if [ -f "$HOME/zoxide-hold" ]; then
+  touch "$HOME/zoxide-held"
+  while [ -f "$HOME/zoxide-hold" ]; do sleep 0.05; done
+fi
+`;
+}

package/src/test-utils/build-stub-host-hold.ts

@@ -0,0 +1,31 @@
+/**
+ * A host operation a test can hold open, for a host preparation or sleep
+ * that must stay in flight while the test changes something. Unarmed, the
+ * operation resolves at once, so the arrange steps before the hold pass
+ * through. Once armed, the next call resolves `entered` and every call
+ * waits until `release`; after the release, calls resolve at once again.
+ */
+export function buildStubHostHold() {
+  const entered = Promise.withResolvers<void>();
+  const released = Promise.withResolvers<void>();
+  let armed = false;
+
+  return {
+    hold: (): Promise<void> => {
+      if (!armed) {
+        return Promise.resolve();
+      }
+
+      entered.resolve();
+
+      return released.promise;
+    },
+    arm: () => {
+      armed = true;
+    },
+    entered: entered.promise,
+    release: () => {
+      released.resolve();
+    },
+  };
+}

package/src/test-utils/build-stub-host-provider.ts

@@ -0,0 +1,26 @@
+import type { ExecutionProvider } from '../daemon/execution-provider';
+import { LocalPTYProvider } from '../daemon/local-pty-provider';
+
+/**
+ * An execution provider of kind `imp-like` whose hosts can be put to sleep
+ * and destroyed, as an imp's can, while every harness, archive transfer, and
+ * command runs on this machine through the local terminal provider.
+ * Readying, suspending, and destroying a host each do nothing and settle at
+ * once.
+ */
+export function buildStubHostProvider(): ExecutionProvider {
+  const local = new LocalPTYProvider();
+
+  return {
+    kind: 'imp-like',
+    remote: false,
+    capabilities: { ...local.capabilities, suspend: true, destroy: true },
+    prepareHost: () => Promise.resolve(),
+    spawnHarness: local.spawnHarness,
+    transferArchive: local.transferArchive,
+    runCommand: local.runCommand,
+    suspendHost: () => Promise.resolve(),
+    destroyHost: () => Promise.resolve(),
+    dispose: local.dispose,
+  };
+}

package/src/test-utils/build-stub-log.ts

@@ -0,0 +1,15 @@
+/**
+ * A log sink that records each line it is given, in order, in place of the
+ * daemon's stderr log: `log` takes a line and `lines` holds every line taken
+ * so far.
+ */
+export function buildStubLog() {
+  const lines: string[] = [];
+
+  return {
+    lines,
+    log: (line: string): void => {
+      lines.push(line);
+    },
+  };
+}

package/src/test-utils/build-stub-mcp-claude.ts

@@ -0,0 +1,26 @@
+import { join } from 'node:path';
+
+const CLI_PATH = join(import.meta.dir, '..', 'cli.ts');
+
+/**
+ * The script of a stand-in `claude` for the stdio MCP suites. It appends its
+ * pid to `$HOME/stub-pids`, prints `FAKE_CLAUDE_UP args: ` and its
+ * arguments, and ends by echoing its input back until that input closes.
+ * Unless the file
+ * `$HOME/fake-claude-hold-start` exists, it first reports `SessionStart`
+ * through the real reporter with session id `fake-1` and transcript
+ * `$HOME/fake-transcript.jsonl`, and when `$HOME/fake-claude-note` exists it
+ * files that file's text as a report labelled `decision`.
+ */
+export function buildStubMCPClaude(): string {
+  const cli = `"${process.execPath}" "${CLI_PATH}"`;
+
+  return `#!/usr/bin/env bash
+echo $$ >> "$HOME/stub-pids"
+echo "FAKE_CLAUDE_UP args: $@"
+if [ -f "$HOME/fake-claude-hold-start" ]; then exec cat; fi
+printf '{"hook_event_name":"SessionStart","session_id":"fake-1","transcript_path":"'"$HOME"'/fake-transcript.jsonl"}' | ${cli} hook-report
+if [ -f "$HOME/fake-claude-note" ]; then ${cli} report note --label decision < "$HOME/fake-claude-note"; fi
+exec cat
+`;
+}

package/src/test-utils/build-stub-mcp-grok.ts

@@ -0,0 +1,19 @@
+import { join } from 'node:path';
+
+const CLI_PATH = join(import.meta.dir, '..', 'cli.ts');
+
+/**
+ * The script of a stand-in `grok` for the stdio MCP suites. It appends its
+ * pid to `$HOME/stub-pids`, prints `FAKE_GROK_UP args: ` and its arguments,
+ * reports `session_start` through the real reporter with session id
+ * `fake-grok-1` and its working directory, then echoes its input back until
+ * that input closes.
+ */
+export function buildStubMCPGrok(): string {
+  return `#!/usr/bin/env bash
+echo $$ >> "$HOME/stub-pids"
+echo "FAKE_GROK_UP args: $@"
+printf '{"hookEventName":"session_start","sessionId":"fake-grok-1","cwd":"%s"}' "$PWD" | "${process.execPath}" "${CLI_PATH}" hook-report
+exec cat
+`;
+}

package/src/test-utils/build-stub-mcp-stdio-server.ts

@@ -0,0 +1,20 @@
+/**
+ * The script of a stand-in `atc mcp` server on stdio that answers each line
+ * it reads with the next of `replies`, printed as given, whether JSON or
+ * not, and reads stdin without answering once the replies run out. It
+ * exits without a reply when stdin ends before a line arrives. Before
+ * it reads anything, it records its pid in the file at its own path with
+ * `.pid` appended, moving the file into place so it appears whole.
+ */
+export function buildStubMCPStdioServer(replies: readonly string[]): string {
+  const answers = replies
+    .map((reply) => `read -r _ || exit 0\nprintf '%s\\n' ${toShellLiteral(reply)}\n`)
+    .join('');
+
+  return `#!/usr/bin/env bash\necho $$ > "$0.pid.tmp"\nmv "$0.pid.tmp" "$0.pid"\n${answers}exec cat > /dev/null\n`;
+}
+
+// Quotes a value for the shell as one word, whatever it holds.
+function toShellLiteral(value: string): string {
+  return `'${value.replaceAll("'", String.raw`'\''`)}'`;
+}

package/src/test-utils/build-stub-peer-socket.ts

@@ -0,0 +1,81 @@
+/**
+ * A peer socket for tests that drive a daemon connection without a socket:
+ * while accepting, it takes every byte at once, as a peer with room does,
+ * and keeps what the daemon wrote; while not, it takes none and returns 0,
+ * as a socket whose kernel buffer is full does, so backpressure is a switch
+ * instead of a buffer race. It starts accepting, and `setAccepting` flips
+ * it. It ignores the end of the connection. `collectFrames`
+ * parses each complete line written so far as one protocol frame, in order.
+ * `waitForAnswer` resolves with the frame answering the request id once the
+ * daemon has written it, that id left out, so two answers compare whole.
+ */
+export function buildStubPeerSocket() {
+  const decoder = new TextDecoder();
+  const waiters = new Map<number, PromiseWithResolvers<Record<string, unknown>>>();
+
+  let accepting = true;
+  let written = '';
+
+  const collectFrames = (): Record<string, unknown>[] =>
+    written
+      .split('\n')
+      .slice(0, -1)
+      .map((line): Record<string, unknown> => toFrame(JSON.parse(line)));
+
+  return {
+    socket: {
+      // oxlint-disable-next-line prefer-readonly-parameter-types -- a readonly view cannot satisfy the writer contract; the stub never mutates chunks
+      write: (data: Uint8Array): number => {
+        if (!accepting) {
+          return 0;
+        }
+
+        written += decoder.decode(data, { stream: true });
+
+        // Frames are parsed only for a pending wait, so a stray line fails
+        // the read that looks at it rather than the daemon's write.
+        for (const frame of waiters.size === 0 ? [] : collectFrames()) {
+          const id = frame['id'];
+          const waiter = typeof id === 'number' ? waiters.get(id) : undefined;
+
+          if (waiter !== undefined) {
+            waiters.delete(Number(id));
+            waiter.resolve(buildAnswer(frame));
+          }
+        }
+
+        return data.length;
+      },
+      end: () => {},
+    },
+    setAccepting: (value: boolean) => {
+      accepting = value;
+    },
+    collectFrames,
+    waitForAnswer: (id: number): Promise<Record<string, unknown>> => {
+      const found = collectFrames().find((frame) => frame['id'] === id);
+
+      if (found !== undefined) {
+        return Promise.resolve(buildAnswer(found));
+      }
+
+      const waiter = Promise.withResolvers<Record<string, unknown>>();
+
+      waiters.set(id, waiter);
+
+      return waiter.promise;
+    },
+  };
+}
+
+function toFrame(value: unknown): Record<string, unknown> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    throw new TypeError(`a protocol frame is a JSON object, not ${JSON.stringify(value)}`);
+  }
+
+  return Object.fromEntries(Object.entries(value));
+}
+
+function buildAnswer(frame: Readonly<Record<string, unknown>>): Record<string, unknown> {
+  return Object.fromEntries(Object.entries(frame).filter(([key]) => key !== 'id'));
+}

package/src/test-utils/build-stub-picker-host.ts

@@ -0,0 +1,36 @@
+import type { DroppedAnswer } from '../client/spawn-picker';
+
+/**
+ * The client a spawn picker runs inside, reduced to the reactions it
+ * records: `counts` holds how many times the picker asked for a status
+ * draw, returned to the screen the flow came from, attached a session, and
+ * dropped an answer, and `dropped` holds the kind of each dropped answer
+ * in order. `countReactions` returns the sum of every count, for a daemon
+ * stand-in that waits on the picker to react. Attaching resolves at once.
+ */
+export function buildStubPickerHost() {
+  const counts = { renders: 0, exits: 0, attached: 0, drops: 0 };
+  const dropped: DroppedAnswer[] = [];
+
+  return {
+    counts,
+    dropped,
+    countReactions: (): number => counts.renders + counts.exits + counts.attached + counts.drops,
+    scheduleStatus: (): void => {
+      counts.renders += 1;
+    },
+    toBase: (): void => {
+      counts.exits += 1;
+    },
+    attach: (): Promise<void> => {
+      counts.attached += 1;
+
+      return Promise.resolve();
+    },
+    onDropAnswer: (kind: DroppedAnswer): void => {
+      counts.drops += 1;
+
+      dropped.push(kind);
+    },
+  };
+}

package/src/test-utils/build-stub-proxied-agent-adapter.ts

@@ -0,0 +1,29 @@
+import type { AgentAdapter } from '../agents/agent-adapter';
+import { buildStubBrokeredAgentAdapter } from './build-stub-brokered-agent-adapter';
+
+interface StubProxiedAgentAdapterConfig {
+  readonly id: string;
+}
+
+/**
+ * An agent adapter for daemon tests that takes the GLM credential from
+ * impd's broker, as the brokered stand-in does, and that always starts
+ * behind the broker, but whose guest spawn plans a proxy variable of its
+ * own: `https_proxy` set to http://proxy.example:3128, beside a `sleep 30`.
+ * Every other member is the brokered stand-in's.
+ */
+export function buildStubProxiedAgentAdapter(config: StubProxiedAgentAdapterConfig): AgentAdapter {
+  return {
+    ...buildStubBrokeredAgentAdapter({
+      id: config.id,
+      brokerRequired: true,
+      isSelected: () => true,
+    }),
+    planGuestSpawn: () => ({
+      bin: 'sleep',
+      args: ['30'],
+      files: {},
+      env: { https_proxy: 'http://proxy.example:3128' },
+    }),
+  };
+}