@rallycry/conveyor-agent 10.2.1 → 10.2.4

package/dist/cli.js

@@ -13,10 +13,12 @@ import {
   fetchBootstrap,
   loadConveyorConfig,
   loadForwardPorts,
+  resolveSessionStart,
   runSetupCommand,
   runStartCommand,
   sampleKeyUsage
-} from "./chunk-YGLTLUGA.js";
+} from "./chunk-DEMRCBJN.js";
+import "./chunk-7TQO4ZF4.js";
 
 // src/cli.ts
 import { readFileSync } from "fs";
@@ -144,14 +146,14 @@ async function waitForSidecars(opts = {}) {
 
 // src/utils/session-identity.ts
 async function checkSessionTaskIdentity(params) {
-  const { sessionId, taskId, fetchSessionTaskId, logger: logger2 } = params;
+  const { sessionId, taskId, fetchSessionTaskId, logger: logger3 } = 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);
-    logger2.warn("Could not verify session/task identity \u2014 continuing (defense-in-depth only)", {
+    logger3.warn("Could not verify session/task identity \u2014 continuing (defense-in-depth only)", {
       sessionId,
       taskId,
       error: message
@@ -159,7 +161,7 @@ async function checkSessionTaskIdentity(params) {
     return "error";
   }
   if (sessionTaskId !== taskId) {
-    logger2.warn(
+    logger3.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 }
     );
@@ -168,15 +170,41 @@ async function checkSessionTaskIdentity(params) {
   return "match";
 }
 
+// src/utils/agent-exit.ts
+function exitLogLevel(reason) {
+  return reason === "clean" ? "info" : "warn";
+}
+function buildAgentExitLog(args) {
+  const log = {
+    event: "agent_exit",
+    reason: args.reason,
+    exitCode: args.exitCode,
+    uptimeSec: Math.round(args.uptimeSec * 10) / 10
+  };
+  if (args.signal !== void 0) log.signal = args.signal;
+  if (args.finalState !== void 0) log.finalState = args.finalState;
+  const id = args.identity;
+  if (id) {
+    if (id.sessionId !== void 0) log.sessionId = id.sessionId;
+    if (id.taskId !== void 0) log.taskId = id.taskId;
+    if (id.workspaceId !== void 0) log.workspaceId = id.workspaceId;
+    if (id.runnerMode !== void 0) log.runnerMode = id.runnerMode;
+  }
+  return log;
+}
+
 // src/setup/project-identity.ts
 function resolveProjectRunnerIdentity(env) {
   if (env.CONVEYOR_TASK_ID) return null;
   if (!env.CONVEYOR_TASK_TOKEN) return null;
-  if (!env.CONVEYOR_PROJECT_ID || !env.CONVEYOR_SESSION_ID) return null;
+  if (!env.CONVEYOR_PROJECT_ID || !env.CONVEYOR_SESSION_ID || !env.CONVEYOR_WORKSPACE_ID) {
+    return null;
+  }
   if (env.CONVEYOR_MODE !== "pm" && env.CONVEYOR_MODE !== "adhoc") return null;
   return {
     projectId: env.CONVEYOR_PROJECT_ID,
     sessionId: env.CONVEYOR_SESSION_ID,
+    workspaceId: env.CONVEYOR_WORKSPACE_ID,
     taskToken: env.CONVEYOR_TASK_TOKEN
   };
 }
@@ -318,11 +346,12 @@ var ADHOC_SYSTEM_NOTE = "You are running in an ad-hoc Conveyor scratch pod \u201
 function buildAdhocPtyBridge(connection) {
   return {
     sendOutput: (data, dims) => connection.sendPtyOutput(data, dims),
+    sendChatEvent: (event) => connection.sendPtyChatEvent(event),
     onInput: (handler) => connection.onPtyInput(handler),
     onResize: (handler) => connection.onPtyResize(handler)
   };
 }
-function buildAdhocQueryOptions(workspaceDir, model, abortController) {
+function buildAdhocQueryOptions(workspaceDir, model, abortController, session) {
   return {
     model,
     systemPrompt: { type: "preset", preset: "claude_code", append: ADHOC_SYSTEM_NOTE },
@@ -336,7 +365,9 @@ function buildAdhocQueryOptions(workspaceDir, model, abortController) {
     settingSources: ["user", "project"],
     // Empty box, unsubmitted: the human types the first prompt themselves.
     promptDelivery: "prefill",
-    abortController
+    abortController,
+    ...session?.sessionId ? { sessionId: session.sessionId } : {},
+    ...session?.resume ? { resume: session.resume } : {}
   };
 }
 var AdhocSessionRunner = class {
@@ -414,7 +445,13 @@ var AdhocSessionRunner = class {
    */
   async runInteractiveTui() {
     const model = this.config.model ?? process.env.CONVEYOR_ADHOC_MODEL ?? DEFAULT_SONNET_MODEL;
-    const options = buildAdhocQueryOptions(this.config.workspaceDir, model, this.abortController);
+    const session = resolveSessionStart(this.config.workspaceId, this.config.workspaceDir);
+    const options = buildAdhocQueryOptions(
+      this.config.workspaceDir,
+      model,
+      this.abortController,
+      session
+    );
     try {
       for await (const _event of this.harness.executeQuery({ prompt: "", options })) {
         if (this.stopped) break;
@@ -456,6 +493,163 @@ var AdhocSessionRunner = class {
   }
 };
 
+// src/runner/review-child.ts
+import { spawn as nodeSpawn, execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var logger = createServiceLogger("ReviewChild");
+var SPAWN_FAILURE_GRACE_MS = 15e3;
+var KILL_WAIT_MS = 5e3;
+function buildReviewChildEnv(baseEnv, data) {
+  const env = { ...baseEnv };
+  env.CONVEYOR_TASK_TOKEN = data.sessionJwt;
+  env.CONVEYOR_SESSION_ID = data.sessionId;
+  env.CONVEYOR_MODE = "code-review";
+  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 ReviewChildSupervisor = class {
+  constructor(connection, workspaceDir, spawnFn = nodeSpawn) {
+    this.connection = connection;
+    this.workspaceDir = workspaceDir;
+    this.spawnFn = spawnFn;
+  }
+  connection;
+  workspaceDir;
+  spawnFn;
+  child = null;
+  childSessionId = null;
+  /** Spawn (or replace) the review child for a `session:spawnReview` push. */
+  async spawn(data) {
+    logger.info("Spawning same-pod review child", {
+      reviewSessionId: data.sessionId,
+      branch: data.branch ?? void 0,
+      prNumber: data.prNumber ?? void 0
+    });
+    await this.stopCurrent("superseded by new review spawn");
+    await this.refreshCheckout(data.branch ?? null);
+    const env = buildReviewChildEnv(process.env, data);
+    const cliPath = process.argv[1];
+    if (!cliPath) {
+      this.connection.reportReviewSpawnFailure(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.reportReviewSpawnFailure(
+        data.sessionId,
+        err instanceof Error ? err.message : String(err)
+      );
+      return;
+    }
+    this.child = child;
+    this.childSessionId = data.sessionId;
+    const spawnedAt = Date.now();
+    let reported = false;
+    const reportOnce = (message) => {
+      if (reported) return;
+      reported = true;
+      this.connection.reportReviewSpawnFailure(data.sessionId, message);
+    };
+    child.stdout?.on("data", (chunk) => {
+      process.stdout.write(`[review-child] ${chunk.toString()}`);
+    });
+    child.stderr?.on("data", (chunk) => {
+      process.stderr.write(`[review-child] ${chunk.toString()}`);
+    });
+    child.on("error", (err) => {
+      logger.error("Review child spawn error", { error: err.message });
+      if (this.child === child) {
+        this.child = null;
+        this.childSessionId = null;
+      }
+      reportOnce(err.message);
+    });
+    child.on("exit", (code, signal) => {
+      const wasCurrent = this.child === child;
+      if (wasCurrent) {
+        this.child = null;
+        this.childSessionId = null;
+      }
+      logger.info("Review child exited", { code, signal, reviewSessionId: data.sessionId });
+      const withinGrace = Date.now() - spawnedAt < SPAWN_FAILURE_GRACE_MS;
+      if (wasCurrent && withinGrace && code !== null && code !== 0) {
+        reportOnce(`review child exited with code ${code} within startup grace`);
+      }
+    });
+  }
+  /** Stop any live child (parent shutdown / supersede). Best-effort. */
+  async stopAll() {
+    await this.stopCurrent("parent shutting down");
+  }
+  async stopCurrent(reason) {
+    const child = this.child;
+    if (!child || child.exitCode !== null || child.killed) {
+      this.child = null;
+      this.childSessionId = null;
+      return;
+    }
+    logger.info("Stopping review child", { reason, reviewSessionId: this.childSessionId });
+    this.child = null;
+    this.childSessionId = null;
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+        resolve();
+      }, KILL_WAIT_MS);
+      timer.unref();
+      child.once("exit", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      try {
+        child.kill("SIGTERM");
+      } catch {
+        clearTimeout(timer);
+        resolve();
+      }
+    });
+  }
+  /**
+   * Best-effort branch freshen before the review reads the tree: fetch the PR
+   * branch and fast-forward only (never clobber local work — the builder's
+   * checkout is the source of truth on conflict). Failures are logged and
+   * skipped; the reviewer still reads the diff via the GitHub API.
+   */
+  async refreshCheckout(branch) {
+    if (!branch) return;
+    try {
+      await execFileAsync("git", ["fetch", "origin", branch], {
+        cwd: this.workspaceDir,
+        timeout: 6e4
+      });
+      await execFileAsync("git", ["merge", "--ff-only", `origin/${branch}`], {
+        cwd: this.workspaceDir,
+        timeout: 3e4
+      });
+    } catch (err) {
+      logger.warn("Review checkout freshen skipped", {
+        branch,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+};
+
 // src/cli.ts
 if (process.argv.includes("--version")) {
   const __dirname = dirname2(fileURLToPath(import.meta.url));
@@ -464,11 +658,26 @@ if (process.argv.includes("--version")) {
   process.stdout.write(pkg.version + "\n");
   process.exit(0);
 }
-var logger = createServiceLogger("CLI");
+var logger2 = createServiceLogger("CLI");
+var exitContext = {};
+var exitLogged = false;
+function logAgentExit(reason, opts) {
+  if (exitLogged) return;
+  exitLogged = true;
+  const payload = buildAgentExitLog({
+    reason,
+    exitCode: opts.exitCode,
+    signal: opts.signal,
+    finalState: opts.finalState,
+    uptimeSec: process.uptime(),
+    identity: exitContext
+  });
+  logger2[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);
-  logger.info("Bootstrapping from codespace", {
+  logger2.info("Bootstrapping from codespace", {
     codespace: instanceName,
     apiUrl,
     apiUrlFromEnv,
@@ -480,7 +689,7 @@ async function bootstrapFromCodespace(apiUrl, instanceName) {
     bootstrapToken
   });
   if (!result.ok) {
-    logger.error("Bootstrap failed after retries", {
+    logger2.error("Bootstrap failed after retries", {
       reason: result.reason,
       attempts: result.attempts,
       status: result.status,
@@ -493,7 +702,7 @@ async function bootstrapFromCodespace(apiUrl, instanceName) {
     process.exit(1);
   }
   applyBootstrapToEnv(result.config);
-  logger.info("Bootstrap complete", {
+  logger2.info("Bootstrap complete", {
     taskId: result.config.taskId,
     attempts: result.attempts
   });
@@ -507,19 +716,21 @@ function isExpectedAbortError(error) {
 process.on("uncaughtException", (err) => {
   if (err.code === "EPIPE") return;
   if (isExpectedAbortError(err)) {
-    logger.info("Ignored expected abort after shutdown", { error: err.message, code: err.code });
+    logger2.info("Ignored expected abort after shutdown", { error: err.message, code: err.code });
     return;
   }
-  logger.error("Uncaught exception", { error: err.message, code: err.code });
+  logger2.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)) {
-    logger.info("Ignored expected abort rejection after shutdown", { error: err.message });
+    logger2.info("Ignored expected abort rejection after shutdown", { error: err.message });
     return;
   }
-  logger.error("Unhandled rejection", { error: err.message });
+  logger2.error("Unhandled rejection", { error: err.message });
+  logAgentExit("unhandled_rejection", { exitCode: 1 });
   process.exit(1);
 });
 var DEFAULT_CONVEYOR_API_URL = "https://api.conveyor.rallycryapp.com";
@@ -527,7 +738,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) {
-    logger.error("Could not resolve CONVEYOR_API_URL for codespace bootstrap");
+    logger2.error("Could not resolve CONVEYOR_API_URL for codespace bootstrap");
     process.exit(1);
   }
   await bootstrapFromCodespace(conveyorApiUrl, INSTANCE_NAME);
@@ -539,9 +750,13 @@ var CONVEYOR_WORKSPACE = process.env.CONVEYOR_WORKSPACE ?? process.cwd();
 var CONVEYOR_MODE = process.env.CONVEYOR_MODE ?? "task";
 var CONVEYOR_AGENT_MODE = process.env.CONVEYOR_AGENT_MODE || void 0;
 var CONVEYOR_IS_AUTO = CONVEYOR_AGENT_MODE ? CONVEYOR_AGENT_MODE === "auto" : process.env.CONVEYOR_IS_AUTO === "true";
+exitContext.taskId = CONVEYOR_TASK_ID;
+exitContext.workspaceId = process.env.CONVEYOR_WORKSPACE_ID;
+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") {
-  logger.info("Starting ad-hoc agent", { projectId: projectIdentity.projectId });
+  logger2.info("Starting ad-hoc agent", { projectId: projectIdentity.projectId });
   const adhocRunner = new AdhocSessionRunner(
     {
       connection: {
@@ -551,22 +766,31 @@ if (!CONVEYOR_TASK_ID && projectIdentity && CONVEYOR_MODE === "adhoc") {
         runnerMode: "adhoc"
       },
       projectId: projectIdentity.projectId,
+      workspaceId: projectIdentity.workspaceId,
       workspaceDir: CONVEYOR_WORKSPACE,
       ...process.env.CLAUDESPACE_NAME ? { lifecycle: { idleTimeoutMs: 60 * 60 * 1e3 } } : {}
     },
     {
       onEvent: (event) => {
-        logger.info("Ad-hoc runner event", { eventType: event.type });
+        logger2.info("Ad-hoc runner event", { eventType: event.type });
       }
     }
   );
+  exitContext.sessionId = projectIdentity.sessionId;
+  exitContext.workspaceId = projectIdentity.workspaceId;
+  exitContext.runnerMode = "adhoc";
   process.on("SIGTERM", () => adhocRunner.stop());
   process.on("SIGINT", () => adhocRunner.stop());
   await adhocRunner.run();
-  process.exit(adhocRunner.finalState === "error" ? 1 : 0);
+  const adhocError = adhocRunner.finalState === "error";
+  logAgentExit(adhocError ? "error" : "clean", {
+    exitCode: adhocError ? 1 : 0,
+    finalState: adhocRunner.finalState ?? void 0
+  });
+  process.exit(adhocError ? 1 : 0);
 }
 if (!CONVEYOR_TASK_ID && projectIdentity) {
-  logger.info("Starting project agent", { projectId: projectIdentity.projectId });
+  logger2.info("Starting project agent", { projectId: projectIdentity.projectId });
   const projectRunner = new ProjectSessionRunner(
     {
       connection: {
@@ -581,38 +805,46 @@ if (!CONVEYOR_TASK_ID && projectIdentity) {
     },
     {
       onEvent: (event) => {
-        logger.info("Project runner event", { eventType: event.type });
+        logger2.info("Project runner event", { eventType: event.type });
       }
     }
   );
+  exitContext.sessionId = projectIdentity.sessionId;
+  exitContext.workspaceId = projectIdentity.workspaceId;
+  exitContext.runnerMode = "pm";
   process.on("SIGTERM", () => projectRunner.stop());
   process.on("SIGINT", () => projectRunner.stop());
   await projectRunner.run();
-  process.exit(projectRunner.finalState === "error" ? 1 : 0);
+  const projectError = projectRunner.finalState === "error";
+  logAgentExit(projectError ? "error" : "clean", {
+    exitCode: projectError ? 1 : 0,
+    finalState: projectRunner.finalState ?? void 0
+  });
+  process.exit(projectError ? 1 : 0);
 }
 if (!CONVEYOR_TASK_TOKEN || !CONVEYOR_TASK_ID) {
-  logger.error("Missing required environment variables");
-  logger.error("  CONVEYOR_TASK_TOKEN - JWT token for task authentication");
-  logger.error("  CONVEYOR_TASK_ID - ID of the task to execute");
-  logger.error("");
-  logger.error("CONVEYOR_API_URL is provided via codespace secret or bootstrap.");
-  logger.error("");
-  logger.error("Optional:");
-  logger.error("  CONVEYOR_MODE - Runner mode: 'task' (default) or 'pm'");
-  logger.error("  CONVEYOR_WORKSPACE - Working directory (defaults to cwd)");
-  logger.error(
+  logger2.error("Missing required environment variables");
+  logger2.error("  CONVEYOR_TASK_TOKEN - JWT token for task authentication");
+  logger2.error("  CONVEYOR_TASK_ID - ID of the task to execute");
+  logger2.error("");
+  logger2.error("CONVEYOR_API_URL is provided via codespace secret or bootstrap.");
+  logger2.error("");
+  logger2.error("Optional:");
+  logger2.error("  CONVEYOR_MODE - Runner mode: 'task' (default) or 'pm'");
+  logger2.error("  CONVEYOR_WORKSPACE - Working directory (defaults to cwd)");
+  logger2.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") {
-  logger.error("Invalid CONVEYOR_MODE", {
+  logger2.error("Invalid CONVEYOR_MODE", {
     mode: CONVEYOR_MODE,
     expected: ["task", "pm", "code-review", "adhoc"]
   });
   process.exit(1);
 }
-logger.info("Starting agent", { mode: CONVEYOR_MODE });
+logger2.info("Starting agent", { mode: CONVEYOR_MODE });
 var lifecycleOverrides = process.env.CLAUDESPACE_NAME ? { idleTimeoutMs: 60 * 60 * 1e3 } : { gitFlushIntervalMs: 0 };
 var runner = new SessionRunner(
   {
@@ -632,19 +864,26 @@ var runner = new SessionRunner(
   },
   {
     onStatusChange: (status) => {
-      logger.info("Status changed", { status });
+      logger2.info("Status changed", { status });
     },
     onEvent: (event) => {
       const detail = event.message ?? event.content ?? event.summary ?? "";
       if (detail) {
-        logger.info(detail, { eventType: event.type });
+        logger2.info(detail, { eventType: event.type });
       }
     }
   }
 );
+var reviewChildren = new ReviewChildSupervisor(runner.connection, CONVEYOR_WORKSPACE);
+var shutdownSignal;
 var shutdownAgent = (signal) => {
-  logger.info(`Received ${signal}, flushing git and stopping agent`);
+  logger2.info(`Received ${signal}, flushing git and stopping agent`);
+  shutdownSignal = signal;
   void (async () => {
+    try {
+      await reviewChildren.stopAll();
+    } catch {
+    }
     try {
       await runner.flushGitOnShutdown();
     } finally {
@@ -652,7 +891,18 @@ var shutdownAgent = (signal) => {
     }
   })();
   setTimeout(() => {
-    logger.warn(`Forcing exit after ${signal} timeout`);
+    logger2.warn(`Forcing exit after ${signal} timeout`);
+    logger2.warn(
+      "agent_exit",
+      buildAgentExitLog({
+        reason: "force_timeout",
+        exitCode: 1,
+        signal,
+        finalState: runner.finalState ?? void 0,
+        uptimeSec: process.uptime(),
+        identity: exitContext
+      })
+    );
     process.exit(1);
   }, 45e3).unref();
 };
@@ -680,7 +930,7 @@ var stopStartCommandChild = () => {
   }
 };
 var launchStartCommand = (command) => {
-  logger.info("Running start command", { command });
+  logger2.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 });
@@ -690,7 +940,7 @@ var launchStartCommand = (command) => {
   child.on("exit", (code, signal) => {
     if (startCommandChild === child) startCommandChild = null;
     if (expectedStartCommandStops.has(child)) return;
-    logger.info("Start command exited", { code, signal });
+    logger2.info("Start command exited", { code, signal });
     runner.connection.sendEvent({
       type: "start_command_exited",
       code,
@@ -706,7 +956,7 @@ var launchStartCommand = (command) => {
   });
   child.on("error", (err) => {
     if (startCommandChild === child) startCommandChild = null;
-    logger.error("Start command error", { error: err.message });
+    logger2.error("Start command error", { error: err.message });
     runner.connection.sendEvent({ type: "start_command_error", message: err.message });
   });
 };
@@ -722,8 +972,21 @@ void checkSessionTaskIdentity({
     const ctx = await runner.connection.call("getTaskContext", { sessionId });
     return ctx.id;
   },
-  logger
+  logger: logger2
 });
+if (CONVEYOR_MODE === "task") {
+  runner.connection.onSpawnReview((data) => {
+    void reviewChildren.spawn(data).catch((err) => {
+      logger2.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)
+      );
+    });
+  });
+}
 var conveyorConfig = loadConveyorConfig();
 runner.connection.onRunStartCommand(() => {
   if (!conveyorConfig?.startCommand) return;
@@ -754,15 +1017,15 @@ if (conveyorConfig) {
       startLazy: false
     });
     if (conveyorConfig.setupCommand) {
-      logger.info("Running setup command (background)", {
+      logger2.info("Running setup command (background)", {
         command: conveyorConfig.setupCommand
       });
       try {
         await runSetupCommand(conveyorConfig.setupCommand, CONVEYOR_WORKSPACE, logSetupOutput);
-        logger.info("Setup command completed");
+        logger2.info("Setup command completed");
       } catch (error) {
         const msg = error instanceof Error ? error.message : "Setup command failed";
-        logger.error("Setup command failed", { error: msg });
+        logger2.error("Setup command failed", { error: msg });
         runner.connection.sendEvent({ type: "setup_error", message: msg });
       }
     }
@@ -776,16 +1039,23 @@ if (conveyorConfig) {
     runner.connection.sendEvent({
       type: "setup_complete",
       startCommandRunning,
-      previewPort: conveyorConfig.previewPort,
       ...previewPorts.length > 0 ? { previewPorts } : {}
     });
   })();
 }
 runner.run().then(() => {
-  process.exit(runner.finalState === "error" ? 1 : 0);
+  const errored = runner.finalState === "error";
+  const reason = shutdownSignal ? "signal" : errored ? "error" : "clean";
+  logAgentExit(reason, {
+    exitCode: errored ? 1 : 0,
+    signal: shutdownSignal,
+    finalState: runner.finalState ?? void 0
+  });
+  process.exit(errored ? 1 : 0);
 }).catch((error) => {
   const msg = error instanceof Error ? error.message : String(error);
-  logger.error("Agent runner failed", { error: msg });
+  logger2.error("Agent runner failed", { error: msg });
+  logAgentExit("error", { exitCode: 1, finalState: runner.finalState ?? void 0 });
   process.exit(1);
 });
 //# sourceMappingURL=cli.js.map