@rallycry/conveyor-agent 10.2.5 → 10.3.0

package/dist/{chunk-CFELRV35.js → chunk-AMPYOJJC.js}

@@ -2035,6 +2035,10 @@ var SessionStopRequestSchema = z.object({
   sessionId: z.string(),
   reason: z.string().optional()
 });
+var EndReviewSessionRequestSchema = z.object({
+  sessionId: z.string(),
+  reason: z.enum(["approved", "changes_requested", "finished"]).optional()
+});
 var ConnectAgentRequestSchema = z.object({
   sessionId: z.string()
 });
@@ -2647,9 +2651,15 @@ 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;
+var PRE_BUILD_TASK_STATUSES = /* @__PURE__ */ new Set(["Planning", "Open"]);
+function hasTaskPlan(plan) {
+  return !!plan?.trim();
+}
+function taskNeedsPlanning(task) {
+  return !hasTaskPlan(task.plan) && PRE_BUILD_TASK_STATUSES.has(task.status) && !task.githubPRUrl;
+}
 
 // src/runner/mode-controller.ts
-var FRESH_AUTO_STATUSES = /* @__PURE__ */ new Set(["Planning", "Open"]);
 var ModeController = class {
   _mode;
   _hasExitedPlanMode = false;
@@ -2734,28 +2744,28 @@ var ModeController = class {
     return this._mode;
   }
   /**
-   * A FRESH auto task runs the read-only plan turn first (`--permission-mode plan`):
-   * resolveInitialMode leaves it in `auto` with `_hasExitedPlanMode = false`, and
-   * once the agent finishes it calls ExitPlanMode → building. Only tasks that have
-   * already progressed past the fresh stage bypass planning and build immediately
-   * with `--dangerously-skip-permissions`:
+   * An auto task that still NEEDS PLANNING (no plan saved, pre-build status, no
+   * PR — see `taskNeedsPlanning` in @project/shared) runs the read-only plan turn
+   * first (`--permission-mode plan`): resolveInitialMode leaves it in `auto` with
+   * `_hasExitedPlanMode = false`, and once the agent finishes it calls
+   * ExitPlanMode → building. Everything else bypasses planning and builds
+   * immediately with `--dangerously-skip-permissions`:
    *
-   * - a build already underway (status past `Planning`/`Open`),
-   * - a PR already open (safety net if status lags),
-   * - a release (booted `InProgress`), or
-   * - a pod restart mid-build (DB `agentMode` stays `"auto"` but status advanced).
+   * - a plan already on the card (e.g. a Planning card planned by a human/PM),
+   * - a build already underway (status past `Planning`/`Open` — releases booted
+   *   `InProgress`, pod restarts mid-build where DB `agentMode` stays `"auto"`),
+   * - a PR already open (safety net if status lags).
    *
    * Runtime Build-after-Discovery never reaches this gate as `auto` — the server's
-   * `resolveModeToSend` rewrites it to `"building"` for any non-`Planning` task.
+   * `resolveModeToSend` rewrites it to `"building"` for any task with a plan.
    */
   canBypassPlanning(context) {
     if (this._mode !== "auto") return false;
-    if (!FRESH_AUTO_STATUSES.has(context.status)) return true;
-    return !!context.githubPRUrl;
+    return !taskNeedsPlanning(context);
   }
   // ── Mode transitions ───────────────────────────────────────────────
   /** Handle mode change from server */
-  handleModeChange(newMode) {
+  handleModeChange(newMode, context) {
     if (newMode === this._mode) return { type: "noop" };
     if (this._runnerMode === "task" && newMode === "review") {
       this._mode = newMode;
@@ -2770,7 +2780,7 @@ var ModeController = class {
     if (this._runnerMode === "task" && newMode === "auto") {
       this._mode = newMode;
       this._isAuto = true;
-      this._hasExitedPlanMode = true;
+      this._hasExitedPlanMode = !context || !taskNeedsPlanning(context);
       return { type: "restart_query", newMode: "auto" };
     }
     if (this._mode === "auto" && this._hasExitedPlanMode && newMode === "building") {
@@ -2941,6 +2951,11 @@ var Lifecycle = class {
 };
 
 // src/harness/types.ts
+function isExternalMcpStdioServer(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return v.type === "stdio" && typeof v.command === "string";
+}
 function defineTool(name, description, schema, handler, options) {
   return {
     name,
@@ -3905,6 +3920,15 @@ async function startToolServers(mcpServers, tempDir) {
   const servers = [];
   const config = {};
   for (const [name, handle] of Object.entries(mcpServers)) {
+    if (isExternalMcpStdioServer(handle)) {
+      config[name] = {
+        type: "stdio",
+        command: handle.command,
+        ...handle.args ? { args: handle.args } : {},
+        ...handle.env ? { env: handle.env } : {}
+      };
+      continue;
+    }
     const tools = handle instanceof PtyMcpServer ? handle.tools : [];
     if (tools.length === 0) continue;
     const server = new PtyToolServer(name, tools);
@@ -4164,11 +4188,14 @@ var PLAN_DIALOG_INTERVAL_MS = 1500;
 var PLAN_DIALOG_SLOW_INTERVAL_MS = 5e3;
 var PLAN_DIALOG_FAST_WINDOW_MS = 1e4;
 var PLAN_DIALOG_WINDOW_MS = 9e4;
+function envMs(name, fallback) {
+  const raw = Number(process.env[name]);
+  return Number.isFinite(raw) && raw > 0 ? raw : fallback;
+}
+function resolveSubmitSettleMs() {
+  return envMs("CONVEYOR_PTY_SUBMIT_SETTLE_MS", SUBMIT_SETTLE_MS);
+}
 function resolveSubmitNudgeTiming() {
-  const envMs = (name, fallback) => {
-    const raw = Number(process.env[name]);
-    return Number.isFinite(raw) && raw > 0 ? raw : fallback;
-  };
   return {
     intervalMs: envMs("CONVEYOR_PTY_NUDGE_INTERVAL_MS", SUBMIT_NUDGE_INTERVAL_MS),
     slowIntervalMs: envMs("CONVEYOR_PTY_NUDGE_SLOW_INTERVAL_MS", SUBMIT_NUDGE_SLOW_INTERVAL_MS),
@@ -4176,6 +4203,15 @@ function resolveSubmitNudgeTiming() {
     windowMs: envMs("CONVEYOR_PTY_NUDGE_WINDOW_MS", SUBMIT_NUDGE_WINDOW_MS)
   };
 }
+function resolvePlanDialogTiming() {
+  return {
+    firstPressMs: envMs("CONVEYOR_PTY_PLAN_DIALOG_FIRST_PRESS_MS", PLAN_DIALOG_FIRST_PRESS_MS),
+    intervalMs: envMs("CONVEYOR_PTY_PLAN_DIALOG_INTERVAL_MS", PLAN_DIALOG_INTERVAL_MS),
+    slowIntervalMs: envMs("CONVEYOR_PTY_PLAN_DIALOG_SLOW_INTERVAL_MS", PLAN_DIALOG_SLOW_INTERVAL_MS),
+    fastWindowMs: envMs("CONVEYOR_PTY_PLAN_DIALOG_FAST_WINDOW_MS", PLAN_DIALOG_FAST_WINDOW_MS),
+    windowMs: envMs("CONVEYOR_PTY_PLAN_DIALOG_WINDOW_MS", PLAN_DIALOG_WINDOW_MS)
+  };
+}
 function turnOptionsFrom(options) {
   return {
     canUseTool: options.canUseTool,
@@ -4727,7 +4763,7 @@ var PtySession = class {
     if (text === "" && !this.adapter.capabilities.prefill) return;
     this.writeStdin(this.adapter.encodePromptBytes(text));
     if (this.turn.promptDelivery === "prefill") return;
-    await sleep3(SUBMIT_SETTLE_MS);
+    await sleep3(resolveSubmitSettleMs());
     if (this._toreDown) return;
     this.writeStdin("\r");
     if (this.adapter.capabilities.structuredEvents) this.armSubmitNudge();
@@ -4844,10 +4880,11 @@ var PtySession = class {
     if (this.pendingPlanApproval) return;
     this.pendingPlanApproval = true;
     const startedAt = Date.now();
+    const { firstPressMs, intervalMs, slowIntervalMs, fastWindowMs, windowMs } = resolvePlanDialogTiming();
     const press = () => {
       if (this._toreDown || !this.pendingPlanApproval) return;
       const elapsed = Date.now() - startedAt;
-      if (elapsed >= PLAN_DIALOG_WINDOW_MS) {
+      if (elapsed >= windowMs) {
         process.stderr.write(
           "[PtySession] plan-dialog auto-accept window expired without ExitPlanMode executing \u2014 the approval dialog may still be parked\n"
         );
@@ -4855,10 +4892,10 @@ var PtySession = class {
         return;
       }
       this.writeStdin("\r");
-      const interval = elapsed < PLAN_DIALOG_FAST_WINDOW_MS ? PLAN_DIALOG_INTERVAL_MS : PLAN_DIALOG_SLOW_INTERVAL_MS;
+      const interval = elapsed < fastWindowMs ? intervalMs : slowIntervalMs;
       this.planApprovalTimer = setTimeout(press, interval);
     };
-    this.planApprovalTimer = setTimeout(press, PLAN_DIALOG_FIRST_PRESS_MS);
+    this.planApprovalTimer = setTimeout(press, firstPressMs);
   }
   disarmPlanDialogAutoAccept() {
     this.pendingPlanApproval = false;
@@ -5141,7 +5178,7 @@ function buildPackRunnerSystemPrompt(context, config, setupLog) {
     `   - "ReviewDev" / "Complete": Already done. Skip.`,
     `   - "Planning": Not ready. If blocking progress, notify team.`,
     ``,
-    `3. Fire ALL ready "Open" tasks whose dependencies are met, not just one. Independent tasks can run in parallel.`,
+    `3. Fire ALL ready "Open" tasks whose dependencies are met, not just one \u2014 independent tasks run in parallel. There is a concurrency limit: if start_child_cloud_build returns a PACK_CHILD_LIMIT error, that is backpressure, not a failure. Merge or wait on in-flight children, then start more as slots free up.`,
     ``,
     `4. After merging a PR: run \`git pull origin ${context.baseBranch}\` then re-check list_subtasks \u2014 previously blocked tasks may now be ready.`,
     ``,
@@ -5150,9 +5187,9 @@ function buildPackRunnerSystemPrompt(context, config, setupLog) {
     `6. When ALL children are in "ReviewDev" or "Complete" (no "Open", "InProgress", or "ReviewPR" remaining): do a final review, summarize results in chat, and mark this parent task complete with force_update_task_status("Complete").`,
     ``,
     `## Important Rules`,
-    `- When dependencies are set on children, use them to determine execution order. Fire all ready tasks in parallel.`,
+    `- When dependencies are set on children, use them to determine execution order. Fire all ready tasks in parallel (up to the PACK_CHILD_LIMIT backpressure \u2014 see the loop above).`,
     `- When NO dependencies are set on any children, fall back to ordinal order (one at a time). This preserves backward compatibility.`,
-    `- After firing builds OR when waiting on CI, explicitly state you are going idle. The system will disconnect you and relaunch when there's a status change.`,
+    `- After firing builds OR when waiting on CI, explicitly state you are going idle. Go idle when waiting \u2014 the system wakes you (or relaunches this environment) when a child changes status.`,
     `- Do NOT attempt to write code yourself. Your role is coordination only.`,
     `- If a child is stuck in "InProgress" for an unusually long time, use get_execution_logs(childTaskId) to check its logs and escalate to the team if it appears stuck.`,
     `- You can use get_task(childTaskId) to get a child's full details including PR URL and branch.`,
@@ -6064,7 +6101,7 @@ Git safety \u2014 STRICT rules:`,
 function buildSystemPrompt(mode, context, config, setupLog, agentMode) {
   const isPm = mode === "pm";
   const isPmActive = isPm && agentMode === "building";
-  const isPackRunner = isPm && !!config.isAuto && !!context.isParentTask;
+  const isPackRunner = mode === "pack" || isPm && !!config.isAuto && !!context.isParentTask;
   if (isPackRunner) {
     return buildPackRunnerSystemPrompt(context, config, setupLog);
   }
@@ -6393,7 +6430,7 @@ Address the requested changes directly. Do NOT re-investigate the codebase from
   return parts;
 }
 function buildIdleRelaunchInstructions(context, isPm, agentMode, isAuto) {
-  if (isPm && agentMode === "auto" && context.status === "Planning") {
+  if (isPm && agentMode === "auto" && PRE_BUILD_TASK_STATUSES.has(context.status ?? "")) {
     if (context.plan?.trim()) {
       return [
         `You were relaunched in auto mode. A plan already exists for this task.`,
@@ -6455,7 +6492,7 @@ function buildInstructions(mode, context, scenario, agentMode, isAuto) {
   return parts;
 }
 async function buildInitialPrompt(mode, context, isAuto, agentMode) {
-  const isPackRunner = mode === "pm" && !!isAuto && !!context.isParentTask;
+  const isPackRunner = mode === "pack" || mode === "pm" && !!isAuto && !!context.isParentTask;
   if (!isPackRunner) {
     const sessionRelaunch = buildRelaunchWithSession(mode, context, agentMode, isAuto);
     if (sessionRelaunch) return sessionRelaunch;
@@ -7562,6 +7599,12 @@ function buildDiscoveryTools(connection) {
 
 // src/tools/code-review-tools.ts
 import { z as z10 } from "zod";
+async function endReviewSession(connection, reason) {
+  await connection.call("endReviewSession", {
+    sessionId: connection.sessionId,
+    reason
+  });
+}
 function buildCodeReviewTools(connection) {
   return [
     defineTool(
@@ -7584,6 +7627,7 @@ ${summary}`;
           result: "approved",
           summary
         });
+        await endReviewSession(connection, "approved");
         return textResult("Code review approved. Exiting.");
       }
     ),
@@ -7622,6 +7666,7 @@ ${issueLines}`;
           summary,
           issues
         });
+        await endReviewSession(connection, "changes_requested");
         return textResult("Code review complete \u2014 changes requested. Exiting.");
       }
     )
@@ -7636,6 +7681,9 @@ function getTaskModeTools(agentMode, connection) {
   return [];
 }
 function getModeTools(agentMode, connection, config, context) {
+  if (config.mode === "pack") {
+    return buildPmTools(connection, { includePackTools: true });
+  }
   if (config.mode === "task") return getTaskModeTools(agentMode, connection);
   switch (agentMode) {
     case "building":
@@ -7667,6 +7715,49 @@ function createConveyorMcpServer(harness, connection, config, context, agentMode
   });
 }
 
+// src/harness/pty/adapters/types.ts
+import { accessSync, constants, statSync } from "fs";
+import { join as join6 } from "path";
+var TuiUnavailableError = class extends Error {
+  constructor(tui, message) {
+    super(message);
+    this.tui = tui;
+    this.name = "TuiUnavailableError";
+  }
+  tui;
+};
+function isExecutable(path4) {
+  try {
+    if (!statSync(path4).isFile()) return false;
+    accessSync(path4, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findOnPath(binary, env = process.env) {
+  if (binary.includes("/")) {
+    return isExecutable(binary) ? binary : null;
+  }
+  for (const dir of (env.PATH ?? "").split(":")) {
+    if (!dir) continue;
+    const candidate = join6(dir, binary);
+    if (isExecutable(candidate)) return candidate;
+  }
+  return null;
+}
+
+// src/execution/playwright-mcp.ts
+var PLAYWRIGHT_MCP_BINARIES = ["playwright-mcp", "mcp-server-playwright"];
+var PLAYWRIGHT_MCP_ARGS = ["--browser", "chromium", "--headless", "--no-sandbox", "--isolated"];
+function resolvePlaywrightMcpServer(env = process.env) {
+  for (const binary of PLAYWRIGHT_MCP_BINARIES) {
+    const command = findOnPath(binary, env);
+    if (command) return { type: "stdio", command, args: [...PLAYWRIGHT_MCP_ARGS] };
+  }
+  return null;
+}
+
 // src/execution/event-handlers.ts
 var logger = createServiceLogger("event-handlers");
 function safeVoid(promise, context) {
@@ -8560,7 +8651,13 @@ function buildQueryOptions(host, context) {
     planDialogAutoAccept: mode === "auto" && !host.hasExitedPlanMode,
     tools: { type: "preset", preset: "claude_code" },
     mcpServers: {
-      conveyor: createConveyorMcpServer(host.harness, host.connection, host.config, context, mode)
+      conveyor: createConveyorMcpServer(host.harness, host.connection, host.config, context, mode),
+      // Baked-in browser automation (claudespace pods) — omitted when the
+      // binary isn't on PATH (dev machines, legacy images).
+      ...(() => {
+        const playwright = resolvePlaywrightMcpServer();
+        return playwright ? { playwright } : {};
+      })()
     },
     sandbox: context.useSandbox ? { enabled: true } : { enabled: false },
     hooks: buildHooks(host),
@@ -9337,7 +9434,7 @@ var QueryBridge = class {
 
 // src/runner/session-runner-helpers.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2, join as join6 } from "path";
+import { dirname as dirname2, join as join7 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function mapChatHistory(messages) {
   if (!messages) return [];
@@ -9366,7 +9463,7 @@ function readAgentVersion() {
     const here = dirname2(fileURLToPath2(import.meta.url));
     for (const rel of ["../package.json", "../../package.json"]) {
       try {
-        const pkg = JSON.parse(readFileSync2(join6(here, rel), "utf-8"));
+        const pkg = JSON.parse(readFileSync2(join7(here, rel), "utf-8"));
         if (pkg.version) return pkg.version;
       } catch {
       }
@@ -9454,8 +9551,22 @@ async function sampleKeyUsage(token) {
 import { readFile as readFile4 } from "fs/promises";
 import { execFile as execFile3 } 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 ports = [];
+  const sockets = [];
   const lines = content.split("\n");
   for (let i = 1; i < lines.length; i++) {
     const line = lines[i];
@@ -9464,26 +9575,40 @@ function parseProcNetTcpListeners(content) {
     if (cols.length < 4 || cols[3] !== PROC_TCP_LISTEN_STATE) continue;
     const local = cols[1];
     if (!local) continue;
-    const portHex = local.split(":").pop();
-    if (!portHex) continue;
+    const [addrHex, portHex] = local.split(":");
+    if (!addrHex || !portHex) continue;
     const port = Number.parseInt(portHex, 16);
-    if (Number.isInteger(port) && port >= 1 && port <= 65535) ports.push(port);
+    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;
+  return { ports, loopbackOnly };
 }
 var DEFAULT_PROC_PATHS = ["/proc/net/tcp", "/proc/net/tcp6"];
 async function readProcListeningPorts(procPaths = DEFAULT_PROC_PATHS) {
-  const ports = /* @__PURE__ */ new Set();
+  const sockets = [];
   let readable = false;
   for (const path4 of procPaths) {
     try {
       const content = await readFile4(path4, "utf8");
       readable = true;
-      for (const port of parseProcNetTcpListeners(content)) ports.add(port);
+      sockets.push(...parseProcNetTcpListeners(content));
     } catch {
     }
   }
-  return readable ? ports : null;
+  return readable ? collectScan(sockets) : null;
 }
 async function readNetstatListeningPorts() {
   const output = await new Promise((resolve) => {
@@ -9492,17 +9617,21 @@ async function readNetstatListeningPorts() {
     });
   });
   if (output === null) return null;
-  const ports = /* @__PURE__ */ new Set();
+  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 portStr = local.split(".").pop();
-    const port = Number(portStr);
-    if (Number.isInteger(port) && port >= 1 && port <= 65535) ports.add(port);
+    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 ports;
+  return collectScan(sockets);
 }
 async function readListeningPorts() {
   const proc = await readProcListeningPorts();
@@ -9526,6 +9655,8 @@ var PortDiscovery = class {
   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;
@@ -9553,7 +9684,7 @@ var PortDiscovery = class {
       this.log("Port discovery disabled: no listening-socket source available");
       return;
     }
-    this.baseline = baseline;
+    this.baseline = baseline.ports;
     this.timer = setInterval(() => void this.tick(), this.intervalMs);
     this.timer.unref?.();
   }
@@ -9590,8 +9721,21 @@ var PortDiscovery = class {
     return true;
   }
   updateTracking(current) {
-    for (const port of 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: "" });
@@ -9605,7 +9749,7 @@ var PortDiscovery = class {
       }
     }
     for (const [port, entry] of this.tracked) {
-      if (current.has(port)) continue;
+      if (reachable.has(port)) continue;
       entry.missed += 1;
       entry.seen = 0;
       if (entry.missed >= CONFIRM_SCANS || !entry.confirmed) this.tracked.delete(port);
@@ -9907,7 +10051,7 @@ var SessionRunner = class _SessionRunner {
     }
     this.mode.applyServerMode(this.fullContext?.agentMode, this.fullContext?.isAuto);
     this.mode.resolveInitialMode(this.taskContext);
-    if (this.fullContext?.isAuto && this.taskContext.status === "Open" && this.mode.isBuildCapable) {
+    if (this.fullContext?.isAuto && PRE_BUILD_TASK_STATUSES.has(this.taskContext.status) && this.mode.isBuildCapable) {
       void this.connection.triggerIdentification().catch(() => {
       });
     }
@@ -10378,11 +10522,12 @@ var SessionRunner = class _SessionRunner {
    * help) it's waiting on a human, not silently stuck.
    *
    * - "pr":       In Progress with no open PR (build finished without shipping).
-   * - "planning": still Planning without (identified + saved plan). A fresh auto
-   *   agent that finishes its plan turn WITHOUT ExitPlanMode would otherwise idle
-   *   → clean-exit → its session Ends → the workspace is reaped "agent_gone"
-   *   before a plan ever landed. Nudging (and, on exhaustion, going dormant)
-   *   keeps the session Active so the pod is never prematurely slept.
+   * - "planning": still in a pre-build status (Planning/Open) without
+   *   (identified + saved plan). A fresh auto agent that finishes its plan turn
+   *   WITHOUT ExitPlanMode would otherwise idle → clean-exit → its session Ends
+   *   → the workspace is reaped "agent_gone" before a plan ever landed. Nudging
+   *   (and, on exhaustion, going dormant) keeps the session Active so the pod
+   *   is never prematurely slept.
    */
   autoStuckKind() {
     if (!this.mode.isAuto || this.stopped) return null;
@@ -10392,7 +10537,7 @@ var SessionRunner = class _SessionRunner {
     if (!this.taskContext) return null;
     const { status, storyPointId, plan, githubPRUrl } = this.taskContext;
     if (status === "InProgress" && !githubPRUrl) return "pr";
-    if (status === "Planning" && !(storyPointId !== null && !!plan?.trim())) {
+    if (PRE_BUILD_TASK_STATUSES.has(status) && !(storyPointId !== null && !!plan?.trim())) {
       return "planning";
     }
     return null;
@@ -10564,7 +10709,7 @@ var SessionRunner = class _SessionRunner {
     this.connection.onSoftStop(() => this.softStop());
     this.connection.onReconnected = () => this.queryBridge?.forceRepaint();
     this.connection.onModeChange((data) => {
-      const action = this.mode.handleModeChange(data.agentMode);
+      const action = this.mode.handleModeChange(data.agentMode, this.taskContext);
       if (action.type === "start_auto") {
         this.connection.emitModeChanged(this.mode.effectiveMode);
         this.softStop();
@@ -10721,12 +10866,12 @@ var SessionRunner = class _SessionRunner {
 
 // src/setup/config.ts
 import { readFile as readFile5 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 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 readFile5(join7(workspaceDir, DEVCONTAINER_PATH), "utf-8");
+    const raw = await readFile5(join8(workspaceDir, DEVCONTAINER_PATH), "utf-8");
     const parsed = JSON.parse(raw);
     const ports = (parsed.forwardPorts ?? []).filter(
       (p) => typeof p === "number" && !DEVCONTAINER_PORT_DENY_LIST.has(p)
@@ -10860,6 +11005,9 @@ export {
   updateRemoteToken,
   flushPendingChanges,
   pushToOrigin,
+  TuiUnavailableError,
+  findOnPath,
+  resolvePlaywrightMcpServer,
   resolveSessionStart,
   sampleKeyUsage,
   awaitGitReady,
@@ -10878,4 +11026,4 @@ export {
   runStartCommand,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-CFELRV35.js.map
+//# sourceMappingURL=chunk-AMPYOJJC.js.map