@rallycry/conveyor-agent 5.12.0 → 6.0.1

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

@@ -427,23 +427,6 @@ 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);
@@ -471,16 +454,9 @@ 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;
@@ -520,37 +496,6 @@ 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)
-      );
       this.socket.on("connect", () => {
         if (!settled) {
           settled = true;
@@ -582,17 +527,6 @@ 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", {});
@@ -640,13 +574,13 @@ var ProjectConnection = class {
       );
     });
   }
-  fetchChatHistory(limit, chatId) {
+  fetchChatHistory(limit) {
     const socket = this.socket;
     if (!socket) return Promise.reject(new Error("Not connected"));
     return new Promise((resolve2, reject) => {
       socket.emit(
         "projectRunner:getChatHistory",
-        { limit, chatId },
+        { limit },
         (response) => {
           if (response.success && response.data) resolve2(response.data);
           else reject(new Error(response.error ?? "Failed to fetch chat history"));
@@ -654,84 +588,39 @@ 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;
   }
 };
 
+// src/utils/logger.ts
+import winston from "winston";
+var { combine, timestamp, printf, colorize } = winston.format;
+var customFormat = printf(({ level, message, timestamp: ts, service, ...meta }) => {
+  const svc = service ? `[${service}] ` : "";
+  const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : "";
+  return `${ts} [${level}]: ${svc}${message}${metaStr}`;
+});
+var logger = winston.createLogger({
+  level: process.env.LOG_LEVEL ?? "info",
+  format: combine(timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), combine(colorize(), customFormat)),
+  transports: [new winston.transports.Console()]
+});
+function createServiceLogger(serviceName) {
+  return logger.child({ service: serviceName });
+}
+function errorMeta(error) {
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      stack: error.stack,
+      ..."code" in error && typeof error.code === "string" ? { code: error.code } : {}
+    };
+  }
+  return { message: String(error) };
+}
+
 // src/runner/worktree.ts
 import { execSync as execSync2 } from "child_process";
 import { existsSync } from "fs";
@@ -813,46 +702,11 @@ function unshallowRepo(workspaceDir) {
   }
 }
 
-// src/utils/logger.ts
-import winston from "winston";
-var { combine, timestamp, printf, colorize } = winston.format;
-var customFormat = printf(({ level, message, timestamp: ts, service, ...meta }) => {
-  const svc = service ? `[${service}] ` : "";
-  const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : "";
-  return `${ts} [${level}]: ${svc}${message}${metaStr}`;
-});
-var logger = winston.createLogger({
-  level: process.env.LOG_LEVEL ?? "info",
-  format: combine(timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), combine(colorize(), customFormat)),
-  transports: [new winston.transports.Console()]
-});
-function createServiceLogger(serviceName) {
-  return logger.child({ service: serviceName });
-}
-function errorMeta(error) {
-  if (error instanceof Error) {
-    return {
-      message: error.message,
-      stack: error.stack,
-      ..."code" in error && typeof error.code === "string" ? { code: error.code } : {}
-    };
-  }
-  return { message: String(error) };
-}
-
 // src/runner/agent-runner.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { execSync as execSync4 } from "child_process";
 
 // 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;
@@ -891,10 +745,6 @@ 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;
@@ -975,10 +825,6 @@ 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 };
@@ -1018,8 +864,7 @@ async function emitResultEvent(event, host, context, startTime, lastAssistantUsa
   return {
     retriable: result.retriable,
     resultSummary: result.resultSummary,
-    staleSession: result.staleSession,
-    authError: result.authError
+    staleSession: result.staleSession
   };
 }
 function handleRateLimitEvent(event, host) {
@@ -1038,13 +883,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 });
-    safeVoid(host.callbacks.onEvent({ type: "error", message }), "rateLimitRejected");
+    void host.callbacks.onEvent({ type: "error", message });
     return resetsAt;
   } else if (status === "allowed_warning") {
     const utilization = rate_limit_info.utilization ? `${Math.round(rate_limit_info.utilization * 100)}%` : "high";
     const message = `Rate limit warning: ${utilization} utilization (type: ${rate_limit_info.rateLimitType ?? "unknown"})`;
     host.connection.sendEvent({ type: "thinking", message });
-    safeVoid(host.callbacks.onEvent({ type: "thinking", message }), "rateLimitWarning");
+    void host.callbacks.onEvent({ type: "thinking", message });
   }
   return void 0;
 }
@@ -1062,46 +907,34 @@ async function handleSystemEvent(event, host, context, sessionIdStored) {
 }
 function handleSystemSubevents(systemEvent, host) {
   if (systemEvent.subtype === "compact_boundary") {
-    safeVoid(
-      host.callbacks.onEvent({
-        type: "context_compacted",
-        trigger: systemEvent.compact_metadata.trigger,
-        preTokens: systemEvent.compact_metadata.pre_tokens
-      }),
-      "compactBoundary"
-    );
+    void host.callbacks.onEvent({
+      type: "context_compacted",
+      trigger: systemEvent.compact_metadata.trigger,
+      preTokens: systemEvent.compact_metadata.pre_tokens
+    });
   } else if (systemEvent.subtype === "task_started") {
-    safeVoid(
-      host.callbacks.onEvent({
-        type: "subagent_started",
-        sdkTaskId: systemEvent.task_id,
-        description: systemEvent.description
-      }),
-      "taskStarted"
-    );
+    void host.callbacks.onEvent({
+      type: "subagent_started",
+      sdkTaskId: systemEvent.task_id,
+      description: systemEvent.description
+    });
   } else if (systemEvent.subtype === "task_progress") {
-    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"
-    );
+    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
+    });
   }
 }
 function handleToolProgressEvent(event, host) {
   const msg = event;
-  safeVoid(
-    host.callbacks.onEvent({
-      type: "tool_progress",
-      toolName: msg.tool_name ?? "",
-      elapsedSeconds: msg.elapsed_time_seconds ?? 0
-    }),
-    "toolProgress"
-  );
+  void host.callbacks.onEvent({
+    type: "tool_progress",
+    toolName: msg.tool_name ?? "",
+    elapsedSeconds: msg.elapsed_time_seconds ?? 0
+  });
 }
 async function handleAssistantCase(event, host, turnToolCalls) {
   await processAssistantEvent(event, host, turnToolCalls);
@@ -1119,13 +952,11 @@ 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();
 }
@@ -1147,12 +978,6 @@ 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(
@@ -1167,7 +992,6 @@ 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();
@@ -1177,11 +1001,9 @@ 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: []
   };
@@ -1218,11 +1040,10 @@ async function processEvents(events, context, host) {
   }
   stopTypingIfNeeded(host, state.isTyping);
   return {
-    retriable: state.retriable || state.sawApiError,
+    retriable: state.retriable,
     resultSummary: state.resultSummary,
     rateLimitResetsAt: state.rateLimitResetsAt,
-    ...state.staleSession && { staleSession: state.staleSession },
-    ...state.authError && { authError: state.authError }
+    ...state.staleSession && { staleSession: state.staleSession }
   };
 }
 
@@ -1580,8 +1401,6 @@ 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`,
@@ -1716,14 +1535,6 @@ 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) {
@@ -1846,7 +1657,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, isAuto) {
+function buildRelaunchWithSession(mode, context, agentMode) {
   const scenario = detectRelaunchScenario(context);
   if (!context.claudeSessionId || scenario === "fresh") return null;
   const parts = [];
@@ -1894,7 +1705,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" && isAuto) {
+    if (agentMode === "auto" || agentMode === "building") {
       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.`
@@ -2100,7 +1911,7 @@ Address the requested changes directly. Do NOT re-investigate the codebase from
   }
   return parts;
 }
-function buildInstructions(mode, context, scenario, agentMode, isAuto) {
+function buildInstructions(mode, context, scenario, agentMode) {
   const parts = [`
 ## Instructions`];
   const isPm = mode === "pm";
@@ -2132,7 +1943,7 @@ function buildInstructions(mode, context, scenario, agentMode, isAuto) {
         `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" && isAuto) {
+      if (agentMode === "auto" || agentMode === "building") {
         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.`
@@ -2155,13 +1966,13 @@ function buildInstructions(mode, context, scenario, agentMode, isAuto) {
 async function buildInitialPrompt(mode, context, isAuto, agentMode) {
   const isPackRunner = mode === "pm" && !!isAuto && !!context.isParentTask;
   if (!isPackRunner) {
-    const sessionRelaunch = buildRelaunchWithSession(mode, context, agentMode, isAuto);
+    const sessionRelaunch = buildRelaunchWithSession(mode, context, agentMode);
     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, isAuto);
+  const instructions = isPackRunner ? buildPackRunnerInstructions(context, scenario) : buildInstructions(mode, context, scenario, agentMode);
   return [...body, ...instructions].join("\n");
 }
 
@@ -2423,14 +2234,11 @@ 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"),
-      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."
-      )
+      body: z.string().describe("The PR description/body in markdown")
     },
-    async ({ title, body, branch }) => {
+    async ({ title, body }) => {
       try {
-        const result = await connection.createPR({ title, body, branch });
+        const result = await connection.createPR({ title, body });
         connection.sendEvent({
           type: "pr_created",
           url: result.url,
@@ -2918,9 +2726,7 @@ 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);
@@ -2928,39 +2734,24 @@ function buildCanUseTool(host) {
     if (toolName === "AskUserQuestion") {
       return await handleAskUserQuestion(host, input);
     }
-    let result;
     switch (host.agentMode) {
       case "discovery":
-        result = handleDiscoveryToolAccess(toolName, input);
-        break;
+        return handleDiscoveryToolAccess(toolName, input);
       case "building":
-        result = handleBuildingToolAccess(toolName, input);
-        break;
+        return handleBuildingToolAccess(toolName, input);
       case "review":
-        result = handleReviewToolAccess(toolName, input, host.isParentTask);
-        break;
+        return handleReviewToolAccess(toolName, input, host.isParentTask);
       case "auto":
-        result = handleAutoToolAccess(toolName, input, host.hasExitedPlanMode, host.isParentTask);
-        break;
+        return handleAutoToolAccess(toolName, input, host.hasExitedPlanMode, host.isParentTask);
       default:
-        result = { behavior: "allow", updatedInput: input };
+        return { 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 API_ERROR_PATTERN3 = /API Error: [45]\d\d/;
+var logger2 = createServiceLogger("QueryExecutor");
+var API_ERROR_PATTERN2 = /API Error: [45]\d\d/;
 var IMAGE_ERROR_PATTERN2 = /Could not process image/i;
 var RETRY_DELAYS_MS = [6e4, 12e4, 18e4, 3e5];
 function buildHooks(host) {
@@ -3048,7 +2839,10 @@ function buildQueryOptions(host, context) {
     betas: settings.betas,
     maxBudgetUsd: settings.maxBudgetUsd ?? 50,
     disallowedTools: buildDisallowedTools(settings, mode, host.hasExitedPlanMode),
-    enableFileCheckpointing: settings.enableFileCheckpointing
+    enableFileCheckpointing: settings.enableFileCheckpointing,
+    stderr: (data) => {
+      logger2.warn("Claude Code stderr", { data: data.trimEnd() });
+    }
   };
   if (isCloud && isReadOnly) {
     baseOptions.sandbox = buildSandboxConfig(host);
@@ -3177,29 +2971,6 @@ 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("");
@@ -3231,17 +3002,12 @@ 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) {
-  const message = getErrorMessage(error);
-  return API_ERROR_PATTERN3.test(message) || IMAGE_ERROR_PATTERN2.test(message);
+  if (!(error instanceof Error)) return false;
+  return API_ERROR_PATTERN2.test(error.message) || IMAGE_ERROR_PATTERN2.test(error.message);
 }
 function classifyImageError(error) {
-  return IMAGE_ERROR_PATTERN2.test(getErrorMessage(error));
+  return error instanceof Error && IMAGE_ERROR_PATTERN2.test(error.message);
 }
 async function emitRetryStatus(host, attempt, delayMs) {
   const delayMin = Math.round(delayMs / 6e4);
@@ -3268,41 +3034,26 @@ 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 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;
+      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 ?? "");
     } catch (error) {
       const outcome = handleRetryError(error, context, host, options, lastErrorWasImage);
       if (outcome instanceof Promise) return outcome;
@@ -3682,7 +3433,7 @@ function buildQueryHost(deps) {
 }
 
 // src/runner/agent-runner.ts
-var logger2 = createServiceLogger("AgentRunner");
+var logger3 = createServiceLogger("AgentRunner");
 var HEARTBEAT_INTERVAL_MS = 3e4;
 var IDLE_TIMEOUT_MS = 30 * 60 * 1e3;
 var AgentRunner = class {
@@ -3971,7 +3722,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);
-    logger2.info("Effective agent settings", {
+    logger3.info("Effective agent settings", {
       model,
       mode: this.config.mode ?? "task",
       effort: s.effort ?? "default",
@@ -4015,7 +3766,7 @@ var AgentRunner = class {
       this.idleTimer = setTimeout(() => {
         this.clearIdleTimers();
         this.inputResolver = null;
-        logger2.info("Idle timeout reached, shutting down", {
+        logger3.info("Idle timeout reached, shutting down", {
           idleMinutes: IDLE_TIMEOUT_MS / 6e4
         });
         this.connection.postChatMessage(
@@ -4132,269 +3883,12 @@ var AgentRunner = class {
 
 // src/runner/project-runner.ts
 import { fork } from "child_process";
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 import * as path from "path";
 import { fileURLToPath } from "url";
 
-// src/runner/commit-watcher.ts
-import { execSync as execSync5 } from "child_process";
-var logger3 = 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);
-    logger3.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 execSync5("git rev-parse HEAD", {
-      cwd: this.config.projectDir,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).toString().trim();
-  }
-  poll() {
-    if (!this.branch || this.isSyncing) return;
-    try {
-      execSync5(`git fetch origin ${this.branch} --quiet`, {
-        cwd: this.config.projectDir,
-        stdio: "ignore",
-        timeout: 3e4
-      });
-      const remoteSha = execSync5(`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 = execSync5(`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 = execSync5(`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;
-    logger3.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) {
-      logger3.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 FALLBACK_MODEL = "claude-sonnet-4-20250514";
 function buildSystemPrompt2(projectDir, agentCtx) {
@@ -4451,7 +3945,7 @@ function processContentBlock(block, responseParts, turnToolCalls) {
     logger4.debug("Tool use", { tool: block.name });
   }
 }
-async function fetchContext(connection, chatId) {
+async function fetchContext(connection) {
   let agentCtx = null;
   try {
     agentCtx = await connection.fetchAgentContext();
@@ -4460,19 +3954,15 @@ async function fetchContext(connection, chatId) {
   }
   let chatHistory = [];
   try {
-    chatHistory = await connection.fetchChatHistory(30, chatId);
+    chatHistory = await connection.fetchChatHistory(30);
   } catch {
     logger4.warn("Could not fetch chat history, proceeding without it");
   }
   return { agentCtx, chatHistory };
 }
-function buildChatQueryOptions(agentCtx, projectDir, connection) {
+function buildChatQueryOptions(agentCtx, projectDir) {
   const model = agentCtx?.model || FALLBACK_MODEL;
   const settings = agentCtx?.agentSettings ?? {};
-  const mcpServer = createSdkMcpServer2({
-    name: "conveyor",
-    tools: buildProjectTools(connection)
-  });
   return {
     model,
     systemPrompt: {
@@ -4484,48 +3974,12 @@ function buildChatQueryOptions(agentCtx, projectDir, connection) {
     permissionMode: "bypassPermissions",
     allowDangerouslySkipPermissions: true,
     tools: { type: "preset", preset: "claude_code" },
-    mcpServers: { conveyor: mcpServer },
-    maxTurns: settings.maxTurns ?? 30,
-    maxBudgetUsd: settings.maxBudgetUsd ?? 50,
+    maxTurns: settings.maxTurns ?? 15,
+    maxBudgetUsd: settings.maxBudgetUsd ?? 5,
     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) {
@@ -4547,30 +4001,19 @@ 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, sessionId) {
-  const { agentCtx, chatHistory } = await fetchContext(connection, message.chatId);
-  const options = buildChatQueryOptions(agentCtx, projectDir, connection);
+async function runChatQuery(message, connection, projectDir) {
+  const { agentCtx, chatHistory } = await fetchContext(connection);
+  const options = buildChatQueryOptions(agentCtx, projectDir);
   const prompt = buildPrompt(message, chatHistory);
-  connection.emitAgentStatus("running");
-  const events = query2({
-    prompt,
-    options,
-    ...sessionId ? { resume: sessionId } : {}
-  });
+  const events = query2({ prompt, options });
   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;
   }
@@ -4581,416 +4024,26 @@ async function runChatQuery(message, connection, projectDir, sessionId) {
   if (responseText) {
     await connection.emitChatMessage(responseText);
   }
-  return resultSessionId;
 }
-async function handleProjectChatMessage(message, connection, projectDir, sessionId) {
-  connection.emitAgentStatus("fetching_context");
+async function handleProjectChatMessage(message, connection, projectDir) {
+  connection.emitAgentStatus("busy");
   try {
-    return await runChatQuery(message, connection, projectDir, sessionId);
+    await runChatQuery(message, connection, projectDir);
   } catch (error) {
     logger4.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 logger5 = 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 {
-    logger5.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()
-    };
-    logger5.info("Tag audit completed", {
-      requestId: request.requestId,
-      recommendationCount: result.recommendations.length
-    });
-    connection.emitAuditResult({ requestId: request.requestId, result });
-  } catch (error) {
-    logger5.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 logger6 = createServiceLogger("ProjectRunner");
+var logger5 = createServiceLogger("ProjectRunner");
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path.dirname(__filename);
 var HEARTBEAT_INTERVAL_MS2 = 3e4;
@@ -5009,12 +4062,12 @@ function setupWorkDir(projectDir, assignment) {
   }
   if (branch && branch !== devBranch) {
     try {
-      execSync6(`git checkout ${branch}`, { cwd: workDir, stdio: "ignore" });
+      execSync5(`git checkout ${branch}`, { cwd: workDir, stdio: "ignore" });
     } catch {
       try {
-        execSync6(`git checkout -b ${branch}`, { cwd: workDir, stdio: "ignore" });
+        execSync5(`git checkout -b ${branch}`, { cwd: workDir, stdio: "ignore" });
       } catch {
-        logger6.warn("Could not checkout branch", { taskId: shortId, branch });
+        logger5.warn("Could not checkout branch", { taskId: shortId, branch });
       }
     }
   }
@@ -5053,13 +4106,13 @@ function spawnChildAgent(assignment, workDir) {
   child.stdout?.on("data", (data) => {
     const lines = data.toString().trimEnd().split("\n");
     for (const line of lines) {
-      logger6.info(line, { taskId: shortId });
+      logger5.info(line, { taskId: shortId });
     }
   });
   child.stderr?.on("data", (data) => {
     const lines = data.toString().trimEnd().split("\n");
     for (const line of lines) {
-      logger6.error(line, { taskId: shortId });
+      logger5.error(line, { taskId: shortId });
     }
   });
   return child;
@@ -5071,60 +4124,27 @@ 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,
-      projectDir: config.projectDir
+      projectId: config.projectId
     });
-    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;
     try {
-      execSync6(`git fetch origin ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
-      execSync6(`git checkout ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
-      logger6.info("Checked out workspace branch", { workspaceBranch });
+      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 });
     } catch (err) {
-      logger6.warn("Failed to checkout workspace branch, continuing on current branch", {
+      logger5.warn("Failed to checkout workspace branch, continuing on current branch", {
         workspaceBranch,
         ...errorMeta(err)
       });
@@ -5133,15 +4153,15 @@ var ProjectRunner = class {
   async executeSetupCommand() {
     const cmd = process.env.CONVEYOR_SETUP_COMMAND;
     if (!cmd) return;
-    logger6.info("Running setup command", { command: cmd });
+    logger5.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);
       });
-      logger6.info("Setup command completed");
+      logger5.info("Setup command completed");
     } catch (error) {
-      logger6.error("Setup command failed", errorMeta(error));
+      logger5.error("Setup command failed", errorMeta(error));
       this.connection.emitEvent({
         type: "setup_error",
         message: error instanceof Error ? error.message : "Setup command failed"
@@ -5152,7 +4172,7 @@ var ProjectRunner = class {
   executeStartCommand() {
     const cmd = process.env.CONVEYOR_START_COMMAND;
     if (!cmd) return;
-    logger6.info("Running start command", { command: cmd });
+    logger5.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);
@@ -5162,7 +4182,7 @@ var ProjectRunner = class {
     child.on("exit", (code, signal) => {
       this.startCommandRunning = false;
       this.startCommandChild = null;
-      logger6.info("Start command exited", { code, signal });
+      logger5.info("Start command exited", { code, signal });
       this.connection.emitEvent({
         type: "start_command_exited",
         code,
@@ -5173,13 +4193,13 @@ var ProjectRunner = class {
     child.on("error", (err) => {
       this.startCommandRunning = false;
       this.startCommandChild = null;
-      logger6.error("Start command error", errorMeta(err));
+      logger5.error("Start command error", errorMeta(err));
     });
   }
   async killStartCommand() {
     const child = this.startCommandChild;
     if (!child || !this.startCommandRunning) return;
-    logger6.info("Killing start command");
+    logger5.info("Killing start command");
     try {
       if (child.pid) process.kill(-child.pid, "SIGTERM");
     } catch {
@@ -5211,7 +4231,7 @@ var ProjectRunner = class {
   getEnvironmentStatus() {
     let currentBranch = "unknown";
     try {
-      currentBranch = execSync6("git branch --show-current", {
+      currentBranch = execSync5("git branch --show-current", {
         cwd: this.projectDir,
         stdio: ["ignore", "pipe", "ignore"]
       }).toString().trim();
@@ -5224,180 +4244,6 @@ var ProjectRunner = class {
       previewPort: Number(process.env.CONVEYOR_PREVIEW_PORT) || null
     };
   }
-  getCurrentBranch() {
-    try {
-      return execSync6("git branch --show-current", {
-        cwd: this.projectDir,
-        stdio: ["ignore", "pipe", "ignore"]
-      }).toString().trim() || null;
-    } catch {
-      return null;
-    }
-  }
-  // oxlint-disable-next-line max-lines-per-function, complexity -- sequential sync steps with per-step error handling
-  async smartSync(previousSha, newSha, branch) {
-    const stepsRun = [];
-    const status = execSync6("git status --porcelain", {
-      cwd: this.projectDir,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).toString().trim();
-    if (status) {
-      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 {
-      execSync6(`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 });
-      logger6.error("Git pull failed during commit sync", errorMeta(err));
-      this.executeStartCommand();
-      return ["error:pull"];
-    }
-    let changedFiles = [];
-    try {
-      changedFiles = execSync6(`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 });
-        logger6.error("Branch switch command failed during commit sync", errorMeta(err));
-      }
-    } else if (!cmd) {
-      if (needsInstall) {
-        this.connection.emitEnvSwitchProgress({ step: "install", status: "running" });
-        try {
-          execSync6("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 });
-          logger6.error("bun install failed during commit sync", errorMeta(err));
-        }
-      }
-      if (needsPrisma) {
-        this.connection.emitEnvSwitchProgress({ step: "prisma", status: "running" });
-        try {
-          execSync6("bunx prisma generate", {
-            cwd: this.projectDir,
-            timeout: 6e4,
-            stdio: "pipe"
-          });
-          execSync6("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 });
-          logger6.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 {
-        execSync6("git fetch origin", { cwd: this.projectDir, stdio: "pipe" });
-      } catch {
-        logger6.warn("Git fetch failed during branch switch");
-      }
-      this.connection.emitEnvSwitchProgress({ step: "fetch", status: "success" });
-      this.connection.emitEnvSwitchProgress({ step: "checkout", status: "running" });
-      try {
-        execSync6(`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 {
-        execSync6(`git pull origin ${branch}`, { cwd: this.projectDir, stdio: "pipe" });
-      } catch {
-        logger6.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";
-      logger6.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 });
-          logger6.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";
-      logger6.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();
@@ -5411,7 +4257,7 @@ var ProjectRunner = class {
         startCommandRunning: this.startCommandRunning
       });
     } catch (error) {
-      logger6.error("Environment setup failed", errorMeta(error));
+      logger5.error("Environment setup failed", errorMeta(error));
       this.setupComplete = false;
     }
     this.connection.onTaskAssignment((assignment) => {
@@ -5421,53 +4267,17 @@ var ProjectRunner = class {
       this.handleStopTask(data.taskId);
     });
     this.connection.onShutdown(() => {
-      logger6.info("Received shutdown signal from server");
+      logger5.info("Received shutdown signal from server");
       void this.stop();
     });
     this.connection.onChatMessage((msg) => {
-      logger6.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) => {
-      logger6.debug("Received tag audit request", { requestId: request.requestId });
-      void handleProjectAuditRequest(request, this.connection, this.projectDir);
+      logger5.debug("Received project chat message");
+      void handleProjectChatMessage(msg, 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);
-    const currentBranch = this.getCurrentBranch();
-    if (currentBranch) {
-      this.commitWatcher.start(currentBranch);
-    }
-    logger6.info("Connected, waiting for task assignments");
+    logger5.info("Connected, waiting for task assignments");
     await new Promise((resolve2) => {
       this.resolveLifecycle = resolve2;
       process.on("SIGTERM", () => void this.stop());
@@ -5478,11 +4288,11 @@ var ProjectRunner = class {
     const { taskId, mode } = assignment;
     const shortId = taskId.slice(0, 8);
     if (this.activeAgents.has(taskId)) {
-      logger6.info("Task already running, skipping", { taskId: shortId });
+      logger5.info("Task already running, skipping", { taskId: shortId });
       return;
     }
     if (this.activeAgents.size >= MAX_CONCURRENT) {
-      logger6.warn("Max concurrent agents reached, rejecting task", {
+      logger5.warn("Max concurrent agents reached, rejecting task", {
         maxConcurrent: MAX_CONCURRENT,
         taskId: shortId
       });
@@ -5491,9 +4301,9 @@ var ProjectRunner = class {
     }
     try {
       try {
-        execSync6("git fetch origin", { cwd: this.projectDir, stdio: "ignore" });
+        execSync5("git fetch origin", { cwd: this.projectDir, stdio: "ignore" });
       } catch {
-        logger6.warn("Git fetch failed", { taskId: shortId });
+        logger5.warn("Git fetch failed", { taskId: shortId });
       }
       const { workDir, usesWorktree } = setupWorkDir(this.projectDir, assignment);
       const child = spawnChildAgent(assignment, workDir);
@@ -5504,12 +4314,12 @@ var ProjectRunner = class {
         usesWorktree
       });
       this.connection.emitTaskStarted(taskId);
-      logger6.info("Started task", { taskId: shortId, mode, workDir });
+      logger5.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);
-        logger6.info("Task exited", { taskId: shortId, reason });
+        logger5.info("Task exited", { taskId: shortId, reason });
         if (code === 0 && usesWorktree) {
           try {
             removeWorktree(this.projectDir, taskId);
@@ -5518,7 +4328,7 @@ var ProjectRunner = class {
         }
       });
     } catch (error) {
-      logger6.error("Failed to start task", {
+      logger5.error("Failed to start task", {
         taskId: shortId,
         ...errorMeta(error)
       });
@@ -5532,7 +4342,7 @@ var ProjectRunner = class {
     const agent = this.activeAgents.get(taskId);
     if (!agent) return;
     const shortId = taskId.slice(0, 8);
-    logger6.info("Stopping task", { taskId: shortId });
+    logger5.info("Stopping task", { taskId: shortId });
     agent.process.kill("SIGTERM");
     const timer = setTimeout(() => {
       if (this.activeAgents.has(taskId)) {
@@ -5552,8 +4362,7 @@ var ProjectRunner = class {
   async stop() {
     if (this.stopping) return;
     this.stopping = true;
-    logger6.info("Shutting down");
-    this.commitWatcher.stop();
+    logger5.info("Shutting down");
     await this.killStartCommand();
     if (this.heartbeatTimer) {
       clearInterval(this.heartbeatTimer);
@@ -5579,7 +4388,7 @@ var ProjectRunner = class {
       })
     ]);
     this.connection.disconnect();
-    logger6.info("Shutdown complete");
+    logger5.info("Shutdown complete");
     if (this.resolveLifecycle) {
       this.resolveLifecycle();
       this.resolveLifecycle = null;
@@ -5656,13 +4465,13 @@ export {
   runStartCommand,
   ConveyorConnection,
   ProjectConnection,
+  createServiceLogger,
+  errorMeta,
   ensureWorktree,
   removeWorktree,
   loadConveyorConfig,
-  createServiceLogger,
-  errorMeta,
   AgentRunner,
   ProjectRunner,
   FileCache
 };
-//# sourceMappingURL=chunk-SQJJL2PU.js.map
+//# sourceMappingURL=chunk-HYWZJYPW.js.map