@rallycry/conveyor-agent 10.4.0 → 10.5.0

package/dist/cli.js

@@ -20,12 +20,13 @@ import {
   inheritedEnv,
   loadConveyorConfig,
   loadForwardPorts,
+  loadPtySpawn,
   resolvePlaywrightMcpServer,
   resolveSessionStart,
   runSetupCommand,
   runStartCommand,
   sampleKeyUsage
-} from "./chunk-TZYEU4QE.js";
+} from "./chunk-MSDYMAG3.js";
 import "./chunk-7TQO4ZF4.js";
 
 // src/cli.ts
@@ -154,14 +155,14 @@ async function waitForSidecars(opts = {}) {
 
 // src/utils/session-identity.ts
 async function checkSessionTaskIdentity(params) {
-  const { sessionId, taskId, fetchSessionTaskId, logger: logger4 } = params;
+  const { sessionId, taskId, fetchSessionTaskId, logger: logger6 } = 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);
-    logger4.warn("Could not verify session/task identity \u2014 continuing (defense-in-depth only)", {
+    logger6.warn("Could not verify session/task identity \u2014 continuing (defense-in-depth only)", {
       sessionId,
       taskId,
       error: message
@@ -169,7 +170,7 @@ async function checkSessionTaskIdentity(params) {
     return "error";
   }
   if (sessionTaskId !== taskId) {
-    logger4.warn(
+    logger6.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 }
     );
@@ -834,6 +835,295 @@ var ReviewChildSupervisor = class {
   }
 };
 
+// src/runner/session-child.ts
+import { spawn as nodeSpawn2 } from "child_process";
+var logger3 = createServiceLogger("SessionChild");
+var KILL_WAIT_MS2 = 5e3;
+function buildSpawnedChildEnv(baseEnv, data) {
+  const env = { ...baseEnv };
+  env.CONVEYOR_TASK_TOKEN = data.sessionJwt;
+  env.CONVEYOR_SESSION_ID = data.sessionId;
+  env.CONVEYOR_MODE = data.mode;
+  env.CONVEYOR_PROJECT_ID = data.projectId;
+  delete env.POD_BOOTSTRAP_TOKEN;
+  delete env.CONVEYOR_BOOTSTRAP_TOKEN;
+  delete env.CONVEYOR_SETUP_COMMAND;
+  delete env.CONVEYOR_START_COMMAND;
+  delete env.CONVEYOR_AGENT_MODE;
+  delete env.CONVEYOR_IS_AUTO;
+  return env;
+}
+var SessionChildSupervisor = class {
+  constructor(connection, workspaceDir, spawnFn = nodeSpawn2) {
+    this.connection = connection;
+    this.workspaceDir = workspaceDir;
+    this.spawnFn = spawnFn;
+  }
+  connection;
+  workspaceDir;
+  spawnFn;
+  children = /* @__PURE__ */ new Map();
+  /** Live child count (for tests/diagnostics). */
+  get size() {
+    return this.children.size;
+  }
+  /** Spawn a TUI/shell child for a `session:spawnTui` push. Additive per session. */
+  async spawn(data) {
+    logger3.info("Spawning same-pod session child", {
+      spawnedSessionId: data.sessionId,
+      mode: data.mode
+    });
+    await this.stopChild(data.sessionId, "superseded by duplicate spawn");
+    const env = buildSpawnedChildEnv(process.env, data);
+    const cliPath = process.argv[1];
+    if (!cliPath) {
+      this.connection.reportSessionSpawnFailure(data.sessionId, "cannot resolve CLI entry path");
+      return;
+    }
+    let child;
+    try {
+      child = this.spawnFn(process.execPath, [cliPath], {
+        cwd: this.workspaceDir,
+        env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (err) {
+      this.connection.reportSessionSpawnFailure(
+        data.sessionId,
+        err instanceof Error ? err.message : String(err)
+      );
+      return;
+    }
+    this.children.set(data.sessionId, child);
+    const spawnedAt = Date.now();
+    let reported = false;
+    const reportOnce = (message) => {
+      if (reported) return;
+      reported = true;
+      this.connection.reportSessionSpawnFailure(data.sessionId, message);
+    };
+    const prefix = `[${data.mode}-child]`;
+    child.stdout?.on("data", (chunk) => {
+      process.stdout.write(`${prefix} ${chunk.toString()}`);
+    });
+    child.stderr?.on("data", (chunk) => {
+      process.stderr.write(`${prefix} ${chunk.toString()}`);
+    });
+    child.on("error", (err) => {
+      logger3.error("Session child spawn error", { error: err.message });
+      if (this.children.get(data.sessionId) === child) {
+        this.children.delete(data.sessionId);
+      }
+      reportOnce(err.message);
+    });
+    child.on("exit", (code, signal) => {
+      const wasCurrent = this.children.get(data.sessionId) === child;
+      if (wasCurrent) this.children.delete(data.sessionId);
+      logger3.info("Session child exited", {
+        code,
+        signal,
+        spawnedSessionId: data.sessionId,
+        mode: data.mode
+      });
+      const withinGrace = Date.now() - spawnedAt < SPAWN_FAILURE_GRACE_MS;
+      if (wasCurrent && withinGrace && code !== null && code !== 0) {
+        reportOnce(`session child exited with code ${code} within startup grace`);
+      }
+    });
+  }
+  /** Stop every live child (parent shutdown). Best-effort. */
+  async stopAll() {
+    const ids = [...this.children.keys()];
+    await Promise.all(ids.map((id) => this.stopChild(id, "parent shutting down")));
+  }
+  async stopChild(sessionId, reason) {
+    const child = this.children.get(sessionId);
+    this.children.delete(sessionId);
+    if (!child || child.exitCode !== null || child.killed) return;
+    logger3.info("Stopping session child", { reason, spawnedSessionId: sessionId });
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+        resolve();
+      }, KILL_WAIT_MS2);
+      timer.unref();
+      child.once("exit", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      try {
+        child.kill("SIGTERM");
+      } catch {
+        clearTimeout(timer);
+        resolve();
+      }
+    });
+  }
+};
+
+// src/runner/shell-session-runner.ts
+var DEFAULT_COLS = 80;
+var DEFAULT_ROWS = 24;
+function buildShellEnv(baseEnv) {
+  const env = { ...baseEnv };
+  delete env.CONVEYOR_TASK_TOKEN;
+  delete env.CONVEYOR_SESSION_ID;
+  return env;
+}
+var ShellSessionRunner = class {
+  connection;
+  lifecycle;
+  config;
+  loadSpawn;
+  pty = null;
+  dims = { cols: DEFAULT_COLS, rows: DEFAULT_ROWS };
+  stopped = false;
+  _finalState = null;
+  constructor(config, deps) {
+    this.config = config;
+    this.connection = deps?.connection ?? new AgentConnection(config.connection);
+    this.loadSpawn = deps?.loadSpawn ?? loadPtySpawn;
+    this.lifecycle = new Lifecycle(
+      // No git flush — the human commits/pushes explicitly from the shell.
+      { ...DEFAULT_LIFECYCLE_CONFIG, gitFlushIntervalMs: 0, ...config.lifecycle },
+      {
+        onHeartbeat: () => this.connection.sendHeartbeat(),
+        onIdleTimeout: () => this.requestStop(),
+        onDormantTimeout: () => this.requestStop(),
+        onTokenRefresh: () => void this.connection.refreshTaskTokenFromBootstrap().catch(() => {
+        }),
+        onGitFlush: () => {
+        },
+        onUsageSample: () => {
+        }
+      }
+    );
+  }
+  get finalState() {
+    return this._finalState;
+  }
+  get isStopped() {
+    return this.stopped;
+  }
+  /** Connect, register, spawn the shell, and relay it until exit or stop. */
+  async run() {
+    try {
+      await this.connection.connect();
+      this.connection.sendEvent({
+        type: "connected",
+        sessionId: this.config.connection.sessionId
+      });
+      this.connection.onStop(() => this.requestStop());
+      this.lifecycle.startHeartbeat();
+      this.lifecycle.startTokenRefresh();
+      await this.connection.call("connectAgent", {
+        sessionId: this.config.connection.sessionId
+      });
+      await this.connection.emitStatus("running");
+      this.lifecycle.startIdleTimer();
+      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}
+`);
+      this.connection.sendEvent({ type: "error", message });
+      this._finalState = "error";
+    } finally {
+      this.shutdown();
+    }
+  }
+  /** Spawn the login shell under a PTY and block until it exits or stop(). */
+  async runShell() {
+    const spawn = await this.loadSpawn();
+    const shell = this.config.shell ?? process.env.SHELL ?? "bash";
+    const pty = spawn(shell, ["-l"], {
+      name: "xterm-256color",
+      cols: this.dims.cols,
+      rows: this.dims.rows,
+      cwd: this.config.workspaceDir,
+      env: buildShellEnv(inheritedEnv())
+    });
+    this.pty = pty;
+    const unsubInput = this.connection.onPtyInput((data) => {
+      this.lifecycle.startIdleTimer();
+      pty.write(data);
+    });
+    const unsubResize = this.connection.onPtyResize((cols, rows) => {
+      this.dims = { cols, rows };
+      pty.resize(cols, rows);
+    });
+    pty.onData((data) => this.connection.sendPtyOutput(data, this.dims));
+    try {
+      await new Promise((resolve) => {
+        pty.onExit(() => resolve());
+      });
+    } finally {
+      unsubInput();
+      unsubResize();
+      this.pty = null;
+      this.connection.sendPtyEnded();
+    }
+  }
+  stop() {
+    this.requestStop();
+  }
+  requestStop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    try {
+      this.pty?.kill();
+    } catch {
+    }
+  }
+  shutdown() {
+    this.stopped = true;
+    this.lifecycle.destroy();
+    this.connection.sendEvent({ type: "shutdown", reason: this._finalState ?? "finished" });
+    this.connection.disconnect();
+  }
+};
+
+// src/runner/spawned-child-boot.ts
+var logger4 = createServiceLogger("SpawnedChildBoot");
+function createSpawnedChildRunner(inputs) {
+  if (inputs.mode === "shell") {
+    return new ShellSessionRunner({
+      connection: {
+        apiUrl: inputs.apiUrl,
+        taskToken: inputs.taskToken,
+        sessionId: inputs.sessionId,
+        runnerMode: "shell"
+      },
+      workspaceDir: inputs.workspaceDir
+    });
+  }
+  return new AdhocSessionRunner(
+    {
+      connection: {
+        apiUrl: inputs.apiUrl,
+        taskToken: inputs.taskToken,
+        sessionId: inputs.sessionId,
+        runnerMode: "adhoc"
+      },
+      projectId: inputs.projectId,
+      // Session lineage key. NOT the inherited CONVEYOR_WORKSPACE_ID — that's
+      // the builder's lineage; concurrent tabs must each be their own Claude
+      // conversation, so key on the spawned session id.
+      workspaceId: inputs.sessionId,
+      workspaceDir: inputs.workspaceDir
+    },
+    {
+      onEvent: (event) => {
+        logger4.info("Spawned TUI event", { eventType: event.type });
+      }
+    }
+  );
+}
+
 // src/cli.ts
 if (process.argv.includes("--version")) {
   const __dirname = dirname3(fileURLToPath(import.meta.url));
@@ -842,7 +1132,7 @@ if (process.argv.includes("--version")) {
   process.stdout.write(pkg.version + "\n");
   process.exit(0);
 }
-var logger3 = createServiceLogger("CLI");
+var logger5 = createServiceLogger("CLI");
 var exitContext = {};
 var exitLogged = false;
 function logAgentExit(reason, opts) {
@@ -856,12 +1146,12 @@ function logAgentExit(reason, opts) {
     uptimeSec: process.uptime(),
     identity: exitContext
   });
-  logger3[exitLogLevel(reason)]("agent_exit", payload);
+  logger5[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);
-  logger3.info("Bootstrapping from codespace", {
+  logger5.info("Bootstrapping from codespace", {
     codespace: instanceName,
     apiUrl,
     apiUrlFromEnv,
@@ -873,7 +1163,7 @@ async function bootstrapFromCodespace(apiUrl, instanceName) {
     bootstrapToken
   });
   if (!result.ok) {
-    logger3.error("Bootstrap failed after retries", {
+    logger5.error("Bootstrap failed after retries", {
       reason: result.reason,
       attempts: result.attempts,
       status: result.status,
@@ -886,7 +1176,7 @@ async function bootstrapFromCodespace(apiUrl, instanceName) {
     process.exit(1);
   }
   applyBootstrapToEnv(result.config);
-  logger3.info("Bootstrap complete", {
+  logger5.info("Bootstrap complete", {
     taskId: result.config.taskId,
     attempts: result.attempts
   });
@@ -900,20 +1190,20 @@ function isExpectedAbortError(error) {
 process.on("uncaughtException", (err) => {
   if (err.code === "EPIPE") return;
   if (isExpectedAbortError(err)) {
-    logger3.info("Ignored expected abort after shutdown", { error: err.message, code: err.code });
+    logger5.info("Ignored expected abort after shutdown", { error: err.message, code: err.code });
     return;
   }
-  logger3.error("Uncaught exception", { error: err.message, code: err.code });
+  logger5.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 (isExpectedAbortError(err)) {
-    logger3.info("Ignored expected abort rejection after shutdown", { error: err.message });
+    logger5.info("Ignored expected abort rejection after shutdown", { error: err.message });
     return;
   }
-  logger3.error("Unhandled rejection", { error: err.message });
+  logger5.error("Unhandled rejection", { error: err.message });
   logAgentExit("unhandled_rejection", { exitCode: 1 });
   process.exit(1);
 });
@@ -922,7 +1212,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) {
-    logger3.error("Could not resolve CONVEYOR_API_URL for codespace bootstrap");
+    logger5.error("Could not resolve CONVEYOR_API_URL for codespace bootstrap");
     process.exit(1);
   }
   await bootstrapFromCodespace(conveyorApiUrl, INSTANCE_NAME);
@@ -940,7 +1230,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") {
-  logger3.info("Starting ad-hoc agent", { projectId: projectIdentity.projectId });
+  logger5.info("Starting ad-hoc agent", { projectId: projectIdentity.projectId });
   const adhocRunner = new AdhocSessionRunner(
     {
       connection: {
@@ -956,7 +1246,7 @@ if (!CONVEYOR_TASK_ID && projectIdentity && CONVEYOR_MODE === "adhoc") {
     },
     {
       onEvent: (event) => {
-        logger3.info("Ad-hoc runner event", { eventType: event.type });
+        logger5.info("Ad-hoc runner event", { eventType: event.type });
       }
     }
   );
@@ -974,7 +1264,7 @@ if (!CONVEYOR_TASK_ID && projectIdentity && CONVEYOR_MODE === "adhoc") {
   process.exit(adhocError ? 1 : 0);
 }
 if (!CONVEYOR_TASK_ID && projectIdentity) {
-  logger3.info("Starting project agent", { projectId: projectIdentity.projectId });
+  logger5.info("Starting project agent", { projectId: projectIdentity.projectId });
   const projectRunner = new ProjectSessionRunner(
     {
       connection: {
@@ -989,7 +1279,7 @@ if (!CONVEYOR_TASK_ID && projectIdentity) {
     },
     {
       onEvent: (event) => {
-        logger3.info("Project runner event", { eventType: event.type });
+        logger5.info("Project runner event", { eventType: event.type });
       }
     }
   );
@@ -1007,28 +1297,58 @@ if (!CONVEYOR_TASK_ID && projectIdentity) {
   process.exit(projectError ? 1 : 0);
 }
 if (!CONVEYOR_TASK_TOKEN || !CONVEYOR_TASK_ID) {
-  logger3.error("Missing required environment variables");
-  logger3.error("  CONVEYOR_TASK_TOKEN - JWT token for task authentication");
-  logger3.error("  CONVEYOR_TASK_ID - ID of the task to execute");
-  logger3.error("");
-  logger3.error("CONVEYOR_API_URL is provided via codespace secret or bootstrap.");
-  logger3.error("");
-  logger3.error("Optional:");
-  logger3.error("  CONVEYOR_MODE - Runner mode: 'task' (default), 'pack', or 'pm'");
-  logger3.error("  CONVEYOR_WORKSPACE - Working directory (defaults to cwd)");
-  logger3.error(
+  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(
     "  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") {
-  logger3.error("Invalid CONVEYOR_MODE", {
+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"]
+    expected: ["task", "pm", "code-review", "adhoc", "pack", "shell"]
   });
   process.exit(1);
 }
-logger3.info("Starting agent", { mode: CONVEYOR_MODE });
+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 });
+    process.exit(1);
+  }
+  exitContext.sessionId = spawnedSessionId;
+  exitContext.runnerMode = CONVEYOR_MODE;
+  const childRunner = createSpawnedChildRunner({
+    mode: CONVEYOR_MODE,
+    apiUrl: conveyorApiUrl ?? "",
+    taskToken: CONVEYOR_TASK_TOKEN,
+    sessionId: spawnedSessionId,
+    workspaceDir: CONVEYOR_WORKSPACE,
+    projectId: process.env.CONVEYOR_PROJECT_ID ?? ""
+  });
+  logger5.info("Starting spawned session child", {
+    mode: CONVEYOR_MODE,
+    sessionId: spawnedSessionId
+  });
+  process.on("SIGTERM", () => childRunner.stop());
+  process.on("SIGINT", () => childRunner.stop());
+  await childRunner.run();
+  const childError = childRunner.finalState === "error";
+  logAgentExit(childError ? "error" : "clean", {
+    exitCode: childError ? 1 : 0,
+    finalState: childRunner.finalState ?? void 0
+  });
+  process.exit(childError ? 1 : 0);
+}
+logger5.info("Starting agent", { mode: CONVEYOR_MODE });
 var lifecycleOverrides = process.env.CLAUDESPACE_NAME ? { idleTimeoutMs: 60 * 60 * 1e3 } : { gitFlushIntervalMs: 0 };
 var runner = new SessionRunner(
   {
@@ -1048,24 +1368,25 @@ var runner = new SessionRunner(
   },
   {
     onStatusChange: (status) => {
-      logger3.info("Status changed", { status });
+      logger5.info("Status changed", { status });
     },
     onEvent: (event) => {
       const detail = event.message ?? event.content ?? event.summary ?? "";
       if (detail) {
-        logger3.info(detail, { eventType: event.type });
+        logger5.info(detail, { eventType: event.type });
       }
     }
   }
 );
 var reviewChildren = new ReviewChildSupervisor(runner.connection, CONVEYOR_WORKSPACE);
+var sessionChildren = new SessionChildSupervisor(runner.connection, CONVEYOR_WORKSPACE);
 var shutdownSignal;
 var shutdownAgent = (signal) => {
-  logger3.info(`Received ${signal}, flushing git and stopping agent`);
+  logger5.info(`Received ${signal}, flushing git and stopping agent`);
   shutdownSignal = signal;
   void (async () => {
     try {
-      await reviewChildren.stopAll();
+      await Promise.all([reviewChildren.stopAll(), sessionChildren.stopAll()]);
     } catch {
     }
     try {
@@ -1075,8 +1396,8 @@ var shutdownAgent = (signal) => {
     }
   })();
   setTimeout(() => {
-    logger3.warn(`Forcing exit after ${signal} timeout`);
-    logger3.warn(
+    logger5.warn(`Forcing exit after ${signal} timeout`);
+    logger5.warn(
       "agent_exit",
       buildAgentExitLog({
         reason: "force_timeout",
@@ -1114,7 +1435,7 @@ var stopStartCommandChild = () => {
   }
 };
 var launchStartCommand = (command) => {
-  logger3.info("Running start command", { 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 });
@@ -1124,7 +1445,7 @@ var launchStartCommand = (command) => {
   child.on("exit", (code, signal) => {
     if (startCommandChild === child) startCommandChild = null;
     if (expectedStartCommandStops.has(child)) return;
-    logger3.info("Start command exited", { code, signal });
+    logger5.info("Start command exited", { code, signal });
     runner.connection.sendEvent({
       type: "start_command_exited",
       code,
@@ -1140,7 +1461,7 @@ var launchStartCommand = (command) => {
   });
   child.on("error", (err) => {
     if (startCommandChild === child) startCommandChild = null;
-    logger3.error("Start command error", { error: err.message });
+    logger5.error("Start command error", { error: err.message });
     runner.connection.sendEvent({ type: "start_command_error", message: err.message });
   });
 };
@@ -1156,12 +1477,12 @@ void checkSessionTaskIdentity({
     const ctx = await runner.connection.call("getTaskContext", { sessionId });
     return ctx.id;
   },
-  logger: logger3
+  logger: logger5
 });
 if (CONVEYOR_MODE === "task") {
   runner.connection.onSpawnReview((data) => {
     void reviewChildren.spawn(data).catch((err) => {
-      logger3.error("Review child spawn threw", {
+      logger5.error("Review child spawn threw", {
         error: err instanceof Error ? err.message : String(err)
       });
       runner.connection.reportReviewSpawnFailure(
@@ -1171,6 +1492,19 @@ if (CONVEYOR_MODE === "task") {
     });
   });
 }
+if (CONVEYOR_MODE === "task" || CONVEYOR_MODE === "pack") {
+  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)
+      );
+    });
+  });
+}
 var conveyorConfig = loadConveyorConfig();
 runner.connection.onRunStartCommand(() => {
   if (!conveyorConfig?.startCommand) return;
@@ -1201,15 +1535,15 @@ if (conveyorConfig) {
       startLazy: false
     });
     if (conveyorConfig.setupCommand) {
-      logger3.info("Running setup command (background)", {
+      logger5.info("Running setup command (background)", {
         command: conveyorConfig.setupCommand
       });
       try {
         await runSetupCommand(conveyorConfig.setupCommand, CONVEYOR_WORKSPACE, logSetupOutput);
-        logger3.info("Setup command completed");
+        logger5.info("Setup command completed");
       } catch (error) {
         const msg = error instanceof Error ? error.message : "Setup command failed";
-        logger3.error("Setup command failed", { error: msg });
+        logger5.error("Setup command failed", { error: msg });
         runner.connection.sendEvent({ type: "setup_error", message: msg });
       }
     }
@@ -1238,7 +1572,7 @@ runner.run().then(() => {
   process.exit(errored ? 1 : 0);
 }).catch((error) => {
   const msg = error instanceof Error ? error.message : String(error);
-  logger3.error("Agent runner failed", { error: msg });
+  logger5.error("Agent runner failed", { error: msg });
   logAgentExit("error", { exitCode: 1, finalState: runner.finalState ?? void 0 });
   process.exit(1);
 });