@rallycry/conveyor-agent 5.11.1 → 5.13.0

package/dist/{chunk-U3YWTVH3.js → chunk-4RFYCO2T.js}

@@ -230,6 +230,18 @@ var ConveyorConnection = class _ConveyorConnection {
           resolve2();
         }
       });
+      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) {
@@ -557,6 +569,18 @@ var ProjectConnection = class {
           resolve2();
         }
       });
+      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) {
@@ -640,13 +664,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"));
@@ -654,6 +678,38 @@ 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);
@@ -701,9 +757,32 @@ var ProjectConnection = class {
 };
 
 // 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}/`)) {
@@ -712,8 +791,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"
         });
@@ -723,17 +805,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"
     });
@@ -769,10 +873,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
@@ -810,7 +914,7 @@ function errorMeta(error) {
 
 // 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/execution/event-handlers.ts
 function safeVoid(promise, context) {
@@ -3444,6 +3548,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",
@@ -3463,6 +3608,19 @@ async function checkoutTaskBranch(runnerConfig, connection, callbacks, setupLog)
       }
     );
     pushSetupLog(setupLog, `[conveyor] Switched to ${taskBranch}`);
+    if (didStash) {
+      try {
+        await runSetupCommand("git stash pop", runnerConfig.workspaceDir, (stream, data) => {
+          connection.sendEvent({ type: "setup_output", stream, data });
+        });
+        pushSetupLog(setupLog, `[conveyor] Restored stashed changes`);
+      } catch {
+        pushSetupLog(
+          setupLog,
+          `[conveyor] Warning: stash pop had conflicts \u2014 agent may need to resolve`
+        );
+      }
+    }
     return true;
   } catch (error) {
     const message = `Failed to checkout ${taskBranch}: ${error instanceof Error ? error.message : "unknown error"}`;
@@ -3807,12 +3965,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 {
     }
   }
@@ -4100,12 +4268,12 @@ var AgentRunner = class {
 
 // src/runner/project-runner.ts
 import { fork } from "child_process";
-import { execSync as execSync6 } 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 execSync5 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 var logger3 = createServiceLogger("CommitWatcher");
 var CommitWatcher = class {
   constructor(config, callbacks) {
@@ -4137,7 +4305,7 @@ var CommitWatcher = class {
     this.isSyncing = false;
   }
   getLocalHeadSha() {
-    return execSync5("git rev-parse HEAD", {
+    return execSync6("git rev-parse HEAD", {
       cwd: this.config.projectDir,
       stdio: ["ignore", "pipe", "ignore"]
     }).toString().trim();
@@ -4145,12 +4313,12 @@ var CommitWatcher = class {
   poll() {
     if (!this.branch || this.isSyncing) return;
     try {
-      execSync5(`git fetch origin ${this.branch} --quiet`, {
+      execSync6(`git fetch origin ${this.branch} --quiet`, {
         cwd: this.config.projectDir,
         stdio: "ignore",
         timeout: 3e4
       });
-      const remoteSha = execSync5(`git rev-parse origin/${this.branch}`, {
+      const remoteSha = execSync6(`git rev-parse origin/${this.branch}`, {
         cwd: this.config.projectDir,
         stdio: ["ignore", "pipe", "ignore"]
       }).toString().trim();
@@ -4171,12 +4339,12 @@ var CommitWatcher = class {
     let latestMessage = "";
     let latestAuthor = "";
     try {
-      const countOutput = execSync5(`git rev-list --count ${previousSha}..origin/${this.branch}`, {
+      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 = execSync5(`git log -1 --format="%s|||%an" origin/${this.branch}`, {
+      const logOutput = execSync6(`git log -1 --format="%s|||%an" origin/${this.branch}`, {
         cwd: this.config.projectDir,
         stdio: ["ignore", "pipe", "ignore"]
       }).toString().trim();
@@ -4210,7 +4378,159 @@ var CommitWatcher = class {
 };
 
 // src/runner/project-chat-handler.ts
-import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
+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
 var logger4 = createServiceLogger("ProjectChat");
 var FALLBACK_MODEL = "claude-sonnet-4-20250514";
 function buildSystemPrompt2(projectDir, agentCtx) {
@@ -4267,7 +4587,7 @@ function processContentBlock(block, responseParts, turnToolCalls) {
     logger4.debug("Tool use", { tool: block.name });
   }
 }
-async function fetchContext(connection) {
+async function fetchContext(connection, chatId) {
   let agentCtx = null;
   try {
     agentCtx = await connection.fetchAgentContext();
@@ -4276,15 +4596,19 @@ async function fetchContext(connection) {
   }
   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");
   }
   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: {
@@ -4296,8 +4620,9 @@ 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
   };
@@ -4363,16 +4688,25 @@ function processEventStream(event, connection, responseParts, turnToolCalls, isT
   }
   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);
   connection.emitAgentStatus("running");
-  const events = query2({ prompt, options });
+  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;
   }
@@ -4383,11 +4717,12 @@ async function runChatQuery(message, connection, projectDir) {
   if (responseText) {
     await connection.emitChatMessage(responseText);
   }
+  return resultSessionId;
 }
-async function handleProjectChatMessage(message, connection, projectDir) {
+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));
     connection.emitAgentStatus("error");
@@ -4397,6 +4732,7 @@ async function handleProjectChatMessage(message, connection, projectDir) {
       );
     } catch {
     }
+    return void 0;
   } finally {
     connection.emitAgentStatus("idle");
   }
@@ -4407,8 +4743,8 @@ import { query as query3 } from "@anthropic-ai/claude-agent-sdk";
 
 // src/tools/audit-tools.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { tool as tool4, createSdkMcpServer as createSdkMcpServer2 } from "@anthropic-ai/claude-agent-sdk";
-import { z as z4 } from "zod";
+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",
@@ -4490,14 +4826,14 @@ function collectRecommendation(toolName, input, collector, onRecommendation) {
 }
 function createAuditMcpServer(collector, onRecommendation) {
   const auditTools = [
-    tool4(
+    tool5(
       "recommend_create_tag",
       "Recommend creating a new tag for an uncovered subsystem or area",
       {
-        name: z4.string().describe("Proposed tag name (lowercase, hyphenated)"),
-        color: z4.string().optional().describe("Hex color code"),
-        description: z4.string().describe("What this tag covers"),
-        reasoning: z4.string().describe("Why this tag should be created")
+        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(
@@ -4509,14 +4845,14 @@ function createAuditMcpServer(collector, onRecommendation) {
         return { content: [{ type: "text", text: result }] };
       }
     ),
-    tool4(
+    tool5(
       "recommend_update_description",
       "Recommend updating a tag's description to better reflect its scope",
       {
-        tagId: z4.string(),
-        tagName: z4.string(),
-        description: z4.string().describe("Proposed new description"),
-        reasoning: z4.string()
+        tagId: z5.string(),
+        tagName: z5.string(),
+        description: z5.string().describe("Proposed new description"),
+        reasoning: z5.string()
       },
       async (args) => {
         const result = collectRecommendation(
@@ -4528,16 +4864,16 @@ function createAuditMcpServer(collector, onRecommendation) {
         return { content: [{ type: "text", text: result }] };
       }
     ),
-    tool4(
+    tool5(
       "recommend_context_link",
       "Recommend linking a doc, rule, file, or folder to a tag's contextPaths",
       {
-        tagId: z4.string(),
-        tagName: z4.string(),
-        linkType: z4.enum(["rule", "doc", "file", "folder"]),
-        path: z4.string(),
-        label: z4.string().optional(),
-        reasoning: z4.string()
+        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(
@@ -4549,16 +4885,16 @@ function createAuditMcpServer(collector, onRecommendation) {
         return { content: [{ type: "text", text: result }] };
       }
     ),
-    tool4(
+    tool5(
       "flag_documentation_gap",
       "Flag a file that agents read heavily but has no tag documentation linked",
       {
-        tagName: z4.string().describe("Tag whose agents read this file"),
-        tagId: z4.string().optional(),
-        filePath: z4.string(),
-        readCount: z4.number(),
-        suggestedAction: z4.string().describe("What doc or rule should be created"),
-        reasoning: z4.string()
+        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(
@@ -4570,15 +4906,15 @@ function createAuditMcpServer(collector, onRecommendation) {
         return { content: [{ type: "text", text: result }] };
       }
     ),
-    tool4(
+    tool5(
       "recommend_merge_tags",
       "Recommend merging one tag into another",
       {
-        tagId: z4.string().describe("Tag ID to be merged (removed after merge)"),
-        tagName: z4.string().describe("Name of the tag to be merged"),
-        mergeIntoTagId: z4.string().describe("Tag ID to merge into (kept)"),
-        mergeIntoTagName: z4.string(),
-        reasoning: z4.string()
+        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(
@@ -4590,14 +4926,14 @@ function createAuditMcpServer(collector, onRecommendation) {
         return { content: [{ type: "text", text: result }] };
       }
     ),
-    tool4(
+    tool5(
       "recommend_rename_tag",
       "Recommend renaming a tag",
       {
-        tagId: z4.string(),
-        tagName: z4.string().describe("Current tag name"),
-        newName: z4.string().describe("Proposed new name"),
-        reasoning: z4.string()
+        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(
@@ -4609,10 +4945,10 @@ function createAuditMcpServer(collector, onRecommendation) {
         return { content: [{ type: "text", text: result }] };
       }
     ),
-    tool4(
+    tool5(
       "complete_audit",
       "Signal that the audit is complete with a summary of all findings",
-      { summary: z4.string().describe("Brief overview of all findings") },
+      { summary: z5.string().describe("Brief overview of all findings") },
       async (args) => {
         collector.complete = true;
         collector.summary = args.summary ?? "Audit completed.";
@@ -4620,7 +4956,7 @@ function createAuditMcpServer(collector, onRecommendation) {
       }
     )
   ];
-  return createSdkMcpServer2({
+  return createSdkMcpServer3({
     name: "tag-audit",
     tools: auditTools
   });
@@ -4808,13 +5144,20 @@ function setupWorkDir(projectDir, assignment) {
     workDir = projectDir;
   }
   if (branch && branch !== devBranch) {
-    try {
-      execSync6(`git checkout ${branch}`, { cwd: workDir, stdio: "ignore" });
-    } catch {
+    if (hasUncommittedChanges(workDir)) {
+      logger6.warn("Uncommitted changes in work dir, skipping checkout", {
+        taskId: shortId,
+        branch
+      });
+    } else {
       try {
-        execSync6(`git checkout -b ${branch}`, { cwd: workDir, stdio: "ignore" });
+        execSync7(`git checkout ${branch}`, { cwd: workDir, stdio: "ignore" });
       } catch {
-        logger6.warn("Could not checkout branch", { taskId: shortId, branch });
+        try {
+          execSync7(`git checkout -b ${branch}`, { cwd: workDir, stdio: "ignore" });
+        } catch {
+          logger6.warn("Could not checkout branch", { taskId: shortId, branch });
+        }
       }
     }
   }
@@ -4871,6 +5214,7 @@ var ProjectRunner = class {
   heartbeatTimer = null;
   stopping = false;
   resolveLifecycle = null;
+  chatSessionIds = /* @__PURE__ */ new Map();
   // Start command process management
   startCommandChild = null;
   startCommandRunning = false;
@@ -4918,9 +5262,20 @@ var ProjectRunner = class {
   checkoutWorkspaceBranch() {
     const workspaceBranch = process.env.CONVEYOR_WORKSPACE_BRANCH;
     if (!workspaceBranch) return;
+    const currentBranch = this.getCurrentBranch();
+    if (currentBranch === workspaceBranch) {
+      logger6.info("Already on workspace branch", { workspaceBranch });
+      return;
+    }
+    if (hasUncommittedChanges(this.projectDir)) {
+      logger6.warn("Uncommitted changes detected, skipping workspace branch checkout", {
+        workspaceBranch
+      });
+      return;
+    }
     try {
-      execSync6(`git fetch origin ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
-      execSync6(`git checkout ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
+      execSync7(`git fetch origin ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
+      execSync7(`git checkout ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
       logger6.info("Checked out workspace branch", { workspaceBranch });
     } catch (err) {
       logger6.warn("Failed to checkout workspace branch, continuing on current branch", {
@@ -5008,39 +5363,20 @@ var ProjectRunner = class {
     this.executeStartCommand();
   }
   getEnvironmentStatus() {
-    let currentBranch = "unknown";
-    try {
-      currentBranch = execSync6("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() {
-    try {
-      return execSync6("git branch --show-current", {
-        cwd: this.projectDir,
-        stdio: ["ignore", "pipe", "ignore"]
-      }).toString().trim() || null;
-    } catch {
-      return null;
-    }
+    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 = [];
-    const status = execSync6("git status --porcelain", {
-      cwd: this.projectDir,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).toString().trim();
-    if (status) {
+    if (hasUncommittedChanges(this.projectDir)) {
       this.connection.emitEvent({
         type: "commit_watch_warning",
         message: "Working tree has uncommitted changes. Auto-pull skipped."
@@ -5050,7 +5386,7 @@ var ProjectRunner = class {
     await this.killStartCommand();
     this.connection.emitEnvSwitchProgress({ step: "pull", status: "running" });
     try {
-      execSync6(`git pull origin ${branch}`, {
+      execSync7(`git pull origin ${branch}`, {
         cwd: this.projectDir,
         stdio: "pipe",
         timeout: 6e4
@@ -5066,7 +5402,7 @@ var ProjectRunner = class {
     }
     let changedFiles = [];
     try {
-      changedFiles = execSync6(`git diff --name-only ${previousSha}..${newSha}`, {
+      changedFiles = execSync7(`git diff --name-only ${previousSha}..${newSha}`, {
         cwd: this.projectDir,
         stdio: ["ignore", "pipe", "ignore"]
       }).toString().trim().split("\n").filter(Boolean);
@@ -5096,7 +5432,7 @@ var ProjectRunner = class {
       if (needsInstall) {
         this.connection.emitEnvSwitchProgress({ step: "install", status: "running" });
         try {
-          execSync6("bun install", { cwd: this.projectDir, timeout: 12e4, stdio: "pipe" });
+          execSync7("bun install", { cwd: this.projectDir, timeout: 12e4, stdio: "pipe" });
           stepsRun.push("install");
           this.connection.emitEnvSwitchProgress({ step: "install", status: "success" });
         } catch (err) {
@@ -5108,12 +5444,12 @@ var ProjectRunner = class {
       if (needsPrisma) {
         this.connection.emitEnvSwitchProgress({ step: "prisma", status: "running" });
         try {
-          execSync6("bunx prisma generate", {
+          execSync7("bunx prisma generate", {
             cwd: this.projectDir,
             timeout: 6e4,
             stdio: "pipe"
           });
-          execSync6("bunx prisma db push --accept-data-loss", {
+          execSync7("bunx prisma db push --accept-data-loss", {
             cwd: this.projectDir,
             timeout: 6e4,
             stdio: "pipe"
@@ -5136,14 +5472,15 @@ var ProjectRunner = class {
     try {
       this.connection.emitEnvSwitchProgress({ step: "fetch", status: "running" });
       try {
-        execSync6("git fetch origin", { cwd: this.projectDir, stdio: "pipe" });
+        execSync7("git fetch origin", { cwd: this.projectDir, stdio: "pipe" });
       } catch {
         logger6.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 {
-        execSync6(`git checkout ${branch}`, { cwd: this.projectDir, stdio: "pipe" });
+        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 });
@@ -5151,7 +5488,7 @@ var ProjectRunner = class {
         return;
       }
       try {
-        execSync6(`git pull origin ${branch}`, { cwd: this.projectDir, stdio: "pipe" });
+        execSync7(`git pull origin ${branch}`, { cwd: this.projectDir, stdio: "pipe" });
       } catch {
         logger6.warn("Git pull failed during branch switch", { branch });
       }
@@ -5225,7 +5562,15 @@ var ProjectRunner = class {
     });
     this.connection.onChatMessage((msg) => {
       logger6.debug("Received project chat message");
-      void handleProjectChatMessage(msg, this.connection, this.projectDir);
+      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 });
@@ -5282,7 +5627,7 @@ var ProjectRunner = class {
     }
     try {
       try {
-        execSync6("git fetch origin", { cwd: this.projectDir, stdio: "ignore" });
+        execSync7("git fetch origin", { cwd: this.projectDir, stdio: "ignore" });
       } catch {
         logger6.warn("Git fetch failed", { taskId: shortId });
       }
@@ -5456,4 +5801,4 @@ export {
   ProjectRunner,
   FileCache
 };
-//# sourceMappingURL=chunk-U3YWTVH3.js.map
+//# sourceMappingURL=chunk-4RFYCO2T.js.map