@rallycry/conveyor-agent 5.11.0 → 5.12.0

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

@@ -427,6 +427,23 @@ var ConveyorConnection = class _ConveyorConnection {
   triggerIdentification() {
     return triggerIdentification(this.socket);
   }
+  async refreshAuthToken() {
+    const codespaceName = process.env.CODESPACE_NAME;
+    const apiUrl = process.env.CONVEYOR_API_URL ?? this.config.conveyorApiUrl;
+    if (!codespaceName || !apiUrl) return false;
+    try {
+      const response = await fetch(`${apiUrl}/api/codespace/bootstrap/${codespaceName}`);
+      if (!response.ok) return false;
+      const config = await response.json();
+      if (config.envVars?.CLAUDE_CODE_OAUTH_TOKEN) {
+        process.env.CLAUDE_CODE_OAUTH_TOKEN = config.envVars.CLAUDE_CODE_OAUTH_TOKEN;
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
   emitModeTransition(payload) {
     if (!this.socket) return;
     this.socket.emit("agentRunner:modeTransition", payload);
@@ -623,13 +640,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"));
@@ -637,6 +654,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);
@@ -842,6 +891,10 @@ async function processAssistantEvent(event, host, turnToolCalls) {
 }
 var API_ERROR_PATTERN = /API Error: [45]\d\d/;
 var IMAGE_ERROR_PATTERN = /Could not process image/i;
+var AUTH_ERROR_PATTERN = /Not logged in|Please run \/login|authentication failed|invalid.*token|unauthorized/i;
+function isAuthError(msg) {
+  return AUTH_ERROR_PATTERN.test(msg);
+}
 function isRetriableMessage(msg) {
   if (IMAGE_ERROR_PATTERN.test(msg)) return true;
   if (API_ERROR_PATTERN.test(msg)) return true;
@@ -922,6 +975,10 @@ function handleErrorResult(event, host) {
   if (isStaleSession) {
     return { retriable: false, staleSession: true };
   }
+  if (isAuthError(errorMsg)) {
+    host.connection.sendEvent({ type: "error", message: errorMsg });
+    return { retriable: false, authError: true };
+  }
   const retriable = isRetriableMessage(errorMsg);
   host.connection.sendEvent({ type: "error", message: errorMsg });
   return { retriable };
@@ -961,7 +1018,8 @@ async function emitResultEvent(event, host, context, startTime, lastAssistantUsa
   return {
     retriable: result.retriable,
     resultSummary: result.resultSummary,
-    staleSession: result.staleSession
+    staleSession: result.staleSession,
+    authError: result.authError
   };
 }
 function handleRateLimitEvent(event, host) {
@@ -1061,6 +1119,7 @@ async function handleResultCase(event, host, context, startTime, isTyping, lastA
     retriable: resultInfo.retriable,
     resultSummary: resultInfo.resultSummary,
     staleSession: resultInfo.staleSession,
+    authError: resultInfo.authError,
     stoppedTyping
   };
 }
@@ -1108,6 +1167,7 @@ async function processResultCase(event, host, context, startTime, state) {
   state.retriable = info.retriable;
   state.resultSummary = info.resultSummary;
   if (info.staleSession) state.staleSession = true;
+  if (info.authError) state.authError = true;
 }
 async function processEvents(events, context, host) {
   const startTime = Date.now();
@@ -1121,6 +1181,7 @@ async function processEvents(events, context, host) {
     resultSummary: void 0,
     rateLimitResetsAt: void 0,
     staleSession: void 0,
+    authError: void 0,
     lastAssistantUsage: void 0,
     turnToolCalls: []
   };
@@ -1160,7 +1221,8 @@ async function processEvents(events, context, host) {
     retriable: state.retriable || state.sawApiError,
     resultSummary: state.resultSummary,
     rateLimitResetsAt: state.rateLimitResetsAt,
-    ...state.staleSession && { staleSession: state.staleSession }
+    ...state.staleSession && { staleSession: state.staleSession },
+    ...state.authError && { authError: state.authError }
   };
 }
 
@@ -3115,6 +3177,29 @@ async function buildRetryQuery(host, context, options, lastErrorWasImage) {
     options: { ...options, resume: void 0 }
   });
 }
+async function handleAuthError(context, host, options) {
+  host.connection.postChatMessage("Authentication expired. Re-bootstrapping credentials...");
+  const refreshed = await host.connection.refreshAuthToken();
+  if (!refreshed) {
+    host.connection.postChatMessage("Failed to refresh authentication. Agent will restart.");
+    host.connection.sendEvent({
+      type: "error",
+      message: "Auth re-bootstrap failed, exiting for restart"
+    });
+    process.exit(1);
+  }
+  context.claudeSessionId = null;
+  host.connection.storeSessionId("");
+  const freshPrompt = buildMultimodalPrompt(
+    await buildInitialPrompt(host.config.mode, context, host.config.isAuto, host.agentMode),
+    context
+  );
+  const freshQuery = query({
+    prompt: host.createInputStream(freshPrompt),
+    options: { ...options, resume: void 0 }
+  });
+  return runWithRetry(freshQuery, context, host, options);
+}
 async function handleStaleSession(context, host, options) {
   context.claudeSessionId = null;
   host.connection.storeSessionId("");
@@ -3183,26 +3268,41 @@ function handleRetryError(error, context, host, options, prevImageError) {
   if (isStaleOrExitedSession(error, context) && context.claudeSessionId) {
     return handleStaleSession(context, host, options);
   }
+  if (isAuthError(getErrorMessage(error))) {
+    return handleAuthError(context, host, options);
+  }
   if (!isRetriableError(error)) throw error;
   return { action: "continue", lastErrorWasImage: classifyImageError(error) || prevImageError };
 }
+function handleProcessResult(result, context, host, options) {
+  if (result.modeRestart || host.isStopped()) return { action: "return" };
+  if (result.rateLimitResetsAt) {
+    handleRateLimitPause(host, result.rateLimitResetsAt);
+    return { action: "return" };
+  }
+  if (result.staleSession && context.claudeSessionId) {
+    return { action: "return_promise", promise: handleStaleSession(context, host, options) };
+  }
+  if (result.authError) {
+    return { action: "return_promise", promise: handleAuthError(context, host, options) };
+  }
+  if (!result.retriable) return { action: "return" };
+  return {
+    action: "continue",
+    lastErrorWasImage: IMAGE_ERROR_PATTERN2.test(result.resultSummary ?? "")
+  };
+}
 async function runWithRetry(initialQuery, context, host, options) {
   let lastErrorWasImage = false;
   for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt++) {
     if (host.isStopped()) return;
     const agentQuery = attempt === 0 ? initialQuery : await buildRetryQuery(host, context, options, lastErrorWasImage);
     try {
-      const { retriable, resultSummary, modeRestart, rateLimitResetsAt, staleSession } = await processEvents(agentQuery, context, host);
-      if (modeRestart || host.isStopped()) return;
-      if (rateLimitResetsAt) {
-        handleRateLimitPause(host, rateLimitResetsAt);
-        return;
-      }
-      if (staleSession && context.claudeSessionId) {
-        return handleStaleSession(context, host, options);
-      }
-      if (!retriable) return;
-      lastErrorWasImage = IMAGE_ERROR_PATTERN2.test(resultSummary ?? "");
+      const result = await processEvents(agentQuery, context, host);
+      const outcome = handleProcessResult(result, context, host, options);
+      if (outcome.action === "return") return;
+      if (outcome.action === "return_promise") return outcome.promise;
+      lastErrorWasImage = outcome.lastErrorWasImage;
     } catch (error) {
       const outcome = handleRetryError(error, context, host, options, lastErrorWasImage);
       if (outcome instanceof Promise) return outcome;
@@ -4142,7 +4242,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) {
@@ -4199,7 +4451,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();
@@ -4208,15 +4460,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: {
@@ -4228,8 +4484,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
   };
@@ -4295,16 +4552,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;
   }
@@ -4315,11 +4581,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");
@@ -4329,6 +4596,7 @@ async function handleProjectChatMessage(message, connection, projectDir) {
       );
     } catch {
     }
+    return void 0;
   } finally {
     connection.emitAgentStatus("idle");
   }
@@ -4339,8 +4607,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",
@@ -4422,14 +4690,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(
@@ -4441,14 +4709,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(
@@ -4460,16 +4728,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(
@@ -4481,16 +4749,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(
@@ -4502,15 +4770,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(
@@ -4522,14 +4790,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(
@@ -4541,10 +4809,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.";
@@ -4552,7 +4820,7 @@ function createAuditMcpServer(collector, onRecommendation) {
       }
     )
   ];
-  return createSdkMcpServer2({
+  return createSdkMcpServer3({
     name: "tag-audit",
     tools: auditTools
   });
@@ -4674,7 +4942,7 @@ async function runAuditQuery(request, connection, projectDir) {
       allowDangerouslySkipPermissions: true,
       tools: { type: "preset", preset: "claude_code" },
       mcpServers: { "tag-audit": createAuditMcpServer(collector, onRecommendation) },
-      maxTurns: settings.maxTurns ?? 30,
+      maxTurns: settings.maxTurns ?? 75,
       maxBudgetUsd: settings.maxBudgetUsd ?? 5,
       effort: settings.effort,
       thinking: settings.thinking
@@ -4803,6 +5071,7 @@ var ProjectRunner = class {
   heartbeatTimer = null;
   stopping = false;
   resolveLifecycle = null;
+  chatSessionIds = /* @__PURE__ */ new Map();
   // Start command process management
   startCommandChild = null;
   startCommandRunning = false;
@@ -5157,7 +5426,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 });
@@ -5388,4 +5665,4 @@ export {
   ProjectRunner,
   FileCache
 };
-//# sourceMappingURL=chunk-LBEAK2VJ.js.map
+//# sourceMappingURL=chunk-SQJJL2PU.js.map