@rallycry/conveyor-agent 2.17.1 → 3.0.0

package/dist/{chunk-3BXPSYXX.js → chunk-5UYKPYFQ.js}

@@ -1,4 +1,4 @@
-// src/connection.ts
+// src/connection/task-connection.ts
 import { io } from "socket.io-client";
 var ConveyorConnection = class _ConveyorConnection {
   socket = null;
@@ -8,8 +8,10 @@ var ConveyorConnection = class _ConveyorConnection {
   static EVENT_BATCH_MS = 500;
   earlyMessages = [];
   earlyStop = false;
+  earlyModeChanges = [];
   chatMessageCallback = null;
   stopCallback = null;
+  modeChangeCallback = null;
   pendingQuestionResolvers = /* @__PURE__ */ new Map();
   constructor(config) {
     this.config = config;
@@ -31,16 +33,13 @@ var ConveyorConnection = class _ConveyorConnection {
           "ngrok-skip-browser-warning": "true"
         }
       });
-      this.socket.on(
-        "agentRunner:incomingMessage",
-        (msg) => {
-          if (this.chatMessageCallback) {
-            this.chatMessageCallback(msg);
-          } else {
-            this.earlyMessages.push(msg);
-          }
+      this.socket.on("agentRunner:incomingMessage", (msg) => {
+        if (this.chatMessageCallback) {
+          this.chatMessageCallback(msg);
+        } else {
+          this.earlyMessages.push(msg);
         }
-      );
+      });
       this.socket.on("agentRunner:stop", () => {
         if (this.stopCallback) {
           this.stopCallback();
@@ -48,16 +47,20 @@ var ConveyorConnection = class _ConveyorConnection {
           this.earlyStop = true;
         }
       });
-      this.socket.on(
-        "agentRunner:questionAnswer",
-        (data) => {
-          const resolver = this.pendingQuestionResolvers.get(data.requestId);
-          if (resolver) {
-            this.pendingQuestionResolvers.delete(data.requestId);
-            resolver(data.answers);
-          }
+      this.socket.on("agentRunner:questionAnswer", (data) => {
+        const resolver = this.pendingQuestionResolvers.get(data.requestId);
+        if (resolver) {
+          this.pendingQuestionResolvers.delete(data.requestId);
+          resolver(data.answers);
         }
-      );
+      });
+      this.socket.on("agentRunner:setMode", (data) => {
+        if (this.modeChangeCallback) {
+          this.modeChangeCallback(data);
+        } else {
+          this.earlyModeChanges.push(data);
+        }
+      });
       this.socket.on("connect", () => {
         if (!settled) {
           settled = true;
@@ -79,7 +82,7 @@ var ConveyorConnection = class _ConveyorConnection {
     return new Promise((resolve2, reject) => {
       socket.emit(
         "agentRunner:getChatMessages",
-        { taskId: this.config.taskId, limit },
+        { limit },
         (response) => {
           if (response.success && response.data) {
             resolve2(response.data);
@@ -96,7 +99,7 @@ var ConveyorConnection = class _ConveyorConnection {
     return new Promise((resolve2, reject) => {
       socket.emit(
         "agentRunner:getTaskFiles",
-        { taskId: this.config.taskId },
+        {},
         (response) => {
           if (response.success && response.data) {
             resolve2(response.data);
@@ -113,7 +116,7 @@ var ConveyorConnection = class _ConveyorConnection {
     return new Promise((resolve2, reject) => {
       socket.emit(
         "agentRunner:getTaskFile",
-        { taskId: this.config.taskId, fileId },
+        { fileId },
         (response) => {
           if (response.success && response.data) {
             resolve2(response.data);
@@ -130,7 +133,7 @@ var ConveyorConnection = class _ConveyorConnection {
     return new Promise((resolve2, reject) => {
       socket.emit(
         "agentRunner:getTaskContext",
-        { taskId: this.config.taskId },
+        {},
         (response) => {
           if (response.success && response.data) {
             resolve2(response.data);
@@ -143,7 +146,7 @@ var ConveyorConnection = class _ConveyorConnection {
   }
   sendEvent(event) {
     if (!this.socket) throw new Error("Not connected");
-    this.eventBuffer.push({ taskId: this.config.taskId, event });
+    this.eventBuffer.push({ event });
     if (!this.flushTimer) {
       this.flushTimer = setTimeout(() => this.flushEvents(), _ConveyorConnection.EVENT_BATCH_MS);
     }
@@ -161,17 +164,11 @@ var ConveyorConnection = class _ConveyorConnection {
   }
   updateStatus(status) {
     if (!this.socket) throw new Error("Not connected");
-    this.socket.emit("agentRunner:statusUpdate", {
-      taskId: this.config.taskId,
-      status
-    });
+    this.socket.emit("agentRunner:statusUpdate", { status });
   }
   postChatMessage(content) {
     if (!this.socket) throw new Error("Not connected");
-    this.socket.emit("agentRunner:chatMessage", {
-      taskId: this.config.taskId,
-      content
-    });
+    this.socket.emit("agentRunner:chatMessage", { content });
   }
   createPR(params) {
     const socket = this.socket;
@@ -179,7 +176,7 @@ var ConveyorConnection = class _ConveyorConnection {
     return new Promise((resolve2, reject) => {
       socket.emit(
         "agentRunner:createPR",
-        { taskId: this.config.taskId, ...params },
+        params,
         (response) => {
           if (response.success && response.data) {
             resolve2(response.data);
@@ -192,11 +189,7 @@ var ConveyorConnection = class _ConveyorConnection {
   }
   askUserQuestion(requestId, questions) {
     if (!this.socket) throw new Error("Not connected");
-    this.socket.emit("agentRunner:askUserQuestion", {
-      taskId: this.config.taskId,
-      requestId,
-      questions
-    });
+    this.socket.emit("agentRunner:askUserQuestion", { requestId, questions });
     return new Promise((resolve2) => {
       this.pendingQuestionResolvers.set(requestId, resolve2);
     });
@@ -206,17 +199,11 @@ var ConveyorConnection = class _ConveyorConnection {
   }
   storeSessionId(sessionId) {
     if (!this.socket) return;
-    this.socket.emit("agentRunner:storeSessionId", {
-      taskId: this.config.taskId,
-      sessionId
-    });
+    this.socket.emit("agentRunner:storeSessionId", { sessionId });
   }
   updateTaskFields(fields) {
     if (!this.socket) throw new Error("Not connected");
-    this.socket.emit("agentRunner:updateTaskFields", {
-      taskId: this.config.taskId,
-      fields
-    });
+    this.socket.emit("agentRunner:updateTaskFields", { fields });
   }
   onChatMessage(callback) {
     this.chatMessageCallback = callback;
@@ -232,25 +219,28 @@ var ConveyorConnection = class _ConveyorConnection {
       this.earlyStop = false;
     }
   }
+  onModeChange(callback) {
+    this.modeChangeCallback = callback;
+    for (const data of this.earlyModeChanges) {
+      callback(data);
+    }
+    this.earlyModeChanges = [];
+  }
+  emitModeChanged(mode) {
+    if (!this.socket) return;
+    this.socket.emit("agentRunner:modeChanged", { mode });
+  }
   trackSpending(params) {
     if (!this.socket) throw new Error("Not connected");
-    this.socket.emit("agentRunner:trackSpending", {
-      taskId: this.config.taskId,
-      ...params
-    });
+    this.socket.emit("agentRunner:trackSpending", params);
   }
   emitStatus(status) {
     if (!this.socket) return;
-    this.socket.emit("agentRunner:statusUpdate", {
-      taskId: this.config.taskId,
-      status
-    });
+    this.socket.emit("agentRunner:statusUpdate", { status });
   }
   sendHeartbeat() {
     if (!this.socket) return;
-    this.socket.emit("agentRunner:heartbeat", {
-      taskId: this.config.taskId
-    });
+    this.socket.emit("agentRunner:heartbeat", {});
   }
   sendTypingStart() {
     this.sendEvent({ type: "agent_typing_start" });
@@ -262,22 +252,15 @@ var ConveyorConnection = class _ConveyorConnection {
     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"));
-        }
-      );
+      socket.emit("agentRunner:createSubtask", data, (response) => {
+        if (response.success && response.data) resolve2(response.data);
+        else reject(new Error(response.error ?? "Failed to create subtask"));
+      });
     });
   }
   updateSubtask(subtaskId, fields) {
     if (!this.socket) throw new Error("Not connected");
-    this.socket.emit("agentRunner:updateSubtask", {
-      subtaskId,
-      fields
-    });
+    this.socket.emit("agentRunner:updateSubtask", { subtaskId, fields });
   }
   deleteSubtask(subtaskId) {
     if (!this.socket) throw new Error("Not connected");
@@ -287,14 +270,10 @@ var ConveyorConnection = class _ConveyorConnection {
     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"));
-        }
-      );
+      socket.emit("agentRunner:listSubtasks", {}, (response) => {
+        if (response.success && response.data) resolve2(response.data);
+        else reject(new Error(response.error ?? "Failed to list subtasks"));
+      });
     });
   }
   fetchTask(slugOrId) {
@@ -303,7 +282,7 @@ var ConveyorConnection = class _ConveyorConnection {
     return new Promise((resolve2, reject) => {
       socket.emit(
         "agentRunner:getTask",
-        { taskId: this.config.taskId, slugOrId },
+        { slugOrId },
         (response) => {
           if (response.success && response.data) {
             resolve2(response.data);
@@ -321,9 +300,157 @@ var ConveyorConnection = class _ConveyorConnection {
   }
 };
 
-// src/setup.ts
-import { execSync } from "child_process";
-import { spawn } from "child_process";
+// src/connection/project-connection.ts
+import { io as io2 } from "socket.io-client";
+var ProjectConnection = class {
+  socket = null;
+  config;
+  taskAssignmentCallback = null;
+  stopTaskCallback = null;
+  shutdownCallback = null;
+  chatMessageCallback = null;
+  earlyChatMessages = [];
+  constructor(config) {
+    this.config = config;
+  }
+  connect() {
+    return new Promise((resolve2, reject) => {
+      let settled = false;
+      let attempts = 0;
+      const maxInitialAttempts = 30;
+      this.socket = io2(this.config.apiUrl, {
+        auth: { projectToken: this.config.projectToken },
+        transports: ["websocket"],
+        reconnection: true,
+        reconnectionAttempts: Infinity,
+        reconnectionDelay: 2e3,
+        reconnectionDelayMax: 3e4,
+        randomizationFactor: 0.3,
+        extraHeaders: {
+          "ngrok-skip-browser-warning": "true"
+        }
+      });
+      this.socket.on("projectRunner:assignTask", (data) => {
+        if (this.taskAssignmentCallback) {
+          this.taskAssignmentCallback(data);
+        }
+      });
+      this.socket.on("projectRunner:stopTask", (data) => {
+        if (this.stopTaskCallback) {
+          this.stopTaskCallback(data);
+        }
+      });
+      this.socket.on("projectRunner:shutdown", () => {
+        if (this.shutdownCallback) {
+          this.shutdownCallback();
+        }
+      });
+      this.socket.on("projectRunner:incomingChatMessage", (msg) => {
+        if (this.chatMessageCallback) {
+          this.chatMessageCallback(msg);
+        } else {
+          this.earlyChatMessages.push(msg);
+        }
+      });
+      this.socket.on("connect", () => {
+        if (!settled) {
+          settled = true;
+          resolve2();
+        }
+      });
+      this.socket.io.on("reconnect_attempt", () => {
+        attempts++;
+        if (!settled && attempts >= maxInitialAttempts) {
+          settled = true;
+          reject(new Error(`Failed to connect after ${maxInitialAttempts} attempts`));
+        }
+      });
+    });
+  }
+  onTaskAssignment(callback) {
+    this.taskAssignmentCallback = callback;
+  }
+  onStopTask(callback) {
+    this.stopTaskCallback = callback;
+  }
+  onShutdown(callback) {
+    this.shutdownCallback = callback;
+  }
+  onChatMessage(callback) {
+    this.chatMessageCallback = callback;
+    for (const msg of this.earlyChatMessages) {
+      callback(msg);
+    }
+    this.earlyChatMessages = [];
+  }
+  sendHeartbeat() {
+    if (!this.socket) return;
+    this.socket.emit("projectRunner:heartbeat", {});
+  }
+  emitTaskStarted(taskId) {
+    if (!this.socket) return;
+    this.socket.emit("projectRunner:taskStarted", { taskId });
+  }
+  emitTaskStopped(taskId, reason) {
+    if (!this.socket) return;
+    this.socket.emit("projectRunner:taskStopped", { taskId, reason });
+  }
+  emitEvent(event) {
+    if (!this.socket) return;
+    this.socket.emit("conveyor:projectAgentEvent", event);
+  }
+  emitChatMessage(content) {
+    const socket = this.socket;
+    if (!socket) return Promise.reject(new Error("Not connected"));
+    return new Promise((resolve2, reject) => {
+      socket.emit(
+        "conveyor:projectAgentChatMessage",
+        { content },
+        (response) => {
+          if (response.success) resolve2();
+          else reject(new Error(response.error ?? "Failed to send chat message"));
+        }
+      );
+    });
+  }
+  emitAgentStatus(status) {
+    if (!this.socket) return;
+    this.socket.emit("conveyor:projectAgentStatus", { status });
+  }
+  fetchAgentContext() {
+    const socket = this.socket;
+    if (!socket) return Promise.reject(new Error("Not connected"));
+    return new Promise((resolve2, reject) => {
+      socket.emit(
+        "projectRunner:getAgentContext",
+        (response) => {
+          if (response.success) resolve2(response.data ?? null);
+          else reject(new Error(response.error ?? "Failed to fetch agent context"));
+        }
+      );
+    });
+  }
+  fetchChatHistory(limit) {
+    const socket = this.socket;
+    if (!socket) return Promise.reject(new Error("Not connected"));
+    return new Promise((resolve2, reject) => {
+      socket.emit(
+        "projectRunner:getChatHistory",
+        { limit },
+        (response) => {
+          if (response.success && response.data) resolve2(response.data);
+          else reject(new Error(response.error ?? "Failed to fetch chat history"));
+        }
+      );
+    });
+  }
+  disconnect() {
+    this.socket?.disconnect();
+    this.socket = null;
+  }
+};
+
+// src/setup/config.ts
 import { readFile } from "fs/promises";
 import { join } from "path";
 var CONVEYOR_CONFIG_PATH = ".conveyor/config.json";
@@ -354,6 +481,9 @@ async function loadConveyorConfig(workspaceDir) {
   }
   return null;
 }
+
+// src/setup/commands.ts
+import { spawn } from "child_process";
 function runSetupCommand(cmd, cwd, onOutput) {
   return new Promise((resolve2, reject) => {
     const child = spawn("sh", ["-c", cmd], {
@@ -395,6 +525,10 @@ function runStartCommand(cmd, cwd, onOutput) {
   child.unref();
   return child;
 }
+
+// src/setup/codespace.ts
+import { execSync } from "child_process";
+var DEVCONTAINER_PATH2 = ".devcontainer/conveyor/devcontainer.json";
 function cleanDevcontainerFromGit(workspaceDir, taskBranch, baseBranch) {
   const git = (cmd) => execSync(cmd, { cwd: workspaceDir, encoding: "utf-8", timeout: 3e4 }).trim();
   try {
@@ -403,7 +537,7 @@ function cleanDevcontainerFromGit(workspaceDir, taskBranch, baseBranch) {
     return { cleaned: false, message: `Failed to fetch origin/${baseBranch}` };
   }
   try {
-    git(`git diff --quiet origin/${baseBranch} -- ${DEVCONTAINER_PATH}`);
+    git(`git diff --quiet origin/${baseBranch} -- ${DEVCONTAINER_PATH2}`);
     return { cleaned: false, message: "devcontainer.json already matches base" };
   } catch {
   }
@@ -412,73 +546,253 @@ function cleanDevcontainerFromGit(workspaceDir, taskBranch, baseBranch) {
     if (ahead <= 1) {
       git(`git reset --hard origin/${baseBranch}`);
     } else {
-      git(`git checkout origin/${baseBranch} -- ${DEVCONTAINER_PATH}`);
-      git(`git add ${DEVCONTAINER_PATH}`);
+      git(`git checkout origin/${baseBranch} -- ${DEVCONTAINER_PATH2}`);
+      git(`git add ${DEVCONTAINER_PATH2}`);
       try {
-        git(`git diff --cached --quiet -- ${DEVCONTAINER_PATH}`);
+        git(`git diff --cached --quiet -- ${DEVCONTAINER_PATH2}`);
         return { cleaned: false, message: "devcontainer.json already clean in working tree" };
       } catch {
         git(`git commit -m "chore: reset devcontainer config"`);
       }
-    }
-    git(`git push --force-with-lease origin ${taskBranch}`);
-    return { cleaned: true, message: "devcontainer.json cleaned from git history" };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : "Unknown error";
-    return { cleaned: false, message: `Git cleanup failed: ${msg}` };
-  }
-}
-
-// src/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 {
+    }
+    try {
+      git(`git push --force-with-lease origin ${taskBranch}`);
+    } catch {
+      git(`git push --force origin ${taskBranch}`);
+    }
+    return { cleaned: true, message: "devcontainer.json cleaned from git history" };
+  } catch (err) {
+    try {
+      git(`git checkout ${taskBranch}`);
+    } catch {
+    }
+    const msg = err instanceof Error ? err.message : "Unknown error";
+    return { cleaned: false, message: `Git cleanup failed: ${msg}` };
+  }
+}
+function initRtk() {
+  try {
+    execSync("rtk --version", { stdio: "ignore" });
+    execSync("rtk init --global --auto-patch", { stdio: "ignore" });
+  } catch {
+  }
+}
+function unshallowRepo(workspaceDir) {
+  try {
+    execSync("git fetch --unshallow", {
+      cwd: workspaceDir,
+      stdio: "ignore",
+      timeout: 6e4
+    });
+  } catch {
+  }
+}
+
+// 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";
+
+// src/execution/event-processor.ts
+async function processAssistantEvent(event, host, turnToolCalls) {
+  const { content } = event.message;
+  const turnTextParts = [];
+  for (const block of content) {
+    if (block.type === "text") {
+      turnTextParts.push(block.text);
+      host.connection.sendEvent({ type: "message", content: block.text });
+      await host.callbacks.onEvent({ type: "message", content: block.text });
+    } else if (block.type === "tool_use") {
+      const inputStr = typeof block.input === "string" ? block.input : JSON.stringify(block.input);
+      const isContentTool = ["edit", "write"].includes(block.name.toLowerCase());
+      const inputLimit = isContentTool ? 1e4 : 500;
+      const summary = {
+        tool: block.name,
+        input: inputStr.slice(0, inputLimit),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      turnToolCalls.push(summary);
+      host.connection.sendEvent({ type: "tool_use", tool: block.name, input: inputStr });
+      await host.callbacks.onEvent({ type: "tool_use", tool: block.name, input: inputStr });
+    }
+  }
+  if (turnTextParts.length > 0) {
+    host.connection.postChatMessage(turnTextParts.join("\n\n"));
+  }
+  if (turnToolCalls.length > 0) {
+    host.connection.sendEvent({ type: "turn_end", toolCalls: [...turnToolCalls] });
+    turnToolCalls.length = 0;
+  }
+}
+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.";
+    if (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)) {
+      retriable = true;
+    }
+    host.connection.sendEvent({ type: "error", message: errorMsg });
+  }
+  return { totalCostUsd, retriable };
+}
+async function emitResultEvent(event, host, context, startTime) {
+  const result = handleResultEvent(event, host, context, startTime);
+  const durationMs = Date.now() - startTime;
+  if (event.subtype === "success") {
+    const successEvent = event;
+    const summary = successEvent.result || "Task completed.";
+    await host.callbacks.onEvent({
+      type: "completed",
+      summary,
+      costUsd: result.totalCostUsd,
+      durationMs
+    });
+  } else {
+    const errorEvent = event;
+    const errorMsg = errorEvent.errors.length > 0 ? errorEvent.errors.join(", ") : `Agent stopped: ${errorEvent.subtype}`;
+    await host.callbacks.onEvent({ type: "error", message: errorMsg });
+  }
+  return result.retriable;
+}
+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})`;
+    host.connection.sendEvent({ type: "error", message });
+    void host.callbacks.onEvent({ type: "error", message });
+  } 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 });
+  }
+}
+async function processEvents(events, context, host) {
+  const startTime = Date.now();
+  let sessionIdStored = false;
+  let isTyping = false;
+  let retriable = false;
+  const turnToolCalls = [];
+  for await (const event of events) {
+    if (host.isStopped()) break;
+    switch (event.type) {
+      case "system": {
+        const systemEvent = event;
+        if (systemEvent.subtype === "init") {
+          if (systemEvent.session_id && !sessionIdStored) {
+            sessionIdStored = true;
+            host.connection.storeSessionId(systemEvent.session_id);
+            context.claudeSessionId = systemEvent.session_id;
+          }
+          await host.callbacks.onEvent({
+            type: "thinking",
+            message: `Agent initialized (model: ${systemEvent.model})`
+          });
+        }
+        break;
+      }
+      case "assistant": {
+        if (!isTyping) {
+          setTimeout(() => host.connection.sendTypingStart(), 200);
+          isTyping = true;
+        }
+        await processAssistantEvent(event, host, turnToolCalls);
+        break;
+      }
+      case "result": {
+        if (isTyping) {
+          host.connection.sendTypingStop();
+          isTyping = false;
+        }
+        retriable = await emitResultEvent(event, host, context, startTime);
+        break;
+      }
+      case "rate_limit_event": {
+        handleRateLimitEvent(event, host);
+        break;
       }
     }
-    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 {
+  if (isTyping) {
+    host.connection.sendTypingStop();
   }
+  return { retriable };
 }
 
-// src/runner.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { execSync as execSync3 } from "child_process";
-import { readdirSync, statSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { join as join3 } from "path";
-
-// src/query-executor.ts
+// src/execution/query-executor.ts
 import { randomUUID } from "crypto";
-import { query } from "@anthropic-ai/claude-agent-sdk";
+import {
+  query
+} from "@anthropic-ai/claude-agent-sdk";
 
-// src/prompt-builder.ts
+// src/execution/prompt-builder.ts
 var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["InProgress", "ReviewPR", "ReviewDev", "ReviewLive"]);
 function formatFileSize(bytes) {
   if (bytes === void 0) return "";
@@ -548,7 +862,7 @@ Address the requested changes. Do NOT re-investigate the codebase from scratch o
       `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.`,
-      `Post a brief status update to the chat, then wait for further instructions.`
+      `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.`);
@@ -630,21 +944,21 @@ function buildInstructions(mode, context, scenario) {
         `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, post a summary to chat, and end your turn.`
+        `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, post a summary to chat, and end your turn. A separate task agent will execute the plan after review.`
+        `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.`,
-        `Post a brief message to chat when you begin meaningful implementation, and again when the PR is ready.`,
-        `When finished, commit your changes, push the branch, and use the create_pull_request tool to open a PR. Do NOT use gh CLI or any other method to create PRs.`
+        `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.`
       );
     }
   } else if (scenario === "idle_relaunch") {
@@ -659,7 +973,7 @@ function buildInstructions(mode, context, scenario) {
         `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.`,
-        `Post a brief status update to the chat summarizing where things stand.`,
+        `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) {
@@ -712,8 +1026,9 @@ function buildInitialPrompt(mode, context) {
   const instructions = buildInstructions(mode, context, scenario);
   return [...body, ...instructions].join("\n");
 }
-function buildSystemPrompt(mode, context, config, setupLog) {
+function buildSystemPrompt(mode, context, config, setupLog, pmSubMode = "planning") {
   const isPm = mode === "pm";
+  const isPmActive = isPm && pmSubMode === "active";
   const pmParts = [
     `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.`,
@@ -727,7 +1042,7 @@ Environment (ready, no setup required):`,
 Workflow:`,
     `- You can draft and iterate on plans in .claude/plans/*.md \u2014 these files are automatically synced to the task.`,
     `- You can also use update_task directly to save the plan to the task.`,
-    `- After saving the plan, post a summary to chat and end your turn. Do NOT attempt to execute the plan yourself.`,
+    `- 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) {
@@ -756,7 +1071,30 @@ Project Agents:`);
       pmParts.push(`- ${pa.agent.name} (${role}${sp})`);
     }
   }
-  const parts = isPm ? pmParts : [
+  const activeParts = [
+    `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 can edit files, run tests, and make commits.`,
+    `You still have access to all PM tools (subtasks, update_task, chat).`,
+    `
+Environment (ready, no setup required):`,
+    `- Repository is cloned at your current working directory.`,
+    `- You can read, write, and edit files directly.`,
+    `- You can run shell commands including git, build tools, and test runners.`,
+    context.githubBranch ? `- You are working on branch: \`${context.githubBranch}\`` : "",
+    `
+Safety rules:`,
+    `- Stay within the project directory (${config.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 /\`.`,
+    `
+Workflow:`,
+    `- You can make code changes, fix bugs, run tests, and commit directly.`,
+    `- 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 : [
     `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.`,
     `
@@ -779,8 +1117,7 @@ Git safety \u2014 STRICT rules:`,
     `- NEVER run \`git checkout main\`, \`git checkout dev\`, or switch to any branch other than \`${context.githubBranch}\`.`,
     `- NEVER create new branches (no \`git checkout -b\`, \`git switch -c\`, etc.).`,
     `- This branch was created from \`${context.baseBranch}\`. PRs will automatically target that branch.`,
-    `- If \`git push\` fails with "non-fast-forward" or similar, run \`git pull --rebase origin ${context.githubBranch}\` and retry. If that also fails, use \`git push --force-with-lease origin ${context.githubBranch}\`.`,
-    `- If you encounter merge conflicts during rebase, resolve them in place \u2014 do NOT abandon the 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.`
   ];
   if (setupLog.length > 0) {
     parts.push(
@@ -803,11 +1140,12 @@ ${config.instructions}`);
   }
   parts.push(
     `
-You have access to Conveyor MCP tools to interact with the task management system.`,
-    `Use the post_to_chat tool to communicate progress or ask questions.`,
-    `Use the read_task_chat tool to check for new messages from the team.`
+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 parent task via get_task).`,
+    `Use read_task_chat only if you need to re-read earlier messages beyond the chat context above.`
   );
-  if (!isPm) {
+  if (!isPm || isPmActive) {
     parts.push(
       `Use the create_pull_request tool to open PRs \u2014 do NOT use gh CLI or shell commands for PR creation.`
     );
@@ -815,8 +1153,11 @@ You have access to Conveyor MCP tools to interact with the task management syste
   return parts.join("\n");
 }
 
-// src/mcp-tools.ts
-import { tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
+// src/tools/index.ts
+import { createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
+
+// src/tools/common-tools.ts
+import { tool } from "@anthropic-ai/claude-agent-sdk";
 import { z } from "zod";
 function buildCommonTools(connection, config) {
   return [
@@ -842,7 +1183,7 @@ function buildCommonTools(connection, config) {
     ),
     tool(
       "post_to_chat",
-      "Post a message to the task chat visible to all team members",
+      "Post a message to the task chat. Your normal replies already appear in chat \u2014 only use this for explicit out-of-band updates or posting to a different task's chat",
       { message: z.string().describe("The message to post to the team") },
       ({ message }) => {
         connection.postChatMessage(message);
@@ -924,6 +1265,10 @@ function buildCommonTools(connection, config) {
     )
   ];
 }
+
+// src/tools/pm-tools.ts
+import { tool as tool2 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z2 } from "zod";
 function buildStoryPointDescription(storyPoints) {
   if (storyPoints && storyPoints.length > 0) {
     const tiers = storyPoints.map((sp) => `${sp.value}=${sp.name}`).join(", ");
@@ -934,12 +1279,12 @@ function buildStoryPointDescription(storyPoints) {
 function buildPmTools(connection, storyPoints) {
   const spDescription = buildStoryPointDescription(storyPoints);
   return [
-    tool(
+    tool2(
       "update_task",
       "Save the finalized task plan and/or description",
       {
-        plan: z.string().optional().describe("The task plan in markdown"),
-        description: z.string().optional().describe("Updated task description")
+        plan: z2.string().optional().describe("The task plan in markdown"),
+        description: z2.string().optional().describe("Updated task description")
       },
       async ({ plan, description }) => {
         try {
@@ -950,15 +1295,15 @@ function buildPmTools(connection, storyPoints) {
         }
       }
     ),
-    tool(
+    tool2(
       "create_subtask",
       "Create a subtask under the current parent task. Use for breaking complex tasks into smaller pieces.",
       {
-        title: z.string().describe("Subtask title"),
-        description: z.string().optional().describe("Brief description"),
-        plan: z.string().optional().describe("Implementation plan in markdown"),
-        ordinal: z.number().optional().describe("Step/order number (0-based)"),
-        storyPointValue: z.number().optional().describe(spDescription)
+        title: z2.string().describe("Subtask title"),
+        description: z2.string().optional().describe("Brief description"),
+        plan: z2.string().optional().describe("Implementation plan in markdown"),
+        ordinal: z2.number().optional().describe("Step/order number (0-based)"),
+        storyPointValue: z2.number().optional().describe(spDescription)
       },
       async (params) => {
         try {
@@ -971,16 +1316,16 @@ function buildPmTools(connection, storyPoints) {
         }
       }
     ),
-    tool(
+    tool2(
       "update_subtask",
       "Update an existing subtask's fields",
       {
-        subtaskId: z.string().describe("The subtask ID to update"),
-        title: z.string().optional(),
-        description: z.string().optional(),
-        plan: z.string().optional(),
-        ordinal: z.number().optional(),
-        storyPointValue: z.number().optional().describe(spDescription)
+        subtaskId: z2.string().describe("The subtask ID to update"),
+        title: z2.string().optional(),
+        description: z2.string().optional(),
+        plan: z2.string().optional(),
+        ordinal: z2.number().optional(),
+        storyPointValue: z2.number().optional().describe(spDescription)
       },
       async ({ subtaskId, ...fields }) => {
         try {
@@ -991,10 +1336,10 @@ function buildPmTools(connection, storyPoints) {
         }
       }
     ),
-    tool(
+    tool2(
       "delete_subtask",
       "Delete a subtask",
-      { subtaskId: z.string().describe("The subtask ID to delete") },
+      { subtaskId: z2.string().describe("The subtask ID to delete") },
       async ({ subtaskId }) => {
         try {
           await Promise.resolve(connection.deleteSubtask(subtaskId));
@@ -1004,7 +1349,7 @@ function buildPmTools(connection, storyPoints) {
         }
       }
     ),
-    tool(
+    tool2(
       "list_subtasks",
       "List all subtasks under the current parent task",
       {},
@@ -1020,14 +1365,18 @@ function buildPmTools(connection, storyPoints) {
     )
   ];
 }
+
+// src/tools/task-tools.ts
+import { tool as tool3 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z3 } from "zod";
 function buildTaskTools(connection) {
   return [
-    tool(
+    tool3(
       "create_pull_request",
       "Create a GitHub pull request for this task. Use this instead of gh CLI or git commands to create PRs.",
       {
-        title: z.string().describe("The PR title"),
-        body: z.string().describe("The PR description/body in markdown")
+        title: z3.string().describe("The PR title"),
+        body: z3.string().describe("The PR description/body in markdown")
       },
       async ({ title, body }) => {
         try {
@@ -1046,6 +1395,8 @@ function buildTaskTools(connection) {
     )
   ];
 }
+
+// src/tools/index.ts
 function textResult(text) {
   return { content: [{ type: "text", text }] };
 }
@@ -1058,144 +1409,17 @@ function createConveyorMcpServer(connection, config, context) {
   });
 }
 
-// src/query-executor.ts
-var API_ERROR_PATTERN = /API Error: [45]\d\d/;
+// src/execution/query-executor.ts
+var API_ERROR_PATTERN2 = /API Error: [45]\d\d/;
 var RETRY_DELAYS_MS = [6e4, 12e4, 18e4, 3e5];
 var PM_PLAN_FILE_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "MultiEdit"]);
-async function processAssistantEvent(event, host, turnToolCalls) {
-  const msg = event.message;
-  const content = msg.content;
-  const turnTextParts = [];
-  for (const block of content) {
-    const blockType = block.type;
-    if (blockType === "text") {
-      const text = block.text;
-      turnTextParts.push(text);
-      host.connection.sendEvent({ type: "message", content: text });
-      await host.callbacks.onEvent({ type: "message", content: text });
-    } else if (blockType === "tool_use") {
-      const name = block.name;
-      const inputStr = typeof block.input === "string" ? block.input : JSON.stringify(block.input);
-      const isContentTool = ["edit", "write"].includes(name.toLowerCase());
-      const inputLimit = isContentTool ? 1e4 : 500;
-      const summary = {
-        tool: name,
-        input: inputStr.slice(0, inputLimit),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      turnToolCalls.push(summary);
-      host.connection.sendEvent({ type: "tool_use", tool: name, input: inputStr });
-      await host.callbacks.onEvent({ type: "tool_use", tool: name, input: inputStr });
-    }
-  }
-  if (turnTextParts.length > 0) {
-    host.connection.postChatMessage(turnTextParts.join("\n\n"));
-  }
-  if (turnToolCalls.length > 0) {
-    host.connection.sendEvent({ type: "turn_end", toolCalls: [...turnToolCalls] });
-    turnToolCalls.length = 0;
-  }
-}
-function handleResultEvent(event, host, context, startTime) {
-  const resultEvent = event;
-  let totalCostUsd = 0;
-  let retriable = false;
-  if (resultEvent.subtype === "success") {
-    totalCostUsd = "total_cost_usd" in resultEvent ? resultEvent.total_cost_usd : 0;
-    const durationMs = Date.now() - startTime;
-    const summary = "result" in resultEvent ? String(resultEvent.result) : "Task completed.";
-    if (API_ERROR_PATTERN.test(summary) && durationMs < 3e4) {
-      retriable = true;
-    }
-    host.connection.sendEvent({ type: "completed", summary, costUsd: totalCostUsd, durationMs });
-    if (totalCostUsd > 0 && context.agentId && context._runnerSessionId) {
-      host.connection.trackSpending({
-        agentId: context.agentId,
-        sessionId: context._runnerSessionId,
-        totalCostUsd,
-        onSubscription: host.config.mode === "pm" || !!process.env.CLAUDE_CODE_OAUTH_TOKEN
-      });
-    }
-  } else {
-    const errors = "errors" in resultEvent ? resultEvent.errors : [];
-    const errorMsg = errors.length > 0 ? errors.join(", ") : `Agent stopped: ${resultEvent.subtype}`;
-    if (API_ERROR_PATTERN.test(errorMsg)) {
-      retriable = true;
-    }
-    host.connection.sendEvent({ type: "error", message: errorMsg });
-  }
-  return { totalCostUsd, retriable };
-}
-async function emitResultEvent(event, host, context, startTime) {
-  const result = handleResultEvent(event, host, context, startTime);
-  const durationMs = Date.now() - startTime;
-  const resultEvent = event;
-  if (resultEvent.subtype === "success") {
-    const summary = "result" in resultEvent ? String(resultEvent.result) : "Task completed.";
-    await host.callbacks.onEvent({
-      type: "completed",
-      summary,
-      costUsd: result.totalCostUsd,
-      durationMs
-    });
-  } else {
-    const errors = "errors" in resultEvent ? resultEvent.errors : [];
-    const errorMsg = errors.length > 0 ? errors.join(", ") : `Agent stopped: ${resultEvent.subtype}`;
-    await host.callbacks.onEvent({ type: "error", message: errorMsg });
-  }
-  return result.retriable;
-}
-async function processEvents(events, context, host) {
-  const startTime = Date.now();
-  let sessionIdStored = false;
-  let isTyping = false;
-  let retriable = false;
-  const turnToolCalls = [];
-  for await (const event of events) {
-    if (host.isStopped()) break;
-    switch (event.type) {
-      case "system": {
-        if (event.subtype === "init") {
-          const sessionId = event.session_id;
-          if (sessionId && !sessionIdStored) {
-            sessionIdStored = true;
-            host.connection.storeSessionId(sessionId);
-            context.claudeSessionId = sessionId;
-          }
-          await host.callbacks.onEvent({
-            type: "thinking",
-            message: `Agent initialized (model: ${event.model})`
-          });
-        }
-        break;
-      }
-      case "assistant": {
-        if (!isTyping) {
-          setTimeout(() => host.connection.sendTypingStart(), 200);
-          isTyping = true;
-        }
-        await processAssistantEvent(event, host, turnToolCalls);
-        break;
-      }
-      case "result": {
-        if (isTyping) {
-          host.connection.sendTypingStop();
-          isTyping = false;
-        }
-        retriable = await emitResultEvent(event, host, context, startTime);
-        break;
-      }
-    }
-  }
-  if (isTyping) {
-    host.connection.sendTypingStop();
-  }
-  return { retriable };
-}
+var DESTRUCTIVE_CMD_PATTERN = /git\s+push\s+--force(?!\s*-with-lease)|git\s+reset\s+--hard|rm\s+-rf\s+\//;
 function buildCanUseTool(host) {
   const QUESTION_TIMEOUT_MS = 5 * 60 * 1e3;
   return async (toolName, input) => {
-    if (host.config.mode === "pm" && PM_PLAN_FILE_TOOLS.has(toolName)) {
+    const isPmPlanning = host.config.mode === "pm" && host.activeMode === "planning";
+    const isPmActive = host.config.mode === "pm" && host.activeMode === "active";
+    if (isPmPlanning && PM_PLAN_FILE_TOOLS.has(toolName)) {
       const filePath = String(input.file_path ?? input.path ?? "");
       if (filePath.includes(".claude/plans/")) {
         return { behavior: "allow", updatedInput: input };
@@ -1205,6 +1429,15 @@ function buildCanUseTool(host) {
         message: "File write tools are only available for plan files in PM mode."
       };
     }
+    if (isPmActive && toolName === "Bash") {
+      const cmd = String(input.command ?? "");
+      if (DESTRUCTIVE_CMD_PATTERN.test(cmd)) {
+        return {
+          behavior: "deny",
+          message: "Destructive operation blocked in active mode. Use safer alternatives."
+        };
+      }
+    }
     if (toolName !== "AskUserQuestion") {
       return { behavior: "allow", updatedInput: input };
     }
@@ -1233,13 +1466,41 @@ function buildCanUseTool(host) {
 }
 function buildQueryOptions(host, context) {
   const settings = context.agentSettings ?? host.config.agentSettings ?? {};
-  const systemPromptText = buildSystemPrompt(host.config.mode, context, host.config, host.setupLog);
+  const isPmActive = host.config.mode === "pm" && host.activeMode === "active";
+  const systemPromptText = buildSystemPrompt(
+    host.config.mode,
+    context,
+    host.config,
+    host.setupLog,
+    isPmActive ? "active" : "planning"
+  );
   const conveyorMcp = createConveyorMcpServer(host.connection, host.config, context);
   const isPm = host.config.mode === "pm";
-  const pmDisallowedTools = isPm ? ["TodoWrite", "TodoRead", "NotebookEdit"] : [];
+  const pmDisallowedTools = isPm && !isPmActive ? ["TodoWrite", "TodoRead", "NotebookEdit"] : [];
   const disallowedTools = [...settings.disallowedTools ?? [], ...pmDisallowedTools];
   const settingSources = settings.settingSources ?? ["user", "project"];
-  return {
+  const hooks = {
+    PostToolUse: [
+      {
+        hooks: [
+          async (input) => {
+            if (input.hook_event_name === "PostToolUse") {
+              const output = typeof input.tool_response === "string" ? input.tool_response.slice(0, 500) : JSON.stringify(input.tool_response).slice(0, 500);
+              host.connection.sendEvent({
+                type: "tool_result",
+                tool: input.tool_name,
+                output,
+                isError: false
+              });
+            }
+            return { continue: true };
+          }
+        ],
+        timeout: 5
+      }
+    ]
+  };
+  const baseOptions = {
     model: context.model || host.config.model,
     systemPrompt: {
       type: "preset",
@@ -1248,11 +1509,12 @@ function buildQueryOptions(host, context) {
     },
     settingSources,
     cwd: host.config.workspaceDir,
-    permissionMode: "bypassPermissions",
-    allowDangerouslySkipPermissions: true,
+    permissionMode: isPmActive ? "acceptEdits" : "bypassPermissions",
+    allowDangerouslySkipPermissions: !isPmActive,
     canUseTool: buildCanUseTool(host),
     tools: { type: "preset", preset: "claude_code" },
     mcpServers: { conveyor: conveyorMcp },
+    hooks,
     maxTurns: settings.maxTurns,
     effort: settings.effort,
     thinking: settings.thinking,
@@ -1261,6 +1523,25 @@ function buildQueryOptions(host, context) {
     disallowedTools: disallowedTools.length > 0 ? disallowedTools : void 0,
     enableFileCheckpointing: settings.enableFileCheckpointing
   };
+  if (isPmActive) {
+    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
+      }
+    };
+  }
+  return baseOptions;
 }
 function buildMultimodalPrompt(textPrompt, context) {
   const taskImages = (context.files ?? []).filter(
@@ -1309,25 +1590,40 @@ function buildMultimodalPrompt(textPrompt, context) {
 async function runSdkQuery(host, context, followUpContent) {
   if (host.isStopped()) return;
   const isPm = host.config.mode === "pm";
-  if (isPm) {
+  const isPmPlanning = isPm && host.activeMode === "planning";
+  if (isPmPlanning) {
     host.snapshotPlanFiles();
   }
   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 = isPm ? `${buildInitialPrompt(host.config.mode, context)}
 
 ---
 
 The team says:
-${followUpContent}` : followUpContent;
-    const prompt = isPm ? buildMultimodalPrompt(textPrompt, context) : textPrompt;
+${followUpText}` : followUpText;
+    let prompt;
+    if (isPm) {
+      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 agentQuery = query({
       prompt: typeof prompt === "string" ? prompt : host.createInputStream(prompt),
       options: { ...options, resume }
     });
     await runWithRetry(agentQuery, context, host, options);
-  } else if (isPm) {
+  } else if (isPmPlanning) {
     return;
   } else {
     const initialPrompt = buildInitialPrompt(host.config.mode, context);
@@ -1338,7 +1634,7 @@ ${followUpContent}` : followUpContent;
     });
     await runWithRetry(agentQuery, context, host, options);
   }
-  if (isPm) {
+  if (isPmPlanning) {
     host.syncPlanFile();
   }
 }
@@ -1373,7 +1669,7 @@ async function runWithRetry(initialQuery, context, host, options) {
         });
         return runWithRetry(freshQuery, context, host, options);
       }
-      const isApiError = error instanceof Error && API_ERROR_PATTERN.test(error.message);
+      const isApiError = error instanceof Error && API_ERROR_PATTERN2.test(error.message);
       if (!isApiError) throw error;
     }
     if (attempt >= RETRY_DELAYS_MS.length) {
@@ -1407,9 +1703,131 @@ async function runWithRetry(initialQuery, context, host, options) {
     host.connection.emitStatus("running");
     await host.callbacks.onStatusChange("running");
   }
-}
+}
+
+// src/execution/cost-tracker.ts
+var CostTracker = class {
+  cumulativeCostUsd = 0;
+  modelUsage = /* @__PURE__ */ new Map();
+  /** Add cost from a completed query and return the running total */
+  addQueryCost(queryCostUsd) {
+    this.cumulativeCostUsd += queryCostUsd;
+    return this.cumulativeCostUsd;
+  }
+  /** Merge per-model usage from a completed query */
+  addModelUsage(usage) {
+    for (const [model, data] of Object.entries(usage)) {
+      const existing = this.modelUsage.get(model) ?? {
+        model,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadInputTokens: 0,
+        cacheCreationInputTokens: 0,
+        costUSD: 0
+      };
+      existing.inputTokens += data.inputTokens ?? 0;
+      existing.outputTokens += data.outputTokens ?? 0;
+      existing.cacheReadInputTokens += data.cacheReadInputTokens ?? 0;
+      existing.cacheCreationInputTokens += data.cacheCreationInputTokens ?? 0;
+      existing.costUSD += data.costUSD ?? 0;
+      this.modelUsage.set(model, existing);
+    }
+  }
+  get totalCostUsd() {
+    return this.cumulativeCostUsd;
+  }
+  get modelBreakdown() {
+    return [...this.modelUsage.values()];
+  }
+};
+
+// src/runner/plan-sync.ts
+import { readdirSync, statSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join as join3 } from "path";
+var PlanSync = class {
+  planFileSnapshot = /* @__PURE__ */ new Map();
+  lockedPlanFile = null;
+  workspaceDir;
+  connection;
+  constructor(workspaceDir, connection) {
+    this.workspaceDir = workspaceDir;
+    this.connection = connection;
+  }
+  updateWorkspaceDir(workspaceDir) {
+    this.workspaceDir = workspaceDir;
+  }
+  getPlanDirs() {
+    return [join3(homedir(), ".claude", "plans"), join3(this.workspaceDir, ".claude", "plans")];
+  }
+  snapshotPlanFiles() {
+    this.planFileSnapshot.clear();
+    this.lockedPlanFile = null;
+    for (const plansDir of this.getPlanDirs()) {
+      try {
+        for (const file of readdirSync(plansDir).filter((f) => f.endsWith(".md"))) {
+          try {
+            const fullPath = join3(plansDir, file);
+            const stat = statSync(fullPath);
+            this.planFileSnapshot.set(fullPath, stat.mtimeMs);
+          } catch {
+            continue;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  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;
+    }
+    let newest = null;
+    for (const plansDir of this.getPlanDirs()) {
+      let files;
+      try {
+        files = readdirSync(plansDir).filter((f) => f.endsWith(".md"));
+      } catch {
+        continue;
+      }
+      for (const file of files) {
+        const fullPath = join3(plansDir, file);
+        try {
+          const stat = statSync(fullPath);
+          const prevMtime = this.planFileSnapshot.get(fullPath);
+          const isNew = prevMtime === void 0 || stat.mtimeMs > prevMtime;
+          if (isNew && (!newest || stat.mtimeMs > newest.mtime)) {
+            newest = { path: fullPath, mtime: stat.mtimeMs };
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+    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();
+        this.connection.postChatMessage(
+          `Detected local plan file (${fileName}) and synced it to the task plan.`
+        );
+      }
+    }
+  }
+};
 
-// src/runner.ts
+// src/runner/agent-runner.ts
 var HEARTBEAT_INTERVAL_MS = 3e4;
 var AgentRunner = class _AgentRunner {
   config;
@@ -1422,14 +1840,16 @@ var AgentRunner = class _AgentRunner {
   setupLog = [];
   heartbeatTimer = null;
   taskContext = null;
-  planFileSnapshot = /* @__PURE__ */ new Map();
-  lockedPlanFile = null;
+  planSync;
+  costTracker = new CostTracker();
   worktreeActive = false;
+  activeMode = "planning";
   static MAX_SETUP_LOG_LINES = 50;
   constructor(config, callbacks) {
     this.config = config;
     this.connection = new ConveyorConnection(config);
     this.callbacks = callbacks;
+    this.planSync = new PlanSync(config.workspaceDir, this.connection);
   }
   get state() {
     return this._state;
@@ -1459,6 +1879,7 @@ var AgentRunner = class _AgentRunner {
     this.connection.onChatMessage(
       (message) => this.injectHumanMessage(message.content, message.files)
     );
+    this.connection.onModeChange((data) => this.handleModeChange(data.mode));
     await this.setState("connected");
     this.connection.sendEvent({ type: "connected", taskId: this.config.taskId });
     this.startHeartbeat();
@@ -1471,11 +1892,12 @@ var AgentRunner = class _AgentRunner {
         return;
       }
     }
-    this.initRtk();
+    initRtk();
     if (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) {
@@ -1496,6 +1918,10 @@ var AgentRunner = class _AgentRunner {
       return;
     }
     this.taskContext._runnerSessionId = randomUUID2();
+    this.logEffectiveSettings();
+    if (process.env.CODESPACES === "true") {
+      unshallowRepo(this.config.workspaceDir);
+    }
     if (process.env.CODESPACES === "true" && this.taskContext.baseBranch) {
       const result = cleanDevcontainerFromGit(
         this.config.workspaceDir,
@@ -1510,6 +1936,7 @@ var AgentRunner = class _AgentRunner {
       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) {
@@ -1593,6 +2020,24 @@ The agent cannot start until this is resolved.`
       return false;
     }
   }
+  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 parts = [
+      `model=${model}`,
+      `mode=${this.config.mode ?? "task"}`,
+      `effort=${s.effort ?? "default"}`,
+      `thinking=${thinking}`,
+      `maxBudget=$${s.maxBudgetUsd ?? 50}`,
+      `maxTurns=${s.maxTurns ?? "unlimited"}`
+    ];
+    if (s.betas?.length) parts.push(`betas=${s.betas.join(",")}`);
+    if (s.disallowedTools?.length) parts.push(`disallowed=[${s.disallowedTools.join(",")}]`);
+    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) {
@@ -1617,13 +2062,6 @@ The agent cannot start until this is resolved.`
       });
     }
   }
-  initRtk() {
-    try {
-      execSync3("rtk --version", { stdio: "ignore" });
-      execSync3("rtk init --global --auto-patch", { stdio: "ignore" });
-    } catch {
-    }
-  }
   injectHumanMessage(content, files) {
     let messageContent;
     if (files?.length) {
@@ -1689,11 +2127,15 @@ ${f.content}
   async waitForUserContent() {
     if (this.pendingMessages.length > 0) {
       const next = this.pendingMessages.shift();
-      return next?.message?.content ?? null;
+      const content2 = next?.message.content;
+      if (!content2) return null;
+      return content2;
     }
     const msg = await this.waitForMessage();
     if (!msg) return null;
-    return msg.message.content;
+    const content = msg.message.content;
+    if (!content) return null;
+    return content;
   }
   async *createInputStream(initialPrompt) {
     const makeUserMessage = (content) => ({
@@ -1718,93 +2160,31 @@ ${f.content}
       yield msg;
     }
   }
-  getPlanDirs() {
-    return [
-      join3(homedir(), ".claude", "plans"),
-      join3(this.config.workspaceDir, ".claude", "plans")
-    ];
-  }
-  /**
-   * Snapshot current plan files so syncPlanFile can distinguish files created
-   * by THIS session from ones created by a concurrent agent.
-   */
-  snapshotPlanFiles() {
-    this.planFileSnapshot.clear();
-    this.lockedPlanFile = null;
-    for (const plansDir of this.getPlanDirs()) {
-      try {
-        for (const file of readdirSync(plansDir).filter((f) => f.endsWith(".md"))) {
-          try {
-            const fullPath = join3(plansDir, file);
-            const stat = statSync(fullPath);
-            this.planFileSnapshot.set(fullPath, stat.mtimeMs);
-          } catch {
-            continue;
-          }
-        }
-      } catch {
-      }
-    }
-  }
-  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;
-    }
-    let newest = null;
-    for (const plansDir of this.getPlanDirs()) {
-      let files;
-      try {
-        files = readdirSync(plansDir).filter((f) => f.endsWith(".md"));
-      } catch {
-        continue;
-      }
-      for (const file of files) {
-        const fullPath = join3(plansDir, file);
-        try {
-          const stat = statSync(fullPath);
-          const prevMtime = this.planFileSnapshot.get(fullPath);
-          const isNew = prevMtime === void 0 || stat.mtimeMs > prevMtime;
-          if (isNew && (!newest || stat.mtimeMs > newest.mtime)) {
-            newest = { path: fullPath, mtime: stat.mtimeMs };
-          }
-        } catch {
-          continue;
-        }
-      }
-    }
-    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();
-        this.connection.postChatMessage(
-          `Detected local plan file (${fileName}) and synced it to the task plan.`
-        );
-      }
-    }
-  }
   asQueryHost() {
+    const getActiveMode = () => this.activeMode;
     return {
       config: this.config,
       connection: this.connection,
       callbacks: this.callbacks,
       setupLog: this.setupLog,
+      costTracker: this.costTracker,
+      get activeMode() {
+        return getActiveMode();
+      },
       isStopped: () => this.stopped,
       createInputStream: (prompt) => this.createInputStream(prompt),
-      snapshotPlanFiles: () => this.snapshotPlanFiles(),
-      syncPlanFile: () => this.syncPlanFile()
+      snapshotPlanFiles: () => this.planSync.snapshotPlanFiles(),
+      syncPlanFile: () => this.planSync.syncPlanFile()
     };
   }
+  handleModeChange(mode) {
+    if (this.config.mode !== "pm") return;
+    this.activeMode = mode;
+    this.connection.emitModeChanged(mode);
+    this.connection.postChatMessage(
+      `Mode switched to **${mode}**${mode === "active" ? " \u2014 I now have direct coding access." : " \u2014 back to planning only."}`
+    );
+  }
   stop() {
     this.stopped = true;
     if (this.inputResolver) {
@@ -1814,163 +2194,13 @@ ${f.content}
   }
 };
 
-// src/project-connection.ts
-import { io as io2 } from "socket.io-client";
-var ProjectConnection = class {
-  socket = null;
-  config;
-  taskAssignmentCallback = null;
-  stopTaskCallback = null;
-  shutdownCallback = null;
-  chatMessageCallback = null;
-  earlyChatMessages = [];
-  constructor(config) {
-    this.config = config;
-  }
-  connect() {
-    return new Promise((resolve2, reject) => {
-      let settled = false;
-      let attempts = 0;
-      const maxInitialAttempts = 30;
-      this.socket = io2(this.config.apiUrl, {
-        auth: { projectToken: this.config.projectToken },
-        transports: ["websocket"],
-        reconnection: true,
-        reconnectionAttempts: Infinity,
-        reconnectionDelay: 2e3,
-        reconnectionDelayMax: 3e4,
-        randomizationFactor: 0.3,
-        extraHeaders: {
-          "ngrok-skip-browser-warning": "true"
-        }
-      });
-      this.socket.on("projectRunner:assignTask", (data) => {
-        if (this.taskAssignmentCallback) {
-          this.taskAssignmentCallback(data);
-        }
-      });
-      this.socket.on("projectRunner:stopTask", (data) => {
-        if (this.stopTaskCallback) {
-          this.stopTaskCallback(data);
-        }
-      });
-      this.socket.on("projectRunner:shutdown", () => {
-        if (this.shutdownCallback) {
-          this.shutdownCallback();
-        }
-      });
-      this.socket.on("projectRunner:incomingChatMessage", (msg) => {
-        if (this.chatMessageCallback) {
-          this.chatMessageCallback(msg);
-        } else {
-          this.earlyChatMessages.push(msg);
-        }
-      });
-      this.socket.on("connect", () => {
-        if (!settled) {
-          settled = true;
-          resolve2();
-        }
-      });
-      this.socket.io.on("reconnect_attempt", () => {
-        attempts++;
-        if (!settled && attempts >= maxInitialAttempts) {
-          settled = true;
-          reject(new Error(`Failed to connect after ${maxInitialAttempts} attempts`));
-        }
-      });
-    });
-  }
-  onTaskAssignment(callback) {
-    this.taskAssignmentCallback = callback;
-  }
-  onStopTask(callback) {
-    this.stopTaskCallback = callback;
-  }
-  onShutdown(callback) {
-    this.shutdownCallback = callback;
-  }
-  onChatMessage(callback) {
-    this.chatMessageCallback = callback;
-    for (const msg of this.earlyChatMessages) {
-      callback(msg);
-    }
-    this.earlyChatMessages = [];
-  }
-  sendHeartbeat() {
-    if (!this.socket) return;
-    this.socket.emit("projectRunner:heartbeat", {});
-  }
-  emitTaskStarted(taskId) {
-    if (!this.socket) return;
-    this.socket.emit("projectRunner:taskStarted", { taskId });
-  }
-  emitTaskStopped(taskId, reason) {
-    if (!this.socket) return;
-    this.socket.emit("projectRunner:taskStopped", { taskId, reason });
-  }
-  emitEvent(event) {
-    if (!this.socket) return;
-    this.socket.emit("conveyor:projectAgentEvent", event);
-  }
-  emitChatMessage(content) {
-    const socket = this.socket;
-    if (!socket) return Promise.reject(new Error("Not connected"));
-    return new Promise((resolve2, reject) => {
-      socket.emit(
-        "conveyor:projectAgentChatMessage",
-        { content },
-        (response) => {
-          if (response.success) resolve2();
-          else reject(new Error(response.error ?? "Failed to send chat message"));
-        }
-      );
-    });
-  }
-  emitAgentStatus(status) {
-    if (!this.socket) return;
-    this.socket.emit("conveyor:projectAgentStatus", { status });
-  }
-  fetchAgentContext() {
-    const socket = this.socket;
-    if (!socket) return Promise.reject(new Error("Not connected"));
-    return new Promise((resolve2, reject) => {
-      socket.emit(
-        "projectRunner:getAgentContext",
-        (response) => {
-          if (response.success) resolve2(response.data ?? null);
-          else reject(new Error(response.error ?? "Failed to fetch agent context"));
-        }
-      );
-    });
-  }
-  fetchChatHistory(limit) {
-    const socket = this.socket;
-    if (!socket) return Promise.reject(new Error("Not connected"));
-    return new Promise((resolve2, reject) => {
-      socket.emit(
-        "projectRunner:getChatHistory",
-        { limit },
-        (response) => {
-          if (response.success && response.data) resolve2(response.data);
-          else reject(new Error(response.error ?? "Failed to fetch chat history"));
-        }
-      );
-    });
-  }
-  disconnect() {
-    this.socket?.disconnect();
-    this.socket = null;
-  }
-};
-
-// src/project-runner.ts
+// src/runner/project-runner.ts
 import { fork } from "child_process";
 import { execSync as execSync4 } from "child_process";
 import * as path from "path";
 import { fileURLToPath } from "url";
 
-// src/project-chat-handler.ts
+// src/runner/project-chat-handler.ts
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
 var FALLBACK_MODEL = "claude-sonnet-4-20250514";
 function buildSystemPrompt2(projectDir, agentCtx) {
@@ -2056,33 +2286,31 @@ async function handleProjectChatMessage(message, connection, projectDir) {
     const turnToolCalls = [];
     let isTyping = false;
     for await (const event of events) {
-      const eventType = event.type;
-      if (eventType === "assistant") {
+      if (event.type === "assistant") {
         if (!isTyping) {
           setTimeout(() => connection.emitEvent({ type: "agent_typing_start" }), 200);
           isTyping = true;
         }
-        const msg = event.message;
-        const content = msg.content;
+        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 name = block.name;
             const inputStr = typeof block.input === "string" ? block.input : JSON.stringify(block.input);
             turnToolCalls.push({
-              tool: name,
+              tool: block.name,
               input: inputStr.slice(0, 1e4),
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
-            console.log(`[project-chat] [tool_use] ${name}`);
+            console.log(`[project-chat] [tool_use] ${block.name}`);
           }
         }
         if (turnToolCalls.length > 0) {
           connection.emitEvent({ type: "activity_block", events: [...turnToolCalls] });
           turnToolCalls.length = 0;
         }
-      } else if (eventType === "result") {
+      } else if (event.type === "result") {
         if (isTyping) {
           connection.emitEvent({ type: "agent_typing_stop" });
           isTyping = false;
@@ -2113,7 +2341,7 @@ async function handleProjectChatMessage(message, connection, projectDir) {
   }
 }
 
-// src/project-runner.ts
+// src/runner/project-runner.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path.dirname(__filename);
 var HEARTBEAT_INTERVAL_MS2 = 3e4;
@@ -2300,15 +2528,80 @@ var ProjectRunner = class {
   }
 };
 
+// src/runner/file-cache.ts
+var DEFAULT_MAX_SIZE_BYTES = 50 * 1024 * 1024;
+var DEFAULT_TTL_MS = 60 * 60 * 1e3;
+var FileCache = class {
+  cache = /* @__PURE__ */ new Map();
+  currentSize = 0;
+  maxSizeBytes;
+  ttlMs;
+  constructor(maxSizeBytes = DEFAULT_MAX_SIZE_BYTES, ttlMs = DEFAULT_TTL_MS) {
+    this.maxSizeBytes = maxSizeBytes;
+    this.ttlMs = ttlMs;
+  }
+  get(fileId) {
+    const entry = this.cache.get(fileId);
+    if (!entry) return null;
+    if (Date.now() - entry.createdAt > this.ttlMs) {
+      this.delete(fileId);
+      return null;
+    }
+    this.cache.delete(fileId);
+    this.cache.set(fileId, entry);
+    return entry;
+  }
+  set(fileId, content, mimeType, fileName) {
+    if (this.cache.has(fileId)) {
+      this.delete(fileId);
+    }
+    const size = content.byteLength;
+    if (size > this.maxSizeBytes) return;
+    while (this.currentSize + size > this.maxSizeBytes && this.cache.size > 0) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== void 0) {
+        this.delete(oldestKey);
+      }
+    }
+    this.cache.set(fileId, {
+      content,
+      mimeType,
+      fileName,
+      createdAt: Date.now(),
+      size
+    });
+    this.currentSize += size;
+  }
+  delete(fileId) {
+    const entry = this.cache.get(fileId);
+    if (entry) {
+      this.currentSize -= entry.size;
+      this.cache.delete(fileId);
+    }
+  }
+  clear() {
+    this.cache.clear();
+    this.currentSize = 0;
+  }
+  get stats() {
+    return {
+      entries: this.cache.size,
+      sizeBytes: this.currentSize,
+      maxSizeBytes: this.maxSizeBytes
+    };
+  }
+};
+
 export {
   ConveyorConnection,
+  ProjectConnection,
   loadConveyorConfig,
   runSetupCommand,
   runStartCommand,
   ensureWorktree,
   removeWorktree,
   AgentRunner,
-  ProjectConnection,
-  ProjectRunner
+  ProjectRunner,
+  FileCache
 };
-//# sourceMappingURL=chunk-3BXPSYXX.js.map
+//# sourceMappingURL=chunk-5UYKPYFQ.js.map