@rallycry/conveyor-agent 10.13.71 → 11.0.0

package/dist/cli.js

@@ -4,750 +4,77 @@ import {
   isLegacyEntrypointLaunch
 } from "./chunk-R3FDJQL6.js";
 import {
-  AgentConnection,
-  CodespacePortVisibility,
-  DEFAULT_LIFECYCLE_CONFIG,
+  WorkspaceCommandSupervisor,
+  startWorkspaceCommandsAfterConnect,
+  stopWorkspaceCommands
+} from "./chunk-JQVAWRVL.js";
+import {
   DEFAULT_SONNET_MODEL,
-  Lifecycle,
-  PortDiscovery,
   PtyHarness,
+  RUNNER_MODES,
   SessionRunner,
-  applyBootstrapToEnv,
-  awaitGitReady,
   buildProjectTools,
   buildRateLimitEvents,
-  buildSessionPreviewPorts,
   buildSynthesizedCredentials,
   buildUnmeasurableEvent,
   claudeJsonPath,
-  createServiceLogger,
-  fetchBootstrap,
   isPermissionDeniedError,
-  loadConveyorConfig,
-  loadForwardPorts,
+  parsePackExecution,
   parseUsageGauges,
-  readWorkspaceBytes,
   resolvePlaywrightMcpServer,
   resolveSessionStart,
   resolveTuiAdapter,
   resolveTuiKindFromEnv,
   runUsageProbe,
-  sampleKeyUsage,
-  statWorkspacePath,
-  workspacePathExists
-} from "./chunk-7MMECTTJ.js";
+  sampleKeyUsage
+} from "./chunk-PEEGCZAR.js";
+import "./chunk-XORJ6SII.js";
 import {
-  reportBootMilestone
-} from "./chunk-QU53HND5.js";
+  AgentConnection,
+  CodespacePortVisibility,
+  DEFAULT_LIFECYCLE_CONFIG,
+  Lifecycle,
+  PortDiscovery,
+  applyBootstrapToEnv,
+  createServiceLogger,
+  fetchBootstrap,
+  loadConveyorConfig
+} from "./chunk-N4WSUTGV.js";
+import "./chunk-GL2DIQEQ.js";
 import "./chunk-IA45XHOA.js";
-import {
-  getWorkbenchClient
-} from "./chunk-EXQ6AHOY.js";
-import {
-  workbenchEnabled
-} from "./chunk-KMB3BU4S.js";
+import "./chunk-EXQ6AHOY.js";
+import "./chunk-KMB3BU4S.js";
 import {
   inheritedEnv,
   resolvePtySpawn,
-  runSetupCommand,
-  runStartCommand,
-  sessionTempBase,
-  terminateProcessGroup
-} from "./chunk-GJXAAPJ6.js";
+  sessionTempBase
+} from "./chunk-3F4ZZKCA.js";
+import "./chunk-W4LZ7R6Z.js";
 import "./chunk-6Q6LQBWO.js";
 
 // src/cli.ts
 import { readFileSync } from "fs";
-import { join as join4, dirname as dirname2 } from "path";
+import { join as join2, dirname } from "path";
 import { fileURLToPath } from "url";
 
-// src/setup/sidecars.ts
-import net from "net";
-var POSTGRES_TIMEOUT_MS = 12e4;
-var FIREBASE_TIMEOUT_MS = 6e4;
-var FALLBACK_TIMEOUT_MS = 3e4;
-var DEFAULT_SIDECAR_POLL_INTERVAL_MS = 1e3;
-var DEFAULT_PROBE_TIMEOUT_MS = 2e3;
-var POSTGRES_DEFAULT_PORT = 5432;
-var FIREBASE_DEFAULT_PORT = 9099;
-function parseHostPort(value, defaultPort) {
-  const trimmed = value.trim().replace(/^[a-z]+:\/\//i, "");
-  if (!trimmed) return null;
-  const idx = trimmed.lastIndexOf(":");
-  if (idx === -1) {
-    return { host: trimmed, port: defaultPort };
-  }
-  const host = trimmed.slice(0, idx) || "localhost";
-  const port = Number(trimmed.slice(idx + 1));
-  return { host, port: Number.isFinite(port) ? port : defaultPort };
-}
-function resolveSidecarTargets(env = process.env) {
-  const targets = [];
-  const databaseUrl = env.DATABASE_URL;
-  if (databaseUrl) {
-    try {
-      const url = new URL(databaseUrl);
-      const host = url.hostname || "localhost";
-      const port = url.port ? Number(url.port) : POSTGRES_DEFAULT_PORT;
-      if (Number.isFinite(port)) {
-        targets.push({ name: "postgres", host, port, timeoutMs: POSTGRES_TIMEOUT_MS });
-      }
-    } catch {
-    }
-  }
-  const firebaseHost = env.FIREBASE_AUTH_EMULATOR_HOST;
-  if (firebaseHost) {
-    const parsed = parseHostPort(firebaseHost, FIREBASE_DEFAULT_PORT);
-    if (parsed) {
-      targets.push({
-        name: "firebase auth emulator",
-        host: parsed.host,
-        port: parsed.port,
-        timeoutMs: FIREBASE_TIMEOUT_MS
-      });
-    }
-  }
-  return targets;
-}
-function abortError() {
-  const error = new Error("Operation aborted");
-  error.name = "AbortError";
-  return error;
-}
-function throwIfAborted(signal) {
-  if (signal?.aborted) throw abortError();
-}
-function defaultProbe(target, signal) {
-  throwIfAborted(signal);
-  return new Promise((resolve) => {
-    let settled = false;
-    const socket = net.createConnection({ host: target.host, port: target.port });
-    const done = (ok) => {
-      if (settled) return;
-      settled = true;
-      socket.destroy();
-      signal?.removeEventListener("abort", onAbort);
-      resolve(ok);
-    };
-    const onAbort = () => done(false);
-    socket.once("connect", () => done(true));
-    socket.once("error", () => done(false));
-    socket.setTimeout(DEFAULT_PROBE_TIMEOUT_MS, () => done(false));
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-var delay = (ms, signal) => {
-  throwIfAborted(signal);
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(abortError());
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-};
-function raceWithAbort(promise, signal) {
-  if (!signal) return promise;
-  throwIfAborted(signal);
-  return new Promise((resolve, reject) => {
-    const onAbort = () => reject(abortError());
-    signal.addEventListener("abort", onAbort, { once: true });
-    void promise.then(
-      (value) => {
-        signal.removeEventListener("abort", onAbort);
-        resolve(value);
-      },
-      (error) => {
-        signal.removeEventListener("abort", onAbort);
-        reject(error);
-      }
-    );
-  });
-}
-async function waitForTarget(target, opts) {
-  const { onLog, pollIntervalMs, probe, signal } = opts;
-  const timeoutMs = opts.timeoutMs ?? target.timeoutMs ?? FALLBACK_TIMEOUT_MS;
-  const deadline = Date.now() + timeoutMs;
-  onLog(`Waiting for ${target.name} on ${target.host}:${target.port}...`);
-  while (true) {
-    throwIfAborted(signal);
-    if (await raceWithAbort(probe(target, signal), signal)) {
-      onLog(`${target.name} is ready`);
-      return;
-    }
-    if (Date.now() >= deadline) {
-      onLog(
-        `WARNING: ${target.name} not ready after ${Math.round(timeoutMs / 1e3)}s, continuing anyway`
-      );
-      return;
-    }
-    await delay(pollIntervalMs, signal);
-  }
-}
-async function waitForSidecars(opts = {}) {
-  const {
-    env = process.env,
-    onLog = () => {
-    },
-    timeoutMs,
-    pollIntervalMs = DEFAULT_SIDECAR_POLL_INTERVAL_MS,
-    probe = defaultProbe,
-    signal
-  } = opts;
-  throwIfAborted(signal);
-  const targets = resolveSidecarTargets(env);
-  if (targets.length === 0) return;
-  await Promise.all(
-    targets.map(
-      (target) => waitForTarget(target, { onLog, timeoutMs, pollIntervalMs, probe, signal })
-    )
-  );
-}
-
-// src/setup/db-schema-sync.ts
-import { basename, dirname, join } from "path";
-var PRISMA_SCHEMA_CANDIDATES = [
-  "packages/db/prisma/schema.prisma",
-  "prisma/schema.prisma",
-  "apps/api/prisma/schema.prisma",
-  "packages/db/schema.prisma"
-];
-var PRISMA_DB_PUSH = "bunx prisma db push";
-var SCHEMA_SYNC_TIMEOUT_MS = 18e4;
-function depsInclude(rawDeps, dep) {
-  return (rawDeps ?? "").split(",").map((entry) => entry.trim()).includes(dep);
-}
-function isDisabled(env) {
-  const flag = env.CONVEYOR_DB_SCHEMA_SYNC?.trim().toLowerCase();
-  return flag === "0" || flag === "false";
-}
-function packageRootForSchema(schemaPath) {
-  const dir = dirname(schemaPath);
-  return basename(dir) === "prisma" ? dirname(dir) : dir;
-}
-async function resolveSchemaSyncPlan(options) {
-  const { workspaceDir, env } = options;
-  const pathExists = options.pathExists ?? workspacePathExists;
-  if (isDisabled(env)) return null;
-  const override = env.CONVEYOR_DB_SCHEMA_SYNC_COMMAND?.trim();
-  if (override) return { command: override, cwd: workspaceDir, source: "override" };
-  if (!depsInclude(env.CONVEYOR_DEPS, "postgresql")) return null;
-  if (!env.DATABASE_URL?.trim()) return null;
-  for (const relative of PRISMA_SCHEMA_CANDIDATES) {
-    const schemaPath = join(workspaceDir, relative);
-    if (await pathExists(schemaPath)) {
-      return { command: PRISMA_DB_PUSH, cwd: packageRootForSchema(schemaPath), source: "prisma" };
-    }
-  }
-  return null;
-}
-async function runDbSchemaSync(options) {
-  let plan = null;
-  try {
-    plan = await resolveSchemaSyncPlan(options);
-  } catch {
-    return "skipped";
-  }
-  if (!plan) return "skipped";
-  const { onOutput, runCommand } = options;
-  onOutput("stdout", `[db] syncing schema (${plan.source}): ${plan.command}
-`);
-  const controller = new AbortController();
-  const abort = () => controller.abort();
-  options.signal?.addEventListener("abort", abort, { once: true });
-  const timer = setTimeout(abort, options.timeoutMs ?? SCHEMA_SYNC_TIMEOUT_MS);
-  timer.unref();
-  try {
-    await runCommand(plan.command, plan.cwd, onOutput, controller.signal);
-    onOutput("stdout", "[db] schema in sync\n");
-    return "synced";
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    onOutput("stderr", `[db] schema sync failed: ${message}
-`);
-    return "failed";
-  } finally {
-    clearTimeout(timer);
-    options.signal?.removeEventListener("abort", abort);
-  }
-}
-
-// src/setup/deps-sync.ts
-import { join as join2 } from "path";
-var INSTALLER_SCRIPT_CANDIDATES = ["scripts/install-deps.sh"];
-var BUN_INSTALL = "bun install --frozen-lockfile";
-var DEPS_SYNC_TIMEOUT_MS = 9e5;
-var REGISTRY_KEY_ENV = "NPM_CACHE_READER_KEY";
-function isDisabled2(env) {
-  const flag = env.CONVEYOR_DEPS_SYNC?.trim().toLowerCase();
-  return flag === "0" || flag === "false";
-}
-var CKSUM_POLYNOMIAL = 79764919;
-var CKSUM_TABLE = (() => {
-  const table = new Uint32Array(256);
-  for (let index = 0; index < 256; index++) {
-    let value = index << 24;
-    for (let bit = 0; bit < 8; bit++) {
-      value = value & 2147483648 ? (value << 1 ^ CKSUM_POLYNOMIAL) >>> 0 : value << 1 >>> 0;
-    }
-    table[index] = value >>> 0;
-  }
-  return table;
-})();
-function posixCksum(bytes) {
-  let crc = 0;
-  for (const byte of bytes) {
-    crc = (crc << 8 ^ CKSUM_TABLE[(crc >>> 24 ^ byte) & 255]) >>> 0;
-  }
-  for (let length = bytes.length; length > 0; length >>>= 8) {
-    crc = (crc << 8 ^ CKSUM_TABLE[(crc >>> 24 ^ length & 255) & 255]) >>> 0;
-  }
-  return ~crc >>> 0;
-}
-function bunLockFingerprint(bytes) {
-  return `${posixCksum(bytes)}:${bytes.length}`;
-}
-async function defaultDirExists(path) {
-  return (await statWorkspacePath(path)).isDirectory;
-}
-async function readLockDrift(options) {
-  const { workspaceDir, readBytes } = options;
-  let baked;
-  try {
-    const raw = await readBytes(join2(workspaceDir, ".conveyor/prebake-cache.json"));
-    const parsed = JSON.parse(Buffer.from(raw).toString("utf8"));
-    const value = parsed?.bunLockCrc;
-    if (typeof value !== "string" || !value) return null;
-    baked = value;
-  } catch {
-    return null;
-  }
-  try {
-    const actual = bunLockFingerprint(await readBytes(join2(workspaceDir, "bun.lock")));
-    return actual === baked ? null : { baked, actual };
-  } catch {
-    return null;
-  }
-}
-async function resolveDepsSyncPlan(options) {
-  const { workspaceDir, env } = options;
-  const pathExists = options.pathExists ?? workspacePathExists;
-  const dirExists = options.dirExists ?? defaultDirExists;
-  const readBytes = options.readBytes ?? readWorkspaceBytes;
-  if (isDisabled2(env)) return null;
-  if (!await pathExists(join2(workspaceDir, "package.json"))) return null;
-  const override = env.CONVEYOR_DEPS_SYNC_COMMAND?.trim();
-  const resolveCommand = async () => {
-    if (override) return override;
-    for (const relative of INSTALLER_SCRIPT_CANDIDATES) {
-      if (await pathExists(join2(workspaceDir, relative))) return `bash ${relative}`;
-    }
-    return BUN_INSTALL;
-  };
-  if (!await dirExists(join2(workspaceDir, "node_modules"))) {
-    return {
-      command: await resolveCommand(),
-      cwd: workspaceDir,
-      reason: "missing_node_modules",
-      detail: "the pod booted with no node_modules \u2014 the baked dependency tree is absent"
-    };
-  }
-  const drift = await readLockDrift({ workspaceDir, readBytes });
-  if (drift) {
-    return {
-      command: await resolveCommand(),
-      cwd: workspaceDir,
-      reason: "lockfile_drift",
-      detail: `bun.lock changed since the image bake (baked ${drift.baked}, checked out ${drift.actual})`
-    };
-  }
-  return null;
-}
-function describeFailure(plan, error, env) {
-  const cause = error instanceof Error ? error.message : String(error);
-  const parts = [
-    `Dependency install failed (${plan.reason}): ${plan.detail}.`,
-    `Ran \`${plan.command}\` in ${plan.cwd} \u2014 ${cause}.`
-  ];
-  if (!env[REGISTRY_KEY_ENV]?.trim()) {
-    parts.push(
-      `${REGISTRY_KEY_ENV} is not set on this pod, so packages on the private registry cache cannot be fetched \u2014 set it as a project secret.`
-    );
-  }
-  return parts.join(" ");
-}
-async function runDepsSync(options) {
-  let plan = null;
-  try {
-    plan = await resolveDepsSyncPlan(options);
-  } catch {
-    return { outcome: "skipped" };
-  }
-  if (!plan) return { outcome: "skipped" };
-  const { onOutput, runCommand, env } = options;
-  onOutput("stdout", `[deps] ${plan.detail}
-`);
-  onOutput("stdout", `[deps] installing (${plan.reason}): ${plan.command}
-`);
-  const controller = new AbortController();
-  const abort = () => controller.abort();
-  options.signal?.addEventListener("abort", abort, { once: true });
-  const timer = setTimeout(abort, options.timeoutMs ?? DEPS_SYNC_TIMEOUT_MS);
-  timer.unref();
-  try {
-    await runCommand(plan.command, plan.cwd, onOutput, controller.signal);
-    onOutput("stdout", "[deps] dependencies installed\n");
-    return { outcome: "installed" };
-  } catch (error) {
-    const message = describeFailure(plan, error, env);
-    onOutput("stderr", `[deps] ${message}
-`);
-    return { outcome: "failed", message };
-  } finally {
-    clearTimeout(timer);
-    options.signal?.removeEventListener("abort", abort);
-  }
-}
-
-// src/setup/workspace-command-supervisor.ts
-function defaultCommandExecutors() {
-  if (workbenchEnabled()) {
-    const client = getWorkbenchClient();
-    return {
-      runStartCommand: (cmd, cwd, onOutput) => client.runStartCommand(cmd, cwd, onOutput),
-      runShellCommand: (cmd, cwd, onOutput, signal) => client.runSetupCommand(cmd, cwd, onOutput, signal)
-    };
-  }
-  return { runStartCommand, runShellCommand: runSetupCommand };
-}
-var defaultWriteOutput = (stream, data) => {
-  (stream === "stderr" ? process.stderr : process.stdout).write(data);
-};
-function stopWorkspaceCommands(supervisor) {
-  return supervisor?.stop() ?? Promise.resolve();
-}
-async function startWorkspaceCommandsAfterConnect(options) {
-  const connected = await options.connect();
-  if (!connected || options.isShuttingDown()) return null;
-  const supervisor = options.create();
-  supervisor.start();
-  return supervisor;
-}
-var WorkspaceCommandSupervisor = class {
-  abortController = new AbortController();
-  expectedStartCommandStops = /* @__PURE__ */ new WeakSet();
-  config;
-  workspaceDir;
-  connection;
-  env;
-  awaitGitReadyFn;
-  waitForSidecarsFn;
-  runStartCommandFn;
-  syncDbSchemaFn;
-  syncDepsFn;
-  loadForwardPortsFn;
-  writeOutput;
-  terminateStartCommand;
-  reportBootMilestoneFn;
-  startCommandChild = null;
-  liveStartCommandChildren = /* @__PURE__ */ new Set();
-  startCommandTerminations = /* @__PURE__ */ new WeakMap();
-  startCommandEndPromises = /* @__PURE__ */ new WeakMap();
-  resolveStartCommandEnd = /* @__PURE__ */ new WeakMap();
-  backgroundTasks = /* @__PURE__ */ new Set();
-  startCommandQueue = Promise.resolve();
-  shutdownPromise = null;
-  startCommandLaunchRequested = false;
-  started = false;
-  stopped = false;
-  /** Resolved by notifyLoopReady() once the PTY is live — the runner fires it
-   *  on the first harness event of the initial query (or when a prefill
-   *  parks), NOT after the first turn completes, so the app's start command
-   *  isn't held behind a long working turn. Also resolved by stop() if
-   *  shutdown arrives first — either way unblocks the awaiter in
-   *  runSetupAndStart so a supervisor stopped before the loop ever signals
-   *  doesn't hang its background task (and therefore stop()) forever. */
-  resolveLoopReady;
-  loopReady = new Promise((resolve) => {
-    this.resolveLoopReady = resolve;
-  });
-  constructor(options) {
-    this.config = options.config;
-    this.workspaceDir = options.workspaceDir;
-    this.connection = options.connection;
-    this.env = options.env ?? process.env;
-    this.awaitGitReadyFn = options.awaitGitReady ?? ((opts) => awaitGitReady({
-      onLog: opts.onLog,
-      signal: opts.signal
-    }));
-    this.waitForSidecarsFn = options.waitForSidecars ?? ((opts) => waitForSidecars({ onLog: opts.onLog, signal: opts.signal }));
-    const executors = defaultCommandExecutors();
-    this.runStartCommandFn = options.runStartCommand ?? executors.runStartCommand;
-    this.syncDbSchemaFn = options.syncDbSchema ?? ((opts) => runDbSchemaSync({
-      workspaceDir: this.workspaceDir,
-      env: this.env,
-      runCommand: executors.runShellCommand,
-      onOutput: opts.onOutput,
-      signal: opts.signal
-    }));
-    this.syncDepsFn = options.syncDeps ?? ((opts) => runDepsSync({
-      workspaceDir: this.workspaceDir,
-      env: this.env,
-      runCommand: executors.runShellCommand,
-      onOutput: opts.onOutput,
-      signal: opts.signal
-    }));
-    this.loadForwardPortsFn = options.loadForwardPorts ?? loadForwardPorts;
-    this.writeOutput = options.writeOutput ?? defaultWriteOutput;
-    this.terminateStartCommand = options.terminateStartCommand ?? terminateProcessGroup;
-    this.reportBootMilestoneFn = options.reportBootMilestone ?? ((key) => {
-      void reportBootMilestone({ key, env: this.env });
-    });
-  }
-  start() {
-    if (this.started || this.stopped) return;
-    this.started = true;
-    this.connection.onRunStartCommand(() => this.restartStartCommand());
-    if (this.config) {
-      this.trackBackgroundTask(
-        this.runSetupAndStart().catch((error) => this.reportUnexpectedError(error))
-      );
-    }
-  }
-  /** Release the start-command launch — called once the runner's core loop
-   *  (the PTY) is live. Idempotent; resolving an already-settled promise is a
-   *  no-op, so a late/duplicate call (or one after stop() already resolved
-   *  it) is harmless. */
-  notifyLoopReady() {
-    this.resolveLoopReady();
-  }
-  stop() {
-    if (this.shutdownPromise) return this.shutdownPromise;
-    this.stopped = true;
-    this.resolveLoopReady();
-    this.abortController.abort();
-    const backgroundTasks = [...this.backgroundTasks];
-    const termination = this.terminateAllStartCommands();
-    this.shutdownPromise = (async () => {
-      await Promise.allSettled([termination, this.startCommandQueue, ...backgroundTasks]);
-      await this.terminateAllStartCommands();
-    })();
-    return this.shutdownPromise;
-  }
-  async runSetupAndStart() {
-    const gitState = await this.awaitGitReadyFn({
-      onLog: (message) => this.forwardSetupOutput("stdout", `[git] ${message}
-`),
-      signal: this.abortController.signal
-    });
-    if (this.stopped) return;
-    if (gitState === "failed" || gitState === "timeout") {
-      this.connection.sendEvent({
-        type: "setup_error",
-        message: "Workspace not ready \u2014 skipping setup/start"
-      });
-      return;
-    }
-    await this.waitForSidecarsFn({
-      onLog: (message) => this.forwardSetupOutput("stdout", `[sidecars] ${message}
-`),
-      signal: this.abortController.signal
-    });
-    if (this.stopped) return;
-    this.reportBootMilestoneFn("sidecars_ready");
-    await this.loopReady;
-    if (this.stopped) return;
-    await this.syncDeps();
-    if (this.stopped) return;
-    await this.syncDbSchema();
-    if (this.stopped) return;
-    const startCommandRunning = this.config?.startCommand ? await this.ensureStartCommandLaunched(this.config.startCommand) : false;
-    if (this.stopped) return;
-    this.reportBootMilestoneFn("start_command_launched");
-    const forwardPorts = await this.loadForwardPortsFn(this.workspaceDir);
-    if (this.stopped) return;
-    const previewPorts = buildSessionPreviewPorts(forwardPorts);
-    this.connection.sendEvent({
-      type: "setup_complete",
-      startCommandRunning,
-      // Reported separately so the server can tell "nothing to run" apart from
-      // "the dev server failed to launch" — both report startCommandRunning:false.
-      startCommandConfigured: Boolean(this.config?.startCommand),
-      ...previewPorts.length > 0 ? { previewPorts } : {}
-    });
-  }
-  /** Run the dependency sync, forwarding its output as setup output so it lands
-   *  in the card's setup log. A failure is announced with its own cause rather
-   *  than thrown: the start command still launches, but the card now carries
-   *  the reason instead of a generic `start command exited with code 1`. */
-  async syncDeps() {
-    const result = await this.syncDepsFn({
-      onOutput: (stream, data) => this.forwardSetupOutput(stream, data),
-      signal: this.abortController.signal
-    });
-    if (result.outcome !== "failed" || this.stopped) return;
-    this.connection.sendEvent({
-      type: "setup_error",
-      message: result.message ?? "Dependency install failed \u2014 the start command will fail until dependencies are installed (see pod logs)"
-    });
-  }
-  /** Run the schema sync, forwarding its output as setup output so it lands in
-   *  the card's setup log. A failure is announced rather than thrown: it is the
-   *  exact condition that used to render as a silent "Displaying 0 results". */
-  async syncDbSchema() {
-    const outcome = await this.syncDbSchemaFn({
-      onOutput: (stream, data) => this.forwardSetupOutput(stream, data),
-      signal: this.abortController.signal
-    });
-    if (outcome !== "failed" || this.stopped) return;
-    this.connection.sendEvent({
-      type: "setup_error",
-      message: "Database schema sync failed \u2014 the app may error on queries touching recently added columns (see pod logs)"
-    });
-  }
-  restartStartCommand() {
-    if (this.stopped || !this.config?.startCommand) return;
-    this.connection.sendEvent({
-      type: "start_command_output",
-      stream: "stdout",
-      data: "[conveyor-agent] Restarting start command...\n"
-    });
-    void this.enqueueStartCommandReplacement(this.config.startCommand);
-  }
-  async ensureStartCommandLaunched(command) {
-    if (!this.startCommandLaunchRequested) {
-      return this.enqueueStartCommandReplacement(command);
-    }
-    await this.startCommandQueue;
-    return !this.stopped && this.liveStartCommandChildren.size > 0;
-  }
-  enqueueStartCommandReplacement(command) {
-    this.startCommandLaunchRequested = true;
-    const operation = this.startCommandQueue.then(async () => {
-      if (this.stopped) return false;
-      await this.terminateAllStartCommands();
-      if (this.stopped) return false;
-      return this.launchStartCommand(command);
-    });
-    this.startCommandQueue = operation.then(
-      () => void 0,
-      () => void 0
-    );
-    return operation;
-  }
-  launchStartCommand(command) {
-    if (this.stopped) return false;
-    this.connection.sendEvent({ type: "start_command_started" });
-    try {
-      const child = this.runStartCommandFn(command, this.workspaceDir, (stream, data) => {
-        if (this.stopped) return;
-        this.connection.sendEvent({ type: "start_command_output", stream, data });
-        this.writeOutput(stream, data);
-      });
-      this.liveStartCommandChildren.add(child);
-      const ended = new Promise((resolve) => {
-        this.resolveStartCommandEnd.set(child, resolve);
-      });
-      this.startCommandEndPromises.set(child, ended);
-      if (this.stopped) {
-        void this.terminateStartCommandChild(child);
-        return false;
-      }
-      this.startCommandChild = child;
-      child.on("exit", (code, signal) => {
-        if (this.startCommandChild === child) this.startCommandChild = null;
-        this.liveStartCommandChildren.delete(child);
-        this.settleStartCommandEnd(child);
-        if (this.stopped || this.expectedStartCommandStops.has(child)) return;
-        const message = `start command exited${code === null ? "" : ` with code ${code}`}${signal ? ` (signal: ${signal})` : ""}`;
-        this.connection.sendEvent({ type: "start_command_exited", code, signal, message });
-        if (code !== null && code !== 0) {
-          this.connection.sendEvent({
-            type: "start_command_error",
-            message: `start command exited with code ${code}${signal ? ` (signal: ${signal})` : ""}`
-          });
-        }
-      });
-      child.on("error", (error) => {
-        if (child.pid === void 0) {
-          if (this.startCommandChild === child) this.startCommandChild = null;
-          this.liveStartCommandChildren.delete(child);
-          this.settleStartCommandEnd(child);
-          this.startCommandTerminations.delete(child);
-        }
-        if (this.stopped) return;
-        this.connection.sendEvent({ type: "start_command_error", message: error.message });
-      });
-      return true;
-    } catch (error) {
-      if (!this.stopped) {
-        this.connection.sendEvent({
-          type: "start_command_error",
-          message: error instanceof Error ? error.message : String(error)
-        });
-      }
-      return false;
-    }
-  }
-  terminateStartCommandChild(child) {
-    const existing = this.startCommandTerminations.get(child);
-    if (existing) return existing;
-    this.expectedStartCommandStops.add(child);
-    const processTermination = Promise.resolve(this.terminateStartCommand(child));
-    const ended = this.startCommandEndPromises.get(child);
-    const termination = (ended ? Promise.race([processTermination, ended]) : processTermination).then(() => void 0).finally(() => this.startCommandTerminations.delete(child));
-    this.startCommandTerminations.set(child, termination);
-    return termination;
-  }
-  async terminateAllStartCommands() {
-    const live = [...this.liveStartCommandChildren].filter((child) => child.exitCode === null);
-    await Promise.all(live.map((child) => this.terminateStartCommandChild(child)));
-  }
-  settleStartCommandEnd(child) {
-    this.resolveStartCommandEnd.get(child)?.();
-    this.resolveStartCommandEnd.delete(child);
-    this.startCommandEndPromises.delete(child);
-  }
-  trackBackgroundTask(task) {
-    this.backgroundTasks.add(task);
-    void task.finally(() => this.backgroundTasks.delete(task));
-  }
-  forwardSetupOutput(stream, data) {
-    if (this.stopped) return;
-    this.connection.sendEvent({ type: "setup_output", stream, data });
-    this.writeOutput(stream, data);
-  }
-  reportUnexpectedError(error) {
-    if (this.stopped) return;
-    this.connection.sendEvent({
-      type: "setup_error",
-      message: error instanceof Error ? error.message : String(error)
-    });
-  }
-};
-
 // src/utils/session-identity.ts
 async function checkSessionTaskIdentity(params) {
-  const { sessionId, taskId, fetchSessionTaskId, logger: logger6 } = params;
+  const { sessionId, taskId, fetchSessionTaskId, logger: logger7 } = params;
   if (!sessionId || sessionId === taskId) return "skipped";
   let sessionTaskId;
   try {
     sessionTaskId = await fetchSessionTaskId(sessionId);
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    logger6.warn("Could not verify session/task identity \u2014 continuing (defense-in-depth only)", {
+    const message2 = err instanceof Error ? err.message : String(err);
+    logger7.warn("Could not verify session/task identity \u2014 continuing (defense-in-depth only)", {
       sessionId,
       taskId,
-      error: message
+      error: message2
     });
     return "error";
   }
   if (sessionTaskId !== taskId) {
-    logger6.warn(
+    logger7.warn(
       "!!! CONVEYOR_SESSION_ID is bound to a different task than CONVEYOR_TASK_ID \u2014 server-side guards should still block mutations, but this indicates a misconfiguration or replayed token.",
       { sessionId, envTaskId: taskId, sessionTaskId }
     );
@@ -863,10 +190,10 @@ var ProjectSessionRunner = class {
       await this.waitUntilStopped();
       this._finalState = "finished";
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`[conveyor-agent] Project runner failed: ${message}
+      const message2 = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`[conveyor-agent] Project runner failed: ${message2}
 `);
-      this.connection.sendEvent({ type: "error", message });
+      this.connection.sendEvent({ type: "error", message: message2 });
       this._finalState = "error";
     } finally {
       this.shutdown();
@@ -929,7 +256,7 @@ var ProjectSessionRunner = class {
 
 // src/usage/multi-key-probe.ts
 import { mkdtemp, writeFile, copyFile, rm } from "fs/promises";
-import { join as join3 } from "path";
+import { join } from "path";
 var logger = createServiceLogger("multi-key-probe");
 function gaugesToSamples(stdout) {
   const { sessionUsage, weeklyUsage, sessionResetsAt, weeklyResetsAt, gauges } = parseUsageGauges(stdout);
@@ -957,12 +284,12 @@ function gaugesToSamples(stdout) {
 async function isolatedProbe(token, now) {
   let dir = null;
   try {
-    dir = await mkdtemp(join3(sessionTempBase(), "conveyor-usage-"));
-    await writeFile(join3(dir, ".credentials.json"), buildSynthesizedCredentials(token, now), {
+    dir = await mkdtemp(join(sessionTempBase(), "conveyor-usage-"));
+    await writeFile(join(dir, ".credentials.json"), buildSynthesizedCredentials(token, now), {
       encoding: "utf8",
       mode: 384
     });
-    await copyFile(claudeJsonPath(), join3(dir, ".claude.json")).catch(() => {
+    await copyFile(claudeJsonPath(), join(dir, ".claude.json")).catch(() => {
     });
     return await runUsageProbe({ env: { ...process.env, CLAUDE_CONFIG_DIR: dir } });
   } catch (error) {
@@ -1138,10 +465,10 @@ var AdhocSessionRunner = class {
       await this.runInteractiveTui();
       this._finalState = "finished";
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`[conveyor-agent] Ad-hoc runner failed: ${message}
+      const message2 = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`[conveyor-agent] Ad-hoc runner failed: ${message2}
 `);
-      this.connection.sendEvent({ type: "error", message });
+      this.connection.sendEvent({ type: "error", message: message2 });
       this._finalState = "error";
     } finally {
       await this.shutdown();
@@ -1295,6 +622,10 @@ var ReviewChildSupervisor = class {
   spawnFn;
   child = null;
   childSessionId = null;
+  /** The review session this supervisor currently hosts, if any. */
+  get activeSessionId() {
+    return this.childSessionId;
+  }
   /** Spawn (or replace) the review child for a `session:spawnReview` push. */
   async spawn(data) {
     logger2.info("Spawning same-pod review child", {
@@ -1328,10 +659,10 @@ var ReviewChildSupervisor = class {
     this.childSessionId = data.sessionId;
     const spawnedAt = Date.now();
     let reported = false;
-    const reportOnce = (message) => {
+    const reportOnce = (message2) => {
       if (reported) return;
       reported = true;
-      this.connection.reportReviewSpawnFailure(data.sessionId, message);
+      this.connection.reportReviewSpawnFailure(data.sessionId, message2);
     };
     child.stdout?.on("data", (chunk) => {
       process.stdout.write(`[review-child] ${chunk.toString()}`);
@@ -1451,6 +782,10 @@ var SessionChildSupervisor = class {
   get size() {
     return this.children.size;
   }
+  /** Sessions this supervisor currently hosts. Drives the shutdown deferral. */
+  get activeSessionIds() {
+    return [...this.children.keys()];
+  }
   /** Spawn a TUI/shell child for a `session:spawnTui` push. Additive per session. */
   async spawn(data) {
     logger3.info("Spawning same-pod session child", {
@@ -1481,10 +816,10 @@ var SessionChildSupervisor = class {
     this.children.set(data.sessionId, child);
     const spawnedAt = Date.now();
     let reported = false;
-    const reportOnce = (message) => {
+    const reportOnce = (message2) => {
       if (reported) return;
       reported = true;
-      this.connection.reportSessionSpawnFailure(data.sessionId, message);
+      this.connection.reportSessionSpawnFailure(data.sessionId, message2);
     };
     const prefix = `[${data.mode}-child]`;
     child.stdout?.on("data", (chunk) => {
@@ -1611,10 +946,10 @@ var ShellSessionRunner = class {
       await this.runShell();
       this._finalState = "finished";
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`[conveyor-agent] Shell runner failed: ${message}
+      const message2 = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`[conveyor-agent] Shell runner failed: ${message2}
 `);
-      this.connection.sendEvent({ type: "error", message });
+      this.connection.sendEvent({ type: "error", message: message2 });
       this._finalState = "error";
     } finally {
       this.shutdown();
@@ -1708,14 +1043,158 @@ function createSpawnedChildRunner(inputs) {
   );
 }
 
+// src/runner/builder-child.ts
+import { spawn as nodeSpawn3 } from "child_process";
+var logger5 = createServiceLogger("BuilderChild");
+function buildBuilderChildEnv(baseEnv, data) {
+  const env = { ...baseEnv };
+  env.CONVEYOR_TASK_TOKEN = data.sessionJwt;
+  env.CONVEYOR_SESSION_ID = data.sessionId;
+  env.CONVEYOR_MODE = data.mode ?? "task";
+  env.CONVEYOR_WORKBENCH_TOKEN ??= baseEnv.POD_BOOTSTRAP_TOKEN;
+  delete env.POD_BOOTSTRAP_TOKEN;
+  delete env.CONVEYOR_BOOTSTRAP_TOKEN;
+  delete env.CONVEYOR_START_COMMAND;
+  delete env.CONVEYOR_GIT_READY;
+  delete env.CONVEYOR_GIT_READY_MARKER;
+  delete env.CONVEYOR_AGENT_MODE;
+  delete env.CONVEYOR_IS_AUTO;
+  return env;
+}
+var BuilderChildSupervisor = class {
+  constructor(connection, workspaceDir, spawnFn = nodeSpawn3) {
+    this.connection = connection;
+    this.workspaceDir = workspaceDir;
+    this.spawnFn = spawnFn;
+  }
+  connection;
+  workspaceDir;
+  spawnFn;
+  child = null;
+  childSessionId = null;
+  /** The build session this supervisor currently hosts, if any. */
+  get activeSessionId() {
+    return this.childSessionId;
+  }
+  /** Spawn (or replace) the builder child for a `session:spawnBuilder` push. */
+  async spawn(data) {
+    if (this.childSessionId === data.sessionId && this.child && this.child.exitCode === null) {
+      logger5.info("Builder child already running for this session; ignoring re-push", {
+        buildSessionId: data.sessionId
+      });
+      return;
+    }
+    logger5.info("Spawning same-pod builder child", {
+      buildSessionId: data.sessionId,
+      branch: data.branch ?? void 0,
+      agentName: data.agentName ?? void 0
+    });
+    await this.stopCurrent("superseded by new builder spawn");
+    const cliPath = process.argv[1];
+    if (!cliPath) {
+      this.connection.reportBuilderSpawnFailure(data.sessionId, "cannot resolve CLI entry path");
+      return;
+    }
+    let child;
+    try {
+      child = this.spawnFn(process.execPath, [cliPath], {
+        cwd: this.workspaceDir,
+        env: buildBuilderChildEnv(process.env, data),
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (err) {
+      this.connection.reportBuilderSpawnFailure(
+        data.sessionId,
+        err instanceof Error ? err.message : String(err)
+      );
+      return;
+    }
+    this.child = child;
+    this.childSessionId = data.sessionId;
+    this.watchForEarlyExit(child, data.sessionId);
+  }
+  /**
+   * A non-zero exit inside the grace window is a spawn failure, not a finished
+   * build — the child never got far enough to connect. Reporting it lets the
+   * server End the orphaned session and fall back to a cold boot instead of
+   * leaving the card parked with a Builder tab that never appears.
+   */
+  watchForEarlyExit(child, sessionId) {
+    const spawnedAt = Date.now();
+    child.on("exit", (code) => {
+      if (this.childSessionId === sessionId) {
+        this.child = null;
+        this.childSessionId = null;
+      }
+      const early = Date.now() - spawnedAt < SPAWN_FAILURE_GRACE_MS;
+      if (early && code !== 0) {
+        logger5.warn("Builder child exited inside the spawn grace window", { sessionId, code });
+        this.connection.reportBuilderSpawnFailure(sessionId, `child exited with code ${code}`);
+      }
+    });
+  }
+  /** SIGTERM the current child, escalating to SIGKILL after KILL_WAIT_MS. */
+  async stopCurrent(reason) {
+    const child = this.child;
+    if (!child || child.exitCode !== null) {
+      this.child = null;
+      this.childSessionId = null;
+      return;
+    }
+    logger5.info("Stopping builder child", { reason, buildSessionId: this.childSessionId });
+    child.kill("SIGTERM");
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        if (child.exitCode === null) child.kill("SIGKILL");
+        resolve();
+      }, KILL_WAIT_MS);
+      child.once("exit", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+    this.child = null;
+    this.childSessionId = null;
+  }
+};
+
 // src/runner/host-modes.ts
 function hostsSpawnedChildren(mode) {
-  return mode === "task" || mode === "pack";
+  return mode === "task" || mode === "plan" || mode === "pack";
+}
+
+// src/runner/wire-spawn-children.ts
+var message = (err) => err instanceof Error ? err.message : String(err);
+function wireSpawnChildren(mode, connection, supervisors, logger7) {
+  if (hostsSpawnedChildren(mode)) {
+    connection.onSpawnReview((data) => {
+      void supervisors.review.spawn(data).catch((err) => {
+        logger7.error("Review child spawn threw", { error: message(err) });
+        connection.reportReviewSpawnFailure(data.sessionId, message(err));
+      });
+    });
+  }
+  if (mode === "plan") {
+    connection.onSpawnBuilder((data) => {
+      void supervisors.builder.spawn(data).catch((err) => {
+        logger7.error("Builder child spawn threw", { error: message(err) });
+        connection.reportBuilderSpawnFailure(data.sessionId, message(err));
+      });
+    });
+  }
+  if (hostsSpawnedChildren(mode)) {
+    connection.onSpawnTui((data) => {
+      void supervisors.session.spawn(data).catch((err) => {
+        logger7.error("Session child spawn threw", { error: message(err) });
+        connection.reportSessionSpawnFailure(data.sessionId, message(err));
+      });
+    });
+  }
 }
 
 // src/cli.ts
 if (process.argv[2] === "boot") {
-  const { runBoot } = await import("./boot-PKHZUDAC.js");
+  const { runBoot } = await import("./boot-PKQ2I66D.js");
   process.exit(await runBoot(process.argv.slice(3)));
 }
 if (isLegacyEntrypointLaunch(process.env)) {
@@ -1724,13 +1203,13 @@ if (isLegacyEntrypointLaunch(process.env)) {
   process.exit(1);
 }
 if (process.argv.includes("--version")) {
-  const __dirname = dirname2(fileURLToPath(import.meta.url));
-  const pkgPath = join4(__dirname, "..", "package.json");
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const pkgPath = join2(__dirname, "..", "package.json");
   const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
   process.stdout.write(pkg.version + "\n");
   process.exit(0);
 }
-var logger5 = createServiceLogger("CLI");
+var logger6 = createServiceLogger("CLI");
 var exitContext = {};
 var exitLogged = false;
 var shuttingDown = false;
@@ -1745,12 +1224,12 @@ function logAgentExit(reason, opts) {
     uptimeSec: process.uptime(),
     identity: exitContext
   });
-  logger5[exitLogLevel(reason)]("agent_exit", payload);
+  logger6[exitLogLevel(reason)]("agent_exit", payload);
 }
 async function bootstrapFromCodespace(apiUrl, instanceName) {
   const bootstrapToken = process.env.CONVEYOR_BOOTSTRAP_TOKEN;
   const apiUrlFromEnv = Boolean(process.env.CONVEYOR_API_URL);
-  logger5.info("Bootstrapping from codespace", {
+  logger6.info("Bootstrapping from codespace", {
     codespace: instanceName,
     apiUrl,
     apiUrlFromEnv,
@@ -1762,7 +1241,7 @@ async function bootstrapFromCodespace(apiUrl, instanceName) {
     bootstrapToken
   });
   if (!result.ok) {
-    logger5.error("Bootstrap failed after retries", {
+    logger6.error("Bootstrap failed after retries", {
       reason: result.reason,
       attempts: result.attempts,
       status: result.status,
@@ -1775,20 +1254,20 @@ async function bootstrapFromCodespace(apiUrl, instanceName) {
     process.exit(1);
   }
   applyBootstrapToEnv(result.config);
-  logger5.info("Bootstrap complete", {
+  logger6.info("Bootstrap complete", {
     taskId: result.config.taskId,
     attempts: result.attempts
   });
 }
 function isExpectedAbortError(error) {
-  const message = error.message || "";
-  const hasAbortMessage = /operation aborted/i.test(message) || /abort/i.test(message);
+  const message2 = error.message || "";
+  const hasAbortMessage = /operation aborted/i.test(message2) || /abort/i.test(message2);
   const hasAbortCode = !("code" in error) || error.code === void 0 || error.code === "ABORT_ERR";
   return hasAbortMessage && hasAbortCode;
 }
 function exitOnPermissionDenial(err) {
   if (!isPermissionDeniedError(err)) return false;
-  logger5.error("Not authorized for this project \u2014 parking instead of crash-looping", {
+  logger6.error("Not authorized for this project \u2014 parking instead of crash-looping", {
     error: err.message
   });
   logAgentExit("unauthorized", { exitCode: 0 });
@@ -1797,48 +1276,48 @@ function exitOnPermissionDenial(err) {
 process.on("uncaughtException", (err) => {
   if (err.code === "EPIPE") return;
   if (shuttingDown && isExpectedAbortError(err)) {
-    logger5.info("Ignored expected abort after shutdown", { error: err.message, code: err.code });
+    logger6.info("Ignored expected abort after shutdown", { error: err.message, code: err.code });
     return;
   }
   if (exitOnPermissionDenial(err)) return;
-  logger5.error("Uncaught exception", { error: err.message, code: err.code });
+  logger6.error("Uncaught exception", { error: err.message, code: err.code });
   logAgentExit("uncaught_exception", { exitCode: 1 });
   process.exit(1);
 });
 process.on("unhandledRejection", (reason) => {
   const err = reason instanceof Error ? reason : new Error(String(reason));
   if (shuttingDown && isExpectedAbortError(err)) {
-    logger5.info("Ignored expected abort rejection after shutdown", { error: err.message });
+    logger6.info("Ignored expected abort rejection after shutdown", { error: err.message });
     return;
   }
   if (exitOnPermissionDenial(err)) return;
-  logger5.error("Unhandled rejection", { error: err.message });
+  logger6.error("Unhandled rejection", { error: err.message });
   logAgentExit("unhandled_rejection", { exitCode: 1 });
   process.exit(1);
 });
 if (process.env.CONVEYOR_MODE === "workbench") {
-  const { startWorkbenchServer } = await import("./server-CC7KUJOK.js");
+  const { startWorkbenchServer } = await import("./server-7XH7RYUX.js");
   const { oomWatchdogOptionsFromEnv } = await import("./oom-watchdog-PAC5OJJG.js");
   const { DEFAULT_WORKBENCH_PORT } = await import("./protocol-QBCYO4GI.js");
   const port = Number(process.env.CONVEYOR_WORKBENCH_PORT) || DEFAULT_WORKBENCH_PORT;
   const token = process.env.CONVEYOR_WORKBENCH_TOKEN ?? process.env.POD_BOOTSTRAP_TOKEN ?? "";
   if (!token) {
-    logger5.error("workbench mode requires POD_BOOTSTRAP_TOKEN (or CONVEYOR_WORKBENCH_TOKEN)");
+    logger6.error("workbench mode requires POD_BOOTSTRAP_TOKEN (or CONVEYOR_WORKBENCH_TOKEN)");
     process.exit(1);
   }
-  const pkgDir = dirname2(fileURLToPath(import.meta.url));
-  const pkg = JSON.parse(readFileSync(join4(pkgDir, "..", "package.json"), "utf-8"));
+  const pkgDir = dirname(fileURLToPath(import.meta.url));
+  const pkg = JSON.parse(readFileSync(join2(pkgDir, "..", "package.json"), "utf-8"));
   const handle = await startWorkbenchServer({
     port,
     token,
     version: pkg.version ?? "unknown",
     oomWatchdog: oomWatchdogOptionsFromEnv({
-      info: (m) => logger5.info(m),
-      warn: (m) => logger5.warn(m),
-      error: (m) => logger5.error(m)
+      info: (m) => logger6.info(m),
+      warn: (m) => logger6.warn(m),
+      error: (m) => logger6.error(m)
     })
   });
-  logger5.info(`Workbench launcher listening on 127.0.0.1:${handle.port}`);
+  logger6.info(`Workbench launcher listening on 127.0.0.1:${handle.port}`);
   process.on("SIGTERM", () => process.exit(0));
   await new Promise(() => {
   });
@@ -1848,7 +1327,7 @@ var conveyorApiUrl = process.env.CONVEYOR_API_URL || DEFAULT_CONVEYOR_API_URL;
 var INSTANCE_NAME = process.env.CODESPACE_NAME || process.env.CLAUDESPACE_NAME;
 if (INSTANCE_NAME && !process.env.CONVEYOR_TASK_TOKEN) {
   if (!conveyorApiUrl) {
-    logger5.error("Could not resolve CONVEYOR_API_URL for codespace bootstrap");
+    logger6.error("Could not resolve CONVEYOR_API_URL for codespace bootstrap");
     process.exit(1);
   }
   await bootstrapFromCodespace(conveyorApiUrl, INSTANCE_NAME);
@@ -1866,7 +1345,7 @@ exitContext.runnerMode = CONVEYOR_MODE;
 exitContext.sessionId = process.env.CONVEYOR_SESSION_ID ?? CONVEYOR_TASK_ID;
 var projectIdentity = resolveProjectRunnerIdentity(process.env);
 if (!CONVEYOR_TASK_ID && projectIdentity && CONVEYOR_MODE === "adhoc") {
-  logger5.info("Starting ad-hoc agent", { projectId: projectIdentity.projectId });
+  logger6.info("Starting ad-hoc agent", { projectId: projectIdentity.projectId });
   const adhocRunner = new AdhocSessionRunner(
     {
       connection: {
@@ -1885,7 +1364,7 @@ if (!CONVEYOR_TASK_ID && projectIdentity && CONVEYOR_MODE === "adhoc") {
     },
     {
       onEvent: (event) => {
-        logger5.info("Ad-hoc runner event", { eventType: event.type });
+        logger6.info("Ad-hoc runner event", { eventType: event.type });
       }
     }
   );
@@ -1909,7 +1388,7 @@ if (!CONVEYOR_TASK_ID && projectIdentity && CONVEYOR_MODE === "adhoc") {
   process.exit(adhocError ? 1 : 0);
 }
 if (!CONVEYOR_TASK_ID && projectIdentity) {
-  logger5.info("Starting project agent", { projectId: projectIdentity.projectId });
+  logger6.info("Starting project agent", { projectId: projectIdentity.projectId });
   const projectRunner = new ProjectSessionRunner(
     {
       connection: {
@@ -1924,7 +1403,7 @@ if (!CONVEYOR_TASK_ID && projectIdentity) {
     },
     {
       onEvent: (event) => {
-        logger5.info("Project runner event", { eventType: event.type });
+        logger6.info("Project runner event", { eventType: event.type });
       }
     }
   );
@@ -1948,31 +1427,46 @@ if (!CONVEYOR_TASK_ID && projectIdentity) {
   process.exit(projectError ? 1 : 0);
 }
 if (!CONVEYOR_TASK_TOKEN || !CONVEYOR_TASK_ID) {
-  logger5.error("Missing required environment variables");
-  logger5.error("  CONVEYOR_TASK_TOKEN - JWT token for task authentication");
-  logger5.error("  CONVEYOR_TASK_ID - ID of the task to execute");
-  logger5.error("");
-  logger5.error("CONVEYOR_API_URL is provided via codespace secret or bootstrap.");
-  logger5.error("");
-  logger5.error("Optional:");
-  logger5.error("  CONVEYOR_MODE - Runner mode: 'task' (default), 'pack', or 'pm'");
-  logger5.error("  CONVEYOR_WORKSPACE - Working directory (defaults to cwd)");
-  logger5.error(
+  logger6.error("Missing required environment variables");
+  logger6.error("  CONVEYOR_TASK_TOKEN - JWT token for task authentication");
+  logger6.error("  CONVEYOR_TASK_ID - ID of the task to execute");
+  logger6.error("");
+  logger6.error("CONVEYOR_API_URL is provided via codespace secret or bootstrap.");
+  logger6.error("");
+  logger6.error("Optional:");
+  logger6.error("  CONVEYOR_MODE - Runner mode: 'task' (default), 'pack', or 'pm'");
+  logger6.error("  CONVEYOR_WORKSPACE - Working directory (defaults to cwd)");
+  logger6.error(
     "  Project pods instead require CONVEYOR_PROJECT_ID + CONVEYOR_SESSION_ID + CONVEYOR_MODE=pm"
   );
   process.exit(1);
 }
-if (CONVEYOR_MODE !== "task" && CONVEYOR_MODE !== "pm" && CONVEYOR_MODE !== "code-review" && CONVEYOR_MODE !== "adhoc" && CONVEYOR_MODE !== "pack" && CONVEYOR_MODE !== "shell") {
-  logger5.error("Invalid CONVEYOR_MODE", {
-    mode: CONVEYOR_MODE,
-    expected: ["task", "pm", "code-review", "adhoc", "pack", "shell"]
-  });
+if (!RUNNER_MODES.includes(CONVEYOR_MODE)) {
+  logger6.error("Invalid CONVEYOR_MODE", { mode: CONVEYOR_MODE, expected: RUNNER_MODES });
   process.exit(1);
 }
+if (CONVEYOR_MODE === "serving") {
+  const { runServingSession } = await import("./serve-boot-YPAUKENG.js");
+  exitContext.runnerMode = "serving";
+  exitContext.sessionId = process.env.CONVEYOR_SESSION_ID ?? exitContext.sessionId;
+  const outcome = await runServingSession({
+    apiUrl: conveyorApiUrl ?? "",
+    taskToken: CONVEYOR_TASK_TOKEN,
+    sessionId: process.env.CONVEYOR_SESSION_ID,
+    taskId: CONVEYOR_TASK_ID,
+    workspaceDir: CONVEYOR_WORKSPACE,
+    // BRANCH is the bundle gitPlan's branch (boot/bundle.ts buildChildEnv):
+    // the branch the preview must check out and serve.
+    branch: process.env.BRANCH,
+    onSignal: () => void (shuttingDown = true)
+  });
+  logAgentExit(outcome.reason, { exitCode: outcome.exitCode, finalState: outcome.finalState });
+  process.exit(outcome.exitCode);
+}
 if (CONVEYOR_MODE === "shell" || CONVEYOR_MODE === "adhoc") {
   const spawnedSessionId = process.env.CONVEYOR_SESSION_ID;
   if (!spawnedSessionId) {
-    logger5.error("Spawned child requires CONVEYOR_SESSION_ID", { mode: CONVEYOR_MODE });
+    logger6.error("Spawned child requires CONVEYOR_SESSION_ID", { mode: CONVEYOR_MODE });
     process.exit(1);
   }
   exitContext.sessionId = spawnedSessionId;
@@ -1985,7 +1479,7 @@ if (CONVEYOR_MODE === "shell" || CONVEYOR_MODE === "adhoc") {
     workspaceDir: CONVEYOR_WORKSPACE,
     projectId: process.env.CONVEYOR_PROJECT_ID ?? ""
   });
-  logger5.info("Starting spawned session child", {
+  logger6.info("Starting spawned session child", {
     mode: CONVEYOR_MODE,
     sessionId: spawnedSessionId
   });
@@ -2005,7 +1499,7 @@ if (CONVEYOR_MODE === "shell" || CONVEYOR_MODE === "adhoc") {
   });
   process.exit(childError ? 1 : 0);
 }
-logger5.info("Starting agent", { mode: CONVEYOR_MODE });
+logger6.info("Starting agent", { mode: CONVEYOR_MODE });
 var lifecycleOverrides = process.env.CLAUDESPACE_NAME ? { idleTimeoutMs: 60 * 60 * 1e3 } : { gitFlushIntervalMs: 0 };
 var runner = new SessionRunner(
   {
@@ -2018,6 +1512,10 @@ var runner = new SessionRunner(
       runnerMode: CONVEYOR_MODE
     },
     runnerMode: CONVEYOR_MODE,
+    // Only read when the mode is "pack". Parsed rather than cast so an unset or
+    // malformed value falls back to single-pod instead of selecting a third,
+    // non-existent behavior.
+    packExecution: parsePackExecution(process.env.CONVEYOR_PACK_EXECUTION),
     isAuto: CONVEYOR_IS_AUTO,
     workspaceDir: CONVEYOR_WORKSPACE,
     agentMode: CONVEYOR_AGENT_MODE,
@@ -2025,29 +1523,51 @@ var runner = new SessionRunner(
   },
   {
     onStatusChange: (status) => {
-      logger5.info("Status changed", { status });
+      logger6.info("Status changed", { status });
     },
     onEvent: (event) => {
       const detail = event.message ?? event.content ?? event.summary ?? "";
       if (detail) {
-        logger5.info(detail, { eventType: event.type });
+        logger6.info(detail, { eventType: event.type });
       }
     }
   }
 );
 var reviewChildren = new ReviewChildSupervisor(runner.connection, CONVEYOR_WORKSPACE);
 var sessionChildren = new SessionChildSupervisor(runner.connection, CONVEYOR_WORKSPACE);
+var builderChildren = new BuilderChildSupervisor(runner.connection, CONVEYOR_WORKSPACE);
+runner.setLiveChildSources([
+  {
+    kind: "builder",
+    activeSessionIds: () => {
+      const id = builderChildren.activeSessionId;
+      return id ? [id] : [];
+    }
+  },
+  {
+    kind: "review",
+    activeSessionIds: () => {
+      const id = reviewChildren.activeSessionId;
+      return id ? [id] : [];
+    }
+  },
+  { kind: "tui", activeSessionIds: () => sessionChildren.activeSessionIds }
+]);
 var shutdownSignal;
 var workspaceCommandSupervisor = null;
 var shutdownCompletion = null;
 var shutdownAgent = (signal) => {
   shuttingDown = true;
-  logger5.info(`Received ${signal}, flushing git and stopping agent`);
+  logger6.info(`Received ${signal}, flushing git and stopping agent`);
   const commandShutdown = stopWorkspaceCommands(workspaceCommandSupervisor);
   shutdownSignal = signal;
   shutdownCompletion ??= (async () => {
     try {
-      await Promise.all([reviewChildren.stopAll(), sessionChildren.stopAll()]);
+      await Promise.all([
+        reviewChildren.stopAll(),
+        sessionChildren.stopAll(),
+        builderChildren.stopCurrent("agent shutdown")
+      ]);
     } catch {
     }
     try {
@@ -2059,8 +1579,8 @@ var shutdownAgent = (signal) => {
   })();
   void shutdownCompletion;
   setTimeout(() => {
-    logger5.warn(`Forcing exit after ${signal} timeout`);
-    logger5.warn(
+    logger6.warn(`Forcing exit after ${signal} timeout`);
+    logger6.warn(
       "agent_exit",
       buildAgentExitLog({
         reason: "force_timeout",
@@ -2086,7 +1606,7 @@ workspaceCommandSupervisor = await startWorkspaceCommandsAfterConnect({
   })
 });
 if (!workspaceCommandSupervisor) {
-  logger5.info("Agent stopped before workspace commands were started");
+  logger6.info("Agent stopped before workspace commands were started");
   if (shutdownCompletion) await shutdownCompletion;
   logAgentExit(shutdownSignal ? "signal" : "clean", {
     exitCode: 0,
@@ -2106,34 +1626,14 @@ void checkSessionTaskIdentity({
     });
     return ctx.id;
   },
-  logger: logger5
+  logger: logger6
 });
-if (hostsSpawnedChildren(CONVEYOR_MODE)) {
-  runner.connection.onSpawnReview((data) => {
-    void reviewChildren.spawn(data).catch((err) => {
-      logger5.error("Review child spawn threw", {
-        error: err instanceof Error ? err.message : String(err)
-      });
-      runner.connection.reportReviewSpawnFailure(
-        data.sessionId,
-        err instanceof Error ? err.message : String(err)
-      );
-    });
-  });
-}
-if (hostsSpawnedChildren(CONVEYOR_MODE)) {
-  runner.connection.onSpawnTui((data) => {
-    void sessionChildren.spawn(data).catch((err) => {
-      logger5.error("Session child spawn threw", {
-        error: err instanceof Error ? err.message : String(err)
-      });
-      runner.connection.reportSessionSpawnFailure(
-        data.sessionId,
-        err instanceof Error ? err.message : String(err)
-      );
-    });
-  });
-}
+wireSpawnChildren(
+  CONVEYOR_MODE,
+  runner.connection,
+  { review: reviewChildren, builder: builderChildren, session: sessionChildren },
+  logger6
+);
 runner.run().then(async () => {
   await stopWorkspaceCommands(workspaceCommandSupervisor);
   const errored = runner.finalState === "error";
@@ -2147,7 +1647,7 @@ runner.run().then(async () => {
 }).catch(async (error) => {
   await stopWorkspaceCommands(workspaceCommandSupervisor);
   const msg = error instanceof Error ? error.message : String(error);
-  logger5.error("Agent runner failed", { error: msg });
+  logger6.error("Agent runner failed", { error: msg });
   logAgentExit("error", { exitCode: 1, finalState: runner.finalState ?? void 0 });
   process.exit(1);
 });