@rallycry/conveyor-agent 10.7.3 → 10.7.5

package/dist/cli.js

@@ -5,6 +5,7 @@ import {
   DEFAULT_LIFECYCLE_CONFIG,
   DEFAULT_SONNET_MODEL,
   Lifecycle,
+  PortDiscovery,
   PtyHarness,
   SessionRunner,
   TUI_KINDS,
@@ -25,8 +26,9 @@ import {
   resolveSessionStart,
   runSetupCommand,
   runStartCommand,
-  sampleKeyUsage
-} from "./chunk-UOHROQ6A.js";
+  sampleKeyUsage,
+  terminateProcessGroup
+} from "./chunk-CWTQXS34.js";
 import "./chunk-7TQO4ZF4.js";
 
 // src/cli.ts
@@ -45,14 +47,18 @@ var DEFAULT_POLL_INTERVAL_MS = 1e3;
 var DEFAULT_PROBE_TIMEOUT_MS = 2e3;
 var POSTGRES_DEFAULT_PORT = 5432;
 var FIREBASE_DEFAULT_PORT = 9099;
-async function startLazySidecars(env, onLog) {
+async function startLazySidecars(env, onLog, signal) {
+  throwIfAborted(signal);
   const markerPath = env.CONVEYOR_SIDECAR_START_FILE;
   if (!markerPath) return;
   try {
     await mkdir(dirname(markerPath), { recursive: true });
+    throwIfAborted(signal);
     await writeFile(markerPath, "start\n", "utf8");
+    throwIfAborted(signal);
     onLog("Started lazy sidecars");
   } catch (err) {
+    if (signal?.aborted) throw abortError();
     const message = err instanceof Error ? err.message : String(err);
     onLog(`WARNING: failed to start lazy sidecars: ${message}`);
   }
@@ -96,7 +102,16 @@ function resolveSidecarTargets(env = process.env) {
   }
   return targets;
 }
-function defaultProbe(target) {
+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 });
@@ -104,23 +119,56 @@ function defaultProbe(target) {
       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);
+      }
+    );
   });
 }
-var delay = (ms) => new Promise((resolve) => {
-  setTimeout(resolve, ms);
-});
 async function waitForTarget(target, opts) {
-  const { onLog, pollIntervalMs, probe } = 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) {
-    if (await probe(target)) {
+    throwIfAborted(signal);
+    if (await raceWithAbort(probe(target, signal), signal)) {
       onLog(`${target.name} is ready`);
       return;
     }
@@ -130,7 +178,7 @@ async function waitForTarget(target, opts) {
       );
       return;
     }
-    await delay(pollIntervalMs);
+    await delay(pollIntervalMs, signal);
   }
 }
 async function waitForSidecars(opts = {}) {
@@ -141,18 +189,282 @@ async function waitForSidecars(opts = {}) {
     timeoutMs,
     pollIntervalMs = DEFAULT_POLL_INTERVAL_MS,
     probe = defaultProbe,
-    startLazy = true
+    startLazy = true,
+    signal
   } = opts;
   if (startLazy) {
-    await startLazySidecars(env, onLog);
+    await startLazySidecars(env, onLog, signal);
   }
+  throwIfAborted(signal);
   const targets = resolveSidecarTargets(env);
   if (targets.length === 0) return;
   await Promise.all(
-    targets.map((target) => waitForTarget(target, { onLog, timeoutMs, pollIntervalMs, probe }))
+    targets.map(
+      (target) => waitForTarget(target, { onLog, timeoutMs, pollIntervalMs, probe, signal })
+    )
   );
 }
 
+// src/setup/workspace-command-supervisor.ts
+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;
+  startLazySidecarsFn;
+  waitForSidecarsFn;
+  runSetupCommandFn;
+  runStartCommandFn;
+  loadForwardPortsFn;
+  writeOutput;
+  terminateStartCommand;
+  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;
+  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.startLazySidecarsFn = options.startLazySidecars ?? ((env, onLog, signal) => startLazySidecars(env, onLog, signal));
+    this.waitForSidecarsFn = options.waitForSidecars ?? ((opts) => waitForSidecars({ onLog: opts.onLog, startLazy: opts.startLazy, signal: opts.signal }));
+    this.runSetupCommandFn = options.runSetupCommand ?? ((command, cwd, onOutput, signal) => runSetupCommand(command, cwd, onOutput, signal));
+    this.runStartCommandFn = options.runStartCommand ?? runStartCommand;
+    this.loadForwardPortsFn = options.loadForwardPorts ?? loadForwardPorts;
+    this.writeOutput = options.writeOutput ?? defaultWriteOutput;
+    this.terminateStartCommand = options.terminateStartCommand ?? terminateProcessGroup;
+  }
+  start() {
+    if (this.started || this.stopped) return;
+    this.started = true;
+    this.connection.onRunStartCommand(() => this.restartStartCommand());
+    this.trackBackgroundTask(
+      this.startLazySidecarsFn(
+        this.env,
+        (message) => this.forwardSetupOutput("stdout", `[sidecars] ${message}
+`),
+        this.abortController.signal
+      ).catch((error) => this.reportUnexpectedError(error))
+    );
+    if (this.config) {
+      this.trackBackgroundTask(
+        this.runSetupAndStart().catch((error) => this.reportUnexpectedError(error))
+      );
+    }
+  }
+  stop() {
+    if (this.shutdownPromise) return this.shutdownPromise;
+    this.stopped = true;
+    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}
+`),
+      startLazy: false,
+      signal: this.abortController.signal
+    });
+    if (this.stopped) return;
+    await this.runConfiguredSetup();
+    if (this.stopped) return;
+    const startCommandRunning = this.config?.startCommand ? await this.ensureStartCommandLaunched(this.config.startCommand) : false;
+    if (this.stopped) return;
+    const forwardPorts = await this.loadForwardPortsFn(this.workspaceDir);
+    if (this.stopped) return;
+    const previewPorts = buildSessionPreviewPorts(forwardPorts);
+    this.connection.sendEvent({
+      type: "setup_complete",
+      startCommandRunning,
+      ...previewPorts.length > 0 ? { previewPorts } : {}
+    });
+  }
+  async runConfiguredSetup() {
+    const command = this.config?.setupCommand;
+    if (!command) return;
+    try {
+      await this.runSetupCommandFn(
+        command,
+        this.workspaceDir,
+        (stream, data) => this.forwardSetupOutput(stream, data),
+        this.abortController.signal
+      );
+    } catch (error) {
+      if (this.stopped) return;
+      this.connection.sendEvent({
+        type: "setup_error",
+        message: error instanceof Error ? error.message : "Setup command failed"
+      });
+    }
+  }
+  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;
@@ -553,6 +865,8 @@ var AdhocSessionRunner = class {
   connection;
   lifecycle;
   harness;
+  portDiscovery;
+  commandSupervisor;
   config;
   callbacks;
   abortController = new AbortController();
@@ -567,6 +881,14 @@ var AdhocSessionRunner = class {
       buildAdhocPtyBridge(this.connection),
       resolveTuiAdapter(resolveAdhocTui(process.env))
     );
+    this.portDiscovery = deps?.portDiscovery ?? new PortDiscovery({
+      report: (ports) => this.connection.reportDiscoveredPorts(ports)
+    });
+    this.commandSupervisor = deps?.commandSupervisor ?? new WorkspaceCommandSupervisor({
+      config: loadConveyorConfig(),
+      workspaceDir: config.workspaceDir,
+      connection: this.connection
+    });
     this.lifecycle = new Lifecycle(
       // No git flush: the WIP snapshot machinery is branch/task-shaped; the human
       // commits/pushes explicitly from the interactive shell.
@@ -605,6 +927,13 @@ var AdhocSessionRunner = class {
       await this.connection.call("connectAgent", {
         sessionId: this.config.connection.sessionId
       });
+      await this.portDiscovery.start().catch(() => {
+      });
+      if (this.stopped) {
+        this._finalState = "finished";
+        return;
+      }
+      this.commandSupervisor.start();
       await this.connection.emitStatus("running");
       this.callbacks.onEvent?.({ type: "adhoc_runner_started", projectId: this.config.projectId });
       this.lifecycle.startIdleTimer();
@@ -617,7 +946,7 @@ var AdhocSessionRunner = class {
       this.connection.sendEvent({ type: "error", message });
       this._finalState = "error";
     } finally {
-      this.shutdown();
+      await this.shutdown();
     }
   }
   /**
@@ -651,6 +980,8 @@ var AdhocSessionRunner = class {
   requestStop() {
     if (this.stopped) return;
     this.stopped = true;
+    this.portDiscovery.stop();
+    void this.commandSupervisor.stop();
     this.abortController.abort();
     if (this.stopResolver) {
       const resolve = this.stopResolver;
@@ -670,8 +1001,10 @@ var AdhocSessionRunner = class {
       });
     }
   }
-  shutdown() {
+  async shutdown() {
     this.stopped = true;
+    this.portDiscovery.stop();
+    await this.commandSupervisor.stop();
     this.lifecycle.destroy();
     this.connection.sendEvent({ type: "shutdown", reason: this._finalState ?? "finished" });
     this.connection.disconnect();
@@ -1381,10 +1714,13 @@ var runner = new SessionRunner(
 var reviewChildren = new ReviewChildSupervisor(runner.connection, CONVEYOR_WORKSPACE);
 var sessionChildren = new SessionChildSupervisor(runner.connection, CONVEYOR_WORKSPACE);
 var shutdownSignal;
+var workspaceCommandSupervisor = null;
+var shutdownCompletion = null;
 var shutdownAgent = (signal) => {
   logger5.info(`Received ${signal}, flushing git and stopping agent`);
+  const commandShutdown = stopWorkspaceCommands(workspaceCommandSupervisor);
   shutdownSignal = signal;
-  void (async () => {
+  shutdownCompletion ??= (async () => {
     try {
       await Promise.all([reviewChildren.stopAll(), sessionChildren.stopAll()]);
     } catch {
@@ -1392,9 +1728,11 @@ var shutdownAgent = (signal) => {
     try {
       await runner.flushGitOnShutdown();
     } finally {
+      await commandShutdown;
       runner.stop();
     }
   })();
+  void shutdownCompletion;
   setTimeout(() => {
     logger5.warn(`Forcing exit after ${signal} timeout`);
     logger5.warn(
@@ -1413,63 +1751,25 @@ var shutdownAgent = (signal) => {
 };
 process.on("SIGTERM", () => shutdownAgent("SIGTERM"));
 process.on("SIGINT", () => shutdownAgent("SIGINT"));
-await runner.connect();
-var logSetupOutput = (stream, data) => {
-  runner.connection.sendEvent({ type: "setup_output", stream, data });
-  (stream === "stderr" ? process.stderr : process.stdout).write(data);
-};
-var startCommandChild = null;
-var expectedStartCommandStops = /* @__PURE__ */ new WeakSet();
-var stopStartCommandChild = () => {
-  const child = startCommandChild;
-  if (!child || child.exitCode !== null || child.killed) return;
-  expectedStartCommandStops.add(child);
-  try {
-    if (child.pid) process.kill(-child.pid, "SIGTERM");
-    else child.kill("SIGTERM");
-  } catch {
-    try {
-      child.kill("SIGTERM");
-    } catch {
-    }
-  }
-};
-var launchStartCommand = (command) => {
-  logger5.info("Running start command", { command });
-  runner.connection.sendEvent({ type: "start_command_started" });
-  const child = runStartCommand(command, CONVEYOR_WORKSPACE, (stream, data) => {
-    runner.connection.sendEvent({ type: "start_command_output", stream, data });
-    (stream === "stderr" ? process.stderr : process.stdout).write(data);
-  });
-  startCommandChild = child;
-  child.on("exit", (code, signal) => {
-    if (startCommandChild === child) startCommandChild = null;
-    if (expectedStartCommandStops.has(child)) return;
-    logger5.info("Start command exited", { code, signal });
-    runner.connection.sendEvent({
-      type: "start_command_exited",
-      code,
-      signal,
-      message: `start command exited${code === null ? "" : ` with code ${code}`}${signal ? ` (signal: ${signal})` : ""}`
-    });
-    if (code !== null && code !== 0) {
-      runner.connection.sendEvent({
-        type: "start_command_error",
-        message: `start command exited with code ${code}${signal ? ` (signal: ${signal})` : ""}`
-      });
-    }
-  });
-  child.on("error", (err) => {
-    if (startCommandChild === child) startCommandChild = null;
-    logger5.error("Start command error", { error: err.message });
-    runner.connection.sendEvent({ type: "start_command_error", message: err.message });
+workspaceCommandSupervisor = await startWorkspaceCommandsAfterConnect({
+  connect: () => runner.connect(),
+  isShuttingDown: () => shutdownSignal !== void 0,
+  create: () => new WorkspaceCommandSupervisor({
+    config: loadConveyorConfig(),
+    workspaceDir: CONVEYOR_WORKSPACE,
+    connection: runner.connection
+  })
+});
+if (!workspaceCommandSupervisor) {
+  logger5.info("Agent stopped before workspace commands were started");
+  if (shutdownCompletion) await shutdownCompletion;
+  logAgentExit(shutdownSignal ? "signal" : "clean", {
+    exitCode: 0,
+    signal: shutdownSignal,
+    finalState: runner.finalState ?? void 0
   });
-};
-void startLazySidecars(
-  process.env,
-  (message) => logSetupOutput("stdout", `[sidecars] ${message}
-`)
-);
+  process.exit(0);
+}
 void checkSessionTaskIdentity({
   sessionId: process.env.CONVEYOR_SESSION_ID,
   taskId: CONVEYOR_TASK_ID,
@@ -1505,63 +1805,8 @@ if (CONVEYOR_MODE === "task" || CONVEYOR_MODE === "pack") {
     });
   });
 }
-var conveyorConfig = loadConveyorConfig();
-runner.connection.onRunStartCommand(() => {
-  if (!conveyorConfig?.startCommand) return;
-  runner.connection.sendEvent({
-    type: "start_command_output",
-    stream: "stdout",
-    data: "[conveyor-agent] Restarting start command...\n"
-  });
-  stopStartCommandChild();
-  launchStartCommand(conveyorConfig.startCommand);
-});
-if (conveyorConfig) {
-  void (async () => {
-    const gitState = await awaitGitReady({
-      onLog: (m) => logSetupOutput("stdout", `[git] ${m}
-`)
-    });
-    if (gitState === "failed" || gitState === "timeout") {
-      runner.connection.sendEvent({
-        type: "setup_error",
-        message: "Workspace not ready \u2014 skipping setup/start"
-      });
-      return;
-    }
-    await waitForSidecars({
-      onLog: (message) => logSetupOutput("stdout", `[sidecars] ${message}
-`),
-      startLazy: false
-    });
-    if (conveyorConfig.setupCommand) {
-      logger5.info("Running setup command (background)", {
-        command: conveyorConfig.setupCommand
-      });
-      try {
-        await runSetupCommand(conveyorConfig.setupCommand, CONVEYOR_WORKSPACE, logSetupOutput);
-        logger5.info("Setup command completed");
-      } catch (error) {
-        const msg = error instanceof Error ? error.message : "Setup command failed";
-        logger5.error("Setup command failed", { error: msg });
-        runner.connection.sendEvent({ type: "setup_error", message: msg });
-      }
-    }
-    let startCommandRunning = false;
-    if (conveyorConfig.startCommand) {
-      launchStartCommand(conveyorConfig.startCommand);
-      startCommandRunning = true;
-    }
-    const forwardPorts = await loadForwardPorts(CONVEYOR_WORKSPACE);
-    const previewPorts = buildSessionPreviewPorts(forwardPorts);
-    runner.connection.sendEvent({
-      type: "setup_complete",
-      startCommandRunning,
-      ...previewPorts.length > 0 ? { previewPorts } : {}
-    });
-  })();
-}
-runner.run().then(() => {
+runner.run().then(async () => {
+  await stopWorkspaceCommands(workspaceCommandSupervisor);
   const errored = runner.finalState === "error";
   const reason = shutdownSignal ? "signal" : errored ? "error" : "clean";
   logAgentExit(reason, {
@@ -1570,7 +1815,8 @@ runner.run().then(() => {
     finalState: runner.finalState ?? void 0
   });
   process.exit(errored ? 1 : 0);
-}).catch((error) => {
+}).catch(async (error) => {
+  await stopWorkspaceCommands(workspaceCommandSupervisor);
   const msg = error instanceof Error ? error.message : String(error);
   logger5.error("Agent runner failed", { error: msg });
   logAgentExit("error", { exitCode: 1, finalState: runner.finalState ?? void 0 });