@rallycry/conveyor-agent 11.0.19 → 11.0.21

package/dist/chunk-4ZDIBDQC.js

@@ -0,0 +1,4926 @@
+import {
+  CLONE_TIMEOUT_MS,
+  DEFAULT_RETRY_DELAY_MS,
+  FETCH_TIMEOUT_MS,
+  GIT_PREP_MAX_RETRIES
+} from "./chunk-Q4FQOJ7D.js";
+import {
+  gitCredentialHelper,
+  sleep,
+  syncGithubTokenFiles,
+  writeGitCredential
+} from "./chunk-W4LZ7R6Z.js";
+import {
+  buildConveyorSocketOptions,
+  callWithAck,
+  heartbeatStatusFor,
+  loopStatusForRunnerStatus,
+  waitForConnected
+} from "./chunk-IA45XHOA.js";
+import {
+  WorkbenchError,
+  getWorkbenchClient
+} from "./chunk-SQM2BQ7H.js";
+import {
+  workbenchEnabled
+} from "./chunk-KMB3BU4S.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;
+  /** Epoch ms of the last relayed keystroke, or null before any input. The
+   *  question-grace expiry reads it to defer un-parking while a human is
+   *  actively typing into the Connected-TUI (they may be mid-answer). */
+  _lastPtyInputAt = 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._lastPtyInputAt = Date.now();
+        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(() => {
+    });
+  }
+  /**
+   * Fire-and-forget: every Claude API retry for the turn failed, so hand the
+   * card back. The server returns a PR-less InProgress card to Open, posts the
+   * cause, notifies stakeholders and sleeps this workspace. Best-effort — an
+   * old server rejects the unknown method harmlessly and today's behaviour
+   * (chat line + idle agent) remains. `detail` is the last API error text.
+   */
+  reportApiOutage(detail, attempts) {
+    if (!this.socket) return;
+    void this.call("reportApiOutage", {
+      sessionId: this.config.sessionId,
+      detail: detail.slice(0, 2e3),
+      attempts
+    }).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(() => {
+    });
+  }
+  /** Epoch ms of the last relayed TUI keystroke, or null before any. */
+  get lastPtyInputAt() {
+    return this._lastPtyInputAt;
+  }
+  /** 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);
+  }
+};
+
+// ../shared/dist/chunk-42BS7Y35.js
+import { z } from "zod";
+var DEFAULT_SONNET_MODEL = "claude-sonnet-5";
+var DEFAULT_OPUS_MODEL = "claude-opus-5";
+var DEFAULT_HAIKU_MODEL = "claude-haiku-4-5-20251001";
+var FABLE_MODEL = "claude-fable-5-1";
+var PREVIOUS_SONNET_MODEL = "claude-sonnet-4-6";
+var PREVIOUS_OPUS_MODEL = "claude-opus-4-8";
+var PTY_STREAM_PORT_BASE = 7420;
+var PTY_STREAM_PORT_ATTEMPTS = 8;
+function encodePtyStreamFrame(frame) {
+  return `${JSON.stringify(frame)}
+`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function parsePtyStreamFrame(line) {
+  if (!line) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!isRecord(parsed) || typeof parsed.t !== "string") return null;
+  switch (parsed.t) {
+    case "hello":
+    case "data":
+    case "ended":
+    case "input":
+    case "resize":
+      return parsed;
+    default:
+      return null;
+  }
+}
+var PtyStreamFrameReader = class {
+  constructor(onFrame) {
+    this.onFrame = onFrame;
+  }
+  onFrame;
+  buffer = "";
+  push(chunk) {
+    this.buffer += chunk;
+    let index = this.buffer.indexOf("\n");
+    while (index >= 0) {
+      const line = this.buffer.slice(0, index);
+      this.buffer = this.buffer.slice(index + 1);
+      const frame = parsePtyStreamFrame(line);
+      if (frame) this.onFrame(frame);
+      index = this.buffer.indexOf("\n");
+    }
+  }
+};
+var PREVIEW_PORT_DENY_LIST = [
+  5432,
+  6379,
+  9200,
+  ...Array.from({ length: PTY_STREAM_PORT_ATTEMPTS }, (_, i) => PTY_STREAM_PORT_BASE + i)
+];
+function normalizeCheckpointPath(value) {
+  let normalized = value.trim().replace(/\/{2,}/g, "/");
+  normalized = normalized.split("/").filter((segment) => segment !== ".").join("/");
+  while (normalized.endsWith("/")) normalized = normalized.slice(0, -1);
+  return normalized;
+}
+var checkpointPathSchema = z.string().transform(normalizeCheckpointPath).pipe(
+  z.string().min(1).refine((value) => value !== ".", "Checkpoint paths must name a repository entry").refine((value) => !value.startsWith("/"), "Checkpoint paths must be repository-relative").refine(
+    (value) => !/^[A-Za-z]:[\\/]/.test(value) && !value.includes("\\"),
+    "Checkpoint paths must use repository-relative POSIX syntax"
+  ).refine(
+    (value) => !value.split("/").includes(".."),
+    "Checkpoint paths must not traverse a parent directory"
+  )
+);
+var secretNameSchema = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
+var checkpointKeySchema = z.string().regex(/^[0-9a-f]{64}$/);
+var checkpointDigestRefSchema = z.string().regex(/^[^\s@]+@sha256:[0-9a-f]{64}$/);
+var ACTIONS_PREBAKE_REGISTRY_PATTERN = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?(?::(?:[1-9][0-9]{0,4}))?(?:\/[a-z0-9]+(?:[._-][a-z0-9]+)*)*$/;
+var actionsPrebakeRegistrySchema = z.string().trim().min(1).regex(
+  ACTIONS_PREBAKE_REGISTRY_PATTERN,
+  "Actions prebake registry must be a lowercase host[:port] with an optional path prefix"
+).refine((value) => {
+  const port = /:([0-9]+)(?:\/|$)/.exec(value)?.[1];
+  return !port || Number(port) <= 65535;
+}, "Actions prebake registry port must be between 1 and 65535");
+function uniqueSortedArray(item, minimum = 0) {
+  return z.array(item).min(minimum).superRefine((values, ctx) => {
+    if (new Set(values).size !== values.length) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: "Duplicate values are not allowed" });
+    }
+  }).transform((values) => [...values].sort());
+}
+var projectCheckpointSettingsSchema = z.object({
+  enabled: z.literal(true),
+  cacheCommand: z.string().trim().min(1),
+  cacheInputPaths: uniqueSortedArray(checkpointPathSchema, 1),
+  reusableArtifactPaths: uniqueSortedArray(checkpointPathSchema, 1),
+  finalizeCommand: z.string().trim().min(1),
+  credentialEpoch: z.string().trim().min(1),
+  requiredSecretNames: uniqueSortedArray(secretNameSchema).optional(),
+  optionalSecretNames: uniqueSortedArray(secretNameSchema).optional(),
+  bakeWebAppBuild: z.boolean().optional()
+}).superRefine((checkpoint, ctx) => {
+  const required = new Set(checkpoint.requiredSecretNames ?? []);
+  for (const name of checkpoint.optionalSecretNames ?? []) {
+    if (required.has(name)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["optionalSecretNames"],
+        message: "A secret cannot be both required and optional"
+      });
+    }
+  }
+});
+var CARD_DESCRIPTION_MAX = 255;
+var CARD_DESCRIPTION_LIMIT_MESSAGE = `Card descriptions are capped at ${CARD_DESCRIPTION_MAX} characters \u2014 write 1-2 plain sentences a non-engineer can read; put technical detail in the plan or card chat.`;
+var CARD_DESCRIPTION_FIELD_HINT = `max ${CARD_DESCRIPTION_MAX} chars, 1-2 plain sentences a non-engineer can read \u2014 put technical detail in the plan`;
+var DEFAULT_CI_WAIT_TIMEOUT_MINUTES = 45;
+var MAX_CI_WAIT_TIMEOUT_MINUTES = 180;
+var SEVERITY_ENUM = [
+  "DEBUG",
+  "INFO",
+  "NOTICE",
+  "WARNING",
+  "ERROR",
+  "CRITICAL",
+  "ALERT",
+  "EMERGENCY"
+];
+var MAX_LINE_CHARS = 400;
+var DEFAULT_SINCE_MINUTES = 60;
+function truncateLine(text) {
+  const oneLine = text.replace(/\s*\n\s*/g, " \u23CE ");
+  if (oneLine.length <= MAX_LINE_CHARS) return oneLine;
+  const overflow = oneLine.length - MAX_LINE_CHARS;
+  return `${oneLine.slice(0, MAX_LINE_CHARS)}\u2026[+${overflow}c]`;
+}
+function entrySource(entry) {
+  return entry.resource.service_name ?? entry.resource.pod_name ?? entry.resource.database_id ?? entry.resourceType ?? "-";
+}
+var PAYLOAD_SKIP_KEYS = /* @__PURE__ */ new Set(["message", "severity", "timestamp", "level", "stack"]);
+var PAYLOAD_PRIORITY = [
+  "error",
+  "outcome",
+  "serviceName",
+  "methodName",
+  "userId",
+  "taskId",
+  "sessionId",
+  "workspaceId",
+  "projectId",
+  "durationMs"
+];
+var PAYLOAD_VALUE_MAX_CHARS = 160;
+function compactPayloadValue(value) {
+  const raw = typeof value === "string" ? value : JSON.stringify(value);
+  const flat = (raw ?? "undefined").replace(/\s+/g, " ");
+  const quoted = typeof value === "string" && /[\s"]/.test(flat) ? JSON.stringify(flat) : flat;
+  return quoted.length > PAYLOAD_VALUE_MAX_CHARS ? `${quoted.slice(0, PAYLOAD_VALUE_MAX_CHARS)}\u2026` : quoted;
+}
+function formatPayloadSuffix(payloadJson) {
+  if (!payloadJson) return "";
+  let parsed;
+  try {
+    parsed = JSON.parse(payloadJson);
+  } catch {
+    return "";
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return "";
+  const obj = parsed;
+  const rank = (key) => {
+    const i = PAYLOAD_PRIORITY.indexOf(key);
+    return i === -1 ? PAYLOAD_PRIORITY.length : i;
+  };
+  const parts = Object.keys(obj).filter((k) => !PAYLOAD_SKIP_KEYS.has(k) && obj[k] !== void 0 && obj[k] !== null).sort((a, b) => rank(a) - rank(b) || a.localeCompare(b)).map((k) => `${k}=${compactPayloadValue(obj[k])}`);
+  return parts.length > 0 ? ` | ${parts.join(" ")}` : "";
+}
+function formatLogEntryLine(entry) {
+  const httpPrefix = entry.httpRequest?.status ? `http ${entry.httpRequest.status} ${entry.httpRequest.method ?? ""} ${entry.httpRequest.url ?? ""}`.trim() + " \u2014 " : "";
+  return `${entry.timestamp} ${entry.severity.padEnd(7)} [${entrySource(entry)}] ${truncateLine(
+    `${httpPrefix}${entry.message}${formatPayloadSuffix(entry.payload)}`
+  )}`;
+}
+async function runQueryGcpLogs(port, params, now = Date.now) {
+  const startTime = params.startTime ?? new Date(now() - (params.sinceMinutes ?? DEFAULT_SINCE_MINUTES) * 6e4).toISOString();
+  const result = await port.queryGcpLogs({
+    projectId: params.projectId,
+    env: params.env,
+    severity: params.severity,
+    services: params.services,
+    sqlInstances: params.sqlInstances,
+    allServices: params.allServices,
+    search: params.search,
+    filter: params.filter,
+    startTime,
+    endTime: params.endTime,
+    limit: params.limit,
+    pageToken: params.pageToken
+  });
+  if (result.error) return result.error;
+  const header = [
+    `env=${params.env ?? "prod"}`,
+    `window=${startTime}\u2192${params.endTime ?? "now"}`,
+    ...params.severity ? [`minSeverity=${params.severity}`] : [],
+    `scope=${result.scopedServices ? `[${result.scopedServices.join(", ")}]` : "all"}`,
+    `entries=${result.entries.length}`
+  ].join(" ");
+  const lines = result.entries.map(formatLogEntryLine);
+  const footer = result.nextPageToken ? [`-- more available: pass pageToken="${result.nextPageToken}" to continue`] : [];
+  if (lines.length === 0) {
+    return [
+      header,
+      "(no matching log entries \u2014 widen the window, lower minSeverity, or drop filters)"
+    ].join("\n");
+  }
+  return [header, ...lines, ...footer].join("\n");
+}
+async function runQueryGrafanaLogs(port, params, now = Date.now) {
+  const startTime = params.startTime ?? new Date(now() - (params.sinceMinutes ?? DEFAULT_SINCE_MINUTES) * 6e4).toISOString();
+  const result = await port.queryGrafanaLogs({
+    projectId: params.projectId,
+    env: params.env,
+    level: params.level,
+    services: params.services,
+    search: params.search,
+    logql: params.logql,
+    startTime,
+    endTime: params.endTime,
+    limit: params.limit
+  });
+  if (result.error) return result.error;
+  const header = [
+    `env=${params.env ?? "prod"}`,
+    `window=${startTime}\u2192${params.endTime ?? "now"}`,
+    ...params.level ? [`minLevel=${params.level}`] : [],
+    ...result.logql ? [`logql=${truncateLine(result.logql)}`] : [],
+    `entries=${result.entries.length}`
+  ].join(" ");
+  const lines = result.entries.map(formatLogEntryLine);
+  const oldest = result.entries.map((e) => e.timestamp).sort()[0];
+  const footer = result.hasMore ? [`-- hit the limit: older lines exist \u2014 pass endTime="${oldest}" to page further back`] : [];
+  if (lines.length === 0) {
+    return [
+      header,
+      "(no matching log entries \u2014 widen the window, lower minLevel, or drop filters)"
+    ].join("\n");
+  }
+  return [header, ...lines, ...footer].join("\n");
+}
+
+// ../shared/dist/index.js
+import { z as z2 } from "zod";
+import { z as z22 } from "zod";
+import { z as z3 } from "zod";
+import { z as z4 } from "zod";
+import { z as z5 } from "zod";
+import { z as z6 } from "zod";
+import { z as z7 } from "zod";
+import { z as z8 } from "zod";
+import { z as z9 } from "zod";
+import { z as z10 } from "zod";
+var EXTERNAL_AGENT_MESSAGE_SOURCE = "external_agent";
+var TUI_KINDS = ["claude-code", "opencode", "codex"];
+var ACHIEVEMENT_RARITIES = [
+  {
+    key: "common",
+    name: "Common",
+    color: "#22c55e",
+    iconPath: "/storypoints/square-solid-full.svg"
+  },
+  {
+    key: "magic",
+    name: "Magic",
+    color: "#3b82f6",
+    iconPath: "/storypoints/diamond-solid-full.svg"
+  },
+  { key: "rare", name: "Rare", color: "#eab308", iconPath: "/storypoints/gem-solid-full.svg" },
+  {
+    key: "unique",
+    name: "Unique",
+    color: "#f97316",
+    iconPath: "/storypoints/scroll-sharp-solid-full.svg"
+  },
+  { key: "pack", name: "Pack", color: "#9c27b0", iconPath: "/storypoints/pack.svg" }
+];
+var RISK_LEVELS = ["critical", "high", "medium", "low"];
+var riskLevelSchema = z2.enum(RISK_LEVELS);
+var DEFAULT_RISK_LEVELS = [
+  {
+    level: "critical",
+    value: 4,
+    label: "Critical",
+    description: "Touches critical surface area; give it the closest review.",
+    color: "#dc2626",
+    ordinal: 0
+  },
+  {
+    level: "high",
+    value: 3,
+    label: "Elevated",
+    description: "Touches important surface area; review carefully.",
+    color: "#ea580c",
+    ordinal: 1
+  },
+  {
+    level: "medium",
+    value: 2,
+    label: "Moderate",
+    description: "Moderate surface area; normal review.",
+    color: "#d97706",
+    ordinal: 2
+  },
+  {
+    level: "low",
+    value: 1,
+    label: "Minimal",
+    description: "Small or isolated surface area.",
+    color: "#64748b",
+    ordinal: 3
+  }
+];
+var LEVEL_BY_VALUE = new Map(
+  DEFAULT_RISK_LEVELS.map((m) => [m.value, m.level])
+);
+var ACTIVE_WORK_STATUSES = [
+  "InProgress",
+  "ReviewPR",
+  "ReviewDev",
+  "ReviewLive",
+  "Complete"
+];
+var IDENTIFIED_WORK_STATUSES = ["Open", ...ACTIVE_WORK_STATUSES];
+var DEFAULT_TASK_STATUS_COLOR = "#a8a29e";
+var DEFAULT_TASK_STATUS_COLOR_INT = Number.parseInt(DEFAULT_TASK_STATUS_COLOR.slice(1), 16);
+var MAX_FILE_SIZE_BYTES = 25 * 1024 * 1024;
+var MAX_FILE_TAGS = 5;
+var MAX_FILE_TAG_LENGTH = 100;
+var EMBED_THRESHOLD_IMAGES = 5 * 1024 * 1024;
+var EMBED_THRESHOLD_TEXT = 2 * 1024 * 1024;
+var IDLE_HEARTBEAT_MS = 90 * 1e3;
+var RUNNER_MODES = [
+  "task",
+  "plan",
+  "pm",
+  "code-review",
+  "adhoc",
+  "pack",
+  "shell",
+  "serving"
+];
+var TurnEndToolCallSchema = z22.object({
+  tool: z22.string(),
+  input: z22.string().optional(),
+  output: z22.string().optional(),
+  timestamp: z22.string().optional()
+}).passthrough();
+var KnownAgentEventSchema = z22.discriminatedUnion("type", [
+  // ── Lifecycle / connection ────────────────────────────────────────────
+  z22.object({
+    type: z22.literal("connected"),
+    sessionId: z22.string(),
+    projectId: z22.string().optional()
+  }).passthrough(),
+  // Open-ended context snapshot spread from buildInitializationContext().
+  z22.object({ type: z22.literal("session_manifest") }).passthrough(),
+  z22.object({
+    type: z22.literal("agent_runner_status"),
+    reason: z22.string(),
+    attempt: z22.number().optional(),
+    attempts: z22.number().optional()
+  }).passthrough(),
+  z22.object({ type: z22.literal("shutdown"), reason: z22.string().optional() }).passthrough(),
+  z22.object({ type: z22.literal("mode_changed"), agentMode: z22.string() }).passthrough(),
+  z22.object({ type: z22.literal("mode_transition"), from: z22.string(), to: z22.string() }).passthrough(),
+  // ── Turn stream ───────────────────────────────────────────────────────
+  z22.object({ type: z22.literal("message"), content: z22.string() }).passthrough(),
+  z22.object({ type: z22.literal("thinking"), message: z22.string() }).passthrough(),
+  z22.object({
+    type: z22.literal("tool_use"),
+    tool: z22.string(),
+    // Producers send JSON.stringify(input); consumers defend against
+    // object inputs from older agents, so the wire stays permissive here.
+    input: z22.unknown().optional()
+  }).passthrough(),
+  z22.object({
+    type: z22.literal("tool_result"),
+    tool: z22.string(),
+    output: z22.unknown().optional(),
+    isError: z22.boolean().optional(),
+    redactedCount: z22.number().optional()
+  }).passthrough(),
+  z22.object({ type: z22.literal("turn_end"), toolCalls: z22.array(TurnEndToolCallSchema) }).passthrough(),
+  z22.object({
+    type: z22.literal("completed"),
+    summary: z22.string().optional(),
+    durationMs: z22.number().optional()
+  }).passthrough(),
+  z22.object({ type: z22.literal("error"), message: z22.string() }).passthrough(),
+  z22.object({ type: z22.literal("agent_typing_start") }).passthrough(),
+  z22.object({ type: z22.literal("agent_typing_stop") }).passthrough(),
+  // ── Telemetry ─────────────────────────────────────────────────────────
+  // heartbeat/typing: legacy telemetry the server still classifies as
+  // transient (TRANSIENT_EVENT_TYPES) — kept in the vocabulary.
+  z22.object({ type: z22.literal("heartbeat") }).passthrough(),
+  z22.object({ type: z22.literal("typing") }).passthrough(),
+  z22.object({
+    type: z22.literal("context_update"),
+    contextTokens: z22.number(),
+    contextWindow: z22.number(),
+    inputTokens: z22.number().optional(),
+    cacheReadInputTokens: z22.number().optional(),
+    cacheCreationInputTokens: z22.number().optional(),
+    totalTokensUsed: z22.number().optional()
+  }).passthrough(),
+  // Four producer shapes share this type: {rateLimitType, utilization, status}
+  // (SDK rate_limit_event), {resetsAt} (agent-connection resume notice), the
+  // usage-sampler ({rateLimitType, utilization, status, resetsAt, gauges}
+  // — resetsAt matches rateLimitType; gauges survives via .passthrough()), and
+  // {unmeasurable, reason} (the sampler reporting it cannot read this key).
+  z22.object({
+    type: z22.literal("rate_limit_update"),
+    rateLimitType: z22.string().optional(),
+    utilization: z22.number().optional(),
+    status: z22.string().optional(),
+    resetsAt: z22.string().optional(),
+    unmeasurable: z22.boolean().optional(),
+    reason: z22.string().optional()
+  }).passthrough(),
+  z22.object({
+    type: z22.literal("context_compacted"),
+    trigger: z22.string().optional(),
+    preTokens: z22.number().optional()
+  }).passthrough(),
+  z22.object({
+    type: z22.literal("tool_progress"),
+    toolName: z22.string().optional(),
+    elapsedSeconds: z22.number().optional()
+  }).passthrough(),
+  z22.object({
+    type: z22.literal("subagent_started"),
+    sdkTaskId: z22.string().optional(),
+    description: z22.string().optional()
+  }).passthrough(),
+  z22.object({
+    type: z22.literal("subagent_progress"),
+    sdkTaskId: z22.string().optional(),
+    description: z22.string().optional(),
+    toolUses: z22.number().optional(),
+    durationMs: z22.number().optional()
+  }).passthrough(),
+  // ── Work products ─────────────────────────────────────────────────────
+  z22.object({ type: z22.literal("pr_created"), url: z22.string(), number: z22.number() }).passthrough(),
+  z22.object({
+    type: z22.literal("code_review_complete"),
+    result: z22.enum(["approved", "changes_requested"]),
+    summary: z22.string().optional(),
+    issues: z22.array(
+      z22.object({
+        file: z22.string(),
+        line: z22.number().optional(),
+        severity: z22.string().optional(),
+        description: z22.string().optional()
+      }).passthrough()
+    ).optional()
+  }).passthrough(),
+  // ── Environment setup / start command ─────────────────────────────────
+  z22.object({ type: z22.literal("setup_output"), stream: z22.string(), data: z22.string() }).passthrough(),
+  z22.object({
+    type: z22.literal("setup_complete"),
+    startCommandRunning: z22.boolean().optional(),
+    startCommandConfigured: z22.boolean().optional(),
+    // Sanitized server-side by sanitizeSessionPreviewPorts — stays unknown.
+    previewPorts: z22.unknown().optional()
+  }).passthrough(),
+  z22.object({ type: z22.literal("setup_error"), message: z22.string() }).passthrough(),
+  z22.object({ type: z22.literal("start_command_started") }).passthrough(),
+  z22.object({ type: z22.literal("start_command_output"), stream: z22.string(), data: z22.string() }).passthrough(),
+  z22.object({
+    type: z22.literal("start_command_exited"),
+    code: z22.number().nullable().optional(),
+    signal: z22.string().nullable().optional(),
+    message: z22.string().optional()
+  }).passthrough(),
+  z22.object({ type: z22.literal("start_command_error"), message: z22.string() }).passthrough()
+]);
+var AgentEventSchema = z22.union([
+  KnownAgentEventSchema,
+  z22.object({ type: z22.string().min(1) }).catchall(z22.unknown())
+]);
+var cardDescription = z3.string().max(CARD_DESCRIPTION_MAX, CARD_DESCRIPTION_LIMIT_MESSAGE).optional();
+var AgentHeartbeatSchema = z3.object({
+  sessionId: z3.string().optional(),
+  timestamp: z3.string(),
+  status: z3.enum(["active", "idle", "building"]),
+  currentAction: z3.string().optional(),
+  /** Sender-observed main event-loop lag (ms) — see AgentHeartbeat.loopLagMs. */
+  loopLagMs: z3.number().nonnegative().optional()
+});
+var CreatePRInputSchema = z3.object({
+  title: z3.string().min(1),
+  body: z3.string(),
+  head: z3.string().optional(),
+  base: z3.string().optional()
+});
+var PostToChatInputSchema = z3.object({
+  message: z3.string().min(1),
+  type: z3.enum(["message", "question", "update"]).optional().default("message"),
+  milestone: z3.enum(["plan_ready", "implementation_complete", "blocked"]).optional()
+});
+var GetTaskContextRequestSchema = z3.object({
+  sessionId: z3.string(),
+  includeHistory: z3.boolean().optional().default(false),
+  /**
+   * Read the plan-revised marker WITHOUT consuming it. Bookkeeping fetches
+   * (the session-identity check, the branch refresh) pass true so they cannot
+   * race the boot fetch and swallow the notice before it reaches the prompt.
+   * Defaults to false — consuming — so a pod running an older agent build still
+   * clears the marker instead of showing the notice on every boot forever.
+   */
+  peekPlanRevision: z3.boolean().optional().default(false)
+});
+var GetChatMessagesRequestSchema = z3.object({
+  sessionId: z3.string(),
+  limit: z3.number().int().positive().optional().default(50),
+  offset: z3.number().int().nonnegative().optional().default(0),
+  /** Task id or slug to read chat from. Omit for the session's own task. Only
+   * the session's own task or one of its children resolves — anything else is
+   * an error, never a silent fallback to the caller's own chat. */
+  taskId: z3.string().optional()
+});
+var GetTaskFilesRequestSchema = z3.object({
+  sessionId: z3.string()
+});
+var GetTaskFileRequestSchema = z3.object({
+  sessionId: z3.string(),
+  fileId: z3.string()
+});
+var GetTaskRequestSchema = z3.object({
+  sessionId: z3.string(),
+  taskSlugOrId: z3.string()
+});
+var GetCliHistoryRequestSchema = z3.object({
+  sessionId: z3.string(),
+  limit: z3.number().int().positive().optional().default(100),
+  source: z3.enum(["agent", "application"]).optional(),
+  /** Task id or slug to read logs from. Omit for the session's own task. Only
+   * the session's own task or one of its children resolves — anything else is
+   * an error, never a silent fallback to the caller's own logs. */
+  taskId: z3.string().optional()
+});
+var ListSubtasksRequestSchema = z3.object({
+  sessionId: z3.string(),
+  /** "compact" returns the slim orchestration view (ListSubtasksCompactResponse:
+   * per-child status, agent, story points, PR state, dependencies); "full" (default — wire-compat with older
+   * agents) returns the verbose SubtaskSummaryDTO[] including description/plan. */
+  view: z3.enum(["compact", "full"]).optional()
+});
+var GetDependenciesRequestSchema = z3.object({
+  sessionId: z3.string()
+});
+var GetSuggestionsRequestSchema = z3.object({
+  sessionId: z3.string(),
+  status: z3.string().optional(),
+  limit: z3.number().int().min(1).max(100).optional()
+});
+var ListManualTestsRequestSchema = z3.object({
+  sessionId: z3.string()
+});
+var QueryManualTestsRequestSchema = z3.object({
+  sessionId: z3.string(),
+  cardStatuses: z3.array(z3.string()).optional(),
+  testStatuses: z3.array(z3.enum(["open", "approved", "rejected"])).optional()
+});
+var CreatePullRequestRequestSchema = CreatePRInputSchema.extend({ sessionId: z3.string() });
+var RequestFileUploadRequestSchema = z3.object({
+  sessionId: z3.string(),
+  fileName: z3.string().min(1).max(255),
+  mimeType: z3.string().min(1).max(128),
+  fileSize: z3.number().int().positive().max(MAX_FILE_SIZE_BYTES)
+});
+var ConfirmFileUploadRequestSchema = z3.object({
+  sessionId: z3.string(),
+  fileId: z3.string(),
+  title: z3.string().max(500).optional(),
+  /** Glossary tag names (or ids) this file is an example of. */
+  tags: z3.array(z3.string().min(1).max(MAX_FILE_TAG_LENGTH)).max(MAX_FILE_TAGS).optional()
+});
+var UpdateTaskStatusRequestSchema = z3.object({
+  sessionId: z3.string(),
+  status: z3.string(),
+  force: z3.boolean().optional().default(false)
+});
+var StoreSessionIdRequestSchema = z3.object({
+  sessionId: z3.string(),
+  sdkSessionId: z3.string()
+});
+var SetManualTestsRequestSchema = z3.object({
+  sessionId: z3.string(),
+  items: z3.array(z3.object({ title: z3.string().min(1) })).min(1)
+});
+var EditManualTestRequestSchema = z3.object({
+  sessionId: z3.string(),
+  title: z3.string().min(1),
+  newTitle: z3.string().min(1)
+});
+var RemoveManualTestRequestSchema = z3.object({
+  sessionId: z3.string(),
+  title: z3.string().min(1)
+});
+var ApproveManualTestRequestSchema = z3.object({
+  sessionId: z3.string(),
+  title: z3.string().min(1)
+});
+var RejectManualTestRequestSchema = z3.object({
+  sessionId: z3.string(),
+  title: z3.string().min(1),
+  reason: z3.string().min(1).max(2e3)
+});
+var SessionStartRequestSchema = z3.object({
+  sessionId: z3.string(),
+  agentVersion: z3.string(),
+  capabilities: z3.array(z3.string())
+});
+var SessionStopRequestSchema = z3.object({
+  sessionId: z3.string(),
+  reason: z3.string().optional()
+});
+var EndReviewSessionRequestSchema = z3.object({
+  sessionId: z3.string(),
+  reason: z3.enum(["approved", "changes_requested", "finished"]).optional()
+});
+var ConnectAgentRequestSchema = z3.object({
+  sessionId: z3.string()
+});
+var ReportAgentStatusRequestSchema = z3.object({
+  sessionId: z3.string(),
+  status: z3.string(),
+  /** Why the agent reports this status (e.g. "user_question" while an AskUserQuestion questionnaire is pending in the TUI). */
+  reason: z3.string().optional(),
+  /**
+   * The pending question text, sent only alongside `reason: "user_question"`
+   * so the server can surface it in the user-question notification body (and
+   * thus the Attention feed) instead of a generic string. Optional: older
+   * agents omit it and the server falls back to the generic wording.
+   */
+  questionText: z3.string().optional()
+});
+var NotifyAgentVersionRequestSchema = z3.object({
+  sessionId: z3.string(),
+  agentVersion: z3.string()
+});
+var DiscoveredPortSchema = z3.object({
+  port: z3.number().int().min(1).max(65535),
+  label: z3.string().min(1).max(64).optional(),
+  protocol: z3.enum(["http", "tcp"]).optional(),
+  detectedAt: z3.string()
+});
+var ReportDiscoveredPortsRequestSchema = z3.object({
+  sessionId: z3.string(),
+  ports: z3.array(DiscoveredPortSchema).max(64)
+});
+var ReportBootMilestoneRequestSchema = z3.object({
+  sessionId: z3.string(),
+  key: z3.string().max(64)
+});
+var CreateSubtaskRequestSchema = z3.object({
+  sessionId: z3.string(),
+  title: z3.string().min(1),
+  description: cardDescription,
+  plan: z3.string().optional(),
+  storyPointValue: z3.number().int().positive().optional(),
+  ordinal: z3.number().int().nonnegative().optional(),
+  followParentStatus: z3.boolean().optional(),
+  /** Sibling subtask ids or slugs this subtask blocks on (explicit dependency
+   * metadata — preferred over encoding order in plan text / ordinal). */
+  dependsOn: z3.array(z3.string().min(1)).max(32).optional(),
+  /** Glossary tag names to assign to the child. Unmatched names come back in
+   * the response rather than failing the create. */
+  tags: z3.array(z3.string().min(1)).max(10).optional()
+});
+var UpdateSubtaskRequestSchema = z3.object({
+  sessionId: z3.string(),
+  subtaskId: z3.string(),
+  title: z3.string().min(1).optional(),
+  description: cardDescription,
+  plan: z3.string().optional(),
+  /** Orchestration statuses only ("Planning" | "Open") — the pack parent's
+   * sanctioned promotion path. Execution statuses stay with the build
+   * pipeline / force_update_task_status. Enforced server-side. */
+  status: z3.string().optional(),
+  /** Assign a project agent to the child — accepts the agent's id or exact
+   * name; resolved against the parent task's project server-side. */
+  agentIdOrName: z3.string().min(1).optional(),
+  storyPointValue: z3.number().int().positive().optional(),
+  followParentStatus: z3.boolean().optional(),
+  /** Replace this subtask's dependency edges with these sibling ids/slugs.
+   * Empty array clears all. Omit to leave dependencies unchanged. */
+  dependsOn: z3.array(z3.string().min(1)).max(32).optional()
+});
+var DeleteSubtaskRequestSchema = z3.object({
+  sessionId: z3.string(),
+  subtaskId: z3.string()
+});
+var SetSubtaskParentRequestSchema = z3.object({
+  sessionId: z3.string(),
+  taskId: z3.string().min(1),
+  detach: z3.boolean().optional(),
+  ordinal: z3.number().int().nonnegative().optional(),
+  followParentStatus: z3.boolean().optional()
+});
+var GetTaskPropertiesRequestSchema = z3.object({
+  sessionId: z3.string()
+});
+var UpdateTaskFieldsRequestSchema = z3.object({
+  sessionId: z3.string(),
+  plan: z3.string().optional(),
+  description: cardDescription
+});
+var UpdateTaskPropertiesRequestSchema = z3.object({
+  sessionId: z3.string(),
+  title: z3.string().optional(),
+  storyPointValue: z3.number().int().positive().optional(),
+  tagIds: z3.array(z3.string()).optional(),
+  tagNames: z3.array(z3.string()).optional(),
+  githubPRUrl: z3.string().url().optional(),
+  githubBranch: z3.string().optional(),
+  // Canonical risk level, or null to clear — same semantics as the headless
+  // update_task boundary (resolved to the project's Risk row in the handler).
+  risk: riskLevelSchema.nullable().optional()
+});
+var ListIconsRequestSchema = z3.object({
+  sessionId: z3.string()
+});
+var GenerateTaskIconRequestSchema = z3.object({
+  sessionId: z3.string(),
+  prompt: z3.string().min(1),
+  aspectRatio: z3.string().optional()
+});
+var SearchFaIconsRequestSchema = z3.object({
+  sessionId: z3.string(),
+  query: z3.string().min(1),
+  first: z3.number().int().positive().optional()
+});
+var PickFaIconRequestSchema = z3.object({
+  sessionId: z3.string(),
+  fontAwesomeId: z3.string().min(1),
+  fontAwesomeStyle: z3.string().optional()
+});
+var CreateFollowUpTaskRequestSchema = z3.object({
+  sessionId: z3.string(),
+  title: z3.string().min(1),
+  description: cardDescription,
+  plan: z3.string().optional(),
+  storyPointValue: z3.number().int().positive().optional()
+});
+var AddDependencyRequestSchema = z3.object({
+  sessionId: z3.string(),
+  dependsOnSlugOrId: z3.string()
+});
+var RemoveDependencyRequestSchema = z3.object({
+  sessionId: z3.string(),
+  dependsOnSlugOrId: z3.string()
+});
+var CreateSuggestionRequestSchema = z3.object({
+  sessionId: z3.string(),
+  title: z3.string().min(1),
+  description: cardDescription,
+  tagNames: z3.array(z3.string()).optional()
+});
+var VoteSuggestionRequestSchema = z3.object({
+  sessionId: z3.string(),
+  suggestionId: z3.string(),
+  value: z3.union([z3.literal(1), z3.literal(-1)])
+});
+var TriggerIdentificationRequestSchema = z3.object({
+  sessionId: z3.string()
+});
+var HandoffToImplementerRequestSchema = z3.object({
+  sessionId: z3.string(),
+  // Optional difficulty sizing — sets the task's story points before resolving
+  // the matched implementer agent. Omit to hand off using the task's current
+  // story points (or the project's default task agent when unsized).
+  storyPoints: z3.number().int().positive().optional(),
+  // Optional kickoff note posted to the task chat alongside the handoff notice.
+  message: z3.string().optional()
+});
+var SubmitCodeReviewResultRequestSchema = z3.object({
+  sessionId: z3.string(),
+  approved: z3.boolean(),
+  content: z3.string(),
+  // Canonical risk level the reviewer assigned to this change. Required on every
+  // verdict — the reviewer must judge it. Applied authoritatively server-side
+  // (may raise OR lower an already-set value; the reviewer has that authority).
+  risk: riskLevelSchema,
+  // The commit SHA the reviewer actually reviewed. When present, the verdict is
+  // rejected unless the task is still at this SHA (guards against a late
+  // old-SHA verdict overwriting a newer review cycle).
+  reviewedSha: z3.string().optional()
+});
+var CycleCodingAgentKeyRequestSchema = z3.object({
+  sessionId: z3.string(),
+  rateLimitType: z3.string(),
+  resetsAt: z3.string().optional()
+});
+var PostChildChatMessageRequestSchema = z3.object({
+  sessionId: z3.string(),
+  childTaskId: z3.string(),
+  message: z3.string().min(1)
+});
+var UpdateChildStatusRequestSchema = z3.object({
+  sessionId: z3.string(),
+  childTaskId: z3.string(),
+  status: z3.string()
+});
+var GetAgentStatusRequestSchema = z3.object({
+  taskId: z3.string()
+});
+var GetUiCliHistoryRequestSchema = z3.object({
+  taskId: z3.string()
+});
+var GetActivePtySessionRequestSchema = z3.object({
+  taskId: z3.string()
+});
+var ListActivePtySessionsRequestSchema = z3.object({
+  taskId: z3.string()
+});
+var SendSoftStopRequestSchema = z3.object({
+  taskId: z3.string()
+});
+var StopTaskSessionRequestSchema = z3.object({
+  taskId: z3.string(),
+  sessionId: z3.string()
+});
+var FlushTaskQueueRequestSchema = z3.object({
+  taskId: z3.string(),
+  softStop: z3.boolean().optional()
+});
+var CancelTaskQueuedMessageRequestSchema = z3.object({
+  taskId: z3.string(),
+  messageId: z3.string()
+});
+var FlushSingleQueuedMessageRequestSchema = z3.object({
+  taskId: z3.string(),
+  messageId: z3.string(),
+  softStop: z3.boolean().optional()
+});
+var AnswerAgentQuestionRequestSchema = z3.object({
+  taskId: z3.string(),
+  requestId: z3.string(),
+  answers: z3.record(z3.string(), z3.string())
+});
+var ClearAgentTodosRequestSchema = z3.object({
+  taskId: z3.string()
+});
+var AgentQuestionOptionSchema = z3.object({
+  label: z3.string(),
+  description: z3.string(),
+  preview: z3.string().optional()
+});
+var AgentQuestionSchema = z3.object({
+  question: z3.string(),
+  header: z3.string(),
+  options: z3.array(AgentQuestionOptionSchema),
+  multiSelect: z3.boolean().optional()
+});
+var AskUserQuestionRequestSchema = z3.object({
+  sessionId: z3.string(),
+  question: z3.string().min(1),
+  requestId: z3.string().min(1),
+  questions: z3.array(AgentQuestionSchema).min(1)
+});
+var PostAgentMessageRequestSchema = z3.object({
+  sessionId: z3.string().min(1),
+  content: z3.string(),
+  milestone: z3.enum(["plan_ready", "implementation_complete", "blocked"]).optional()
+});
+var EmitAgentEventRequestSchema = z3.object({
+  sessionId: z3.string(),
+  events: z3.array(AgentEventSchema).max(500)
+});
+var RefreshGithubTokenRequestSchema = z3.object({
+  sessionId: z3.string(),
+  forceFresh: z3.boolean().optional()
+});
+var ReportCredentialFailureRequestSchema = z3.object({
+  sessionId: z3.string(),
+  error: z3.string().max(2e3).optional(),
+  tokenShape: z3.string().max(500).optional(),
+  healed: z3.boolean().optional()
+});
+var ReportReviewSpawnFailureRequestSchema = z3.object({
+  sessionId: z3.string(),
+  reviewSessionId: z3.string(),
+  error: z3.string().max(2e3).optional()
+});
+var ReportBuilderSpawnFailureRequestSchema = ReportReviewSpawnFailureRequestSchema.omit({
+  reviewSessionId: true
+}).extend({ buildSessionId: z3.string() });
+var SpawnTaskSessionRequestSchema = z3.object({
+  taskId: z3.string(),
+  kind: z3.enum(["tui", "shell"])
+});
+var StartCodeReviewRequestSchema = z3.object({
+  taskId: z3.string(),
+  force: z3.boolean().optional()
+});
+var StopCodeReviewRequestSchema = z3.object({
+  taskId: z3.string()
+});
+var ReportSessionSpawnFailureRequestSchema = z3.object({
+  sessionId: z3.string(),
+  spawnedSessionId: z3.string(),
+  error: z3.string().max(2e3).optional()
+});
+var RefreshGithubTokenResponseSchema = z3.object({
+  token: z3.string()
+});
+var PTY_FRAME_MAX_CHARS = 256 * 1024;
+var PTY_MAX_DIMENSION = 1e3;
+var PtyOutputRequestSchema = z3.object({
+  sessionId: z3.string(),
+  data: z3.string().max(PTY_FRAME_MAX_CHARS),
+  cols: z3.number().int().positive().max(PTY_MAX_DIMENSION).optional(),
+  rows: z3.number().int().positive().max(PTY_MAX_DIMENSION).optional()
+});
+var PtyEndedRequestSchema = z3.object({
+  sessionId: z3.string()
+});
+var PtyInputRequestSchema = z3.object({
+  sessionId: z3.string(),
+  data: z3.string().max(PTY_FRAME_MAX_CHARS)
+});
+var PtyResizeRequestSchema = z3.object({
+  sessionId: z3.string(),
+  cols: z3.number().int().positive().max(PTY_MAX_DIMENSION),
+  rows: z3.number().int().positive().max(PTY_MAX_DIMENSION)
+});
+var PtyAttachRequestSchema = z3.object({
+  sessionId: z3.string()
+});
+var ReportPtyStreamRequestSchema = z3.object({
+  sessionId: z3.string(),
+  port: z3.number().int().positive().max(65535).nullable()
+});
+var GetPtyStreamEndpointRequestSchema = z3.object({
+  sessionId: z3.string()
+});
+var PtyChatEventPayloadSchema = z3.discriminatedUnion("kind", [
+  z3.object({
+    kind: z3.literal("init"),
+    model: z3.string().max(200),
+    claudeSessionId: z3.string().max(100).optional()
+  }),
+  z3.object({
+    kind: z3.literal("user_text"),
+    text: z3.string().max(16384),
+    // Set by the SERVER (never the agent) when this prompt was injected by
+    // Conveyor rather than typed by a human — the routed message's `source`
+    // (`ci_success`, `review_trigger`, `automated_feedback`, …). The agent
+    // pastes automated messages into the TUI exactly like human prompts, so the
+    // CLI records both as plain transcript `user` records; without this the
+    // builder chat renders "All CI checks passed on your PR." as the human's
+    // own bubble. Absent ⇒ a genuine human prompt.
+    source: z3.string().max(60).optional()
+  }),
+  z3.object({ kind: z3.literal("assistant_text"), text: z3.string().max(16384) }),
+  z3.object({
+    kind: z3.literal("tool_use"),
+    name: z3.string().max(200),
+    // Compact preview: JSON.stringify(input) truncated agent-side. The cap
+    // matches the text events because AskUserQuestion payloads ride this field
+    // and the web lifts them into an interactive card — a tight cap forced
+    // option descriptions down to 80 chars, making them unreadable. Every
+    // other tool keeps a far smaller agent-side budget (`TOOL_INPUT_MAX` in
+    // `chat-record-mapper.ts`), so the ring does not grow for normal calls.
+    input: z3.string().max(16384),
+    // Transcript tool_use block id — lets the client pair the tool_result.
+    id: z3.string().max(100).optional()
+  }),
+  z3.object({
+    kind: z3.literal("tool_result"),
+    // tool_use block id this result answers (absent on malformed records).
+    toolUseId: z3.string().max(100).optional(),
+    // Compact output preview, truncated agent-side.
+    output: z3.string().max(2e3),
+    isError: z3.boolean().optional()
+  }),
+  z3.object({ kind: z3.literal("turn_end") })
+]);
+var PtyChatEventRequestSchema = z3.object({
+  sessionId: z3.string(),
+  event: PtyChatEventPayloadSchema
+});
+var PtyChatAttachRequestSchema = z3.object({
+  sessionId: z3.string()
+});
+var CreatePRResponseSchema = z3.object({
+  prNumber: z3.number().int().positive(),
+  prUrl: z3.string().url(),
+  /** Advisory glossary-upkeep note derived from the PR's changed files matched
+   *  against tag contextPaths — rendered into the tool result, never stored. */
+  glossaryNote: z3.string().optional()
+});
+var PostToChatResponseSchema = z3.object({
+  messageId: z3.string()
+});
+var UpdateTaskStatusResponseSchema = z3.object({
+  taskId: z3.string(),
+  status: z3.string()
+});
+var StoreSessionIdResponseSchema = z3.object({
+  success: z3.boolean()
+});
+var HeartbeatResponseSchema = z3.object({
+  acknowledged: z3.boolean()
+});
+var SessionStartResponseSchema = z3.object({
+  sessionId: z3.string(),
+  startedAt: z3.string()
+});
+var SessionStopResponseSchema = z3.object({
+  sessionId: z3.string(),
+  stoppedAt: z3.string()
+});
+var DeleteSubtaskResponseSchema = z3.object({
+  deleted: z3.boolean()
+});
+var ParkOnCheckResultRequestSchema = z4.object({
+  sessionId: z4.string(),
+  sha: z4.string().regex(/^[0-9a-f]{7,40}$/i).optional(),
+  prNumber: z4.number().int().positive().optional(),
+  timeoutMinutes: z4.number().int().min(1).max(MAX_CI_WAIT_TIMEOUT_MINUTES).optional()
+});
+var GIT_BRANCH_NAME_MAX = 255;
+var GIT_BRANCH_NAME_MESSAGE = "Invalid git branch name \u2014 use only letters, numbers, '.', '_', '/' and '-', starting with a letter or number, with no '..', '@{' or '//', and no trailing '/', '-', '.' or '.lock'";
+var ALLOWED_REF = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/;
+function isValidGitBranchName(name) {
+  if (typeof name !== "string") return false;
+  if (name.length === 0 || name.length > GIT_BRANCH_NAME_MAX) return false;
+  if (!ALLOWED_REF.test(name)) return false;
+  if (name.includes("..") || name.includes("@{") || name.includes("//")) return false;
+  if (name.endsWith("/") || name.endsWith("-")) return false;
+  if (name.endsWith(".") || name.endsWith(".lock")) return false;
+  return true;
+}
+var cardDescription2 = z5.string().max(CARD_DESCRIPTION_MAX, CARD_DESCRIPTION_LIMIT_MESSAGE).optional();
+var ListAccessibleProjectsRequestSchema = z5.object({
+  pageSize: z5.number().int().positive().max(100).optional().default(100)
+});
+var ListProjectTasksRequestSchema = z5.object({
+  projectId: z5.string(),
+  status: z5.string().optional(),
+  // Card types to include. Omitted/empty → defaults to ["task"] in the handler
+  // (mirrors searchProjectTasks) so listing doesn't surface incidents/suggestions
+  // unless asked. Enum validation lives at the MCP tool layer.
+  typeFilters: z5.array(z5.string()).optional(),
+  assigneeId: z5.string().optional(),
+  unassigned: z5.boolean().optional(),
+  // Scope to a sub-project board when provided. Unlike the board layer's `?? null`
+  // semantics, agents default to seeing the whole project when omitted.
+  subProjectId: z5.string().nullable().optional(),
+  limit: z5.number().int().positive().optional().default(50)
+}).refine((p) => !(p.unassigned && p.assigneeId), {
+  message: "Pass either assigneeId or unassigned, not both"
+});
+var GetProjectTaskRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string()
+});
+var SearchProjectTasksRequestSchema = z5.object({
+  projectId: z5.string(),
+  // Tag names, matched case-insensitively against the project glossary.
+  tagNames: z5.array(z5.string()).optional(),
+  // How to combine tagNames: "any" (default) = carries at least one,
+  // "all" = carries every one.
+  tagMatch: z5.enum(["any", "all"]).optional(),
+  // Expand each named tag to its descendants in the tag DAG before matching,
+  // so a parent tag sweeps its whole area. Default false.
+  includeChildTags: z5.boolean().optional(),
+  searchQuery: z5.string().optional(),
+  statusFilters: z5.array(z5.string()).optional(),
+  // Card types to include. Omitted/empty → defaults to ["task"] in the handler so
+  // search doesn't surface incidents/suggestions unless asked. Enum validation lives
+  // at the MCP tool layer (mirrors statusFilters).
+  typeFilters: z5.array(z5.string()).optional(),
+  assigneeId: z5.string().optional(),
+  unassigned: z5.boolean().optional(),
+  // Scope to a sub-project board when provided. Unlike the board layer's `?? null`
+  // semantics, agents default to seeing the whole project when omitted.
+  subProjectId: z5.string().nullable().optional(),
+  limit: z5.number().int().positive().optional().default(20)
+}).refine((p) => !(p.unassigned && p.assigneeId), {
+  message: "Pass either assigneeId or unassigned, not both"
+});
+var ListProjectTagsRequestSchema = z5.object({
+  projectId: z5.string()
+});
+var GetProjectTagRequestSchema = z5.object({
+  projectId: z5.string(),
+  /** Tag id or exact (case-insensitive) tag name. */
+  tag: z5.string().min(1).max(100)
+});
+var ListProjectTagAttachmentsRequestSchema = z5.object({
+  projectId: z5.string(),
+  /** Tag id or exact (case-insensitive) tag name. */
+  tag: z5.string().min(1).max(100),
+  limit: z5.number().int().min(1).max(60).optional(),
+  offset: z5.number().int().min(0).optional()
+});
+var SetProjectFileTagsRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  fileId: z5.string(),
+  tags: z5.array(z5.string().min(1).max(MAX_FILE_TAG_LENGTH)).max(MAX_FILE_TAGS),
+  requestingUserId: z5.string().optional()
+});
+var GetProjectSummaryRequestSchema = z5.object({
+  projectId: z5.string()
+});
+var GetProjectOnboardingStatusRequestSchema = z5.object({
+  projectId: z5.string()
+});
+var GetProjectOnboardingStepRequestSchema = z5.object({
+  projectId: z5.string()
+});
+var GetProjectConnectUrlsRequestSchema = z5.object({
+  projectId: z5.string()
+});
+var conveyorCapabilitySchema = z5.enum([
+  "read",
+  "create",
+  "update",
+  "chat",
+  "files",
+  "build"
+]);
+var GetConnectionContextRequestSchema = z5.object({
+  projectId: z5.string(),
+  // Optional board scope (CONVEYOR_SUBPROJECT_ID). Validated to belong to the
+  // project in the handler; an invalid/foreign id is reported, not silently
+  // dropped, so a mis-scoped connection is never presented as board-specific.
+  subProjectId: z5.string().nullable().optional()
+});
+var VerifyConnectionRequestSchema = z5.object({
+  projectId: z5.string(),
+  subProjectId: z5.string().nullable().optional(),
+  intendedActions: z5.array(conveyorCapabilitySchema).optional()
+});
+var ListAccessibleSubprojectsRequestSchema = z5.object({
+  projectId: z5.string()
+});
+var CreateProjectTaskRequestSchema = z5.object({
+  projectId: z5.string(),
+  title: z5.string().min(1),
+  description: cardDescription2,
+  plan: z5.string().optional(),
+  status: z5.string().optional(),
+  // Assign to a sub-project board. Validated to belong to `projectId` in the handler.
+  subProjectId: z5.string().nullable().optional(),
+  requestingUserId: z5.string().optional()
+});
+var SetProjectTaskParentRequestSchema = z5.object({
+  projectId: z5.string(),
+  /** Card to move — id or slug. */
+  taskId: z5.string().min(1),
+  /** New parent (id or slug), or null to detach. */
+  parentTaskId: z5.string().min(1).nullable(),
+  ordinal: z5.number().int().nonnegative().optional(),
+  followParentStatus: z5.boolean().optional(),
+  requestingUserId: z5.string().optional()
+}).strict();
+var UpdateProjectTaskRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  title: z5.string().optional(),
+  description: cardDescription2,
+  plan: z5.string().optional(),
+  // Enum validation lives at the MCP tool layer (mirrors createProjectTask);
+  // the handler routes through the shared updateStatus core (InProgress
+  // dependency check + cleanup/board/Slack side effects), not the stricter
+  // card-type-validating path the Socket.IO updateTaskStatus mutation uses.
+  status: z5.string().optional(),
+  // Canonical risk level, or null to clear. Resolved to the project's
+  // configured Risk row (by rank) in the handler.
+  risk: riskLevelSchema.nullable().optional(),
+  // Story-point value, or null to clear. Resolved to the project's configured
+  // StoryPoint row in the handler, which rejects an unconfigured value.
+  storyPointValue: z5.number().int().positive().nullable().optional(),
+  assignedUserId: z5.string().nullish(),
+  // Move to a different sub-project board, or null to move to the parent board.
+  // Validated to belong to `projectId` in the handler.
+  subProjectId: z5.string().nullable().optional(),
+  // Record the task's ACTUAL working branch (e.g. a locally-driven pack's
+  // branch, so identification never mints a competing name and pack-child
+  // merge handling matches reality), or null to detach. Guarded in the
+  // handler: the ref must exist on origin and no live workspace may be bound
+  // to a different branch.
+  githubBranch: z5.string().min(1).max(GIT_BRANCH_NAME_MAX).refine(isValidGitBranchName, { message: GIT_BRANCH_NAME_MESSAGE }).nullable().optional(),
+  requestingUserId: z5.string().optional()
+}).strict().refine(
+  (v) => v.title !== void 0 || v.description !== void 0 || v.plan !== void 0 || v.status !== void 0 || v.risk !== void 0 || v.storyPointValue !== void 0 || v.assignedUserId !== void 0 || v.subProjectId !== void 0 || v.githubBranch !== void 0,
+  {
+    message: "update_task requires at least one field to change (title, description, plan, status, risk, storyPointValue, assignedUserId, subProjectId, or githubBranch)"
+  }
+);
+var TransitionProjectTaskStatusRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  toStatus: z5.string(),
+  expectedFromStatus: z5.string().optional(),
+  // Optional raise-only risk to attempt alongside the transition
+  // (approve → low, request_changes → medium by default).
+  risk: riskLevelSchema.optional(),
+  requestingUserId: z5.string().optional()
+});
+var MoveProjectCardRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  destinationProjectId: z5.string(),
+  requestingUserId: z5.string().optional()
+});
+var PostToProjectTaskChatRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  content: z5.string(),
+  requestingUserId: z5.string().optional()
+});
+var GetProjectTaskCliRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  limit: z5.number().int().positive().optional().default(50),
+  source: z5.string().optional()
+});
+var GetProjectTaskSessionsRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string()
+});
+var QueryProjectGcpLogsRequestSchema = z5.object({
+  projectId: z5.string(),
+  env: z5.enum(["prod", "dev", "claudespace"]).optional(),
+  severity: z5.enum(["DEBUG", "INFO", "NOTICE", "WARNING", "ERROR", "CRITICAL", "ALERT", "EMERGENCY"]).optional(),
+  services: z5.array(z5.string().min(1).max(200)).max(25).optional(),
+  sqlInstances: z5.array(z5.string().min(1).max(200)).max(25).optional(),
+  allServices: z5.boolean().optional(),
+  search: z5.string().max(256).optional(),
+  filter: z5.string().max(1e3).optional(),
+  startTime: z5.string().optional(),
+  endTime: z5.string().optional(),
+  limit: z5.number().int().min(1).max(200).optional().default(50),
+  pageToken: z5.string().max(4096).optional()
+});
+var QueryProjectGrafanaLogsRequestSchema = z5.object({
+  projectId: z5.string(),
+  env: z5.enum(["prod", "dev"]).optional(),
+  services: z5.array(z5.string().min(1).max(200)).max(25).optional(),
+  level: z5.enum(["debug", "info", "warn", "error", "fatal"]).optional(),
+  search: z5.string().max(256).optional(),
+  logql: z5.string().max(2e3).optional(),
+  startTime: z5.string().optional(),
+  endTime: z5.string().optional(),
+  limit: z5.number().int().min(1).max(200).optional().default(50)
+});
+var driveFileNameSchema = z5.string().min(1).max(255).regex(/^[^/\\\r\n]+$/, "File names cannot contain slashes or line breaks");
+var DRIVE_MAX_CONTENT_CHARS = 1e6;
+var ListProjectDriveFilesRequestSchema = z5.object({
+  projectId: z5.string(),
+  folderId: z5.string().max(200).optional(),
+  search: z5.string().max(200).optional(),
+  limit: z5.number().int().min(1).max(200).optional()
+});
+var ReadProjectDriveFileRequestSchema = z5.object({
+  projectId: z5.string(),
+  fileId: z5.string().min(1).max(200)
+});
+var CreateProjectDriveFileRequestSchema = z5.object({
+  projectId: z5.string(),
+  name: driveFileNameSchema,
+  content: z5.string().max(DRIVE_MAX_CONTENT_CHARS),
+  mimeType: z5.string().max(200).optional(),
+  folderId: z5.string().max(200).optional()
+});
+var UpdateProjectDriveFileRequestSchema = z5.object({
+  projectId: z5.string(),
+  fileId: z5.string().min(1).max(200),
+  content: z5.string().max(DRIVE_MAX_CONTENT_CHARS),
+  mimeType: z5.string().max(200).optional()
+});
+var DeleteProjectDriveFileRequestSchema = z5.object({
+  projectId: z5.string(),
+  fileId: z5.string().min(1).max(200)
+});
+var CreateProjectDriveFolderRequestSchema = z5.object({
+  projectId: z5.string(),
+  name: driveFileNameSchema,
+  folderId: z5.string().max(200).optional()
+});
+var StartProjectBuildRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  requestingUserId: z5.string().optional()
+});
+var StopProjectBuildRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  requestingUserId: z5.string().optional()
+});
+var StartProjectWorkspaceRequestSchema = z5.object({
+  projectId: z5.string(),
+  requestingUserId: z5.string().optional()
+});
+var StopProjectWorkspaceRequestSchema = z5.object({
+  projectId: z5.string(),
+  destroy: z5.boolean().optional(),
+  requestingUserId: z5.string().optional()
+});
+var ListMyLiveSessionsRequestSchema = z5.object({
+  projectId: z5.string(),
+  /** Admin-only: list another member's sessions instead of the caller's. */
+  targetUserId: z5.string().optional()
+});
+var ListProjectSessionGroupsRequestSchema = z5.object({
+  projectId: z5.string()
+});
+var ListMyLiveSessionsAcrossProjectsRequestSchema = z5.object({});
+var ListSessionGroupsAcrossProjectsRequestSchema = z5.object({});
+var GetProjectAvailableTuisRequestSchema = z5.object({
+  projectId: z5.string()
+});
+var StartAdhocSessionRequestSchema = z5.object({
+  projectId: z5.string(),
+  label: z5.string().max(200).optional(),
+  /** Coding-agent key to launch under — validated pick-time (ownership + TUI availability) in the handler. */
+  codingAgentKeyId: z5.string().optional(),
+  /** Model override (Claude model id) — overrides the launch key's own model. */
+  model: z5.string().max(200).optional(),
+  /**
+   * Session role. Constrained: other task-less modes fall through to the pm
+   * runner in the pod entrypoint, and "review" would crash without a task.
+   */
+  mode: z5.enum(["adhoc", "pm"]).optional(),
+  /** Base branch to check out (defaults to the project's dev branch). */
+  branch: z5.string().max(300).optional(),
+  /**
+   * Server-assembled instructions the pod's TUI auto-submits once on first boot
+   * (headless kickoff). Used by the onboarding "Set it up for me" flow to seed a
+   * setup-driver prompt; the session stays watchable/interactive in the Sessions
+   * view. `ensureAdhocWorkspace` persists it and clears it after first submit.
+   */
+  initialPrompt: z5.string().max(2e4).optional(),
+  requestingUserId: z5.string().optional()
+});
+var StopAdhocSessionRequestSchema = z5.object({
+  projectId: z5.string(),
+  workspaceId: z5.string(),
+  destroy: z5.boolean().optional(),
+  requestingUserId: z5.string().optional()
+});
+var ResumeAdhocSessionRequestSchema = z5.object({
+  projectId: z5.string(),
+  workspaceId: z5.string(),
+  requestingUserId: z5.string().optional()
+});
+var RefreshCodingAgentKeyUsageRequestSchema = z5.object({
+  projectId: z5.string(),
+  keyId: z5.string().optional(),
+  requestingUserId: z5.string().optional()
+});
+var ListKeysToProbeRequestSchema = z5.object({
+  sessionId: z5.string()
+});
+var CreateProjectReleaseRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskIds: z5.array(z5.string()).optional(),
+  requestingUserId: z5.string().optional()
+});
+var AddTasksToProjectReleaseRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskIds: z5.array(z5.string()).min(1),
+  requestingUserId: z5.string().optional()
+});
+var ApproveProjectMergePRRequestSchema = z5.object({
+  projectId: z5.string(),
+  childTaskId: z5.string(),
+  requestingUserId: z5.string().optional()
+});
+var ListProjectSubtasksRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string()
+});
+var CreateProjectSubtaskRequestSchema = z5.object({
+  projectId: z5.string(),
+  parentTaskId: z5.string(),
+  title: z5.string().min(1),
+  description: cardDescription2,
+  plan: z5.string().optional(),
+  ordinal: z5.number().int().nonnegative().optional(),
+  storyPointValue: z5.number().int().positive().optional(),
+  followParentStatus: z5.boolean().optional(),
+  /** Sibling subtask ids or slugs this subtask blocks on (explicit dependency
+   * metadata — preferred over encoding order in plan text / ordinal). */
+  dependsOn: z5.array(z5.string().min(1)).max(32).optional(),
+  requestingUserId: z5.string().optional()
+});
+var UpdateProjectSubtaskRequestSchema = z5.object({
+  projectId: z5.string(),
+  subtaskId: z5.string(),
+  title: z5.string().optional(),
+  description: cardDescription2,
+  plan: z5.string().optional(),
+  status: z5.string().optional(),
+  ordinal: z5.number().int().nonnegative().optional(),
+  storyPointValue: z5.number().int().positive().optional(),
+  followParentStatus: z5.boolean().optional(),
+  /** Replace-set of sibling subtask ids/slugs this subtask blocks on ([] clears).
+   * Mirrors the in-pod updateSubtask semantics. */
+  dependsOn: z5.array(z5.string().min(1)).max(32).optional(),
+  requestingUserId: z5.string().optional()
+});
+var DeleteProjectSubtaskRequestSchema = z5.object({
+  projectId: z5.string(),
+  subtaskId: z5.string(),
+  requestingUserId: z5.string().optional()
+});
+var GetProjectTaskChatRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  limit: z5.number().int().positive().optional().default(20)
+});
+var AddProjectTaskDependencyRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  dependsOnSlugOrId: z5.string(),
+  requestingUserId: z5.string().optional()
+});
+var RemoveProjectTaskDependencyRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  dependsOnSlugOrId: z5.string(),
+  requestingUserId: z5.string().optional()
+});
+var VoteProjectSuggestionRequestSchema = z5.object({
+  projectId: z5.string(),
+  suggestionId: z5.string(),
+  value: z5.union([z5.literal(1), z5.literal(-1)]),
+  requestingUserId: z5.string().optional()
+});
+var GetProjectTaskDependenciesRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string()
+});
+var ListProjectTaskFilesRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string()
+});
+var GetProjectAttachmentRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  fileId: z5.string(),
+  /** Byte offset into text content (paging large logs/JSON). Default 0. */
+  offset: z5.number().int().nonnegative().optional(),
+  /** Max bytes of text content to return from `offset`. Server default applies. */
+  maxBytes: z5.number().int().positive().optional()
+});
+var RequestProjectFileUploadRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  fileName: z5.string().min(1).max(255),
+  mimeType: z5.string().min(1).max(128),
+  fileSize: z5.number().int().positive().max(MAX_FILE_SIZE_BYTES),
+  requestingUserId: z5.string().optional()
+});
+var ConfirmProjectFileUploadRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  fileId: z5.string(),
+  /** When set, the attachment is also posted to the task chat with this text. */
+  comment: z5.string().max(2e3).optional(),
+  /** Glossary tag names (or ids) this file is an example of. */
+  tags: z5.array(z5.string().min(1).max(MAX_FILE_TAG_LENGTH)).max(MAX_FILE_TAGS).optional(),
+  requestingUserId: z5.string().optional()
+});
+var CreateProjectPullRequestRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  title: z5.string().min(1),
+  body: z5.string(),
+  head: z5.string().optional(),
+  base: z5.string().optional(),
+  requestingUserId: z5.string().optional()
+});
+var ListProjectMembersRequestSchema = z5.object({
+  projectId: z5.string()
+});
+var AddProjectTaskReviewerRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  userId: z5.string(),
+  requestingUserId: z5.string().optional()
+});
+var RemoveProjectTaskReviewerRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  userId: z5.string(),
+  requestingUserId: z5.string().optional()
+});
+var ListProjectManualTestsRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string()
+});
+var QueryProjectManualTestsRequestSchema = z5.object({
+  projectId: z5.string(),
+  cardStatuses: z5.array(z5.string()).optional(),
+  testStatuses: z5.array(z5.enum(["open", "approved", "rejected"])).optional()
+});
+var SetProjectManualTestsRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  items: z5.array(z5.object({ title: z5.string().min(1) })).min(1),
+  requestingUserId: z5.string().optional()
+});
+var EditProjectManualTestRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  title: z5.string().min(1),
+  newTitle: z5.string().min(1),
+  requestingUserId: z5.string().optional()
+});
+var RemoveProjectManualTestRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  title: z5.string().min(1),
+  requestingUserId: z5.string().optional()
+});
+var ApproveProjectManualTestRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  title: z5.string().min(1),
+  requestingUserId: z5.string().optional()
+});
+var RejectProjectManualTestRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  title: z5.string().min(1),
+  reason: z5.string().min(1).max(2e3),
+  requestingUserId: z5.string().optional()
+});
+var CreateProjectSuggestionRequestSchema = z5.object({
+  projectId: z5.string(),
+  title: z5.string().min(1),
+  description: cardDescription2,
+  tagNames: z5.array(z5.string()).optional(),
+  requestingUserId: z5.string().optional()
+});
+var ListProjectChannelsRequestSchema = z6.object({
+  projectId: z6.string()
+});
+var READ_CHANNEL_MESSAGES_MAX_LIMIT = 50;
+var ReadChannelMessagesRequestSchema = z6.object({
+  projectId: z6.string(),
+  channelId: z6.string().min(1).max(200),
+  limit: z6.number().int().min(1).max(READ_CHANNEL_MESSAGES_MAX_LIMIT).optional(),
+  /** Provider-native cursor: return messages OLDER than this one. */
+  before: z6.string().max(100).optional(),
+  /** Provider-native cursor: return messages NEWER than this one. */
+  after: z6.string().max(100).optional(),
+  /**
+   * Read one thread instead of the channel surface. Slack calls this a
+   * `thread_ts`; on Discord it is the thread channel's id. One field for both,
+   * because a caller holding a `threadTs` from a previous read should not have
+   * to know which provider produced it.
+   */
+  threadTs: z6.string().max(100).optional()
+});
+var POST_CHANNEL_MESSAGE_MAX_CHARS = 1800;
+var PostChannelMessageRequestSchema = z6.object({
+  projectId: z6.string(),
+  channelId: z6.string().min(1).max(200),
+  text: z6.string().min(1).max(POST_CHANNEL_MESSAGE_MAX_CHARS),
+  /** Reply inside a thread rather than to the channel. */
+  threadTs: z6.string().max(100).optional()
+});
+var GET_ANALYTICS_SUMMARY_MAX_RANGE_DAYS = 90;
+var GetProjectAnalyticsSummaryRequestSchema = z6.object({
+  projectId: z6.string(),
+  rangeDays: z6.number().int().min(1).max(GET_ANALYTICS_SUMMARY_MAX_RANGE_DAYS).optional(),
+  campaign: z6.string().max(200).optional()
+});
+var RequestWorkspaceRecycleRequestSchema = z7.object({
+  sessionId: z7.string(),
+  reason: z7.string().max(2e3)
+});
+var ReportApiOutageRequestSchema = z7.object({
+  sessionId: z7.string(),
+  detail: z7.string().max(2e3),
+  attempts: z7.number().int().min(0).max(100)
+});
+var SHA_PATTERN = /^[0-9a-f]{40}$/i;
+var ReviewGuideFileReferenceSchema = z8.object({
+  path: z8.string().min(1).max(500),
+  startLine: z8.number().int().positive().max(1e6).optional(),
+  endLine: z8.number().int().positive().max(1e6).optional(),
+  hunkHeader: z8.string().min(1).max(300).optional()
+}).strict().superRefine((value, ctx) => {
+  if (value.endLine !== void 0 && value.startLine === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["startLine"],
+      message: "startLine is required when endLine is set"
+    });
+  }
+  if (value.startLine !== void 0 && value.endLine !== void 0 && value.endLine < value.startLine) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["endLine"],
+      message: "endLine must be greater than or equal to startLine"
+    });
+  }
+});
+var ReviewGuideSectionSchema = z8.object({
+  title: z8.string().min(1).max(160),
+  explanation: z8.string().min(1).max(2e3),
+  classification: z8.enum(["core", "supporting"]).optional(),
+  files: z8.array(ReviewGuideFileReferenceSchema).min(1).max(20)
+}).strict();
+var ReviewGuideContentSchema = z8.object({
+  overview: z8.string().min(1).max(3e3),
+  sections: z8.array(ReviewGuideSectionSchema).min(1).max(12)
+}).strict();
+var PublishReviewGuideRequestSchema = ReviewGuideContentSchema.extend({
+  sessionId: z8.string().min(1),
+  reviewedSha: z8.string().regex(SHA_PATTERN, "reviewedSha must be a 40-character commit SHA")
+}).strict();
+var CONTEXT_LINK_LOCATOR_MAX = 300;
+var TEST_TITLE = /\b(?:it|test|describe)(?:\.\w+)?\s*\(\s*(['"`])((?:(?!\1)[\s\S])*)\1/g;
+function extractTestTitles(content) {
+  return [...content.matchAll(TEST_TITLE)].map((m) => m[2]);
+}
+function isPlaceholderLocator(locator) {
+  return locator.includes("<") || locator.includes(">");
+}
+function locatorMatchesContent(content, locatorType, locator) {
+  if (locatorType === "code") return content.includes(locator);
+  return extractTestTitles(content).some((title) => title.includes(locator));
+}
+var TAG_DESCRIPTION_MAX = CARD_DESCRIPTION_MAX;
+var TAG_OVERVIEW_MAX = 32e3;
+var TAG_REASON_MAX = 500;
+var ProjectTagContextPathSchema = z9.object({
+  type: z9.enum(["rule", "doc", "file", "folder"]),
+  path: z9.string().min(1).max(500),
+  label: z9.string().max(100).optional(),
+  /** Verified-link tether — text that must keep existing in the file. */
+  locator: z9.string().min(1).max(CONTEXT_LINK_LOCATOR_MAX).regex(/^[^\r\n]*$/, "Locator cannot contain line breaks").optional(),
+  /** test = must appear in a real test/describe title; code = any substring. */
+  locatorType: z9.enum(["test", "code"]).optional()
+}).refine((link) => link.locator === void 0 === (link.locatorType === void 0), {
+  message: "locator and locatorType must be provided together"
+}).refine((link) => link.locator === void 0 || link.type !== "folder", {
+  message: "folder links cannot carry a locator"
+});
+var hexColor = z9.string().regex(/^#[0-9a-fA-F]{6}$/, "Expected #RRGGBB hex color");
+var overviewPathSchema = z9.string().min(1).max(500).regex(/^[^\r\n]*$/, "Overview path cannot contain line breaks");
+var CreateProjectTagRequestSchema = z9.object({
+  projectId: z9.string(),
+  name: z9.string().min(1).max(50),
+  color: hexColor.optional(),
+  description: z9.string().max(TAG_DESCRIPTION_MAX).optional(),
+  overview: z9.string().max(TAG_OVERVIEW_MAX).optional(),
+  /** Source the overview from this repo file (stored overview stays as the pending fallback). */
+  overviewPath: overviewPathSchema.optional(),
+  contextPaths: z9.array(ProjectTagContextPathSchema).max(20).optional(),
+  /** Parents to link at create time (multi-parent DAG). */
+  parentTagIds: z9.array(z9.string()).max(25).optional(),
+  requestingUserId: z9.string().optional()
+});
+var UpdateProjectTagRequestSchema = z9.object({
+  projectId: z9.string(),
+  tagId: z9.string(),
+  name: z9.string().min(1).max(50).optional(),
+  color: hexColor.optional(),
+  description: z9.string().max(TAG_DESCRIPTION_MAX).optional(),
+  /** Full markdown glossary body; null clears it. Rejected while overviewPath is set. */
+  overview: z9.string().max(TAG_OVERVIEW_MAX).nullable().optional(),
+  /** Repo file to source the overview from; null clears back to the stored overview. */
+  overviewPath: overviewPathSchema.nullable().optional(),
+  /** Full replacement of the tag's context links when provided. */
+  contextPaths: z9.array(ProjectTagContextPathSchema).max(20).optional(),
+  /** Full-set replacement of the tag's parent tags (multi-parent DAG). */
+  parentTagIds: z9.array(z9.string()).max(25).optional(),
+  /** One-line revision provenance, recorded in the tag's history. */
+  reason: z9.string().max(TAG_REASON_MAX).optional(),
+  /** Card the caller was working in — stamped into the revision history. */
+  taskId: z9.string().optional(),
+  requestingUserId: z9.string().optional()
+});
+var PostToProjectChatRequestSchema = z9.object({
+  projectId: z9.string(),
+  content: z9.string().min(1).max(2e4),
+  requestingUserId: z9.string().optional(),
+  /** Marks the post so the server can persist it beyond chat (tag-audit summaries land in tag history). */
+  kind: z9.enum(["tag_audit_summary"]).optional()
+});
+var StartTagAuditRequestSchema = z9.object({
+  projectId: z9.string(),
+  requestingUserId: z9.string().optional()
+});
+var StartTaskAuditRequestSchema = z9.object({
+  projectId: z9.string(),
+  taskIds: z9.array(z9.string()).min(1).max(20),
+  requestingUserId: z9.string().optional()
+});
+var GetActiveAuditSessionsRequestSchema = z9.object({
+  projectId: z9.string()
+});
+var ReportTaskAuditResultRequestSchema = z9.object({
+  projectId: z9.string(),
+  taskId: z9.string(),
+  summary: z9.string(),
+  turnGrades: z9.array(
+    z9.object({
+      turnIndex: z9.number(),
+      phase: z9.enum(["planning", "building", "human"]),
+      grade: z9.enum(["correct", "neutral", "blunder"]),
+      reasoning: z9.string(),
+      eventType: z9.string(),
+      eventSummary: z9.string()
+    })
+  ),
+  planningAccuracy: z9.number().nullable(),
+  buildingAccuracy: z9.number().nullable(),
+  humanAccuracy: z9.number().nullable(),
+  planningCorrect: z9.number(),
+  planningNeutral: z9.number(),
+  planningBlunder: z9.number(),
+  buildingCorrect: z9.number(),
+  buildingNeutral: z9.number(),
+  buildingBlunder: z9.number(),
+  humanCorrect: z9.number(),
+  humanNeutral: z9.number(),
+  humanBlunder: z9.number(),
+  humanEvaluations: z9.array(
+    z9.object({
+      messageIndex: z9.number(),
+      rating: z9.union([z9.literal(-1), z9.literal(0), z9.literal(1)]),
+      reasoning: z9.string()
+    })
+  ).optional(),
+  suggestionIds: z9.array(z9.string()),
+  auditCostUsd: z9.number().nullable(),
+  model: z9.string().nullable(),
+  /** When set, the audit is marked failed with this message instead. */
+  error: z9.string().optional()
+});
+var GetTaskAuditsRequestSchema = z9.object({
+  projectId: z9.string(),
+  limit: z9.number().int().positive().max(200).optional().default(50)
+});
+var GetTaskAuditRequestSchema = z9.object({
+  projectId: z9.string(),
+  auditId: z9.string()
+});
+var GetTaskAuditAggregatesRequestSchema = z9.object({
+  projectId: z9.string()
+});
+var DeleteTaskAuditRequestSchema = z9.object({
+  projectId: z9.string(),
+  auditId: z9.string(),
+  requestingUserId: z9.string().optional()
+});
+var MarkInitialPromptSubmittedRequestSchema = z9.object({
+  sessionId: z9.string()
+});
+var CRITICAL_AUTOMATED_SOURCES = /* @__PURE__ */ new Set([
+  "ci_failure",
+  "review_trigger",
+  "merge_conflict",
+  "merge_failed",
+  "pull_branch",
+  // Child-task events for pack parents: the orchestrator must act (merge the
+  // child's PR, start unblocked siblings, finish the pack) even after it
+  // reported completed for a prior turn. Only ever sent to parent tasks.
+  "parent",
+  // The result of a CI wait the agent parked with `wait_for_checks`. The agent
+  // ended its turn BECAUSE it was told to, so the wake that answers it must
+  // clear the completion guard.
+  "ci_result"
+]);
+var MEETING_CHECKLIST_TITLE_MAX = 300;
+var MEETING_TRANSCRIPT_MAX_CHARS = 2e6;
+var MEETING_TITLE_MAX = 200;
+var MEETING_OCCURRED_AT_MIN_YEAR = 2e3;
+var MEETING_OCCURRED_AT_MAX_FUTURE_MS = 48 * 60 * 60 * 1e3;
+var OCCURRED_AT_RANGE_MESSAGE = `occurredAt must be a real date: no earlier than ${MEETING_OCCURRED_AT_MIN_YEAR}, and no more than 48 hours in the future.`;
+var MeetingOccurredAtSchema = z10.string().datetime().refine((value) => {
+  const ms = Date.parse(value);
+  if (Number.isNaN(ms)) return false;
+  if (ms > Date.now() + MEETING_OCCURRED_AT_MAX_FUTURE_MS) return false;
+  return new Date(ms).getUTCFullYear() >= MEETING_OCCURRED_AT_MIN_YEAR;
+}, OCCURRED_AT_RANGE_MESSAGE);
+var CreateMeetingFromTranscriptRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  rawText: z10.string().min(1).max(MEETING_TRANSCRIPT_MAX_CHARS),
+  title: z10.string().min(1).max(MEETING_TITLE_MAX).optional(),
+  /** ISO 8601. Defaults to now when the source carries no date. */
+  occurredAt: MeetingOccurredAtSchema.optional(),
+  /** Override auto-detection. Rarely needed; detection handles the three formats. */
+  format: z10.enum(["text", "vtt", "srt"]).optional(),
+  source: z10.enum(["manual", "slack"]).optional()
+});
+var GetMeetingRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid()
+});
+var UpdateMeetingRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  title: z10.string().min(1).max(MEETING_TITLE_MAX).optional(),
+  occurredAt: MeetingOccurredAtSchema.optional()
+});
+var RegenerateMeetingSummaryRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid()
+});
+var DeleteMeetingRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid()
+});
+var checklistTitle = z10.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX);
+var ListMeetingChecklistRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid()
+});
+var AddMeetingChecklistItemsRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  items: z10.array(z10.object({ title: checklistTitle })).min(1).max(50)
+});
+var UpdateMeetingChecklistItemRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  itemId: z10.string().cuid(),
+  title: checklistTitle.optional(),
+  ordinal: z10.number().int().min(0).optional(),
+  /** Explicit null clears the link; undefined leaves it alone. */
+  linkedTaskId: z10.string().cuid().nullable().optional()
+}).refine(
+  (v) => v.title !== void 0 || v.ordinal !== void 0 || v.linkedTaskId !== void 0,
+  "Pass at least one of title, ordinal, or linkedTaskId."
+);
+var DeleteMeetingChecklistItemRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  itemId: z10.string().cuid()
+});
+var SetMeetingChecklistItemCheckedRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  itemId: z10.string().cuid(),
+  checked: z10.boolean(),
+  /** Attach the card in the same call that ticks the item. */
+  linkedTaskId: z10.string().cuid().nullable().optional()
+});
+var ListMeetingsRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  limit: z10.number().int().min(1).max(50).optional(),
+  search: z10.string().max(200).optional()
+});
+var ReadMeetingTranscriptRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  offset: z10.number().int().min(0).optional(),
+  limit: z10.number().int().min(1).max(500).optional()
+});
+var MEETING_SUMMARY_MAX_CHARS = 5e4;
+var AddProjectMeetingChecklistItemsRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  items: z10.array(z10.object({ title: z10.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX) })).min(1).max(50),
+  requestingUserId: z10.string().optional()
+});
+var CheckProjectMeetingChecklistItemRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  title: z10.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
+  checked: z10.boolean(),
+  /** Card id or slug. Resolved server-side and required to be in the project. */
+  linkedTask: z10.string().min(1).optional(),
+  requestingUserId: z10.string().optional()
+});
+var EditProjectMeetingChecklistItemRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  title: z10.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
+  newTitle: z10.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
+  requestingUserId: z10.string().optional()
+});
+var RemoveProjectMeetingChecklistItemRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  title: z10.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
+  requestingUserId: z10.string().optional()
+});
+var CreateProjectMeetingRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  rawText: z10.string().min(1).max(MEETING_TRANSCRIPT_MAX_CHARS),
+  title: z10.string().min(1).max(MEETING_TITLE_MAX).optional(),
+  occurredAt: MeetingOccurredAtSchema.optional(),
+  requestingUserId: z10.string().optional()
+});
+var UpdateProjectMeetingRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  title: z10.string().min(1).max(MEETING_TITLE_MAX).optional(),
+  occurredAt: MeetingOccurredAtSchema.optional(),
+  summary: z10.string().min(1).max(MEETING_SUMMARY_MAX_CHARS).optional(),
+  requestingUserId: z10.string().optional()
+}).refine(
+  (v) => v.title !== void 0 || v.occurredAt !== void 0 || v.summary !== void 0,
+  "Pass at least one of title, occurredAt, or summary."
+);
+var AGENT_STATUS_REASON_USER_QUESTION = "user_question";
+var TASK_CHAT_HISTORY_LIMIT = 20;
+var PM_CHAT_HISTORY_LIMIT = 40;
+var AGENT_CHAT_HISTORY_FETCH_LIMIT = Math.max(TASK_CHAT_HISTORY_LIMIT, PM_CHAT_HISTORY_LIMIT) + 10;
+function formatModelId(provider, model) {
+  return `${provider}/${model}`;
+}
+function anthropicEntry(model, label, inputPerMillion, outputPerMillion, opts = {}) {
+  return {
+    provider: "anthropic",
+    model,
+    id: formatModelId("anthropic", model),
+    label,
+    format: "anthropic-messages",
+    inputPrice: inputPerMillion / 1e6,
+    outputPrice: outputPerMillion / 1e6,
+    supportsTools: true,
+    supportsEffort: opts.supportsEffort ?? true,
+    ...opts.experimental ? { experimental: true } : {}
+  };
+}
+var ANTHROPIC_CATALOG = [
+  anthropicEntry(DEFAULT_OPUS_MODEL, "Opus 5 Latest", 5, 25),
+  anthropicEntry(PREVIOUS_OPUS_MODEL, "Opus 4.8", 5, 25),
+  anthropicEntry(DEFAULT_SONNET_MODEL, "Sonnet 5 Latest", 3, 15),
+  anthropicEntry(PREVIOUS_SONNET_MODEL, "Sonnet 4.6", 3, 15),
+  // The Haiku line (4.5 and older) predates the tuning surface and 400s on it.
+  anthropicEntry(DEFAULT_HAIKU_MODEL, "Haiku 4.5", 1, 5, { supportsEffort: false }),
+  anthropicEntry(FABLE_MODEL, "Fable 5.1", 10, 50)
+];
+var CODEX_REASONING_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+var DEFAULT_CODEX_CODING_MODEL = "gpt-5.6-terra";
+function isCodexReasoningEffort(value) {
+  return typeof value === "string" && CODEX_REASONING_EFFORTS.includes(value);
+}
+var HUMAN_PROSE_WRITING_STYLE = `## Writing style for humans
+When you write prose a person will read \u2014 chat messages, plan updates, PR titles and bodies, PR review guides (the \`publish_review_guide\` overview and section explanations), review comments \u2014 follow these rules (based on ASD-STE100 Simplified Technical English):
+- Use active voice. Say who does what ("The API rejects the request", not "the request is rejected").
+- Use simple tenses ("we received", not "we have received").
+- One instruction or fact per sentence. Keep sentences under ~20 words.
+- Pick one word for one thing and reuse it. Do not rotate synonyms (check/verify/confirm) for the same action.
+- Prefer the plain, common word ("use", not "utilize"; "start", not "initiate").
+- Do not stack more than 3 nouns in a row ("task queue handler" is the limit).
+- Use a numbered or bulleted list for 3+ steps or conditions instead of burying them in one sentence.
+- Define a technical term on first use when a non-engineer will read the message.
+- Never drop a condition, number, or scope qualifier to shorten a sentence. Precision beats brevity.
+These rules do NOT apply to code, code comments, commit messages, or quoted output.`;
+var CLAUDESPACE_WORKLOAD_LABEL = "rc-workload";
+var CLAUDESPACE_WORKLOAD_VALUE = "claudespace";
+var CONVEYOR_POD_SELECTOR = `${CLAUDESPACE_WORKLOAD_LABEL}=${CLAUDESPACE_WORKLOAD_VALUE}`;
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+var MENTION_TOKEN_REGEX = /@\[(\w+):([^\]]+)\]/g;
+function parseMentions(content) {
+  const tokens = [];
+  for (const match of content.matchAll(MENTION_TOKEN_REGEX)) {
+    tokens.push({ type: match[1], id: match[2] });
+  }
+  return tokens;
+}
+var POSTGRES_ENV = {
+  POSTGRES_HOST_AUTH_METHOD: "trust",
+  POSTGRES_DB: "conveyor"
+};
+var FIREBASE_EMULATOR_COMMAND = [
+  "sh",
+  "-c",
+  `set -e; mkdir -p /home/node && cd /home/node && cat > firebase.json <<'EOF'
+{"emulators":{"auth":{"host":"0.0.0.0","port":9099},"hub":{"host":"0.0.0.0","port":4400},"ui":{"enabled":false}}}
+EOF
+exec firebase emulators:start --only=auth --project=rally-cry-dev`
+];
+var FIREBASE_EMULATOR_ENV = {
+  METADATA_SERVER_DETECTION: "none",
+  GOOGLE_APPLICATION_CREDENTIALS: "/dev/null"
+};
+var CATALOG = {
+  postgresql: {
+    name: "postgresql",
+    image: "postgres:16-alpine",
+    command: [
+      "sh",
+      "-c",
+      // Start postgres, wait for readiness, then create the test database.
+      // Durability flags: service state is ephemeral by design (overlayfs, no
+      // PVC; a crash re-seeds from pod-data), so commits must never wait on a
+      // WAL flush. fsync=off + synchronous_commit=off + full_page_writes=off
+      // remove all blocking storage I/O — without them, per-commit flushes on
+      // the node's network boot disk dominated int-test wall time (~100ms/commit).
+      "if [ ! -s /var/lib/postgresql/data/PG_VERSION ] && [ -d /var/lib/postgresql/pod-data ]; then cp -a /var/lib/postgresql/pod-data/. /var/lib/postgresql/data/; fi; chown -R postgres:postgres /var/lib/postgresql/data; docker-entrypoint.sh postgres -c fsync=off -c synchronous_commit=off -c full_page_writes=off & PID=$!; for i in $(seq 1 30); do pg_isready -U postgres && break; sleep 1; done; createdb -U postgres conveyor_test 2>/dev/null || true; wait $PID"
+    ],
+    ports: [5432],
+    livenessProbe: {
+      exec: ["pg_isready", "-U", "postgres"],
+      periodSeconds: 30,
+      failureThreshold: 3,
+      timeoutSeconds: 5,
+      initialDelaySeconds: 60
+    },
+    env: { ...POSTGRES_ENV },
+    resources: {
+      // postgres runs from the baked seed at /var/lib/postgresql/pod-data via
+      // overlayfs CoW (no emptyDir — see k8s-pod-spec.ts), so WAL + catalog +
+      // re-seed churn charges the container's ephemeral-storage. It must exceed
+      // the ~1Gi ceiling where pods evicted, but is bounded by TWO Autopilot rules:
+      //   1) limit == request — Autopilot caps the limit DOWN to the request at
+      //      admission, so headroom must live on the REQUEST, not just the limit;
+      //   2) the SUM of all container ephemeral requests in a pod must be ≤ 10Gi
+      //      (an emptyDir doesn't escape this: its usage still evicts against the
+      //      container limit, and raising the limit re-hits rule 1 → the cap).
+      // The agent is trimmed to 4Gi (resource-tiers.ts) to free room: with
+      // agent 4 + gcsfuse 1 + lgtm 1 + es/redis/firebase 0.75, postgres gets 3Gi
+      // and the heaviest (URC) pod sits at 9.75Gi + 10Mi for GCS Fuse metadata
+      // prefetch — under the 10Gi cap — while giving postgres 3x the ~1Gi
+      // ceiling that evicted. Keep request == limit;
+      // see the per-pod ephemeral budget guard test.
+      // CPU: the request is the CFS floor; the old 50m starved postgres to 5ms
+      // of CPU per 100ms period — every query burst hit throttle stalls, which
+      // showed up as ~100ms floors on trivial statements and dominated the API
+      // int suite even after the fsync flags above. 250m is paid for out of the
+      // workbench's derived share (resource-tiers.ts); measured across the fleet
+      // postgres peaks at 0.66 cores and idles far below 250m, and the limit
+      // (unchanged at 2) is what serves the peaks: the first-boot pod-data seed
+      // copy and int-suite query storms borrow idle node CPU without moving the
+      // request.
+      requests: { cpuMillicores: 250, memoryMi: 512, ephemeralMi: 3 * 1024 },
+      limits: { cpuMillicores: 2e3, memoryMi: 512, ephemeralMi: 3 * 1024 }
+    },
+    connectionEnv: {
+      DATABASE_URL: "postgresql://postgres@postgresql:5432/conveyor",
+      TEST_DATABASE_URL: "postgresql://postgres@postgresql:5432/conveyor_test"
+    },
+    statefulBake: true,
+    bake: {
+      // Start postgres, wait for readiness, then create the test database so
+      // it's baked into the committed image. No pod-data restore (nothing is
+      // seeded yet) and no durability flags (the bake's writes must land).
+      // NOTE: docker-compose interpolates `$VAR`/`$(...)`, so every `$` that
+      // must reach the shell is doubled.
+      command: [
+        "sh",
+        "-c",
+        "docker-entrypoint.sh postgres & PID=$$!; for i in $$(seq 1 30); do pg_isready -U postgres && break; sleep 1; done; createdb -U postgres conveyor_test 2>/dev/null || true; wait $$PID"
+      ],
+      environment: { ...POSTGRES_ENV },
+      healthcheck: {
+        test: ["CMD-SHELL", "pg_isready -U postgres"],
+        intervalSec: 2,
+        timeoutSec: 5,
+        retries: 15
+      }
+    }
+  },
+  redis: {
+    name: "redis",
+    image: "redis:7-alpine",
+    command: ["redis-server", "--appendonly", "yes", "--dir", "/data"],
+    ports: [6379],
+    env: {},
+    resources: {
+      requests: { cpuMillicores: 25, memoryMi: 32, ephemeralMi: 256 },
+      limits: { cpuMillicores: 50, memoryMi: 64, ephemeralMi: 256 }
+    },
+    connectionEnv: {
+      REDIS_URL: "redis://redis:6379",
+      AUTH_REDIS_URL: "redis://redis:6379"
+    },
+    statefulBake: false,
+    // Redis holds no baked state, so the bake runs the stock image CMD.
+    bake: {},
+    mirror: { src: "redis:7-alpine", dest: "mirror-redis:7-alpine" }
+  },
+  elasticsearch: {
+    name: "elasticsearch",
+    // 9.4.0 matches universal-rally-cry's local compose + its v9 ES client —
+    // the v9 client sends Accept: compatible-with=9, which an 8.x server
+    // rejects (media_type_header_exception), breaking search/audit indexing
+    // in pods. 512m heap matches the project compose sizing.
+    image: "docker.elastic.co/elasticsearch/elasticsearch:9.4.0",
+    mirror: {
+      src: "docker.elastic.co/elasticsearch/elasticsearch:9.4.0",
+      dest: "mirror-elasticsearch:9.4.0"
+    },
+    ports: [9200],
+    // Baked service images are `docker commit`s of a recently-running ES, so
+    // they carry a stale data-dir node.lock; ES 9 hard-fails on it at boot
+    // ("Underlying file changed by an external force" → AlreadyClosedException).
+    // Clear it before handing off to the stock entrypoint.
+    command: [
+      "sh",
+      "-c",
+      // ALL Lucene lock files, not just node.lock — the baked image also
+      // carries per-index write.lock + snapshot_cache/write.lock, and ES 9
+      // fail-fasts on any of them ("changed by an external force").
+      "find /usr/share/elasticsearch/data -name '*.lock' -type f -delete 2>/dev/null; exec /usr/local/bin/docker-entrypoint.sh eswrapper"
+    ],
+    env: {
+      "discovery.type": "single-node",
+      "xpack.security.enabled": "false",
+      "xpack.ml.enabled": "false",
+      "xpack.watcher.enabled": "false",
+      "xpack.profiling.enabled": "false",
+      "ingest.geoip.downloader.enabled": "false",
+      ES_JAVA_OPTS: "-Xms512m -Xmx512m"
+    },
+    resources: {
+      // CPU limit 8x the request: ES cold-start is a CPU-bound JVM boot
+      // (class loading + JIT + recovery of the docker-commit'ed data dir),
+      // and a 500m hard cap put it at ~135s to yellow, past the sidecar
+      // wait script's original 90s budget. Bursting to 2 cut it to ~40s on
+      // the real cluster (A/B on identical nodes, 2 rounds). The burst only
+      // borrows idle node CPU at boot; under contention CFS still floors ES
+      // at its request. That request is 250m: the fleet-wide peak is 1.6
+      // cores (served by the limit) and steady state is far below 250m, so
+      // the old 500m only inflated the billed pod total.
+      requests: { cpuMillicores: 250, memoryMi: 1024, ephemeralMi: 256 },
+      limits: { cpuMillicores: 2e3, memoryMi: 1024, ephemeralMi: 256 }
+    },
+    connectionEnv: {
+      ELASTICSEARCH_URL: "http://elasticsearch:9200"
+    },
+    statefulBake: true,
+    bake: {
+      // No lock-clearing command at bake time: the bake starts from the stock
+      // image, which has no committed data dir to unlock yet.
+      environment: {
+        "discovery.type": "single-node",
+        "xpack.security.enabled": "false",
+        ES_JAVA_OPTS: "-Xms512m -Xmx512m"
+      }
+    }
+  },
+  // All-in-one image bundling Grafana + Loki + Tempo + Mimir + an OTEL Collector.
+  // Pinned tag (not :latest) so the image-builder content hash stays
+  // deterministic across upstream releases — see image-builder.ts content-hash
+  // dedup keyed on `deps.sorted()`.
+  lgtm: {
+    name: "lgtm",
+    image: "grafana/otel-lgtm:0.11.6",
+    // The otel-lgtm image's own CMD is ["/otel-lgtm/run-all.sh"] (WORKDIR
+    // /otel-lgtm). Declaring it explicitly makes lgtm a command-based service so
+    // the lazy start-file gate wraps it like the others — otherwise it launches
+    // via image CMD at boot and can't be parked (which is why warm-booting it at
+    // a minimal request OOMKilled it). getSidecarSpecs strips this command for a
+    // baked lgtm image, so it only applies to the stock image whose launcher is
+    // exactly this path.
+    command: ["/otel-lgtm/run-all.sh"],
+    ports: [
+      // OTLP gRPC + HTTP — agents and user code emit telemetry here.
+      4317,
+      4318,
+      // Grafana UI — reachable through the existing preview proxy on
+      // https://3000-{sessionId}.preview.<PREVIEW_DOMAIN>/.
+      3e3
+    ],
+    env: {
+      // The pod is per-task; the preview proxy authenticates the session
+      // upstream, so anonymous in-pod admin is acceptable here.
+      GF_AUTH_ANONYMOUS_ENABLED: "true",
+      GF_AUTH_ANONYMOUS_ORG_ROLE: "Admin",
+      GF_SECURITY_ALLOW_EMBEDDING: "true",
+      ENABLE_LOGS_GRAFANA: "true",
+      ENABLE_LOGS_OTELCOL: "true"
+    },
+    resources: {
+      // Autopilot caps the ephemeral-storage limit to the request (see the
+      // postgresql note), so the 1Gi headroom must be on the request too.
+      // CPU: the collector draws ~0.3 cores at idle fleet-wide, so the request
+      // stays at 250m to cover that draw under node contention (a request
+      // below usage is a container CFS throttles continuously); the 1-core
+      // limit covers ingest bursts.
+      requests: { cpuMillicores: 250, memoryMi: 1024, ephemeralMi: 1024 },
+      limits: { cpuMillicores: 1e3, memoryMi: 2048, ephemeralMi: 1024 }
+    },
+    statefulBake: false,
+    // No `bake` block: a BAKE produces traces nobody reads, so starting the
+    // (heavy) collector image would only add a pull + boot to every build.
+    // lgtm still runs for live pods, and is never committed regardless.
+    mirror: { src: "grafana/otel-lgtm:0.11.6", dest: "mirror-otel-lgtm:0.11.6" }
+  },
+  "firebase-auth-emulator": {
+    name: "firebase-auth-emulator",
+    image: "andreysenov/firebase-tools:latest",
+    command: FIREBASE_EMULATOR_COMMAND,
+    ports: [9099, 4400],
+    env: {
+      // The emulator container inherits the pod's Workload Identity, so
+      // firebase-tools finds GCP credentials and its `emulators:start` does an
+      // online "auto auth" + project validation that stalls ~47s on the pod's
+      // locked-down egress (the dominant service boot cost — measured live).
+      // The emulator needs NO real credentials, so cut off credential discovery
+      // for this container only: google-auth-library skips metadata detection
+      // and finds no key file, firebase-tools logs "not authenticated" and
+      // starts the emulator immediately. The agent container keeps its WI.
+      ...FIREBASE_EMULATOR_ENV
+    },
+    resources: {
+      requests: { cpuMillicores: 100, memoryMi: 256, ephemeralMi: 256 },
+      limits: { cpuMillicores: 500, memoryMi: 512, ephemeralMi: 256 }
+    },
+    connectionEnv: {
+      // In docker-compose, services reach each other by service name — the
+      // runtime pod equivalents use `localhost` because co-located services
+      // share the pod's network namespace.
+      FIREBASE_AUTH_EMULATOR_HOST: "firebase-auth-emulator:9099",
+      NEXT_PUBLIC_FIREBASE_AUTH_EMULATOR_HOST: "firebase-auth-emulator:9099"
+    },
+    statefulBake: false,
+    mirror: {
+      src: "andreysenov/firebase-tools:latest",
+      dest: "mirror-firebase-tools:latest"
+    },
+    bake: {
+      // The emulator writes its config at startup, so the bake needs the same
+      // inline command the runtime uses.
+      command: FIREBASE_EMULATOR_COMMAND,
+      environment: FIREBASE_EMULATOR_ENV,
+      healthcheck: {
+        // Probe with node, the one runtime this image guarantees. The image
+        // (`andreysenov/firebase-tools`) is a slim Node image that ships
+        // NEITHER `wget` NOR `curl`, so the `wget -qO- …` probe this replaced
+        // exited 127 on every attempt: a healthy emulator burned all 20 retries
+        // and every bake reported it unhealthy. See the catalog invariant in
+        // `service-definitions.test.ts`, which also executes this probe.
+        test: [
+          "CMD-SHELL",
+          `node -e "fetch('http://localhost:9099/').then((response) => process.exit(response.ok ? 0 : 1)).catch(() => process.exit(1))"`
+        ],
+        intervalSec: 3,
+        timeoutSec: 5,
+        retries: 20
+      }
+    }
+  }
+};
+var SERVICE_DEFINITIONS = CATALOG;
+var SUPPORTED_CLAUDESPACE_DEPS = Object.keys(CATALOG);
+var STATEFUL_BAKE_DEPS = new Set(
+  SUPPORTED_CLAUDESPACE_DEPS.filter((dep) => SERVICE_DEFINITIONS[dep].statefulBake)
+);
+var MIRRORABLE_SIDECARS = Object.fromEntries(
+  SUPPORTED_CLAUDESPACE_DEPS.flatMap((dep) => {
+    const mirror = SERVICE_DEFINITIONS[dep].mirror;
+    return mirror ? [[dep, mirror]] : [];
+  })
+);
+var LEVELS_PER_BAND = 100;
+var PRESTIGE_TIERS = ACHIEVEMENT_RARITIES.map((rarity, index) => ({
+  prestige: index + 1,
+  name: rarity.name,
+  color: rarity.color,
+  iconPath: rarity.iconPath,
+  minLevel: (index + 1) * LEVELS_PER_BAND
+}));
+var TOP_PRESTIGE_BAND = PRESTIGE_TIERS.length;
+var POD_PROFILES = ["full", "reader"];
+var POD_PROFILE_ENV = "CONVEYOR_POD_PROFILE";
+function podProfileRunsWorkload(profile) {
+  return profile === "full";
+}
+function isPodProfile(value) {
+  return typeof value === "string" && POD_PROFILES.includes(value);
+}
+var PRE_BUILD_TASK_STATUSES = /* @__PURE__ */ new Set(["Planning", "Open"]);
+function hasTaskPlan(plan) {
+  return !!plan?.trim();
+}
+var CARD_TYPE_SURFACE = {
+  task: "board",
+  chat: "board",
+  incident: "report",
+  suggestion: "report"
+};
+var surfaceTypes = (surface) => Object.keys(CARD_TYPE_SURFACE).filter(
+  (type) => CARD_TYPE_SURFACE[type] === surface
+);
+var BOARD_CARD_TYPES = surfaceTypes("board");
+var REPORT_CARD_TYPES = surfaceTypes("report");
+
+// 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_SONNET_MODEL,
+  FABLE_MODEL,
+  PTY_STREAM_PORT_BASE,
+  PTY_STREAM_PORT_ATTEMPTS,
+  encodePtyStreamFrame,
+  PtyStreamFrameReader,
+  CARD_DESCRIPTION_FIELD_HINT,
+  DEFAULT_CI_WAIT_TIMEOUT_MINUTES,
+  MAX_CI_WAIT_TIMEOUT_MINUTES,
+  SEVERITY_ENUM,
+  runQueryGcpLogs,
+  runQueryGrafanaLogs,
+  EXTERNAL_AGENT_MESSAGE_SOURCE,
+  TUI_KINDS,
+  MAX_FILE_SIZE_BYTES,
+  RUNNER_MODES,
+  ReviewGuideContentSchema,
+  CONTEXT_LINK_LOCATOR_MAX,
+  isPlaceholderLocator,
+  locatorMatchesContent,
+  TAG_DESCRIPTION_MAX,
+  TAG_OVERVIEW_MAX,
+  TAG_REASON_MAX,
+  CRITICAL_AUTOMATED_SOURCES,
+  AGENT_STATUS_REASON_USER_QUESTION,
+  TASK_CHAT_HISTORY_LIMIT,
+  PM_CHAT_HISTORY_LIMIT,
+  DEFAULT_CODEX_CODING_MODEL,
+  isCodexReasoningEffort,
+  HUMAN_PROSE_WRITING_STYLE,
+  parseMentions,
+  POD_PROFILE_ENV,
+  podProfileRunsWorkload,
+  isPodProfile,
+  PRE_BUILD_TASK_STATUSES,
+  hasTaskPlan,
+  DEFAULT_LIFECYCLE_CONFIG,
+  Lifecycle,
+  readWorkspaceFile,
+  readWorkspaceBytes,
+  readWorkspaceDir,
+  statWorkspacePath,
+  workspacePathExists,
+  GIT_TIMEOUT_MS,
+  git,
+  updateRemoteToken,
+  verifyGitCredential,
+  forceFreshMintBlocked,
+  recordForceFreshFailure,
+  clearForceFreshCooldown,
+  forceFreshCooldownNotice,
+  ensureOnTaskBranch,
+  hasUncommittedChanges,
+  getCurrentBranch,
+  hasUnpushedCommits,
+  remoteMatchesLocalHead,
+  stageAndCommit,
+  restoreWipSnapshot,
+  flushPendingChanges,
+  pushToOrigin,
+  flushAllPendingWork,
+  awaitGitReady,
+  PortDiscovery,
+  CodespacePortVisibility,
+  loadForwardPorts,
+  buildSessionPreviewPorts,
+  loadConveyorConfig
+};