@rallycry/conveyor-agent 10.13.71 → 11.0.0

package/dist/chunk-N4WSUTGV.js

@@ -0,0 +1,2564 @@
+import {
+  CLONE_TIMEOUT_MS,
+  DEFAULT_RETRY_DELAY_MS,
+  FETCH_TIMEOUT_MS,
+  GIT_PREP_MAX_RETRIES
+} from "./chunk-GL2DIQEQ.js";
+import {
+  buildConveyorSocketOptions,
+  callWithAck,
+  heartbeatStatusFor,
+  loopStatusForRunnerStatus,
+  waitForConnected
+} from "./chunk-IA45XHOA.js";
+import {
+  WorkbenchError,
+  getWorkbenchClient
+} from "./chunk-EXQ6AHOY.js";
+import {
+  workbenchEnabled
+} from "./chunk-KMB3BU4S.js";
+import {
+  gitCredentialHelper,
+  sleep,
+  syncGithubTokenFiles,
+  writeGitCredential
+} from "./chunk-W4LZ7R6Z.js";
+
+// src/setup/bootstrap.ts
+var BOOTSTRAP_TIMEOUT_MS = 3e4;
+var RETRY_DELAYS_MS = [5e3, 1e4, 2e4];
+function emitFailureEvent(payload) {
+  process.stderr.write(JSON.stringify(payload) + "\n");
+}
+async function singleBootstrapAttempt(apiUrl, instanceName, bootstrapToken, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const headers = {};
+    if (bootstrapToken) headers["x-codespace-token"] = bootstrapToken;
+    const response = await fetch(`${apiUrl}/api/codespace/bootstrap/${instanceName}`, {
+      headers,
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      return {
+        ok: false,
+        status: response.status,
+        errorText: errorText.slice(0, 500),
+        reason: response.status === 401 || response.status === 403 ? "auth_rejected" : "http_error"
+      };
+    }
+    const body = await response.json();
+    return { ok: true, body };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const reason = controller.signal.aborted ? "timeout" : "network_error";
+    return { ok: false, errorText: message.slice(0, 500), reason };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function buildFailure(reason, attempts, status, detail) {
+  const out = { ok: false, reason, attempts };
+  if (status === void 0) {
+  } else {
+    out.status = status;
+  }
+  if (detail) out.detail = detail;
+  return out;
+}
+function isRetryable(reason, retryOnHttpError) {
+  if (reason === "timeout" || reason === "network_error") return true;
+  return retryOnHttpError === true && reason === "http_error";
+}
+async function fetchBootstrap(opts) {
+  const timeoutMs = opts.timeoutMs ?? BOOTSTRAP_TIMEOUT_MS;
+  const delays = opts.retryDelaysMs ?? RETRY_DELAYS_MS;
+  const maxAttempts = delays.length + 1;
+  const hasBootstrapToken = Boolean(opts.bootstrapToken);
+  const hasTaskToken = Boolean(process.env.CONVEYOR_TASK_TOKEN);
+  let lastReason = "unknown";
+  let lastStatus;
+  let lastDetail;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const result = await singleBootstrapAttempt(
+      opts.apiUrl,
+      opts.instanceName,
+      opts.bootstrapToken,
+      timeoutMs
+    );
+    if (result.ok && result.body) {
+      return { ok: true, config: result.body, attempts: attempt };
+    }
+    lastReason = result.reason ?? "unknown";
+    lastStatus = result.status;
+    lastDetail = result.errorText;
+    const failurePayload = {
+      event: "bootstrap_failed",
+      reason: lastReason,
+      apiUrl: opts.apiUrl,
+      instanceName: opts.instanceName,
+      hasBootstrapToken,
+      hasTaskToken,
+      attempt
+    };
+    if (lastStatus === void 0) {
+    } else {
+      failurePayload.status = lastStatus;
+    }
+    if (lastDetail) failurePayload.detail = lastDetail;
+    emitFailureEvent(failurePayload);
+    if (!isRetryable(lastReason, opts.retryOnHttpError) || attempt >= maxAttempts) {
+      return buildFailure(lastReason, attempt, lastStatus, lastDetail);
+    }
+    await sleep(delays[attempt - 1]);
+  }
+  return buildFailure(lastReason, maxAttempts, lastStatus, lastDetail);
+}
+function applyBootstrapToEnv(config) {
+  for (const [key, value] of Object.entries(config.envVars ?? {})) {
+    process.env[key] = value;
+  }
+  if (config.mode === "project") {
+    if (config.projectToken) process.env.CONVEYOR_PROJECT_TOKEN = config.projectToken;
+    if (config.projectId) process.env.CONVEYOR_PROJECT_ID = config.projectId;
+    if (config.workspaceBranch) process.env.CONVEYOR_WORKSPACE_BRANCH = config.workspaceBranch;
+    return;
+  }
+  if (config.taskId) process.env.CONVEYOR_TASK_ID = config.taskId;
+  if (config.sessionId) process.env.CONVEYOR_SESSION_ID = config.sessionId;
+  if (config.taskToken) process.env.CONVEYOR_TASK_TOKEN = config.taskToken;
+  if (config.agentMode !== void 0) process.env.CONVEYOR_AGENT_MODE = config.agentMode;
+  if (config.isAuto !== void 0) process.env.CONVEYOR_IS_AUTO = config.isAuto;
+  if (config.runnerMode) process.env.CONVEYOR_MODE = config.runnerMode;
+  if (config.taskBranch) process.env.CONVEYOR_TASK_BRANCH = config.taskBranch;
+}
+
+// src/utils/logger.ts
+function createServiceLogger(service) {
+  const prefix = `[conveyor-agent:${service}]`;
+  return {
+    info(message, data) {
+      const extra = data ? ` ${JSON.stringify(data)}` : "";
+      process.stderr.write(`${prefix} ${message}${extra}
+`);
+    },
+    warn(message, data) {
+      const extra = data ? ` ${JSON.stringify(data)}` : "";
+      process.stderr.write(`${prefix} WARN ${message}${extra}
+`);
+    },
+    error(message, data) {
+      const extra = data ? ` ${JSON.stringify(data)}` : "";
+      process.stderr.write(`${prefix} ERROR ${message}${extra}
+`);
+    }
+  };
+}
+
+// src/connection/agent-connection.ts
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+import { Worker } from "worker_threads";
+import { io } from "socket.io-client";
+
+// src/setup/bootstrap-poll.ts
+var PollUntilBoundHttpError = class extends Error {
+  constructor(status) {
+    super(`pollUntilBound got unexpected status ${status}`);
+    this.status = status;
+    this.name = "PollUntilBoundHttpError";
+  }
+  status;
+};
+async function pollUntilBound(opts) {
+  const pollIntervalMs = opts.pollIntervalMs ?? 2e3;
+  const maxWaitMs = opts.maxWaitMs ?? 30 * 60 * 1e3;
+  const deadline = Date.now() + maxWaitMs;
+  while (true) {
+    const response = await fetch(`${opts.apiUrl}/api/v3/pods/bootstrap`, {
+      headers: { Authorization: `Bearer ${opts.bootstrapToken}` }
+    });
+    if (response.status === 200) {
+      return await response.json();
+    }
+    if (response.status === 204) {
+      if (Date.now() >= deadline) {
+        throw new Error(`pollUntilBound timed out after ${maxWaitMs}ms waiting for pod bind`);
+      }
+      await sleep(pollIntervalMs);
+      continue;
+    }
+    throw new PollUntilBoundHttpError(response.status);
+  }
+}
+
+// src/connection/bundle-credentials.ts
+function readBundleIdentity(sessionJwt) {
+  if (!sessionJwt) return {};
+  const segments = sessionJwt.split(".");
+  if (segments.length !== 3) return {};
+  try {
+    const json = Buffer.from(segments[1], "base64url").toString("utf8");
+    const claims = JSON.parse(json);
+    return {
+      ...typeof claims.sessionId === "string" ? { sessionId: claims.sessionId } : {},
+      ...typeof claims.role === "string" ? { role: claims.role } : {}
+    };
+  } catch {
+    return {};
+  }
+}
+function bundleMayWriteGithubFiles(bundle, self) {
+  const identity = readBundleIdentity(bundle.sessionJwt);
+  if (identity.sessionId && self.sessionId && identity.sessionId !== self.sessionId) {
+    return {
+      allowed: false,
+      reason: `bundle resolved to session ${identity.sessionId}, not ours (${self.sessionId})`
+    };
+  }
+  if (identity.role === "reader" && self.role && self.role !== "reader") {
+    return {
+      allowed: false,
+      reason: `bundle carries a reader-scoped token but this session is a ${self.role}`
+    };
+  }
+  return { allowed: true };
+}
+function applyBundleGithubToken(bundle, self) {
+  if (!bundle.githubToken) return { written: false, reason: "bundle carried no GitHub token" };
+  const permitted = bundleMayWriteGithubFiles(bundle, self);
+  if (!permitted.allowed) {
+    return { written: false, ...permitted.reason ? { reason: permitted.reason } : {} };
+  }
+  syncGithubTokenFiles(bundle.githubToken);
+  return { written: true };
+}
+function syncBundleGithubToken(token) {
+  syncGithubTokenFiles(token);
+}
+
+// src/connection/agent-connection.ts
+var logger = createServiceLogger("agent-connection");
+var EVENT_BATCH_MS = 500;
+var MAX_EVENT_BUFFER = 5e3;
+var TOKEN_REFRESH_INTERVAL_MS = 45 * 60 * 1e3;
+var AgentConnection = class _AgentConnection {
+  socket = null;
+  config;
+  eventBuffer = [];
+  flushTimer = null;
+  tokenRefreshTimer = null;
+  lastEmittedStatus = null;
+  lastReportedStatus = null;
+  droppedEventCount = 0;
+  // Pending answer resolvers for askUserQuestion room-event fallback
+  pendingAnswerResolvers = /* @__PURE__ */ new Map();
+  // Dedup: suppress near-identical messages within a short window
+  recentMessages = [];
+  static DEDUP_WINDOW_MS = 3e4;
+  static DEDUP_SIMILARITY_THRESHOLD = 0.7;
+  static DEDUP_PREVIEW_LIMIT = 120;
+  // Early-buffering: events that arrive before callbacks are registered
+  earlyMessages = [];
+  earlyStop = false;
+  earlySoftStop = false;
+  earlyModeChanges = [];
+  // Registered callbacks
+  messageCallback = null;
+  stopCallback = null;
+  softStopCallback = null;
+  modeChangeCallback = null;
+  apiKeyUpdateCallback = null;
+  pullBranchCallback = null;
+  runStartCommandCallback = null;
+  earlyRunStartCommand = false;
+  earlyPullBranches = [];
+  spawnReviewCallback = null;
+  earlySpawnReviews = [];
+  spawnBuilderCallback = null;
+  earlySpawnBuilders = [];
+  spawnTuiCallback = null;
+  earlySpawnTuis = [];
+  probeUsageCallback = null;
+  earlyProbeUsage = false;
+  // PTY relay (S5 terminal). Single-slot callbacks, set per PtySession run.
+  ptyInputCallback = null;
+  ptyResizeCallback = null;
+  constructor(config) {
+    this.config = config;
+  }
+  get sessionId() {
+    return this.config.sessionId;
+  }
+  get connected() {
+    return this.socket?.connected ?? false;
+  }
+  // ── Typed service method call ──────────────────────────────────────────
+  // Socket.IO keeps the SAME Socket instance across transport-level
+  // reconnects (it only goes null on an explicit disconnect() teardown), so a
+  // brief flap leaves `this.socket` non-null but `.connected === false`. Rather
+  // than failing a tool call instantly (which the spawned `claude` surfaces as
+  // "Conveyor MCP disconnected" and an excuse to go idle), we wait out a short
+  // reconnect window, then emit with an ack timeout so a buffered packet whose
+  // ack never returns can't hang the call forever. We do NOT auto-retry the
+  // emit — re-sending a write could double-apply it; the agent prompt instructs
+  // the model to retry the tool, which is the safe place to decide idempotency.
+  static CALL_CONNECT_WAIT_MS = 2e4;
+  static CALL_ACK_TIMEOUT_MS = 3e4;
+  // ── Proactive socket recycle ───────────────────────────────────────────
+  // Cloud Run severs every WebSocket at its request timeout (3600s is the
+  // platform ceiling), so a socket that lives past ~60 minutes is killed at a
+  // random moment — historically mid-tool-call, which let the spawned CLI
+  // abandon its MCP session. Recycle the transport at a QUIET moment (no
+  // in-flight RPC) before the platform deadline instead: an engine-level close
+  // looks like a transport drop, so Socket.IO's auto-reconnect and the
+  // io "reconnect" → reconnectToSession() recovery path run unchanged. Jitter
+  // keeps a fleet of pods from recycling in one thundering herd.
+  static SOCKET_RECYCLE_BASE_MS = 52 * 60 * 1e3;
+  static SOCKET_RECYCLE_JITTER_MS = 4 * 60 * 1e3;
+  static SOCKET_RECYCLE_BUSY_POLL_MS = 15e3;
+  recycleTimer = null;
+  pendingCalls = 0;
+  async call(method, payload) {
+    const socket = this.socket;
+    if (!socket) {
+      throw new Error(
+        `Not connected (method: ${String(method)}, session: ${this.config.sessionId})`
+      );
+    }
+    this.pendingCalls++;
+    try {
+      if (!socket.connected) {
+        await this.waitForConnected(socket, _AgentConnection.CALL_CONNECT_WAIT_MS, String(method));
+      }
+      return await this.emitWithAck(socket, method, payload);
+    } finally {
+      this.pendingCalls--;
+    }
+  }
+  /** (Re)arm the recycle timer — called on every successful (re)connect. */
+  scheduleSocketRecycle() {
+    this.clearSocketRecycle();
+    const delay2 = _AgentConnection.SOCKET_RECYCLE_BASE_MS + Math.random() * _AgentConnection.SOCKET_RECYCLE_JITTER_MS;
+    this.armRecycleTimer(delay2);
+  }
+  clearSocketRecycle() {
+    if (this.recycleTimer) {
+      clearTimeout(this.recycleTimer);
+      this.recycleTimer = null;
+    }
+  }
+  armRecycleTimer(delay2) {
+    this.recycleTimer = setTimeout(() => {
+      this.recycleTimer = null;
+      this.attemptSocketRecycle();
+    }, delay2);
+    this.recycleTimer.unref?.();
+  }
+  attemptSocketRecycle() {
+    const socket = this.socket;
+    if (!socket?.connected) return;
+    if (this.pendingCalls > 0) {
+      this.armRecycleTimer(_AgentConnection.SOCKET_RECYCLE_BUSY_POLL_MS);
+      return;
+    }
+    process.stderr.write(
+      "[conveyor-agent] Recycling socket ahead of the platform request timeout\n"
+    );
+    socket.io.engine?.close?.();
+  }
+  /** Resolve once `socket` reports connected, or reject after `timeoutMs`. */
+  waitForConnected(socket, timeoutMs, method) {
+    return waitForConnected(socket, timeoutMs, () => {
+      return new Error(
+        `Not connected \u2014 socket did not reconnect within ${timeoutMs / 1e3}s (method: ${method}, session: ${this.config.sessionId}). Transient; retry.`
+      );
+    });
+  }
+  /** Emit an RPC and resolve on ack, rejecting if no ack arrives in time. */
+  emitWithAck(socket, method, payload) {
+    return callWithAck(
+      socket,
+      `agentSessionService:${String(method)}`,
+      payload,
+      {
+        timeoutMs: _AgentConnection.CALL_ACK_TIMEOUT_MS,
+        requireData: true,
+        makeTimeoutError: () => new Error(
+          `Service call timed out after ${_AgentConnection.CALL_ACK_TIMEOUT_MS / 1e3}s (method: ${String(method)}, session: ${this.config.sessionId}). Usually a transient reconnect; retry.`
+        ),
+        makeFailureError: (error) => new Error(error ?? `Service call failed: ${String(method)}`)
+      }
+    );
+  }
+  // ── Connection lifecycle ───────────────────────────────────────────────
+  // oxlint-disable-next-line max-lines-per-function -- socket setup requires registering many co-located event handlers
+  connect() {
+    if (!this.config.apiUrl) {
+      return Promise.reject(new Error("Cannot connect: apiUrl is empty"));
+    }
+    this.startProactiveTokenRefresh();
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let attempts = 0;
+      const maxInitialAttempts = 30;
+      process.stderr.write(
+        `[conveyor-agent] Connecting to ${this.config.apiUrl} (mode: ${this.config.runnerMode ?? "task"}, session: ${this.config.sessionId})
+`
+      );
+      this.socket = io(
+        this.config.apiUrl,
+        buildConveyorSocketOptions({
+          taskToken: this.config.taskToken,
+          runnerMode: this.config.runnerMode ?? "task"
+        })
+      );
+      this.socket.on("session:message", (msg) => {
+        const incoming = {
+          content: msg.content,
+          userId: msg.userId,
+          ...msg.source && { source: msg.source },
+          ...msg.files && { files: msg.files },
+          ...msg.delivery === "prefill" && { delivery: msg.delivery }
+        };
+        if (this.messageCallback) this.messageCallback(incoming);
+        else this.earlyMessages.push(incoming);
+      });
+      this.socket.on("session:stop", () => {
+        if (this.stopCallback) this.stopCallback();
+        else this.earlyStop = true;
+      });
+      this.socket.on("session:softStop", () => {
+        if (this.softStopCallback) this.softStopCallback();
+        else this.earlySoftStop = true;
+      });
+      this.socket.on("session:modeChange", (data) => {
+        if (this.modeChangeCallback) this.modeChangeCallback(data);
+        else this.earlyModeChanges.push(data);
+      });
+      this.socket.on(
+        "session:answerQuestion",
+        (data) => {
+          const resolver = this.pendingAnswerResolvers.get(data.requestId);
+          if (resolver) resolver(data.answers);
+        }
+      );
+      this.socket.on("agentRunner:updateApiKey", (data) => {
+        if (this.apiKeyUpdateCallback) this.apiKeyUpdateCallback(data);
+      });
+      this.socket.on("session:pullBranch", (data) => {
+        if (this.pullBranchCallback) this.pullBranchCallback(data);
+        else this.earlyPullBranches.push(data);
+      });
+      this.socket.on("session:spawnReview", (data) => {
+        if (this.spawnReviewCallback) this.spawnReviewCallback(data);
+        else this.earlySpawnReviews.push(data);
+      });
+      this.socket.on("session:spawnBuilder", (data) => {
+        if (this.spawnBuilderCallback) this.spawnBuilderCallback(data);
+        else this.earlySpawnBuilders.push(data);
+      });
+      this.socket.on("session:spawnTui", (data) => {
+        if (this.spawnTuiCallback) this.spawnTuiCallback(data);
+        else this.earlySpawnTuis.push(data);
+      });
+      this.socket.on("session:probeUsage", () => {
+        if (this.probeUsageCallback) this.probeUsageCallback();
+        else this.earlyProbeUsage = true;
+      });
+      this.socket.on("session:runStartCommand", () => {
+        if (this.runStartCommandCallback) this.runStartCommandCallback();
+        else this.earlyRunStartCommand = true;
+      });
+      this.socket.on("pty:input", (data) => {
+        if (data.sessionId && data.sessionId !== this.config.sessionId) return;
+        this.ptyInputCallback?.(data.data);
+      });
+      this.socket.on("pty:resize", (data) => {
+        if (data.sessionId && data.sessionId !== this.config.sessionId) return;
+        this.ptyResizeCallback?.(data.cols, data.rows);
+      });
+      this.socket.on("connect", () => {
+        process.stderr.write("[conveyor-agent] Socket connected\n");
+        this.scheduleSocketRecycle();
+        if (!settled) {
+          settled = true;
+          resolve();
+        }
+      });
+      this.socket.on("connect_error", (err) => {
+        attempts++;
+        process.stderr.write(
+          `[conveyor-agent] Connection error (attempt ${attempts}/${maxInitialAttempts}): ${err.message}
+`
+        );
+        if (!settled && attempts >= maxInitialAttempts) {
+          settled = true;
+          reject(
+            new Error(
+              `Failed to connect to ${this.config.apiUrl} after ${maxInitialAttempts} attempts: ${err.message}`
+            )
+          );
+        }
+      });
+      this.socket.on("disconnect", (reason) => {
+        process.stderr.write(`[conveyor-agent] Disconnected: ${reason}
+`);
+        if (reason === "io server disconnect" || reason === "server namespace disconnect") {
+          this.scheduleReconnectAfterServerDisconnect();
+        }
+      });
+      this.socket.on("auth:rejected", () => {
+        process.stderr.write("[conveyor-agent] Auth rejected by server, refreshing taskToken\n");
+        void this.refreshTaskTokenFromBootstrap().catch(() => {
+        });
+      });
+      this.socket.io.on("reconnect", (reconnectAttempts) => {
+        process.stderr.write(
+          `[conveyor-agent] Reconnected (attempts: ${reconnectAttempts}, ${(/* @__PURE__ */ new Date()).toISOString()})
+`
+        );
+        this.sendHeartbeat();
+        void this.reconnectToSession();
+      });
+      this.socket.io.on("reconnect_attempt", () => {
+      });
+    });
+  }
+  disconnect() {
+    this.stopProactiveTokenRefresh();
+    this.clearSocketRecycle();
+    this.stopHeartbeatWorker();
+    void this.flushEvents();
+    if (this.socket) {
+      this.socket.io.reconnection(false);
+      this.socket.removeAllListeners();
+      this.socket.disconnect();
+      this.socket = null;
+    }
+  }
+  // ── Reconnect with retry ────────────────────────────────────────────
+  //
+  // Socket.IO already retries the transport forever. This higher-level helper
+  // re-issues the `connectAgent` RPC after a successful reconnect to re-join
+  // the session room and drain pending messages. We retry indefinitely with a
+  // capped exponential backoff — a stranded codespace with a missing agent is
+  // worse than a long-running reconnect loop, and a transient API outage
+  // shouldn't kill the agent process.
+  static RECONNECT_BASE_DELAY_MS = 2e3;
+  static RECONNECT_MAX_DELAY_MS = 6e4;
+  static RECONNECT_STATUS_EVERY_N = 3;
+  isReconnecting = false;
+  reconnectingAfterServerDisconnect = false;
+  /** Capped exponential backoff (2s, 4s, 8s, 16s, 32s, then 60s steady) shared
+   *  by both reconnect loops (connectAgent-RPC and server-disconnect). */
+  static backoffDelayMs(attempt) {
+    return Math.min(
+      _AgentConnection.RECONNECT_BASE_DELAY_MS * 2 ** Math.min(attempt - 1, 5),
+      _AgentConnection.RECONNECT_MAX_DELAY_MS
+    );
+  }
+  /** Sleep `ms`, unref'd so it never holds the process open on its own. */
+  static delay(ms) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(resolve, ms);
+      timer.unref?.();
+    });
+  }
+  /**
+   * Invoked after every successful session reconnect (the `connectAgent` RPC
+   * re-established the session room). The runner uses this to force a TUI
+   * repaint: the reconnect may have landed on a different/restarted API
+   * process whose PTY scrollback ring is empty, and a quiet terminal would
+   * otherwise never re-seed it.
+   */
+  onReconnected;
+  async reconnectToSession() {
+    if (this.isReconnecting) return;
+    this.isReconnecting = true;
+    try {
+      let attempt = 0;
+      while (this.socket) {
+        attempt++;
+        try {
+          const { pendingMessages } = await this.call("connectAgent", {
+            sessionId: this.config.sessionId
+          });
+          this.drainPendingMessages(pendingMessages);
+          process.stderr.write(
+            `[conveyor-agent] Reconnected to session successfully (attempts: ${attempt})
+`
+          );
+          if (this.lastEmittedStatus && this.lastEmittedStatus !== this.lastReportedStatus) {
+            const status = this.lastEmittedStatus;
+            void this.call("reportAgentStatus", {
+              sessionId: this.config.sessionId,
+              status
+            }).then(() => {
+              this.lastReportedStatus = status;
+            }).catch(() => {
+            });
+          }
+          this.sendEvent({
+            type: "agent_runner_status",
+            reason: "reconnected",
+            attempts: attempt
+          });
+          try {
+            this.onReconnected?.();
+          } catch {
+          }
+          return;
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          const delayMs = _AgentConnection.backoffDelayMs(attempt);
+          process.stderr.write(
+            `[conveyor-agent] connectAgent failed (attempt ${attempt}): ${errMsg} \u2014 retrying in ${delayMs / 1e3}s
+`
+          );
+          if (this.looksLikeAuthError(errMsg)) {
+            void this.refreshTaskTokenFromBootstrap().catch(() => {
+            });
+          }
+          if (attempt % _AgentConnection.RECONNECT_STATUS_EVERY_N === 0) {
+            this.sendEvent({
+              type: "agent_runner_status",
+              reason: "reconnecting",
+              attempt
+            });
+          }
+          await _AgentConnection.delay(delayMs);
+        }
+      }
+    } finally {
+      this.isReconnecting = false;
+    }
+  }
+  /**
+   * Drive a bounded reconnect after a server-initiated disconnect. Loops until
+   * the socket reconnects or is torn down, nudging socket.connect() on each
+   * pass with a capped exponential backoff. A token refresh is attempted every
+   * pass (rate-limited to once/60s inside refreshTaskTokenFromBootstrap) but
+   * its result NEVER gates the reconnect — the socket must recover even when
+   * there is no fresh token to apply.
+   */
+  scheduleReconnectAfterServerDisconnect() {
+    if (this.reconnectingAfterServerDisconnect) return;
+    this.reconnectingAfterServerDisconnect = true;
+    void this.reconnectAfterServerDisconnect().finally(() => {
+      this.reconnectingAfterServerDisconnect = false;
+    });
+  }
+  async reconnectAfterServerDisconnect() {
+    let attempt = 0;
+    while (this.socket && !this.socket.connected) {
+      attempt++;
+      try {
+        await this.refreshTaskTokenFromBootstrap();
+      } catch {
+      }
+      const socket = this.socket;
+      if (!socket || socket.connected) return;
+      socket.connect();
+      try {
+        await this.waitForConnected(
+          socket,
+          _AgentConnection.CALL_CONNECT_WAIT_MS,
+          "server-disconnect-reconnect"
+        );
+        this.sendHeartbeat();
+        void this.reconnectToSession();
+        return;
+      } catch {
+        const delayMs = _AgentConnection.backoffDelayMs(attempt);
+        process.stderr.write(
+          `[conveyor-agent] server-disconnect reconnect attempt ${attempt} did not connect within ${_AgentConnection.CALL_CONNECT_WAIT_MS / 1e3}s \u2014 retrying in ${delayMs / 1e3}s
+`
+        );
+        await _AgentConnection.delay(delayMs);
+      }
+    }
+  }
+  looksLikeAuthError(message) {
+    return /unauthor|forbid|auth|token|session (?:not found|expired|invalid)|invalid session/i.test(
+      message
+    );
+  }
+  // ── Proactive task-token refresh ────────────────────────────────────────
+  //
+  // Socket.IO only re-presents the taskToken on a (re)connect handshake, and
+  // the server only re-validates the JWT then. So a token that expires while
+  // the socket stays connected goes unnoticed until the next RPC fails. Re-mint
+  // periodically from the bootstrap endpoint — refreshFromBootstrap() updates
+  // both this.config.taskToken and socket.auth.taskToken, so any later
+  // reconnect carries a fresh token. No-ops for project mode / missing
+  // codespace env, and is rate-limited to once/60s inside refreshFromBootstrap.
+  startProactiveTokenRefresh() {
+    if (this.tokenRefreshTimer) return;
+    this.tokenRefreshTimer = setInterval(() => {
+      void this.refreshTaskTokenFromBootstrap().catch(() => {
+      });
+    }, TOKEN_REFRESH_INTERVAL_MS);
+    this.tokenRefreshTimer.unref?.();
+  }
+  stopProactiveTokenRefresh() {
+    if (this.tokenRefreshTimer) {
+      clearInterval(this.tokenRefreshTimer);
+      this.tokenRefreshTimer = null;
+    }
+  }
+  drainPendingMessages(messages) {
+    for (const msg of messages) {
+      if (!msg.content) continue;
+      if (this.messageCallback) {
+        this.messageCallback({ content: msg.content, userId: msg.userId });
+      } else {
+        this.earlyMessages.push({ content: msg.content, userId: msg.userId });
+      }
+    }
+  }
+  // ── Callback registration with early-buffer draining ───────────────
+  onMessage(callback) {
+    this.messageCallback = callback;
+    for (const msg of this.earlyMessages) callback(msg);
+    this.earlyMessages = [];
+  }
+  onStop(callback) {
+    this.stopCallback = callback;
+    if (this.earlyStop) {
+      callback();
+      this.earlyStop = false;
+    }
+  }
+  onSoftStop(callback) {
+    this.softStopCallback = callback;
+    if (this.earlySoftStop) {
+      callback();
+      this.earlySoftStop = false;
+    }
+  }
+  onModeChange(callback) {
+    this.modeChangeCallback = callback;
+    for (const data of this.earlyModeChanges) callback(data);
+    this.earlyModeChanges = [];
+  }
+  onApiKeyUpdate(callback) {
+    this.apiKeyUpdateCallback = callback;
+  }
+  onPullBranch(callback) {
+    this.pullBranchCallback = callback;
+    for (const data of this.earlyPullBranches) callback(data);
+    this.earlyPullBranches = [];
+  }
+  onSpawnReview(callback) {
+    this.spawnReviewCallback = callback;
+    for (const data of this.earlySpawnReviews) callback(data);
+    this.earlySpawnReviews = [];
+  }
+  /** Mirror of onSpawnReview for the Builder handoff. Drains the early buffer
+   *  so a Build pressed during boot is not lost. */
+  onSpawnBuilder(callback) {
+    this.spawnBuilderCallback = callback;
+    for (const data of this.earlySpawnBuilders) callback(data);
+    this.earlySpawnBuilders = [];
+  }
+  /**
+   * Report that a same-pod review child failed to spawn (fire-and-forget).
+   * The server Ends the orphaned review session and falls back to a dedicated
+   * review pod. sessionId is OUR (builder) session — the task-identity guard runs on
+   * it; the review session is identified separately.
+   */
+  reportReviewSpawnFailure(reviewSessionId, error) {
+    if (!this.socket) return;
+    void this.call("reportReviewSpawnFailure", {
+      sessionId: this.config.sessionId,
+      reviewSessionId,
+      ...error ? { error: error.slice(0, 2e3) } : {}
+    }).catch(() => {
+    });
+  }
+  /**
+   * Report that this (planner) pod could not spawn the Builder child, so the
+   * server can End the orphaned build session and reopen the card instead of
+   * leaving it InProgress with a Builder tab that never appears.
+   *
+   * sessionId is OUR (planner) session — the task-identity guard runs on it;
+   * the build session is identified separately.
+   */
+  reportBuilderSpawnFailure(buildSessionId, error) {
+    if (!this.socket) return;
+    void this.call("reportBuilderSpawnFailure", {
+      sessionId: this.config.sessionId,
+      buildSessionId,
+      ...error ? { error: error.slice(0, 2e3) } : {}
+    }).catch(() => {
+    });
+  }
+  /**
+   * Report that this pod's git credential is dead and refreshing did not fix
+   * it (fire-and-forget).
+   *
+   * Purely diagnostic. Until this existed a pod could lose git entirely and
+   * leave no server-side trace at all — the refresh RPC succeeded every time,
+   * so the failure was visible only in pod stderr, which is why it took two
+   * investigations to attribute. `tokenShape` describes the served credential
+   * (length, prefix class, mtime) and NEVER carries its value.
+   */
+  reportCredentialFailure(details) {
+    if (!this.socket) return;
+    void this.call("reportCredentialFailure", {
+      sessionId: this.config.sessionId,
+      ...details.error ? { error: details.error.slice(0, 2e3) } : {},
+      ...details.tokenShape ? { tokenShape: details.tokenShape.slice(0, 500) } : {},
+      ...details.healed === void 0 ? {} : { healed: details.healed }
+    }).catch(() => {
+    });
+  }
+  /**
+   * Ask the server to destroy and recreate this pod (fire-and-forget). The
+   * agent calls this only when it has proven it cannot recover in place — the
+   * shared `~/.claude` GCS FUSE mount is dead and no in-container action can
+   * remount it. The server rate-limits the recycle and posts `reason` to the
+   * card; old servers that don't know the method reject harmlessly, leaving
+   * today's behavior (a failed turn with a chat warning).
+   */
+  requestWorkspaceRecycle(reason) {
+    if (!this.socket) return;
+    void this.call("requestWorkspaceRecycle", {
+      sessionId: this.config.sessionId,
+      reason: reason.slice(0, 2e3)
+    }).catch(() => {
+    });
+  }
+  onSpawnTui(callback) {
+    this.spawnTuiCallback = callback;
+    for (const data of this.earlySpawnTuis) callback(data);
+    this.earlySpawnTuis = [];
+  }
+  /** Register the on-demand usage-refresh handler; drains an early-buffered
+   *  `session:probeUsage` that arrived before the runner was ready. */
+  onProbeUsage(callback) {
+    this.probeUsageCallback = callback;
+    if (this.earlyProbeUsage) {
+      this.earlyProbeUsage = false;
+      callback();
+    }
+  }
+  /**
+   * Report that a same-pod TUI/shell child failed to spawn (fire-and-forget).
+   * The server Ends the orphaned session — no fallback pod (unlike review).
+   * sessionId is OUR (builder) session — the task-identity guard runs on it.
+   */
+  reportSessionSpawnFailure(spawnedSessionId, error) {
+    if (!this.socket) return;
+    void this.call("reportSessionSpawnFailure", {
+      sessionId: this.config.sessionId,
+      spawnedSessionId,
+      ...error ? { error: error.slice(0, 2e3) } : {}
+    }).catch(() => {
+    });
+  }
+  /** Register the restart handler, draining a `session:runStartCommand` that
+   *  arrived before the supervisor was ready. Collapsed to one drain: two
+   *  clicks during boot should produce one restart, not two competing ones. */
+  onRunStartCommand(callback) {
+    this.runStartCommandCallback = callback;
+    if (this.earlyRunStartCommand) {
+      this.earlyRunStartCommand = false;
+      callback();
+    }
+  }
+  // ── PTY relay (S5 Connected-TUI terminal) ──────────────────────────
+  /**
+   * Forward a raw chunk of terminal output to the S2 relay (fire-and-forget).
+   * The first chunk creates the server-side scrollback ring, which is what
+   * surfaces the terminal in the UI. `dims` seed/refresh the ring geometry.
+   */
+  sendPtyOutput(data, dims) {
+    if (!this.socket) return;
+    void this.call("ptyOutput", {
+      sessionId: this.config.sessionId,
+      data,
+      ...dims ? { cols: dims.cols, rows: dims.rows } : {}
+    }).catch(() => {
+    });
+  }
+  /**
+   * Forward one compact chat-proxy event derived from the transcript JSONL to
+   * the relay (fire-and-forget). Feeds the experimental chat PTY proxy ring.
+   * Old servers that don't know the method reject harmlessly.
+   */
+  sendPtyChatEvent(event) {
+    if (!this.socket) return;
+    void this.call("ptyChatEvent", {
+      sessionId: this.config.sessionId,
+      event
+    }).catch(() => {
+    });
+  }
+  /**
+   * Report that the interactive CLI process for this session has died and no
+   * respawn is imminent (fire-and-forget). The server clears the scrollback
+   * ring and broadcasts pty:ended so clients hide the Connected-TUI tab. Old
+   * servers that don't know the method reject harmlessly.
+   */
+  sendPtyEnded() {
+    if (!this.socket) return;
+    void this.call("ptyEnded", { sessionId: this.config.sessionId }).catch(() => {
+    });
+  }
+  /**
+   * Report the port this pod's in-pod PTY stream server bound to, or null when
+   * it stopped (fire-and-forget). The server persists it so a viewer can be
+   * handed a port-scoped tunnel URL and stream the TUI straight from the pod.
+   * Old servers that don't know the method reject harmlessly — the session then
+   * just stays on the relay transport.
+   */
+  reportPtyStream(port) {
+    if (!this.socket) return;
+    void this.call("reportPtyStream", {
+      sessionId: this.config.sessionId,
+      port
+    }).catch(() => {
+    });
+  }
+  /** Subscribe to relayed keystrokes. Returns an unsubscribe fn. */
+  onPtyInput(handler) {
+    this.ptyInputCallback = handler;
+    return () => {
+      if (this.ptyInputCallback === handler) this.ptyInputCallback = null;
+    };
+  }
+  /** Subscribe to relayed (reconciled) terminal resizes. Returns an unsubscribe fn. */
+  onPtyResize(handler) {
+    this.ptyResizeCallback = handler;
+    return () => {
+      if (this.ptyResizeCallback === handler) this.ptyResizeCallback = null;
+    };
+  }
+  // ── Convenience methods (thin wrappers around call / emit) ─────────
+  async emitStatus(status, reason, questionText) {
+    this.lastEmittedStatus = status;
+    await this.flushEvents();
+    const payload = {
+      sessionId: this.config.sessionId,
+      status,
+      ...reason ? { reason } : {},
+      // Only sent with a pending TUI questionnaire (reason "user_question") so
+      // the server can surface the real question text in the notification.
+      ...questionText ? { questionText } : {}
+    };
+    const AWAIT_STATUSES = ["idle", "waiting_for_input", "connected"];
+    if (AWAIT_STATUSES.includes(status)) {
+      try {
+        await this.call("reportAgentStatus", payload);
+        this.lastReportedStatus = status;
+      } catch {
+      }
+    } else {
+      void this.call("reportAgentStatus", payload).then(() => {
+        this.lastReportedStatus = status;
+      }).catch(() => {
+      });
+    }
+  }
+  postChatMessage(content, milestone) {
+    if (!this.socket) return;
+    if (this.suppressIfDuplicate(content)) return;
+    void this.call("postAgentMessage", {
+      sessionId: this.config.sessionId,
+      content,
+      milestone
+    }).catch(() => {
+    });
+  }
+  // Awaitable variant of postChatMessage for callers that need to guarantee
+  // the message is acknowledged by the server before proceeding (e.g. before
+  // aborting the session). Dedup still applies; a suppressed message resolves
+  // immediately without hitting the wire.
+  async postChatMessageAwait(content, milestone) {
+    if (!this.socket) return;
+    if (this.suppressIfDuplicate(content)) return;
+    try {
+      await this.call("postAgentMessage", {
+        sessionId: this.config.sessionId,
+        content,
+        milestone
+      });
+    } catch (err) {
+      process.stderr.write(
+        `[conveyor-agent] postChatMessageAwait failed: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  suppressIfDuplicate(content) {
+    const d = this.checkAndTrackDuplicate(content);
+    if (!d.duplicate) return false;
+    process.stderr.write(
+      `[dedup] Suppressed near-duplicate (matched: "${d.matchedMessagePreview}")
+`
+    );
+    return true;
+  }
+  // Exposed so `post_to_chat` can surface suppression back to the agent.
+  checkAndTrackDuplicate(content) {
+    const now = Date.now();
+    this.recentMessages = this.recentMessages.filter(
+      (m) => now - m.timestamp < _AgentConnection.DEDUP_WINDOW_MS
+    );
+    const words = new Set(
+      content.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/).filter((w) => w.length >= 3)
+    );
+    if (words.size === 0) return { duplicate: false };
+    for (const recent of this.recentMessages) {
+      let intersection = 0;
+      for (const w of words) if (recent.words.has(w)) intersection++;
+      const union = (/* @__PURE__ */ new Set([...words, ...recent.words])).size;
+      if (union > 0 && intersection / union > _AgentConnection.DEDUP_SIMILARITY_THRESHOLD) {
+        return { duplicate: true, matchedMessagePreview: recent.preview };
+      }
+    }
+    const max = _AgentConnection.DEDUP_PREVIEW_LIMIT;
+    const preview = content.length > max ? content.slice(0, max) + "\u2026" : content;
+    this.recentMessages.push({ words, timestamp: now, preview });
+    if (this.recentMessages.length > 3) this.recentMessages.shift();
+    return { duplicate: false };
+  }
+  /**
+   * @param loopStatus overrides the status derived from the last emitted
+   *   runner status. SessionRunner passes it so an idle runner that still has
+   *   background work outstanding in the pod beats as `waiting` (→ `active` on
+   *   the wire) rather than `idle`, which would let the workspace activity
+   *   clock expire mid-gate. See connection/loop-lag.ts `heartbeatStatusFor`.
+   *
+   * Without an override the status comes from `loopStatusForRunnerStatus`, the
+   * same total classifier SessionRunner uses, so both paths agree. This used to
+   * be a partial map covering 5 of the 11 `AgentRunnerStatus` values with a
+   * `?? "active"` fallback, which meant a parked runner (`waiting_for_input`,
+   * `finished`, `error`, `stopping`, `disconnected`) beat as ACTIVE on every
+   * no-arg call site — the reconnect paths below, and the shell/project/adhoc
+   * runners, which never pass a loop status at all. That renewed the workspace
+   * activity clock for an agent doing nothing, so the card stayed "active" and
+   * its pod stayed up long past the project's inactivity window.
+   */
+  sendHeartbeat(loopLagMs, loopStatus) {
+    if (!this.socket) return;
+    const heartbeatStatus = heartbeatStatusFor(
+      loopStatus ?? loopStatusForRunnerStatus(this.lastEmittedStatus)
+    );
+    void this.call("heartbeat", {
+      sessionId: this.config.sessionId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      status: heartbeatStatus,
+      ...loopLagMs !== void 0 && loopLagMs > 0 ? { loopLagMs: Math.round(loopLagMs) } : {}
+    }).catch(() => {
+    });
+  }
+  // ── Starvation-proof heartbeat worker ────────────────────────────────
+  //
+  // A worker thread with its own event loop + Socket.IO connection keeps the
+  // v3 session lease renewed even when the MAIN loop is stalled (the failure
+  // mode where a heavy gate got the session declared stranded and restarted
+  // mid-run). Best-effort by design: any spawn/runtime failure just degrades
+  // heartbeats to main-loop-only. See heartbeat-worker.ts for the policy.
+  heartbeatWorker = null;
+  startHeartbeatWorker(sharedBuffer, intervalMs = 3e4) {
+    if (this.heartbeatWorker) return;
+    try {
+      const workerUrl = new URL("./heartbeat-worker.js", import.meta.url);
+      if (!existsSync(fileURLToPath(workerUrl))) {
+        process.stderr.write(
+          "[conveyor-agent] heartbeat worker bundle not found \u2014 main-loop heartbeat only\n"
+        );
+        return;
+      }
+      const worker = new Worker(workerUrl, {
+        workerData: {
+          apiUrl: this.config.apiUrl,
+          taskToken: this.config.taskToken,
+          sessionId: this.config.sessionId,
+          runnerMode: this.config.runnerMode ?? "task",
+          sharedBuffer,
+          intervalMs
+        }
+      });
+      worker.unref();
+      worker.on("error", (err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[conveyor-agent] heartbeat worker error: ${message}
+`);
+        this.heartbeatWorker = null;
+      });
+      worker.on("exit", (code) => {
+        if (code !== 0) {
+          process.stderr.write(`[conveyor-agent] heartbeat worker exited (code ${code})
+`);
+        }
+        this.heartbeatWorker = null;
+      });
+      this.heartbeatWorker = worker;
+      process.stderr.write("[conveyor-agent] heartbeat worker started\n");
+    } catch (err) {
+      process.stderr.write(
+        `[conveyor-agent] heartbeat worker failed to start: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      this.heartbeatWorker = null;
+    }
+  }
+  stopHeartbeatWorker() {
+    const worker = this.heartbeatWorker;
+    this.heartbeatWorker = null;
+    if (worker) void worker.terminate();
+  }
+  emitModeChanged(agentMode) {
+    this.sendEvent({ type: "mode_changed", agentMode });
+  }
+  async updateTaskFields(fields) {
+    if (!this.socket) return { ok: false, error: "socket not connected" };
+    try {
+      await this.call("updateTaskFields", { sessionId: this.config.sessionId, ...fields });
+      return { ok: true };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  storeSessionId(sdkSessionId) {
+    void this.call("storeSessionId", { sessionId: this.config.sessionId, sdkSessionId }).catch(
+      () => {
+      }
+    );
+  }
+  /** Report the full current set of runtime-discovered listening ports.
+   *  Throws on failure so the PortDiscovery poller can retry on its next
+   *  tick (a swallowed error here would silently drop the delta). */
+  async reportDiscoveredPorts(ports) {
+    await this.call("reportDiscoveredPorts", { sessionId: this.config.sessionId, ports });
+  }
+  /** Boot-milestone report over the socket — the codespace-parity fallback
+   *  for the GKE pod bootstrap-token route. Fire-and-forget: a failed report
+   *  must never delay or fail the boot path. */
+  reportBootMilestone(key) {
+    void this.call("reportBootMilestone", { sessionId: this.config.sessionId, key }).catch(
+      () => {
+      }
+    );
+  }
+  // ── Typing indicators ───────────────────────────────────────────────
+  sendTypingStart() {
+    this.sendEvent({ type: "agent_typing_start" });
+  }
+  sendTypingStop() {
+    this.sendEvent({ type: "agent_typing_stop" });
+  }
+  // ── RPC convenience wrappers (v6 compat, will migrate to call()) ───
+  emitRateLimitPause(resetsAt) {
+    this.sendEvent({ type: "rate_limit_update", resetsAt });
+  }
+  updateStatus(status) {
+    this.emitStatus(status);
+  }
+  /**
+   * The session's key hit a hard usage cap — ask the server to stamp it
+   * limited and hand back the best remaining key's credential env (or a
+   * requeue confirmation when none is left). Awaited: the caller swaps
+   * credentials and resumes on success, so it needs the real response.
+   */
+  async cycleCodingAgentKey(rateLimitType, resetsAt) {
+    return await this.call("cycleCodingAgentKey", {
+      sessionId: this.config.sessionId,
+      rateLimitType,
+      ...resetsAt ? { resetsAt } : {}
+    });
+  }
+  // ── Question handling ──────────────────────────────────────────────
+  async askUserQuestion(questions) {
+    const questionText = questions.map(
+      (q) => `**${q.header}**
+${q.question}${q.options.length ? "\n" + q.options.map((o) => `- ${o.label}: ${o.description}`).join("\n") : ""}`
+    ).join("\n\n");
+    const requestId = crypto.randomUUID();
+    const roomEventPromise = new Promise((resolve) => {
+      this.pendingAnswerResolvers.set(requestId, resolve);
+    });
+    const rpcPromise = this.call("askUserQuestion", {
+      sessionId: this.config.sessionId,
+      question: questionText,
+      requestId,
+      questions
+    }).then((res) => res.answers);
+    try {
+      return await Promise.race([rpcPromise, roomEventPromise]);
+    } finally {
+      this.pendingAnswerResolvers.delete(requestId);
+    }
+  }
+  // ── Typed service method wrappers ───────────────────────────────────
+  getTaskProperties() {
+    return this.call("getTaskProperties", { sessionId: this.config.sessionId });
+  }
+  triggerIdentification() {
+    return this.call("triggerIdentification", { sessionId: this.config.sessionId });
+  }
+  handoffToImplementer(payload) {
+    return this.call("handoffToImplementer", {
+      sessionId: this.config.sessionId,
+      ...payload
+    });
+  }
+  async refreshAuthToken() {
+    const result = await this.refreshFromBootstrap();
+    return result.refreshedClaude;
+  }
+  /**
+   * Refresh the in-process `CONVEYOR_TASK_TOKEN` from the bootstrap endpoint.
+   * Returns true if a new token was applied. Rate-limited locally to once per
+   * 60s so a tight auth-rejected loop can't hammer the bootstrap endpoint —
+   * the server enforces the same window via `lastBootstrapAt`.
+   */
+  lastTaskTokenRefreshAt = 0;
+  async refreshTaskTokenFromBootstrap() {
+    const result = await this.refreshFromBootstrap();
+    return result.refreshedTaskToken;
+  }
+  refreshFromBootstrap() {
+    const none = Promise.resolve({ refreshedClaude: false, refreshedTaskToken: false });
+    const podBootstrapToken = process.env.POD_BOOTSTRAP_TOKEN;
+    const codespaceName = process.env.CODESPACE_NAME;
+    const apiUrl = this.config.apiUrl;
+    if (!apiUrl || !podBootstrapToken && !codespaceName) {
+      return none;
+    }
+    const now = Date.now();
+    if (now - this.lastTaskTokenRefreshAt < 6e4) {
+      return none;
+    }
+    this.lastTaskTokenRefreshAt = now;
+    if (podBootstrapToken) {
+      return this.refreshFromV3Bootstrap(apiUrl, podBootstrapToken);
+    }
+    if (!codespaceName) return none;
+    return this.refreshFromCodespaceBootstrap(apiUrl, codespaceName);
+  }
+  /** Legacy GitHub Codespaces refresh path — keys on instance name. */
+  async refreshFromCodespaceBootstrap(apiUrl, codespaceName) {
+    const bootstrapToken = process.env.CONVEYOR_BOOTSTRAP_TOKEN;
+    const result = await fetchBootstrap({
+      apiUrl,
+      instanceName: codespaceName,
+      bootstrapToken
+      // Do not retry on http errors during a runtime refresh — a 401/403
+      // means the token is consumed / session terminal and retrying won't
+      // help. Network/timeout still retry inside fetchBootstrap.
+    });
+    if (!result.ok) {
+      logger.warn("bootstrap refresh abandoned \u2014 pod credentials will go stale", {
+        path: "codespace",
+        reason: result.reason,
+        status: result.status,
+        attempts: result.attempts,
+        detail: result.detail
+      });
+      return { refreshedClaude: false, refreshedTaskToken: false };
+    }
+    const previousTaskToken = process.env.CONVEYOR_TASK_TOKEN;
+    applyBootstrapToEnv(result.config);
+    const env = result.config.envVars ?? {};
+    syncBundleGithubToken(env.CONVEYOR_GITHUB_TOKEN ?? env.GH_TOKEN ?? env.GITHUB_TOKEN);
+    const refreshedTaskToken = result.config.mode !== "project" && Boolean(result.config.taskToken) && result.config.taskToken !== previousTaskToken;
+    if (refreshedTaskToken && result.config.taskToken) {
+      this.config.taskToken = result.config.taskToken;
+      if (this.socket) {
+        const auth = this.socket.auth;
+        if (auth && typeof auth === "object") {
+          auth.taskToken = result.config.taskToken;
+        }
+      }
+      this.heartbeatWorker?.postMessage({ taskToken: result.config.taskToken });
+    }
+    const refreshedClaude = Boolean(result.config.envVars?.CLAUDE_CODE_OAUTH_TOKEN);
+    return { refreshedClaude, refreshedTaskToken };
+  }
+  /**
+   * v3 refresh: re-fetch the full bootstrap bundle from the pod's bound v3
+   * route and swap the credentials in place. The GitHub installation token
+   * dies at ~1h and the sessionJwt at 24h; re-polling the bootstrap GET with
+   * the same pod token is the designed refresh mechanism.
+   */
+  async refreshFromV3Bootstrap(apiUrl, bootstrapToken) {
+    const bundle = await this.pollBundleWithRateLimitRetry(apiUrl, bootstrapToken);
+    if (!bundle) {
+      return { refreshedClaude: false, refreshedTaskToken: false };
+    }
+    const previousTaskToken = process.env.CONVEYOR_TASK_TOKEN;
+    for (const [key, value] of Object.entries(bundle.envVars ?? {})) {
+      process.env[key] = value;
+    }
+    if (bundle.githubToken) {
+      process.env.CONVEYOR_GITHUB_TOKEN = bundle.githubToken;
+      this.applyBundleCredentialFiles(bundle, previousTaskToken);
+    }
+    if (bundle.anthropicKey) process.env.ANTHROPIC_API_KEY = bundle.anthropicKey;
+    if (bundle.gcpToken) process.env.CLOUDSDK_AUTH_ACCESS_TOKEN = bundle.gcpToken;
+    const refreshedTaskToken = Boolean(bundle.sessionJwt) && bundle.sessionJwt !== previousTaskToken;
+    if (refreshedTaskToken) {
+      process.env.CONVEYOR_TASK_TOKEN = bundle.sessionJwt;
+      this.config.taskToken = bundle.sessionJwt;
+      if (this.socket) {
+        const auth = this.socket.auth;
+        if (auth && typeof auth === "object") {
+          auth.taskToken = bundle.sessionJwt;
+        }
+      }
+      this.heartbeatWorker?.postMessage({ taskToken: bundle.sessionJwt });
+    }
+    const refreshedClaude = Boolean(bundle.envVars?.CLAUDE_CODE_OAUTH_TOKEN);
+    return { refreshedClaude, refreshedTaskToken };
+  }
+  /**
+   * Write the bundle's GitHub token to the shared credential files — unless the
+   * bundle belongs to another session.
+   *
+   * The bootstrap GET is keyed by the POD, so on a pod also hosting a same-pod
+   * review it can resolve to the reader session, whose token is read-only.
+   * Writing that over the shared files silently downgrades the builder's push
+   * credential. Our own taskToken carries the same claims, so it is what we
+   * compare against.
+   *
+   * The legitimate case this path exists for — our own session's bundle
+   * refreshing the token when the RPC is failing — is unaffected.
+   */
+  applyBundleCredentialFiles(bundle, previousTaskToken) {
+    const self = readBundleIdentity(previousTaskToken);
+    const result = applyBundleGithubToken(bundle, {
+      sessionId: this.config.sessionId || self.sessionId,
+      ...self.role ? { role: self.role } : {}
+    });
+    if (!result.written && result.reason) {
+      process.stderr.write(
+        `[conveyor-agent] Skipped writing GitHub credential files from the bootstrap bundle: ${result.reason}
+`
+      );
+    }
+  }
+  /**
+   * Poll the bootstrap bundle once (maxWaitMs 0), retrying only on a transient
+   * 429 (standby-pool pods share one Cloud NAT IP against podBootstrapLimiter)
+   * with a short backoff. Returns null when the refresh should be abandoned —
+   * a non-429 error, or 429s past the retry budget — so the caller no-ops
+   * instead of parking a RUNNING pod in a poll loop.
+   */
+  async pollBundleWithRateLimitRetry(apiUrl, bootstrapToken) {
+    const retryDelaysMs = [1e3, 3e3];
+    for (let attempt = 0; ; attempt++) {
+      try {
+        return await pollUntilBound({ apiUrl, bootstrapToken, maxWaitMs: 0 });
+      } catch (err) {
+        const isRateLimited = err instanceof PollUntilBoundHttpError && err.status === 429;
+        if (!isRateLimited || attempt >= retryDelaysMs.length) {
+          logger.warn("bootstrap refresh abandoned \u2014 pod credentials will go stale", {
+            path: "v3",
+            attempt,
+            rateLimited: isRateLimited,
+            error: err instanceof Error ? err.message : String(err)
+          });
+          return null;
+        }
+        await new Promise((resolve) => {
+          setTimeout(resolve, retryDelaysMs[attempt]);
+        });
+      }
+    }
+  }
+  // ── Event buffering ────────────────────────────────────────────────
+  sendEvent(event) {
+    if (!this.socket) return;
+    this.enqueueEvents([{ event }], false);
+  }
+  /** Append (or, on `toFront`, prepend for a failed-flush re-queue) events to
+   *  the buffer, then cap + arm the flush timer. Single owner of the overflow
+   *  policy so append and re-queue can't diverge on the drop accounting. */
+  enqueueEvents(entries, toFront) {
+    if (toFront) this.eventBuffer.unshift(...entries);
+    else this.eventBuffer.push(...entries);
+    while (this.eventBuffer.length > MAX_EVENT_BUFFER) {
+      this.eventBuffer.shift();
+      this.droppedEventCount++;
+      if (this.droppedEventCount === 1 || this.droppedEventCount % 500 === 0) {
+        process.stderr.write(
+          `[conveyor-agent] eventBuffer overflow \u2014 dropped ${this.droppedEventCount} event(s) (cap: ${MAX_EVENT_BUFFER})
+`
+        );
+      }
+    }
+    if (this.socket && !this.flushTimer) {
+      this.flushTimer = setTimeout(() => void this.flushEvents(), EVENT_BATCH_MS);
+    }
+  }
+  async flushEvents() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (!this.socket || this.eventBuffer.length === 0) return;
+    const entries = this.eventBuffer;
+    this.eventBuffer = [];
+    const events = entries.map((entry) => entry.event);
+    try {
+      await this.call("emitAgentEvent", { sessionId: this.config.sessionId, events });
+    } catch {
+      this.requeueFailedEvents(entries);
+    }
+  }
+  /** Put a failed flush's events back at the FRONT of the buffer, preserving
+   *  order, via the shared cap-and-arm path. */
+  requeueFailedEvents(entries) {
+    this.enqueueEvents(entries, true);
+  }
+};
+
+// src/runner/git-run.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var GIT_TIMEOUT_MS = 6e4;
+var GIT_SLOW_TIMEOUT_MS = 12e4;
+var GIT_MAX_BUFFER = 16 * 1024 * 1024;
+async function git(cwd, args, timeoutMs = GIT_TIMEOUT_MS) {
+  if (workbenchEnabled()) {
+    try {
+      const { stdout: stdout2 } = await getWorkbenchClient().execFile("git", args, {
+        cwd,
+        timeout: timeoutMs,
+        maxBuffer: GIT_MAX_BUFFER
+      });
+      return stdout2.trim();
+    } catch (err) {
+      if (err instanceof Error && err.message.startsWith("Command timed out:")) {
+        err.killed = true;
+      }
+      throw err;
+    }
+  }
+  const { stdout } = await execFileAsync("git", args, {
+    cwd,
+    timeout: timeoutMs,
+    maxBuffer: GIT_MAX_BUFFER
+  });
+  return stdout.toString().trim();
+}
+
+// src/runner/git-credential-ops.ts
+function credentialErrorText(err) {
+  const raw = err instanceof Error ? err.message : String(err);
+  return raw.replace(/\/\/[^@\s]+@/g, "//***@");
+}
+async function updateRemoteCredential(cwd, credential) {
+  const result = { ok: false, storeWritten: false, helperConfigured: false };
+  try {
+    const currentUrl = await git(cwd, ["remote", "get-url", "origin"]);
+    const cloneUrl = credential.cloneUrl ?? currentUrl;
+    const normalizedUrl = writeGitCredential(cwd, cloneUrl, credential);
+    result.storeWritten = true;
+    if (currentUrl !== normalizedUrl) {
+      await git(cwd, ["remote", "set-url", "origin", normalizedUrl]);
+    }
+    await git(cwd, ["config", "--local", "credential.helper", gitCredentialHelper(cwd)]);
+    result.helperConfigured = true;
+    result.ok = true;
+  } catch (err) {
+    result.error = credentialErrorText(err);
+  }
+  return result;
+}
+async function updateRemoteToken(cwd, token) {
+  const username = process.env.CONVEYOR_GIT_USERNAME || "x-access-token";
+  const cloneUrl = process.env.CONVEYOR_GIT_CLONE_URL || void 0;
+  const credential = await updateRemoteCredential(cwd, { username, secret: token, cloneUrl });
+  process.env.CONVEYOR_GIT_SECRET = token;
+  const files = syncGithubTokenFiles(token);
+  return { credential, files };
+}
+async function verifyGitCredential(cwd) {
+  try {
+    await git(cwd, ["ls-remote", "--heads", "origin"], 3e4);
+    return { ok: true, outcome: "ok" };
+  } catch (err) {
+    const killed = err.killed === true;
+    return {
+      ok: false,
+      outcome: killed ? "timeout" : "denied",
+      error: credentialErrorText(err)
+    };
+  }
+}
+
+// src/runner/git-utils.ts
+import { realpathSync } from "fs";
+
+// src/runner/force-fresh-cooldown.ts
+var FORCE_FRESH_COOLDOWN_MS = 30 * 60 * 1e3;
+var blockedUntil = 0;
+function forceFreshCooldownRemainingMs() {
+  return Math.max(0, blockedUntil - Date.now());
+}
+function forceFreshMintBlocked() {
+  return forceFreshCooldownRemainingMs() > 0;
+}
+function recordForceFreshFailure() {
+  blockedUntil = Date.now() + FORCE_FRESH_COOLDOWN_MS;
+}
+function clearForceFreshCooldown() {
+  blockedUntil = 0;
+}
+function forceFreshCooldownNotice() {
+  const minutes = Math.ceil(forceFreshCooldownRemainingMs() / 6e4);
+  return `- the force-fresh retry was SKIPPED: one already failed against this pod, so it is on a ${Math.round(FORCE_FRESH_COOLDOWN_MS / 6e4)}-minute cooldown (${minutes} min left). Re-minting cannot fix a credential the pod cannot serve.`;
+}
+
+// src/runner/git-utils.ts
+async function ensureOnTaskBranch(cwd, taskBranch, baseBranch) {
+  if (!taskBranch) return true;
+  try {
+    if (await getCurrentBranch(cwd) === taskBranch) return true;
+    let existsOnOrigin = true;
+    try {
+      await git(cwd, [
+        "fetch",
+        "origin",
+        `+refs/heads/${taskBranch}:refs/remotes/origin/${taskBranch}`
+      ]);
+    } catch (err) {
+      if (String(err).includes("couldn't find remote ref")) existsOnOrigin = false;
+      else throw err;
+    }
+    if (existsOnOrigin) {
+      await git(cwd, ["checkout", "-B", taskBranch, `origin/${taskBranch}`], 3e4);
+      process.stderr.write(`[conveyor-agent] Checked out task branch ${taskBranch}
+`);
+      return true;
+    }
+    if (!baseBranch) {
+      process.stderr.write(
+        `[conveyor-agent] Warning: task branch ${taskBranch} missing on origin and no base branch given
+`
+      );
+      return false;
+    }
+    await git(cwd, [
+      "fetch",
+      "origin",
+      `+refs/heads/${baseBranch}:refs/remotes/origin/${baseBranch}`
+    ]);
+    await git(cwd, ["checkout", "-B", taskBranch, `origin/${baseBranch}`], 3e4);
+    await git(cwd, ["push", "-u", "origin", taskBranch], 3e4);
+    process.stderr.write(
+      `[conveyor-agent] Created task branch ${taskBranch} from origin/${baseBranch} and pushed
+`
+    );
+    return true;
+  } catch {
+    process.stderr.write(`[conveyor-agent] Warning: ensureOnTaskBranch(${taskBranch}) failed
+`);
+    return false;
+  }
+}
+async function hasUncommittedChanges(cwd) {
+  const status = await git(cwd, ["status", "--porcelain"], GIT_SLOW_TIMEOUT_MS);
+  return status.length > 0;
+}
+async function getCurrentBranch(cwd) {
+  try {
+    const branch = await git(cwd, ["branch", "--show-current"]);
+    return branch || null;
+  } catch {
+    return null;
+  }
+}
+async function hasUnpushedCommits(cwd) {
+  try {
+    const currentBranch = await getCurrentBranch(cwd);
+    if (!currentBranch) return false;
+    try {
+      await git(cwd, ["rev-parse", `origin/${currentBranch}`]);
+    } catch {
+      try {
+        await git(cwd, ["rev-parse", "HEAD"]);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    const ahead = await git(cwd, [
+      "rev-list",
+      "--count",
+      "HEAD",
+      "--not",
+      `origin/${currentBranch}`
+    ]);
+    return parseInt(ahead, 10) > 0;
+  } catch {
+    return false;
+  }
+}
+async function remoteMatchesLocalHead(cwd, branch) {
+  try {
+    const [remote, local] = await Promise.all([
+      git(cwd, ["ls-remote", "origin", `refs/heads/${branch}`], GIT_SLOW_TIMEOUT_MS),
+      git(cwd, ["rev-parse", "HEAD"])
+    ]);
+    const remoteSha = remote.split(/\s+/)[0] ?? "";
+    return /^[0-9a-f]{40}$/i.test(remoteSha) && remoteSha === local.trim();
+  } catch {
+    return false;
+  }
+}
+async function stageAndCommit(cwd, message) {
+  try {
+    await git(cwd, ["add", "-A"], GIT_SLOW_TIMEOUT_MS);
+    if (!await hasUncommittedChanges(cwd)) return null;
+    await git(cwd, ["commit", "-m", message], GIT_SLOW_TIMEOUT_MS);
+    return await git(cwd, ["rev-parse", "HEAD"]);
+  } catch {
+    return null;
+  }
+}
+function errLooksLikeAuth(err) {
+  if (err.killed) return true;
+  const stderr = err.stderr?.toString() ?? "";
+  const stdout = err.stdout?.toString() ?? "";
+  const msg = stderr || stdout || (err instanceof Error ? err.message : "");
+  return /authentication|authorization|403|401|token/i.test(msg);
+}
+async function tryPush(cwd, branch, skipVerify = false) {
+  const noVerify = skipVerify ? ["--no-verify"] : [];
+  try {
+    await git(cwd, ["push", ...noVerify, "origin", branch], 3e4);
+    return true;
+  } catch (err) {
+    if (errLooksLikeAuth(err)) return false;
+    process.stderr.write(
+      `[conveyor-agent] Plain push of ${branch} failed \u2014 retrying with --force-with-lease
+`
+    );
+    try {
+      await git(cwd, ["push", ...noVerify, "--force-with-lease", "origin", branch], 3e4);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+async function isAuthError(cwd) {
+  try {
+    await git(cwd, ["push", "--dry-run"], 3e4);
+    return false;
+  } catch (err) {
+    return errLooksLikeAuth(err);
+  }
+}
+function wipRefForBranch(branch) {
+  return `conveyor-wip/${branch}`;
+}
+var wipRefPushed = /* @__PURE__ */ new Set();
+var wipRefPreserved = /* @__PURE__ */ new Set();
+async function createWipSnapshot(cwd, message) {
+  let savedIndexTree;
+  try {
+    savedIndexTree = await git(cwd, ["write-tree"], GIT_SLOW_TIMEOUT_MS);
+  } catch {
+    return null;
+  }
+  try {
+    await git(cwd, ["add", "-A"], GIT_SLOW_TIMEOUT_MS);
+    const sha = await git(cwd, ["stash", "create", message], GIT_SLOW_TIMEOUT_MS);
+    return sha || null;
+  } catch {
+    return null;
+  } finally {
+    try {
+      await git(cwd, ["read-tree", savedIndexTree], GIT_SLOW_TIMEOUT_MS);
+    } catch {
+    }
+  }
+}
+async function tryPushRefspec(cwd, refspec, force = false) {
+  try {
+    const forceArgs = force ? ["--force"] : [];
+    await git(cwd, ["push", "--no-verify", ...forceArgs, "origin", refspec], 3e4);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function refreshRemoteToken(cwd, refreshToken) {
+  if (!refreshToken) return;
+  try {
+    const token = await refreshToken();
+    if (token) {
+      await updateRemoteToken(cwd, token);
+      process.env.GITHUB_TOKEN = token;
+      process.env.GH_TOKEN = token;
+    }
+  } catch {
+  }
+}
+async function restoreWipSnapshot(cwd, branch) {
+  if (!branch) return "none";
+  const ref = wipRefForBranch(branch);
+  try {
+    await git(cwd, ["fetch", "origin", `+refs/heads/${ref}:refs/remotes/origin/${ref}`]);
+  } catch (err) {
+    if (isMissingRefError(err)) return "none";
+    wipRefPreserved.add(cwd);
+    return "failed";
+  }
+  try {
+    const sha = await git(cwd, ["rev-parse", `refs/remotes/origin/${ref}`]);
+    const parent = await git(cwd, ["rev-parse", `${sha}^`]);
+    const head = await git(cwd, ["rev-parse", "HEAD"]);
+    if (parent !== head) {
+      try {
+        await git(cwd, ["stash", "apply", sha], GIT_SLOW_TIMEOUT_MS);
+        wipRefPushed.add(cwd);
+        wipRefPreserved.delete(cwd);
+        return "applied";
+      } catch {
+        try {
+          await git(cwd, ["reset", "--merge"], GIT_SLOW_TIMEOUT_MS);
+        } catch {
+        }
+        wipRefPreserved.add(cwd);
+        return "stale";
+      }
+    }
+    await git(cwd, ["stash", "apply", sha], GIT_SLOW_TIMEOUT_MS);
+    wipRefPushed.add(cwd);
+    wipRefPreserved.delete(cwd);
+    return "applied";
+  } catch {
+    wipRefPreserved.add(cwd);
+    return "failed";
+  }
+}
+function isMissingRefError(err) {
+  const stderr = err.stderr?.toString() ?? "";
+  const msg = stderr || (err instanceof Error ? err.message : String(err));
+  return /couldn't find remote ref|couldn't find remote|no such ref|not our ref/i.test(msg);
+}
+async function flushPendingChanges(cwd, opts) {
+  let committed = false;
+  let pushed = false;
+  let hadWork = false;
+  try {
+    const branch = await getCurrentBranch(cwd);
+    if (!branch) return { committed, pushed, hadWork };
+    const dirty = await hasUncommittedChanges(cwd);
+    const unpushed = await hasUnpushedCommits(cwd);
+    if (!dirty && !unpushed) {
+      await dropStaleWipRef(cwd, branch, opts?.refreshToken);
+      return { committed, pushed, hadWork };
+    }
+    hadWork = true;
+    await refreshRemoteToken(cwd, opts?.refreshToken);
+    if (unpushed) {
+      pushed = await pushToOrigin(cwd, opts?.refreshToken);
+    }
+    if (dirty && !wipRefPreserved.has(cwd)) {
+      const message = opts?.wipMessage ?? "WIP: conveyor-agent snapshot";
+      const sha = await createWipSnapshot(cwd, message);
+      if (sha) {
+        committed = await tryPushRefspec(cwd, `${sha}:refs/heads/${wipRefForBranch(branch)}`, true);
+        if (committed) wipRefPushed.add(cwd);
+      }
+    }
+  } catch {
+  }
+  return { committed, pushed, hadWork };
+}
+async function dropStaleWipRef(cwd, branch, refreshToken) {
+  if (wipRefPreserved.has(cwd) || !wipRefPushed.has(cwd)) return;
+  await refreshRemoteToken(cwd, refreshToken);
+  if (await tryPushRefspec(cwd, `:refs/heads/${wipRefForBranch(branch)}`)) {
+    wipRefPushed.delete(cwd);
+  }
+}
+async function pushToOrigin(cwd, refreshToken, skipVerify = false) {
+  try {
+    const currentBranch = await getCurrentBranch(cwd);
+    if (!currentBranch) return false;
+    if (refreshToken) {
+      try {
+        const token = await refreshToken();
+        if (token) {
+          await updateRemoteToken(cwd, token);
+          process.env.GITHUB_TOKEN = token;
+          process.env.GH_TOKEN = token;
+        }
+      } catch {
+      }
+    }
+    if (await tryPush(cwd, currentBranch, skipVerify)) {
+      clearForceFreshCooldown();
+      return true;
+    }
+    if (refreshToken && !forceFreshMintBlocked() && await isAuthError(cwd)) {
+      const token = await refreshToken({ forceFresh: true });
+      if (token) {
+        await updateRemoteToken(cwd, token);
+        process.env.GITHUB_TOKEN = token;
+        process.env.GH_TOKEN = token;
+        const pushed = await tryPush(cwd, currentBranch, skipVerify);
+        if (pushed) clearForceFreshCooldown();
+        else recordForceFreshFailure();
+        return pushed;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function branchBackupRef(branch) {
+  return `conveyor-wip/branches/${branch}`;
+}
+async function listWorktrees(cwd) {
+  try {
+    const out = await git(cwd, ["worktree", "list", "--porcelain"]);
+    const result = [];
+    for (const entry of out.split("\n\n")) {
+      const lines = entry.trim().split("\n");
+      const wl = lines.find((l) => l.startsWith("worktree "));
+      if (!wl) continue;
+      const bl = lines.find((l) => l.startsWith("branch "));
+      result.push({
+        path: wl.slice("worktree ".length),
+        branch: bl ? bl.slice("branch refs/heads/".length) : null
+      });
+    }
+    return result;
+  } catch {
+    return [];
+  }
+}
+async function listLocalBranches(cwd) {
+  try {
+    const out = await git(cwd, ["for-each-ref", "--format=%(refname:short)", "refs/heads/"]);
+    return out.split("\n").map((s) => s.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function branchUnpushedCount(cwd, branch) {
+  try {
+    const n = await git(cwd, ["rev-list", "--count", branch, "--not", "--remotes=origin"]);
+    return Number.parseInt(n, 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+function samePath(a, b) {
+  try {
+    return realpathSync(a) === realpathSync(b);
+  } catch {
+    return a === b;
+  }
+}
+async function flushAllPendingWork(cwd, opts) {
+  try {
+    const primary = await flushPendingChanges(cwd, opts);
+    await refreshRemoteToken(cwd, opts?.refreshToken);
+    const currentBranch = await getCurrentBranch(cwd);
+    const worktreesSnapshotted = await snapshotOtherWorktrees(cwd, opts?.wipMessage);
+    const branchesBackedUp = await backupOtherBranches(cwd, currentBranch);
+    return {
+      hadWork: primary.hadWork || worktreesSnapshotted > 0 || branchesBackedUp > 0,
+      branchesBackedUp,
+      worktreesSnapshotted
+    };
+  } catch {
+    return { hadWork: false, branchesBackedUp: 0, worktreesSnapshotted: 0 };
+  }
+}
+async function snapshotOtherWorktrees(cwd, wipMessage) {
+  let count = 0;
+  for (const wt of await listWorktrees(cwd)) {
+    if (samePath(wt.path, cwd) || !wt.branch) continue;
+    try {
+      if (!await hasUncommittedChanges(wt.path)) continue;
+      const sha = await createWipSnapshot(wt.path, wipMessage ?? "WIP: conveyor-agent snapshot");
+      if (sha && await tryPushRefspec(wt.path, `${sha}:refs/heads/${wipRefForBranch(wt.branch)}`, true)) {
+        wipRefPushed.add(wt.path);
+        count++;
+      }
+    } catch {
+    }
+  }
+  return count;
+}
+async function backupOtherBranches(cwd, currentBranch) {
+  let count = 0;
+  for (const branch of await listLocalBranches(cwd)) {
+    if (branch === currentBranch || branch.startsWith("conveyor-wip/")) continue;
+    try {
+      if (await branchUnpushedCount(cwd, branch) === 0) continue;
+      if (await tryPushRefspec(
+        cwd,
+        `refs/heads/${branch}:refs/heads/${branchBackupRef(branch)}`,
+        true
+      )) {
+        count++;
+      }
+    } catch {
+    }
+  }
+  return count;
+}
+
+// src/setup/config.ts
+import { join } from "path";
+
+// src/workbench/fs.ts
+import {
+  readFile as localReadFile,
+  readdir as localReaddir,
+  stat as localStat
+} from "fs/promises";
+async function readWorkspaceFile(path) {
+  if (workbenchEnabled()) {
+    return (await getWorkbenchClient().readFile(path)).toString("utf8");
+  }
+  return localReadFile(path, "utf-8");
+}
+function readWorkspaceBytes(path) {
+  if (workbenchEnabled()) return getWorkbenchClient().readFile(path);
+  return localReadFile(path);
+}
+function readWorkspaceDir(path) {
+  if (workbenchEnabled()) return getWorkbenchClient().readdir(path);
+  return localReaddir(path);
+}
+async function statWorkspacePath(path) {
+  if (workbenchEnabled()) return getWorkbenchClient().stat(path);
+  try {
+    const s = await localStat(path);
+    return {
+      exists: true,
+      isFile: s.isFile(),
+      isDirectory: s.isDirectory(),
+      size: s.size,
+      mtimeMs: s.mtimeMs
+    };
+  } catch {
+    return { exists: false, isFile: false, isDirectory: false, size: 0, mtimeMs: 0 };
+  }
+}
+async function workspacePathExists(path) {
+  return (await statWorkspacePath(path)).exists;
+}
+
+// src/setup/config.ts
+var DEVCONTAINER_PATH = ".devcontainer/conveyor/devcontainer.json";
+var DEVCONTAINER_PORT_DENY_LIST = /* @__PURE__ */ new Set([5432, 6379, 9200]);
+async function loadForwardPorts(workspaceDir) {
+  try {
+    const raw = await readWorkspaceFile(join(workspaceDir, DEVCONTAINER_PATH));
+    const parsed = JSON.parse(raw);
+    const ports = (parsed.forwardPorts ?? []).filter(
+      (p) => typeof p === "number" && !DEVCONTAINER_PORT_DENY_LIST.has(p)
+    );
+    const attributes = {};
+    for (const [key, value] of Object.entries(parsed.portsAttributes ?? {})) {
+      if (!value || typeof value !== "object") continue;
+      const entry = {};
+      if (typeof value.label === "string") entry.label = value.label;
+      if (value.visibility === "public" || value.visibility === "private") {
+        entry.visibility = value.visibility;
+      }
+      attributes[key] = entry;
+    }
+    return { ports, attributes };
+  } catch {
+    return { ports: [], attributes: {} };
+  }
+}
+function buildSessionPreviewPorts(result) {
+  return result.ports.filter((port) => !DEVCONTAINER_PORT_DENY_LIST.has(port)).map((port) => {
+    const attr = result.attributes[String(port)];
+    const entry = { port };
+    if (attr?.label) entry.label = attr.label;
+    if (attr?.visibility) entry.visibility = attr.visibility;
+    return entry;
+  });
+}
+function loadConveyorConfig() {
+  const envStart = process.env.CONVEYOR_START_COMMAND;
+  if (envStart) {
+    return { startCommand: envStart };
+  }
+  return null;
+}
+
+// src/runner/lifecycle.ts
+var DEFAULT_LIFECYCLE_CONFIG = {
+  idleTimeoutMs: 30 * 60 * 1e3,
+  dormantTimeoutMs: 60 * 60 * 1e3,
+  heartbeatIntervalMs: 3e4,
+  tokenRefreshIntervalMs: 45 * 60 * 1e3,
+  gitFlushIntervalMs: 2 * 60 * 1e3,
+  usageSampleIntervalMs: 5 * 60 * 1e3,
+  usageSampleInitialDelayMs: 3e4
+};
+var Lifecycle = class {
+  config;
+  callbacks;
+  heartbeatTimer = null;
+  tokenRefreshTimer = null;
+  idleTimer = null;
+  idleCheckInterval = null;
+  dormantTimer = null;
+  gitFlushTimer = null;
+  usageSampleTimer = null;
+  constructor(config, callbacks) {
+    this.config = config;
+    this.callbacks = callbacks;
+  }
+  // ── Heartbeat ──────────────────────────────────────────────────────
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      this.callbacks.onHeartbeat();
+    }, this.config.heartbeatIntervalMs);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  // ── Token refresh ─────────────────────────────────────────────────
+  startTokenRefresh() {
+    this.stopTokenRefresh();
+    this.callbacks.onTokenRefresh();
+    this.tokenRefreshTimer = setInterval(() => {
+      this.callbacks.onTokenRefresh();
+    }, this.config.tokenRefreshIntervalMs);
+  }
+  stopTokenRefresh() {
+    if (this.tokenRefreshTimer) {
+      clearInterval(this.tokenRefreshTimer);
+      this.tokenRefreshTimer = null;
+    }
+  }
+  // ── Periodic git flush ────────────────────────────────────────────
+  startGitFlush() {
+    this.stopGitFlush();
+    if (this.config.gitFlushIntervalMs <= 0) return;
+    this.gitFlushTimer = setInterval(() => {
+      this.callbacks.onGitFlush();
+    }, this.config.gitFlushIntervalMs);
+  }
+  stopGitFlush() {
+    if (this.gitFlushTimer) {
+      clearInterval(this.gitFlushTimer);
+      this.gitFlushTimer = null;
+    }
+  }
+  // ── Claude key usage sampling ─────────────────────────────────────
+  startUsageSample() {
+    this.stopUsageSample();
+    if (this.config.usageSampleIntervalMs <= 0) return;
+    this.usageSampleTimer = setTimeout(() => {
+      this.callbacks.onUsageSample();
+      this.usageSampleTimer = setInterval(() => {
+        this.callbacks.onUsageSample();
+      }, this.config.usageSampleIntervalMs);
+    }, this.config.usageSampleInitialDelayMs);
+  }
+  stopUsageSample() {
+    if (this.usageSampleTimer) {
+      clearInterval(this.usageSampleTimer);
+      this.usageSampleTimer = null;
+    }
+  }
+  // ── Idle timer ─────────────────────────────────────────────────────
+  /** Start (or restart) the idle timer.
+   *  @param overrideMs Optional custom delay in ms, mirroring
+   *  `startDormantTimer`. SessionRunner passes a short delay when it DEFERS a
+   *  shutdown because a spawned child is still working: the pod must re-check
+   *  soon after that child exits, rather than granting itself a fresh full idle
+   *  window every time it defers. */
+  startIdleTimer(overrideMs) {
+    this.clearIdleTimers();
+    const delay2 = Math.max(0, overrideMs ?? this.config.idleTimeoutMs);
+    this.idleTimer = setTimeout(() => {
+      this.callbacks.onIdleTimeout();
+    }, delay2);
+  }
+  cancelIdleTimer() {
+    this.clearIdleTimers();
+  }
+  // ── Dormant timer ──────────────────────────────────────────────────
+  /** Start (or restart) the dormant timer.
+   *  @param overrideMs Optional custom delay in ms. When provided, the timer
+   *  fires after exactly that delay instead of `dormantTimeoutMs`. SessionRunner
+   *  uses this to enforce an *absolute* deadline across cycles: even if the
+   *  dormant wait is interrupted by an inbound message, the next iteration
+   *  passes the remaining time, so the agent shuts down at the original
+   *  deadline regardless of message volume. */
+  startDormantTimer(overrideMs) {
+    this.cancelDormantTimer();
+    const delay2 = Math.max(0, overrideMs ?? this.config.dormantTimeoutMs);
+    this.dormantTimer = setTimeout(() => {
+      this.callbacks.onDormantTimeout();
+    }, delay2);
+  }
+  cancelDormantTimer() {
+    if (this.dormantTimer) {
+      clearTimeout(this.dormantTimer);
+      this.dormantTimer = null;
+    }
+  }
+  // ── Cleanup ────────────────────────────────────────────────────────
+  destroy() {
+    this.stopHeartbeat();
+    this.stopTokenRefresh();
+    this.stopGitFlush();
+    this.stopUsageSample();
+    this.clearIdleTimers();
+    this.cancelDormantTimer();
+  }
+  // ── Private ────────────────────────────────────────────────────────
+  clearIdleTimers() {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    if (this.idleCheckInterval) {
+      clearInterval(this.idleCheckInterval);
+      this.idleCheckInterval = null;
+    }
+  }
+};
+
+// src/setup/git-ready.ts
+var GATE_MARGIN_MS = 5 * 6e4;
+var DEFAULT_TIMEOUT_MS = GIT_PREP_MAX_RETRIES * (CLONE_TIMEOUT_MS + FETCH_TIMEOUT_MS) + (GIT_PREP_MAX_RETRIES - 1) * DEFAULT_RETRY_DELAY_MS + GATE_MARGIN_MS;
+var DEFAULT_POLL_MS = 200;
+function awaitGitReady(opts = {}) {
+  if (!workbenchEnabled()) {
+    return Promise.resolve("not-gated");
+  }
+  const clientFn = opts.clientFn ?? getWorkbenchClient;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const pollMs = opts.pollMs ?? DEFAULT_POLL_MS;
+  opts.onLog?.("waiting for workspace git (workbench daemon)");
+  return pollDaemon(clientFn, timeoutMs, pollMs, opts.onLog, opts.signal);
+}
+function delay(ms, signal) {
+  if (!signal) {
+    return new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    });
+  }
+  if (signal.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function pollOnce(clientFn, reportError) {
+  try {
+    const frame = await clientFn().gitStatus();
+    if (frame.state === "ready") return { state: "ready", log: "workspace git ready" };
+    if (frame.state === "failed") {
+      return {
+        state: "failed",
+        log: `workspace git preparation failed: ${frame.reason ?? "unknown reason"}`
+      };
+    }
+    return { state: null };
+  } catch (err) {
+    if (err instanceof WorkbenchError && err.code === "unauthorized") {
+      return {
+        state: "failed",
+        log: "workspace git gate unauthorized \u2014 workbench token missing or invalid, giving up"
+      };
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return reportError ? { state: null, log: `workspace git poll error (retrying): ${message}` } : { state: null };
+  }
+}
+async function pollDaemon(clientFn, timeoutMs, pollMs, onLog, signal) {
+  const deadline = Date.now() + timeoutMs;
+  let loggedError = false;
+  for (; ; ) {
+    if (signal?.aborted) {
+      onLog?.("workspace git wait aborted \u2014 giving up");
+      return "timeout";
+    }
+    const outcome = await pollOnce(clientFn, !loggedError);
+    if (outcome.log !== void 0) {
+      loggedError = true;
+      onLog?.(outcome.log);
+    }
+    if (outcome.state !== null) return outcome.state;
+    if (Date.now() >= deadline) {
+      onLog?.(`workspace git not ready after ${timeoutMs}ms \u2014 giving up`);
+      return "timeout";
+    }
+    await delay(pollMs, signal);
+  }
+}
+
+// src/runner/port-discovery.ts
+import { readFile } from "fs/promises";
+import { execFile as execFile2 } from "child_process";
+var PROC_TCP_LISTEN_STATE = "0A";
+function isLoopbackHexAddress(hex) {
+  const addr = hex.toUpperCase();
+  if (addr.length === 8) {
+    return addr.slice(6, 8) === "7F";
+  }
+  if (addr.length === 32) {
+    if (addr === "00000000000000000000000001000000") return true;
+    if (addr.slice(0, 16) === "0000000000000000" && addr.slice(16, 24) === "FFFF0000") {
+      return addr.slice(30, 32) === "7F";
+    }
+    return false;
+  }
+  return false;
+}
+function parseProcNetTcpListeners(content) {
+  const sockets = [];
+  const lines = content.split("\n");
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    const cols = line.trim().split(/\s+/);
+    if (cols.length < 4 || cols[3] !== PROC_TCP_LISTEN_STATE) continue;
+    const local = cols[1];
+    if (!local) continue;
+    const [addrHex, portHex] = local.split(":");
+    if (!addrHex || !portHex) continue;
+    const port = Number.parseInt(portHex, 16);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) continue;
+    sockets.push({ port, loopback: isLoopbackHexAddress(addrHex) });
+  }
+  return sockets;
+}
+function collectScan(sockets) {
+  const ports = /* @__PURE__ */ new Set();
+  const hasExternal = /* @__PURE__ */ new Set();
+  for (const { port, loopback } of sockets) {
+    ports.add(port);
+    if (!loopback) hasExternal.add(port);
+  }
+  const loopbackOnly = /* @__PURE__ */ new Set();
+  for (const port of ports) {
+    if (!hasExternal.has(port)) loopbackOnly.add(port);
+  }
+  return { ports, loopbackOnly };
+}
+var DEFAULT_PROC_PATHS = ["/proc/net/tcp", "/proc/net/tcp6"];
+async function readProcListeningPorts(procPaths = DEFAULT_PROC_PATHS) {
+  const sockets = [];
+  let readable = false;
+  for (const path of procPaths) {
+    try {
+      const content = await readFile(path, "utf8");
+      readable = true;
+      sockets.push(...parseProcNetTcpListeners(content));
+    } catch {
+    }
+  }
+  return readable ? collectScan(sockets) : null;
+}
+async function readNetstatListeningPorts() {
+  const output = await new Promise((resolve) => {
+    execFile2("netstat", ["-an", "-p", "tcp"], { timeout: 5e3 }, (err, stdout) => {
+      resolve(err ? null : stdout);
+    });
+  });
+  if (output === null) return null;
+  const sockets = [];
+  for (const line of output.split("\n")) {
+    if (!line.includes("LISTEN")) continue;
+    const cols = line.trim().split(/\s+/);
+    const local = cols[3];
+    if (!local) continue;
+    const lastDot = local.lastIndexOf(".");
+    if (lastDot < 0) continue;
+    const host = local.slice(0, lastDot);
+    const port = Number(local.slice(lastDot + 1));
+    if (!Number.isInteger(port) || port < 1 || port > 65535) continue;
+    const loopback = host.startsWith("127.") || host === "::1" || host === "localhost";
+    sockets.push({ port, loopback });
+  }
+  return collectScan(sockets);
+}
+async function readListeningPorts() {
+  const proc = await readProcListeningPorts();
+  if (proc !== null) return proc;
+  if (process.platform !== "linux") return readNetstatListeningPorts();
+  return null;
+}
+var DEFAULT_EXCLUDED_PORTS = [2222, 5432, 6379, 9200];
+var DEFAULT_EPHEMERAL_PORT_MIN = 32768;
+var DEFAULT_DISCOVERY_INTERVAL_MS = 15e3;
+var DEFAULT_MAX_PORTS = 16;
+var CONFIRM_SCANS = 2;
+var PortDiscovery = class {
+  opts;
+  intervalMs;
+  maxPorts;
+  excluded;
+  ephemeralPortMin;
+  scan;
+  now;
+  log;
+  baseline = null;
+  tracked = /* @__PURE__ */ new Map();
+  /** Loopback-only candidates already warned about (once per port). */
+  warnedLoopback = /* @__PURE__ */ new Set();
+  timer = null;
+  ticking = false;
+  disabled = false;
+  stopped = false;
+  /** Set when the confirmed set changed (or a report failed) — cleared only
+   *  after a successful report, so transient RPC failures retry next tick. */
+  reportPending = false;
+  lastReportedKey = "";
+  constructor(options) {
+    this.opts = options;
+    this.intervalMs = options.intervalMs ?? DEFAULT_DISCOVERY_INTERVAL_MS;
+    this.maxPorts = options.maxPorts ?? DEFAULT_MAX_PORTS;
+    this.excluded = new Set(options.excludedPorts ?? DEFAULT_EXCLUDED_PORTS);
+    this.ephemeralPortMin = options.ephemeralPortMin ?? DEFAULT_EPHEMERAL_PORT_MIN;
+    this.scan = options.scan ?? readListeningPorts;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.log = options.log ?? ((m) => process.stderr.write(`[conveyor-agent] ${m}
+`));
+  }
+  /** Take the baseline scan and start polling. Safe to call once. */
+  async start() {
+    if (this.timer || this.disabled || this.stopped) return;
+    const baseline = await this.scanSafe();
+    if (this.stopped) return;
+    if (baseline === null) {
+      this.disabled = true;
+      this.log("Port discovery disabled: no listening-socket source available");
+      return;
+    }
+    this.baseline = baseline.ports;
+    this.timer = setInterval(() => void this.tick(), this.intervalMs);
+    this.timer.unref?.();
+  }
+  stop() {
+    this.stopped = true;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  /** One poll cycle. Exposed for tests (deterministic, no timers needed). */
+  async tick() {
+    if (this.ticking || this.disabled || !this.baseline) return;
+    this.ticking = true;
+    try {
+      const current = await this.scanSafe();
+      if (current === null) return;
+      this.updateTracking(current);
+      if (this.reportPending) await this.flushReport();
+    } finally {
+      this.ticking = false;
+    }
+  }
+  async scanSafe() {
+    try {
+      return await this.scan();
+    } catch {
+      return null;
+    }
+  }
+  isCandidate(port) {
+    if (this.baseline?.has(port)) return false;
+    if (this.excluded.has(port)) return false;
+    if (port >= this.ephemeralPortMin) return false;
+    return true;
+  }
+  updateTracking(current) {
+    const reachable = /* @__PURE__ */ new Set();
+    for (const port of current.ports) {
+      if (!this.isCandidate(port)) continue;
+      if (current.loopbackOnly.has(port)) {
+        if (!this.warnedLoopback.has(port)) {
+          this.warnedLoopback.add(port);
+          this.log(
+            `Port ${port} is listening on loopback only and cannot be previewed \u2014 bind 0.0.0.0 (or the pod IP) to make it reachable through the preview proxy`
+          );
+        }
+        continue;
+      }
+      reachable.add(port);
+    }
+    for (const port of reachable) {
+      const entry = this.tracked.get(port);
+      if (!entry) {
+        this.tracked.set(port, { seen: 1, missed: 0, confirmed: false, detectedAt: "" });
+        continue;
+      }
+      entry.seen += 1;
+      entry.missed = 0;
+      if (!entry.confirmed && entry.seen >= CONFIRM_SCANS) {
+        entry.confirmed = true;
+        entry.detectedAt = this.now().toISOString();
+      }
+    }
+    for (const [port, entry] of this.tracked) {
+      if (reachable.has(port)) continue;
+      entry.missed += 1;
+      entry.seen = 0;
+      if (entry.missed >= CONFIRM_SCANS || !entry.confirmed) this.tracked.delete(port);
+    }
+    const key = this.confirmedKey();
+    if (key !== this.lastReportedKey) this.reportPending = true;
+  }
+  confirmedPorts() {
+    const confirmed = [...this.tracked.entries()].filter(([, entry]) => entry.confirmed).sort(([a], [b]) => a - b).slice(0, this.maxPorts);
+    return confirmed.map(([port, entry]) => ({
+      port,
+      protocol: "tcp",
+      detectedAt: entry.detectedAt
+    }));
+  }
+  confirmedKey() {
+    return this.confirmedPorts().map(({ port }) => port).join(",");
+  }
+  async flushReport() {
+    const ports = this.confirmedPorts();
+    const key = ports.map(({ port }) => port).join(",");
+    try {
+      await this.opts.report(ports);
+      this.lastReportedKey = key;
+      this.reportPending = false;
+      this.log(`Discovered preview ports: [${key || "none"}]`);
+    } catch {
+      return;
+    }
+    try {
+      await this.opts.onReported?.(ports);
+    } catch {
+    }
+  }
+};
+
+// src/runner/codespace-port-visibility.ts
+import { execFile as execFile3 } from "child_process";
+var GH_TIMEOUT_MS = 15e3;
+var VISIBILITIES = ["org", "public"];
+function runGh(args) {
+  return new Promise((resolve) => {
+    execFile3("gh", [...args], { timeout: GH_TIMEOUT_MS }, (error, _stdout, stderr) => {
+      resolve({ ok: !error, stderr: (stderr || (error ? String(error.message) : "")).trim() });
+    });
+  });
+}
+function isCodespaceEnvironment(env = process.env) {
+  return env.CODESPACES === "true" && !!env.CODESPACE_NAME;
+}
+var CodespacePortVisibility = class {
+  env;
+  run;
+  log;
+  /** Ports already attempted (success or failure) — one try per process. */
+  attempted = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    this.env = options.env ?? process.env;
+    this.run = options.run ?? runGh;
+    this.log = options.log ?? ((m) => process.stderr.write(`[conveyor-agent] ${m}
+`));
+  }
+  /** Flip every not-yet-attempted port. Resolves even when everything fails. */
+  async ensureVisible(ports) {
+    if (!isCodespaceEnvironment(this.env)) return;
+    const codespaceName = this.env.CODESPACE_NAME;
+    for (const port of ports) {
+      if (this.attempted.has(port)) continue;
+      this.attempted.add(port);
+      await this.flip(port, codespaceName);
+    }
+  }
+  async flip(port, codespaceName) {
+    let lastError = "";
+    for (const visibility of VISIBILITIES) {
+      const result = await this.run([
+        "codespace",
+        "ports",
+        "visibility",
+        `${port}:${visibility}`,
+        "-c",
+        codespaceName
+      ]).catch((error) => ({
+        ok: false,
+        stderr: error instanceof Error ? error.message : String(error)
+      }));
+      if (result.ok) {
+        this.log(`Forwarded port ${port} set to ${visibility} visibility`);
+        return;
+      }
+      lastError = result.stderr;
+    }
+    this.log(
+      `Could not change visibility of forwarded port ${port} \u2014 the preview URL may 404 for other users${lastError ? `: ${lastError}` : ""}`
+    );
+  }
+};
+
+export {
+  fetchBootstrap,
+  applyBootstrapToEnv,
+  createServiceLogger,
+  AgentConnection,
+  DEFAULT_LIFECYCLE_CONFIG,
+  Lifecycle,
+  readWorkspaceFile,
+  readWorkspaceBytes,
+  readWorkspaceDir,
+  statWorkspacePath,
+  workspacePathExists,
+  GIT_TIMEOUT_MS,
+  updateRemoteToken,
+  verifyGitCredential,
+  forceFreshMintBlocked,
+  recordForceFreshFailure,
+  clearForceFreshCooldown,
+  forceFreshCooldownNotice,
+  ensureOnTaskBranch,
+  hasUncommittedChanges,
+  getCurrentBranch,
+  hasUnpushedCommits,
+  remoteMatchesLocalHead,
+  stageAndCommit,
+  restoreWipSnapshot,
+  flushPendingChanges,
+  pushToOrigin,
+  flushAllPendingWork,
+  awaitGitReady,
+  PortDiscovery,
+  CodespacePortVisibility,
+  loadForwardPorts,
+  buildSessionPreviewPorts,
+  loadConveyorConfig
+};