@rallycry/conveyor-agent 6.0.2 → 6.0.4

package/dist/{chunk-HYWZJYPW.js → chunk-NKZSUGND.js}

@@ -179,6 +179,7 @@ var ConveyorConnection = class _ConveyorConnection {
   constructor(config) {
     this.config = config;
   }
+  // oxlint-disable-next-line max-lines-per-function -- socket setup requires registering many event handlers
   connect() {
     return new Promise((resolve2, reject) => {
       let settled = false;
@@ -220,16 +221,42 @@ var ConveyorConnection = class _ConveyorConnection {
       this.socket.on("agentRunner:runStartCommand", () => {
         if (this.runStartCommandCallback) this.runStartCommandCallback();
       });
+      this.socket.on("agentRunner:wake", () => {
+        if (this.chatMessageCallback) {
+          this.chatMessageCallback({ content: "", userId: "system" });
+        }
+      });
+      this.socket.on("agentRunner:updateApiKey", (data) => {
+        process.env.ANTHROPIC_API_KEY = data.apiKey;
+      });
       this.socket.on(
         "agentRunner:runAuthTokenCommand",
         (data, cb) => this.handleRunAuthTokenCommand(data.userEmail, cb)
       );
       this.socket.on("connect", () => {
+        process.stderr.write(`[conveyor] Socket connected
+`);
         if (!settled) {
           settled = true;
           resolve2();
         }
       });
+      this.socket.on("connect_error", (err) => {
+        process.stderr.write(`[conveyor] Socket connection error: ${err.message}
+`);
+      });
+      this.socket.on("disconnect", (reason) => {
+        process.stderr.write(`[conveyor] Socket disconnected: ${reason}
+`);
+      });
+      this.socket.io.on("reconnect", (attempt) => {
+        process.stderr.write(`[conveyor] Reconnected after ${attempt} attempt(s)
+`);
+      });
+      this.socket.io.on("reconnect_error", (err) => {
+        process.stderr.write(`[conveyor] Reconnection error: ${err.message}
+`);
+      });
       this.socket.io.on("reconnect_attempt", () => {
         attempts++;
         if (!settled && attempts >= maxInitialAttempts) {
@@ -427,10 +454,39 @@ var ConveyorConnection = class _ConveyorConnection {
   triggerIdentification() {
     return triggerIdentification(this.socket);
   }
+  async refreshAuthToken() {
+    const codespaceName = process.env.CODESPACE_NAME;
+    const apiUrl = process.env.CONVEYOR_API_URL ?? this.config.conveyorApiUrl;
+    if (!codespaceName || !apiUrl) return false;
+    try {
+      const response = await fetch(`${apiUrl}/api/codespace/bootstrap/${codespaceName}`);
+      if (!response.ok) return false;
+      const config = await response.json();
+      if (config.envVars?.CLAUDE_CODE_OAUTH_TOKEN) {
+        process.env.CLAUDE_CODE_OAUTH_TOKEN = config.envVars.CLAUDE_CODE_OAUTH_TOKEN;
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
   emitModeTransition(payload) {
     if (!this.socket) return;
     this.socket.emit("agentRunner:modeTransition", payload);
   }
+  emitDebugStateChanged(state) {
+    if (!this.socket) return;
+    this.socket.emit("agentRunner:debugStateChanged", { state });
+  }
+  emitDebugSessionComplete(summary) {
+    if (!this.socket) return;
+    this.socket.emit("agentRunner:debugSessionComplete", { summary });
+  }
+  emitDebugReproduceRequested(hypothesis) {
+    if (!this.socket) return;
+    this.socket.emit("agentRunner:debugReproduceRequested", { hypothesis });
+  }
   searchIncidents(status, source) {
     return searchIncidents(this.socket, status, source);
   }
@@ -454,9 +510,16 @@ var ProjectConnection = class {
   shutdownCallback = null;
   chatMessageCallback = null;
   earlyChatMessages = [];
+  auditRequestCallback = null;
+  // Branch switching callbacks
+  onSwitchBranch = null;
+  onSyncEnvironment = null;
+  onGetEnvStatus = null;
+  onRestartStartCommand = null;
   constructor(config) {
     this.config = config;
   }
+  // oxlint-disable-next-line max-lines-per-function -- socket event registration requires co-located handlers
   connect() {
     return new Promise((resolve2, reject) => {
       let settled = false;
@@ -496,12 +559,65 @@ var ProjectConnection = class {
           this.earlyChatMessages.push(msg);
         }
       });
+      this.socket.on("projectRunner:auditTags", (data) => {
+        if (this.auditRequestCallback) {
+          this.auditRequestCallback(data);
+        }
+      });
+      this.socket.on(
+        "projectRunner:switchBranch",
+        (data, cb) => {
+          if (this.onSwitchBranch) this.onSwitchBranch(data, cb);
+          else cb({ ok: false, error: "switchBranch handler not registered" });
+        }
+      );
+      this.socket.on("projectRunner:syncEnvironment", (cb) => {
+        if (this.onSyncEnvironment) this.onSyncEnvironment(cb);
+        else cb({ ok: false, error: "syncEnvironment handler not registered" });
+      });
+      this.socket.on("projectRunner:getEnvStatus", (cb) => {
+        if (this.onGetEnvStatus) this.onGetEnvStatus(cb);
+        else cb({ ok: false, data: void 0 });
+      });
+      this.socket.on(
+        "projectRunner:restartStartCommand",
+        (_data, cb) => {
+          if (this.onRestartStartCommand) this.onRestartStartCommand(cb);
+          else cb({ ok: false, error: "restartStartCommand handler not registered" });
+        }
+      );
+      this.socket.on(
+        "projectRunner:runAuthTokenCommand",
+        (data, cb) => this.handleRunAuthTokenCommand(data.userEmail, cb)
+      );
+      process.stderr.write(
+        `[conveyor] Connecting to ${this.config.apiUrl} (project: ${this.config.projectId})
+`
+      );
       this.socket.on("connect", () => {
+        process.stderr.write(`[conveyor] Project socket connected
+`);
         if (!settled) {
           settled = true;
           resolve2();
         }
       });
+      this.socket.on("connect_error", (err) => {
+        process.stderr.write(`[conveyor] Project socket connection error: ${err.message}
+`);
+      });
+      this.socket.on("disconnect", (reason) => {
+        process.stderr.write(`[conveyor] Project socket disconnected: ${reason}
+`);
+      });
+      this.socket.io.on("reconnect", (attempt) => {
+        process.stderr.write(`[conveyor] Project socket reconnected after ${attempt} attempt(s)
+`);
+      });
+      this.socket.io.on("reconnect_error", (err) => {
+        process.stderr.write(`[conveyor] Project socket reconnection error: ${err.message}
+`);
+      });
       this.socket.io.on("reconnect_attempt", () => {
         attempts++;
         if (!settled && attempts >= maxInitialAttempts) {
@@ -527,6 +643,17 @@ var ProjectConnection = class {
     }
     this.earlyChatMessages = [];
   }
+  onAuditRequest(callback) {
+    this.auditRequestCallback = callback;
+  }
+  emitAuditResult(data) {
+    if (!this.socket) return;
+    this.socket.emit("conveyor:tagAuditResult", data);
+  }
+  emitAuditProgress(data) {
+    if (!this.socket) return;
+    this.socket.emit("conveyor:tagAuditProgress", data);
+  }
   sendHeartbeat() {
     if (!this.socket) return;
     this.socket.emit("projectRunner:heartbeat", {});
@@ -574,13 +701,13 @@ var ProjectConnection = class {
       );
     });
   }
-  fetchChatHistory(limit) {
+  fetchChatHistory(limit, chatId) {
     const socket = this.socket;
     if (!socket) return Promise.reject(new Error("Not connected"));
     return new Promise((resolve2, reject) => {
       socket.emit(
         "projectRunner:getChatHistory",
-        { limit },
+        { limit, chatId },
         (response) => {
           if (response.success && response.data) resolve2(response.data);
           else reject(new Error(response.error ?? "Failed to fetch chat history"));
@@ -588,6 +715,78 @@ var ProjectConnection = class {
       );
     });
   }
+  // ── Project MCP tool request methods ──
+  requestListTasks(params) {
+    return this.requestWithCallback("projectRunner:listTasks", params);
+  }
+  requestGetTask(taskId) {
+    return this.requestWithCallback("projectRunner:getTask", { taskId });
+  }
+  requestCreateTask(params) {
+    return this.requestWithCallback("projectRunner:createTask", params);
+  }
+  requestUpdateTask(params) {
+    return this.requestWithCallback("projectRunner:updateTask", params);
+  }
+  requestSearchTasks(params) {
+    return this.requestWithCallback("projectRunner:searchTasks", params);
+  }
+  requestListTags() {
+    return this.requestWithCallback("projectRunner:listTags", {});
+  }
+  requestGetProjectSummary() {
+    return this.requestWithCallback("projectRunner:getProjectSummary", {});
+  }
+  requestWithCallback(event, data) {
+    const socket = this.socket;
+    if (!socket) return Promise.reject(new Error("Not connected"));
+    return new Promise((resolve2, reject) => {
+      socket.emit(event, data, (response) => {
+        if (response.success) resolve2(response.data);
+        else reject(new Error(response.error ?? `${event} failed`));
+      });
+    });
+  }
+  emitNewCommitsDetected(data) {
+    if (!this.socket) return;
+    this.socket.emit("projectRunner:newCommitsDetected", data);
+  }
+  emitEnvironmentReady(data) {
+    if (!this.socket) return;
+    this.socket.emit("projectRunner:environmentReady", data);
+  }
+  emitEnvSwitchProgress(data) {
+    if (!this.socket) return;
+    this.socket.emit("projectRunner:envSwitchProgress", data);
+  }
+  handleRunAuthTokenCommand(userEmail, cb) {
+    try {
+      if (process.env.CODESPACES !== "true") {
+        cb({ ok: false, error: "Auth token command only available in codespace environments" });
+        return;
+      }
+      const authCmd = process.env.CONVEYOR_AUTH_TOKEN_COMMAND;
+      if (!authCmd) {
+        cb({ ok: false, error: "CONVEYOR_AUTH_TOKEN_COMMAND not configured" });
+        return;
+      }
+      const cwd = this.config.projectDir ?? process.cwd();
+      const token = runAuthTokenCommand(authCmd, userEmail, cwd);
+      if (!token) {
+        cb({
+          ok: false,
+          error: `Auth token command returned empty output. Command: ${authCmd}`
+        });
+        return;
+      }
+      cb({ ok: true, token });
+    } catch (error) {
+      cb({
+        ok: false,
+        error: error instanceof Error ? error.message : "Auth token command failed"
+      });
+    }
+  }
   disconnect() {
     this.socket?.disconnect();
     this.socket = null;
@@ -622,9 +821,32 @@ function errorMeta(error) {
 }
 
 // src/runner/worktree.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 import { existsSync } from "fs";
 import { join } from "path";
+
+// src/runner/git-utils.ts
+import { execSync as execSync2 } from "child_process";
+function hasUncommittedChanges(cwd) {
+  const status = execSync2("git status --porcelain", {
+    cwd,
+    stdio: ["ignore", "pipe", "ignore"]
+  }).toString().trim();
+  return status.length > 0;
+}
+function getCurrentBranch(cwd) {
+  try {
+    const branch = execSync2("git branch --show-current", {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+    return branch || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/runner/worktree.ts
 var WORKTREE_DIR = ".worktrees";
 function ensureWorktree(projectDir, taskId, branch) {
   if (projectDir.includes(`/${WORKTREE_DIR}/`)) {
@@ -633,8 +855,11 @@ function ensureWorktree(projectDir, taskId, branch) {
   const worktreePath = join(projectDir, WORKTREE_DIR, taskId);
   if (existsSync(worktreePath)) {
     if (branch) {
+      if (hasUncommittedChanges(worktreePath)) {
+        return worktreePath;
+      }
       try {
-        execSync2(`git checkout --detach origin/${branch}`, {
+        execSync3(`git checkout --detach origin/${branch}`, {
           cwd: worktreePath,
           stdio: "ignore"
         });
@@ -644,17 +869,39 @@ function ensureWorktree(projectDir, taskId, branch) {
     return worktreePath;
   }
   const ref = branch ? `origin/${branch}` : "HEAD";
-  execSync2(`git worktree add --detach "${worktreePath}" ${ref}`, {
+  execSync3(`git worktree add --detach "${worktreePath}" ${ref}`, {
     cwd: projectDir,
     stdio: "ignore"
   });
   return worktreePath;
 }
+function detachWorktreeBranch(projectDir, branch) {
+  try {
+    const output = execSync3("git worktree list --porcelain", {
+      cwd: projectDir,
+      encoding: "utf-8"
+    });
+    const entries = output.split("\n\n");
+    for (const entry of entries) {
+      const lines = entry.trim().split("\n");
+      const worktreeLine = lines.find((l) => l.startsWith("worktree "));
+      const branchLine = lines.find((l) => l.startsWith("branch "));
+      if (!worktreeLine || branchLine !== `branch refs/heads/${branch}`) continue;
+      const worktreePath = worktreeLine.replace("worktree ", "");
+      if (!worktreePath.includes(`/${WORKTREE_DIR}/`)) continue;
+      try {
+        execSync3("git checkout --detach", { cwd: worktreePath, stdio: "ignore" });
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
 function removeWorktree(projectDir, taskId) {
   const worktreePath = join(projectDir, WORKTREE_DIR, taskId);
   if (!existsSync(worktreePath)) return;
   try {
-    execSync2(`git worktree remove "${worktreePath}" --force`, {
+    execSync3(`git worktree remove "${worktreePath}" --force`, {
       cwd: projectDir,
       stdio: "ignore"
     });
@@ -690,10 +937,10 @@ function loadConveyorConfig(_workspaceDir) {
 }
 
 // src/setup/codespace.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 function unshallowRepo(workspaceDir) {
   try {
-    execSync3("git fetch --unshallow", {
+    execSync4("git fetch --unshallow", {
       cwd: workspaceDir,
       stdio: "ignore",
       timeout: 6e4
@@ -704,9 +951,252 @@ function unshallowRepo(workspaceDir) {
 
 // src/runner/agent-runner.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync5 } from "child_process";
+
+// src/connection/tunnel-client.ts
+import { request as httpRequest } from "http";
+var logger2 = createServiceLogger("TunnelClient");
+var RECONNECT_BASE_MS = 1e3;
+var RECONNECT_MAX_MS = 3e4;
+var TunnelClient = class _TunnelClient {
+  static STABLE_MS = 3e4;
+  apiUrl;
+  token;
+  localPort;
+  ws = null;
+  stopped = false;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  connectedAt = 0;
+  constructor(apiUrl, token, localPort) {
+    this.apiUrl = apiUrl;
+    this.token = token;
+    this.localPort = localPort;
+  }
+  connect() {
+    if (this.stopped) return;
+    const wsUrl = this.apiUrl.replace(/^http/, "ws").replace(/\/$/, "");
+    const url = `${wsUrl}/api/tunnel?token=${encodeURIComponent(this.token)}`;
+    try {
+      this.ws = new WebSocket(url);
+    } catch (err) {
+      logger2.warn("Failed to create tunnel WebSocket", { error: String(err) });
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws.binaryType = "arraybuffer";
+    this.ws.addEventListener("open", () => {
+      this.connectedAt = Date.now();
+      logger2.info("Tunnel connected", { port: this.localPort });
+    });
+    this.ws.addEventListener("close", (event) => {
+      logger2.info("Tunnel disconnected", { code: event.code, reason: event.reason });
+      this.scheduleReconnect();
+    });
+    this.ws.addEventListener("error", (event) => {
+      const msg = "message" in event ? event.message : "unknown";
+      logger2.warn("Tunnel error", { error: msg });
+    });
+    this.ws.addEventListener("message", (event) => {
+      this.handleMessage(event.data);
+    });
+  }
+  disconnect() {
+    this.stopped = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close(1e3, "shutdown");
+      this.ws = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.stopped) return;
+    if (Date.now() - this.connectedAt >= _TunnelClient.STABLE_MS) {
+      this.reconnectAttempts = 0;
+    }
+    const delay = Math.min(RECONNECT_BASE_MS * 2 ** this.reconnectAttempts, RECONNECT_MAX_MS);
+    this.reconnectAttempts++;
+    logger2.info("Tunnel reconnecting", { delay, attempt: this.reconnectAttempts });
+    this.reconnectTimer = setTimeout(() => this.connect(), delay);
+  }
+  // ---------------------------------------------------------------------------
+  // Message handling
+  // ---------------------------------------------------------------------------
+  handleMessage(data) {
+    if (typeof data === "string") {
+      this.handleJsonMessage(data);
+    } else {
+      this.handleBinaryFrame(data);
+    }
+  }
+  handleJsonMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    switch (msg.type) {
+      case "http-req":
+        this.handleHttpRequest(msg.id, msg.method ?? "GET", msg.path ?? "/", msg.headers ?? {});
+        break;
+      case "http-req-end":
+        this.endHttpRequest(msg.id);
+        break;
+      case "ws-upgrade":
+        this.handleWsUpgrade(msg.id, msg.path ?? "/", msg.headers ?? {});
+        break;
+      case "ws-data":
+        this.relayWsData(msg.id, msg.data ?? "");
+        break;
+      case "ws-close":
+        this.closeWs(msg.id);
+        break;
+    }
+  }
+  handleBinaryFrame(data) {
+    const buf = new Uint8Array(data);
+    if (buf.length <= 4) return;
+    const id = buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3];
+    const body = buf.subarray(4);
+    const pending = this.pendingHttpRequests.get(id);
+    if (pending) pending.chunks.push(Buffer.from(body));
+  }
+  // ---------------------------------------------------------------------------
+  // HTTP request proxying
+  // ---------------------------------------------------------------------------
+  pendingHttpRequests = /* @__PURE__ */ new Map();
+  handleHttpRequest(id, method, path2, headers) {
+    const state = { chunks: [], ended: false };
+    this.pendingHttpRequests.set(id, state);
+    const req = httpRequest(
+      {
+        hostname: "127.0.0.1",
+        port: this.localPort,
+        path: path2,
+        method,
+        headers: { ...headers, host: `127.0.0.1:${this.localPort}` }
+      },
+      (res) => {
+        const resHeaders = {};
+        for (const [key, val] of Object.entries(res.headers)) {
+          if (typeof val === "string") resHeaders[key] = val;
+        }
+        this.send(
+          JSON.stringify({ type: "http-res", id, statusCode: res.statusCode, headers: resHeaders })
+        );
+        res.on("data", (chunk) => {
+          const frame = Buffer.alloc(4 + chunk.length);
+          frame.writeUInt32BE(id, 0);
+          chunk.copy(frame, 4);
+          this.sendBinary(frame);
+        });
+        res.on("end", () => {
+          this.send(JSON.stringify({ type: "http-end", id }));
+          this.pendingHttpRequests.delete(id);
+        });
+      }
+    );
+    req.on("error", (err) => {
+      logger2.warn("Local HTTP request failed", { id, error: err.message });
+      this.send(JSON.stringify({ type: "http-res", id, statusCode: 502, headers: {} }));
+      this.send(JSON.stringify({ type: "http-end", id }));
+      this.pendingHttpRequests.delete(id);
+    });
+    for (const chunk of state.chunks) {
+      req.write(chunk);
+    }
+    state.chunks = [];
+    if (state.ended) {
+      req.end();
+    } else {
+      state.req = req;
+    }
+  }
+  endHttpRequest(id) {
+    const state = this.pendingHttpRequests.get(id);
+    if (!state) return;
+    state.ended = true;
+    const req = state.req;
+    if (req) {
+      for (const chunk of state.chunks) {
+        req.write(chunk);
+      }
+      req.end();
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // WebSocket proxying
+  // ---------------------------------------------------------------------------
+  localWebSockets = /* @__PURE__ */ new Map();
+  handleWsUpgrade(id, path2, _headers) {
+    const url = `ws://127.0.0.1:${this.localPort}${path2}`;
+    try {
+      const localWs = new WebSocket(url);
+      localWs.addEventListener("open", () => {
+        this.localWebSockets.set(id, localWs);
+        this.send(JSON.stringify({ type: "ws-open", id }));
+      });
+      localWs.addEventListener("message", (event) => {
+        const data = typeof event.data === "string" ? event.data : String(event.data);
+        this.send(JSON.stringify({ type: "ws-data", id, data }));
+      });
+      localWs.addEventListener("close", () => {
+        this.localWebSockets.delete(id);
+        this.send(JSON.stringify({ type: "ws-close", id }));
+      });
+      localWs.addEventListener("error", () => {
+        this.localWebSockets.delete(id);
+        this.send(JSON.stringify({ type: "ws-close", id }));
+      });
+    } catch {
+      this.send(JSON.stringify({ type: "ws-close", id }));
+    }
+  }
+  relayWsData(id, data) {
+    const localWs = this.localWebSockets.get(id);
+    if (localWs && localWs.readyState === WebSocket.OPEN) {
+      localWs.send(data);
+    }
+  }
+  closeWs(id) {
+    const localWs = this.localWebSockets.get(id);
+    if (localWs) {
+      localWs.close();
+      this.localWebSockets.delete(id);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Send helpers
+  // ---------------------------------------------------------------------------
+  send(data) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(data);
+    }
+  }
+  sendBinary(data) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      const copy = new ArrayBuffer(data.byteLength);
+      new Uint8Array(copy).set(
+        new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
+      );
+      this.ws.send(copy);
+    }
+  }
+};
 
 // src/execution/event-handlers.ts
+function safeVoid(promise, context) {
+  if (promise && typeof promise.catch === "function") {
+    promise.catch((err) => {
+      process.stderr.write(`[safeVoid] ${context}: ${err}
+`);
+    });
+  }
+}
 function epochSecondsToISO(value) {
   if (typeof value === "string") return value;
   if (typeof value !== "number" || value <= 0) return void 0;
@@ -745,6 +1235,10 @@ async function processAssistantEvent(event, host, turnToolCalls) {
 }
 var API_ERROR_PATTERN = /API Error: [45]\d\d/;
 var IMAGE_ERROR_PATTERN = /Could not process image/i;
+var AUTH_ERROR_PATTERN = /Not logged in|Please run \/login|authentication failed|invalid.*token|unauthorized/i;
+function isAuthError(msg) {
+  return AUTH_ERROR_PATTERN.test(msg);
+}
 function isRetriableMessage(msg) {
   if (IMAGE_ERROR_PATTERN.test(msg)) return true;
   if (API_ERROR_PATTERN.test(msg)) return true;
@@ -825,6 +1319,10 @@ function handleErrorResult(event, host) {
   if (isStaleSession) {
     return { retriable: false, staleSession: true };
   }
+  if (isAuthError(errorMsg)) {
+    host.connection.sendEvent({ type: "error", message: errorMsg });
+    return { retriable: false, authError: true };
+  }
   const retriable = isRetriableMessage(errorMsg);
   host.connection.sendEvent({ type: "error", message: errorMsg });
   return { retriable };
@@ -864,7 +1362,8 @@ async function emitResultEvent(event, host, context, startTime, lastAssistantUsa
   return {
     retriable: result.retriable,
     resultSummary: result.resultSummary,
-    staleSession: result.staleSession
+    staleSession: result.staleSession,
+    authError: result.authError
   };
 }
 function handleRateLimitEvent(event, host) {
@@ -883,13 +1382,13 @@ function handleRateLimitEvent(event, host) {
     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 });
+    safeVoid(host.callbacks.onEvent({ type: "error", message }), "rateLimitRejected");
     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 });
+    safeVoid(host.callbacks.onEvent({ type: "thinking", message }), "rateLimitWarning");
   }
   return void 0;
 }
@@ -907,34 +1406,46 @@ async function handleSystemEvent(event, host, context, sessionIdStored) {
 }
 function handleSystemSubevents(systemEvent, host) {
   if (systemEvent.subtype === "compact_boundary") {
-    void host.callbacks.onEvent({
-      type: "context_compacted",
-      trigger: systemEvent.compact_metadata.trigger,
-      preTokens: systemEvent.compact_metadata.pre_tokens
-    });
+    safeVoid(
+      host.callbacks.onEvent({
+        type: "context_compacted",
+        trigger: systemEvent.compact_metadata.trigger,
+        preTokens: systemEvent.compact_metadata.pre_tokens
+      }),
+      "compactBoundary"
+    );
   } else if (systemEvent.subtype === "task_started") {
-    void host.callbacks.onEvent({
-      type: "subagent_started",
-      sdkTaskId: systemEvent.task_id,
-      description: systemEvent.description
-    });
+    safeVoid(
+      host.callbacks.onEvent({
+        type: "subagent_started",
+        sdkTaskId: systemEvent.task_id,
+        description: systemEvent.description
+      }),
+      "taskStarted"
+    );
   } else if (systemEvent.subtype === "task_progress") {
-    void host.callbacks.onEvent({
-      type: "subagent_progress",
-      sdkTaskId: systemEvent.task_id,
-      description: systemEvent.description,
-      toolUses: systemEvent.usage?.tool_uses ?? 0,
-      durationMs: systemEvent.usage?.duration_ms ?? 0
-    });
+    safeVoid(
+      host.callbacks.onEvent({
+        type: "subagent_progress",
+        sdkTaskId: systemEvent.task_id,
+        description: systemEvent.description,
+        toolUses: systemEvent.usage?.tool_uses ?? 0,
+        durationMs: systemEvent.usage?.duration_ms ?? 0
+      }),
+      "taskProgress"
+    );
   }
 }
 function handleToolProgressEvent(event, host) {
   const msg = event;
-  void host.callbacks.onEvent({
-    type: "tool_progress",
-    toolName: msg.tool_name ?? "",
-    elapsedSeconds: msg.elapsed_time_seconds ?? 0
-  });
+  safeVoid(
+    host.callbacks.onEvent({
+      type: "tool_progress",
+      toolName: msg.tool_name ?? "",
+      elapsedSeconds: msg.elapsed_time_seconds ?? 0
+    }),
+    "toolProgress"
+  );
 }
 async function handleAssistantCase(event, host, turnToolCalls) {
   await processAssistantEvent(event, host, turnToolCalls);
@@ -952,11 +1463,13 @@ async function handleResultCase(event, host, context, startTime, isTyping, lastA
     retriable: resultInfo.retriable,
     resultSummary: resultInfo.resultSummary,
     staleSession: resultInfo.staleSession,
+    authError: resultInfo.authError,
     stoppedTyping
   };
 }
 
 // src/execution/event-processor.ts
+var API_ERROR_PATTERN2 = /API Error: [45]\d\d/;
 function stopTypingIfNeeded(host, isTyping) {
   if (isTyping) host.connection.sendTypingStop();
 }
@@ -978,6 +1491,12 @@ async function processAssistantCase(event, host, state) {
   }
   const usage = await handleAssistantCase(event, host, state.turnToolCalls);
   if (usage) state.lastAssistantUsage = usage;
+  if (!state.sawApiError) {
+    const fullText = event.message.content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
+    if (API_ERROR_PATTERN2.test(fullText)) {
+      state.sawApiError = true;
+    }
+  }
 }
 async function processResultCase(event, host, context, startTime, state) {
   const info = await handleResultCase(
@@ -992,6 +1511,7 @@ async function processResultCase(event, host, context, startTime, state) {
   state.retriable = info.retriable;
   state.resultSummary = info.resultSummary;
   if (info.staleSession) state.staleSession = true;
+  if (info.authError) state.authError = true;
 }
 async function processEvents(events, context, host) {
   const startTime = Date.now();
@@ -1001,9 +1521,11 @@ async function processEvents(events, context, host) {
     sessionIdStored: false,
     isTyping: false,
     retriable: false,
+    sawApiError: false,
     resultSummary: void 0,
     rateLimitResetsAt: void 0,
     staleSession: void 0,
+    authError: void 0,
     lastAssistantUsage: void 0,
     turnToolCalls: []
   };
@@ -1040,10 +1562,11 @@ async function processEvents(events, context, host) {
   }
   stopTypingIfNeeded(host, state.isTyping);
   return {
-    retriable: state.retriable,
+    retriable: state.retriable || state.sawApiError,
     resultSummary: state.resultSummary,
     rateLimitResetsAt: state.rateLimitResetsAt,
-    ...state.staleSession && { staleSession: state.staleSession }
+    ...state.staleSession && { staleSession: state.staleSession },
+    ...state.authError && { authError: state.authError }
   };
 }
 
@@ -1363,11 +1886,10 @@ function buildPropertyInstructions(context) {
     ``,
     `### Proactive Property Management`,
     `As you plan this task, proactively fill in task properties when you have enough context:`,
-    `- Once you understand the scope, use set_story_points to assign a value`,
-    `- Use set_task_tags to categorize the work`,
-    `- For icons: FIRST call list_icons to check for existing matches. Use set_task_icon if one fits.`,
+    `- Use update_task_properties to set any combination of: title, story points, tags, and icon`,
+    `- You can update all properties at once or just one at a time as needed`,
+    `- For icons: FIRST call list_icons to check for existing matches, then use update_task_properties with iconId.`,
     `  Only call generate_task_icon if no existing icon is a good fit.`,
-    `- Use set_task_title if the current title doesn't accurately reflect the plan`,
     ``,
     `Don't wait for the user to ask \u2014 fill these in naturally as the plan takes shape.`,
     `If the user adjusts the plan significantly, update the properties to match.`
@@ -1401,6 +1923,8 @@ function buildDiscoveryPrompt(context) {
     `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 can write plan files in .claude/plans/ only \u2014 no other file writes`,
+    `- Do NOT attempt to edit, write, or modify source code files \u2014 these operations will be denied`,
+    `- If you identify code changes needed, describe them in the plan instead of implementing them`,
     `- You can create and manage subtasks`,
     `- Goal: collaborate with the user to create a clear plan`,
     `- Proactively fill task properties (SP, tags, icon) as the plan takes shape`,
@@ -1408,10 +1932,8 @@ function buildDiscoveryPrompt(context) {
     `### 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)`,
+    `- \`update_task_properties\` \u2014 set title, story points, tags, and icon (any combination)`,
+    `- \`generate_task_icon\` \u2014 generate a new icon if needed (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`,
@@ -1419,7 +1941,7 @@ function buildDiscoveryPrompt(context) {
     ``,
     `### 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)`,
+    `- Required before ExitPlanMode will succeed: **plan** (via update_task), **story points** (via update_task_properties), **title** (via update_task_properties)`,
     `- 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`
   ];
@@ -1435,13 +1957,13 @@ function buildAutoPrompt(context) {
     `### Phase 1: Discovery & Planning (current)`,
     `- You have read-only codebase access (can read files, run git commands, search code)`,
     `- You can write plan files in .claude/plans/ only \u2014 no other file writes`,
-    `- You have MCP tools for task properties: update_task, set_story_points, set_task_tags, set_task_icon, set_task_title`,
+    `- You have MCP tools for task properties: update_task, update_task_properties`,
     ``,
     `### Required before transitioning:`,
     `Before calling ExitPlanMode, you MUST fill in ALL of these:`,
     `1. **Plan** \u2014 Save a clear implementation plan using update_task`,
-    `2. **Story Points** \u2014 Assign via set_story_points`,
-    `3. **Title** \u2014 Set an accurate title via set_task_title (if the current one is vague or "Untitled")`,
+    `2. **Story Points** \u2014 Assign via update_task_properties`,
+    `3. **Title** \u2014 Set an accurate title via update_task_properties (if the current one is vague or "Untitled")`,
     ``,
     `### Transitioning to Building:`,
     `When your plan is complete and all required properties are set, call the **ExitPlanMode** tool.`,
@@ -1535,6 +2057,14 @@ Project Agents:`);
       parts.push(formatProjectAgentLine(pa));
     }
   }
+  if (context.projectObjectives && context.projectObjectives.length > 0) {
+    parts.push(`
+Project Objectives:`);
+    for (const obj of context.projectObjectives) {
+      const dates = `${obj.startDate.split("T")[0]} to ${obj.endDate.split("T")[0]}`;
+      parts.push(`- **${obj.name}** (${dates})${obj.description ? ": " + obj.description : ""}`);
+    }
+  }
   return parts;
 }
 function buildActivePreamble(context, workspaceDir) {
@@ -1589,7 +2119,37 @@ Git safety \u2014 STRICT rules:`,
     `- 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) {
+function buildDebugModeSection(hypothesisTracker) {
+  const lines = [
+    `
+## Debug Mode`,
+    `You have access to debug tools that let you set breakpoints, inspect live state,`,
+    `and capture client-side behavior. Use these when:`,
+    `- You can't find the bug from code reading alone`,
+    `- The bug is state-dependent or timing-dependent`,
+    `- You need to verify a hypothesis about runtime behavior`,
+    ``,
+    `Debugging workflow:`,
+    `1. Form a hypothesis about the root cause`,
+    `2. Identify 2-5 strategic locations to observe (don't over-instrument)`,
+    `3. Set breakpoints or probes at those locations`,
+    `4. Ask the user to reproduce on the preview link`,
+    `5. Analyze the captured data \u2014 confirm or refute your hypothesis`,
+    `6. If refuted, refine hypothesis and repeat (max 3 iterations)`,
+    `7. Exit debug mode and implement the fix`,
+    ``,
+    `Keep debug sessions focused. You don't need to see everything \u2014`,
+    `just the data that tests your hypothesis.`
+  ];
+  if (hypothesisTracker?.isActive()) {
+    const debugContext = hypothesisTracker.getDebugContext();
+    if (debugContext) {
+      lines.push(``, debugContext);
+    }
+  }
+  return lines.join("\n");
+}
+function buildSystemPrompt(mode, context, config, setupLog, agentMode, options) {
   const isPm = mode === "pm";
   const isPmActive = isPm && agentMode === "building";
   const isPackRunner = isPm && !!config.isAuto && !!context.isParentTask;
@@ -1628,6 +2188,9 @@ Your responses are sent directly to the task chat \u2014 the team sees everythin
       `Use the mcp__conveyor__create_pull_request tool to open PRs \u2014 do NOT use gh CLI or shell commands for PR creation.`
     );
   }
+  if (options?.hasDebugTools) {
+    parts.push(buildDebugModeSection(options.hypothesisTracker));
+  }
   const modePrompt = buildModePrompt(agentMode, context);
   if (modePrompt) {
     parts.push(modePrompt);
@@ -1657,7 +2220,7 @@ function detectRelaunchScenario(context, trustChatHistory = false) {
   const hasNewUserMessages = messagesAfterAgent.some((m) => m.role === "user");
   return hasNewUserMessages ? "feedback_relaunch" : "idle_relaunch";
 }
-function buildRelaunchWithSession(mode, context, agentMode) {
+function buildRelaunchWithSession(mode, context, agentMode, isAuto) {
   const scenario = detectRelaunchScenario(context);
   if (!context.claudeSessionId || scenario === "fresh") return null;
   const parts = [];
@@ -1705,7 +2268,7 @@ Address the requested changes. Do NOT re-investigate the codebase from scratch o
       `Run \`git log --oneline -10\` to review what you already committed.`,
       `Review the current state of the codebase and verify everything is working correctly.`
     );
-    if (agentMode === "auto" || agentMode === "building") {
+    if (agentMode === "auto" || agentMode === "building" && isAuto) {
       parts.push(
         `If work is incomplete, continue implementing the plan. When finished, commit, push, and use mcp__conveyor__create_pull_request to open a PR.`,
         `Do NOT go idle or wait for instructions \u2014 you are in auto mode.`
@@ -1837,7 +2400,7 @@ CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or g
       `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)`,
+      `3. Set story points, tags, and title (update_task_properties)`,
       `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.`
     ];
@@ -1911,7 +2474,7 @@ Address the requested changes directly. Do NOT re-investigate the codebase from
   }
   return parts;
 }
-function buildInstructions(mode, context, scenario, agentMode) {
+function buildInstructions(mode, context, scenario, agentMode, isAuto) {
   const parts = [`
 ## Instructions`];
   const isPm = mode === "pm";
@@ -1943,7 +2506,7 @@ function buildInstructions(mode, context, scenario, agentMode) {
         `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.`
       );
-      if (agentMode === "auto" || agentMode === "building") {
+      if (agentMode === "auto" || agentMode === "building" && isAuto) {
         parts.push(
           `If work is incomplete, continue implementing the plan. When finished, commit, push, and use mcp__conveyor__create_pull_request to open a PR.`,
           `Do NOT go idle or wait for instructions \u2014 you are in auto mode.`
@@ -1966,13 +2529,13 @@ function buildInstructions(mode, context, scenario, agentMode) {
 async function buildInitialPrompt(mode, context, isAuto, agentMode) {
   const isPackRunner = mode === "pm" && !!isAuto && !!context.isParentTask;
   if (!isPackRunner) {
-    const sessionRelaunch = buildRelaunchWithSession(mode, context, agentMode);
+    const sessionRelaunch = buildRelaunchWithSession(mode, context, agentMode, isAuto);
     if (sessionRelaunch) return sessionRelaunch;
   }
   const isPm = mode === "pm";
   const scenario = detectRelaunchScenario(context, isPm);
   const body = await buildTaskBody(context);
-  const instructions = isPackRunner ? buildPackRunnerInstructions(context, scenario) : buildInstructions(mode, context, scenario, agentMode);
+  const instructions = isPackRunner ? buildPackRunnerInstructions(context, scenario) : buildInstructions(mode, context, scenario, agentMode, isAuto);
   return [...body, ...instructions].join("\n");
 }
 
@@ -2234,11 +2797,14 @@ function buildCreatePullRequestTool(connection) {
     "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")
+      body: z.string().describe("The PR description/body in markdown"),
+      branch: z.string().optional().describe(
+        "The head branch name for the PR. If the task doesn't have a branch set, this will be used. Defaults to the task's existing branch."
+      )
     },
-    async ({ title, body }) => {
+    async ({ title, body, branch }) => {
       try {
-        const result = await connection.createPR({ title, body });
+        const result = await connection.createPR({ title, body, branch });
         connection.sendEvent({
           type: "pr_created",
           url: result.url,
@@ -2444,7 +3010,7 @@ function buildIconTools(connection) {
   return [
     tool3(
       "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.",
+      "List available icons (default library + user-created). Returns icon IDs, names, and whether they're defaults. Call this FIRST before update_task_properties to check for existing matches.",
       {},
       async () => {
         try {
@@ -2458,23 +3024,6 @@ function buildIconTools(connection) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool3(
-      "set_task_icon",
-      "Assign an existing icon to this task by its ID. Use list_icons first to find a matching icon.",
-      {
-        iconId: z3.string().describe("The icon ID to assign")
-      },
-      async ({ iconId }) => {
-        try {
-          await Promise.resolve(connection.updateTaskProperties({ iconId }));
-          return textResult("Icon assigned to task.");
-        } catch (error) {
-          return textResult(
-            `Failed to set icon: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
-        }
-      }
-    ),
     tool3(
       "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.",
@@ -2501,50 +3050,32 @@ function buildDiscoveryTools(connection, context) {
   const spDescription = buildStoryPointDescription(context?.storyPoints);
   return [
     tool3(
-      "set_story_points",
-      "Set the story point estimate for this task. Use after understanding the scope of the work.",
-      { value: z3.number().describe(spDescription) },
-      async ({ value }) => {
-        try {
-          await Promise.resolve(connection.updateTaskProperties({ storyPointValue: value }));
-          return textResult(`Story points set to ${value}`);
-        } catch (error) {
-          return textResult(
-            `Failed to set story points: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
-        }
-      }
-    ),
-    tool3(
-      "set_task_tags",
-      "Assign tags to this task from the project's available tags. Use the tag IDs from the project tags list.",
-      {
-        tagIds: z3.array(z3.string()).describe("Array of tag IDs to assign")
-      },
-      async ({ tagIds }) => {
-        try {
-          await Promise.resolve(connection.updateTaskProperties({ tagIds }));
-          return textResult(`Tags assigned: ${tagIds.length} tag(s)`);
-        } catch (error) {
-          return textResult(
-            `Failed to set tags: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
-        }
-      }
-    ),
-    tool3(
-      "set_task_title",
-      "Update the task title to better reflect the planned work.",
+      "update_task_properties",
+      "Set one or more task properties in a single call. All fields are optional \u2014 only include the fields you want to update.",
       {
-        title: z3.string().describe("The new task title")
+        title: z3.string().optional().describe("The new task title"),
+        storyPointValue: z3.number().optional().describe(spDescription),
+        tagIds: z3.array(z3.string()).optional().describe("Array of tag IDs to assign"),
+        iconId: z3.string().optional().describe("Icon ID to assign (use list_icons first)")
       },
-      async ({ title }) => {
+      async ({ title, storyPointValue, tagIds, iconId }) => {
         try {
-          await Promise.resolve(connection.updateTaskProperties({ title }));
-          return textResult(`Task title updated to: ${title}`);
+          const updateFields = {};
+          if (title !== void 0) updateFields.title = title;
+          if (storyPointValue !== void 0) updateFields.storyPointValue = storyPointValue;
+          if (tagIds !== void 0) updateFields.tagIds = tagIds;
+          if (iconId !== void 0) updateFields.iconId = iconId;
+          await Promise.resolve(connection.updateTaskProperties(updateFields));
+          const updatedFields = [];
+          if (title !== void 0) updatedFields.push(`title to "${title}"`);
+          if (storyPointValue !== void 0)
+            updatedFields.push(`story points to ${storyPointValue}`);
+          if (tagIds !== void 0) updatedFields.push(`tags (${tagIds.length} tag(s))`);
+          if (iconId !== void 0) updatedFields.push(`icon`);
+          return textResult(`Task properties updated: ${updatedFields.join(", ")}`);
         } catch (error) {
           return textResult(
-            `Failed to update title: ${error instanceof Error ? error.message : "Unknown error"}`
+            `Failed to update task properties: ${error instanceof Error ? error.message : "Unknown error"}`
           );
         }
       }
@@ -2553,21 +3084,1272 @@ function buildDiscoveryTools(connection, context) {
   ];
 }
 
-// src/tools/index.ts
-function textResult(text) {
-  return { content: [{ type: "text", text }] };
-}
-function imageBlock(data, mimeType) {
-  return { type: "image", data, mimeType };
-}
-function getTaskModeTools(agentMode, connection) {
-  if (agentMode === "discovery" || agentMode === "auto") {
-    return [buildUpdateTaskTool(connection)];
-  }
-  return [];
-}
-function getModeTools(agentMode, connection, config, context) {
-  if (config.mode === "task") return getTaskModeTools(agentMode, connection);
+// src/tools/debug-tools.ts
+import { tool as tool6 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z6 } from "zod";
+
+// src/tools/telemetry-tools.ts
+import { tool as tool4 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z4 } from "zod";
+
+// src/debug/telemetry-injector.ts
+var BUFFER_SIZE = 200;
+var BODY_MAX_BYTES = 1024;
+var MAX_DEPTH = 3;
+var EXCLUDED_EXTENSIONS = [
+  ".js",
+  ".css",
+  ".ico",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".svg",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".map",
+  ".webp"
+];
+var EXCLUDED_PATHS = ["/_next/", "/__nextjs", "/favicon", "/_healthz", "/healthz", "/health"];
+var EXCLUDED_SOCKET_EVENTS = ["ping", "pong", "connection", "disconnect", "websocket", "upgrade"];
+function scriptPreamble() {
+  return `(function() {
+  if (globalThis.__conveyorTelemetry) {
+    return JSON.stringify({ success: true, alreadyInjected: true, patches: globalThis.__conveyorTelemetry._patches });
+  }
+
+  var BUFFER_SIZE = ${BUFFER_SIZE};
+  var BODY_MAX_BYTES = ${BODY_MAX_BYTES};
+  var MAX_DEPTH = ${MAX_DEPTH};
+  var excludedExtensions = ${JSON.stringify(EXCLUDED_EXTENSIONS)};
+  var excludedPaths = ${JSON.stringify(EXCLUDED_PATHS)};
+  var excludedSocketEvents = ${JSON.stringify(EXCLUDED_SOCKET_EVENTS)};`;
+}
+function scriptHelpers() {
+  return `
+  function truncate(str, max) {
+    if (typeof str !== 'string') return '';
+    if (str.length <= max) return str;
+    return str.slice(0, max) + '...[truncated]';
+  }
+
+  function safeStringify(obj, depth) {
+    if (depth === undefined) depth = MAX_DEPTH;
+    try {
+      if (obj === null || obj === undefined) return String(obj);
+      if (typeof obj === 'string') return obj;
+      if (typeof obj !== 'object') return String(obj);
+      if (depth <= 0) return '[Object]';
+      var seen = new Set();
+      return JSON.stringify(obj, function(key, value) {
+        if (typeof value === 'object' && value !== null) {
+          if (seen.has(value)) return '[Circular]';
+          seen.add(value);
+        }
+        return value;
+      }, 0).slice(0, BODY_MAX_BYTES);
+    } catch (e) {
+      return '[unserializable]';
+    }
+  }
+
+  function isExcludedUrl(url) {
+    if (!url) return false;
+    var lower = url.toLowerCase();
+    for (var i = 0; i < excludedExtensions.length; i++) {
+      if (lower.endsWith(excludedExtensions[i])) return true;
+    }
+    for (var j = 0; j < excludedPaths.length; j++) {
+      if (lower.indexOf(excludedPaths[j]) !== -1) return true;
+    }
+    return false;
+  }
+
+  function isExcludedSocketEvent(event) {
+    return excludedSocketEvents.indexOf(event) !== -1;
+  }
+
+  function nowMs() { return Date.now(); }`;
+}
+function scriptBuffer() {
+  return `
+  var buffer = [];
+
+  function pushEvent(event) {
+    buffer.push(event);
+    if (buffer.length > BUFFER_SIZE) { buffer.shift(); }
+  }
+
+  function getEvents(filter, limit) {
+    var result = buffer;
+    if (filter) {
+      if (filter.type) {
+        result = result.filter(function(e) { return e.type === filter.type; });
+      }
+      if (filter.urlPattern) {
+        var re;
+        try { re = new RegExp(filter.urlPattern, 'i'); } catch(e) { re = null; }
+        if (re) {
+          result = result.filter(function(e) { return e.type === 'http' && re.test(e.url); });
+        }
+      }
+      if (filter.minDuration) {
+        var minD = filter.minDuration;
+        result = result.filter(function(e) { return ('duration' in e) && e.duration >= minD; });
+      }
+      if (filter.errorOnly) {
+        result = result.filter(function(e) {
+          return e.type === 'error' || (e.type === 'http' && e.status >= 400);
+        });
+      }
+      if (filter.since) {
+        var since = filter.since;
+        result = result.filter(function(e) { return e.timestamp >= since; });
+      }
+    }
+    if (limit && limit > 0) { result = result.slice(-limit); }
+    return result;
+  }
+
+  function clear() { buffer = []; }
+
+  var patches = { express: false, prisma: false, socketIo: false, errorHandler: false };`;
+}
+function scriptPatchExpress() {
+  return `
+  function patchExpress() {
+    try {
+      var http = require('http');
+      var originalEmit = http.Server.prototype.emit;
+      http.Server.prototype.emit = function(event) {
+        if (event === 'request') {
+          var req = arguments[1];
+          var res = arguments[2];
+          if (req && res && !isExcludedUrl(req.url)) {
+            var start = nowMs();
+            var reqBody = '';
+            if (req.readable) {
+              var chunks = [];
+              var origPush = req.push;
+              req.push = function(chunk) {
+                if (chunk) { chunks.push(typeof chunk === 'string' ? chunk : chunk.toString()); }
+                return origPush.apply(this, arguments);
+              };
+              var origReqEmit = req.emit;
+              req.emit = function(evt) {
+                if (evt === 'end') { reqBody = truncate(chunks.join(''), BODY_MAX_BYTES); }
+                return origReqEmit.apply(this, arguments);
+              };
+            }
+            var origEnd = res.end;
+            res.end = function(chunk) {
+              var resBody = '';
+              if (chunk) { resBody = truncate(typeof chunk === 'string' ? chunk : chunk.toString(), BODY_MAX_BYTES); }
+              var duration = nowMs() - start;
+              pushEvent({
+                type: 'http', timestamp: start, method: req.method || 'UNKNOWN',
+                url: req.url || '/', status: res.statusCode || 0, duration: duration,
+                requestBody: reqBody || undefined, responseBody: resBody || undefined,
+                error: res.statusCode >= 400 ? ('HTTP ' + res.statusCode) : undefined
+              });
+              return origEnd.apply(this, arguments);
+            };
+          }
+        }
+        return originalEmit.apply(this, arguments);
+      };
+      patches.express = true;
+    } catch (e) {}
+  }`;
+}
+function scriptPatchPrisma() {
+  return `
+  function patchPrisma() {
+    try {
+      var prismaClient = globalThis.prisma || globalThis.__prisma;
+      if (!prismaClient) {
+        var cacheKeys = Object.keys(require.cache || {});
+        for (var i = 0; i < cacheKeys.length; i++) {
+          var mod = require.cache[cacheKeys[i]];
+          if (mod && mod.exports && typeof mod.exports.$on === 'function') {
+            prismaClient = mod.exports;
+            break;
+          }
+        }
+      }
+      if (prismaClient && typeof prismaClient.$on === 'function') {
+        prismaClient.$on('query', function(e) {
+          pushEvent({
+            type: 'db', timestamp: nowMs(),
+            query: truncate(e.query || '', BODY_MAX_BYTES),
+            params: truncate(safeStringify(e.params), BODY_MAX_BYTES),
+            duration: e.duration || 0
+          });
+        });
+        patches.prisma = true;
+      }
+    } catch (e) {}
+  }`;
+}
+function scriptPatchSocketIo() {
+  return `
+  function patchSocketIo() {
+    try {
+      var io = globalThis.io || globalThis.__io;
+      if (io && io.sockets) {
+        var origOn = io.sockets.constructor.prototype.on;
+        if (origOn) {
+          io.sockets.constructor.prototype.on = function(event, handler) {
+            if (!isExcludedSocketEvent(event)) {
+              var wrappedHandler = function() {
+                var args = Array.prototype.slice.call(arguments);
+                pushEvent({
+                  type: 'socket', timestamp: nowMs(), event: event, direction: 'in',
+                  data: truncate(safeStringify(args[0]), BODY_MAX_BYTES),
+                  namespace: (this.nsp && this.nsp.name) || '/'
+                });
+                return handler.apply(this, arguments);
+              };
+              return origOn.call(this, event, wrappedHandler);
+            }
+            return origOn.call(this, event, handler);
+          };
+        }
+        var origEmit = io.sockets.constructor.prototype.emit;
+        if (origEmit) {
+          io.sockets.constructor.prototype.emit = function(event) {
+            if (!isExcludedSocketEvent(event)) {
+              var args = Array.prototype.slice.call(arguments, 1);
+              pushEvent({
+                type: 'socket', timestamp: nowMs(), event: event, direction: 'out',
+                data: truncate(safeStringify(args[0]), BODY_MAX_BYTES),
+                namespace: (this.nsp && this.nsp.name) || '/'
+              });
+            }
+            return origEmit.apply(this, arguments);
+          };
+        }
+        patches.socketIo = true;
+      }
+    } catch (e) {}
+  }`;
+}
+function scriptPatchErrors() {
+  return `
+  function patchErrorHandler() {
+    try {
+      process.on('uncaughtException', function(err) {
+        pushEvent({
+          type: 'error', timestamp: nowMs(),
+          message: err.message || String(err),
+          stack: truncate(err.stack || '', BODY_MAX_BYTES),
+          context: 'uncaughtException'
+        });
+      });
+      process.on('unhandledRejection', function(reason) {
+        var msg = (reason && reason.message) ? reason.message : String(reason);
+        var stack = (reason && reason.stack) ? reason.stack : '';
+        pushEvent({
+          type: 'error', timestamp: nowMs(), message: msg,
+          stack: truncate(stack, BODY_MAX_BYTES), context: 'unhandledRejection'
+        });
+      });
+      patches.errorHandler = true;
+    } catch (e) {}
+  }`;
+}
+function scriptInit() {
+  return `
+  patchExpress();
+  patchPrisma();
+  patchSocketIo();
+  patchErrorHandler();
+
+  globalThis.__conveyorTelemetry = {
+    getEvents: getEvents,
+    clear: clear,
+    getStatus: function() {
+      return { active: true, eventCount: buffer.length, patches: patches };
+    },
+    _patches: patches,
+    _buffer: buffer
+  };
+
+  return JSON.stringify({ success: true, alreadyInjected: false, patches: patches });
+})();`;
+}
+function generateTelemetryScript() {
+  return [
+    scriptPreamble(),
+    scriptHelpers(),
+    scriptBuffer(),
+    scriptPatchExpress(),
+    scriptPatchPrisma(),
+    scriptPatchSocketIo(),
+    scriptPatchErrors(),
+    scriptInit()
+  ].join("\n");
+}
+async function injectTelemetry(cdpClient) {
+  try {
+    const script = generateTelemetryScript();
+    const result = await cdpClient.evaluate(script);
+    if (result.type === "error") {
+      return { success: false, error: result.value };
+    }
+    try {
+      const parsed = JSON.parse(result.value);
+      return {
+        success: parsed.success === true,
+        patches: parsed.patches
+      };
+    } catch {
+      return { success: true };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown injection error"
+    };
+  }
+}
+async function queryTelemetry(cdpClient, filter, limit) {
+  const filterJson = JSON.stringify(filter ?? {});
+  const limitVal = limit ?? 20;
+  const result = await cdpClient.evaluate(
+    `JSON.stringify(globalThis.__conveyorTelemetry ? globalThis.__conveyorTelemetry.getEvents(${filterJson}, ${limitVal}) : [])`
+  );
+  if (result.type === "error") {
+    throw new Error(`Telemetry query failed: ${result.value}`);
+  }
+  try {
+    let val = result.value;
+    if (val.startsWith('"') && val.endsWith('"')) {
+      val = JSON.parse(val);
+    }
+    return JSON.parse(val);
+  } catch {
+    return [];
+  }
+}
+async function clearTelemetry(cdpClient) {
+  await cdpClient.evaluate(
+    `globalThis.__conveyorTelemetry ? (globalThis.__conveyorTelemetry.clear(), 'cleared') : 'not active'`
+  );
+}
+async function getTelemetryStatus(cdpClient) {
+  const result = await cdpClient.evaluate(
+    `JSON.stringify(globalThis.__conveyorTelemetry ? globalThis.__conveyorTelemetry.getStatus() : { active: false, eventCount: 0, patches: { express: false, prisma: false, socketIo: false, errorHandler: false } })`
+  );
+  if (result.type === "error") {
+    return {
+      active: false,
+      eventCount: 0,
+      patches: { express: false, prisma: false, socketIo: false, errorHandler: false }
+    };
+  }
+  try {
+    let val = result.value;
+    if (val.startsWith('"') && val.endsWith('"')) {
+      val = JSON.parse(val);
+    }
+    return JSON.parse(val);
+  } catch {
+    return {
+      active: false,
+      eventCount: 0,
+      patches: { express: false, prisma: false, socketIo: false, errorHandler: false }
+    };
+  }
+}
+
+// src/tools/telemetry-tools.ts
+function requireDebugClient(manager) {
+  if (!manager.isDebugMode()) {
+    return "Debug mode is not active. Use debug_enter_mode first.";
+  }
+  const client = manager.getClient();
+  if (!client?.isConnected()) {
+    return "CDP client is not connected. Try exiting and re-entering debug mode.";
+  }
+  return client;
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : "Unknown error";
+}
+function buildGetTelemetryTool(manager) {
+  return tool4(
+    "debug_get_telemetry",
+    "Query structured telemetry events (HTTP requests, database queries, Socket.IO events, errors) captured from the running dev server. Returns filtered, structured data instead of raw logs.",
+    {
+      type: z4.enum(["http", "db", "socket", "error"]).optional().describe("Filter by event type"),
+      urlPattern: z4.string().optional().describe("Regex pattern to filter HTTP events by URL"),
+      minDuration: z4.number().optional().describe("Minimum duration in ms \u2014 only return events slower than this"),
+      errorOnly: z4.boolean().optional().describe("Only return error events and HTTP 4xx/5xx responses"),
+      since: z4.number().optional().describe("Only return events after this timestamp (ms since epoch)"),
+      limit: z4.number().optional().describe("Max events to return (default: 20, from most recent)")
+    },
+    async ({ type, urlPattern, minDuration, errorOnly, since, limit }) => {
+      const clientOrErr = requireDebugClient(manager);
+      if (typeof clientOrErr === "string") return textResult(clientOrErr);
+      try {
+        const filter = {
+          ...type && { type },
+          ...urlPattern && { urlPattern },
+          ...minDuration && { minDuration },
+          ...errorOnly && { errorOnly },
+          ...since && { since }
+        };
+        const hasFilter = Object.keys(filter).length > 0;
+        const events = await queryTelemetry(clientOrErr, hasFilter ? filter : void 0, limit);
+        if (events.length === 0) {
+          return textResult("No telemetry events found matching the filter.");
+        }
+        return textResult(JSON.stringify(events, null, 2));
+      } catch (error) {
+        return textResult(`Failed to query telemetry: ${formatError(error)}`);
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildClearTelemetryTool(manager) {
+  return tool4(
+    "debug_clear_telemetry",
+    "Clear all captured telemetry events from the buffer. Useful to reset before reproducing a specific issue.",
+    {},
+    async () => {
+      const clientOrErr = requireDebugClient(manager);
+      if (typeof clientOrErr === "string") return textResult(clientOrErr);
+      try {
+        await clearTelemetry(clientOrErr);
+        return textResult("Telemetry buffer cleared.");
+      } catch (error) {
+        return textResult(`Failed to clear telemetry: ${formatError(error)}`);
+      }
+    }
+  );
+}
+function buildTelemetryStatusTool(manager) {
+  return tool4(
+    "debug_telemetry_status",
+    "Check if telemetry is active, how many events have been captured, and which framework patches (Express, Prisma, Socket.IO) were successfully applied.",
+    {},
+    async () => {
+      const clientOrErr = requireDebugClient(manager);
+      if (typeof clientOrErr === "string") return textResult(clientOrErr);
+      try {
+        const status = await getTelemetryStatus(clientOrErr);
+        return textResult(JSON.stringify(status, null, 2));
+      } catch (error) {
+        return textResult(`Failed to get telemetry status: ${formatError(error)}`);
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildTelemetryTools(manager) {
+  return [
+    buildGetTelemetryTool(manager),
+    buildClearTelemetryTool(manager),
+    buildTelemetryStatusTool(manager)
+  ];
+}
+
+// src/tools/client-debug-tools.ts
+import { tool as tool5 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z5 } from "zod";
+function requirePlaywrightClient(manager) {
+  if (!manager.isClientDebugMode()) {
+    return "Client debug mode is not active. Use debug_enter_mode with clientSide: true first.";
+  }
+  const client = manager.getPlaywrightClient();
+  if (!client?.isConnected()) {
+    return "Playwright client is not connected. Try exiting and re-entering debug mode.";
+  }
+  return client;
+}
+function formatError2(error) {
+  return error instanceof Error ? error.message : "Unknown error";
+}
+function buildClientBreakpointTools(manager) {
+  return [
+    tool5(
+      "debug_set_client_breakpoint",
+      "Set a breakpoint in client-side code running in the headless Chromium browser. V8 resolves source maps automatically, so original .tsx/.ts file paths work. Use this for React components, client utilities, and browser-side code.",
+      {
+        file: z5.string().describe(
+          "Original source file path (e.g., src/components/App.tsx) \u2014 source maps resolve automatically"
+        ),
+        line: z5.number().describe("Line number (1-based) in the original source file"),
+        condition: z5.string().optional().describe("JavaScript condition expression \u2014 breakpoint only triggers when truthy")
+      },
+      async ({ file, line, condition }) => {
+        const clientOrErr = requirePlaywrightClient(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          const breakpointId = await clientOrErr.setBreakpoint(file, line, condition);
+          const condStr = condition ? ` (condition: ${condition})` : "";
+          const sourceMapNote = clientOrErr.hasSourceMaps() === false ? "\n\u26A0\uFE0F Source maps not detected \u2014 breakpoints will reference bundled code." : "";
+          return textResult(
+            `Client breakpoint set: ${file}:${line}${condStr}
+Breakpoint ID: ${breakpointId}${sourceMapNote}`
+          );
+        } catch (error) {
+          return textResult(`Failed to set client breakpoint: ${formatError2(error)}`);
+        }
+      }
+    ),
+    tool5(
+      "debug_remove_client_breakpoint",
+      "Remove a previously set client-side breakpoint by its ID.",
+      {
+        breakpointId: z5.string().describe("The breakpoint ID returned by debug_set_client_breakpoint")
+      },
+      async ({ breakpointId }) => {
+        const clientOrErr = requirePlaywrightClient(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          await clientOrErr.removeBreakpoint(breakpointId);
+          return textResult(`Client breakpoint ${breakpointId} removed.`);
+        } catch (error) {
+          return textResult(`Failed to remove client breakpoint: ${formatError2(error)}`);
+        }
+      }
+    ),
+    tool5(
+      "debug_list_client_breakpoints",
+      "List all active client-side breakpoints with their file, line, and condition.",
+      {},
+      // oxlint-disable-next-line require-await
+      async () => {
+        const clientOrErr = requirePlaywrightClient(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        const breakpoints = clientOrErr.listBreakpoints();
+        if (breakpoints.length === 0) {
+          return textResult("No client breakpoints set.");
+        }
+        return textResult(JSON.stringify(breakpoints, null, 2));
+      },
+      { annotations: { readOnlyHint: true } }
+    )
+  ];
+}
+function buildClientInspectionTools(manager) {
+  return [
+    tool5(
+      "debug_inspect_client_paused",
+      "When the client-side debugger is paused at a breakpoint, returns the call stack and local variables. Includes React component state, props, and hooks when paused inside a component.",
+      {},
+      async () => {
+        const clientOrErr = requirePlaywrightClient(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        const queuedHits = manager.drainClientBreakpointHitQueue();
+        if (!clientOrErr.isPaused()) {
+          if (queuedHits.length > 0) {
+            return textResult(
+              `Client debugger was paused but has since resumed. Recent breakpoint hits:
+${JSON.stringify(queuedHits, null, 2)}`
+            );
+          }
+          return textResult(
+            "Client debugger is not currently paused. Set client breakpoints and trigger the code path in the browser to pause execution."
+          );
+        }
+        try {
+          const callStack = clientOrErr.getCallStack();
+          const topFrame = callStack[0];
+          let variables = [];
+          if (topFrame) {
+            try {
+              variables = await clientOrErr.getScopeVariables(topFrame.callFrameId);
+            } catch {
+            }
+          }
+          const result = {
+            side: "client",
+            reason: clientOrErr.getPausedState()?.reason,
+            hitBreakpoints: clientOrErr.getPausedState()?.hitBreakpoints,
+            callStack,
+            localVariables: variables
+          };
+          return textResult(JSON.stringify(result, null, 2));
+        } catch (error) {
+          return textResult(`Failed to inspect client paused state: ${formatError2(error)}`);
+        }
+      },
+      { annotations: { readOnlyHint: true } }
+    ),
+    tool5(
+      "debug_evaluate_client",
+      "Evaluate a JavaScript expression in the client-side browser context. When paused at a client breakpoint, evaluates in the paused scope. Can access DOM, window, React internals, etc.",
+      {
+        expression: z5.string().describe("JavaScript expression to evaluate in the browser context"),
+        frameIndex: z5.number().optional().describe("Call stack frame index (0 = top frame). Defaults to the top frame.")
+      },
+      async ({ expression, frameIndex }) => {
+        const clientOrErr = requirePlaywrightClient(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          let callFrameId;
+          if (clientOrErr.isPaused()) {
+            const callStack = clientOrErr.getCallStack();
+            const frame = callStack[frameIndex ?? 0];
+            callFrameId = frame?.callFrameId;
+          }
+          const result = await clientOrErr.evaluate(expression, callFrameId);
+          return textResult(`(${result.type}) ${result.value}`);
+        } catch (error) {
+          return textResult(`Client evaluation failed: ${formatError2(error)}`);
+        }
+      }
+    )
+  ];
+}
+function buildClientExecutionTools(manager) {
+  return [
+    tool5(
+      "debug_continue_client",
+      "Resume client-side execution after the browser debugger has paused at a breakpoint.",
+      {},
+      async () => {
+        const clientOrErr = requirePlaywrightClient(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        if (!clientOrErr.isPaused()) {
+          return textResult("Client debugger is not paused.");
+        }
+        try {
+          await clientOrErr.resume();
+          return textResult("Client execution resumed.");
+        } catch (error) {
+          return textResult(`Failed to resume client: ${formatError2(error)}`);
+        }
+      }
+    )
+  ];
+}
+function buildClientInteractionTools(manager) {
+  return [
+    tool5(
+      "debug_client_screenshot",
+      "Take a screenshot of the current page state in the headless browser. Returns the image as base64-encoded PNG.",
+      {},
+      async () => {
+        const clientOrErr = requirePlaywrightClient(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          const base64 = await clientOrErr.screenshot();
+          return {
+            content: [
+              imageBlock(base64, "image/png"),
+              {
+                type: "text",
+                text: `Screenshot captured (${clientOrErr.getCurrentUrl()})`
+              }
+            ]
+          };
+        } catch (error) {
+          return textResult(`Failed to capture screenshot: ${formatError2(error)}`);
+        }
+      },
+      { annotations: { readOnlyHint: true } }
+    ),
+    tool5(
+      "debug_navigate_client",
+      "Navigate the headless browser to a specific URL. Use this to reproduce specific flows or visit different pages.",
+      {
+        url: z5.string().describe("URL to navigate to (e.g., http://localhost:3000/dashboard)")
+      },
+      async ({ url }) => {
+        const clientOrErr = requirePlaywrightClient(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          await clientOrErr.navigate(url);
+          return textResult(`Navigated to: ${clientOrErr.getCurrentUrl()}`);
+        } catch (error) {
+          return textResult(`Failed to navigate: ${formatError2(error)}`);
+        }
+      }
+    ),
+    tool5(
+      "debug_click_client",
+      "Click an element on the page in the headless browser. Use CSS selectors to target elements. Useful for reproducing bugs by interacting with the UI programmatically.",
+      {
+        selector: z5.string().describe(
+          "CSS selector of the element to click (e.g., 'button.submit', '#login-form input[type=submit]')"
+        )
+      },
+      async ({ selector }) => {
+        const clientOrErr = requirePlaywrightClient(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          await clientOrErr.click(selector);
+          return textResult(`Clicked: ${selector}`);
+        } catch (error) {
+          return textResult(`Failed to click "${selector}": ${formatError2(error)}`);
+        }
+      }
+    )
+  ];
+}
+function buildClientConsoleTool(manager) {
+  return tool5(
+    "debug_get_client_console",
+    "Get console messages captured from the headless browser. Includes console.log, warn, error, etc.",
+    {
+      level: z5.string().optional().describe("Filter by console level: log, warn, error, info, debug"),
+      limit: z5.number().optional().describe("Maximum number of recent messages to return (default: all)")
+    },
+    // oxlint-disable-next-line require-await
+    async ({ level, limit }) => {
+      const clientOrErr = requirePlaywrightClient(manager);
+      if (typeof clientOrErr === "string") return textResult(clientOrErr);
+      const messages = clientOrErr.getConsoleMessages(level, limit);
+      if (messages.length === 0) {
+        const filterDesc = level ? ` (level: ${level})` : "";
+        return textResult(`No console messages captured${filterDesc}.`);
+      }
+      const formatted = messages.map((m) => {
+        const time = new Date(m.timestamp).toLocaleTimeString("en-US", { hour12: false });
+        const loc = m.url ? ` [${m.url}${m.line ? `:${m.line}` : ""}]` : "";
+        return `[${time}] ${m.level.toUpperCase()}: ${m.text}${loc}`;
+      }).join("\n");
+      return textResult(`${messages.length} console message(s):
+${formatted}`);
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildClientNetworkTool(manager) {
+  return tool5(
+    "debug_get_client_network",
+    "Get network requests captured from the headless browser. Shows URLs, methods, status codes, and timing.",
+    {
+      filter: z5.string().optional().describe("Regex pattern to filter requests by URL"),
+      limit: z5.number().optional().describe("Maximum number of recent requests to return (default: all)")
+    },
+    // oxlint-disable-next-line require-await
+    async ({ filter, limit }) => {
+      const clientOrErr = requirePlaywrightClient(manager);
+      if (typeof clientOrErr === "string") return textResult(clientOrErr);
+      const requests = clientOrErr.getNetworkRequests(filter, limit);
+      if (requests.length === 0) {
+        const filterDesc = filter ? ` matching "${filter}"` : "";
+        return textResult(`No network requests captured${filterDesc}.`);
+      }
+      const formatted = requests.map((r) => {
+        const time = new Date(r.timestamp).toLocaleTimeString("en-US", { hour12: false });
+        const status = r.status ? ` \u2192 ${r.status}` : " \u2192 (pending)";
+        const dur = r.duration ? ` (${r.duration}ms)` : "";
+        return `[${time}] ${r.method} ${r.url}${status}${dur}`;
+      }).join("\n");
+      return textResult(`${requests.length} network request(s):
+${formatted}`);
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildClientErrorsTool(manager) {
+  return tool5(
+    "debug_get_client_errors",
+    "Get uncaught errors captured from the headless browser. Includes error messages and source-mapped stack traces.",
+    {
+      limit: z5.number().optional().describe("Maximum number of recent errors to return (default: all)")
+    },
+    // oxlint-disable-next-line require-await
+    async ({ limit }) => {
+      const clientOrErr = requirePlaywrightClient(manager);
+      if (typeof clientOrErr === "string") return textResult(clientOrErr);
+      const errors = clientOrErr.getPageErrors(limit);
+      if (errors.length === 0) {
+        return textResult("No uncaught page errors captured.");
+      }
+      const formatted = errors.map((e) => {
+        const time = new Date(e.timestamp).toLocaleTimeString("en-US", { hour12: false });
+        const stack = e.stack ? `
+  ${e.stack.split("\n").slice(0, 5).join("\n  ")}` : "";
+        return `[${time}] ${e.message}${stack}`;
+      }).join("\n\n");
+      return textResult(`${errors.length} page error(s):
+${formatted}`);
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildClientCaptureTools(manager) {
+  return [
+    buildClientConsoleTool(manager),
+    buildClientNetworkTool(manager),
+    buildClientErrorsTool(manager)
+  ];
+}
+function buildClientDebugTools(manager) {
+  return [
+    ...buildClientBreakpointTools(manager),
+    ...buildClientInspectionTools(manager),
+    ...buildClientExecutionTools(manager),
+    ...buildClientInteractionTools(manager),
+    ...buildClientCaptureTools(manager)
+  ];
+}
+
+// src/tools/debug-tools.ts
+function requireDebugClient2(manager) {
+  if (!manager.isDebugMode()) {
+    return "Debug mode is not active. Use debug_enter_mode first.";
+  }
+  const client = manager.getClient();
+  if (!client?.isConnected()) {
+    return "CDP client is not connected. Try exiting and re-entering debug mode.";
+  }
+  return client;
+}
+function formatError3(error) {
+  return error instanceof Error ? error.message : "Unknown error";
+}
+async function handleEnterDebugMode(manager, {
+  hypothesis,
+  serverSide,
+  clientSide,
+  previewUrl
+}) {
+  const wantServer = serverSide ?? !clientSide;
+  const wantClient = clientSide ?? false;
+  const alreadyMsg = checkAlreadyActive(manager, wantServer, wantClient);
+  if (alreadyMsg) return textResult(alreadyMsg);
+  await manager.enterDebugMode(void 0, {
+    serverSide: wantServer && !manager.isDebugMode(),
+    clientSide: wantClient && !manager.isClientDebugMode(),
+    previewUrl
+  });
+  return textResult(buildActivationMessage(manager, hypothesis));
+}
+function checkAlreadyActive(manager, wantServer, wantClient) {
+  if (wantServer && manager.isDebugMode() && !wantClient) return "Already in server debug mode.";
+  if (wantClient && manager.isClientDebugMode() && !wantServer)
+    return "Already in client debug mode.";
+  if (wantServer && manager.isDebugMode() && wantClient && manager.isClientDebugMode()) {
+    return "Already in both server and client debug mode.";
+  }
+  return null;
+}
+function buildActivationMessage(manager, hypothesis) {
+  const modes = [];
+  if (manager.isDebugMode()) modes.push("server");
+  if (manager.isClientDebugMode()) modes.push("client");
+  const modeStr = modes.join(" + ");
+  const sourceMapWarning = manager.getPlaywrightClient()?.hasSourceMaps() === false ? "\n\u26A0\uFE0F Source maps not detected in the client \u2014 client breakpoints will reference bundled code." : "";
+  return hypothesis ? `Debug mode activated (${modeStr}). Hypothesis: ${hypothesis}
+Set breakpoints to test your hypothesis.${sourceMapWarning}` : `Debug mode activated (${modeStr}). Set breakpoints to begin debugging.${sourceMapWarning}`;
+}
+function buildDebugLifecycleTools(manager) {
+  return [
+    tool6(
+      "debug_enter_mode",
+      "Activate debug mode: restarts the dev server with Node.js --inspect flag and connects the CDP debugger. Optionally launch a headless Chromium browser for client-side debugging. Use serverSide for backend breakpoints, clientSide for frontend breakpoints, or both for full-stack.",
+      {
+        hypothesis: z6.string().optional().describe("Your hypothesis about the bug \u2014 helps track debugging intent"),
+        serverSide: z6.boolean().optional().describe(
+          "Enable server-side Node.js debugging (default: true if clientSide is not set)"
+        ),
+        clientSide: z6.boolean().optional().describe("Enable client-side browser debugging via headless Chromium + Playwright"),
+        previewUrl: z6.string().optional().describe(
+          "Preview URL for client-side debugging (e.g., http://localhost:3000). Required when clientSide is true."
+        )
+      },
+      async (params) => {
+        try {
+          return await handleEnterDebugMode(manager, params);
+        } catch (error) {
+          return textResult(`Failed to enter debug mode: ${formatError3(error)}`);
+        }
+      }
+    ),
+    tool6(
+      "debug_exit_mode",
+      "Exit debug mode: removes all breakpoints, disconnects the debugger, and restarts the dev server normally.",
+      {},
+      async () => {
+        try {
+          if (!manager.isDebugMode()) {
+            return textResult("Not in debug mode.");
+          }
+          await manager.exitDebugMode();
+          return textResult("Debug mode deactivated. Dev server restarted normally.");
+        } catch (error) {
+          return textResult(`Failed to exit debug mode: ${formatError3(error)}`);
+        }
+      }
+    )
+  ];
+}
+function buildBreakpointTools(manager) {
+  return [
+    tool6(
+      "debug_set_breakpoint",
+      "Set a breakpoint at the specified file and line number. Optionally provide a condition expression that must evaluate to true for the breakpoint to pause execution.",
+      {
+        file: z6.string().describe("Absolute or relative file path to set the breakpoint in"),
+        line: z6.number().describe("Line number (1-based) to set the breakpoint on"),
+        condition: z6.string().optional().describe("JavaScript condition expression \u2014 breakpoint only triggers when truthy")
+      },
+      async ({ file, line, condition }) => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          const client = clientOrErr;
+          const breakpointId = await client.setBreakpoint(file, line, condition);
+          const condStr = condition ? ` (condition: ${condition})` : "";
+          return textResult(
+            `Breakpoint set: ${file}:${line}${condStr}
+Breakpoint ID: ${breakpointId}`
+          );
+        } catch (error) {
+          return textResult(`Failed to set breakpoint: ${formatError3(error)}`);
+        }
+      }
+    ),
+    tool6(
+      "debug_remove_breakpoint",
+      "Remove a previously set breakpoint by its ID.",
+      {
+        breakpointId: z6.string().describe("The breakpoint ID returned by debug_set_breakpoint")
+      },
+      async ({ breakpointId }) => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          const client = clientOrErr;
+          await client.removeBreakpoint(breakpointId);
+          return textResult(`Breakpoint ${breakpointId} removed.`);
+        } catch (error) {
+          return textResult(`Failed to remove breakpoint: ${formatError3(error)}`);
+        }
+      }
+    ),
+    tool6(
+      "debug_list_breakpoints",
+      "List all currently active breakpoints with their file, line, and condition.",
+      {},
+      // oxlint-disable-next-line require-await
+      async () => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        const breakpoints = clientOrErr.listBreakpoints();
+        if (breakpoints.length === 0) {
+          return textResult("No breakpoints set.");
+        }
+        return textResult(JSON.stringify(breakpoints, null, 2));
+      },
+      { annotations: { readOnlyHint: true } }
+    )
+  ];
+}
+function buildInspectionTools(manager) {
+  return [
+    tool6(
+      "debug_inspect_paused",
+      "When the debugger is paused at a breakpoint, returns the call stack and local variables. Check this after a breakpoint is hit to understand the current execution state.",
+      {},
+      async () => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        const client = clientOrErr;
+        const queuedHits = manager.drainBreakpointHitQueue();
+        if (!client.isPaused()) {
+          if (queuedHits.length > 0) {
+            return textResult(
+              `Debugger was paused but has since resumed. Recent breakpoint hits:
+${JSON.stringify(queuedHits, null, 2)}`
+            );
+          }
+          return textResult(
+            "Debugger is not currently paused. Set breakpoints and trigger the code path to pause execution."
+          );
+        }
+        try {
+          const callStack = client.getCallStack();
+          const topFrame = callStack[0];
+          let variables = [];
+          if (topFrame) {
+            try {
+              variables = await client.getScopeVariables(topFrame.callFrameId);
+            } catch {
+            }
+          }
+          const result = {
+            reason: client.getPausedState()?.reason,
+            hitBreakpoints: client.getPausedState()?.hitBreakpoints,
+            callStack,
+            localVariables: variables
+          };
+          return textResult(JSON.stringify(result, null, 2));
+        } catch (error) {
+          return textResult(`Failed to inspect paused state: ${formatError3(error)}`);
+        }
+      },
+      { annotations: { readOnlyHint: true } }
+    ),
+    tool6(
+      "debug_evaluate",
+      "Evaluate a JavaScript expression in the current paused scope (or globally if not paused). When paused, use frameIndex to evaluate in a specific call frame.",
+      {
+        expression: z6.string().describe("The JavaScript expression to evaluate"),
+        frameIndex: z6.number().optional().describe("Call stack frame index (0 = top frame). Defaults to the top frame.")
+      },
+      async ({ expression, frameIndex }) => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          const client = clientOrErr;
+          let callFrameId;
+          if (client.isPaused()) {
+            const callStack = client.getCallStack();
+            const frame = callStack[frameIndex ?? 0];
+            callFrameId = frame?.callFrameId;
+          }
+          const result = await client.evaluate(expression, callFrameId);
+          return textResult(`(${result.type}) ${result.value}`);
+        } catch (error) {
+          return textResult(`Evaluation failed: ${formatError3(error)}`);
+        }
+      }
+    )
+  ];
+}
+function buildProbeManagementTools(manager) {
+  return [
+    tool6(
+      "debug_add_probe",
+      "Add a debug probe at a specific code location. Captures expression values each time the line executes \u2014 without pausing or modifying source files. Like console.log but better: structured, no diff pollution, auto-cleaned on debug exit.",
+      {
+        file: z6.string().describe("File path to probe"),
+        line: z6.number().describe("Line number (1-based) to probe"),
+        expressions: z6.array(z6.string()).describe(
+          'JavaScript expressions to capture when the line executes (e.g., ["req.params.id", "user.role"])'
+        ),
+        label: z6.string().optional().describe("Optional label for this probe (defaults to file:line)")
+      },
+      async ({ file, line, expressions, label }) => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          const probeId = await clientOrErr.setLogpoint(file, line, expressions, label);
+          const probeLabel = label ?? `${file}:${line}`;
+          const exprList = expressions.join(", ");
+          return textResult(
+            `Probe "${probeLabel}" set at ${file}:${line}
+Capturing: ${exprList}
+Probe ID: ${probeId}
+
+Trigger the code path, then use debug_get_probe_results to see captured values.`
+          );
+        } catch (error) {
+          return textResult(`Failed to add probe: ${formatError3(error)}`);
+        }
+      }
+    ),
+    tool6(
+      "debug_remove_probe",
+      "Remove a previously set debug probe by its ID.",
+      {
+        probeId: z6.string().describe("The probe ID returned by debug_add_probe")
+      },
+      async ({ probeId }) => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          await clientOrErr.removeProbe(probeId);
+          return textResult(`Probe ${probeId} removed.`);
+        } catch (error) {
+          return textResult(`Failed to remove probe: ${formatError3(error)}`);
+        }
+      }
+    ),
+    tool6(
+      "debug_list_probes",
+      "List all active debug probes with their file, line, expressions, and labels.",
+      {},
+      // oxlint-disable-next-line require-await
+      async () => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        const probes = clientOrErr.listProbes();
+        if (probes.length === 0) {
+          return textResult("No probes set.");
+        }
+        const lines = probes.map(
+          (p) => `${p.probeId}: "${p.label}" at ${p.file}:${p.line} \u2014 [${p.expressions.join(", ")}]`
+        );
+        return textResult(lines.join("\n"));
+      },
+      { annotations: { readOnlyHint: true } }
+    )
+  ];
+}
+function buildProbeResultTools(manager) {
+  return [
+    tool6(
+      "debug_get_probe_results",
+      "Fetch captured probe hit data. Returns expression values from each time a probed line executed.",
+      {
+        probeId: z6.string().optional().describe("Filter results by probe ID (resolves to its label)"),
+        label: z6.string().optional().describe("Filter results by probe label"),
+        limit: z6.number().optional().describe("Maximum number of recent hits to return (default: all)")
+      },
+      async ({ probeId, label, limit }) => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          let filterLabel = label;
+          if (probeId && !filterLabel) {
+            const probe = clientOrErr.listProbes().find((p) => p.probeId === probeId);
+            if (probe) filterLabel = probe.label;
+          }
+          const hits = await clientOrErr.getProbeResults(filterLabel, limit);
+          if (hits.length === 0) {
+            const filterDesc = filterLabel ? ` for "${filterLabel}"` : "";
+            return textResult(
+              `No probe hits${filterDesc}. Make sure the probed code path has been triggered.`
+            );
+          }
+          const formatted = formatProbeHits(hits);
+          return textResult(formatted);
+        } catch (error) {
+          return textResult(`Failed to get probe results: ${formatError3(error)}`);
+        }
+      },
+      { annotations: { readOnlyHint: true } }
+    )
+  ];
+}
+function formatProbeHits(hits) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const hit of hits) {
+    const group = grouped.get(hit.label) ?? [];
+    group.push(hit);
+    grouped.set(hit.label, group);
+  }
+  const sections = [];
+  for (const [label, labelHits] of grouped) {
+    const header = `Probe "${label}" \u2014 hit ${labelHits.length} time${labelHits.length === 1 ? "" : "s"}:`;
+    const lines = labelHits.map((hit) => {
+      const time = new Date(hit.timestamp).toLocaleTimeString("en-US", { hour12: false });
+      const entries = Object.entries(hit.data).map(([key, val]) => `${key}=${formatProbeValue(val)}`).join(", ");
+      return `  [${time}] ${entries}`;
+    });
+    sections.push([header, ...lines].join("\n"));
+  }
+  return sections.join("\n\n");
+}
+function formatProbeValue(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") {
+    return value.length > 100 ? `"${value.slice(0, 97)}..."` : `"${value}"`;
+  }
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) {
+    return `Array(${value.length})`;
+  }
+  if (typeof value === "object") {
+    const keys = Object.keys(value);
+    if (keys.length <= 3) {
+      const preview = keys.map((k) => `${k}: ${formatProbeValue(value[k])}`).join(", ");
+      return `{${preview}}`;
+    }
+    return `Object(${keys.length} keys)`;
+  }
+  return String(value);
+}
+function buildExecutionControlTools(manager) {
+  return [
+    tool6(
+      "debug_continue",
+      "Resume execution after the debugger has paused at a breakpoint.",
+      {},
+      async () => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        if (!clientOrErr.isPaused()) {
+          return textResult("Debugger is not paused.");
+        }
+        try {
+          await clientOrErr.resume();
+          return textResult("Execution resumed.");
+        } catch (error) {
+          return textResult(`Failed to resume: ${formatError3(error)}`);
+        }
+      }
+    ),
+    tool6(
+      "debug_step_over",
+      "Step over the current line while paused at a breakpoint. Executes the current line and pauses at the next line in the same function.",
+      {},
+      async () => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        if (!clientOrErr.isPaused()) {
+          return textResult("Debugger is not paused.");
+        }
+        try {
+          await clientOrErr.stepOver();
+          return textResult("Stepped over. Use debug_inspect_paused to see current state.");
+        } catch (error) {
+          return textResult(`Failed to step over: ${formatError3(error)}`);
+        }
+      }
+    ),
+    tool6(
+      "debug_step_into",
+      "Step into the function call on the current line while paused at a breakpoint. Pauses at the first line inside the called function.",
+      {},
+      async () => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        if (!clientOrErr.isPaused()) {
+          return textResult("Debugger is not paused.");
+        }
+        try {
+          await clientOrErr.stepInto();
+          return textResult("Stepped into. Use debug_inspect_paused to see current state.");
+        } catch (error) {
+          return textResult(`Failed to step into: ${formatError3(error)}`);
+        }
+      }
+    )
+  ];
+}
+function buildDebugTools(manager) {
+  return [
+    ...buildDebugLifecycleTools(manager),
+    ...buildBreakpointTools(manager),
+    ...buildProbeManagementTools(manager),
+    ...buildProbeResultTools(manager),
+    ...buildInspectionTools(manager),
+    ...buildExecutionControlTools(manager),
+    ...buildTelemetryTools(manager),
+    ...buildClientDebugTools(manager)
+  ];
+}
+
+// src/tools/index.ts
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function imageBlock(data, mimeType) {
+  return { type: "image", data, mimeType };
+}
+function getTaskModeTools(agentMode, connection) {
+  if (agentMode === "discovery" || agentMode === "auto") {
+    return [buildUpdateTaskTool(connection)];
+  }
+  return [];
+}
+function getModeTools(agentMode, connection, config, context) {
+  if (config.mode === "task") return getTaskModeTools(agentMode, connection);
   switch (agentMode) {
     case "building":
       return context?.isParentTask ? buildPmTools(connection, context?.storyPoints, { includePackTools: true }) : [];
@@ -2582,14 +4364,15 @@ function getModeTools(agentMode, connection, config, context) {
       return config.mode === "pm" ? buildPmTools(connection, context?.storyPoints, { includePackTools: false }) : [];
   }
 }
-function createConveyorMcpServer(connection, config, context, agentMode) {
+function createConveyorMcpServer(connection, config, context, agentMode, debugManager) {
   const commonTools = buildCommonTools(connection, config);
   const effectiveMode = agentMode ?? context?.agentMode ?? void 0;
   const modeTools = getModeTools(effectiveMode, connection, config, context);
   const discoveryTools = effectiveMode === "discovery" || effectiveMode === "auto" ? buildDiscoveryTools(connection, context) : [];
+  const debugTools = debugManager && effectiveMode === "building" ? buildDebugTools(debugManager) : [];
   return createSdkMcpServer({
     name: "conveyor",
-    tools: [...commonTools, ...modeTools, ...discoveryTools]
+    tools: [...commonTools, ...modeTools, ...discoveryTools, ...debugTools]
   });
 }
 
@@ -2667,9 +4450,9 @@ async function handleExitPlanMode(host, input) {
     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.storyPointId) missingProps.push("story points (use update_task_properties)");
     if (!taskProps.title || taskProps.title === "Untitled")
-      missingProps.push("title (use set_task_title)");
+      missingProps.push("title (use update_task_properties)");
     if (missingProps.length > 0) {
       return {
         behavior: "deny",
@@ -2726,7 +4509,9 @@ async function handleAskUserQuestion(host, input) {
   }
   return { behavior: "allow", updatedInput: { questions: input.questions, answers } };
 }
+var DENIAL_WARNING_THRESHOLD = 3;
 function buildCanUseTool(host) {
+  let consecutiveDenials = 0;
   return async (toolName, input) => {
     if (toolName === "ExitPlanMode" && (host.agentMode === "auto" || host.agentMode === "discovery") && !host.hasExitedPlanMode) {
       return await handleExitPlanMode(host, input);
@@ -2734,24 +4519,40 @@ function buildCanUseTool(host) {
     if (toolName === "AskUserQuestion") {
       return await handleAskUserQuestion(host, input);
     }
+    let result;
     switch (host.agentMode) {
       case "discovery":
-        return handleDiscoveryToolAccess(toolName, input);
+        result = handleDiscoveryToolAccess(toolName, input);
+        break;
       case "building":
-        return handleBuildingToolAccess(toolName, input);
+        result = handleBuildingToolAccess(toolName, input);
+        break;
       case "review":
-        return handleReviewToolAccess(toolName, input, host.isParentTask);
+        result = handleReviewToolAccess(toolName, input, host.isParentTask);
+        break;
       case "auto":
-        return handleAutoToolAccess(toolName, input, host.hasExitedPlanMode, host.isParentTask);
+        result = handleAutoToolAccess(toolName, input, host.hasExitedPlanMode, host.isParentTask);
+        break;
       default:
-        return { behavior: "allow", updatedInput: input };
+        result = { behavior: "allow", updatedInput: input };
+    }
+    if (result.behavior === "deny") {
+      consecutiveDenials++;
+      if (consecutiveDenials === DENIAL_WARNING_THRESHOLD) {
+        host.connection.postChatMessage(
+          `\u26A0\uFE0F Multiple tool denials detected. You are in ${host.agentMode} mode \u2014 file writes outside .claude/plans/ are not permitted. Focus on creating a plan instead of implementing code changes.`
+        );
+      }
+    } else {
+      consecutiveDenials = 0;
     }
+    return result;
   };
 }
 
 // src/execution/query-executor.ts
-var logger2 = createServiceLogger("QueryExecutor");
-var API_ERROR_PATTERN2 = /API Error: [45]\d\d/;
+var logger3 = createServiceLogger("QueryExecutor");
+var API_ERROR_PATTERN3 = /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) {
@@ -2827,7 +4628,7 @@ function buildQueryOptions(host, context) {
     },
     settingSources,
     cwd: host.config.workspaceDir,
-    permissionMode: needsCanUseTool ? "acceptEdits" : "bypassPermissions",
+    permissionMode: needsCanUseTool ? "plan" : "bypassPermissions",
     allowDangerouslySkipPermissions: !needsCanUseTool,
     canUseTool: buildCanUseTool(host),
     tools: { type: "preset", preset: "claude_code" },
@@ -2841,7 +4642,7 @@ function buildQueryOptions(host, context) {
     disallowedTools: buildDisallowedTools(settings, mode, host.hasExitedPlanMode),
     enableFileCheckpointing: settings.enableFileCheckpointing,
     stderr: (data) => {
-      logger2.warn("Claude Code stderr", { data: data.trimEnd() });
+      logger3.warn("Claude Code stderr", { data: data.trimEnd() });
     }
   };
   if (isCloud && isReadOnly) {
@@ -2971,6 +4772,29 @@ async function buildRetryQuery(host, context, options, lastErrorWasImage) {
     options: { ...options, resume: void 0 }
   });
 }
+async function handleAuthError(context, host, options) {
+  host.connection.postChatMessage("Authentication expired. Re-bootstrapping credentials...");
+  const refreshed = await host.connection.refreshAuthToken();
+  if (!refreshed) {
+    host.connection.postChatMessage("Failed to refresh authentication. Agent will restart.");
+    host.connection.sendEvent({
+      type: "error",
+      message: "Auth re-bootstrap failed, exiting for restart"
+    });
+    process.exit(1);
+  }
+  context.claudeSessionId = null;
+  host.connection.storeSessionId("");
+  const freshPrompt = buildMultimodalPrompt(
+    await 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 handleStaleSession(context, host, options) {
   context.claudeSessionId = null;
   host.connection.storeSessionId("");
@@ -3002,12 +4826,17 @@ function isStaleOrExitedSession(error, context) {
   if (error.message.includes("No conversation found with session ID")) return true;
   return !!context.claudeSessionId && error.message.includes("process exited");
 }
+function getErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  return String(error);
+}
 function isRetriableError(error) {
-  if (!(error instanceof Error)) return false;
-  return API_ERROR_PATTERN2.test(error.message) || IMAGE_ERROR_PATTERN2.test(error.message);
+  const message = getErrorMessage(error);
+  return API_ERROR_PATTERN3.test(message) || IMAGE_ERROR_PATTERN2.test(message);
 }
 function classifyImageError(error) {
-  return error instanceof Error && IMAGE_ERROR_PATTERN2.test(error.message);
+  return IMAGE_ERROR_PATTERN2.test(getErrorMessage(error));
 }
 async function emitRetryStatus(host, attempt, delayMs) {
   const delayMin = Math.round(delayMs / 6e4);
@@ -3034,26 +4863,41 @@ function handleRetryError(error, context, host, options, prevImageError) {
   if (isStaleOrExitedSession(error, context) && context.claudeSessionId) {
     return handleStaleSession(context, host, options);
   }
+  if (isAuthError(getErrorMessage(error))) {
+    return handleAuthError(context, host, options);
+  }
   if (!isRetriableError(error)) throw error;
   return { action: "continue", lastErrorWasImage: classifyImageError(error) || prevImageError };
 }
+function handleProcessResult(result, context, host, options) {
+  if (result.modeRestart || host.isStopped()) return { action: "return" };
+  if (result.rateLimitResetsAt) {
+    handleRateLimitPause(host, result.rateLimitResetsAt);
+    return { action: "return" };
+  }
+  if (result.staleSession && context.claudeSessionId) {
+    return { action: "return_promise", promise: handleStaleSession(context, host, options) };
+  }
+  if (result.authError) {
+    return { action: "return_promise", promise: handleAuthError(context, host, options) };
+  }
+  if (!result.retriable) return { action: "return" };
+  return {
+    action: "continue",
+    lastErrorWasImage: IMAGE_ERROR_PATTERN2.test(result.resultSummary ?? "")
+  };
+}
 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 : await buildRetryQuery(host, context, options, lastErrorWasImage);
     try {
-      const { retriable, resultSummary, modeRestart, rateLimitResetsAt, staleSession } = await processEvents(agentQuery, context, host);
-      if (modeRestart || host.isStopped()) return;
-      if (rateLimitResetsAt) {
-        handleRateLimitPause(host, rateLimitResetsAt);
-        return;
-      }
-      if (staleSession && context.claudeSessionId) {
-        return handleStaleSession(context, host, options);
-      }
-      if (!retriable) return;
-      lastErrorWasImage = IMAGE_ERROR_PATTERN2.test(resultSummary ?? "");
+      const result = await processEvents(agentQuery, context, host);
+      const outcome = handleProcessResult(result, context, host, options);
+      if (outcome.action === "return") return;
+      if (outcome.action === "return_promise") return outcome.promise;
+      lastErrorWasImage = outcome.lastErrorWasImage;
     } catch (error) {
       const outcome = handleRetryError(error, context, host, options, lastErrorWasImage);
       if (outcome instanceof Promise) return outcome;
@@ -3227,6 +5071,47 @@ async function executeSetupConfig(config, runnerConfig, connection, setupLog) {
 async function checkoutTaskBranch(runnerConfig, connection, callbacks, setupLog) {
   const taskBranch = process.env.CONVEYOR_TASK_BRANCH;
   if (!taskBranch) return true;
+  const currentBranch = getCurrentBranch(runnerConfig.workspaceDir);
+  if (currentBranch === taskBranch) {
+    pushSetupLog(setupLog, `[conveyor] Already on ${taskBranch}, skipping checkout`);
+    connection.sendEvent({
+      type: "setup_output",
+      stream: "stdout",
+      data: `Already on branch ${taskBranch}, skipping checkout
+`
+    });
+    try {
+      await runSetupCommand(
+        `git fetch origin ${taskBranch}`,
+        runnerConfig.workspaceDir,
+        (stream, data) => {
+          connection.sendEvent({ type: "setup_output", stream, data });
+        }
+      );
+    } catch {
+    }
+    return true;
+  }
+  let didStash = false;
+  if (hasUncommittedChanges(runnerConfig.workspaceDir)) {
+    pushSetupLog(setupLog, `[conveyor] Uncommitted changes detected, stashing before checkout`);
+    connection.sendEvent({
+      type: "setup_output",
+      stream: "stdout",
+      data: "Uncommitted changes detected \u2014 stashing before branch switch\n"
+    });
+    try {
+      await runSetupCommand(
+        `git stash push -m "conveyor-auto-stash"`,
+        runnerConfig.workspaceDir,
+        (stream, data) => {
+          connection.sendEvent({ type: "setup_output", stream, data });
+        }
+      );
+      didStash = true;
+    } catch {
+    }
+  }
   pushSetupLog(setupLog, `[conveyor] Switching to task branch ${taskBranch}...`);
   connection.sendEvent({
     type: "setup_output",
@@ -3246,6 +5131,19 @@ async function checkoutTaskBranch(runnerConfig, connection, callbacks, setupLog)
       }
     );
     pushSetupLog(setupLog, `[conveyor] Switched to ${taskBranch}`);
+    if (didStash) {
+      try {
+        await runSetupCommand("git stash pop", runnerConfig.workspaceDir, (stream, data) => {
+          connection.sendEvent({ type: "setup_output", stream, data });
+        });
+        pushSetupLog(setupLog, `[conveyor] Restored stashed changes`);
+      } catch {
+        pushSetupLog(
+          setupLog,
+          `[conveyor] Warning: stash pop had conflicts \u2014 agent may need to resolve`
+        );
+      }
+    }
     return true;
   } catch (error) {
     const message = `Failed to checkout ${taskBranch}: ${error instanceof Error ? error.message : "unknown error"}`;
@@ -3433,7 +5331,7 @@ function buildQueryHost(deps) {
 }
 
 // src/runner/agent-runner.ts
-var logger3 = createServiceLogger("AgentRunner");
+var logger4 = createServiceLogger("AgentRunner");
 var HEARTBEAT_INTERVAL_MS = 3e4;
 var IDLE_TIMEOUT_MS = 30 * 60 * 1e3;
 var AgentRunner = class {
@@ -3462,6 +5360,7 @@ var AgentRunner = class {
   idleCheckInterval = null;
   conveyorConfig = null;
   _queryHost = null;
+  tunnelClient = null;
   constructor(config, callbacks) {
     this.config = config;
     this.connection = new ConveyorConnection(config);
@@ -3536,11 +5435,13 @@ var AgentRunner = class {
     }
     this.tryInitWorktree();
     if (!await this.fetchAndInitContext()) return;
+    this.startPreviewTunnel();
     this.tryPostContextWorktree();
     this.checkoutWorktreeBranch();
     await this.executeInitialMode();
     await this.runCoreLoop();
     this.stopHeartbeat();
+    this.tunnelClient?.disconnect();
     await this.setState("finished");
     this.connection.disconnect();
   }
@@ -3573,6 +5474,11 @@ var AgentRunner = class {
       this.activateWorktree("[conveyor] Using worktree (from task config):");
     }
   }
+  startPreviewTunnel() {
+    const port = this.conveyorConfig?.previewPort ?? (Number(process.env.CONVEYOR_PREVIEW_PORT) || 3050);
+    this.tunnelClient = new TunnelClient(this.config.conveyorApiUrl, this.config.taskToken, port);
+    this.tunnelClient.connect();
+  }
   activateWorktree(logPrefix) {
     try {
       const worktreePath = ensureWorktree(this.config.workspaceDir, this.config.taskId);
@@ -3590,12 +5496,22 @@ var AgentRunner = class {
   }
   checkoutWorktreeBranch() {
     if (!this.worktreeActive || !this.taskContext?.githubBranch) return;
+    const branch = this.taskContext.githubBranch;
+    const cwd = this.config.workspaceDir;
+    if (getCurrentBranch(cwd) === branch) return;
     try {
-      const branch = this.taskContext.githubBranch;
-      execSync4(`git fetch origin ${branch} && git checkout ${branch}`, {
-        cwd: this.config.workspaceDir,
-        stdio: "ignore"
-      });
+      let didStash = false;
+      if (hasUncommittedChanges(cwd)) {
+        execSync5(`git stash push -m "conveyor-auto-stash"`, { cwd, stdio: "ignore" });
+        didStash = true;
+      }
+      execSync5(`git fetch origin ${branch} && git checkout ${branch}`, { cwd, stdio: "ignore" });
+      if (didStash) {
+        try {
+          execSync5("git stash pop", { cwd, stdio: "ignore" });
+        } catch {
+        }
+      }
     } catch {
     }
   }
@@ -3722,7 +5638,7 @@ var AgentRunner = class {
     const s = this.taskContext.agentSettings ?? this.config.agentSettings ?? {};
     const model = this.taskContext.model || this.config.model;
     const thinking = formatThinkingSetting(s.thinking);
-    logger3.info("Effective agent settings", {
+    logger4.info("Effective agent settings", {
       model,
       mode: this.config.mode ?? "task",
       effort: s.effort ?? "default",
@@ -3764,15 +5680,11 @@ var AgentRunner = class {
         }
       }, 1e3);
       this.idleTimer = setTimeout(() => {
-        this.clearIdleTimers();
-        this.inputResolver = null;
-        logger3.info("Idle timeout reached, shutting down", {
+        logger4.info("Idle timeout reached, entering sleep mode", {
           idleMinutes: IDLE_TIMEOUT_MS / 6e4
         });
-        this.connection.postChatMessage(
-          `Agent idle for ${IDLE_TIMEOUT_MS / 6e4} minutes with no new messages \u2014 shutting down.`
-        );
-        resolve2(null);
+        this.connection.emitStatus("sleeping");
+        this.connection.postChatMessage("Agent sleeping \u2014 send a message or click Resume to wake.");
       }, IDLE_TIMEOUT_MS);
       this.inputResolver = (msg) => {
         this.clearIdleTimers();
@@ -3864,32 +5776,290 @@ var AgentRunner = class {
       if (typeof q.interrupt === "function") {
         void q.interrupt();
       }
-      host.activeQuery = null;
-    }
-    if (this.inputResolver) {
-      this.inputResolver(null);
-      this.inputResolver = null;
-    }
-  }
-  stop() {
-    this.stopped = true;
-    this.clearIdleTimers();
-    if (this.inputResolver) {
-      this.inputResolver(null);
-      this.inputResolver = null;
-    }
-  }
-};
-
-// src/runner/project-runner.ts
-import { fork } from "child_process";
-import { execSync as execSync5 } from "child_process";
-import * as path from "path";
-import { fileURLToPath } from "url";
+      host.activeQuery = null;
+    }
+    if (this.inputResolver) {
+      this.inputResolver(null);
+      this.inputResolver = null;
+    }
+  }
+  stop() {
+    this.stopped = true;
+    this.clearIdleTimers();
+    this.tunnelClient?.disconnect();
+    if (this.inputResolver) {
+      this.inputResolver(null);
+      this.inputResolver = null;
+    }
+  }
+};
+
+// src/runner/project-runner.ts
+import { fork } from "child_process";
+import { execSync as execSync7 } from "child_process";
+import * as path from "path";
+import { fileURLToPath } from "url";
+
+// src/runner/commit-watcher.ts
+import { execSync as execSync6 } from "child_process";
+var logger5 = createServiceLogger("CommitWatcher");
+var CommitWatcher = class {
+  constructor(config, callbacks) {
+    this.config = config;
+    this.callbacks = callbacks;
+  }
+  interval = null;
+  lastKnownRemoteSha = null;
+  branch = null;
+  debounceTimer = null;
+  isSyncing = false;
+  start(branch) {
+    this.stop();
+    this.branch = branch;
+    this.lastKnownRemoteSha = this.getLocalHeadSha();
+    this.interval = setInterval(() => void this.poll(), this.config.pollIntervalMs);
+    logger5.info("Commit watcher started", {
+      branch,
+      baseSha: this.lastKnownRemoteSha?.slice(0, 8)
+    });
+  }
+  stop() {
+    if (this.interval) clearInterval(this.interval);
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.interval = null;
+    this.debounceTimer = null;
+    this.branch = null;
+    this.lastKnownRemoteSha = null;
+    this.isSyncing = false;
+  }
+  getLocalHeadSha() {
+    return execSync6("git rev-parse HEAD", {
+      cwd: this.config.projectDir,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+  }
+  poll() {
+    if (!this.branch || this.isSyncing) return;
+    try {
+      execSync6(`git fetch origin ${this.branch} --quiet`, {
+        cwd: this.config.projectDir,
+        stdio: "ignore",
+        timeout: 3e4
+      });
+      const remoteSha = execSync6(`git rev-parse origin/${this.branch}`, {
+        cwd: this.config.projectDir,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).toString().trim();
+      if (remoteSha !== this.lastKnownRemoteSha) {
+        if (this.debounceTimer) clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(
+          () => void this.handleNewCommits(remoteSha),
+          this.config.debounceMs
+        );
+      }
+    } catch {
+    }
+  }
+  async handleNewCommits(remoteSha) {
+    if (!this.branch) return;
+    const previousSha = this.lastKnownRemoteSha ?? "HEAD";
+    let commitCount = 1;
+    let latestMessage = "";
+    let latestAuthor = "";
+    try {
+      const countOutput = execSync6(`git rev-list --count ${previousSha}..origin/${this.branch}`, {
+        cwd: this.config.projectDir,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).toString().trim();
+      commitCount = parseInt(countOutput, 10) || 1;
+      const logOutput = execSync6(`git log -1 --format="%s|||%an" origin/${this.branch}`, {
+        cwd: this.config.projectDir,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).toString().trim();
+      const parts = logOutput.split("|||");
+      latestMessage = parts[0] ?? "";
+      latestAuthor = parts[1] ?? "";
+    } catch {
+    }
+    this.lastKnownRemoteSha = remoteSha;
+    this.isSyncing = true;
+    logger5.info("New commits detected", {
+      branch: this.branch,
+      commitCount,
+      sha: remoteSha.slice(0, 8)
+    });
+    try {
+      await this.callbacks.onNewCommits({
+        branch: this.branch,
+        previousSha,
+        newCommitSha: remoteSha,
+        commitCount,
+        latestMessage,
+        latestAuthor
+      });
+    } catch (err) {
+      logger5.error("Error handling new commits", errorMeta(err));
+    } finally {
+      this.isSyncing = false;
+    }
+  }
+};
+
+// src/runner/project-chat-handler.ts
+import {
+  query as query2,
+  createSdkMcpServer as createSdkMcpServer2
+} from "@anthropic-ai/claude-agent-sdk";
+
+// src/tools/project-tools.ts
+import { tool as tool7 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z7 } from "zod";
+function buildReadTools(connection) {
+  return [
+    tool7(
+      "list_tasks",
+      "List tasks in the project. Optionally filter by status or assignee.",
+      {
+        status: z7.string().optional().describe("Filter by task status (e.g. Planning, Open, InProgress, ReviewPR, Complete)"),
+        assigneeId: z7.string().optional().describe("Filter by assigned user ID"),
+        limit: z7.number().optional().describe("Max number of tasks to return (default 50)")
+      },
+      async (params) => {
+        try {
+          const tasks = await connection.requestListTasks(params);
+          return textResult(JSON.stringify(tasks, null, 2));
+        } catch (error) {
+          return textResult(
+            `Failed to list tasks: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      },
+      { annotations: { readOnlyHint: true } }
+    ),
+    tool7(
+      "get_task",
+      "Get detailed information about a task including its chat messages, child tasks, and codespace status.",
+      { task_id: z7.string().describe("The task ID to look up") },
+      async ({ task_id }) => {
+        try {
+          const task = await connection.requestGetTask(task_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 } }
+    ),
+    tool7(
+      "search_tasks",
+      "Search tasks by tags, text query, or status filters.",
+      {
+        tagNames: z7.array(z7.string()).optional().describe("Filter by tag names"),
+        searchQuery: z7.string().optional().describe("Text search in title/description"),
+        statusFilters: z7.array(z7.string()).optional().describe("Filter by statuses"),
+        limit: z7.number().optional().describe("Max results (default 20)")
+      },
+      async (params) => {
+        try {
+          const tasks = await connection.requestSearchTasks(params);
+          return textResult(JSON.stringify(tasks, null, 2));
+        } catch (error) {
+          return textResult(
+            `Failed to search tasks: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      },
+      { annotations: { readOnlyHint: true } }
+    ),
+    tool7(
+      "list_tags",
+      "List all tags available in the project.",
+      {},
+      async () => {
+        try {
+          const tags = await connection.requestListTags();
+          return textResult(JSON.stringify(tags, null, 2));
+        } catch (error) {
+          return textResult(
+            `Failed to list tags: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      },
+      { annotations: { readOnlyHint: true } }
+    ),
+    tool7(
+      "get_project_summary",
+      "Get a summary of the project including task counts by status and active builds.",
+      {},
+      async () => {
+        try {
+          const summary = await connection.requestGetProjectSummary();
+          return textResult(JSON.stringify(summary, null, 2));
+        } catch (error) {
+          return textResult(
+            `Failed to get project summary: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      },
+      { annotations: { readOnlyHint: true } }
+    )
+  ];
+}
+function buildMutationTools(connection) {
+  return [
+    tool7(
+      "create_task",
+      "Create a new task in the project.",
+      {
+        title: z7.string().describe("Task title"),
+        description: z7.string().optional().describe("Task description"),
+        plan: z7.string().optional().describe("Implementation plan in markdown"),
+        status: z7.string().optional().describe("Initial status (default: Planning)"),
+        isBug: z7.boolean().optional().describe("Whether this is a bug report")
+      },
+      async (params) => {
+        try {
+          const result = await connection.requestCreateTask(params);
+          return textResult(`Task created: ${result.slug} (ID: ${result.id})`);
+        } catch (error) {
+          return textResult(
+            `Failed to create task: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      }
+    ),
+    tool7(
+      "update_task",
+      "Update an existing task's title, description, plan, status, or assignee.",
+      {
+        task_id: z7.string().describe("The task ID to update"),
+        title: z7.string().optional().describe("New title"),
+        description: z7.string().optional().describe("New description"),
+        plan: z7.string().optional().describe("New plan in markdown"),
+        status: z7.string().optional().describe("New status"),
+        assignedUserId: z7.string().nullable().optional().describe("Assign to user ID, or null to unassign")
+      },
+      async ({ task_id, ...fields }) => {
+        try {
+          await connection.requestUpdateTask({ taskId: task_id, ...fields });
+          return textResult("Task updated successfully.");
+        } catch (error) {
+          return textResult(
+            `Failed to update task: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      }
+    )
+  ];
+}
+function buildProjectTools(connection) {
+  return [...buildReadTools(connection), ...buildMutationTools(connection)];
+}
 
 // src/runner/project-chat-handler.ts
-import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
-var logger4 = createServiceLogger("ProjectChat");
+var logger6 = createServiceLogger("ProjectChat");
 var FALLBACK_MODEL = "claude-sonnet-4-20250514";
 function buildSystemPrompt2(projectDir, agentCtx) {
   const parts = [];
@@ -3942,27 +6112,31 @@ function processContentBlock(block, responseParts, turnToolCalls) {
       input: inputStr.slice(0, 1e4),
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
-    logger4.debug("Tool use", { tool: block.name });
+    logger6.debug("Tool use", { tool: block.name });
   }
 }
-async function fetchContext(connection) {
+async function fetchContext(connection, chatId) {
   let agentCtx = null;
   try {
     agentCtx = await connection.fetchAgentContext();
   } catch {
-    logger4.warn("Could not fetch agent context, using defaults");
+    logger6.warn("Could not fetch agent context, using defaults");
   }
   let chatHistory = [];
   try {
-    chatHistory = await connection.fetchChatHistory(30);
+    chatHistory = await connection.fetchChatHistory(30, chatId);
   } catch {
-    logger4.warn("Could not fetch chat history, proceeding without it");
+    logger6.warn("Could not fetch chat history, proceeding without it");
   }
   return { agentCtx, chatHistory };
 }
-function buildChatQueryOptions(agentCtx, projectDir) {
+function buildChatQueryOptions(agentCtx, projectDir, connection) {
   const model = agentCtx?.model || FALLBACK_MODEL;
   const settings = agentCtx?.agentSettings ?? {};
+  const mcpServer = createSdkMcpServer2({
+    name: "conveyor",
+    tools: buildProjectTools(connection)
+  });
   return {
     model,
     systemPrompt: {
@@ -3974,12 +6148,48 @@ function buildChatQueryOptions(agentCtx, projectDir) {
     permissionMode: "bypassPermissions",
     allowDangerouslySkipPermissions: true,
     tools: { type: "preset", preset: "claude_code" },
-    maxTurns: settings.maxTurns ?? 15,
-    maxBudgetUsd: settings.maxBudgetUsd ?? 5,
+    mcpServers: { conveyor: mcpServer },
+    maxTurns: settings.maxTurns ?? 30,
+    maxBudgetUsd: settings.maxBudgetUsd ?? 50,
     effort: settings.effort,
     thinking: settings.thinking
   };
 }
+function emitResultCostAndContext(event, connection) {
+  const resultEvent = event;
+  if (resultEvent.total_cost_usd !== void 0 && resultEvent.total_cost_usd > 0) {
+    connection.emitEvent({
+      type: "cost_update",
+      costUsd: resultEvent.total_cost_usd
+    });
+  }
+  if (resultEvent.modelUsage && typeof resultEvent.modelUsage === "object") {
+    const modelUsage = resultEvent.modelUsage;
+    let contextWindow = 0;
+    let totalInputTokens = 0;
+    let totalCacheRead = 0;
+    let totalCacheCreation = 0;
+    for (const data of Object.values(modelUsage)) {
+      const d = data;
+      totalInputTokens += d.inputTokens ?? 0;
+      totalCacheRead += d.cacheReadInputTokens ?? 0;
+      totalCacheCreation += d.cacheCreationInputTokens ?? 0;
+      const cw = d.contextWindow ?? 0;
+      if (cw > contextWindow) contextWindow = cw;
+    }
+    if (contextWindow > 0) {
+      const queryInputTokens = totalInputTokens + totalCacheRead + totalCacheCreation;
+      connection.emitEvent({
+        type: "context_update",
+        contextTokens: queryInputTokens,
+        contextWindow,
+        inputTokens: totalInputTokens,
+        cacheReadInputTokens: totalCacheRead,
+        cacheCreationInputTokens: totalCacheCreation
+      });
+    }
+  }
+}
 function processEventStream(event, connection, responseParts, turnToolCalls, isTyping) {
   if (event.type === "assistant") {
     if (!isTyping.value) {
@@ -4001,19 +6211,30 @@ function processEventStream(event, connection, responseParts, turnToolCalls, isT
       connection.emitEvent({ type: "agent_typing_stop" });
       isTyping.value = false;
     }
+    emitResultCostAndContext(event, connection);
     return true;
   }
   return false;
 }
-async function runChatQuery(message, connection, projectDir) {
-  const { agentCtx, chatHistory } = await fetchContext(connection);
-  const options = buildChatQueryOptions(agentCtx, projectDir);
+async function runChatQuery(message, connection, projectDir, sessionId) {
+  const { agentCtx, chatHistory } = await fetchContext(connection, message.chatId);
+  const options = buildChatQueryOptions(agentCtx, projectDir, connection);
   const prompt = buildPrompt(message, chatHistory);
-  const events = query2({ prompt, options });
+  connection.emitAgentStatus("running");
+  const events = query2({
+    prompt,
+    options,
+    ...sessionId ? { resume: sessionId } : {}
+  });
   const responseParts = [];
   const turnToolCalls = [];
   const isTyping = { value: false };
+  let resultSessionId;
   for await (const event of events) {
+    if (event.type === "result") {
+      const resultEvent = event;
+      resultSessionId = resultEvent.sessionId;
+    }
     const done = processEventStream(event, connection, responseParts, turnToolCalls, isTyping);
     if (done) break;
   }
@@ -4024,26 +6245,416 @@ async function runChatQuery(message, connection, projectDir) {
   if (responseText) {
     await connection.emitChatMessage(responseText);
   }
+  return resultSessionId;
 }
-async function handleProjectChatMessage(message, connection, projectDir) {
-  connection.emitAgentStatus("busy");
+async function handleProjectChatMessage(message, connection, projectDir, sessionId) {
+  connection.emitAgentStatus("fetching_context");
   try {
-    await runChatQuery(message, connection, projectDir);
+    return await runChatQuery(message, connection, projectDir, sessionId);
   } catch (error) {
-    logger4.error("Failed to handle message", errorMeta(error));
+    logger6.error("Failed to handle message", errorMeta(error));
+    connection.emitAgentStatus("error");
     try {
       await connection.emitChatMessage(
         "I encountered an error processing your message. Please try again."
       );
     } catch {
     }
+    return void 0;
+  } finally {
+    connection.emitAgentStatus("idle");
+  }
+}
+
+// src/runner/project-audit-handler.ts
+import { query as query3 } from "@anthropic-ai/claude-agent-sdk";
+
+// src/tools/audit-tools.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { tool as tool8, createSdkMcpServer as createSdkMcpServer3 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z8 } from "zod";
+function mapCreateTag(input) {
+  return {
+    type: "create_tag",
+    tagName: input.name,
+    suggestion: `Create new tag "${input.name}"${input.description ? `: ${input.description}` : ""}`,
+    reasoning: input.reasoning,
+    payload: { name: input.name, color: input.color ?? "#6B7280", description: input.description }
+  };
+}
+function mapUpdateDescription(input) {
+  return {
+    type: "update_description",
+    tagId: input.tagId,
+    tagName: input.tagName,
+    suggestion: `Update description for "${input.tagName}"`,
+    reasoning: input.reasoning,
+    payload: { description: input.description }
+  };
+}
+function mapContextLink(input) {
+  return {
+    type: "add_context_link",
+    tagId: input.tagId,
+    tagName: input.tagName,
+    suggestion: `Link ${input.linkType}:${input.path} to "${input.tagName}"`,
+    reasoning: input.reasoning,
+    payload: { contextLink: { type: input.linkType, path: input.path, label: input.label } }
+  };
+}
+function mapDocGap(input) {
+  return {
+    type: "documentation_gap",
+    tagId: input.tagId,
+    tagName: input.tagName,
+    suggestion: `Documentation gap: ${input.filePath} (${input.readCount} reads)`,
+    reasoning: input.reasoning,
+    payload: {
+      filePath: input.filePath,
+      readCount: input.readCount,
+      suggestedAction: input.suggestedAction
+    }
+  };
+}
+function mapMergeTags(input) {
+  return {
+    type: "merge_tags",
+    tagId: input.tagId,
+    tagName: input.tagName,
+    suggestion: `Merge "${input.tagName}" into "${input.mergeIntoTagName}"`,
+    reasoning: input.reasoning,
+    payload: { mergeIntoTagId: input.mergeIntoTagId }
+  };
+}
+function mapRenameTag(input) {
+  return {
+    type: "rename_tag",
+    tagId: input.tagId,
+    tagName: input.tagName,
+    suggestion: `Rename "${input.tagName}" to "${input.newName}"`,
+    reasoning: input.reasoning,
+    payload: { newName: input.newName }
+  };
+}
+var TOOL_MAPPERS = {
+  recommend_create_tag: mapCreateTag,
+  recommend_update_description: mapUpdateDescription,
+  recommend_context_link: mapContextLink,
+  flag_documentation_gap: mapDocGap,
+  recommend_merge_tags: mapMergeTags,
+  recommend_rename_tag: mapRenameTag
+};
+function collectRecommendation(toolName, input, collector, onRecommendation) {
+  const mapper = TOOL_MAPPERS[toolName];
+  if (!mapper) return JSON.stringify({ error: `Unknown tool: ${toolName}` });
+  const rec = { id: randomUUID3(), ...mapper(input) };
+  collector.recommendations.push(rec);
+  onRecommendation?.({ tagName: rec.tagName ?? rec.type, type: rec.type });
+  return JSON.stringify({ success: true, recommendationId: rec.id });
+}
+function createAuditMcpServer(collector, onRecommendation) {
+  const auditTools = [
+    tool8(
+      "recommend_create_tag",
+      "Recommend creating a new tag for an uncovered subsystem or area",
+      {
+        name: z8.string().describe("Proposed tag name (lowercase, hyphenated)"),
+        color: z8.string().optional().describe("Hex color code"),
+        description: z8.string().describe("What this tag covers"),
+        reasoning: z8.string().describe("Why this tag should be created")
+      },
+      async (args) => {
+        const result = collectRecommendation(
+          "recommend_create_tag",
+          args,
+          collector,
+          onRecommendation
+        );
+        return { content: [{ type: "text", text: result }] };
+      }
+    ),
+    tool8(
+      "recommend_update_description",
+      "Recommend updating a tag's description to better reflect its scope",
+      {
+        tagId: z8.string(),
+        tagName: z8.string(),
+        description: z8.string().describe("Proposed new description"),
+        reasoning: z8.string()
+      },
+      async (args) => {
+        const result = collectRecommendation(
+          "recommend_update_description",
+          args,
+          collector,
+          onRecommendation
+        );
+        return { content: [{ type: "text", text: result }] };
+      }
+    ),
+    tool8(
+      "recommend_context_link",
+      "Recommend linking a doc, rule, file, or folder to a tag's contextPaths",
+      {
+        tagId: z8.string(),
+        tagName: z8.string(),
+        linkType: z8.enum(["rule", "doc", "file", "folder"]),
+        path: z8.string(),
+        label: z8.string().optional(),
+        reasoning: z8.string()
+      },
+      async (args) => {
+        const result = collectRecommendation(
+          "recommend_context_link",
+          args,
+          collector,
+          onRecommendation
+        );
+        return { content: [{ type: "text", text: result }] };
+      }
+    ),
+    tool8(
+      "flag_documentation_gap",
+      "Flag a file that agents read heavily but has no tag documentation linked",
+      {
+        tagName: z8.string().describe("Tag whose agents read this file"),
+        tagId: z8.string().optional(),
+        filePath: z8.string(),
+        readCount: z8.number(),
+        suggestedAction: z8.string().describe("What doc or rule should be created"),
+        reasoning: z8.string()
+      },
+      async (args) => {
+        const result = collectRecommendation(
+          "flag_documentation_gap",
+          args,
+          collector,
+          onRecommendation
+        );
+        return { content: [{ type: "text", text: result }] };
+      }
+    ),
+    tool8(
+      "recommend_merge_tags",
+      "Recommend merging one tag into another",
+      {
+        tagId: z8.string().describe("Tag ID to be merged (removed after merge)"),
+        tagName: z8.string().describe("Name of the tag to be merged"),
+        mergeIntoTagId: z8.string().describe("Tag ID to merge into (kept)"),
+        mergeIntoTagName: z8.string(),
+        reasoning: z8.string()
+      },
+      async (args) => {
+        const result = collectRecommendation(
+          "recommend_merge_tags",
+          args,
+          collector,
+          onRecommendation
+        );
+        return { content: [{ type: "text", text: result }] };
+      }
+    ),
+    tool8(
+      "recommend_rename_tag",
+      "Recommend renaming a tag",
+      {
+        tagId: z8.string(),
+        tagName: z8.string().describe("Current tag name"),
+        newName: z8.string().describe("Proposed new name"),
+        reasoning: z8.string()
+      },
+      async (args) => {
+        const result = collectRecommendation(
+          "recommend_rename_tag",
+          args,
+          collector,
+          onRecommendation
+        );
+        return { content: [{ type: "text", text: result }] };
+      }
+    ),
+    tool8(
+      "complete_audit",
+      "Signal that the audit is complete with a summary of all findings",
+      { summary: z8.string().describe("Brief overview of all findings") },
+      async (args) => {
+        collector.complete = true;
+        collector.summary = args.summary ?? "Audit completed.";
+        return { content: [{ type: "text", text: JSON.stringify({ success: true }) }] };
+      }
+    )
+  ];
+  return createSdkMcpServer3({
+    name: "tag-audit",
+    tools: auditTools
+  });
+}
+
+// src/runner/project-audit-handler.ts
+var logger7 = createServiceLogger("ProjectAudit");
+var FALLBACK_MODEL2 = "claude-sonnet-4-20250514";
+function buildTagSection(tags) {
+  if (tags.length === 0) return "No tags configured yet.";
+  return tags.map((t) => {
+    const paths = t.contextPaths ?? [];
+    const pathStr = paths.length > 0 ? `
+    Context links: ${paths.map((p) => `${p.type}:${p.path}`).join(", ")}` : "";
+    return `  - ${t.name} (id: ${t.id})${t.description ? `: ${t.description}` : " [no description]"}${pathStr}
+    Active tasks: ${t.activeTaskCount}`;
+  }).join("\n");
+}
+function buildHeatmapSection(entries) {
+  if (entries.length === 0) return "No file read analytics data available.";
+  return entries.slice(0, 50).map((e) => {
+    const tagBreakdown = Object.entries(e.byTag).sort(([, a], [, b]) => b - a).map(([tag, count]) => `${tag}:${count}`).join(", ");
+    return `  ${e.filePath} \u2014 ${e.totalReads} reads${tagBreakdown ? ` (${tagBreakdown})` : ""}`;
+  }).join("\n");
+}
+function buildAuditSystemPrompt(projectName, tags, heatmapData, projectDir) {
+  return [
+    "You are a project organization expert analyzing tag taxonomy for a software project.",
+    "Tags are used to categorize tasks and link relevant documentation/rules/files to subsystems.",
+    "",
+    `PROJECT: ${projectName}`,
+    "",
+    `EXISTING TAGS (${tags.length}):`,
+    buildTagSection(tags),
+    "",
+    "FILE READ ANALYTICS (what agents actually read, by tag):",
+    buildHeatmapSection(heatmapData),
+    "",
+    `You have full access to the codebase at: ${projectDir}`,
+    "Use your file reading and searching tools to understand the codebase structure,",
+    "module boundaries, and architectural patterns before making recommendations.",
+    "",
+    "ANALYSIS TASKS:",
+    "1. Read actual source files to understand code areas and module boundaries",
+    "2. Search for imports, class definitions, and architectural patterns",
+    "3. Coverage: Are all major subsystems/services represented by tags?",
+    "4. Descriptions: Do all tags have clear, useful descriptions?",
+    "5. Context Links: Are relevant rules/docs/folders linked to tags via contextPaths?",
+    "6. Documentation Gaps: Which high-read files lack linked documentation?",
+    "7. Cleanup: Any tags that should be merged, renamed, or removed?",
+    "",
+    "Use the tag-audit MCP tools to submit each recommendation.",
+    "Call complete_audit when you are done with a thorough summary.",
+    "Be comprehensive \u2014 recommend all improvements your analysis supports.",
+    "Analyze actual file contents, not just file names."
+  ].join("\n");
+}
+function emitToolCallProgress(event, request, connection) {
+  if (event.type !== "assistant") return;
+  const assistantEvent = event;
+  for (const block of assistantEvent.message.content) {
+    if (block.type === "tool_use" && block.name) {
+      const inputStr = typeof block.input === "string" ? block.input : JSON.stringify(block.input);
+      connection.emitAuditProgress({
+        requestId: request.requestId,
+        activity: {
+          tool: block.name,
+          input: inputStr.slice(0, 500),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+    }
+  }
+}
+async function runAuditQuery(request, connection, projectDir) {
+  connection.emitAgentStatus("fetching_context");
+  let agentCtx = null;
+  try {
+    agentCtx = await connection.fetchAgentContext();
+  } catch {
+    logger7.warn("Could not fetch agent context for audit, using defaults");
+  }
+  connection.emitAgentStatus("running");
+  const model = agentCtx?.model || FALLBACK_MODEL2;
+  const settings = agentCtx?.agentSettings ?? {};
+  const collector = {
+    recommendations: [],
+    summary: "Audit completed.",
+    complete: false
+  };
+  const onRecommendation = (rec) => {
+    connection.emitEvent({
+      type: "audit_recommendation",
+      tagName: rec.tagName,
+      recommendationType: rec.type
+    });
+  };
+  const systemPrompt = buildAuditSystemPrompt(
+    request.projectName,
+    request.tags,
+    request.fileHeatmap,
+    projectDir
+  );
+  const userPrompt = [
+    "Analyze the project's tag taxonomy and submit recommendations using the tag-audit MCP tools.",
+    `There are currently ${request.tags.length} tags configured.`,
+    request.fileHeatmap.length > 0 ? `File analytics show ${request.fileHeatmap.length} files with read activity.` : "No file read analytics available.",
+    "",
+    "Start by exploring the codebase structure, then analyze each tag for accuracy and completeness.",
+    "Call complete_audit when done."
+  ].join("\n");
+  const events = query3({
+    prompt: userPrompt,
+    options: {
+      model,
+      systemPrompt: { type: "preset", preset: "claude_code", append: systemPrompt },
+      cwd: projectDir,
+      permissionMode: "bypassPermissions",
+      allowDangerouslySkipPermissions: true,
+      tools: { type: "preset", preset: "claude_code" },
+      mcpServers: { "tag-audit": createAuditMcpServer(collector, onRecommendation) },
+      maxTurns: settings.maxTurns ?? 75,
+      maxBudgetUsd: settings.maxBudgetUsd ?? 5,
+      effort: settings.effort,
+      thinking: settings.thinking
+    }
+  });
+  const responseParts = [];
+  const turnToolCalls = [];
+  const isTyping = { value: false };
+  for await (const event of events) {
+    emitToolCallProgress(event, request, connection);
+    const done = processEventStream(event, connection, responseParts, turnToolCalls, isTyping);
+    if (done) break;
+  }
+  if (isTyping.value) {
+    connection.emitEvent({ type: "agent_typing_stop" });
+  }
+  return collector;
+}
+async function handleProjectAuditRequest(request, connection, projectDir) {
+  connection.emitAgentStatus("running");
+  try {
+    const collector = await runAuditQuery(request, connection, projectDir);
+    const result = {
+      recommendations: collector.recommendations,
+      summary: collector.summary,
+      analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    logger7.info("Tag audit completed", {
+      requestId: request.requestId,
+      recommendationCount: result.recommendations.length
+    });
+    connection.emitAuditResult({ requestId: request.requestId, result });
+  } catch (error) {
+    logger7.error("Tag audit failed", {
+      requestId: request.requestId,
+      ...errorMeta(error)
+    });
+    connection.emitAuditResult({
+      requestId: request.requestId,
+      error: error instanceof Error ? error.message : "Tag audit failed"
+    });
   } finally {
     connection.emitAgentStatus("idle");
   }
 }
 
 // src/runner/project-runner.ts
-var logger5 = createServiceLogger("ProjectRunner");
+var logger8 = createServiceLogger("ProjectRunner");
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path.dirname(__filename);
 var HEARTBEAT_INTERVAL_MS2 = 3e4;
@@ -4061,13 +6672,20 @@ function setupWorkDir(projectDir, assignment) {
     workDir = projectDir;
   }
   if (branch && branch !== devBranch) {
-    try {
-      execSync5(`git checkout ${branch}`, { cwd: workDir, stdio: "ignore" });
-    } catch {
+    if (hasUncommittedChanges(workDir)) {
+      logger8.warn("Uncommitted changes in work dir, skipping checkout", {
+        taskId: shortId,
+        branch
+      });
+    } else {
       try {
-        execSync5(`git checkout -b ${branch}`, { cwd: workDir, stdio: "ignore" });
+        execSync7(`git checkout ${branch}`, { cwd: workDir, stdio: "ignore" });
       } catch {
-        logger5.warn("Could not checkout branch", { taskId: shortId, branch });
+        try {
+          execSync7(`git checkout -b ${branch}`, { cwd: workDir, stdio: "ignore" });
+        } catch {
+          logger8.warn("Could not checkout branch", { taskId: shortId, branch });
+        }
       }
     }
   }
@@ -4106,13 +6724,13 @@ function spawnChildAgent(assignment, workDir) {
   child.stdout?.on("data", (data) => {
     const lines = data.toString().trimEnd().split("\n");
     for (const line of lines) {
-      logger5.info(line, { taskId: shortId });
+      logger8.info(line, { taskId: shortId });
     }
   });
   child.stderr?.on("data", (data) => {
     const lines = data.toString().trimEnd().split("\n");
     for (const line of lines) {
-      logger5.error(line, { taskId: shortId });
+      logger8.error(line, { taskId: shortId });
     }
   });
   return child;
@@ -4124,27 +6742,71 @@ var ProjectRunner = class {
   heartbeatTimer = null;
   stopping = false;
   resolveLifecycle = null;
+  chatSessionIds = /* @__PURE__ */ new Map();
   // Start command process management
   startCommandChild = null;
   startCommandRunning = false;
   setupComplete = false;
+  branchSwitchCommand;
+  commitWatcher;
   constructor(config) {
     this.projectDir = config.projectDir;
     this.connection = new ProjectConnection({
       apiUrl: config.conveyorApiUrl,
       projectToken: config.projectToken,
-      projectId: config.projectId
+      projectId: config.projectId,
+      projectDir: config.projectDir
     });
+    this.commitWatcher = new CommitWatcher(
+      {
+        projectDir: this.projectDir,
+        pollIntervalMs: Number(process.env.CONVEYOR_COMMIT_POLL_INTERVAL) || 1e4,
+        debounceMs: 3e3
+      },
+      {
+        onNewCommits: async (data) => {
+          this.connection.emitNewCommitsDetected({
+            branch: data.branch,
+            commitCount: data.commitCount,
+            latestCommit: {
+              sha: data.newCommitSha,
+              message: data.latestMessage,
+              author: data.latestAuthor
+            },
+            autoSyncing: true
+          });
+          const startTime = Date.now();
+          const stepsRun = await this.smartSync(data.previousSha, data.newCommitSha, data.branch);
+          this.connection.emitEnvironmentReady({
+            branch: data.branch,
+            commitsSynced: data.commitCount,
+            syncDurationMs: Date.now() - startTime,
+            stepsRun
+          });
+        }
+      }
+    );
   }
   checkoutWorkspaceBranch() {
     const workspaceBranch = process.env.CONVEYOR_WORKSPACE_BRANCH;
     if (!workspaceBranch) return;
+    const currentBranch = this.getCurrentBranch();
+    if (currentBranch === workspaceBranch) {
+      logger8.info("Already on workspace branch", { workspaceBranch });
+      return;
+    }
+    if (hasUncommittedChanges(this.projectDir)) {
+      logger8.warn("Uncommitted changes detected, skipping workspace branch checkout", {
+        workspaceBranch
+      });
+      return;
+    }
     try {
-      execSync5(`git fetch origin ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
-      execSync5(`git checkout ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
-      logger5.info("Checked out workspace branch", { workspaceBranch });
+      execSync7(`git fetch origin ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
+      execSync7(`git checkout ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
+      logger8.info("Checked out workspace branch", { workspaceBranch });
     } catch (err) {
-      logger5.warn("Failed to checkout workspace branch, continuing on current branch", {
+      logger8.warn("Failed to checkout workspace branch, continuing on current branch", {
         workspaceBranch,
         ...errorMeta(err)
       });
@@ -4153,15 +6815,15 @@ var ProjectRunner = class {
   async executeSetupCommand() {
     const cmd = process.env.CONVEYOR_SETUP_COMMAND;
     if (!cmd) return;
-    logger5.info("Running setup command", { command: cmd });
+    logger8.info("Running setup command", { command: cmd });
     try {
       await runSetupCommand(cmd, this.projectDir, (stream, data) => {
         this.connection.emitEvent({ type: "setup_output", stream, data });
         (stream === "stderr" ? process.stderr : process.stdout).write(data);
       });
-      logger5.info("Setup command completed");
+      logger8.info("Setup command completed");
     } catch (error) {
-      logger5.error("Setup command failed", errorMeta(error));
+      logger8.error("Setup command failed", errorMeta(error));
       this.connection.emitEvent({
         type: "setup_error",
         message: error instanceof Error ? error.message : "Setup command failed"
@@ -4172,7 +6834,7 @@ var ProjectRunner = class {
   executeStartCommand() {
     const cmd = process.env.CONVEYOR_START_COMMAND;
     if (!cmd) return;
-    logger5.info("Running start command", { command: cmd });
+    logger8.info("Running start command", { command: cmd });
     const child = runStartCommand(cmd, this.projectDir, (stream, data) => {
       this.connection.emitEvent({ type: "start_command_output", stream, data });
       (stream === "stderr" ? process.stderr : process.stdout).write(data);
@@ -4182,7 +6844,7 @@ var ProjectRunner = class {
     child.on("exit", (code, signal) => {
       this.startCommandRunning = false;
       this.startCommandChild = null;
-      logger5.info("Start command exited", { code, signal });
+      logger8.info("Start command exited", { code, signal });
       this.connection.emitEvent({
         type: "start_command_exited",
         code,
@@ -4193,13 +6855,13 @@ var ProjectRunner = class {
     child.on("error", (err) => {
       this.startCommandRunning = false;
       this.startCommandChild = null;
-      logger5.error("Start command error", errorMeta(err));
+      logger8.error("Start command error", errorMeta(err));
     });
   }
   async killStartCommand() {
     const child = this.startCommandChild;
     if (!child || !this.startCommandRunning) return;
-    logger5.info("Killing start command");
+    logger8.info("Killing start command");
     try {
       if (child.pid) process.kill(-child.pid, "SIGTERM");
     } catch {
@@ -4229,21 +6891,177 @@ var ProjectRunner = class {
     this.executeStartCommand();
   }
   getEnvironmentStatus() {
-    let currentBranch = "unknown";
-    try {
-      currentBranch = execSync5("git branch --show-current", {
-        cwd: this.projectDir,
-        stdio: ["ignore", "pipe", "ignore"]
-      }).toString().trim();
-    } catch {
-    }
     return {
       setupComplete: this.setupComplete,
       startCommandRunning: this.startCommandRunning,
-      currentBranch,
+      currentBranch: this.getCurrentBranch() ?? "unknown",
       previewPort: Number(process.env.CONVEYOR_PREVIEW_PORT) || null
     };
   }
+  getCurrentBranch() {
+    return getCurrentBranch(this.projectDir);
+  }
+  // oxlint-disable-next-line max-lines-per-function, complexity -- sequential sync steps with per-step error handling
+  async smartSync(previousSha, newSha, branch) {
+    const stepsRun = [];
+    if (hasUncommittedChanges(this.projectDir)) {
+      this.connection.emitEvent({
+        type: "commit_watch_warning",
+        message: "Working tree has uncommitted changes. Auto-pull skipped."
+      });
+      return ["skipped:dirty_tree"];
+    }
+    await this.killStartCommand();
+    this.connection.emitEnvSwitchProgress({ step: "pull", status: "running" });
+    try {
+      execSync7(`git pull origin ${branch}`, {
+        cwd: this.projectDir,
+        stdio: "pipe",
+        timeout: 6e4
+      });
+      stepsRun.push("pull");
+      this.connection.emitEnvSwitchProgress({ step: "pull", status: "success" });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Pull failed";
+      this.connection.emitEnvSwitchProgress({ step: "pull", status: "error", message });
+      logger8.error("Git pull failed during commit sync", errorMeta(err));
+      this.executeStartCommand();
+      return ["error:pull"];
+    }
+    let changedFiles = [];
+    try {
+      changedFiles = execSync7(`git diff --name-only ${previousSha}..${newSha}`, {
+        cwd: this.projectDir,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).toString().trim().split("\n").filter(Boolean);
+    } catch {
+    }
+    const needsInstall = changedFiles.some(
+      (f) => f === "package.json" || f === "bun.lockb" || f === "bunfig.toml" || f.endsWith("/package.json") || f.endsWith("/bun.lockb")
+    );
+    const needsPrisma = changedFiles.some(
+      (f) => f.includes("prisma/schema.prisma") || f.includes("prisma/migrations/")
+    );
+    const cmd = this.branchSwitchCommand ?? process.env.CONVEYOR_BRANCH_SWITCH_COMMAND;
+    if (cmd && (needsInstall || needsPrisma)) {
+      this.connection.emitEnvSwitchProgress({ step: "sync", status: "running" });
+      try {
+        await runSetupCommand(cmd, this.projectDir, (stream, data) => {
+          this.connection.emitEvent({ type: "sync_output", stream, data });
+        });
+        stepsRun.push("branchSwitchCommand");
+        this.connection.emitEnvSwitchProgress({ step: "sync", status: "success" });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Sync command failed";
+        this.connection.emitEnvSwitchProgress({ step: "sync", status: "error", message });
+        logger8.error("Branch switch command failed during commit sync", errorMeta(err));
+      }
+    } else if (!cmd) {
+      if (needsInstall) {
+        this.connection.emitEnvSwitchProgress({ step: "install", status: "running" });
+        try {
+          execSync7("bun install", { cwd: this.projectDir, timeout: 12e4, stdio: "pipe" });
+          stepsRun.push("install");
+          this.connection.emitEnvSwitchProgress({ step: "install", status: "success" });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Install failed";
+          this.connection.emitEnvSwitchProgress({ step: "install", status: "error", message });
+          logger8.error("bun install failed during commit sync", errorMeta(err));
+        }
+      }
+      if (needsPrisma) {
+        this.connection.emitEnvSwitchProgress({ step: "prisma", status: "running" });
+        try {
+          execSync7("bunx prisma generate", {
+            cwd: this.projectDir,
+            timeout: 6e4,
+            stdio: "pipe"
+          });
+          execSync7("bunx prisma db push --accept-data-loss", {
+            cwd: this.projectDir,
+            timeout: 6e4,
+            stdio: "pipe"
+          });
+          stepsRun.push("prisma");
+          this.connection.emitEnvSwitchProgress({ step: "prisma", status: "success" });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Prisma sync failed";
+          this.connection.emitEnvSwitchProgress({ step: "prisma", status: "error", message });
+          logger8.error("Prisma sync failed during commit sync", errorMeta(err));
+        }
+      }
+    }
+    this.executeStartCommand();
+    stepsRun.push("startCommand");
+    return stepsRun;
+  }
+  async handleSwitchBranch(data, callback) {
+    const { branch, syncAfter } = data;
+    try {
+      this.connection.emitEnvSwitchProgress({ step: "fetch", status: "running" });
+      try {
+        execSync7("git fetch origin", { cwd: this.projectDir, stdio: "pipe" });
+      } catch {
+        logger8.warn("Git fetch failed during branch switch");
+      }
+      this.connection.emitEnvSwitchProgress({ step: "fetch", status: "success" });
+      detachWorktreeBranch(this.projectDir, branch);
+      this.connection.emitEnvSwitchProgress({ step: "checkout", status: "running" });
+      try {
+        execSync7(`git checkout ${branch}`, { cwd: this.projectDir, stdio: "pipe" });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Checkout failed";
+        this.connection.emitEnvSwitchProgress({ step: "checkout", status: "error", message });
+        callback({ ok: false, error: `Failed to checkout branch: ${message}` });
+        return;
+      }
+      try {
+        execSync7(`git pull origin ${branch}`, { cwd: this.projectDir, stdio: "pipe" });
+      } catch {
+        logger8.warn("Git pull failed during branch switch", { branch });
+      }
+      this.connection.emitEnvSwitchProgress({ step: "checkout", status: "success" });
+      if (syncAfter !== false) {
+        await this.handleSyncEnvironment();
+      }
+      this.commitWatcher.start(branch);
+      callback({ ok: true, data: this.getEnvironmentStatus() });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Branch switch failed";
+      logger8.error("Branch switch failed", errorMeta(err));
+      callback({ ok: false, error: message });
+    }
+  }
+  async handleSyncEnvironment(callback) {
+    try {
+      await this.killStartCommand();
+      const cmd = this.branchSwitchCommand ?? process.env.CONVEYOR_BRANCH_SWITCH_COMMAND;
+      if (cmd) {
+        this.connection.emitEnvSwitchProgress({ step: "sync", status: "running" });
+        try {
+          await runSetupCommand(cmd, this.projectDir, (stream, data) => {
+            this.connection.emitEvent({ type: "sync_output", stream, data });
+            (stream === "stderr" ? process.stderr : process.stdout).write(data);
+          });
+          this.connection.emitEnvSwitchProgress({ step: "sync", status: "success" });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Sync command failed";
+          this.connection.emitEnvSwitchProgress({ step: "sync", status: "error", message });
+          logger8.error("Branch switch sync command failed", errorMeta(err));
+        }
+      }
+      this.executeStartCommand();
+      this.connection.emitEnvSwitchProgress({ step: "startCommand", status: "success" });
+      callback?.({ ok: true, data: this.getEnvironmentStatus() });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Sync failed";
+      logger8.error("Environment sync failed", errorMeta(err));
+      callback?.({ ok: false, error: message });
+    }
+  }
+  handleGetEnvStatus(callback) {
+    callback({ ok: true, data: this.getEnvironmentStatus() });
+  }
   async start() {
     this.checkoutWorkspaceBranch();
     await this.connection.connect();
@@ -4257,7 +7075,7 @@ var ProjectRunner = class {
         startCommandRunning: this.startCommandRunning
       });
     } catch (error) {
-      logger5.error("Environment setup failed", errorMeta(error));
+      logger8.error("Environment setup failed", errorMeta(error));
       this.setupComplete = false;
     }
     this.connection.onTaskAssignment((assignment) => {
@@ -4267,17 +7085,53 @@ var ProjectRunner = class {
       this.handleStopTask(data.taskId);
     });
     this.connection.onShutdown(() => {
-      logger5.info("Received shutdown signal from server");
+      logger8.info("Received shutdown signal from server");
       void this.stop();
     });
     this.connection.onChatMessage((msg) => {
-      logger5.debug("Received project chat message");
-      void handleProjectChatMessage(msg, this.connection, this.projectDir);
+      logger8.debug("Received project chat message");
+      const chatId = msg.chatId ?? "default";
+      const existingSessionId = this.chatSessionIds.get(chatId);
+      void handleProjectChatMessage(msg, this.connection, this.projectDir, existingSessionId).then(
+        (newSessionId) => {
+          if (newSessionId) {
+            this.chatSessionIds.set(chatId, newSessionId);
+          }
+        }
+      );
     });
+    this.connection.onAuditRequest((request) => {
+      logger8.debug("Received tag audit request", { requestId: request.requestId });
+      void handleProjectAuditRequest(request, this.connection, this.projectDir);
+    });
+    this.connection.onSwitchBranch = (data, cb) => {
+      void this.handleSwitchBranch(data, cb);
+    };
+    this.connection.onSyncEnvironment = (cb) => {
+      void this.handleSyncEnvironment(cb);
+    };
+    this.connection.onGetEnvStatus = (cb) => {
+      this.handleGetEnvStatus(cb);
+    };
+    this.connection.onRestartStartCommand = (cb) => {
+      void this.restartStartCommand().then(() => cb({ ok: true })).catch(
+        (err) => cb({ ok: false, error: err instanceof Error ? err.message : "Restart failed" })
+      );
+    };
+    try {
+      const context = await this.connection.fetchAgentContext();
+      this.branchSwitchCommand = context?.branchSwitchCommand ?? process.env.CONVEYOR_BRANCH_SWITCH_COMMAND;
+    } catch {
+      this.branchSwitchCommand = process.env.CONVEYOR_BRANCH_SWITCH_COMMAND;
+    }
     this.heartbeatTimer = setInterval(() => {
       this.connection.sendHeartbeat();
     }, HEARTBEAT_INTERVAL_MS2);
-    logger5.info("Connected, waiting for task assignments");
+    const currentBranch = this.getCurrentBranch();
+    if (currentBranch) {
+      this.commitWatcher.start(currentBranch);
+    }
+    logger8.info("Connected, waiting for task assignments");
     await new Promise((resolve2) => {
       this.resolveLifecycle = resolve2;
       process.on("SIGTERM", () => void this.stop());
@@ -4288,11 +7142,11 @@ var ProjectRunner = class {
     const { taskId, mode } = assignment;
     const shortId = taskId.slice(0, 8);
     if (this.activeAgents.has(taskId)) {
-      logger5.info("Task already running, skipping", { taskId: shortId });
+      logger8.info("Task already running, skipping", { taskId: shortId });
       return;
     }
     if (this.activeAgents.size >= MAX_CONCURRENT) {
-      logger5.warn("Max concurrent agents reached, rejecting task", {
+      logger8.warn("Max concurrent agents reached, rejecting task", {
         maxConcurrent: MAX_CONCURRENT,
         taskId: shortId
       });
@@ -4301,9 +7155,9 @@ var ProjectRunner = class {
     }
     try {
       try {
-        execSync5("git fetch origin", { cwd: this.projectDir, stdio: "ignore" });
+        execSync7("git fetch origin", { cwd: this.projectDir, stdio: "ignore" });
       } catch {
-        logger5.warn("Git fetch failed", { taskId: shortId });
+        logger8.warn("Git fetch failed", { taskId: shortId });
       }
       const { workDir, usesWorktree } = setupWorkDir(this.projectDir, assignment);
       const child = spawnChildAgent(assignment, workDir);
@@ -4314,12 +7168,12 @@ var ProjectRunner = class {
         usesWorktree
       });
       this.connection.emitTaskStarted(taskId);
-      logger5.info("Started task", { taskId: shortId, mode, workDir });
+      logger8.info("Started task", { taskId: shortId, mode, workDir });
       child.on("exit", (code) => {
         this.activeAgents.delete(taskId);
         const reason = code === 0 ? "completed" : `exited with code ${code}`;
         this.connection.emitTaskStopped(taskId, reason);
-        logger5.info("Task exited", { taskId: shortId, reason });
+        logger8.info("Task exited", { taskId: shortId, reason });
         if (code === 0 && usesWorktree) {
           try {
             removeWorktree(this.projectDir, taskId);
@@ -4328,7 +7182,7 @@ var ProjectRunner = class {
         }
       });
     } catch (error) {
-      logger5.error("Failed to start task", {
+      logger8.error("Failed to start task", {
         taskId: shortId,
         ...errorMeta(error)
       });
@@ -4342,7 +7196,7 @@ var ProjectRunner = class {
     const agent = this.activeAgents.get(taskId);
     if (!agent) return;
     const shortId = taskId.slice(0, 8);
-    logger5.info("Stopping task", { taskId: shortId });
+    logger8.info("Stopping task", { taskId: shortId });
     agent.process.kill("SIGTERM");
     const timer = setTimeout(() => {
       if (this.activeAgents.has(taskId)) {
@@ -4362,7 +7216,8 @@ var ProjectRunner = class {
   async stop() {
     if (this.stopping) return;
     this.stopping = true;
-    logger5.info("Shutting down");
+    logger8.info("Shutting down");
+    this.commitWatcher.stop();
     await this.killStartCommand();
     if (this.heartbeatTimer) {
       clearInterval(this.heartbeatTimer);
@@ -4388,7 +7243,7 @@ var ProjectRunner = class {
       })
     ]);
     this.connection.disconnect();
-    logger5.info("Shutdown complete");
+    logger8.info("Shutdown complete");
     if (this.resolveLifecycle) {
       this.resolveLifecycle();
       this.resolveLifecycle = null;
@@ -4467,6 +7322,7 @@ export {
   ProjectConnection,
   createServiceLogger,
   errorMeta,
+  injectTelemetry,
   ensureWorktree,
   removeWorktree,
   loadConveyorConfig,
@@ -4474,4 +7330,4 @@ export {
   ProjectRunner,
   FileCache
 };
-//# sourceMappingURL=chunk-HYWZJYPW.js.map
+//# sourceMappingURL=chunk-NKZSUGND.js.map