@rallycry/conveyor-agent 10.2.4 → 10.3.0

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

@@ -1909,6 +1909,7 @@ async function restoreOnBoot(bundle, cwd) {
 import { z } from "zod";
 import { z as z2 } from "zod";
 var DEFAULT_SONNET_MODEL = "claude-sonnet-5";
+var TUI_KINDS = ["claude-code", "opencode"];
 var MAX_FILE_SIZE_BYTES = 25 * 1024 * 1024;
 var EMBED_THRESHOLD_IMAGES = 5 * 1024 * 1024;
 var EMBED_THRESHOLD_TEXT = 2 * 1024 * 1024;
@@ -2034,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()
 });
@@ -2444,9 +2449,14 @@ var ListMyLiveSessionsRequestSchema = z2.object({
   /** Admin-only: list another member's sessions instead of the caller's. */
   targetUserId: z2.string().optional()
 });
+var GetProjectAvailableTuisRequestSchema = z2.object({
+  projectId: z2.string()
+});
 var StartAdhocSessionRequestSchema = z2.object({
   projectId: z2.string(),
   label: z2.string().max(200).optional(),
+  /** Coding-agent key to launch under — validated pick-time (ownership + TUI availability) in the handler. */
+  codingAgentKeyId: z2.string().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.
@@ -2641,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;
@@ -2728,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;
@@ -2764,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") {
@@ -2935,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,
@@ -2977,9 +2998,9 @@ var ClaudeCodeHarness = class {
 };
 
 // src/harness/pty/session.ts
-import { mkdtemp as mkdtemp2, mkdir as mkdir2, rm as rm4 } from "fs/promises";
+import { mkdtemp as mkdtemp2, mkdir as mkdir3, rm as rm5 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join3, dirname } from "path";
+import { join as join4, dirname } from "path";
 
 // src/harness/pty/event-queue.ts
 var AsyncEventQueue = class {
@@ -3442,76 +3463,6 @@ function mapChatRecords(raw) {
   }
 }
 
-// src/harness/pty/spawn-args.ts
-function resolveClaudeBinary() {
-  return process.env.CONVEYOR_CLAUDE_BIN ?? "claude";
-}
-function buildSpawnArgs(input) {
-  const args = [];
-  if (input.resume) {
-    args.push("--resume", input.resume);
-  } else if (input.sessionId) {
-    args.push("--session-id", input.sessionId);
-  }
-  args.push("--model", input.model);
-  if (input.permissionMode === "bypassPermissions") {
-    args.push("--dangerously-skip-permissions");
-  } else {
-    args.push("--permission-mode", "plan");
-  }
-  args.push("--settings", input.settingsPath);
-  if (input.appendSystemPrompt) {
-    args.push("--append-system-prompt", input.appendSystemPrompt);
-  }
-  if (input.mcpConfigPath) {
-    args.push("--mcp-config", input.mcpConfigPath);
-    if (input.strictMcpConfig) {
-      args.push("--strict-mcp-config");
-    }
-  }
-  return args;
-}
-function spawnOptionsFingerprint(input) {
-  return JSON.stringify([
-    input.model,
-    input.permissionMode,
-    input.appendSystemPrompt ?? "",
-    input.cwd
-  ]);
-}
-var ANSI_CSI = new RegExp(`${String.fromCharCode(27)}\\[[0-9;?]*[ -/]*[@-~]`, "g");
-function cleanTerminalOutput(raw, maxChars = 1200) {
-  const noAnsi = raw.replace(ANSI_CSI, "");
-  let out = "";
-  for (const ch of noAnsi) {
-    const code = ch.charCodeAt(0);
-    if (ch === "\r" || ch === "\n") out += "\n";
-    else if (ch === "	") out += ch;
-    else if (code < 32 || code === 127) continue;
-    else out += ch;
-  }
-  const lines = out.split("\n").map((line) => line.trimEnd()).filter((line) => line.trim().length > 0);
-  const text = lines.join("\n").trim();
-  return text.length > maxChars ? `\u2026${text.slice(-maxChars)}` : text;
-}
-function isMissingBinaryFailure(tail) {
-  return /execvp\(\d+\) failed|no such file or directory|command not found/i.test(tail);
-}
-function buildExitErrors(exitCode, rawOutput, binary) {
-  const errors = [`claude exited (code ${exitCode}) without a result`];
-  const tail = cleanTerminalOutput(rawOutput);
-  if (isMissingBinaryFailure(tail)) {
-    errors.push(
-      `The \`${binary}\` CLI could not be started \u2014 it is not installed or not on PATH. Install the Claude Code CLI in this environment (npm i -g @anthropic-ai/claude-code) or set CONVEYOR_CLAUDE_BIN to its absolute path.`
-    );
-  }
-  if (tail) {
-    errors.push(`Last terminal output before exit:
-${tail}`);
-  }
-  return errors;
-}
-
 // src/harness/pty/settings.ts
 import { mkdir, writeFile as writeFile2, chmod } from "fs/promises";
 import { homedir } from "os";
@@ -3969,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);
@@ -3976,10 +3936,242 @@ async function startToolServers(mcpServers, tempDir) {
     servers.push(server);
     config[name] = { type: "http", url, headers: { Authorization: `Bearer ${token}` } };
   }
-  if (Object.keys(config).length === 0) return { servers, mcpConfigPath: null };
-  const mcpConfigPath = join2(tempDir, "mcp-config.json");
-  await writeFile3(mcpConfigPath, JSON.stringify({ mcpServers: config }, null, 2), "utf8");
-  return { servers, mcpConfigPath };
+  if (Object.keys(config).length === 0) return { servers, mcpConfigPath: null };
+  const mcpConfigPath = join2(tempDir, "mcp-config.json");
+  await writeFile3(mcpConfigPath, JSON.stringify({ mcpServers: config }, null, 2), "utf8");
+  return { servers, mcpConfigPath };
+}
+
+// src/harness/pty/spawn-args.ts
+function buildSpawnArgs(input) {
+  const args = [];
+  if (input.resume) {
+    args.push("--resume", input.resume);
+  } else if (input.sessionId) {
+    args.push("--session-id", input.sessionId);
+  }
+  args.push("--model", input.model);
+  if (input.permissionMode === "bypassPermissions") {
+    args.push("--dangerously-skip-permissions");
+  } else {
+    args.push("--permission-mode", "plan");
+  }
+  args.push("--settings", input.settingsPath);
+  if (input.appendSystemPrompt) {
+    args.push("--append-system-prompt", input.appendSystemPrompt);
+  }
+  if (input.mcpConfigPath) {
+    args.push("--mcp-config", input.mcpConfigPath);
+    if (input.strictMcpConfig) {
+      args.push("--strict-mcp-config");
+    }
+  }
+  return args;
+}
+function spawnOptionsFingerprint(input) {
+  return JSON.stringify([
+    input.model,
+    input.permissionMode,
+    input.appendSystemPrompt ?? "",
+    input.cwd
+  ]);
+}
+var ANSI_CSI = new RegExp(`${String.fromCharCode(27)}\\[[0-9;?]*[ -/]*[@-~]`, "g");
+function cleanTerminalOutput(raw, maxChars = 1200) {
+  const noAnsi = raw.replace(ANSI_CSI, "");
+  let out = "";
+  for (const ch of noAnsi) {
+    const code = ch.charCodeAt(0);
+    if (ch === "\r" || ch === "\n") out += "\n";
+    else if (ch === "	") out += ch;
+    else if (code < 32 || code === 127) continue;
+    else out += ch;
+  }
+  const lines = out.split("\n").map((line) => line.trimEnd()).filter((line) => line.trim().length > 0);
+  const text = lines.join("\n").trim();
+  return text.length > maxChars ? `\u2026${text.slice(-maxChars)}` : text;
+}
+function isMissingBinaryFailure(tail) {
+  return /execvp\(\d+\) failed|no such file or directory|command not found/i.test(tail);
+}
+function buildExitErrors(exitCode, rawOutput, binary) {
+  const errors = [`claude exited (code ${exitCode}) without a result`];
+  const tail = cleanTerminalOutput(rawOutput);
+  if (isMissingBinaryFailure(tail)) {
+    errors.push(
+      `The \`${binary}\` CLI could not be started \u2014 it is not installed or not on PATH. Install the Claude Code CLI in this environment (npm i -g @anthropic-ai/claude-code) or set CONVEYOR_CLAUDE_BIN to its absolute path.`
+    );
+  }
+  if (tail) {
+    errors.push(`Last terminal output before exit:
+${tail}`);
+  }
+  return errors;
+}
+
+// src/harness/pty/credentials.ts
+import { chmod as chmod2, mkdir as mkdir2, readFile, rm as rm4, writeFile as writeFile4 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+var SYNTH_TOKEN_TTL_MS = 365 * 24 * 60 * 60 * 1e3;
+var REFRESH_SKEW_MS = 30 * 24 * 60 * 60 * 1e3;
+function claudeCredentialsPath() {
+  return join3(claudeConfigHome(), ".credentials.json");
+}
+function isConveyorCloudEnv(env = process.env) {
+  return Boolean(env.CLAUDESPACE_NAME || env.CODESPACE_NAME || env.CODESPACES);
+}
+function parseClaudeAiOauth(raw) {
+  if (!raw || raw.trim() === "") return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const oauth = parsed.claudeAiOauth;
+    if (typeof oauth !== "object" || oauth === null) return null;
+    const record = oauth;
+    return {
+      accessToken: record.accessToken,
+      refreshToken: record.refreshToken,
+      expiresAt: record.expiresAt
+    };
+  } catch {
+    return null;
+  }
+}
+function buildSynthesizedCredentials(token, now) {
+  return JSON.stringify({
+    claudeAiOauth: {
+      accessToken: token,
+      expiresAt: now + SYNTH_TOKEN_TTL_MS,
+      scopes: ["user:inference", "user:profile"],
+      subscriptionType: "max"
+    }
+  });
+}
+function planCredentialsWrite(input) {
+  if (!input.isCloud) return { action: "skip", reason: "not-cloud" };
+  if (!input.token) return { action: "skip", reason: "no-token" };
+  const contents = buildSynthesizedCredentials(input.token, input.now);
+  const existing = parseClaudeAiOauth(input.existingRaw);
+  if (!existing) return { action: "write", contents };
+  if (typeof existing.refreshToken === "string" && existing.refreshToken.length > 0) {
+    return { action: "skip", reason: "foreign-credentials" };
+  }
+  const fresh = existing.accessToken === input.token && typeof existing.expiresAt === "number" && existing.expiresAt > input.now + REFRESH_SKEW_MS;
+  if (fresh) return { action: "skip", reason: "current" };
+  return { action: "write", contents };
+}
+async function readRaw(path4) {
+  try {
+    return await readFile(path4, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function ensureClaudeCredentials(env = process.env) {
+  try {
+    const path4 = claudeCredentialsPath();
+    const plan = planCredentialsWrite({
+      isCloud: isConveyorCloudEnv(env),
+      token: env.CLAUDE_CODE_OAUTH_TOKEN,
+      existingRaw: await readRaw(path4),
+      now: Date.now()
+    });
+    if (plan.action === "skip") return;
+    await mkdir2(claudeConfigHome(), { recursive: true });
+    await writeFile4(path4, plan.contents, { encoding: "utf8", mode: 384 });
+    await chmod2(path4, 384).catch(() => {
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[conveyor-agent] claude credentials sync failed: ${message}
+`);
+  }
+}
+function claudeJsonPath() {
+  const configDir = process.env.CLAUDE_CONFIG_DIR;
+  return configDir ? join3(configDir, ".claude.json") : join3(homedir2(), ".claude.json");
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function parseClaudeJson(existingRaw) {
+  if (!existingRaw || existingRaw.trim() === "") return {};
+  try {
+    return asRecord(JSON.parse(existingRaw));
+  } catch {
+    return {};
+  }
+}
+function seedWorkspaceTrust(config, trustCwd) {
+  const projects = asRecord(config.projects);
+  const entry = asRecord(projects[trustCwd]);
+  if (entry.hasTrustDialogAccepted === true) return false;
+  entry.hasTrustDialogAccepted = true;
+  projects[trustCwd] = entry;
+  config.projects = projects;
+  return true;
+}
+function planClaudeJsonSeed(existingRaw, trustCwd) {
+  const config = parseClaudeJson(existingRaw);
+  const isFresh = Object.keys(config).length === 0;
+  let changed = false;
+  if (config.hasCompletedOnboarding !== true) {
+    config.hasCompletedOnboarding = true;
+    changed = true;
+  }
+  if (config.bypassPermissionsModeAccepted !== true) {
+    config.bypassPermissionsModeAccepted = true;
+    changed = true;
+  }
+  if (isFresh && typeof config.theme !== "string") {
+    config.theme = "dark";
+    changed = true;
+  }
+  if (trustCwd && seedWorkspaceTrust(config, trustCwd)) {
+    changed = true;
+  }
+  return changed ? JSON.stringify(config) : null;
+}
+async function ensureClaudeOnboarding(env = process.env, trustCwd) {
+  try {
+    if (!isConveyorCloudEnv(env)) return;
+    const path4 = claudeJsonPath();
+    const contents = planClaudeJsonSeed(await readRaw(path4), trustCwd);
+    if (contents === null) return;
+    await writeFile4(path4, contents, "utf8");
+    const verify = await readRaw(path4);
+    if (verify === contents) {
+      process.stderr.write(
+        `[conveyor-agent] claude onboarding seeded${trustCwd ? ` (trust: ${trustCwd})` : ""}
+`
+      );
+    } else {
+      process.stderr.write(
+        `[conveyor-agent] claude onboarding seed read-back MISMATCH at ${path4}: wrote ${contents.length}B, read ${verify?.length ?? 0}B \u2014 CLI may see stale config and park at a startup dialog
+`
+      );
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[conveyor-agent] claude onboarding seed failed: ${message}
+`);
+  }
+}
+async function removeConveyorCredentials(env = process.env) {
+  try {
+    if (!isConveyorCloudEnv(env)) return;
+    const path4 = claudeCredentialsPath();
+    const existing = parseClaudeAiOauth(await readRaw(path4));
+    if (existing && typeof existing.refreshToken === "string" && existing.refreshToken.length > 0) {
+      return;
+    }
+    await rm4(path4, { force: true });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[conveyor-agent] claude credentials removal failed: ${message}
+`);
+  }
 }
 
 // src/harness/pty/pty-support.ts
@@ -3996,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),
@@ -4008,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,
@@ -4037,7 +4241,9 @@ function inheritedEnv(socketPath) {
   for (const [key, value] of Object.entries(process.env)) {
     if (typeof value === "string") env[key] = value;
   }
-  env.CONVEYOR_HOOK_SOCKET = socketPath;
+  if (socketPath) {
+    env.CONVEYOR_HOOK_SOCKET = socketPath;
+  }
   env.MCP_TIMEOUT ??= "60000";
   env.MCP_TOOL_TIMEOUT ??= "180000";
   return env;
@@ -4087,18 +4293,65 @@ function parseUserQuestions(input) {
   return questions;
 }
 
+// src/harness/pty/adapters/claude.ts
+var ClaudeTuiAdapter = class {
+  id = "claude-code";
+  capabilities = {
+    resume: true,
+    structuredEvents: true,
+    prefill: true,
+    passiveTurns: true
+  };
+  resolveBinary(env = process.env) {
+    return env.CONVEYOR_CLAUDE_BIN ?? "claude";
+  }
+  buildSpawn(input) {
+    const { options, resume } = input;
+    const args = buildSpawnArgs({
+      ...resume ? { resume } : {},
+      ...options.sessionId ? { sessionId: options.sessionId } : {},
+      model: options.model,
+      permissionMode: options.permissionMode,
+      settingsPath: input.settingsPath ?? "",
+      ...options.appendSystemPrompt ? { appendSystemPrompt: options.appendSystemPrompt } : {},
+      ...input.mcpConfigPath ? { mcpConfigPath: input.mcpConfigPath, strictMcpConfig: true } : {}
+    });
+    return {
+      file: this.resolveBinary(),
+      args,
+      env: inheritedEnv(input.hookSocketPath)
+    };
+  }
+  async prepareEnvironment(opts) {
+    const env = opts.env ?? process.env;
+    await ensureClaudeCredentials(env);
+    await ensureClaudeOnboarding(env, opts.cwd);
+  }
+  spawnFingerprint(input) {
+    return spawnOptionsFingerprint(input);
+  }
+  encodePromptBytes(text) {
+    return buildPromptBytes(text);
+  }
+  buildExitErrors(exitCode, rawOutput) {
+    return buildExitErrors(exitCode, rawOutput, this.resolveBinary());
+  }
+};
+
 // src/harness/pty/session.ts
 var PtySession = class {
-  constructor(prompt, options, resume, bridge) {
+  constructor(prompt, options, resume, bridge, adapter = new ClaudeTuiAdapter()) {
     this.options = options;
     this.resume = resume;
     this.bridge = bridge;
+    this.adapter = adapter;
     this.turnPrompt = prompt;
     this.turn = turnOptionsFrom(options);
   }
   options;
   resume;
   bridge;
+  adapter;
   // The current turn's event stream. Null between turns (process parked) — the
   // process outlives any single turn, so the queue is per-turn, not per-process.
   activeQueue = null;
@@ -4184,7 +4437,7 @@ var PtySession = class {
   }
   /** Fingerprint of the spawn-time options a reused process cannot change. */
   get spawnFingerprint() {
-    return spawnOptionsFingerprint({
+    return this.adapter.spawnFingerprint({
       model: this.options.model,
       permissionMode: this.options.permissionMode,
       ...this.options.appendSystemPrompt ? { appendSystemPrompt: this.options.appendSystemPrompt } : {},
@@ -4321,29 +4574,19 @@ var PtySession = class {
       return;
     }
     try {
-      this.tempDir = await mkdtemp2(join3(tmpdir3(), "conveyor-pty-"));
-      const socketPath = join3(this.tempDir, "hook.sock");
-      this.socket = new HookSocketServer(
-        socketPath,
-        (progress) => this.handleProgress(progress),
-        (request) => this.handlePreToolUse(request)
-      );
-      await this.socket.listen();
-      const { settingsPath } = await writeHookSettings(this.tempDir);
-      await this.setupToolServers();
-      const transcriptPath = sessionTranscriptPath(this.options.cwd, sessionId);
-      await mkdir2(dirname(transcriptPath), { recursive: true });
-      const startOffset = this.resume ? await transcriptSize(transcriptPath) : 0;
-      const sendChat = this.bridge?.sendChatEvent?.bind(this.bridge);
-      this.tailer = new JsonlTailer(
-        transcriptPath,
-        (event) => this.handleTranscriptEvent(event),
-        sendChat ? (raw) => {
-          for (const chatEvent of mapChatRecords(raw)) sendChat(chatEvent);
-        } : void 0
-      );
-      this.tailer.start(startOffset);
-      await this.spawn(settingsPath, socketPath);
+      if (this.adapter.capabilities.structuredEvents) {
+        const { settingsPath, socketPath } = await this.startStructuredEventSources(sessionId);
+        await this.spawn(settingsPath, socketPath);
+      } else {
+        this.tempDir = await mkdtemp2(join4(tmpdir3(), "conveyor-pty-"));
+        await this.spawn();
+        this.pushEvent({
+          type: "system",
+          subtype: "init",
+          session_id: sessionId,
+          model: this.options.model
+        });
+      }
       if (signal) {
         this.abortHandler = () => {
           void this.teardown();
@@ -4364,6 +4607,38 @@ var PtySession = class {
       throw err;
     }
   }
+  /**
+   * Allocate the Claude-style structured-event sources: the PostToolUse hook
+   * socket, the per-run settings file, the in-process tool servers, and the
+   * transcript tailer. Only structured-events adapters call this — raw-terminal
+   * adapters have no trusted event source and skip it entirely. Returns the
+   * paths spawn() must wire into the child's argv/env.
+   */
+  async startStructuredEventSources(sessionId) {
+    this.tempDir = await mkdtemp2(join4(tmpdir3(), "conveyor-pty-"));
+    const socketPath = join4(this.tempDir, "hook.sock");
+    this.socket = new HookSocketServer(
+      socketPath,
+      (progress) => this.handleProgress(progress),
+      (request) => this.handlePreToolUse(request)
+    );
+    await this.socket.listen();
+    const { settingsPath } = await writeHookSettings(this.tempDir);
+    await this.setupToolServers();
+    const transcriptPath = sessionTranscriptPath(this.options.cwd, sessionId);
+    await mkdir3(dirname(transcriptPath), { recursive: true });
+    const startOffset = this.resume ? await transcriptSize(transcriptPath) : 0;
+    const sendChat = this.bridge?.sendChatEvent?.bind(this.bridge);
+    this.tailer = new JsonlTailer(
+      transcriptPath,
+      (event) => this.handleTranscriptEvent(event),
+      sendChat ? (raw) => {
+        for (const chatEvent of mapChatRecords(raw)) sendChat(chatEvent);
+      } : void 0
+    );
+    this.tailer.start(startOffset);
+    return { settingsPath, socketPath };
+  }
   writeStdin(text) {
     this.pty?.write(text);
   }
@@ -4429,7 +4704,7 @@ var PtySession = class {
     this.activeQueue?.close();
     this.activeQueue = null;
     if (this.tempDir) {
-      await rm4(this.tempDir, { recursive: true, force: true });
+      await rm5(this.tempDir, { recursive: true, force: true });
       this.tempDir = "";
     }
   }
@@ -4448,25 +4723,23 @@ var PtySession = class {
     this.mcpConfigPath = mcpConfigPath;
   }
   async spawn(settingsPath, socketPath) {
-    const args = buildSpawnArgs({
-      resume: this.resume,
-      sessionId: this.options.sessionId,
-      model: this.options.model,
-      permissionMode: this.options.permissionMode,
-      settingsPath,
-      ...this.options.appendSystemPrompt ? { appendSystemPrompt: this.options.appendSystemPrompt } : {},
+    const spec = this.adapter.buildSpawn({
+      options: this.options,
+      ...this.resume ? { resume: this.resume } : {},
+      ...settingsPath ? { settingsPath } : {},
+      ...socketPath ? { hookSocketPath: socketPath } : {},
       // Only this config: ignore the user's ~/.claude.json / project .mcp.json
       // so the agent's tool set is deterministic (and a stale personal conveyor
       // server doesn't load).
-      ...this.mcpConfigPath ? { mcpConfigPath: this.mcpConfigPath, strictMcpConfig: true } : {}
+      ...this.mcpConfigPath ? { mcpConfigPath: this.mcpConfigPath } : {}
     });
     const spawn2 = await loadPtySpawn();
-    const pty = spawn2(resolveClaudeBinary(), args, {
+    const pty = spawn2(spec.file, spec.args, {
       name: "xterm-color",
       cols: this.cols,
       rows: this.rows,
       cwd: this.options.cwd,
-      env: inheritedEnv(socketPath)
+      env: spec.env
     });
     const bridge = this.bridge;
     if (bridge) {
@@ -4487,12 +4760,13 @@ var PtySession = class {
     this.pty = pty;
   }
   async deliverPrompt(text) {
-    this.writeStdin(buildPromptBytes(text));
+    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");
-    this.armSubmitNudge();
+    if (this.adapter.capabilities.structuredEvents) this.armSubmitNudge();
   }
   async feedPrompt() {
     if (typeof this.turnPrompt === "string") {
@@ -4606,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"
         );
@@ -4617,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;
@@ -4649,11 +4924,22 @@ var PtySession = class {
       this.tailer.close();
       await this.tailer.flush();
     }
-    if (!this.sawResult && this.activeQueue) {
+    if (!this.adapter.capabilities.structuredEvents) {
+      if (exitCode === 0) {
+        this.pushEvent({ type: "result", subtype: "success", result: "", total_cost_usd: 0 });
+      } else {
+        this.pushEvent({
+          type: "result",
+          subtype: "error",
+          errors: this.adapter.buildExitErrors(exitCode, this.recentOutput)
+        });
+      }
+      this.endTurn(exitCode === 0);
+    } else if (!this.sawResult && this.activeQueue) {
       this.activeQueue.push({
         type: "result",
         subtype: "error",
-        errors: buildExitErrors(exitCode, this.recentOutput, resolveClaudeBinary())
+        errors: this.adapter.buildExitErrors(exitCode, this.recentOutput)
       });
     }
     for (const listener of this.exitListeners) listener(exitCode);
@@ -4662,191 +4948,29 @@ var PtySession = class {
   }
 };
 
-// src/harness/pty/credentials.ts
-import { chmod as chmod2, mkdir as mkdir3, readFile, rm as rm5, writeFile as writeFile4 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join4 } from "path";
-var SYNTH_TOKEN_TTL_MS = 365 * 24 * 60 * 60 * 1e3;
-var REFRESH_SKEW_MS = 30 * 24 * 60 * 60 * 1e3;
-function claudeCredentialsPath() {
-  return join4(claudeConfigHome(), ".credentials.json");
-}
-function isConveyorCloudEnv(env = process.env) {
-  return Boolean(env.CLAUDESPACE_NAME || env.CODESPACE_NAME || env.CODESPACES);
-}
-function parseClaudeAiOauth(raw) {
-  if (!raw || raw.trim() === "") return null;
-  try {
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null) return null;
-    const oauth = parsed.claudeAiOauth;
-    if (typeof oauth !== "object" || oauth === null) return null;
-    const record = oauth;
-    return {
-      accessToken: record.accessToken,
-      refreshToken: record.refreshToken,
-      expiresAt: record.expiresAt
-    };
-  } catch {
-    return null;
-  }
-}
-function buildSynthesizedCredentials(token, now) {
-  return JSON.stringify({
-    claudeAiOauth: {
-      accessToken: token,
-      expiresAt: now + SYNTH_TOKEN_TTL_MS,
-      scopes: ["user:inference", "user:profile"],
-      subscriptionType: "max"
-    }
-  });
-}
-function planCredentialsWrite(input) {
-  if (!input.isCloud) return { action: "skip", reason: "not-cloud" };
-  if (!input.token) return { action: "skip", reason: "no-token" };
-  const contents = buildSynthesizedCredentials(input.token, input.now);
-  const existing = parseClaudeAiOauth(input.existingRaw);
-  if (!existing) return { action: "write", contents };
-  if (typeof existing.refreshToken === "string" && existing.refreshToken.length > 0) {
-    return { action: "skip", reason: "foreign-credentials" };
-  }
-  const fresh = existing.accessToken === input.token && typeof existing.expiresAt === "number" && existing.expiresAt > input.now + REFRESH_SKEW_MS;
-  if (fresh) return { action: "skip", reason: "current" };
-  return { action: "write", contents };
-}
-async function readRaw(path4) {
-  try {
-    return await readFile(path4, "utf8");
-  } catch {
-    return null;
-  }
-}
-async function ensureClaudeCredentials(env = process.env) {
-  try {
-    const path4 = claudeCredentialsPath();
-    const plan = planCredentialsWrite({
-      isCloud: isConveyorCloudEnv(env),
-      token: env.CLAUDE_CODE_OAUTH_TOKEN,
-      existingRaw: await readRaw(path4),
-      now: Date.now()
-    });
-    if (plan.action === "skip") return;
-    await mkdir3(claudeConfigHome(), { recursive: true });
-    await writeFile4(path4, plan.contents, { encoding: "utf8", mode: 384 });
-    await chmod2(path4, 384).catch(() => {
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[conveyor-agent] claude credentials sync failed: ${message}
-`);
-  }
-}
-function claudeJsonPath() {
-  const configDir = process.env.CLAUDE_CONFIG_DIR;
-  return configDir ? join4(configDir, ".claude.json") : join4(homedir2(), ".claude.json");
-}
-function asRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
-}
-function parseClaudeJson(existingRaw) {
-  if (!existingRaw || existingRaw.trim() === "") return {};
-  try {
-    return asRecord(JSON.parse(existingRaw));
-  } catch {
-    return {};
-  }
-}
-function seedWorkspaceTrust(config, trustCwd) {
-  const projects = asRecord(config.projects);
-  const entry = asRecord(projects[trustCwd]);
-  if (entry.hasTrustDialogAccepted === true) return false;
-  entry.hasTrustDialogAccepted = true;
-  projects[trustCwd] = entry;
-  config.projects = projects;
-  return true;
-}
-function planClaudeJsonSeed(existingRaw, trustCwd) {
-  const config = parseClaudeJson(existingRaw);
-  const isFresh = Object.keys(config).length === 0;
-  let changed = false;
-  if (config.hasCompletedOnboarding !== true) {
-    config.hasCompletedOnboarding = true;
-    changed = true;
-  }
-  if (config.bypassPermissionsModeAccepted !== true) {
-    config.bypassPermissionsModeAccepted = true;
-    changed = true;
-  }
-  if (isFresh && typeof config.theme !== "string") {
-    config.theme = "dark";
-    changed = true;
-  }
-  if (trustCwd && seedWorkspaceTrust(config, trustCwd)) {
-    changed = true;
-  }
-  return changed ? JSON.stringify(config) : null;
-}
-async function ensureClaudeOnboarding(env = process.env, trustCwd) {
-  try {
-    if (!isConveyorCloudEnv(env)) return;
-    const path4 = claudeJsonPath();
-    const contents = planClaudeJsonSeed(await readRaw(path4), trustCwd);
-    if (contents === null) return;
-    await writeFile4(path4, contents, "utf8");
-    const verify = await readRaw(path4);
-    if (verify === contents) {
-      process.stderr.write(
-        `[conveyor-agent] claude onboarding seeded${trustCwd ? ` (trust: ${trustCwd})` : ""}
-`
-      );
-    } else {
-      process.stderr.write(
-        `[conveyor-agent] claude onboarding seed read-back MISMATCH at ${path4}: wrote ${contents.length}B, read ${verify?.length ?? 0}B \u2014 CLI may see stale config and park at a startup dialog
-`
-      );
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[conveyor-agent] claude onboarding seed failed: ${message}
-`);
-  }
-}
-async function removeConveyorCredentials(env = process.env) {
-  try {
-    if (!isConveyorCloudEnv(env)) return;
-    const path4 = claudeCredentialsPath();
-    const existing = parseClaudeAiOauth(await readRaw(path4));
-    if (existing && typeof existing.refreshToken === "string" && existing.refreshToken.length > 0) {
-      return;
-    }
-    await rm5(path4, { force: true });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[conveyor-agent] claude credentials removal failed: ${message}
-`);
-  }
-}
-
 // src/harness/pty/index.ts
 var ENDED_GRACE_MS = 4e3;
-function fingerprintOf(options) {
-  return spawnOptionsFingerprint({
-    model: options.model,
-    permissionMode: options.permissionMode,
-    ...options.appendSystemPrompt ? { appendSystemPrompt: options.appendSystemPrompt } : {},
-    cwd: options.cwd
-  });
-}
 var PtyHarness = class {
   /**
    * `bridge` relays raw terminal I/O to/from the S2 server (and on to the S5
    * terminal). It is undefined for SDK-only callers and PTY runs that never
    * attach a relay; the session simply discards stdout in that case.
    */
-  constructor(bridge) {
+  constructor(bridge, adapter = new ClaudeTuiAdapter()) {
     this.bridge = bridge;
+    this.adapter = adapter;
   }
   bridge;
+  adapter;
+  /** Fingerprint of the spawn-time options a reused process cannot change. */
+  fingerprintOf(options) {
+    return this.adapter.spawnFingerprint({
+      model: options.model,
+      permissionMode: options.permissionMode,
+      ...options.appendSystemPrompt ? { appendSystemPrompt: options.appendSystemPrompt } : {},
+      cwd: options.cwd
+    });
+  }
   /** The session currently streaming events, if any — repaint target. */
   activeSession = null;
   /** A completed-but-alive session kept for the next turn (keep-alive). */
@@ -4865,7 +4989,7 @@ var PtyHarness = class {
   }
   async *executeQuery(opts) {
     const want = opts.resume ?? opts.options.resume;
-    const fingerprint = fingerprintOf(opts.options);
+    const fingerprint = this.fingerprintOf(opts.options);
     let session;
     if (this.parked?.canReuse(want, fingerprint)) {
       session = this.parked;
@@ -4879,9 +5003,8 @@ var PtyHarness = class {
         this.cancelEndedTimer();
         await stale.teardown();
       }
-      session = new PtySession(opts.prompt, opts.options, want, this.bridge);
-      await ensureClaudeCredentials();
-      await ensureClaudeOnboarding(process.env, opts.options.cwd);
+      session = new PtySession(opts.prompt, opts.options, want, this.bridge, this.adapter);
+      await this.adapter.prepareEnvironment({ cwd: opts.options.cwd });
       session.onExit(() => this.handleSessionExit(session));
       await session.start();
     }
@@ -5055,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.`,
     ``,
@@ -5064,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.`,
@@ -5978,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);
   }
@@ -6307,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.`,
@@ -6369,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;
@@ -7476,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(
@@ -7498,6 +7627,7 @@ ${summary}`;
           result: "approved",
           summary
         });
+        await endReviewSession(connection, "approved");
         return textResult("Code review approved. Exiting.");
       }
     ),
@@ -7536,6 +7666,7 @@ ${issueLines}`;
           summary,
           issues
         });
+        await endReviewSession(connection, "changes_requested");
         return textResult("Code review complete \u2014 changes requested. Exiting.");
       }
     )
@@ -7550,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":
@@ -7581,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) {
@@ -8474,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),
@@ -9251,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 [];
@@ -9280,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 {
       }
@@ -9368,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];
@@ -9378,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);
   }
-  return ports;
+  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 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) => {
@@ -9406,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();
@@ -9440,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;
@@ -9467,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?.();
   }
@@ -9504,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: "" });
@@ -9519,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);
@@ -9821,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(() => {
       });
     }
@@ -10292,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;
@@ -10306,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;
@@ -10478,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();
@@ -10635,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)
@@ -10758,8 +10989,13 @@ export {
   applyBootstrapToEnv,
   AgentConnection,
   DEFAULT_SONNET_MODEL,
+  TUI_KINDS,
   DEFAULT_LIFECYCLE_CONFIG,
   Lifecycle,
+  cleanTerminalOutput,
+  inheritedEnv,
+  buildPromptBytes,
+  ClaudeTuiAdapter,
   PtyHarness,
   createServiceLogger,
   hasUncommittedChanges,
@@ -10769,6 +11005,9 @@ export {
   updateRemoteToken,
   flushPendingChanges,
   pushToOrigin,
+  TuiUnavailableError,
+  findOnPath,
+  resolvePlaywrightMcpServer,
   resolveSessionStart,
   sampleKeyUsage,
   awaitGitReady,
@@ -10787,4 +11026,4 @@ export {
   runStartCommand,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-DEMRCBJN.js.map
+//# sourceMappingURL=chunk-AMPYOJJC.js.map