@rallycry/conveyor-agent 6.0.1 → 6.0.3

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

@@ -220,16 +220,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,6 +453,23 @@ 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);
@@ -454,9 +497,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 +546,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 +630,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 +688,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 +702,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 +808,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 +842,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 +856,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 +924,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 +938,245 @@ 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 {
+  apiUrl;
+  token;
+  localPort;
+  ws = null;
+  stopped = false;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  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.reconnectAttempts = 0;
+      logger2.info("Tunnel connected", { port: this.localPort });
+    });
+    this.ws.addEventListener("close", () => {
+      logger2.info("Tunnel disconnected");
+      this.scheduleReconnect();
+    });
+    this.ws.addEventListener("error", (event) => {
+      logger2.warn("Tunnel error", { error: String(event) });
+    });
+    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;
+    const delay = Math.min(RECONNECT_BASE_MS * 2 ** this.reconnectAttempts, RECONNECT_MAX_MS);
+    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 +1215,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 +1299,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 +1342,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 +1362,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 +1386,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 +1443,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 +1471,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 +1491,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 +1501,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 +1542,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 }
   };
 }
 
@@ -1401,6 +1904,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`,
@@ -1535,6 +2040,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) {
@@ -1657,7 +2170,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 +2218,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.`
@@ -1911,7 +2424,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 +2456,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 +2479,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 +2747,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,
@@ -2726,7 +3242,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 +3252,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) {
@@ -2841,7 +3375,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 +3505,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 +3559,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 +3596,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 +3804,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,9 +3864,22 @@ async function checkoutTaskBranch(runnerConfig, connection, callbacks, setupLog)
       }
     );
     pushSetupLog(setupLog, `[conveyor] Switched to ${taskBranch}`);
-    return true;
-  } catch (error) {
-    const message = `Failed to checkout ${taskBranch}: ${error instanceof Error ? error.message : "unknown error"}`;
+    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"}`;
     connection.sendEvent({ type: "setup_error", message });
     await callbacks.onEvent({ type: "setup_error", message });
     connection.postChatMessage(`Failed to switch to task branch \`${taskBranch}\`.
@@ -3433,7 +4064,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 +4093,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 +4168,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 +4207,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 +4229,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 +4371,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 +4413,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();
@@ -3874,6 +4519,7 @@ var AgentRunner = class {
   stop() {
     this.stopped = true;
     this.clearIdleTimers();
+    this.tunnelClient?.disconnect();
     if (this.inputResolver) {
       this.inputResolver(null);
       this.inputResolver = null;
@@ -3883,13 +4529,270 @@ var AgentRunner = class {
 
 // src/runner/project-runner.ts
 import { fork } from "child_process";
-import { execSync as execSync5 } 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 tool4 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z4 } from "zod";
+function buildReadTools(connection) {
+  return [
+    tool4(
+      "list_tasks",
+      "List tasks in the project. Optionally filter by status or assignee.",
+      {
+        status: z4.string().optional().describe("Filter by task status (e.g. Planning, Open, InProgress, ReviewPR, Complete)"),
+        assigneeId: z4.string().optional().describe("Filter by assigned user ID"),
+        limit: z4.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 } }
+    ),
+    tool4(
+      "get_task",
+      "Get detailed information about a task including its chat messages, child tasks, and codespace status.",
+      { task_id: z4.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 } }
+    ),
+    tool4(
+      "search_tasks",
+      "Search tasks by tags, text query, or status filters.",
+      {
+        tagNames: z4.array(z4.string()).optional().describe("Filter by tag names"),
+        searchQuery: z4.string().optional().describe("Text search in title/description"),
+        statusFilters: z4.array(z4.string()).optional().describe("Filter by statuses"),
+        limit: z4.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 } }
+    ),
+    tool4(
+      "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 } }
+    ),
+    tool4(
+      "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 [
+    tool4(
+      "create_task",
+      "Create a new task in the project.",
+      {
+        title: z4.string().describe("Task title"),
+        description: z4.string().optional().describe("Task description"),
+        plan: z4.string().optional().describe("Implementation plan in markdown"),
+        status: z4.string().optional().describe("Initial status (default: Planning)"),
+        isBug: z4.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"}`
+          );
+        }
+      }
+    ),
+    tool4(
+      "update_task",
+      "Update an existing task's title, description, plan, status, or assignee.",
+      {
+        task_id: z4.string().describe("The task ID to update"),
+        title: z4.string().optional().describe("New title"),
+        description: z4.string().optional().describe("New description"),
+        plan: z4.string().optional().describe("New plan in markdown"),
+        status: z4.string().optional().describe("New status"),
+        assignedUserId: z4.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 +4845,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 +4881,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 +4944,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 +4978,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 tool5, createSdkMcpServer as createSdkMcpServer3 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z5 } 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 = [
+    tool5(
+      "recommend_create_tag",
+      "Recommend creating a new tag for an uncovered subsystem or area",
+      {
+        name: z5.string().describe("Proposed tag name (lowercase, hyphenated)"),
+        color: z5.string().optional().describe("Hex color code"),
+        description: z5.string().describe("What this tag covers"),
+        reasoning: z5.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 }] };
+      }
+    ),
+    tool5(
+      "recommend_update_description",
+      "Recommend updating a tag's description to better reflect its scope",
+      {
+        tagId: z5.string(),
+        tagName: z5.string(),
+        description: z5.string().describe("Proposed new description"),
+        reasoning: z5.string()
+      },
+      async (args) => {
+        const result = collectRecommendation(
+          "recommend_update_description",
+          args,
+          collector,
+          onRecommendation
+        );
+        return { content: [{ type: "text", text: result }] };
+      }
+    ),
+    tool5(
+      "recommend_context_link",
+      "Recommend linking a doc, rule, file, or folder to a tag's contextPaths",
+      {
+        tagId: z5.string(),
+        tagName: z5.string(),
+        linkType: z5.enum(["rule", "doc", "file", "folder"]),
+        path: z5.string(),
+        label: z5.string().optional(),
+        reasoning: z5.string()
+      },
+      async (args) => {
+        const result = collectRecommendation(
+          "recommend_context_link",
+          args,
+          collector,
+          onRecommendation
+        );
+        return { content: [{ type: "text", text: result }] };
+      }
+    ),
+    tool5(
+      "flag_documentation_gap",
+      "Flag a file that agents read heavily but has no tag documentation linked",
+      {
+        tagName: z5.string().describe("Tag whose agents read this file"),
+        tagId: z5.string().optional(),
+        filePath: z5.string(),
+        readCount: z5.number(),
+        suggestedAction: z5.string().describe("What doc or rule should be created"),
+        reasoning: z5.string()
+      },
+      async (args) => {
+        const result = collectRecommendation(
+          "flag_documentation_gap",
+          args,
+          collector,
+          onRecommendation
+        );
+        return { content: [{ type: "text", text: result }] };
+      }
+    ),
+    tool5(
+      "recommend_merge_tags",
+      "Recommend merging one tag into another",
+      {
+        tagId: z5.string().describe("Tag ID to be merged (removed after merge)"),
+        tagName: z5.string().describe("Name of the tag to be merged"),
+        mergeIntoTagId: z5.string().describe("Tag ID to merge into (kept)"),
+        mergeIntoTagName: z5.string(),
+        reasoning: z5.string()
+      },
+      async (args) => {
+        const result = collectRecommendation(
+          "recommend_merge_tags",
+          args,
+          collector,
+          onRecommendation
+        );
+        return { content: [{ type: "text", text: result }] };
+      }
+    ),
+    tool5(
+      "recommend_rename_tag",
+      "Recommend renaming a tag",
+      {
+        tagId: z5.string(),
+        tagName: z5.string().describe("Current tag name"),
+        newName: z5.string().describe("Proposed new name"),
+        reasoning: z5.string()
+      },
+      async (args) => {
+        const result = collectRecommendation(
+          "recommend_rename_tag",
+          args,
+          collector,
+          onRecommendation
+        );
+        return { content: [{ type: "text", text: result }] };
+      }
+    ),
+    tool5(
+      "complete_audit",
+      "Signal that the audit is complete with a summary of all findings",
+      { summary: z5.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 +5405,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 +5457,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 +5475,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 +5548,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 +5567,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 +5577,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 +5588,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 +5624,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 +5808,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 +5818,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 +5875,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 +5888,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 +5901,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 +5915,7 @@ var ProjectRunner = class {
         }
       });
     } catch (error) {
-      logger5.error("Failed to start task", {
+      logger8.error("Failed to start task", {
         taskId: shortId,
         ...errorMeta(error)
       });
@@ -4342,7 +5929,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 +5949,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 +5976,7 @@ var ProjectRunner = class {
       })
     ]);
     this.connection.disconnect();
-    logger5.info("Shutdown complete");
+    logger8.info("Shutdown complete");
     if (this.resolveLifecycle) {
       this.resolveLifecycle();
       this.resolveLifecycle = null;
@@ -4474,4 +6062,4 @@ export {
   ProjectRunner,
   FileCache
 };
-//# sourceMappingURL=chunk-HYWZJYPW.js.map
+//# sourceMappingURL=chunk-SL5MRNSI.js.map