@rallycry/conveyor-agent 4.3.0 → 4.5.0

package/dist/{chunk-NUD2M24L.js → chunk-7Y3RP3ZA.js}

@@ -1,5 +1,100 @@
 // src/connection/task-connection.ts
 import { io } from "socket.io-client";
+
+// src/connection/task-connection-rpc.ts
+function requireSocket(socket) {
+  if (!socket) throw new Error("Not connected");
+  return socket;
+}
+function emitRpc(socket, event, data) {
+  return new Promise((resolve2, reject) => {
+    socket.emit(event, data, (response) => {
+      if (response.success && response.data) resolve2(response.data);
+      else reject(new Error(response.error ?? `Failed: ${event}`));
+    });
+  });
+}
+function emitRpcVoid(socket, event, data) {
+  return new Promise((resolve2, reject) => {
+    socket.emit(event, data, (response) => {
+      if (response.success) resolve2();
+      else reject(new Error(response.error ?? `Failed: ${event}`));
+    });
+  });
+}
+function fetchChatMessages(socket, limit, taskId) {
+  return emitRpc(requireSocket(socket), "agentRunner:getChatMessages", { limit, taskId });
+}
+function fetchTaskFiles(socket) {
+  return emitRpc(requireSocket(socket), "agentRunner:getTaskFiles", {});
+}
+function fetchTaskFile(socket, fileId) {
+  return emitRpc(requireSocket(socket), "agentRunner:getTaskFile", { fileId });
+}
+function fetchTaskContext(socket) {
+  return emitRpc(requireSocket(socket), "agentRunner:getTaskContext", {});
+}
+function createPR(socket, params) {
+  return emitRpc(requireSocket(socket), "agentRunner:createPR", params);
+}
+function createSubtask(socket, data) {
+  return emitRpc(requireSocket(socket), "agentRunner:createSubtask", data);
+}
+function listSubtasks(socket) {
+  return emitRpc(requireSocket(socket), "agentRunner:listSubtasks", {});
+}
+function fetchCliHistory(socket, taskId, limit, source) {
+  const s = requireSocket(socket);
+  const timeout = 1e4;
+  return Promise.race([
+    emitRpc(s, "agentRunner:getCliHistory", {
+      taskId,
+      limit,
+      source
+    }),
+    new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("CLI history request timed out")), timeout);
+    })
+  ]);
+}
+function startChildCloudBuild(socket, childTaskId) {
+  return emitRpc(requireSocket(socket), "agentRunner:startChildCloudBuild", { childTaskId });
+}
+function approveAndMergePR(socket, childTaskId) {
+  return emitRpc(requireSocket(socket), "agentRunner:approveAndMergePR", { childTaskId });
+}
+function postChildChatMessage(socket, childTaskId, content) {
+  return emitRpcVoid(requireSocket(socket), "agentRunner:postChildChatMessage", {
+    childTaskId,
+    content
+  });
+}
+function updateChildStatus(socket, childTaskId, status) {
+  return emitRpcVoid(requireSocket(socket), "agentRunner:updateChildStatus", {
+    childTaskId,
+    status
+  });
+}
+function stopChildBuild(socket, childTaskId) {
+  return emitRpcVoid(requireSocket(socket), "agentRunner:stopChildBuild", { childTaskId });
+}
+function fetchTask(socket, slugOrId) {
+  return emitRpc(requireSocket(socket), "agentRunner:getTask", { slugOrId });
+}
+function listIcons(socket) {
+  return emitRpc(requireSocket(socket), "agentRunner:listIcons", {});
+}
+function generateTaskIcon(socket, prompt, aspectRatio) {
+  return emitRpc(requireSocket(socket), "agentRunner:generateTaskIcon", { prompt, aspectRatio });
+}
+function getTaskProperties(socket) {
+  return emitRpc(requireSocket(socket), "agentRunner:getTaskProperties", {});
+}
+function triggerIdentification(socket) {
+  return emitRpc(requireSocket(socket), "agentRunner:triggerIdentification", {});
+}
+
+// src/connection/task-connection.ts
 var ConveyorConnection = class _ConveyorConnection {
   socket = null;
   config;
@@ -30,23 +125,15 @@ var ConveyorConnection = class _ConveyorConnection {
         reconnectionDelay: 2e3,
         reconnectionDelayMax: 3e4,
         randomizationFactor: 0.3,
-        extraHeaders: {
-          "ngrok-skip-browser-warning": "true"
-        }
+        extraHeaders: { "ngrok-skip-browser-warning": "true" }
       });
       this.socket.on("agentRunner:incomingMessage", (msg) => {
-        if (this.chatMessageCallback) {
-          this.chatMessageCallback(msg);
-        } else {
-          this.earlyMessages.push(msg);
-        }
+        if (this.chatMessageCallback) this.chatMessageCallback(msg);
+        else this.earlyMessages.push(msg);
       });
       this.socket.on("agentRunner:stop", () => {
-        if (this.stopCallback) {
-          this.stopCallback();
-        } else {
-          this.earlyStop = true;
-        }
+        if (this.stopCallback) this.stopCallback();
+        else this.earlyStop = true;
       });
       this.socket.on("agentRunner:questionAnswer", (data) => {
         const resolver = this.pendingQuestionResolvers.get(data.requestId);
@@ -56,16 +143,11 @@ var ConveyorConnection = class _ConveyorConnection {
         }
       });
       this.socket.on("agentRunner:setMode", (data) => {
-        if (this.modeChangeCallback) {
-          this.modeChangeCallback(data);
-        } else {
-          this.earlyModeChanges.push(data);
-        }
+        if (this.modeChangeCallback) this.modeChangeCallback(data);
+        else this.earlyModeChanges.push(data);
       });
       this.socket.on("agentRunner:runStartCommand", () => {
-        if (this.runStartCommandCallback) {
-          this.runStartCommandCallback();
-        }
+        if (this.runStartCommandCallback) this.runStartCommandCallback();
       });
       this.socket.on("connect", () => {
         if (!settled) {
@@ -83,72 +165,16 @@ var ConveyorConnection = class _ConveyorConnection {
     });
   }
   fetchChatMessages(limit, taskId) {
-    const socket = this.socket;
-    if (!socket) throw new Error("Not connected");
-    return new Promise((resolve2, reject) => {
-      socket.emit(
-        "agentRunner:getChatMessages",
-        { limit, taskId },
-        (response) => {
-          if (response.success && response.data) {
-            resolve2(response.data);
-          } else {
-            reject(new Error(response.error ?? "Failed to fetch chat messages"));
-          }
-        }
-      );
-    });
+    return fetchChatMessages(this.socket, limit, taskId);
   }
   fetchTaskFiles() {
-    const socket = this.socket;
-    if (!socket) throw new Error("Not connected");
-    return new Promise((resolve2, reject) => {
-      socket.emit(
-        "agentRunner:getTaskFiles",
-        {},
-        (response) => {
-          if (response.success && response.data) {
-            resolve2(response.data);
-          } else {
-            reject(new Error(response.error ?? "Failed to fetch task files"));
-          }
-        }
-      );
-    });
+    return fetchTaskFiles(this.socket);
   }
   fetchTaskFile(fileId) {
-    const socket = this.socket;
-    if (!socket) throw new Error("Not connected");
-    return new Promise((resolve2, reject) => {
-      socket.emit(
-        "agentRunner:getTaskFile",
-        { fileId },
-        (response) => {
-          if (response.success && response.data) {
-            resolve2(response.data);
-          } else {
-            reject(new Error(response.error ?? "Failed to fetch task file"));
-          }
-        }
-      );
-    });
+    return fetchTaskFile(this.socket, fileId);
   }
   fetchTaskContext() {
-    const socket = this.socket;
-    if (!socket) throw new Error("Not connected");
-    return new Promise((resolve2, reject) => {
-      socket.emit(
-        "agentRunner:getTaskContext",
-        {},
-        (response) => {
-          if (response.success && response.data) {
-            resolve2(response.data);
-          } else {
-            reject(new Error(response.error ?? "Failed to fetch task context"));
-          }
-        }
-      );
-    });
+    return fetchTaskContext(this.socket);
   }
   sendEvent(event) {
     if (!this.socket) throw new Error("Not connected");
@@ -163,9 +189,7 @@ var ConveyorConnection = class _ConveyorConnection {
       this.flushTimer = null;
     }
     if (!this.socket || this.eventBuffer.length === 0) return;
-    for (const entry of this.eventBuffer) {
-      this.socket.emit("agentRunner:event", entry);
-    }
+    for (const entry of this.eventBuffer) this.socket.emit("agentRunner:event", entry);
     this.eventBuffer = [];
   }
   updateStatus(status) {
@@ -177,21 +201,7 @@ var ConveyorConnection = class _ConveyorConnection {
     this.socket.emit("agentRunner:chatMessage", { content });
   }
   createPR(params) {
-    const socket = this.socket;
-    if (!socket) throw new Error("Not connected");
-    return new Promise((resolve2, reject) => {
-      socket.emit(
-        "agentRunner:createPR",
-        params,
-        (response) => {
-          if (response.success && response.data) {
-            resolve2(response.data);
-          } else {
-            reject(new Error(response.error ?? "Failed to create pull request"));
-          }
-        }
-      );
-    });
+    return createPR(this.socket, params);
   }
   askUserQuestion(requestId, questions) {
     if (!this.socket) throw new Error("Not connected");
@@ -213,9 +223,7 @@ var ConveyorConnection = class _ConveyorConnection {
   }
   onChatMessage(callback) {
     this.chatMessageCallback = callback;
-    for (const msg of this.earlyMessages) {
-      callback(msg);
-    }
+    for (const msg of this.earlyMessages) callback(msg);
     this.earlyMessages = [];
   }
   onStopRequested(callback) {
@@ -227,9 +235,7 @@ var ConveyorConnection = class _ConveyorConnection {
   }
   onModeChange(callback) {
     this.modeChangeCallback = callback;
-    for (const data of this.earlyModeChanges) {
-      callback(data);
-    }
+    for (const data of this.earlyModeChanges) callback(data);
     this.earlyModeChanges = [];
   }
   onRunStartCommand(callback) {
@@ -247,6 +253,10 @@ var ConveyorConnection = class _ConveyorConnection {
     if (!this.socket) return;
     this.socket.emit("agentRunner:statusUpdate", { status });
   }
+  emitRateLimitPause(resetsAt) {
+    if (!this.socket) return;
+    this.socket.emit("agentRunner:rateLimitPause", { resetsAt });
+  }
   sendHeartbeat() {
     if (!this.socket) return;
     this.socket.emit("agentRunner:heartbeat", {});
@@ -258,14 +268,7 @@ var ConveyorConnection = class _ConveyorConnection {
     this.sendEvent({ type: "agent_typing_stop" });
   }
   createSubtask(data) {
-    const socket = this.socket;
-    if (!socket) throw new Error("Not connected");
-    return new Promise((resolve2, reject) => {
-      socket.emit("agentRunner:createSubtask", data, (response) => {
-        if (response.success && response.data) resolve2(response.data);
-        else reject(new Error(response.error ?? "Failed to create subtask"));
-      });
-    });
+    return createSubtask(this.socket, data);
   }
   updateSubtask(subtaskId, fields) {
     if (!this.socket) throw new Error("Not connected");
@@ -276,183 +279,44 @@ var ConveyorConnection = class _ConveyorConnection {
     this.socket.emit("agentRunner:deleteSubtask", { subtaskId });
   }
   listSubtasks() {
-    const socket = this.socket;
-    if (!socket) throw new Error("Not connected");
-    return new Promise((resolve2, reject) => {
-      socket.emit("agentRunner:listSubtasks", {}, (response) => {
-        if (response.success && response.data) resolve2(response.data);
-        else reject(new Error(response.error ?? "Failed to list subtasks"));
-      });
-    });
+    return listSubtasks(this.socket);
   }
   fetchCliHistory(taskId, limit, source) {
-    const socket = this.socket;
-    if (!socket) throw new Error("Not connected");
-    const timeout = 1e4;
-    return Promise.race([
-      new Promise((resolve2, reject) => {
-        socket.emit(
-          "agentRunner:getCliHistory",
-          { taskId: taskId ?? this.config.taskId, limit, source },
-          (response) => {
-            if (response.success && response.data) {
-              resolve2(response.data);
-            } else {
-              reject(new Error(response.error ?? "Failed to fetch CLI history"));
-            }
-          }
-        );
-      }),
-      new Promise(
-        (_, reject) => setTimeout(() => reject(new Error("CLI history request timed out")), timeout)
-      )
-    ]);
+    return fetchCliHistory(this.socket, taskId ?? this.config.taskId, limit, source);
   }
   startChildCloudBuild(childTaskId) {
-    const socket = this.socket;
-    if (!socket) throw new Error("Not connected");
-    return new Promise((resolve2, reject) => {
-      socket.emit(
-        "agentRunner:startChildCloudBuild",
-        { childTaskId },
-        (response) => {
-          if (response.success && response.data) resolve2(response.data);
-          else reject(new Error(response.error ?? "Failed to start child cloud build"));
-        }
-      );
-    });
+    return startChildCloudBuild(this.socket, childTaskId);
   }
   approveAndMergePR(childTaskId) {
-    const socket = this.socket;
-    if (!socket) throw new Error("Not connected");
-    return new Promise((resolve2, reject) => {
-      socket.emit(
-        "agentRunner:approveAndMergePR",
-        { childTaskId },
-        (response) => {
-          if (response.success && response.data) {
-            resolve2(response.data);
-          } else {
-            reject(new Error(response.error ?? "Failed to approve and merge PR"));
-          }
-        }
-      );
-    });
+    return approveAndMergePR(this.socket, childTaskId);
   }
   postChildChatMessage(childTaskId, content) {
-    const socket = this.socket;
-    if (!socket) throw new Error("Not connected");
-    return new Promise((resolve2, reject) => {
-      socket.emit(
-        "agentRunner:postChildChatMessage",
-        { childTaskId, content },
-        (response) => {
-          if (response.success) resolve2();
-          else reject(new Error(response.error ?? "Failed to post to child chat"));
-        }
-      );
-    });
+    return postChildChatMessage(this.socket, childTaskId, content);
   }
   updateChildStatus(childTaskId, status) {
-    const socket = this.socket;
-    if (!socket) throw new Error("Not connected");
-    return new Promise((resolve2, reject) => {
-      socket.emit(
-        "agentRunner:updateChildStatus",
-        { childTaskId, status },
-        (response) => {
-          if (response.success) resolve2();
-          else reject(new Error(response.error ?? "Failed to update child status"));
-        }
-      );
-    });
+    return updateChildStatus(this.socket, childTaskId, status);
   }
   stopChildBuild(childTaskId) {
-    const socket = this.socket;
-    if (!socket) throw new Error("Not connected");
-    return new Promise((resolve2, reject) => {
-      socket.emit(
-        "agentRunner:stopChildBuild",
-        { childTaskId },
-        (response) => {
-          if (response.success) resolve2();
-          else reject(new Error(response.error ?? "Failed to stop child build"));
-        }
-      );
-    });
+    return stopChildBuild(this.socket, childTaskId);
   }
   fetchTask(slugOrId) {
-    const socket = this.socket;
-    if (!socket) throw new Error("Not connected");
-    return new Promise((resolve2, reject) => {
-      socket.emit(
-        "agentRunner:getTask",
-        { slugOrId },
-        (response) => {
-          if (response.success && response.data) {
-            resolve2(response.data);
-          } else {
-            reject(new Error(response.error ?? "Failed to fetch task"));
-          }
-        }
-      );
-    });
+    return fetchTask(this.socket, slugOrId);
   }
   updateTaskProperties(data) {
     if (!this.socket) throw new Error("Not connected");
     this.socket.emit("agentRunner:updateTaskProperties", data);
   }
   listIcons() {
-    const socket = this.socket;
-    if (!socket) throw new Error("Not connected");
-    return new Promise((resolve2, reject) => {
-      socket.emit("agentRunner:listIcons", {}, (response) => {
-        if (response.success && response.data) resolve2(response.data);
-        else reject(new Error(response.error ?? "Failed to list icons"));
-      });
-    });
+    return listIcons(this.socket);
   }
   generateTaskIcon(prompt, aspectRatio) {
-    const socket = this.socket;
-    if (!socket) throw new Error("Not connected");
-    return new Promise((resolve2, reject) => {
-      socket.emit(
-        "agentRunner:generateTaskIcon",
-        { prompt, aspectRatio },
-        (response) => {
-          if (response.success && response.data) resolve2(response.data);
-          else reject(new Error(response.error ?? "Failed to generate icon"));
-        }
-      );
-    });
+    return generateTaskIcon(this.socket, prompt, aspectRatio);
   }
   getTaskProperties() {
-    const socket = this.socket;
-    if (!socket) throw new Error("Not connected");
-    return new Promise((resolve2, reject) => {
-      socket.emit(
-        "agentRunner:getTaskProperties",
-        {},
-        (response) => {
-          if (response.success && response.data) resolve2(response.data);
-          else reject(new Error(response.error ?? "Failed to get task properties"));
-        }
-      );
-    });
+    return getTaskProperties(this.socket);
   }
   triggerIdentification() {
-    const socket = this.socket;
-    if (!socket) throw new Error("Not connected");
-    return new Promise((resolve2, reject) => {
-      socket.emit(
-        "agentRunner:triggerIdentification",
-        {},
-        (response) => {
-          if (response.success && response.data) resolve2(response.data);
-          else reject(new Error(response.error ?? "Identification failed"));
-        }
-      );
-    });
+    return triggerIdentification(this.socket);
   }
   emitModeTransition(payload) {
     if (!this.socket) return;
@@ -615,14 +479,52 @@ var ProjectConnection = class {
   }
 };
 
+// src/runner/worktree.ts
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+var WORKTREE_DIR = ".worktrees";
+function ensureWorktree(projectDir, taskId, branch) {
+  const worktreePath = join(projectDir, WORKTREE_DIR, taskId);
+  if (existsSync(worktreePath)) {
+    if (branch) {
+      try {
+        execSync(`git checkout --detach origin/${branch}`, {
+          cwd: worktreePath,
+          stdio: "ignore"
+        });
+      } catch {
+      }
+    }
+    return worktreePath;
+  }
+  const ref = branch ? `origin/${branch}` : "HEAD";
+  execSync(`git worktree add --detach "${worktreePath}" ${ref}`, {
+    cwd: projectDir,
+    stdio: "ignore"
+  });
+  return worktreePath;
+}
+function removeWorktree(projectDir, taskId) {
+  const worktreePath = join(projectDir, WORKTREE_DIR, taskId);
+  if (!existsSync(worktreePath)) return;
+  try {
+    execSync(`git worktree remove "${worktreePath}" --force`, {
+      cwd: projectDir,
+      stdio: "ignore"
+    });
+  } catch {
+  }
+}
+
 // src/setup/config.ts
 import { readFile } from "fs/promises";
-import { join } from "path";
+import { join as join2 } from "path";
 var CONVEYOR_CONFIG_PATH = ".conveyor/config.json";
 var DEVCONTAINER_PATH = ".devcontainer/conveyor/devcontainer.json";
 async function loadForwardPorts(workspaceDir) {
   try {
-    const raw = await readFile(join(workspaceDir, DEVCONTAINER_PATH), "utf-8");
+    const raw = await readFile(join2(workspaceDir, DEVCONTAINER_PATH), "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.forwardPorts ?? [];
   } catch {
@@ -631,13 +533,13 @@ async function loadForwardPorts(workspaceDir) {
 }
 async function loadConveyorConfig(workspaceDir) {
   try {
-    const raw = await readFile(join(workspaceDir, CONVEYOR_CONFIG_PATH), "utf-8");
+    const raw = await readFile(join2(workspaceDir, CONVEYOR_CONFIG_PATH), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.setupCommand || parsed.startCommand) return parsed;
   } catch {
   }
   try {
-    const raw = await readFile(join(workspaceDir, DEVCONTAINER_PATH), "utf-8");
+    const raw = await readFile(join2(workspaceDir, DEVCONTAINER_PATH), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.conveyor && (parsed.conveyor.startCommand || parsed.conveyor.setupCommand)) {
       return parsed.conveyor;
@@ -692,17 +594,17 @@ function runStartCommand(cmd, cwd, onOutput) {
 }
 
 // src/setup/codespace.ts
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 function initRtk() {
   try {
-    execSync("rtk --version", { stdio: "ignore" });
-    execSync("rtk init --global --auto-patch", { stdio: "ignore" });
+    execSync2("rtk --version", { stdio: "ignore" });
+    execSync2("rtk init --global --auto-patch", { stdio: "ignore" });
   } catch {
   }
 }
 function unshallowRepo(workspaceDir) {
   try {
-    execSync("git fetch --unshallow", {
+    execSync2("git fetch --unshallow", {
       cwd: workspaceDir,
       stdio: "ignore",
       timeout: 6e4
@@ -711,44 +613,6 @@ function unshallowRepo(workspaceDir) {
   }
 }
 
-// src/runner/worktree.ts
-import { execSync as execSync2 } from "child_process";
-import { existsSync } from "fs";
-import { join as join2 } from "path";
-var WORKTREE_DIR = ".worktrees";
-function ensureWorktree(projectDir, taskId, branch) {
-  const worktreePath = join2(projectDir, WORKTREE_DIR, taskId);
-  if (existsSync(worktreePath)) {
-    if (branch) {
-      try {
-        execSync2(`git checkout --detach origin/${branch}`, {
-          cwd: worktreePath,
-          stdio: "ignore"
-        });
-      } catch {
-      }
-    }
-    return worktreePath;
-  }
-  const ref = branch ? `origin/${branch}` : "HEAD";
-  execSync2(`git worktree add --detach "${worktreePath}" ${ref}`, {
-    cwd: projectDir,
-    stdio: "ignore"
-  });
-  return worktreePath;
-}
-function removeWorktree(projectDir, taskId) {
-  const worktreePath = join2(projectDir, WORKTREE_DIR, taskId);
-  if (!existsSync(worktreePath)) return;
-  try {
-    execSync2(`git worktree remove "${worktreePath}" --force`, {
-      cwd: projectDir,
-      stdio: "ignore"
-    });
-  } catch {
-  }
-}
-
 // src/runner/agent-runner.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { execSync as execSync3 } from "child_process";
@@ -785,45 +649,64 @@ async function processAssistantEvent(event, host, turnToolCalls) {
   }
 }
 var API_ERROR_PATTERN = /API Error: [45]\d\d/;
-function handleResultEvent(event, host, context, startTime) {
-  let totalCostUsd = 0;
-  let retriable = false;
-  if (event.subtype === "success") {
-    const successEvent = event;
-    const queryCostUsd = successEvent.total_cost_usd;
-    const durationMs = Date.now() - startTime;
-    const summary = successEvent.result || "Task completed.";
-    const isImageError = /Could not process image/i.test(summary);
-    if (isImageError || API_ERROR_PATTERN.test(summary) && durationMs < 3e4) {
-      retriable = true;
-    }
-    const cumulativeTotal = host.costTracker.addQueryCost(queryCostUsd);
-    totalCostUsd = cumulativeTotal;
-    const { modelUsage } = successEvent;
-    if (modelUsage && typeof modelUsage === "object") {
-      host.costTracker.addModelUsage(modelUsage);
-    }
-    host.connection.sendEvent({ type: "completed", summary, costUsd: cumulativeTotal, durationMs });
-    if (cumulativeTotal > 0 && context.agentId && context._runnerSessionId) {
-      const breakdown = host.costTracker.modelBreakdown;
-      host.connection.trackSpending({
-        agentId: context.agentId,
-        sessionId: context._runnerSessionId,
-        totalCostUsd: cumulativeTotal,
-        onSubscription: host.config.mode === "pm" || !!process.env.CLAUDE_CODE_OAUTH_TOKEN,
-        modelUsage: breakdown.length > 0 ? breakdown : void 0
-      });
-    }
-  } else {
-    const errorEvent = event;
-    const errorMsg = errorEvent.errors.length > 0 ? errorEvent.errors.join(", ") : `Agent stopped: ${errorEvent.subtype}`;
-    if (API_ERROR_PATTERN.test(errorMsg) || /Could not process image/i.test(errorMsg)) {
-      retriable = true;
+var IMAGE_ERROR_PATTERN = /Could not process image/i;
+function isRetriableMessage(msg, durationMs) {
+  if (IMAGE_ERROR_PATTERN.test(msg)) return true;
+  if (API_ERROR_PATTERN.test(msg) && (durationMs === void 0 || durationMs < 3e4)) return true;
+  return false;
+}
+function handleSuccessResult(event, host, context, startTime) {
+  const durationMs = Date.now() - startTime;
+  const summary = event.result || "Task completed.";
+  const retriable = isRetriableMessage(summary, durationMs);
+  const cumulativeTotal = host.costTracker.addQueryCost(event.total_cost_usd);
+  const { modelUsage } = event;
+  if (modelUsage && typeof modelUsage === "object") {
+    host.costTracker.addModelUsage(modelUsage);
+  }
+  host.connection.sendEvent({ type: "completed", summary, costUsd: cumulativeTotal, durationMs });
+  if (modelUsage && typeof modelUsage === "object") {
+    let queryInputTokens = 0;
+    let contextWindow = 0;
+    for (const data of Object.values(modelUsage)) {
+      queryInputTokens += data.inputTokens ?? 0;
+      const cw = data.contextWindow ?? 0;
+      if (cw > contextWindow) contextWindow = cw;
+    }
+    if (contextWindow > 0) {
+      host.connection.sendEvent({
+        type: "context_update",
+        contextTokens: queryInputTokens,
+        contextWindow
+      });
     }
-    host.connection.sendEvent({ type: "error", message: errorMsg });
   }
+  if (cumulativeTotal > 0 && context.agentId && context._runnerSessionId) {
+    const breakdown = host.costTracker.modelBreakdown;
+    host.connection.trackSpending({
+      agentId: context.agentId,
+      sessionId: context._runnerSessionId,
+      totalCostUsd: cumulativeTotal,
+      onSubscription: host.config.mode === "pm" || !!process.env.CLAUDE_CODE_OAUTH_TOKEN,
+      modelUsage: breakdown.length > 0 ? breakdown : void 0
+    });
+  }
+  return { totalCostUsd: cumulativeTotal, retriable };
+}
+function handleErrorResult(event, host) {
+  const errorMsg = event.errors.length > 0 ? event.errors.join(", ") : `Agent stopped: ${event.subtype}`;
+  const retriable = isRetriableMessage(errorMsg);
+  host.connection.sendEvent({ type: "error", message: errorMsg });
+  return { retriable };
+}
+function handleResultEvent(event, host, context, startTime) {
   const resultSummary = event.subtype === "success" ? event.result : event.errors.join(", ");
-  return { totalCostUsd, retriable, resultSummary };
+  if (event.subtype === "success") {
+    const result2 = handleSuccessResult(event, host, context, startTime);
+    return { ...result2, resultSummary };
+  }
+  const result = handleErrorResult(event, host);
+  return { totalCostUsd: 0, ...result, resultSummary };
 }
 async function emitResultEvent(event, host, context, startTime) {
   const result = handleResultEvent(event, host, context, startTime);
@@ -848,16 +731,19 @@ function handleRateLimitEvent(event, host) {
   const { rate_limit_info } = event;
   const status = rate_limit_info.status;
   if (status === "rejected") {
-    const resetsAt = rate_limit_info.resetsAt ? new Date(rate_limit_info.resetsAt).toISOString() : "unknown";
-    const message = `Rate limit rejected (type: ${rate_limit_info.rateLimitType ?? "unknown"}, resets at: ${resetsAt})`;
+    const resetsAt = rate_limit_info.resetsAt ? new Date(rate_limit_info.resetsAt).toISOString() : void 0;
+    const resetsAtDisplay = resetsAt ?? "unknown";
+    const message = `Rate limit rejected (type: ${rate_limit_info.rateLimitType ?? "unknown"}, resets at: ${resetsAtDisplay})`;
     host.connection.sendEvent({ type: "error", message });
     void host.callbacks.onEvent({ type: "error", message });
+    return resetsAt;
   } else if (status === "allowed_warning") {
     const utilization = rate_limit_info.utilization ? `${Math.round(rate_limit_info.utilization * 100)}%` : "high";
     const message = `Rate limit warning: ${utilization} utilization (type: ${rate_limit_info.rateLimitType ?? "unknown"})`;
     host.connection.sendEvent({ type: "thinking", message });
     void host.callbacks.onEvent({ type: "thinking", message });
   }
+  return void 0;
 }
 async function processEvents(events, context, host) {
   const startTime = Date.now();
@@ -865,6 +751,7 @@ async function processEvents(events, context, host) {
   let isTyping = false;
   let retriable = false;
   let resultSummary;
+  let rateLimitResetsAt;
   const turnToolCalls = [];
   for await (const event of events) {
     if (host.isStopped()) break;
@@ -914,7 +801,8 @@ async function processEvents(events, context, host) {
         break;
       }
       case "rate_limit_event": {
-        handleRateLimitEvent(event, host);
+        const resetsAt = handleRateLimitEvent(event, host);
+        if (resetsAt) rateLimitResetsAt = resetsAt;
         break;
       }
     }
@@ -922,260 +810,141 @@ async function processEvents(events, context, host) {
   if (isTyping) {
     host.connection.sendTypingStop();
   }
-  return { retriable, resultSummary };
+  return { retriable, resultSummary, rateLimitResetsAt };
 }
 
 // src/execution/query-executor.ts
-import { randomUUID } from "crypto";
 import {
   query
 } from "@anthropic-ai/claude-agent-sdk";
 
-// src/execution/prompt-builder.ts
-var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["InProgress", "ReviewPR", "ReviewDev", "ReviewLive"]);
-function formatFileSize(bytes) {
-  if (bytes === void 0) return "";
-  if (bytes < 1024) return `${bytes}B`;
-  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)}KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-}
+// src/execution/pack-runner-prompt.ts
 function findLastAgentMessageIndex(history) {
   for (let i = history.length - 1; i >= 0; i--) {
     if (history[i].role === "assistant") return i;
   }
   return -1;
 }
-function detectRelaunchScenario(context) {
-  const lastAgentIdx = findLastAgentMessageIndex(context.chatHistory);
-  if (lastAgentIdx === -1) return "fresh";
-  const hasPriorWork = !!context.githubPRUrl || !!context.claudeSessionId || ACTIVE_STATUSES.has(context.status ?? "");
-  if (!hasPriorWork) return "fresh";
-  const messagesAfterAgent = context.chatHistory.slice(lastAgentIdx + 1);
-  const hasNewUserMessages = messagesAfterAgent.some((m) => m.role === "user");
-  return hasNewUserMessages ? "feedback_relaunch" : "idle_relaunch";
+function formatProjectAgents(projectAgents) {
+  const parts = [``, `## Project Agents`];
+  for (const pa of projectAgents) {
+    const role = pa.role ? `role: ${pa.role}` : "role: unassigned";
+    const sp = pa.storyPoints === null || pa.storyPoints === void 0 ? "" : `, story points: ${pa.storyPoints}`;
+    parts.push(`- ${pa.agent.name} (${role}${sp})`);
+  }
+  return parts;
 }
-function buildRelaunchWithSession(mode, context) {
-  const scenario = detectRelaunchScenario(context);
-  if (!context.claudeSessionId || scenario === "fresh") return null;
-  const parts = [];
-  const lastAgentIdx = findLastAgentMessageIndex(context.chatHistory);
-  if (mode === "pm") {
-    const newMessages = context.chatHistory.slice(lastAgentIdx + 1).filter((m) => m.role === "user");
-    if (newMessages.length > 0) {
-      parts.push(
-        `You have been relaunched. Here are new messages since your last session:`,
-        ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`)
-      );
-    } else {
-      parts.push(`You have been relaunched. No new messages since your last session.`);
-    }
-    parts.push(
-      `
-You are the project manager for this task.`,
-      `Review the context above and wait for the team to provide instructions before taking action.`
-    );
-  } else if (scenario === "feedback_relaunch") {
-    const newMessages = context.chatHistory.slice(lastAgentIdx + 1).filter((m) => m.role === "user");
-    parts.push(
-      `You have been relaunched with new feedback.`,
-      `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
-      `
-New messages since your last run:`,
-      ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`),
-      `
-Address the requested changes. Do NOT re-investigate the codebase from scratch or write a new plan \u2014 review the feedback and implement the changes directly.`,
-      `Commit and push your updates.`
-    );
-    if (context.githubPRUrl) {
-      parts.push(
-        `An existing PR is open at ${context.githubPRUrl} \u2014 push to the same branch. Do NOT create a new PR.`
-      );
-    } else {
-      parts.push(
-        `When finished, use the create_pull_request tool to open a PR. Do NOT use gh CLI.`
-      );
-    }
-  } else {
-    parts.push(
-      `You were relaunched but no new instructions have been given since your last run.`,
-      `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
-      `Run \`git log --oneline -10\` to review what you already committed.`,
-      `Review the current state of the codebase and verify everything is working correctly.`,
-      `Reply with a brief status update (visible in chat), then wait for further instructions.`
-    );
-    if (context.githubPRUrl) {
-      parts.push(`An existing PR is open at ${context.githubPRUrl}. Do not create a new PR.`);
-    }
+function formatStoryPoints(storyPoints) {
+  const parts = [``, `## Story Point Tiers`];
+  for (const sp of storyPoints) {
+    const desc = sp.description ? ` \u2014 ${sp.description}` : "";
+    parts.push(`- Value ${sp.value}: "${sp.name}"${desc}`);
   }
-  return parts.join("\n");
+  return parts;
 }
-function buildTaskBody(context) {
-  const parts = [];
-  parts.push(`# Task: ${context.title}`);
-  if (context.description) {
-    parts.push(`
-## Description
-${context.description}`);
+function buildPackRunnerSystemPrompt(context, config, setupLog) {
+  const parts = [
+    `You are an autonomous Pack Runner managing child tasks for the "${context.title}" project.`,
+    `You are running locally with full access to the repository and task management tools.`,
+    `Your job is to sequentially execute child tasks by firing cloud builds, reviewing their PRs, and merging them.`,
+    ``,
+    `## Child Task Status Lifecycle`,
+    `- "Planning" \u2014 Not ready for execution. Skip it (or escalate if blocking).`,
+    `- "Open" \u2014 Ready to execute. Use start_child_cloud_build to fire it.`,
+    `- "InProgress" \u2014 Currently being worked on by a Task Runner. Wait \u2014 it will move to ReviewPR when done.`,
+    `- "ReviewPR" \u2014 Task Runner finished and opened a PR. Review and merge it.`,
+    `- "ReviewDev" \u2014 PR was merged to dev. This child is complete. Move on.`,
+    `- "Complete" \u2014 Fully done. Move on.`,
+    ``,
+    `## Autonomous Loop`,
+    `Follow this loop each time you are launched or relaunched:`,
+    ``,
+    `1. Call list_subtasks to see the current state of all child tasks.`,
+    `   The response includes PR info (githubPRNumber, githubPRUrl) and agent assignment (agentId).`,
+    ``,
+    `2. Evaluate each child by status (in ordinal order):`,
+    `   - "ReviewPR": Review and merge its PR with approve_and_merge_pr.`,
+    `     - If merge fails due to pending CI: post a status update to chat, state you are going idle, and the system will relaunch you to try again.`,
+    `     - If merge fails due to failed CI: use get_task_cli(childTaskId) to check what went wrong. Escalate to the team in chat.`,
+    `   - "InProgress": A Task Runner is actively working on this child. Do nothing \u2014 wait for it to finish.`,
+    `   - "Open": This is the next child to execute. Fire it with start_child_cloud_build.`,
+    `     - If it fails because the child is missing story points or an agent: notify the team in chat and go idle.`,
+    `   - "ReviewDev" / "Complete": Already done. Skip.`,
+    `   - "Planning": Not ready. If this is blocking progress, notify the team.`,
+    ``,
+    `3. After merging a PR: run \`git pull origin ${context.baseBranch}\` to get the merged changes before firing the next child.`,
+    ``,
+    `4. After firing a child build: report which task you fired to chat, then explicitly state you are going idle. The system will relaunch you when the child completes or changes status.`,
+    ``,
+    `5. 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 update_task_status("Complete").`,
+    ``,
+    `## Important Rules`,
+    `- Process children ONE at a time, in ordinal order.`,
+    `- After firing a child build OR when waiting on CI, explicitly state you are going idle. The system will disconnect you and relaunch when there's a status change.`,
+    `- 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_task_cli(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.`,
+    `- list_subtasks returns PR info (githubPRNumber, githubPRUrl) and agent assignment (agentId) for each child \u2014 use this to verify readiness before firing builds.`,
+    `- You can use read_task_chat to check for team messages.`
+  ];
+  if (context.storyPoints && context.storyPoints.length > 0) {
+    parts.push(...formatStoryPoints(context.storyPoints));
   }
-  if (context.plan) {
-    parts.push(`
-## Plan
-${context.plan}`);
+  if (context.projectAgents && context.projectAgents.length > 0) {
+    parts.push(...formatProjectAgents(context.projectAgents));
   }
-  if (context.files && context.files.length > 0) {
-    parts.push(`
-## Attached Files`);
-    for (const file of context.files) {
-      if (file.content && file.contentEncoding === "utf-8") {
-        parts.push(`
-### ${file.fileName} (${file.mimeType})`);
-        parts.push("```");
-        parts.push(file.content);
-        parts.push("```");
-      } else if (file.content && file.contentEncoding === "base64") {
-        const size = formatFileSize(file.fileSize);
-        parts.push(
-          `- [Attached image: ${file.fileName} (${file.mimeType}${size ? `, ${size}` : ""}) \u2014 use get_task_file("${file.fileId}") to view]`
-        );
-      } else if (!file.content) {
-        parts.push(`- **${file.fileName}** (${file.mimeType}): ${file.downloadUrl}`);
-      }
-    }
+  if (setupLog.length > 0) {
+    parts.push(``, `## Environment setup log`, "```", ...setupLog, "```");
   }
-  if (context.repoRefs && context.repoRefs.length > 0) {
-    parts.push(`
-## Repository References`);
-    for (const ref of context.repoRefs) {
-      const icon = ref.refType === "folder" ? "folder" : "file";
-      parts.push(`- [${icon}] \`${ref.path}\``);
-    }
+  if (context.agentInstructions) {
+    parts.push(``, `## Agent Instructions`, context.agentInstructions);
   }
-  if (context.chatHistory.length > 0) {
-    const relevant = context.chatHistory.slice(-20);
-    parts.push(`
-## Recent Chat Context`);
-    for (const msg of relevant) {
-      const sender = msg.userName ?? msg.role;
-      parts.push(`[${sender}]: ${msg.content}`);
-      if (msg.files?.length) {
-        for (const file of msg.files) {
-          const sizeStr = file.fileSize ? `, ${formatFileSize(file.fileSize)}` : "";
-          if (file.content && file.contentEncoding === "utf-8") {
-            parts.push(`[Attached: ${file.fileName} (${file.mimeType}${sizeStr})]`);
-            parts.push("```");
-            parts.push(file.content);
-            parts.push("```");
-          } else if (!file.content) {
-            parts.push(
-              `[Attached: ${file.fileName} (${file.mimeType}${sizeStr})]: ${file.downloadUrl}`
-            );
-          } else if (file.content && file.contentEncoding === "base64") {
-            parts.push(
-              `[Attached image: ${file.fileName} (${file.mimeType}${sizeStr}) \u2014 use get_task_file("${file.fileId}") to view]`
-            );
-          } else {
-            parts.push(`[Attached: ${file.fileName} (${file.mimeType}${sizeStr})]`);
-          }
-        }
-      }
-    }
+  if (config.instructions) {
+    parts.push(``, `## Additional Instructions`, config.instructions);
   }
-  return parts;
+  parts.push(
+    ``,
+    `Your responses are sent directly to the task chat \u2014 the team sees everything you say.`,
+    `Do NOT call the post_to_chat tool for your own task; your replies already appear in chat automatically.`,
+    `Only use post_to_chat if you need to message a different task's chat (e.g. a child task).`,
+    `Use read_task_chat only if you need to re-read earlier messages beyond the chat context above.`
+  );
+  return parts.join("\n");
 }
-function buildInstructions(mode, context, scenario, agentMode) {
+function buildPackRunnerInstructions(context, scenario) {
   const parts = [`
 ## Instructions`];
-  const isPm = mode === "pm";
-  const isAutoMode = agentMode === "auto";
   if (scenario === "fresh") {
-    if (isAutoMode && isPm) {
-      parts.push(
-        `You are operating autonomously. Begin planning immediately.`,
-        `1. Explore the codebase to understand the architecture and relevant files`,
-        `2. Draft a clear implementation plan and save it with update_task`,
-        `3. Set story points (set_story_points), tags (set_task_tags), and title (set_task_title)`,
-        `4. When the plan and all required properties are set, call ExitPlanMode to transition to building`,
-        `Do NOT wait for team input \u2014 proceed autonomously.`
-      );
-    } else if (isPm && context.isParentTask) {
-      parts.push(
-        `You are the project manager for this task and its subtasks.`,
-        `Use list_subtasks to review the current state of child tasks.`,
-        `The task details are provided above. Wait for the team to provide instructions before taking action.`,
-        `When you finish planning, save the plan with update_task and end your turn. Your reply will be visible to the team in chat.`
-      );
-    } else if (isPm) {
-      parts.push(
-        `You are the project manager for this task.`,
-        `The task details are provided above. Wait for the team to ask questions or provide additional requirements before starting to plan.`,
-        `When you finish planning, save the plan with update_task and end your turn. Your reply summarizing the plan will be visible in chat. A separate task agent will execute the plan after review.`
-      );
-    } else {
-      parts.push(
-        `Begin executing the task plan above immediately.`,
-        `Your FIRST action should be reading the relevant source files mentioned in the plan, then writing code. Do NOT run install, build, lint, test, or dev server commands first \u2014 the environment is already set up.`,
-        `Work on the git branch "${context.githubBranch}". Stay on this branch for the entire task. Do not checkout or create other branches.`,
-        `Your replies are visible to the team in chat \u2014 briefly describe what you're doing when you begin meaningful implementation, and again when the PR is ready.`,
-        `When finished, commit your changes, then run \`git fetch origin ${context.githubBranch}\` and \`git push origin ${context.githubBranch}\` (use --force-with-lease if push fails). Then use the create_pull_request tool to open a PR. Do NOT use gh CLI or any other method to create PRs.`
-      );
-    }
+    parts.push(
+      `You are the Pack Runner for this task and its subtasks.`,
+      `Begin your autonomous loop immediately: call list_subtasks to assess the current state.`,
+      `If any child is in "ReviewPR" status, review and merge its PR first.`,
+      `Then fire the next "Open" child task.`
+    );
   } else if (scenario === "idle_relaunch") {
-    if (isPm) {
-      parts.push(
-        `You were relaunched but no new instructions have been given since your last run.`,
-        `You are the project manager for this task.`,
-        `Wait for the team to provide instructions before taking action.`
-      );
-    } else {
-      parts.push(
-        `You were relaunched but no new instructions have been given since your last run.`,
-        `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
-        `Run \`git log --oneline -10\` to review what you already committed, then verify the current state is correct.`,
-        `Reply with a brief status update summarizing where things stand (visible in chat).`,
-        `Then wait for further instructions \u2014 do NOT redo work that was already completed.`
-      );
-      if (context.githubPRUrl) {
-        parts.push(`An existing PR is open at ${context.githubPRUrl}. Do not create a new PR.`);
-      }
-    }
+    parts.push(
+      `You have been relaunched \u2014 a child task likely changed status (completed work, opened a PR, or was merged).`,
+      `Call list_subtasks to check the current state of all children.`,
+      `Look for children in "ReviewPR" status first \u2014 review and merge their PRs.`,
+      `If a child you previously fired is now in "ReviewDev", it was merged. Pull latest with \`git pull origin ${context.baseBranch}\` and continue to the next "Open" child.`,
+      `If no children need action (all InProgress or waiting), state you are going idle.`
+    );
   } else {
     const lastAgentIdx = findLastAgentMessageIndex(context.chatHistory);
     const newMessages = context.chatHistory.slice(lastAgentIdx + 1).filter((m) => m.role === "user");
-    if (isPm) {
-      parts.push(
-        `You were relaunched with new feedback since your last run.`,
-        `You are the project manager for this task.`,
-        `
-New messages since your last run:`,
-        ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`),
-        `
-Review these messages and wait for the team to provide instructions before taking action.`
-      );
-    } else {
-      parts.push(
-        `You have been relaunched to address feedback on your previous work.`,
-        `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
-        `Start by running \`git log --oneline -10\` and \`git diff HEAD~3 HEAD --stat\` to review what you already committed.`,
-        `
+    parts.push(
+      `You have been relaunched with new messages.`,
+      `
 New messages since your last run:`,
-        ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`),
-        `
-Address the requested changes directly. Do NOT re-investigate the codebase from scratch or write a new plan \u2014 go straight to implementing the feedback.`,
-        `Commit and push your updates.`
-      );
-      if (context.githubPRUrl) {
-        parts.push(
-          `An existing PR is open at ${context.githubPRUrl} \u2014 push to the same branch to update it. Do NOT create a new PR.`
-        );
-      } else {
-        parts.push(
-          `When finished, use the create_pull_request tool to open a PR. Do NOT use gh CLI or any other method to create PRs.`
-        );
-      }
-    }
+      ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`),
+      `
+After addressing the feedback, resume your autonomous loop: call list_subtasks and proceed accordingly.`
+    );
   }
   return parts;
 }
+
+// src/execution/mode-prompt.ts
 function buildPropertyInstructions(context) {
   const parts = [];
   parts.push(
@@ -1214,16 +983,28 @@ function buildModePrompt(agentMode, context) {
 ## Mode: Discovery`,
         `You are in Discovery mode \u2014 helping plan and scope this task.`,
         `- You have read-only codebase access (can read files, run git commands, search code)`,
-        `- You have MCP tools: update_task (title, description, plan, tags, SP, icon)`,
+        `- You can write plan files in .claude/plans/ only \u2014 no other file writes`,
         `- You can create and manage subtasks`,
-        `- You cannot write code or edit files (except .claude/plans/)`,
         `- Goal: collaborate with the user to create a clear plan`,
         `- Proactively fill task properties (SP, tags, icon) as the plan takes shape`,
         ``,
+        `### Self-Identification Tools`,
+        `Use these MCP tools to set your own task properties:`,
+        `- \`update_task\` \u2014 save your plan and description`,
+        `- \`set_story_points\` \u2014 assign story points`,
+        `- \`set_task_title\` \u2014 set an accurate title`,
+        `- \`set_task_tags\` \u2014 categorize the work`,
+        `- \`set_task_icon\` / \`generate_task_icon\` \u2014 set a task icon (call \`list_icons\` first)`,
+        ``,
         `### Self-Update vs Subtasks`,
         `- If the work fits in a single task (1-3 SP), update YOUR OWN plan and properties \u2014 do not create subtasks`,
         `- Only create subtasks when the work genuinely requires multiple independent pieces (e.g., Pack-tier work, 8+ SP)`,
-        `- When planning for yourself: use update_task to save the plan, then set_story_points, set_task_title, set_task_icon`
+        ``,
+        `### Finishing Planning`,
+        `Once your plan is complete and all required properties are set, call the **ExitPlanMode** tool.`,
+        `- Required before ExitPlanMode will succeed: **plan** (via update_task), **story points** (via set_story_points), **title** (via set_task_title)`,
+        `- ExitPlanMode validates these properties and moves the task to Open status`,
+        `- It does NOT start building \u2014 the team controls when to switch to Build mode`
       ];
       if (context) {
         parts.push(...buildPropertyInstructions(context));
@@ -1287,135 +1068,15 @@ function buildModePrompt(agentMode, context) {
       return null;
   }
 }
-function buildPackRunnerSystemPrompt(context, config, setupLog) {
-  const parts = [
-    `You are an autonomous Pack Runner managing child tasks for the "${context.title}" project.`,
-    `You are running locally with full access to the repository and task management tools.`,
-    `Your job is to sequentially execute child tasks by firing cloud builds, reviewing their PRs, and merging them.`,
-    ``,
-    `## Child Task Status Lifecycle`,
-    `- "Planning" \u2014 Not ready for execution. Skip it (or escalate if blocking).`,
-    `- "Open" \u2014 Ready to execute. Use start_child_cloud_build to fire it.`,
-    `- "InProgress" \u2014 Currently being worked on by a Task Runner. Wait \u2014 it will move to ReviewPR when done.`,
-    `- "ReviewPR" \u2014 Task Runner finished and opened a PR. Review and merge it.`,
-    `- "ReviewDev" \u2014 PR was merged to dev. This child is complete. Move on.`,
-    `- "Complete" \u2014 Fully done. Move on.`,
-    ``,
-    `## Autonomous Loop`,
-    `Follow this loop each time you are launched or relaunched:`,
-    ``,
-    `1. Call list_subtasks to see the current state of all child tasks.`,
-    `   The response includes PR info (githubPRNumber, githubPRUrl) and agent assignment (agentId).`,
-    ``,
-    `2. Evaluate each child by status (in ordinal order):`,
-    `   - "ReviewPR": Review and merge its PR with approve_and_merge_pr.`,
-    `     - If merge fails due to pending CI: post a status update to chat, state you are going idle, and the system will relaunch you to try again.`,
-    `     - If merge fails due to failed CI: use get_task_cli(childTaskId) to check what went wrong. Escalate to the team in chat.`,
-    `   - "InProgress": A Task Runner is actively working on this child. Do nothing \u2014 wait for it to finish.`,
-    `   - "Open": This is the next child to execute. Fire it with start_child_cloud_build.`,
-    `     - If it fails because the child is missing story points or an agent: notify the team in chat and go idle.`,
-    `   - "ReviewDev" / "Complete": Already done. Skip.`,
-    `   - "Planning": Not ready. If this is blocking progress, notify the team.`,
-    ``,
-    `3. After merging a PR: run \`git pull origin ${context.baseBranch}\` to get the merged changes before firing the next child.`,
-    ``,
-    `4. After firing a child build: report which task you fired to chat, then explicitly state you are going idle. The system will relaunch you when the child completes or changes status.`,
-    ``,
-    `5. 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 update_task_status("Complete").`,
-    ``,
-    `## Important Rules`,
-    `- Process children ONE at a time, in ordinal order.`,
-    `- After firing a child build OR when waiting on CI, explicitly state you are going idle. The system will disconnect you and relaunch when there's a status change.`,
-    `- 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_task_cli(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.`,
-    `- list_subtasks returns PR info (githubPRNumber, githubPRUrl) and agent assignment (agentId) for each child \u2014 use this to verify readiness before firing builds.`,
-    `- You can use read_task_chat to check for team messages.`
-  ];
-  if (context.storyPoints && context.storyPoints.length > 0) {
-    parts.push(``, `## Story Point Tiers`);
-    for (const sp of context.storyPoints) {
-      const desc = sp.description ? ` \u2014 ${sp.description}` : "";
-      parts.push(`- Value ${sp.value}: "${sp.name}"${desc}`);
-    }
-  }
-  if (context.projectAgents && context.projectAgents.length > 0) {
-    parts.push(``, `## Project Agents`);
-    for (const pa of context.projectAgents) {
-      const role = pa.role ? `role: ${pa.role}` : "role: unassigned";
-      const sp = pa.storyPoints != null ? `, story points: ${pa.storyPoints}` : "";
-      parts.push(`- ${pa.agent.name} (${role}${sp})`);
-    }
-  }
-  if (setupLog.length > 0) {
-    parts.push(``, `## Environment setup log`, "```", ...setupLog, "```");
-  }
-  if (context.agentInstructions) {
-    parts.push(``, `## Agent Instructions`, context.agentInstructions);
-  }
-  if (config.instructions) {
-    parts.push(``, `## Additional Instructions`, config.instructions);
-  }
-  parts.push(
-    ``,
-    `Your responses are sent directly to the task chat \u2014 the team sees everything you say.`,
-    `Do NOT call the post_to_chat tool for your own task; your replies already appear in chat automatically.`,
-    `Only use post_to_chat if you need to message a different task's chat (e.g. a child task).`,
-    `Use read_task_chat only if you need to re-read earlier messages beyond the chat context above.`
-  );
-  return parts.join("\n");
-}
-function buildPackRunnerInstructions(context, scenario) {
-  const parts = [`
-## Instructions`];
-  if (scenario === "fresh") {
-    parts.push(
-      `You are the Pack Runner for this task and its subtasks.`,
-      `Begin your autonomous loop immediately: call list_subtasks to assess the current state.`,
-      `If any child is in "ReviewPR" status, review and merge its PR first.`,
-      `Then fire the next "Open" child task.`
-    );
-  } else if (scenario === "idle_relaunch") {
-    parts.push(
-      `You have been relaunched \u2014 a child task likely changed status (completed work, opened a PR, or was merged).`,
-      `Call list_subtasks to check the current state of all children.`,
-      `Look for children in "ReviewPR" status first \u2014 review and merge their PRs.`,
-      `If a child you previously fired is now in "ReviewDev", it was merged. Pull latest with \`git pull origin ${context.baseBranch}\` and continue to the next "Open" child.`,
-      `If no children need action (all InProgress or waiting), state you are going idle.`
-    );
-  } else {
-    const lastAgentIdx = findLastAgentMessageIndex(context.chatHistory);
-    const newMessages = context.chatHistory.slice(lastAgentIdx + 1).filter((m) => m.role === "user");
-    parts.push(
-      `You have been relaunched with new messages.`,
-      `
-New messages since your last run:`,
-      ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`),
-      `
-After addressing the feedback, resume your autonomous loop: call list_subtasks and proceed accordingly.`
-    );
-  }
-  return parts;
-}
-function buildInitialPrompt(mode, context, isAuto, agentMode) {
-  const isPackRunner = mode === "pm" && !!isAuto && !!context.isParentTask;
-  if (!isPackRunner) {
-    const sessionRelaunch = buildRelaunchWithSession(mode, context);
-    if (sessionRelaunch) return sessionRelaunch;
-  }
-  const scenario = detectRelaunchScenario(context);
-  const body = buildTaskBody(context);
-  const instructions = isPackRunner ? buildPackRunnerInstructions(context, scenario) : buildInstructions(mode, context, scenario, agentMode);
-  return [...body, ...instructions].join("\n");
+
+// src/execution/system-prompt.ts
+function formatProjectAgentLine(pa) {
+  const role = pa.role ? `role: ${pa.role}` : "role: unassigned";
+  const sp = pa.storyPoints === null || pa.storyPoints === void 0 ? "" : `, story points: ${pa.storyPoints}`;
+  return `- ${pa.agent.name} (${role}${sp})`;
 }
-function buildSystemPrompt(mode, context, config, setupLog, agentMode) {
-  const isPm = mode === "pm";
-  const isPmActive = isPm && agentMode === "building";
-  const isPackRunner = isPm && !!config.isAuto && !!context.isParentTask;
-  if (isPackRunner) {
-    return buildPackRunnerSystemPrompt(context, config, setupLog);
-  }
-  const pmParts = [
+function buildPmPreamble(context) {
+  const parts = [
     `You are an AI project manager helping to plan tasks for the "${context.title}" project.`,
     `You are running locally with full access to the repository.`,
     `You can read files, search code, and run shell commands (e.g. git log, git diff) to understand the codebase. You cannot write or edit files.`,
@@ -1431,8 +1092,8 @@ Workflow:`,
     `- After saving the plan, end your turn with a summary reply (the team sees your responses in chat automatically). Do NOT attempt to execute the plan yourself.`,
     `- A separate task agent will handle execution after the team reviews and approves your plan.`
   ];
-  if (isPm && context.isParentTask) {
-    pmParts.push(
+  if (context.isParentTask) {
+    parts.push(
       `
 You are the Project Manager for this set of tasks.`,
       `This task has child tasks (subtasks) that are tracked on the board.`,
@@ -1440,26 +1101,27 @@ You are the Project Manager for this set of tasks.`,
       `Use the subtask tools (create_subtask, update_subtask, list_subtasks) to manage work breakdown.`
     );
   }
-  if (isPm && context.storyPoints && context.storyPoints.length > 0) {
-    pmParts.push(`
+  if (context.storyPoints && context.storyPoints.length > 0) {
+    parts.push(`
 Story Point Tiers:`);
     for (const sp of context.storyPoints) {
       const desc = sp.description ? ` \u2014 ${sp.description}` : "";
-      pmParts.push(`- Value ${sp.value}: "${sp.name}"${desc}`);
+      parts.push(`- Value ${sp.value}: "${sp.name}"${desc}`);
     }
   }
-  if (isPm && context.projectAgents && context.projectAgents.length > 0) {
-    pmParts.push(`
+  if (context.projectAgents && context.projectAgents.length > 0) {
+    parts.push(`
 Project Agents:`);
     for (const pa of context.projectAgents) {
-      const role = pa.role ? `role: ${pa.role}` : "role: unassigned";
-      const sp = pa.storyPoints != null ? `, story points: ${pa.storyPoints}` : "";
-      pmParts.push(`- ${pa.agent.name} (${role}${sp})`);
+      parts.push(formatProjectAgentLine(pa));
     }
   }
-  const activeParts = [
+  return parts;
+}
+function buildActivePreamble(context, workspaceDir) {
+  return [
     `You are an AI project manager in ACTIVE mode for the "${context.title}" project.`,
-    `You have direct coding access to the repository at ${config.workspaceDir}.`,
+    `You have direct coding access to the repository at ${workspaceDir}.`,
     `You can edit files, run tests, and make commits.`,
     `You still have access to all PM tools (subtasks, update_task, chat).`,
     `
@@ -1470,7 +1132,7 @@ Environment (ready, no setup required):`,
     context.githubBranch ? `- You are working on branch: \`${context.githubBranch}\`` : "",
     `
 Safety rules:`,
-    `- Stay within the project directory (${config.workspaceDir}).`,
+    `- Stay within the project directory (${workspaceDir}).`,
     `- Do NOT run \`git push --force\` or \`git reset --hard\`. Use \`--force-with-lease\` if needed.`,
     `- Do NOT delete \`.env\` files or modify \`node_modules\`.`,
     `- Do NOT run destructive commands like \`rm -rf /\`.`,
@@ -1480,7 +1142,9 @@ Workflow:`,
     `- When done with changes, summarize what you did in your reply.`,
     `- If you toggled into active mode temporarily, mention when you're done so the team can switch you back to planning mode.`
   ].filter(Boolean);
-  const parts = isPmActive ? activeParts : isPm ? pmParts : [
+}
+function buildTaskAgentPreamble(context) {
+  return [
     `You are an AI agent working on a task for the "${context.title}" project.`,
     `You are running inside a GitHub Codespace with full access to the repository.`,
     `
@@ -1505,6 +1169,15 @@ Git safety \u2014 STRICT rules:`,
     `- This branch was created from \`${context.baseBranch}\`. PRs will automatically target that branch.`,
     `- If \`git push\` fails with "non-fast-forward", run \`git push --force-with-lease origin ${context.githubBranch}\`. This branch is exclusively yours \u2014 force-with-lease is safe.`
   ];
+}
+function buildSystemPrompt(mode, context, config, setupLog, agentMode) {
+  const isPm = mode === "pm";
+  const isPmActive = isPm && agentMode === "building";
+  const isPackRunner = isPm && !!config.isAuto && !!context.isParentTask;
+  if (isPackRunner) {
+    return buildPackRunnerSystemPrompt(context, config, setupLog);
+  }
+  const parts = isPmActive ? buildActivePreamble(context, config.workspaceDir) : isPm ? buildPmPreamble(context) : buildTaskAgentPreamble(context);
   if (setupLog.length > 0) {
     parts.push(
       `
@@ -1536,11 +1209,306 @@ Your responses are sent directly to the task chat \u2014 the team sees everythin
       `Use the create_pull_request tool to open PRs \u2014 do NOT use gh CLI or shell commands for PR creation.`
     );
   }
-  const modePrompt = buildModePrompt(agentMode, context);
-  if (modePrompt) {
-    parts.push(modePrompt);
+  const modePrompt = buildModePrompt(agentMode, context);
+  if (modePrompt) {
+    parts.push(modePrompt);
+  }
+  return parts.join("\n");
+}
+
+// src/execution/prompt-builder.ts
+var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["InProgress", "ReviewPR", "ReviewDev", "ReviewLive"]);
+function formatFileSize(bytes) {
+  if (bytes === void 0) return "";
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+function findLastAgentMessageIndex2(history) {
+  for (let i = history.length - 1; i >= 0; i--) {
+    if (history[i].role === "assistant") return i;
+  }
+  return -1;
+}
+function detectRelaunchScenario(context) {
+  const lastAgentIdx = findLastAgentMessageIndex2(context.chatHistory);
+  if (lastAgentIdx === -1) return "fresh";
+  const hasPriorWork = !!context.githubPRUrl || !!context.claudeSessionId || ACTIVE_STATUSES.has(context.status ?? "");
+  if (!hasPriorWork) return "fresh";
+  const messagesAfterAgent = context.chatHistory.slice(lastAgentIdx + 1);
+  const hasNewUserMessages = messagesAfterAgent.some((m) => m.role === "user");
+  return hasNewUserMessages ? "feedback_relaunch" : "idle_relaunch";
+}
+function buildRelaunchWithSession(mode, context) {
+  const scenario = detectRelaunchScenario(context);
+  if (!context.claudeSessionId || scenario === "fresh") return null;
+  const parts = [];
+  const lastAgentIdx = findLastAgentMessageIndex2(context.chatHistory);
+  if (mode === "pm") {
+    const newMessages = context.chatHistory.slice(lastAgentIdx + 1).filter((m) => m.role === "user");
+    if (newMessages.length > 0) {
+      parts.push(
+        `You have been relaunched. Here are new messages since your last session:`,
+        ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`)
+      );
+    } else {
+      parts.push(`You have been relaunched. No new messages since your last session.`);
+    }
+    parts.push(
+      `
+You are the project manager for this task.`,
+      `Review the context above and wait for the team to provide instructions before taking action.`
+    );
+  } else if (scenario === "feedback_relaunch") {
+    const newMessages = context.chatHistory.slice(lastAgentIdx + 1).filter((m) => m.role === "user");
+    parts.push(
+      `You have been relaunched with new feedback.`,
+      `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
+      `
+New messages since your last run:`,
+      ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`),
+      `
+Address the requested changes. Do NOT re-investigate the codebase from scratch or write a new plan \u2014 review the feedback and implement the changes directly.`,
+      `Commit and push your updates.`
+    );
+    if (context.githubPRUrl) {
+      parts.push(
+        `An existing PR is open at ${context.githubPRUrl} \u2014 push to the same branch. Do NOT create a new PR.`
+      );
+    } else {
+      parts.push(
+        `When finished, use the create_pull_request tool to open a PR. Do NOT use gh CLI.`
+      );
+    }
+  } else {
+    parts.push(
+      `You were relaunched but no new instructions have been given since your last run.`,
+      `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
+      `Run \`git log --oneline -10\` to review what you already committed.`,
+      `Review the current state of the codebase and verify everything is working correctly.`,
+      `Reply with a brief status update (visible in chat), then wait for further instructions.`
+    );
+    if (context.githubPRUrl) {
+      parts.push(`An existing PR is open at ${context.githubPRUrl}. Do not create a new PR.`);
+    }
+  }
+  return parts.join("\n");
+}
+function formatChatFile(file) {
+  const sizeStr = file.fileSize ? `, ${formatFileSize(file.fileSize)}` : "";
+  if (file.content && file.contentEncoding === "utf-8") {
+    return [
+      `[Attached: ${file.fileName} (${file.mimeType}${sizeStr})]`,
+      "```",
+      file.content,
+      "```"
+    ];
+  }
+  if (!file.content) {
+    return [`[Attached: ${file.fileName} (${file.mimeType}${sizeStr})]: ${file.downloadUrl}`];
+  }
+  if (file.content && file.contentEncoding === "base64") {
+    return [
+      `[Attached image: ${file.fileName} (${file.mimeType}${sizeStr}) \u2014 use get_task_file("${file.fileId}") to view]`
+    ];
+  }
+  return [`[Attached: ${file.fileName} (${file.mimeType}${sizeStr})]`];
+}
+function formatTaskFile(file) {
+  if (file.content && file.contentEncoding === "utf-8") {
+    return [`
+### ${file.fileName} (${file.mimeType})`, "```", file.content, "```"];
+  }
+  if (file.content && file.contentEncoding === "base64") {
+    const size = formatFileSize(file.fileSize);
+    return [
+      `- [Attached image: ${file.fileName} (${file.mimeType}${size ? `, ${size}` : ""}) \u2014 use get_task_file("${file.fileId}") to view]`
+    ];
+  }
+  if (!file.content) {
+    return [`- **${file.fileName}** (${file.mimeType}): ${file.downloadUrl}`];
+  }
+  return [];
+}
+function formatChatHistory(chatHistory) {
+  const relevant = chatHistory.slice(-20);
+  const parts = [`
+## Recent Chat Context`];
+  for (const msg of relevant) {
+    const sender = msg.userName ?? msg.role;
+    parts.push(`[${sender}]: ${msg.content}`);
+    if (msg.files?.length) {
+      for (const file of msg.files) {
+        parts.push(...formatChatFile(file));
+      }
+    }
+  }
+  return parts;
+}
+function buildTaskBody(context) {
+  const parts = [];
+  parts.push(`# Task: ${context.title}`);
+  if (context.description) {
+    parts.push(`
+## Description
+${context.description}`);
+  }
+  if (context.plan) {
+    parts.push(`
+## Plan
+${context.plan}`);
+  }
+  if (context.files && context.files.length > 0) {
+    parts.push(`
+## Attached Files`);
+    for (const file of context.files) {
+      parts.push(...formatTaskFile(file));
+    }
+  }
+  if (context.repoRefs && context.repoRefs.length > 0) {
+    parts.push(`
+## Repository References`);
+    for (const ref of context.repoRefs) {
+      const icon = ref.refType === "folder" ? "folder" : "file";
+      parts.push(`- [${icon}] \`${ref.path}\``);
+    }
+  }
+  if (context.chatHistory.length > 0) {
+    parts.push(...formatChatHistory(context.chatHistory));
+  }
+  return parts;
+}
+function buildFreshInstructions(isPm, isAutoMode, context, agentMode) {
+  if (isPm && agentMode === "building") {
+    return [
+      `Your plan has been approved. Begin implementing it now.`,
+      `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
+      `Start by reading the relevant source files mentioned in the plan, then write code.`,
+      `When finished, commit and push your changes, then use the create_pull_request tool to open a PR. Do NOT use gh CLI.`
+    ];
+  }
+  if (isAutoMode && isPm) {
+    return [
+      `You are operating autonomously. Begin planning immediately.`,
+      `1. Explore the codebase to understand the architecture and relevant files`,
+      `2. Draft a clear implementation plan and save it with update_task`,
+      `3. Set story points (set_story_points), tags (set_task_tags), and title (set_task_title)`,
+      `4. When the plan and all required properties are set, call ExitPlanMode to transition to building`,
+      `Do NOT wait for team input \u2014 proceed autonomously.`
+    ];
+  }
+  if (isPm && context.isParentTask) {
+    return [
+      `You are the project manager for this task and its subtasks.`,
+      `Use list_subtasks to review the current state of child tasks.`,
+      `The task details are provided above. Wait for the team to provide instructions before taking action.`,
+      `When you finish planning, save the plan with update_task and end your turn. Your reply will be visible to the team in chat.`
+    ];
+  }
+  if (isPm) {
+    return [
+      `You are the project manager for this task.`,
+      `The task details are provided above. Wait for the team to ask questions or provide additional requirements before starting to plan.`,
+      `When you finish planning, save the plan with update_task and end your turn. Your reply summarizing the plan will be visible in chat. A separate task agent will execute the plan after review.`
+    ];
+  }
+  return [
+    `Begin executing the task plan above immediately.`,
+    `Your FIRST action should be reading the relevant source files mentioned in the plan, then writing code. Do NOT run install, build, lint, test, or dev server commands first \u2014 the environment is already set up.`,
+    `Work on the git branch "${context.githubBranch}". Stay on this branch for the entire task. Do not checkout or create other branches.`,
+    `Your replies are visible to the team in chat \u2014 briefly describe what you're doing when you begin meaningful implementation, and again when the PR is ready.`,
+    `When finished, commit your changes, then run \`git fetch origin ${context.githubBranch}\` and \`git push origin ${context.githubBranch}\` (use --force-with-lease if push fails). Then use the create_pull_request tool to open a PR. Do NOT use gh CLI or any other method to create PRs.`
+  ];
+}
+function buildFeedbackInstructions(context, isPm) {
+  const lastAgentIdx = findLastAgentMessageIndex2(context.chatHistory);
+  const newMessages = context.chatHistory.slice(lastAgentIdx + 1).filter((m) => m.role === "user");
+  if (isPm) {
+    return [
+      `You were relaunched with new feedback since your last run.`,
+      `You are the project manager for this task.`,
+      `
+New messages since your last run:`,
+      ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`),
+      `
+Review these messages and wait for the team to provide instructions before taking action.`
+    ];
+  }
+  const parts = [
+    `You have been relaunched to address feedback on your previous work.`,
+    `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
+    `Start by running \`git log --oneline -10\` and \`git diff HEAD~3 HEAD --stat\` to review what you already committed.`,
+    `
+New messages since your last run:`,
+    ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`),
+    `
+Address the requested changes directly. Do NOT re-investigate the codebase from scratch or write a new plan \u2014 go straight to implementing the feedback.`,
+    `Commit and push your updates.`
+  ];
+  if (context.githubPRUrl) {
+    parts.push(
+      `An existing PR is open at ${context.githubPRUrl} \u2014 push to the same branch to update it. Do NOT create a new PR.`
+    );
+  } else {
+    parts.push(
+      `When finished, use the create_pull_request tool to open a PR. Do NOT use gh CLI or any other method to create PRs.`
+    );
+  }
+  return parts;
+}
+function buildInstructions(mode, context, scenario, agentMode) {
+  const parts = [`
+## Instructions`];
+  const isPm = mode === "pm";
+  if (scenario === "fresh") {
+    parts.push(...buildFreshInstructions(isPm, agentMode === "auto", context, agentMode));
+    return parts;
+  }
+  if (scenario === "idle_relaunch") {
+    if (isPm && (agentMode === "building" || agentMode === "review")) {
+      parts.push(
+        `You were relaunched but no new instructions have been given since your last run.`,
+        `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
+        `Run \`git log --oneline -10\` to review what you already committed, then verify the current state is correct.`,
+        `Reply with a brief status update summarizing where things stand (visible in chat).`,
+        `Then wait for further instructions \u2014 do NOT redo work that was already completed.`
+      );
+      if (context.githubPRUrl) {
+        parts.push(`An existing PR is open at ${context.githubPRUrl}. Do not create a new PR.`);
+      }
+    } else if (isPm) {
+      parts.push(
+        `You were relaunched but no new instructions have been given since your last run.`,
+        `You are the project manager for this task.`,
+        `Wait for the team to provide instructions before taking action.`
+      );
+    } else {
+      parts.push(
+        `You were relaunched but no new instructions have been given since your last run.`,
+        `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
+        `Run \`git log --oneline -10\` to review what you already committed, then verify the current state is correct.`,
+        `Reply with a brief status update summarizing where things stand (visible in chat).`,
+        `Then wait for further instructions \u2014 do NOT redo work that was already completed.`
+      );
+      if (context.githubPRUrl) {
+        parts.push(`An existing PR is open at ${context.githubPRUrl}. Do not create a new PR.`);
+      }
+    }
+    return parts;
+  }
+  parts.push(...buildFeedbackInstructions(context, isPm));
+  return parts;
+}
+function buildInitialPrompt(mode, context, isAuto, agentMode) {
+  const isPackRunner = mode === "pm" && !!isAuto && !!context.isParentTask;
+  if (!isPackRunner) {
+    const sessionRelaunch = buildRelaunchWithSession(mode, context);
+    if (sessionRelaunch) return sessionRelaunch;
   }
-  return parts.join("\n");
+  const scenario = detectRelaunchScenario(context);
+  const body = buildTaskBody(context);
+  const instructions = isPackRunner ? buildPackRunnerInstructions(context, scenario) : buildInstructions(mode, context, scenario, agentMode);
+  return [...body, ...instructions].join("\n");
 }
 
 // src/tools/index.ts
@@ -1552,212 +1520,218 @@ import { z } from "zod";
 function isImageMimeType(mimeType) {
   return mimeType.startsWith("image/");
 }
+var cliEventFormatters = {
+  thinking: (e) => e.message ?? "",
+  tool_use: (e) => `${e.tool}: ${e.input?.slice(0, 1e3) ?? ""}`,
+  tool_result: (e) => `${e.tool} \u2192 ${e.output?.slice(0, 500) ?? ""}${e.isError ? " [ERROR]" : ""}`,
+  message: (e) => e.content ?? "",
+  error: (e) => `ERROR: ${e.message ?? ""}`,
+  completed: (e) => `Completed: ${e.summary ?? ""} (cost: $${e.costUsd ?? "?"}, duration: ${e.durationMs ?? "?"}ms)`,
+  setup_output: (e) => `[${e.stream ?? "stdout"}] ${e.data ?? ""}`,
+  start_command_output: (e) => `[${e.stream ?? "stdout"}] ${e.data ?? ""}`,
+  turn_end: (e) => `Turn complete (${e.toolCalls?.length ?? 0} tool calls)`
+};
 function formatCliEvent(e) {
-  switch (e.type) {
-    case "thinking":
-      return e.message ?? "";
-    case "tool_use": {
-      const tu = e;
-      return `${tu.tool}: ${tu.input?.slice(0, 1e3) ?? ""}`;
-    }
-    case "tool_result": {
-      const tr = e;
-      return `${tr.tool} \u2192 ${tr.output?.slice(0, 500) ?? ""}${tr.isError ? " [ERROR]" : ""}`;
-    }
-    case "message":
-      return e.content ?? "";
-    case "error":
-      return `ERROR: ${e.message ?? ""}`;
-    case "completed": {
-      const c = e;
-      return `Completed: ${c.summary ?? ""} (cost: $${c.costUsd ?? "?"}, duration: ${c.durationMs ?? "?"}ms)`;
-    }
-    case "setup_output":
-    case "start_command_output": {
-      const so = e;
-      return `[${so.stream ?? "stdout"}] ${so.data ?? ""}`;
-    }
-    case "turn_end": {
-      const te = e;
-      return `Turn complete (${te.toolCalls?.length ?? 0} tool calls)`;
-    }
-    default:
-      return JSON.stringify(e);
-  }
+  const formatter = cliEventFormatters[e.type];
+  return formatter ? formatter(e) : JSON.stringify(e);
 }
-function buildCommonTools(connection, config) {
-  return [
-    tool(
-      "read_task_chat",
-      "Read recent messages from a task chat. Omit task_id to read the current task's chat, or provide a child task ID to read a child's chat.",
-      {
-        limit: z.number().optional().describe("Number of recent messages to fetch (default 20)"),
-        task_id: z.string().optional().describe("Child task ID to read chat from. Omit to read the current task's chat.")
-      },
-      async ({ limit, task_id }) => {
-        try {
-          const messages = await connection.fetchChatMessages(limit, task_id);
-          return textResult(JSON.stringify(messages, null, 2));
-        } catch {
-          return textResult(
-            JSON.stringify({
-              note: "Could not fetch live chat. Chat history was provided in the initial context."
-            })
-          );
-        }
-      },
-      { annotations: { readOnlyHint: true } }
-    ),
-    tool(
-      "post_to_chat",
-      "Post a message to a task chat. Your normal replies already appear in chat \u2014 only use this for explicit out-of-band updates or posting to a child task's chat.",
-      {
-        message: z.string().describe("The message to post to the team"),
-        task_id: z.string().optional().describe("Child task ID to post to. Omit to post to the current task's chat.")
-      },
-      async ({ message, task_id }) => {
-        try {
-          if (task_id) {
-            await connection.postChildChatMessage(task_id, message);
-            return textResult(`Message posted to child task ${task_id} chat.`);
-          }
-          connection.postChatMessage(message);
-          return textResult("Message posted to task chat.");
-        } catch (error) {
-          return textResult(
-            `Failed to post message: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
-        }
+function buildReadTaskChatTool(connection) {
+  return tool(
+    "read_task_chat",
+    "Read recent messages from a task chat. Omit task_id to read the current task's chat, or provide a child task ID to read a child's chat.",
+    {
+      limit: z.number().optional().describe("Number of recent messages to fetch (default 20)"),
+      task_id: z.string().optional().describe("Child task ID to read chat from. Omit to read the current task's chat.")
+    },
+    async ({ limit, task_id }) => {
+      try {
+        const messages = await connection.fetchChatMessages(limit, task_id);
+        return textResult(JSON.stringify(messages, null, 2));
+      } catch {
+        return textResult(
+          JSON.stringify({
+            note: "Could not fetch live chat. Chat history was provided in the initial context."
+          })
+        );
       }
-    ),
-    tool(
-      "update_task_status",
-      "Update a task's status on the Kanban board. Omit task_id to update the current task, or provide a child task ID to update a child's status.",
-      {
-        status: z.enum(["InProgress", "ReviewPR", "ReviewDev", "Complete"]).describe("The new status for the task"),
-        task_id: z.string().optional().describe("Child task ID to update. Omit to update the current task.")
-      },
-      async ({ status, task_id }) => {
-        try {
-          if (task_id) {
-            await connection.updateChildStatus(task_id, status);
-            return textResult(`Child task ${task_id} status updated to ${status}.`);
-          }
-          connection.updateStatus(status);
-          return textResult(`Task status updated to ${status}.`);
-        } catch (error) {
-          return textResult(
-            `Failed to update status: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildPostToChatTool(connection) {
+  return tool(
+    "post_to_chat",
+    "Post a message to a task chat. Your normal replies already appear in chat \u2014 only use this for explicit out-of-band updates or posting to a child task's chat.",
+    {
+      message: z.string().describe("The message to post to the team"),
+      task_id: z.string().optional().describe("Child task ID to post to. Omit to post to the current task's chat.")
+    },
+    async ({ message, task_id }) => {
+      try {
+        if (task_id) {
+          await connection.postChildChatMessage(task_id, message);
+          return textResult(`Message posted to child task ${task_id} chat.`);
         }
+        connection.postChatMessage(message);
+        return textResult("Message posted to task chat.");
+      } catch (error) {
+        return textResult(
+          `Failed to post message: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
       }
-    ),
-    tool(
-      "get_task_plan",
-      "Re-read the latest task plan in case it was updated",
-      {},
-      async () => {
-        try {
-          const ctx = await connection.fetchTaskContext();
-          return textResult(ctx.plan ?? "No plan available.");
-        } catch {
-          return textResult(`Task ID: ${config.taskId} - could not fetch updated plan.`);
-        }
-      },
-      { annotations: { readOnlyHint: true } }
-    ),
-    tool(
-      "get_task",
-      "Look up a task by slug or ID to get its title, description, plan, and status",
-      {
-        slug_or_id: z.string().describe("The task slug (e.g. 'my-task') or CUID")
-      },
-      async ({ slug_or_id }) => {
-        try {
-          const task = await connection.fetchTask(slug_or_id);
-          return textResult(JSON.stringify(task, null, 2));
-        } catch (error) {
-          return textResult(
-            `Failed to get task: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
-        }
-      },
-      { annotations: { readOnlyHint: true } }
-    ),
-    tool(
-      "get_task_cli",
-      "Read CLI execution logs from a task. Returns agent reasoning, tool calls, setup output, and other execution events. Use 'source' to filter: 'agent' for agent reasoning/tool calls only, 'application' for setup/dev-server output only.",
-      {
-        task_id: z.string().optional().describe("Task ID or slug. Omit to read logs from the current task."),
-        source: z.enum(["agent", "application"]).optional().describe("Filter by log source. Omit for all logs."),
-        limit: z.number().optional().describe("Max number of log entries to return (default 50, max 500).")
-      },
-      async ({ task_id, source, limit }) => {
-        try {
-          const effectiveLimit = Math.min(limit ?? 50, 500);
-          const result = await connection.fetchCliHistory(task_id, effectiveLimit, source);
-          const formatted = result.map((entry) => {
-            const time = entry.time;
-            const e = entry.event;
-            return `[${time}] [${e.type}] ${formatCliEvent(e)}`;
-          }).join("\n");
-          return textResult(formatted || "No CLI logs found.");
-        } catch (error) {
-          return textResult(
-            `Failed to fetch CLI logs: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
-        }
-      },
-      { annotations: { readOnlyHint: true } }
-    ),
-    tool(
-      "list_task_files",
-      "List all files attached to this task with metadata (name, type, size) and download URLs",
-      {},
-      async () => {
-        try {
-          const files = await connection.fetchTaskFiles();
-          const metadata = files.map(({ content: _c, ...rest }) => rest);
-          const content = [
-            { type: "text", text: JSON.stringify(metadata, null, 2) }
-          ];
-          for (const file of files) {
-            if (file.content && file.contentEncoding === "base64" && isImageMimeType(file.mimeType)) {
-              content.push(imageBlock(file.content, file.mimeType));
-            }
-          }
-          return { content };
-        } catch {
-          return textResult("Failed to list task files.");
+    }
+  );
+}
+function buildUpdateTaskStatusTool(connection) {
+  return tool(
+    "update_task_status",
+    "Update a task's status on the Kanban board. Omit task_id to update the current task, or provide a child task ID to update a child's status.",
+    {
+      status: z.enum(["InProgress", "ReviewPR", "ReviewDev", "Complete"]).describe("The new status for the task"),
+      task_id: z.string().optional().describe("Child task ID to update. Omit to update the current task.")
+    },
+    async ({ status, task_id }) => {
+      try {
+        if (task_id) {
+          await connection.updateChildStatus(task_id, status);
+          return textResult(`Child task ${task_id} status updated to ${status}.`);
         }
-      },
-      { annotations: { readOnlyHint: true } }
-    ),
-    tool(
-      "get_task_file",
-      "Get a specific task file's content and download URL by file ID",
-      { fileId: z.string().describe("The file ID to retrieve") },
-      async ({ fileId }) => {
-        try {
-          const file = await connection.fetchTaskFile(fileId);
-          const { content: rawContent, ...metadata } = file;
-          const content = [
-            { type: "text", text: JSON.stringify(metadata, null, 2) }
-          ];
-          if (rawContent && file.contentEncoding === "base64" && isImageMimeType(file.mimeType)) {
-            content.push(imageBlock(rawContent, file.mimeType));
-          } else if (rawContent) {
-            content[0] = { type: "text", text: JSON.stringify(file, null, 2) };
+        connection.updateStatus(status);
+        return textResult(`Task status updated to ${status}.`);
+      } catch (error) {
+        return textResult(
+          `Failed to update status: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+  );
+}
+function buildGetTaskPlanTool(connection, config) {
+  return tool(
+    "get_task_plan",
+    "Re-read the latest task plan in case it was updated",
+    {},
+    async () => {
+      try {
+        const ctx = await connection.fetchTaskContext();
+        return textResult(ctx.plan ?? "No plan available.");
+      } catch {
+        return textResult(`Task ID: ${config.taskId} - could not fetch updated plan.`);
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildGetTaskTool(connection) {
+  return tool(
+    "get_task",
+    "Look up a task by slug or ID to get its title, description, plan, and status",
+    {
+      slug_or_id: z.string().describe("The task slug (e.g. 'my-task') or CUID")
+    },
+    async ({ slug_or_id }) => {
+      try {
+        const task = await connection.fetchTask(slug_or_id);
+        return textResult(JSON.stringify(task, null, 2));
+      } catch (error) {
+        return textResult(
+          `Failed to get task: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildGetTaskCliTool(connection) {
+  return tool(
+    "get_task_cli",
+    "Read CLI execution logs from a task. Returns agent reasoning, tool calls, setup output, and other execution events. Use 'source' to filter: 'agent' for agent reasoning/tool calls only, 'application' for setup/dev-server output only.",
+    {
+      task_id: z.string().optional().describe("Task ID or slug. Omit to read logs from the current task."),
+      source: z.enum(["agent", "application"]).optional().describe("Filter by log source. Omit for all logs."),
+      limit: z.number().optional().describe("Max number of log entries to return (default 50, max 500).")
+    },
+    async ({ task_id, source, limit }) => {
+      try {
+        const effectiveLimit = Math.min(limit ?? 50, 500);
+        const result = await connection.fetchCliHistory(task_id, effectiveLimit, source);
+        const formatted = result.map((entry) => {
+          const time = entry.time;
+          const e = entry.event;
+          return `[${time}] [${e.type}] ${formatCliEvent(e)}`;
+        }).join("\n");
+        return textResult(formatted || "No CLI logs found.");
+      } catch (error) {
+        return textResult(
+          `Failed to fetch CLI logs: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildListTaskFilesTool(connection) {
+  return tool(
+    "list_task_files",
+    "List all files attached to this task with metadata (name, type, size) and download URLs",
+    {},
+    async () => {
+      try {
+        const files = await connection.fetchTaskFiles();
+        const metadata = files.map(({ content: _c, ...rest }) => rest);
+        const content = [
+          { type: "text", text: JSON.stringify(metadata, null, 2) }
+        ];
+        for (const file of files) {
+          if (file.content && file.contentEncoding === "base64" && isImageMimeType(file.mimeType)) {
+            content.push(imageBlock(file.content, file.mimeType));
           }
-          return { content };
-        } catch (error) {
-          return textResult(
-            `Failed to get task file: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
         }
-      },
-      { annotations: { readOnlyHint: true } }
-    )
+        return { content };
+      } catch {
+        return textResult("Failed to list task files.");
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildGetTaskFileTool(connection) {
+  return tool(
+    "get_task_file",
+    "Get a specific task file's content and download URL by file ID",
+    { fileId: z.string().describe("The file ID to retrieve") },
+    async ({ fileId }) => {
+      try {
+        const file = await connection.fetchTaskFile(fileId);
+        const { content: rawContent, ...metadata } = file;
+        const content = [
+          { type: "text", text: JSON.stringify(metadata, null, 2) }
+        ];
+        if (rawContent && file.contentEncoding === "base64" && isImageMimeType(file.mimeType)) {
+          content.push(imageBlock(rawContent, file.mimeType));
+        } else if (rawContent) {
+          content[0] = { type: "text", text: JSON.stringify(file, null, 2) };
+        }
+        return { content };
+      } catch (error) {
+        return textResult(
+          `Failed to get task file: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildCommonTools(connection, config) {
+  return [
+    buildReadTaskChatTool(connection),
+    buildPostToChatTool(connection),
+    buildUpdateTaskStatusTool(connection),
+    buildGetTaskPlanTool(connection, config),
+    buildGetTaskTool(connection),
+    buildGetTaskCliTool(connection),
+    buildListTaskFilesTool(connection),
+    buildGetTaskFileTool(connection)
   ];
 }
 
@@ -1771,26 +1745,8 @@ function buildStoryPointDescription(storyPoints) {
   }
   return "Story point value (1=Common, 2=Magic, 3=Rare, 5=Unique)";
 }
-function buildPmTools(connection, storyPoints, options) {
-  const spDescription = buildStoryPointDescription(storyPoints);
-  const includePackTools = options?.includePackTools ?? false;
-  const tools = [
-    tool2(
-      "update_task",
-      "Save the finalized task plan and/or description",
-      {
-        plan: z2.string().optional().describe("The task plan in markdown"),
-        description: z2.string().optional().describe("Updated task description")
-      },
-      async ({ plan, description }) => {
-        try {
-          await Promise.resolve(connection.updateTaskFields({ plan, description }));
-          return textResult("Task updated successfully.");
-        } catch {
-          return textResult("Failed to update task.");
-        }
-      }
-    ),
+function buildSubtaskTools(connection, spDescription) {
+  return [
     tool2(
       "create_subtask",
       "Create a subtask under the current parent task. Use for breaking complex tasks into smaller pieces.",
@@ -1860,9 +1816,33 @@ function buildPmTools(connection, storyPoints, options) {
       { annotations: { readOnlyHint: true } }
     )
   ];
-  if (!includePackTools) return tools;
+}
+function buildPmTools(connection, storyPoints, options) {
+  const spDescription = buildStoryPointDescription(storyPoints);
+  const tools = [
+    tool2(
+      "update_task",
+      "Save the finalized task plan and/or description",
+      {
+        plan: z2.string().optional().describe("The task plan in markdown"),
+        description: z2.string().optional().describe("Updated task description")
+      },
+      async ({ plan, description }) => {
+        try {
+          await Promise.resolve(connection.updateTaskFields({ plan, description }));
+          return textResult("Task updated successfully.");
+        } catch {
+          return textResult("Failed to update task.");
+        }
+      }
+    ),
+    ...buildSubtaskTools(connection, spDescription)
+  ];
+  if (!options?.includePackTools) return tools;
+  return [...tools, ...buildPackTools(connection)];
+}
+function buildPackTools(connection) {
   return [
-    ...tools,
     tool2(
       "start_child_cloud_build",
       "Start a cloud build for a child task. The child must be in Open status with story points and an agent assigned.",
@@ -1952,111 +1932,116 @@ function buildTaskTools(connection) {
 // src/tools/discovery-tools.ts
 import { tool as tool4 } from "@anthropic-ai/claude-agent-sdk";
 import { z as z4 } from "zod";
-function buildDiscoveryTools(connection, context) {
-  const spDescription = buildStoryPointDescription(context?.storyPoints);
+function buildIconTools(connection) {
   return [
     tool4(
-      "set_story_points",
-      "Set the story point estimate for this task. Use after understanding the scope of the work.",
-      { value: z4.number().describe(spDescription) },
-      async ({ value }) => {
+      "list_icons",
+      "List available icons (default library + user-created). Returns icon IDs, names, and whether they're defaults. Call this FIRST before set_task_icon to check for existing matches.",
+      {},
+      async () => {
         try {
-          connection.updateTaskProperties({ storyPointValue: value });
-          return textResult(`Story points set to ${value}`);
+          const icons = await connection.listIcons();
+          return textResult(JSON.stringify(icons, null, 2));
         } catch (error) {
           return textResult(
-            `Failed to set story points: ${error instanceof Error ? error.message : "Unknown error"}`
+            `Failed to list icons: ${error instanceof Error ? error.message : "Unknown error"}`
           );
         }
-      }
+      },
+      { annotations: { readOnlyHint: true } }
     ),
     tool4(
-      "set_task_tags",
-      "Assign tags to this task from the project's available tags. Use the tag IDs from the project tags list.",
+      "set_task_icon",
+      "Assign an existing icon to this task by its ID. Use list_icons first to find a matching icon.",
       {
-        tagIds: z4.array(z4.string()).describe("Array of tag IDs to assign")
+        iconId: z4.string().describe("The icon ID to assign")
       },
-      async ({ tagIds }) => {
+      async ({ iconId }) => {
         try {
-          connection.updateTaskProperties({ tagIds });
-          return textResult(`Tags assigned: ${tagIds.length} tag(s)`);
+          await Promise.resolve(connection.updateTaskProperties({ iconId }));
+          return textResult("Icon assigned to task.");
         } catch (error) {
           return textResult(
-            `Failed to set tags: ${error instanceof Error ? error.message : "Unknown error"}`
+            `Failed to set icon: ${error instanceof Error ? error.message : "Unknown error"}`
           );
         }
       }
     ),
     tool4(
-      "set_task_title",
-      "Update the task title to better reflect the planned work.",
+      "generate_task_icon",
+      "Generate a new SVG icon using AI and assign it to this task. Only use if no existing icon from list_icons is a good fit. Provide a concise visual description.",
       {
-        title: z4.string().describe("The new task title")
+        prompt: z4.string().describe(
+          "Description of the icon to generate (e.g. 'minimal flat gear and wrench icon')"
+        ),
+        aspectRatio: z4.enum(["auto", "portrait", "landscape", "square"]).optional().describe("Icon aspect ratio, defaults to square")
       },
-      async ({ title }) => {
+      async ({ prompt, aspectRatio }) => {
         try {
-          connection.updateTaskProperties({ title });
-          return textResult(`Task title updated to: ${title}`);
+          const result = await connection.generateTaskIcon(prompt, aspectRatio ?? "square");
+          return textResult(`Icon generated and assigned: ${result.iconId}`);
         } catch (error) {
           return textResult(
-            `Failed to update title: ${error instanceof Error ? error.message : "Unknown error"}`
+            `Failed to generate icon: ${error instanceof Error ? error.message : "Unknown error"}`
           );
         }
       }
-    ),
+    )
+  ];
+}
+function buildDiscoveryTools(connection, context) {
+  const spDescription = buildStoryPointDescription(context?.storyPoints);
+  return [
     tool4(
-      "list_icons",
-      "List available icons (default library + user-created). Returns icon IDs, names, and whether they're defaults. Call this FIRST before set_task_icon to check for existing matches.",
-      {},
-      async () => {
+      "set_story_points",
+      "Set the story point estimate for this task. Use after understanding the scope of the work.",
+      { value: z4.number().describe(spDescription) },
+      async ({ value }) => {
         try {
-          const icons = await connection.listIcons();
-          return textResult(JSON.stringify(icons, null, 2));
+          await Promise.resolve(connection.updateTaskProperties({ storyPointValue: value }));
+          return textResult(`Story points set to ${value}`);
         } catch (error) {
           return textResult(
-            `Failed to list icons: ${error instanceof Error ? error.message : "Unknown error"}`
+            `Failed to set story points: ${error instanceof Error ? error.message : "Unknown error"}`
           );
         }
-      },
-      { annotations: { readOnlyHint: true } }
+      }
     ),
     tool4(
-      "set_task_icon",
-      "Assign an existing icon to this task by its ID. Use list_icons first to find a matching icon.",
+      "set_task_tags",
+      "Assign tags to this task from the project's available tags. Use the tag IDs from the project tags list.",
       {
-        iconId: z4.string().describe("The icon ID to assign")
+        tagIds: z4.array(z4.string()).describe("Array of tag IDs to assign")
       },
-      async ({ iconId }) => {
+      async ({ tagIds }) => {
         try {
-          connection.updateTaskProperties({ iconId });
-          return textResult("Icon assigned to task.");
+          await Promise.resolve(connection.updateTaskProperties({ tagIds }));
+          return textResult(`Tags assigned: ${tagIds.length} tag(s)`);
         } catch (error) {
           return textResult(
-            `Failed to set icon: ${error instanceof Error ? error.message : "Unknown error"}`
+            `Failed to set tags: ${error instanceof Error ? error.message : "Unknown error"}`
           );
         }
       }
     ),
     tool4(
-      "generate_task_icon",
-      "Generate a new SVG icon using AI and assign it to this task. Only use if no existing icon from list_icons is a good fit. Provide a concise visual description.",
+      "set_task_title",
+      "Update the task title to better reflect the planned work.",
       {
-        prompt: z4.string().describe(
-          "Description of the icon to generate (e.g. 'minimal flat gear and wrench icon')"
-        ),
-        aspectRatio: z4.enum(["auto", "portrait", "landscape", "square"]).optional().describe("Icon aspect ratio, defaults to square")
+        title: z4.string().describe("The new task title")
       },
-      async ({ prompt, aspectRatio }) => {
+      async ({ title }) => {
         try {
-          const result = await connection.generateTaskIcon(prompt, aspectRatio ?? "square");
-          return textResult(`Icon generated and assigned: ${result.iconId}`);
+          await Promise.resolve(connection.updateTaskProperties({ title }));
+          return textResult(`Task title updated to: ${title}`);
         } catch (error) {
           return textResult(
-            `Failed to generate icon: ${error instanceof Error ? error.message : "Unknown error"}`
+            `Failed to update title: ${error instanceof Error ? error.message : "Unknown error"}`
           );
         }
       }
-    )
+    ),
+    ...buildIconTools(connection)
   ];
 }
 
@@ -2067,37 +2052,28 @@ function textResult(text) {
 function imageBlock(data, mimeType) {
   return { type: "image", data, mimeType };
 }
-function createConveyorMcpServer(connection, config, context) {
-  const commonTools = buildCommonTools(connection, config);
-  const agentMode = context?.agentMode;
-  let modeTools;
+function getModeTools(agentMode, connection, config, context) {
   switch (agentMode) {
     case "building":
-      modeTools = context?.isParentTask ? [
+      return context?.isParentTask ? [
         ...buildTaskTools(connection),
         ...buildPmTools(connection, context?.storyPoints, { includePackTools: true })
       ] : buildTaskTools(connection);
-      break;
     case "review":
-      modeTools = buildPmTools(connection, context?.storyPoints, {
-        includePackTools: !!context?.isParentTask
-      });
-      break;
     case "auto":
-      modeTools = buildPmTools(connection, context?.storyPoints, {
-        includePackTools: !!context?.isParentTask
-      });
-      break;
     case "discovery":
     case "help":
-      modeTools = buildPmTools(connection, context?.storyPoints, {
+      return buildPmTools(connection, context?.storyPoints, {
         includePackTools: !!context?.isParentTask
       });
-      break;
     default:
-      modeTools = config.mode === "pm" ? buildPmTools(connection, context?.storyPoints, { includePackTools: false }) : buildTaskTools(connection);
-      break;
+      return config.mode === "pm" ? buildPmTools(connection, context?.storyPoints, { includePackTools: false }) : buildTaskTools(connection);
   }
+}
+function createConveyorMcpServer(connection, config, context) {
+  const commonTools = buildCommonTools(connection, config);
+  const agentMode = context?.agentMode ?? void 0;
+  const modeTools = getModeTools(agentMode, connection, config, context);
   const discoveryTools = agentMode === "discovery" || agentMode === "auto" ? buildDiscoveryTools(connection, context) : [];
   return createSdkMcpServer({
     name: "conveyor",
@@ -2105,16 +2081,17 @@ function createConveyorMcpServer(connection, config, context) {
   });
 }
 
-// src/execution/query-executor.ts
-var API_ERROR_PATTERN2 = /API Error: [45]\d\d/;
-var IMAGE_ERROR_PATTERN = /Could not process image/i;
-var RETRY_DELAYS_MS = [6e4, 12e4, 18e4, 3e5];
+// src/execution/tool-access.ts
+import { randomUUID } from "crypto";
 var PM_PLAN_FILE_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "MultiEdit"]);
 var DESTRUCTIVE_CMD_PATTERN = /git\s+push\s+--force(?!\s*-with-lease)|git\s+reset\s+--hard|rm\s+-rf\s+\//;
+function isPlanFile(input) {
+  const filePath = String(input.file_path ?? input.path ?? "");
+  return filePath.includes(".claude/plans/");
+}
 function handleDiscoveryToolAccess(toolName, input) {
   if (PM_PLAN_FILE_TOOLS.has(toolName)) {
-    const filePath = String(input.file_path ?? input.path ?? "");
-    if (filePath.includes(".claude/plans/")) {
+    if (isPlanFile(input)) {
       return { behavior: "allow", updatedInput: input };
     }
     return {
@@ -2141,8 +2118,7 @@ function handleReviewToolAccess(toolName, input, isParentTask) {
     return handleBuildingToolAccess(toolName, input);
   }
   if (PM_PLAN_FILE_TOOLS.has(toolName)) {
-    const filePath = String(input.file_path ?? input.path ?? "");
-    if (filePath.includes(".claude/plans/")) {
+    if (isPlanFile(input)) {
       return { behavior: "allow", updatedInput: input };
     }
     return {
@@ -2163,8 +2139,7 @@ function handleAutoToolAccess(toolName, input, hasExitedPlanMode, isParentTask)
     return isParentTask ? handleReviewToolAccess(toolName, input, true) : handleBuildingToolAccess(toolName, input);
   }
   if (PM_PLAN_FILE_TOOLS.has(toolName)) {
-    const filePath = String(input.file_path ?? input.path ?? "");
-    if (filePath.includes(".claude/plans/")) {
+    if (isPlanFile(input)) {
       return { behavior: "allow", updatedInput: input };
     }
     return {
@@ -2174,65 +2149,77 @@ function handleAutoToolAccess(toolName, input, hasExitedPlanMode, isParentTask)
   }
   return { behavior: "allow", updatedInput: input };
 }
-function buildCanUseTool(host) {
+async function handleExitPlanMode(host, input) {
+  try {
+    const taskProps = await host.connection.getTaskProperties();
+    const missingProps = [];
+    if (!taskProps.plan?.trim()) missingProps.push("plan (save via update_task)");
+    if (!taskProps.storyPointId) missingProps.push("story points (use set_story_points)");
+    if (!taskProps.title || taskProps.title === "Untitled")
+      missingProps.push("title (use set_task_title)");
+    if (missingProps.length > 0) {
+      return {
+        behavior: "deny",
+        message: [
+          "Cannot exit plan mode yet. Required task properties are missing:",
+          ...missingProps.map((p) => `- ${p}`),
+          "",
+          "Fill these in using MCP tools, then try ExitPlanMode again."
+        ].join("\n")
+      };
+    }
+    await host.connection.triggerIdentification();
+    host.hasExitedPlanMode = true;
+    if (host.agentMode === "discovery") {
+      host.connection.postChatMessage(
+        "Task identified and moved to Open. Switch to Build mode when ready to start implementation."
+      );
+      return { behavior: "allow", updatedInput: input };
+    }
+    const newMode = host.isParentTask ? "review" : "building";
+    host.pendingModeRestart = true;
+    if (host.onModeTransition) {
+      host.onModeTransition(newMode);
+    }
+    return { behavior: "allow", updatedInput: input };
+  } catch (err) {
+    return {
+      behavior: "deny",
+      message: `Identification failed: ${err instanceof Error ? err.message : String(err)}. Fix the issue and try again.`
+    };
+  }
+}
+async function handleAskUserQuestion(host, input) {
   const QUESTION_TIMEOUT_MS = 5 * 60 * 1e3;
+  const questions = input.questions;
+  const requestId = randomUUID();
+  host.connection.emitStatus("waiting_for_input");
+  host.connection.sendEvent({
+    type: "tool_use",
+    tool: "AskUserQuestion",
+    input: JSON.stringify(input)
+  });
+  const answerPromise = host.connection.askUserQuestion(requestId, questions);
+  const timeoutPromise = new Promise((resolve2) => {
+    setTimeout(() => resolve2(null), QUESTION_TIMEOUT_MS);
+  });
+  const answers = await Promise.race([answerPromise, timeoutPromise]);
+  host.connection.emitStatus("running");
+  if (!answers) {
+    return {
+      behavior: "deny",
+      message: "User did not respond to clarifying questions in time. Proceed with your best judgment."
+    };
+  }
+  return { behavior: "allow", updatedInput: { questions: input.questions, answers } };
+}
+function buildCanUseTool(host) {
   return async (toolName, input) => {
-    if (toolName === "ExitPlanMode" && host.agentMode === "auto" && !host.hasExitedPlanMode) {
-      try {
-        const taskProps = await host.connection.getTaskProperties();
-        const missingProps = [];
-        if (!taskProps.plan?.trim()) missingProps.push("plan (save via update_task)");
-        if (!taskProps.storyPointId) missingProps.push("story points (use set_story_points)");
-        if (!taskProps.title || taskProps.title === "Untitled")
-          missingProps.push("title (use set_task_title)");
-        if (missingProps.length > 0) {
-          return {
-            behavior: "deny",
-            message: [
-              "Cannot exit plan mode yet. Required task properties are missing:",
-              ...missingProps.map((p) => `- ${p}`),
-              "",
-              "Fill these in using MCP tools, then try ExitPlanMode again."
-            ].join("\n")
-          };
-        }
-        await host.connection.triggerIdentification();
-        host.hasExitedPlanMode = true;
-        const newMode = host.isParentTask ? "review" : "building";
-        host.pendingModeRestart = true;
-        if (host.onModeTransition) {
-          host.onModeTransition(newMode);
-        }
-        return { behavior: "allow", updatedInput: input };
-      } catch (err) {
-        return {
-          behavior: "deny",
-          message: `Identification failed: ${err instanceof Error ? err.message : String(err)}. Fix the issue and try again.`
-        };
-      }
+    if (toolName === "ExitPlanMode" && (host.agentMode === "auto" || host.agentMode === "discovery") && !host.hasExitedPlanMode) {
+      return await handleExitPlanMode(host, input);
     }
     if (toolName === "AskUserQuestion") {
-      const questions = input.questions;
-      const requestId = randomUUID();
-      host.connection.emitStatus("waiting_for_input");
-      host.connection.sendEvent({
-        type: "tool_use",
-        tool: "AskUserQuestion",
-        input: JSON.stringify(input)
-      });
-      const answerPromise = host.connection.askUserQuestion(requestId, questions);
-      const timeoutPromise = new Promise((resolve2) => {
-        setTimeout(() => resolve2(null), QUESTION_TIMEOUT_MS);
-      });
-      const answers = await Promise.race([answerPromise, timeoutPromise]);
-      host.connection.emitStatus("running");
-      if (!answers) {
-        return {
-          behavior: "deny",
-          message: "User did not respond to clarifying questions in time. Proceed with your best judgment."
-        };
-      }
-      return { behavior: "allow", updatedInput: { questions: input.questions, answers } };
+      return await handleAskUserQuestion(host, input);
     }
     switch (host.agentMode) {
       case "discovery":
@@ -2248,24 +2235,13 @@ function buildCanUseTool(host) {
     }
   };
 }
-function buildQueryOptions(host, context) {
-  const settings = context.agentSettings ?? host.config.agentSettings ?? {};
-  const mode = host.agentMode;
-  const isActiveMode = mode === "building" || mode === "review" || mode === "auto" && host.hasExitedPlanMode;
-  const shouldSandbox = host.config.mode === "pm" && isActiveMode && context.useSandbox !== false;
-  const systemPromptText = buildSystemPrompt(
-    host.config.mode,
-    context,
-    host.config,
-    host.setupLog,
-    mode
-  );
-  const conveyorMcp = createConveyorMcpServer(host.connection, host.config, context);
-  const isReadOnlyMode = mode === "discovery" || mode === "help" || mode === "auto" && !host.hasExitedPlanMode;
-  const modeDisallowedTools = isReadOnlyMode ? ["TodoWrite", "TodoRead", "NotebookEdit"] : [];
-  const disallowedTools = [...settings.disallowedTools ?? [], ...modeDisallowedTools];
-  const settingSources = settings.settingSources ?? ["user", "project"];
-  const hooks = {
+
+// src/execution/query-executor.ts
+var API_ERROR_PATTERN2 = /API Error: [45]\d\d/;
+var IMAGE_ERROR_PATTERN2 = /Could not process image/i;
+var RETRY_DELAYS_MS = [6e4, 12e4, 18e4, 3e5];
+function buildHooks(host) {
+  return {
     PostToolUse: [
       {
         hooks: [
@@ -2279,13 +2255,55 @@ function buildQueryOptions(host, context) {
                 isError: false
               });
             }
-            return { continue: true };
+            return await Promise.resolve({ continue: true });
           }
         ],
         timeout: 5
       }
     ]
   };
+}
+function buildSandboxConfig(host) {
+  const apiHostname = new URL(host.config.conveyorApiUrl).hostname;
+  return {
+    enabled: true,
+    autoAllowBashIfSandboxed: true,
+    allowUnsandboxedCommands: false,
+    filesystem: {
+      allowWrite: [`${host.config.workspaceDir}/**`],
+      denyRead: ["/etc/shadow", "/etc/passwd", "**/.env", "**/.env.*"],
+      denyWrite: ["**/.env", "**/.env.*", "**/node_modules/**"]
+    },
+    network: {
+      allowedDomains: [apiHostname, "api.anthropic.com"],
+      allowManagedDomainsOnly: true,
+      allowLocalBinding: true
+    }
+  };
+}
+function isReadOnlyMode(mode, hasExitedPlanMode) {
+  return mode === "discovery" || mode === "help" || mode === "auto" && !hasExitedPlanMode;
+}
+function buildDisallowedTools(settings, mode, hasExitedPlanMode) {
+  const modeDisallowed = isReadOnlyMode(mode, hasExitedPlanMode) ? ["TodoWrite", "TodoRead", "NotebookEdit"] : [];
+  const configured = settings.disallowedTools ?? [];
+  const combined = [...configured, ...modeDisallowed];
+  return combined.length > 0 ? combined : void 0;
+}
+function buildQueryOptions(host, context) {
+  const settings = context.agentSettings ?? host.config.agentSettings ?? {};
+  const mode = host.agentMode;
+  const isCloud = host.config.mode === "pm";
+  const isReadOnly = isReadOnlyMode(mode, host.hasExitedPlanMode);
+  const needsCanUseTool = isCloud && isReadOnly;
+  const systemPromptText = buildSystemPrompt(
+    host.config.mode,
+    context,
+    host.config,
+    host.setupLog,
+    mode
+  );
+  const settingSources = settings.settingSources ?? ["user", "project"];
   const baseOptions = {
     model: context.model || host.config.model,
     systemPrompt: {
@@ -2295,37 +2313,22 @@ function buildQueryOptions(host, context) {
     },
     settingSources,
     cwd: host.config.workspaceDir,
-    permissionMode: shouldSandbox ? "acceptEdits" : "bypassPermissions",
-    allowDangerouslySkipPermissions: !shouldSandbox,
+    permissionMode: needsCanUseTool ? "acceptEdits" : "bypassPermissions",
+    allowDangerouslySkipPermissions: !needsCanUseTool,
     canUseTool: buildCanUseTool(host),
     tools: { type: "preset", preset: "claude_code" },
-    mcpServers: { conveyor: conveyorMcp },
-    hooks,
+    mcpServers: { conveyor: createConveyorMcpServer(host.connection, host.config, context) },
+    hooks: buildHooks(host),
     maxTurns: settings.maxTurns,
     effort: settings.effort,
     thinking: settings.thinking,
     betas: settings.betas,
     maxBudgetUsd: settings.maxBudgetUsd ?? 50,
-    disallowedTools: disallowedTools.length > 0 ? disallowedTools : void 0,
+    disallowedTools: buildDisallowedTools(settings, mode, host.hasExitedPlanMode),
     enableFileCheckpointing: settings.enableFileCheckpointing
   };
-  if (shouldSandbox) {
-    const apiHostname = new URL(host.config.conveyorApiUrl).hostname;
-    baseOptions.sandbox = {
-      enabled: true,
-      autoAllowBashIfSandboxed: true,
-      allowUnsandboxedCommands: false,
-      filesystem: {
-        allowWrite: [`${host.config.workspaceDir}/**`],
-        denyRead: ["/etc/shadow", "/etc/passwd", "**/.env", "**/.env.*"],
-        denyWrite: ["**/.env", "**/.env.*", "**/node_modules/**"]
-      },
-      network: {
-        allowedDomains: [apiHostname, "api.anthropic.com"],
-        allowManagedDomainsOnly: true,
-        allowLocalBinding: true
-      }
-    };
+  if (needsCanUseTool) {
+    baseOptions.sandbox = buildSandboxConfig(host);
   }
   return baseOptions;
 }
@@ -2350,34 +2353,47 @@ function buildMultimodalPrompt(textPrompt, context, skipImages = false) {
       source: {
         type: "base64",
         media_type: file.mimeType,
-        data: file.content
+        data: file.content ?? ""
       }
     });
-    blocks.push({
-      type: "text",
-      text: `[Attached image: ${file.fileName} (${file.mimeType})]`
-    });
+    blocks.push({ type: "text", text: `[Attached image: ${file.fileName} (${file.mimeType})]` });
   }
   for (const file of chatImages) {
     blocks.push({
       type: "image",
-      source: {
-        type: "base64",
-        media_type: file.mimeType,
-        data: file.content
-      }
-    });
-    blocks.push({
-      type: "text",
-      text: `[Chat image: ${file.fileName} (${file.mimeType})]`
+      source: { type: "base64", media_type: file.mimeType, data: file.content }
     });
+    blocks.push({ type: "text", text: `[Chat image: ${file.fileName} (${file.mimeType})]` });
   }
   return blocks;
 }
+function buildFollowUpPrompt(host, context, followUpContent) {
+  const isPmMode = host.config.mode === "pm";
+  const followUpText = typeof followUpContent === "string" ? followUpContent : followUpContent.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+  const followUpImages = typeof followUpContent === "string" ? [] : followUpContent.filter(
+    (b) => b.type === "image"
+  );
+  const textPrompt = isPmMode ? `${buildInitialPrompt(host.config.mode, context, host.config.isAuto, host.agentMode)}
+
+---
+
+The team says:
+${followUpText}` : followUpText;
+  if (isPmMode) {
+    const prompt = buildMultimodalPrompt(textPrompt, context);
+    if (followUpImages.length > 0 && Array.isArray(prompt)) {
+      prompt.push(...followUpImages);
+    }
+    return prompt;
+  }
+  if (followUpImages.length > 0) {
+    return [{ type: "text", text: textPrompt }, ...followUpImages];
+  }
+  return textPrompt;
+}
 async function runSdkQuery(host, context, followUpContent) {
   if (host.isStopped()) return;
   const mode = host.agentMode;
-  const isPmMode = host.config.mode === "pm";
   const isDiscoveryLike = mode === "discovery" || mode === "help";
   if (isDiscoveryLike) {
     host.snapshotPlanFiles();
@@ -2385,27 +2401,7 @@ async function runSdkQuery(host, context, followUpContent) {
   const options = buildQueryOptions(host, context);
   const resume = context.claudeSessionId ?? void 0;
   if (followUpContent) {
-    const followUpText = typeof followUpContent === "string" ? followUpContent : followUpContent.filter((b) => b.type === "text").map((b) => b.text).join("\n");
-    const followUpImages = typeof followUpContent === "string" ? [] : followUpContent.filter(
-      (b) => b.type === "image"
-    );
-    const textPrompt = isPmMode ? `${buildInitialPrompt(host.config.mode, context, host.config.isAuto, mode)}
-
----
-
-The team says:
-${followUpText}` : followUpText;
-    let prompt;
-    if (isPmMode) {
-      prompt = buildMultimodalPrompt(textPrompt, context);
-      if (followUpImages.length > 0 && Array.isArray(prompt)) {
-        prompt.push(...followUpImages);
-      }
-    } else if (followUpImages.length > 0) {
-      prompt = [{ type: "text", text: textPrompt }, ...followUpImages];
-    } else {
-      prompt = textPrompt;
-    }
+    const prompt = buildFollowUpPrompt(host, context, followUpContent);
     const agentQuery = query({
       prompt: typeof prompt === "string" ? prompt : host.createInputStream(prompt),
       options: { ...options, resume }
@@ -2426,55 +2422,105 @@ ${followUpText}` : followUpText;
     host.syncPlanFile();
   }
 }
+function buildRetryQuery(host, context, options, lastErrorWasImage) {
+  if (lastErrorWasImage) {
+    host.connection.postChatMessage(
+      "An attached image could not be processed. Retrying without images..."
+    );
+  }
+  const retryPrompt = buildMultimodalPrompt(
+    buildInitialPrompt(host.config.mode, context, host.config.isAuto, host.agentMode),
+    context,
+    lastErrorWasImage
+  );
+  return query({
+    prompt: host.createInputStream(retryPrompt),
+    options: { ...options, resume: void 0 }
+  });
+}
+function handleStaleSession(context, host, options) {
+  context.claudeSessionId = null;
+  host.connection.storeSessionId("");
+  const freshPrompt = buildMultimodalPrompt(
+    buildInitialPrompt(host.config.mode, context, host.config.isAuto, host.agentMode),
+    context
+  );
+  const freshQuery = query({
+    prompt: host.createInputStream(freshPrompt),
+    options: { ...options, resume: void 0 }
+  });
+  return runWithRetry(freshQuery, context, host, options);
+}
+async function waitForRetryDelay(host, delayMs) {
+  await new Promise((resolve2) => {
+    const timer = setTimeout(resolve2, delayMs);
+    const checkStopped = setInterval(() => {
+      if (host.isStopped()) {
+        clearTimeout(timer);
+        clearInterval(checkStopped);
+        resolve2();
+      }
+    }, 1e3);
+    setTimeout(() => clearInterval(checkStopped), delayMs + 100);
+  });
+}
+function isStaleOrExitedSession(error, context) {
+  if (!(error instanceof Error)) return false;
+  if (error.message.includes("No conversation found with session ID")) return true;
+  return !!context.claudeSessionId && error.message.includes("process exited");
+}
+function isRetriableError(error) {
+  if (!(error instanceof Error)) return false;
+  return API_ERROR_PATTERN2.test(error.message) || IMAGE_ERROR_PATTERN2.test(error.message);
+}
+function classifyImageError(error) {
+  return error instanceof Error && IMAGE_ERROR_PATTERN2.test(error.message);
+}
+async function emitRetryStatus(host, attempt, delayMs) {
+  const delayMin = Math.round(delayMs / 6e4);
+  host.connection.postChatMessage(
+    `API error encountered. Retrying in ${delayMin} minute${delayMin > 1 ? "s" : ""}... (attempt ${attempt + 1}/${RETRY_DELAYS_MS.length})`
+  );
+  host.connection.sendEvent({
+    type: "error",
+    message: `API error, retrying in ${delayMin}m (${attempt + 1}/${RETRY_DELAYS_MS.length})`
+  });
+  host.connection.emitStatus("waiting_for_input");
+  await host.callbacks.onStatusChange("waiting_for_input");
+  await waitForRetryDelay(host, delayMs);
+  host.connection.emitStatus("running");
+  await host.callbacks.onStatusChange("running");
+}
 async function runWithRetry(initialQuery, context, host, options) {
   let lastErrorWasImage = false;
   for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt++) {
     if (host.isStopped()) return;
-    const agentQuery = attempt === 0 ? initialQuery : (() => {
-      if (lastErrorWasImage) {
-        host.connection.postChatMessage(
-          "An attached image could not be processed. Retrying without images..."
-        );
-      }
-      const retryPrompt = buildMultimodalPrompt(
-        buildInitialPrompt(host.config.mode, context, host.config.isAuto, host.agentMode),
-        context,
-        lastErrorWasImage
-      );
-      return query({
-        prompt: host.createInputStream(retryPrompt),
-        options: { ...options, resume: void 0 }
-      });
-    })();
+    const agentQuery = attempt === 0 ? initialQuery : buildRetryQuery(host, context, options, lastErrorWasImage);
     try {
-      const { retriable, resultSummary, modeRestart } = await processEvents(
+      const { retriable, resultSummary, modeRestart, rateLimitResetsAt } = await processEvents(
         agentQuery,
         context,
         host
       );
-      if (modeRestart) return;
-      if (!retriable || host.isStopped()) return;
-      lastErrorWasImage = IMAGE_ERROR_PATTERN.test(resultSummary ?? "");
+      if (modeRestart || host.isStopped()) return;
+      if (rateLimitResetsAt) {
+        const resetMs = new Date(rateLimitResetsAt).getTime() - Date.now();
+        if (resetMs > 5 * 6e4) {
+          host.connection.emitRateLimitPause(rateLimitResetsAt);
+          host.connection.postChatMessage(
+            `Rate limited. The task will be automatically re-queued and resume after ${new Date(rateLimitResetsAt).toLocaleString()}.`
+          );
+          return;
+        }
+      }
+      if (!retriable) return;
+      lastErrorWasImage = IMAGE_ERROR_PATTERN2.test(resultSummary ?? "");
     } catch (error) {
-      const isStaleSession = error instanceof Error && error.message.includes("No conversation found with session ID");
-      const isResumeProcessExit = !isStaleSession && !!context.claudeSessionId && error instanceof Error && error.message.includes("process exited");
-      if ((isStaleSession || isResumeProcessExit) && context.claudeSessionId) {
-        context.claudeSessionId = null;
-        host.connection.storeSessionId("");
-        const freshPrompt = buildMultimodalPrompt(
-          buildInitialPrompt(host.config.mode, context, host.config.isAuto, host.agentMode),
-          context
-        );
-        const freshQuery = query({
-          prompt: host.createInputStream(freshPrompt),
-          options: { ...options, resume: void 0 }
-        });
-        return runWithRetry(freshQuery, context, host, options);
+      if (isStaleOrExitedSession(error, context) && context.claudeSessionId) {
+        return handleStaleSession(context, host, options);
       }
-      const isApiError = error instanceof Error && API_ERROR_PATTERN2.test(error.message);
-      const isImageError = error instanceof Error && IMAGE_ERROR_PATTERN.test(error.message);
-      if (isImageError) lastErrorWasImage = true;
-      if (!isApiError && !isImageError) throw error;
+      if (classifyImageError(error)) lastErrorWasImage = true;
+      if (!isRetriableError(error)) throw error;
     }
     if (attempt >= RETRY_DELAYS_MS.length) {
       host.connection.postChatMessage(
@@ -2482,30 +2528,7 @@ async function runWithRetry(initialQuery, context, host, options) {
       );
       return;
     }
-    const delayMs = RETRY_DELAYS_MS[attempt];
-    const delayMin = Math.round(delayMs / 6e4);
-    host.connection.postChatMessage(
-      `API error encountered. Retrying in ${delayMin} minute${delayMin > 1 ? "s" : ""}... (attempt ${attempt + 1}/${RETRY_DELAYS_MS.length})`
-    );
-    host.connection.sendEvent({
-      type: "error",
-      message: `API error, retrying in ${delayMin}m (${attempt + 1}/${RETRY_DELAYS_MS.length})`
-    });
-    host.connection.emitStatus("waiting_for_input");
-    await host.callbacks.onStatusChange("waiting_for_input");
-    await new Promise((resolve2) => {
-      const timer = setTimeout(resolve2, delayMs);
-      const checkStopped = setInterval(() => {
-        if (host.isStopped()) {
-          clearTimeout(timer);
-          clearInterval(checkStopped);
-          resolve2();
-        }
-      }, 1e3);
-      setTimeout(() => clearInterval(checkStopped), delayMs + 100);
-    });
-    host.connection.emitStatus("running");
-    await host.callbacks.onStatusChange("running");
+    await emitRetryStatus(host, attempt, RETRY_DELAYS_MS[attempt]);
   }
 }
 
@@ -2582,19 +2605,7 @@ var PlanSync = class {
       }
     }
   }
-  syncPlanFile() {
-    if (this.lockedPlanFile) {
-      try {
-        const content = readFileSync(this.lockedPlanFile, "utf-8").trim();
-        if (content) {
-          this.connection.updateTaskFields({ plan: content });
-          const fileName = this.lockedPlanFile.split("/").pop();
-          this.connection.postChatMessage(`Synced local plan file (${fileName}) to the task plan.`);
-        }
-      } catch {
-      }
-      return;
-    }
+  findNewestPlanFile() {
     let newest = null;
     for (const plansDir of this.getPlanDirs()) {
       let files;
@@ -2617,24 +2628,240 @@ var PlanSync = class {
         }
       }
     }
+    return newest;
+  }
+  syncPlanFile() {
+    if (this.lockedPlanFile) {
+      try {
+        const content = readFileSync(this.lockedPlanFile, "utf-8").trim();
+        if (content) {
+          this.connection.updateTaskFields({ plan: content });
+          const fileName = this.lockedPlanFile.split("/").pop() ?? "plan";
+          this.connection.postChatMessage(`Synced local plan file (${fileName}) to the task plan.`);
+        }
+      } catch {
+      }
+      return;
+    }
+    const newest = this.findNewestPlanFile();
     if (newest) {
       this.lockedPlanFile = newest.path;
       const content = readFileSync(newest.path, "utf-8").trim();
       if (content) {
         this.connection.updateTaskFields({ plan: content });
-        const fileName = newest.path.split("/").pop();
+        const fileName = newest.path.split("/").pop() ?? "plan";
         this.connection.postChatMessage(
           `Detected local plan file (${fileName}) and synced it to the task plan.`
         );
       }
     }
   }
-};
+};
+
+// src/runner/runner-setup.ts
+var MAX_SETUP_LOG_LINES = 50;
+function pushSetupLog(setupLog, line) {
+  setupLog.push(line);
+  if (setupLog.length > MAX_SETUP_LOG_LINES) {
+    setupLog.splice(0, setupLog.length - MAX_SETUP_LOG_LINES);
+  }
+}
+async function executeSetupConfig(config, runnerConfig, connection, setupLog, effectiveAgentMode) {
+  let deferredStartConfig = null;
+  if (config.setupCommand) {
+    pushSetupLog(setupLog, `$ ${config.setupCommand}`);
+    await runSetupCommand(config.setupCommand, runnerConfig.workspaceDir, (stream, data) => {
+      connection.sendEvent({ type: "setup_output", stream, data });
+      for (const line of data.split("\n").filter(Boolean)) {
+        pushSetupLog(setupLog, `[${stream}] ${line}`);
+      }
+    });
+    pushSetupLog(setupLog, "(exit 0)");
+  }
+  if (config.startCommand) {
+    if (effectiveAgentMode === "auto") {
+      deferredStartConfig = config;
+      pushSetupLog(setupLog, `[conveyor] startCommand deferred (auto mode)`);
+    } else {
+      pushSetupLog(setupLog, `$ ${config.startCommand} &  (background)`);
+      runStartCommand(config.startCommand, runnerConfig.workspaceDir, (stream, data) => {
+        connection.sendEvent({ type: "start_command_output", stream, data });
+      });
+    }
+  }
+  return deferredStartConfig;
+}
+async function runSetupSafe(runnerConfig, connection, callbacks, setupLog, effectiveAgentMode, setState) {
+  await setState("setup");
+  const ports = await loadForwardPorts(runnerConfig.workspaceDir);
+  if (ports.length > 0 && process.env.CODESPACE_NAME) {
+    const visibility = ports.map((p) => `${p}:public`).join(" ");
+    runStartCommand(
+      `gh codespace ports visibility ${visibility} -c "${process.env.CODESPACE_NAME}" 2>/dev/null`,
+      runnerConfig.workspaceDir,
+      () => void 0
+    );
+  }
+  const config = await loadConveyorConfig(runnerConfig.workspaceDir);
+  if (!config) {
+    connection.sendEvent({ type: "setup_complete" });
+    await callbacks.onEvent({ type: "setup_complete" });
+    return { ok: true, deferredStartConfig: null };
+  }
+  try {
+    const deferredStartConfig = await executeSetupConfig(
+      config,
+      runnerConfig,
+      connection,
+      setupLog,
+      effectiveAgentMode
+    );
+    const setupEvent = {
+      type: "setup_complete",
+      previewPort: config.previewPort ?? void 0,
+      startCommandDeferred: deferredStartConfig === null ? void 0 : true
+    };
+    connection.sendEvent(setupEvent);
+    await callbacks.onEvent(setupEvent);
+    return { ok: true, deferredStartConfig };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Setup failed";
+    connection.sendEvent({ type: "setup_error", message });
+    await callbacks.onEvent({ type: "setup_error", message });
+    connection.postChatMessage(
+      `Environment setup failed: ${message}
+The agent cannot start until this is resolved.`
+    );
+    return { ok: false, deferredStartConfig: null };
+  }
+}
+function runDeferredStartCommand(deferredStartConfig, runnerConfig, connection, setupLog) {
+  if (!deferredStartConfig?.startCommand) return;
+  pushSetupLog(setupLog, `$ ${deferredStartConfig.startCommand} &  (background, deferred)`);
+  connection.sendEvent({ type: "start_command_started" });
+  runStartCommand(deferredStartConfig.startCommand, runnerConfig.workspaceDir, (stream, data) => {
+    connection.sendEvent({ type: "start_command_output", stream, data });
+  });
+  const setupEvent = {
+    type: "setup_complete",
+    previewPort: deferredStartConfig.previewPort ?? void 0
+  };
+  connection.sendEvent(setupEvent);
+}
+
+// src/runner/runner-helpers.ts
+function buildFileBlock(f) {
+  if (f.content && f.contentEncoding === "base64") {
+    return [
+      {
+        type: "image",
+        source: { type: "base64", media_type: f.mimeType, data: f.content }
+      },
+      { type: "text", text: `[Attached image: ${f.fileName} (${f.mimeType})]` }
+    ];
+  }
+  if (f.content && f.contentEncoding === "utf-8") {
+    return [
+      {
+        type: "text",
+        text: `[Attached file: ${f.fileName} (${f.mimeType})]
+\`\`\`
+${f.content}
+\`\`\``
+      }
+    ];
+  }
+  return [
+    {
+      type: "text",
+      text: `[Attached file: ${f.fileName} (${f.mimeType})] Download: ${f.downloadUrl}`
+    }
+  ];
+}
+function buildMessageContent(content, files) {
+  if (!files?.length) return content;
+  const blocks = [{ type: "text", text: content }];
+  for (const f of files) blocks.push(...buildFileBlock(f));
+  return blocks;
+}
+function formatThinkingSetting(thinking) {
+  if (thinking?.type === "enabled") return `enabled(${thinking.budgetTokens ?? "?"})`;
+  return thinking?.type ?? "default";
+}
+function getModelForMode(context, mode, isParentTask) {
+  if (mode === "building" && !isParentTask) {
+    return context.builderModel ?? context.model;
+  }
+  return context.pmModel ?? context.model;
+}
+async function handleAutoModeRestart(state, connection, setState, runQuerySafe, fetchFreshContext) {
+  const { taskContext } = state;
+  const currentModel = taskContext.model;
+  const currentSessionId = taskContext.claudeSessionId;
+  if (currentSessionId && currentModel) {
+    state.sessionIds.set(currentModel, currentSessionId);
+  }
+  const newMode = state.agentMode;
+  const isParentTask = !!taskContext.isParentTask;
+  const newModel = getModelForMode(taskContext, newMode, isParentTask);
+  taskContext.claudeSessionId = null;
+  connection.storeSessionId("");
+  if (newModel) taskContext.model = newModel;
+  taskContext.agentMode = newMode;
+  connection.emitModeTransition({ fromMode: "auto", toMode: newMode ?? "building" });
+  connection.emitModeChanged(newMode);
+  connection.postChatMessage(
+    `Transitioning to **${newMode}** mode${newModel ? ` with ${newModel}` : ""}. Restarting session...`
+  );
+  const freshContext = await fetchFreshContext();
+  if (freshContext) {
+    freshContext._runnerSessionId = taskContext._runnerSessionId;
+    freshContext.claudeSessionId = taskContext.claudeSessionId;
+    freshContext.agentMode = newMode;
+    if (newModel) freshContext.model = newModel;
+    state.taskContext = freshContext;
+  }
+  await setState("running");
+  await runQuerySafe(state.taskContext);
+}
+function buildQueryHost(deps) {
+  return {
+    config: deps.config,
+    connection: deps.connection,
+    callbacks: deps.callbacks,
+    setupLog: deps.setupLog,
+    costTracker: deps.costTracker,
+    get agentMode() {
+      return deps.getEffectiveAgentMode();
+    },
+    get isParentTask() {
+      return deps.getIsParentTask();
+    },
+    get hasExitedPlanMode() {
+      return deps.getHasExitedPlanMode();
+    },
+    set hasExitedPlanMode(val) {
+      deps.setHasExitedPlanMode(val);
+    },
+    get pendingModeRestart() {
+      return deps.getPendingModeRestart();
+    },
+    set pendingModeRestart(val) {
+      deps.setPendingModeRestart(val);
+    },
+    sessionIds: deps.sessionIds,
+    isStopped: deps.isStopped,
+    createInputStream: deps.createInputStream,
+    snapshotPlanFiles: () => deps.planSync.snapshotPlanFiles(),
+    syncPlanFile: () => deps.planSync.syncPlanFile(),
+    onModeTransition: deps.onModeTransition
+  };
+}
 
 // src/runner/agent-runner.ts
 var HEARTBEAT_INTERVAL_MS = 3e4;
 var IDLE_TIMEOUT_MS = 30 * 60 * 1e3;
-var AgentRunner = class _AgentRunner {
+var AgentRunner = class {
   config;
   connection;
   callbacks;
@@ -2653,11 +2880,10 @@ var AgentRunner = class _AgentRunner {
   pendingModeRestart = false;
   sessionIds = /* @__PURE__ */ new Map();
   lastQueryModeRestart = false;
-  deferredStartConfig = null;
   startCommandStarted = false;
   idleTimer = null;
   idleCheckInterval = null;
-  static MAX_SETUP_LOG_LINES = 50;
+  deferredStartConfig = null;
   constructor(config, callbacks) {
     this.config = config;
     this.connection = new ConveyorConnection(config);
@@ -2667,15 +2893,10 @@ var AgentRunner = class _AgentRunner {
   get state() {
     return this._state;
   }
-  /**
-   * Resolve the effective AgentMode from explicit agentMode or legacy config flags.
-   * This is the single axis of behavior for all execution path decisions.
-   */
   get effectiveAgentMode() {
     if (this.agentMode) return this.agentMode;
     if (this.config.mode === "pm") {
-      if (this.config.isAuto) return "auto";
-      return "discovery";
+      return this.config.isAuto ? "auto" : "discovery";
     }
     return "building";
   }
@@ -2686,9 +2907,7 @@ var AgentRunner = class _AgentRunner {
   }
   startHeartbeat() {
     this.heartbeatTimer = setInterval(() => {
-      if (!this.stopped) {
-        this.connection.sendHeartbeat();
-      }
+      if (!this.stopped) this.connection.sendHeartbeat();
     }, HEARTBEAT_INTERVAL_MS);
   }
   stopHeartbeat() {
@@ -2715,32 +2934,44 @@ var AgentRunner = class _AgentRunner {
       (message) => this.injectHumanMessage(message.content, message.files)
     );
     this.connection.onModeChange((data) => this.handleModeChange(data.agentMode));
-    this.connection.onRunStartCommand(() => this.runDeferredStartCommand());
+    this.connection.onRunStartCommand(() => this.handleRunStartCommand());
     await this.setState("connected");
     this.connection.sendEvent({ type: "connected", taskId: this.config.taskId });
     this.startHeartbeat();
     if (this.config.mode !== "pm" && process.env.CODESPACES === "true") {
-      const setupOk = await this.runSetupSafe();
-      if (!setupOk) {
+      const result = await runSetupSafe(
+        this.config,
+        this.connection,
+        this.callbacks,
+        this.setupLog,
+        this.effectiveAgentMode,
+        (s) => this.setState(s)
+      );
+      if (!result.ok) {
         this.stopHeartbeat();
         await this.setState("error");
         this.connection.disconnect();
         return;
       }
+      this.deferredStartConfig = result.deferredStartConfig;
     }
     initRtk();
+    this.tryInitWorktree();
+    if (!await this.fetchAndInitContext()) return;
+    this.tryPostContextWorktree();
+    this.checkoutWorktreeBranch();
+    await this.executeInitialMode();
+    await this.runCoreLoop();
+    this.stopHeartbeat();
+    await this.setState("finished");
+    this.connection.disconnect();
+  }
+  tryInitWorktree() {
     if (process.env.CODESPACES !== "true" && process.env.CONVEYOR_USE_WORKTREE !== "false" && (this.config.mode === "pm" || process.env.CONVEYOR_USE_WORKTREE === "true")) {
-      try {
-        const worktreePath = ensureWorktree(this.config.workspaceDir, this.config.taskId);
-        this.config = { ...this.config, workspaceDir: worktreePath };
-        this.planSync.updateWorkspaceDir(worktreePath);
-        this.worktreeActive = true;
-        this.setupLog.push(`[conveyor] Using worktree: ${worktreePath}`);
-      } catch (error) {
-        const msg = error instanceof Error ? error.message : "Unknown error";
-        this.setupLog.push(`[conveyor] Worktree creation failed, using shared workspace: ${msg}`);
-      }
+      this.activateWorktree("[conveyor] Using worktree:");
     }
+  }
+  async fetchAndInitContext() {
     await this.setState("fetching_context");
     try {
       this.taskContext = await this.connection.fetchTaskContext();
@@ -2751,67 +2982,56 @@ var AgentRunner = class _AgentRunner {
       this.stopHeartbeat();
       await this.setState("error");
       this.connection.disconnect();
-      return;
+      return false;
     }
     this.taskContext._runnerSessionId = randomUUID2();
-    if (this.taskContext.agentMode) {
-      this.agentMode = this.taskContext.agentMode;
-    }
+    if (this.taskContext.agentMode) this.agentMode = this.taskContext.agentMode;
     this.logEffectiveSettings();
-    if (process.env.CODESPACES === "true") {
-      unshallowRepo(this.config.workspaceDir);
+    if (process.env.CODESPACES === "true") unshallowRepo(this.config.workspaceDir);
+    return true;
+  }
+  tryPostContextWorktree() {
+    if (process.env.CODESPACES !== "true" && !this.worktreeActive && this.taskContext?.useWorktree) {
+      this.activateWorktree("[conveyor] Using worktree (from task config):");
     }
-    if (process.env.CODESPACES !== "true" && !this.worktreeActive && this.taskContext.useWorktree) {
-      try {
-        const worktreePath = ensureWorktree(this.config.workspaceDir, this.config.taskId);
-        this.config = { ...this.config, workspaceDir: worktreePath };
-        this.planSync.updateWorkspaceDir(worktreePath);
-        this.worktreeActive = true;
-        this.setupLog.push(`[conveyor] Using worktree (from task config): ${worktreePath}`);
-      } catch (error) {
-        const msg = error instanceof Error ? error.message : "Unknown error";
-        this.setupLog.push(`[conveyor] Worktree creation failed, using shared workspace: ${msg}`);
-      }
+  }
+  activateWorktree(logPrefix) {
+    try {
+      const worktreePath = ensureWorktree(this.config.workspaceDir, this.config.taskId);
+      this.config = { ...this.config, workspaceDir: worktreePath };
+      this.planSync.updateWorkspaceDir(worktreePath);
+      this.worktreeActive = true;
+      pushSetupLog(this.setupLog, `${logPrefix} ${worktreePath}`);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : "Unknown error";
+      pushSetupLog(
+        this.setupLog,
+        `[conveyor] Worktree creation failed, using shared workspace: ${msg}`
+      );
     }
-    if (this.worktreeActive && this.taskContext.githubBranch) {
-      try {
-        const branch = this.taskContext.githubBranch;
-        execSync3(`git fetch origin ${branch} && git checkout ${branch}`, {
-          cwd: this.config.workspaceDir,
-          stdio: "ignore"
-        });
-      } catch {
-      }
+  }
+  checkoutWorktreeBranch() {
+    if (!this.worktreeActive || !this.taskContext?.githubBranch) return;
+    try {
+      const branch = this.taskContext.githubBranch;
+      execSync3(`git fetch origin ${branch} && git checkout ${branch}`, {
+        cwd: this.config.workspaceDir,
+        stdio: "ignore"
+      });
+    } catch {
     }
-    switch (this.effectiveAgentMode) {
-      case "discovery":
-      case "help":
-        await this.setState("idle");
-        break;
-      case "building":
-        await this.setState("running");
-        await this.runQuerySafe(this.taskContext);
-        if (!this.stopped) await this.setState("idle");
-        break;
-      case "review":
-        if (this.taskContext.isParentTask) {
-          await this.setState("running");
-          await this.runQuerySafe(this.taskContext);
-          if (!this.stopped) await this.setState("idle");
-        } else {
-          await this.setState("idle");
-        }
-        break;
-      case "auto":
-        await this.setState("running");
-        await this.runQuerySafe(this.taskContext);
-        if (!this.stopped) await this.setState("idle");
-        break;
+  }
+  async executeInitialMode() {
+    if (!this.taskContext) return;
+    const mode = this.effectiveAgentMode;
+    const shouldRun = mode === "building" || mode === "auto" || mode === "review" && !!this.taskContext.isParentTask;
+    if (shouldRun) {
+      await this.setState("running");
+      await this.runQuerySafe(this.taskContext);
+      if (!this.stopped) await this.setState("idle");
+    } else {
+      await this.setState("idle");
     }
-    await this.runCoreLoop();
-    this.stopHeartbeat();
-    await this.setState("finished");
-    this.connection.disconnect();
   }
   async runQuerySafe(context, followUp) {
     this.lastQueryModeRestart = false;
@@ -2833,7 +3053,21 @@ var AgentRunner = class _AgentRunner {
     while (!this.stopped) {
       if (this.lastQueryModeRestart) {
         this.lastQueryModeRestart = false;
-        await this.handleAutoModeRestart();
+        await handleAutoModeRestart(
+          { agentMode: this.agentMode, sessionIds: this.sessionIds, taskContext: this.taskContext },
+          this.connection,
+          (s) => this.setState(s),
+          (ctx) => this.runQuerySafe(ctx),
+          async () => {
+            try {
+              return await this.connection.fetchTaskContext();
+            } catch {
+              return null;
+            }
+          }
+        );
+        this.taskContext = await this.connection.fetchTaskContext().catch(() => null) ?? this.taskContext;
+        if (!this.stopped && this._state !== "error") await this.setState("idle");
         continue;
       }
       if (this._state === "idle") {
@@ -2849,108 +3083,17 @@ var AgentRunner = class _AgentRunner {
       }
     }
   }
-  /**
-   * Handle auto mode transition after ExitPlanMode.
-   * Saves the current session, switches model/mode, and restarts with a fresh query.
-   */
-  async handleAutoModeRestart() {
-    if (!this.taskContext) return;
-    const currentModel = this.taskContext.model;
-    const currentSessionId = this.taskContext.claudeSessionId;
-    if (currentSessionId && currentModel) {
-      this.sessionIds.set(currentModel, currentSessionId);
-    }
-    const newMode = this.agentMode;
-    const isParentTask = !!this.taskContext.isParentTask;
-    const newModel = this.getModelForMode(newMode, isParentTask);
-    const resumeSessionId = newModel ? this.sessionIds.get(newModel) : null;
-    if (resumeSessionId) {
-      this.taskContext.claudeSessionId = resumeSessionId;
-    } else {
-      this.taskContext.claudeSessionId = null;
-      this.connection.storeSessionId("");
-    }
-    if (newModel) {
-      this.taskContext.model = newModel;
-    }
-    this.taskContext.agentMode = newMode;
-    this.connection.emitModeTransition({
-      fromMode: "auto",
-      toMode: newMode ?? "building"
-    });
-    this.connection.emitModeChanged(newMode);
-    this.connection.postChatMessage(
-      `Transitioning to **${newMode}** mode${newModel ? ` with ${newModel}` : ""}. Restarting session...`
-    );
-    try {
-      const freshContext = await this.connection.fetchTaskContext();
-      freshContext._runnerSessionId = this.taskContext._runnerSessionId;
-      freshContext.claudeSessionId = this.taskContext.claudeSessionId;
-      freshContext.agentMode = newMode;
-      if (newModel) freshContext.model = newModel;
-      this.taskContext = freshContext;
-    } catch {
-    }
-    await this.setState("running");
-    await this.runQuerySafe(this.taskContext);
-    if (!this.stopped && this._state !== "error") {
-      await this.setState("idle");
-    }
-  }
-  /**
-   * Get the appropriate model for a given mode.
-   * Building uses the builder model (Sonnet), Discovery/Review use PM model (Opus).
-   */
-  getModelForMode(mode, isParentTask) {
-    if (!this.taskContext) return null;
-    if (mode === "building" && !isParentTask) {
-      return this.taskContext.builderModel ?? this.taskContext.model;
-    }
-    return this.taskContext.pmModel ?? this.taskContext.model;
-  }
-  async runSetupSafe() {
-    await this.setState("setup");
-    const ports = await loadForwardPorts(this.config.workspaceDir);
-    if (ports.length > 0 && process.env.CODESPACE_NAME) {
-      const visibility = ports.map((p) => `${p}:public`).join(" ");
-      runStartCommand(
-        `gh codespace ports visibility ${visibility} -c "${process.env.CODESPACE_NAME}" 2>/dev/null`,
-        this.config.workspaceDir,
-        () => void 0
-      );
-    }
-    const config = await loadConveyorConfig(this.config.workspaceDir);
-    if (!config) {
-      this.connection.sendEvent({ type: "setup_complete" });
-      await this.callbacks.onEvent({ type: "setup_complete" });
-      return true;
-    }
-    try {
-      await this.executeSetupConfig(config);
-      const setupEvent = {
-        type: "setup_complete",
-        previewPort: config.previewPort ?? void 0,
-        startCommandDeferred: this.deferredStartConfig !== null ? true : void 0
-      };
-      this.connection.sendEvent(setupEvent);
-      await this.callbacks.onEvent(setupEvent);
-      return true;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Setup failed";
-      this.connection.sendEvent({ type: "setup_error", message });
-      await this.callbacks.onEvent({ type: "setup_error", message });
-      this.connection.postChatMessage(
-        `Environment setup failed: ${message}
-The agent cannot start until this is resolved.`
-      );
-      return false;
-    }
+  handleRunStartCommand() {
+    if (!this.deferredStartConfig?.startCommand || this.startCommandStarted) return;
+    this.startCommandStarted = true;
+    runDeferredStartCommand(this.deferredStartConfig, this.config, this.connection, this.setupLog);
+    this.deferredStartConfig = null;
   }
   logEffectiveSettings() {
     if (!this.taskContext) return;
     const s = this.taskContext.agentSettings ?? this.config.agentSettings ?? {};
     const model = this.taskContext.model || this.config.model;
-    const thinking = s.thinking?.type === "enabled" ? `enabled(${s.thinking.budgetTokens ?? "?"})` : s.thinking?.type ?? "default";
+    const thinking = formatThinkingSetting(s.thinking);
     const parts = [
       `model=${model}`,
       `mode=${this.config.mode ?? "task"}`,
@@ -2964,84 +3107,8 @@ The agent cannot start until this is resolved.`
     if (s.enableFileCheckpointing) parts.push(`checkpointing=on`);
     console.log(`[conveyor-agent] ${parts.join(", ")}`);
   }
-  pushSetupLog(line) {
-    this.setupLog.push(line);
-    if (this.setupLog.length > _AgentRunner.MAX_SETUP_LOG_LINES) {
-      this.setupLog.splice(0, this.setupLog.length - _AgentRunner.MAX_SETUP_LOG_LINES);
-    }
-  }
-  async executeSetupConfig(config) {
-    if (config.setupCommand) {
-      this.pushSetupLog(`$ ${config.setupCommand}`);
-      await runSetupCommand(config.setupCommand, this.config.workspaceDir, (stream, data) => {
-        this.connection.sendEvent({ type: "setup_output", stream, data });
-        for (const line of data.split("\n").filter(Boolean)) {
-          this.pushSetupLog(`[${stream}] ${line}`);
-        }
-      });
-      this.pushSetupLog("(exit 0)");
-    }
-    if (config.startCommand) {
-      if (this.effectiveAgentMode === "auto") {
-        this.deferredStartConfig = config;
-        this.pushSetupLog(`[conveyor] startCommand deferred (auto mode)`);
-      } else {
-        this.pushSetupLog(`$ ${config.startCommand} &  (background)`);
-        runStartCommand(config.startCommand, this.config.workspaceDir, (stream, data) => {
-          this.connection.sendEvent({ type: "start_command_output", stream, data });
-        });
-      }
-    }
-  }
-  runDeferredStartCommand() {
-    if (!this.deferredStartConfig?.startCommand || this.startCommandStarted) return;
-    this.startCommandStarted = true;
-    const config = this.deferredStartConfig;
-    this.deferredStartConfig = null;
-    this.pushSetupLog(`$ ${config.startCommand} &  (background, deferred)`);
-    this.connection.sendEvent({ type: "start_command_started" });
-    runStartCommand(config.startCommand, this.config.workspaceDir, (stream, data) => {
-      this.connection.sendEvent({ type: "start_command_output", stream, data });
-    });
-    const setupEvent = {
-      type: "setup_complete",
-      previewPort: config.previewPort ?? void 0
-    };
-    this.connection.sendEvent(setupEvent);
-  }
   injectHumanMessage(content, files) {
-    let messageContent;
-    if (files?.length) {
-      const blocks = [{ type: "text", text: content }];
-      for (const f of files) {
-        if (f.content && f.contentEncoding === "base64") {
-          blocks.push({
-            type: "image",
-            source: { type: "base64", media_type: f.mimeType, data: f.content }
-          });
-          blocks.push({
-            type: "text",
-            text: `[Attached image: ${f.fileName} (${f.mimeType})]`
-          });
-        } else if (f.content && f.contentEncoding === "utf-8") {
-          blocks.push({
-            type: "text",
-            text: `[Attached file: ${f.fileName} (${f.mimeType})]
-\`\`\`
-${f.content}
-\`\`\``
-          });
-        } else {
-          blocks.push({
-            type: "text",
-            text: `[Attached file: ${f.fileName} (${f.mimeType})] Download: ${f.downloadUrl}`
-          });
-        }
-      }
-      messageContent = blocks;
-    } else {
-      messageContent = content;
-    }
+    const messageContent = buildMessageContent(content, files);
     const msg = {
       type: "user",
       session_id: "",
@@ -3085,16 +3152,11 @@ ${f.content}
   }
   async waitForUserContent() {
     if (this.pendingMessages.length > 0) {
-      const next = this.pendingMessages.shift();
-      const content2 = next?.message.content;
-      if (!content2) return null;
-      return content2;
+      const content = this.pendingMessages.shift()?.message.content;
+      return content ?? null;
     }
     const msg = await this.waitForMessage();
-    if (!msg) return null;
-    const content = msg.message.content;
-    if (!content) return null;
-    return content;
+    return msg?.message.content ?? null;
   }
   async *createInputStream(initialPrompt) {
     const makeUserMessage = (content) => ({
@@ -3124,60 +3186,43 @@ ${f.content}
     }
   }
   asQueryHost() {
-    const getEffectiveAgentMode = () => this.effectiveAgentMode;
-    const getHasExitedPlanMode = () => this.hasExitedPlanMode;
-    const setHasExitedPlanMode = (val) => {
-      this.hasExitedPlanMode = val;
-    };
-    const getPendingModeRestart = () => this.pendingModeRestart;
-    const setPendingModeRestart = (val) => {
-      this.pendingModeRestart = val;
-    };
-    const getIsParentTask = () => !!this.taskContext?.isParentTask;
-    return {
+    return buildQueryHost({
       config: this.config,
       connection: this.connection,
       callbacks: this.callbacks,
       setupLog: this.setupLog,
       costTracker: this.costTracker,
-      get agentMode() {
-        return getEffectiveAgentMode();
-      },
-      get isParentTask() {
-        return getIsParentTask();
-      },
-      get hasExitedPlanMode() {
-        return getHasExitedPlanMode();
-      },
-      set hasExitedPlanMode(val) {
-        setHasExitedPlanMode(val);
-      },
-      get pendingModeRestart() {
-        return getPendingModeRestart();
+      planSync: this.planSync,
+      sessionIds: this.sessionIds,
+      getEffectiveAgentMode: () => this.effectiveAgentMode,
+      getIsParentTask: () => !!this.taskContext?.isParentTask,
+      getHasExitedPlanMode: () => this.hasExitedPlanMode,
+      setHasExitedPlanMode: (val) => {
+        this.hasExitedPlanMode = val;
       },
-      set pendingModeRestart(val) {
-        setPendingModeRestart(val);
+      getPendingModeRestart: () => this.pendingModeRestart,
+      setPendingModeRestart: (val) => {
+        this.pendingModeRestart = val;
       },
-      sessionIds: this.sessionIds,
       isStopped: () => this.stopped,
       createInputStream: (prompt) => this.createInputStream(prompt),
-      snapshotPlanFiles: () => this.planSync.snapshotPlanFiles(),
-      syncPlanFile: () => this.planSync.syncPlanFile(),
       onModeTransition: (newMode) => {
         this.agentMode = newMode;
       }
-    };
+    });
   }
   handleModeChange(newAgentMode) {
     if (this.config.mode !== "pm") return;
-    if (newAgentMode) {
-      this.agentMode = newAgentMode;
-    }
+    if (newAgentMode) this.agentMode = newAgentMode;
     const effectiveMode = this.effectiveAgentMode;
     this.connection.emitModeChanged(effectiveMode);
     this.connection.postChatMessage(
       `Mode switched to **${effectiveMode}**${effectiveMode === "building" ? " \u2014 I now have direct coding access." : ""}`
     );
+    if (effectiveMode === "building" && this.taskContext?.status === "Open") {
+      this.connection.updateStatus("InProgress");
+      this.taskContext.status = "InProgress";
+    }
   }
   stop() {
     this.stopped = true;
@@ -3239,87 +3284,103 @@ function buildPrompt(message, chatHistory) {
 ${message.content}`);
   return parts.join("\n");
 }
-async function handleProjectChatMessage(message, connection, projectDir) {
-  connection.emitAgentStatus("busy");
+function processContentBlock(block, responseParts, turnToolCalls) {
+  if (block.type === "text" && block.text) {
+    responseParts.push(block.text);
+  } else if (block.type === "tool_use" && block.name) {
+    const inputStr = typeof block.input === "string" ? block.input : JSON.stringify(block.input);
+    turnToolCalls.push({
+      tool: block.name,
+      input: inputStr.slice(0, 1e4),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    console.log(`[project-chat] [tool_use] ${block.name}`);
+  }
+}
+async function fetchContext(connection) {
+  let agentCtx = null;
   try {
-    let agentCtx = null;
-    try {
-      agentCtx = await connection.fetchAgentContext();
-    } catch {
-      console.log("[project-chat] Could not fetch agent context, using defaults");
+    agentCtx = await connection.fetchAgentContext();
+  } catch {
+    console.log("[project-chat] Could not fetch agent context, using defaults");
+  }
+  let chatHistory = [];
+  try {
+    chatHistory = await connection.fetchChatHistory(30);
+  } catch {
+    console.log("[project-chat] Could not fetch chat history, proceeding without it");
+  }
+  return { agentCtx, chatHistory };
+}
+function buildChatQueryOptions(agentCtx, projectDir) {
+  const model = agentCtx?.model || FALLBACK_MODEL;
+  const settings = agentCtx?.agentSettings ?? {};
+  return {
+    model,
+    systemPrompt: {
+      type: "preset",
+      preset: "claude_code",
+      append: buildSystemPrompt2(projectDir, agentCtx)
+    },
+    cwd: projectDir,
+    permissionMode: "bypassPermissions",
+    allowDangerouslySkipPermissions: true,
+    tools: { type: "preset", preset: "claude_code" },
+    maxTurns: settings.maxTurns ?? 15,
+    maxBudgetUsd: settings.maxBudgetUsd ?? 5,
+    effort: settings.effort,
+    thinking: settings.thinking
+  };
+}
+function processEventStream(event, connection, responseParts, turnToolCalls, isTyping) {
+  if (event.type === "assistant") {
+    if (!isTyping.value) {
+      setTimeout(() => connection.emitEvent({ type: "agent_typing_start" }), 200);
+      isTyping.value = true;
     }
-    let chatHistory = [];
-    try {
-      chatHistory = await connection.fetchChatHistory(30);
-    } catch {
-      console.log("[project-chat] Could not fetch chat history, proceeding without it");
-    }
-    const model = agentCtx?.model || FALLBACK_MODEL;
-    const settings = agentCtx?.agentSettings ?? {};
-    const systemPrompt = buildSystemPrompt2(projectDir, agentCtx);
-    const prompt = buildPrompt(message, chatHistory);
-    const events = query2({
-      prompt,
-      options: {
-        model,
-        systemPrompt: {
-          type: "preset",
-          preset: "claude_code",
-          append: systemPrompt
-        },
-        cwd: projectDir,
-        permissionMode: "bypassPermissions",
-        allowDangerouslySkipPermissions: true,
-        tools: { type: "preset", preset: "claude_code" },
-        maxTurns: settings.maxTurns ?? 15,
-        maxBudgetUsd: settings.maxBudgetUsd ?? 5,
-        effort: settings.effort,
-        thinking: settings.thinking
-      }
-    });
-    const responseParts = [];
-    const turnToolCalls = [];
-    let isTyping = false;
-    for await (const event of events) {
-      if (event.type === "assistant") {
-        if (!isTyping) {
-          setTimeout(() => connection.emitEvent({ type: "agent_typing_start" }), 200);
-          isTyping = true;
-        }
-        const assistantEvent = event;
-        const { content } = assistantEvent.message;
-        for (const block of content) {
-          if (block.type === "text") {
-            responseParts.push(block.text);
-          } else if (block.type === "tool_use") {
-            const inputStr = typeof block.input === "string" ? block.input : JSON.stringify(block.input);
-            turnToolCalls.push({
-              tool: block.name,
-              input: inputStr.slice(0, 1e4),
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-            console.log(`[project-chat] [tool_use] ${block.name}`);
-          }
-        }
-        if (turnToolCalls.length > 0) {
-          connection.emitEvent({ type: "activity_block", events: [...turnToolCalls] });
-          turnToolCalls.length = 0;
-        }
-      } else if (event.type === "result") {
-        if (isTyping) {
-          connection.emitEvent({ type: "agent_typing_stop" });
-          isTyping = false;
-        }
-        break;
-      }
+    const assistantEvent = event;
+    for (const block of assistantEvent.message.content) {
+      processContentBlock(block, responseParts, turnToolCalls);
     }
-    if (isTyping) {
-      connection.emitEvent({ type: "agent_typing_stop" });
+    if (turnToolCalls.length > 0) {
+      connection.emitEvent({ type: "activity_block", events: [...turnToolCalls] });
+      turnToolCalls.length = 0;
     }
-    const responseText = responseParts.join("\n\n").trim();
-    if (responseText) {
-      await connection.emitChatMessage(responseText);
+    return false;
+  }
+  if (event.type === "result") {
+    if (isTyping.value) {
+      connection.emitEvent({ type: "agent_typing_stop" });
+      isTyping.value = false;
     }
+    return true;
+  }
+  return false;
+}
+async function runChatQuery(message, connection, projectDir) {
+  const { agentCtx, chatHistory } = await fetchContext(connection);
+  const options = buildChatQueryOptions(agentCtx, projectDir);
+  const prompt = buildPrompt(message, chatHistory);
+  const events = query2({ prompt, options });
+  const responseParts = [];
+  const turnToolCalls = [];
+  const isTyping = { value: false };
+  for await (const event of events) {
+    const done = processEventStream(event, connection, responseParts, turnToolCalls, isTyping);
+    if (done) break;
+  }
+  if (isTyping.value) {
+    connection.emitEvent({ type: "agent_typing_stop" });
+  }
+  const responseText = responseParts.join("\n\n").trim();
+  if (responseText) {
+    await connection.emitChatMessage(responseText);
+  }
+}
+async function handleProjectChatMessage(message, connection, projectDir) {
+  connection.emitAgentStatus("busy");
+  try {
+    await runChatQuery(message, connection, projectDir);
   } catch (error) {
     console.error(
       "[project-chat] Failed to handle message:",
@@ -3342,6 +3403,72 @@ var __dirname = path.dirname(__filename);
 var HEARTBEAT_INTERVAL_MS2 = 3e4;
 var MAX_CONCURRENT = 5;
 var STOP_TIMEOUT_MS = 3e4;
+function setupWorkDir(projectDir, assignment) {
+  const { taskId, branch, devBranch, useWorktree } = assignment;
+  const shortId = taskId.slice(0, 8);
+  const shouldWorktree = useWorktree === true;
+  let workDir;
+  if (shouldWorktree) {
+    workDir = ensureWorktree(projectDir, taskId, devBranch);
+  } else {
+    workDir = projectDir;
+  }
+  if (branch && branch !== devBranch) {
+    try {
+      execSync4(`git checkout ${branch}`, { cwd: workDir, stdio: "ignore" });
+    } catch {
+      try {
+        execSync4(`git checkout -b ${branch}`, { cwd: workDir, stdio: "ignore" });
+      } catch {
+        console.log(`[task:${shortId}] Warning: could not checkout branch ${branch}`);
+      }
+    }
+  }
+  return { workDir, usesWorktree: shouldWorktree };
+}
+function spawnChildAgent(assignment, workDir) {
+  const { taskToken, apiUrl, taskId, mode, isAuto, useSandbox } = assignment;
+  const cliPath = path.resolve(__dirname, "cli.js");
+  const childEnv = { ...process.env };
+  delete childEnv.CONVEYOR_PROJECT_TOKEN;
+  delete childEnv.CONVEYOR_PROJECT_ID;
+  const child = fork(cliPath, [], {
+    env: {
+      ...childEnv,
+      CONVEYOR_API_URL: apiUrl,
+      CONVEYOR_TASK_TOKEN: taskToken,
+      CONVEYOR_TASK_ID: taskId,
+      CONVEYOR_MODE: mode,
+      CONVEYOR_WORKSPACE: workDir,
+      CONVEYOR_USE_WORKTREE: "false",
+      CONVEYOR_AGENT_MODE: isAuto ? "auto" : "",
+      CONVEYOR_IS_AUTO: isAuto ? "true" : "false",
+      CONVEYOR_USE_SANDBOX: useSandbox === true ? "true" : "false"
+    },
+    cwd: workDir,
+    stdio: ["pipe", "pipe", "pipe", "ipc"]
+  });
+  child.stdin?.on("error", () => {
+  });
+  child.stdout?.on("error", () => {
+  });
+  child.stderr?.on("error", () => {
+  });
+  const shortId = taskId.slice(0, 8);
+  child.stdout?.on("data", (data) => {
+    const lines = data.toString().trimEnd().split("\n");
+    for (const line of lines) {
+      console.log(`[task:${shortId}] ${line}`);
+    }
+  });
+  child.stderr?.on("data", (data) => {
+    const lines = data.toString().trimEnd().split("\n");
+    for (const line of lines) {
+      console.error(`[task:${shortId}] ${line}`);
+    }
+  });
+  return child;
+}
 var ProjectRunner = class {
   connection;
   projectDir;
@@ -3360,7 +3487,7 @@ var ProjectRunner = class {
   async start() {
     await this.connection.connect();
     this.connection.onTaskAssignment((assignment) => {
-      void this.handleAssignment(assignment);
+      this.handleAssignment(assignment);
     });
     this.connection.onStopTask((data) => {
       this.handleStopTask(data.taskId);
@@ -3383,8 +3510,8 @@ var ProjectRunner = class {
       process.on("SIGINT", () => void this.stop());
     });
   }
-  async handleAssignment(assignment) {
-    const { taskId, taskToken, apiUrl, mode, branch, devBranch, useWorktree, isAuto, useSandbox } = assignment;
+  handleAssignment(assignment) {
+    const { taskId, mode } = assignment;
     const shortId = taskId.slice(0, 8);
     if (this.activeAgents.has(taskId)) {
       console.log(`[project-runner] Task ${shortId} already running, skipping`);
@@ -3403,67 +3530,13 @@ var ProjectRunner = class {
       } catch {
         console.log(`[task:${shortId}] Warning: git fetch failed`);
       }
-      let workDir;
-      const shouldWorktree = useWorktree === true;
-      if (shouldWorktree) {
-        workDir = ensureWorktree(this.projectDir, taskId, devBranch);
-      } else {
-        workDir = this.projectDir;
-      }
-      if (branch && branch !== devBranch) {
-        try {
-          execSync4(`git checkout ${branch}`, { cwd: workDir, stdio: "ignore" });
-        } catch {
-          try {
-            execSync4(`git checkout -b ${branch}`, { cwd: workDir, stdio: "ignore" });
-          } catch {
-            console.log(`[task:${shortId}] Warning: could not checkout branch ${branch}`);
-          }
-        }
-      }
-      const cliPath = path.resolve(__dirname, "cli.js");
-      const childEnv = { ...process.env };
-      delete childEnv.CONVEYOR_PROJECT_TOKEN;
-      delete childEnv.CONVEYOR_PROJECT_ID;
-      const child = fork(cliPath, [], {
-        env: {
-          ...childEnv,
-          CONVEYOR_API_URL: apiUrl,
-          CONVEYOR_TASK_TOKEN: taskToken,
-          CONVEYOR_TASK_ID: taskId,
-          CONVEYOR_MODE: mode,
-          CONVEYOR_WORKSPACE: workDir,
-          CONVEYOR_USE_WORKTREE: "false",
-          CONVEYOR_AGENT_MODE: isAuto ? "auto" : "",
-          CONVEYOR_IS_AUTO: isAuto ? "true" : "false",
-          CONVEYOR_USE_SANDBOX: useSandbox === true ? "true" : "false"
-        },
-        cwd: workDir,
-        stdio: ["pipe", "pipe", "pipe", "ipc"]
-      });
-      child.stdin?.on("error", () => {
-      });
-      child.stdout?.on("error", () => {
-      });
-      child.stderr?.on("error", () => {
-      });
-      child.stdout?.on("data", (data) => {
-        const lines = data.toString().trimEnd().split("\n");
-        for (const line of lines) {
-          console.log(`[task:${shortId}] ${line}`);
-        }
-      });
-      child.stderr?.on("data", (data) => {
-        const lines = data.toString().trimEnd().split("\n");
-        for (const line of lines) {
-          console.error(`[task:${shortId}] ${line}`);
-        }
-      });
+      const { workDir, usesWorktree } = setupWorkDir(this.projectDir, assignment);
+      const child = spawnChildAgent(assignment, workDir);
       this.activeAgents.set(taskId, {
         process: child,
         worktreePath: workDir,
         mode,
-        usesWorktree: shouldWorktree
+        usesWorktree
       });
       this.connection.emitTaskStarted(taskId);
       console.log(`[project-runner] Started task ${shortId} in ${mode} mode at ${workDir}`);
@@ -3472,7 +3545,7 @@ var ProjectRunner = class {
         const reason = code === 0 ? "completed" : `exited with code ${code}`;
         this.connection.emitTaskStopped(taskId, reason);
         console.log(`[project-runner] Task ${shortId} ${reason}`);
-        if (code === 0 && shouldWorktree) {
+        if (code === 0 && usesWorktree) {
           try {
             removeWorktree(this.projectDir, taskId);
           } catch {
@@ -3534,7 +3607,9 @@ var ProjectRunner = class {
     );
     await Promise.race([
       Promise.all(stopPromises),
-      new Promise((resolve2) => setTimeout(resolve2, 6e4))
+      new Promise((resolve2) => {
+        setTimeout(resolve2, 6e4);
+      })
     ]);
     this.connection.disconnect();
     console.log("[project-runner] Shutdown complete");
@@ -3612,13 +3687,13 @@ var FileCache = class {
 export {
   ConveyorConnection,
   ProjectConnection,
+  ensureWorktree,
+  removeWorktree,
   loadConveyorConfig,
   runSetupCommand,
   runStartCommand,
-  ensureWorktree,
-  removeWorktree,
   AgentRunner,
   ProjectRunner,
   FileCache
 };
-//# sourceMappingURL=chunk-NUD2M24L.js.map
+//# sourceMappingURL=chunk-7Y3RP3ZA.js.map