@rallycry/conveyor-agent 6.0.7 → 6.0.8

package/dist/{chunk-ANYHEBDY.js → chunk-T6IASOS2.js}

@@ -487,6 +487,10 @@ var ConveyorConnection = class _ConveyorConnection {
     if (!this.socket) return;
     this.socket.emit("agentRunner:debugReproduceRequested", { hypothesis });
   }
+  emitCodeReviewResult(content, approved) {
+    if (!this.socket) throw new Error("Not connected");
+    this.socket.emit("agentRunner:codeReviewResult", { content, approved });
+  }
   searchIncidents(status, source) {
     return searchIncidents(this.socket, status, source);
   }
@@ -1487,7 +1491,13 @@ var API_ERROR_PATTERN2 = /API Error: [45]\d\d/;
 function stopTypingIfNeeded(host, isTyping) {
   if (isTyping) host.connection.sendTypingStop();
 }
-function flushPendingToolCalls(host, turnToolCalls) {
+function shouldBreakEventLoop(host, state) {
+  if (host.isStopped()) return true;
+  if (state.loopDetected) return true;
+  return false;
+}
+function flushPendingToolCalls(host, state) {
+  const { turnToolCalls } = state;
   if (turnToolCalls.length === 0) return;
   for (let i = 0; i < turnToolCalls.length; i++) {
     if (i < host.pendingToolOutputs.length) {
@@ -1495,6 +1505,12 @@ function flushPendingToolCalls(host, turnToolCalls) {
     }
   }
   host.connection.sendEvent({ type: "turn_end", toolCalls: [...turnToolCalls] });
+  if (host.loopDetector.recordTurn(turnToolCalls)) {
+    state.loopDetected = true;
+    host.connection.postChatMessage(
+      "Loop detected: the agent has been repeating the same tool pattern. Intervening to change strategy..."
+    );
+  }
   turnToolCalls.length = 0;
   host.pendingToolOutputs.length = 0;
 }
@@ -1552,12 +1568,13 @@ async function processEvents(events, context, host) {
     rateLimitResetsAt: void 0,
     staleSession: void 0,
     authError: void 0,
+    loopDetected: false,
     lastAssistantUsage: void 0,
     turnToolCalls: []
   };
   for await (const event of events) {
-    if (host.isStopped()) break;
-    flushPendingToolCalls(host, state.turnToolCalls);
+    flushPendingToolCalls(host, state);
+    if (shouldBreakEventLoop(host, state)) break;
     const now = Date.now();
     if (now - lastStatusEmit >= STATUS_REEMIT_INTERVAL_MS) {
       host.connection.emitStatus("running");
@@ -1587,14 +1604,15 @@ async function processEvents(events, context, host) {
         break;
     }
   }
-  flushPendingToolCalls(host, state.turnToolCalls);
+  flushPendingToolCalls(host, state);
   stopTypingIfNeeded(host, state.isTyping);
   return {
     retriable: state.retriable || state.sawApiError,
     resultSummary: state.resultSummary,
     rateLimitResetsAt: state.rateLimitResetsAt,
     ...state.staleSession && { staleSession: state.staleSession },
-    ...state.authError && { authError: state.authError }
+    ...state.authError && { authError: state.authError },
+    ...state.loopDetected && { loopDetected: state.loopDetected }
   };
 }
 
@@ -2035,10 +2053,52 @@ function buildModePrompt(agentMode, context) {
       ].join("\n");
     case "auto":
       return buildAutoPrompt(context);
+    case "code-review":
+      return buildCodeReviewPrompt();
     default:
       return null;
   }
 }
+function buildCodeReviewPrompt() {
+  return [
+    `
+## Mode: Code Review`,
+    `You are an automated code reviewer. A PR has passed all CI checks and you are performing a final code quality review before merge.`,
+    ``,
+    `## Review Process`,
+    `1. Run \`git diff <devBranch>..HEAD\` to see all changes in this PR`,
+    `2. Read the task plan to understand the intended changes`,
+    `3. Explore the surrounding codebase to verify pattern consistency`,
+    `4. Review against the criteria below`,
+    ``,
+    `### Review Criteria`,
+    `- **Correctness**: Does the code do what the plan says? Logic errors, off-by-one, race conditions?`,
+    `- **Pattern Consistency**: Does the code follow existing patterns in the codebase? Check nearby files.`,
+    `- **Security**: No hardcoded secrets, no injection vulnerabilities, proper input validation at boundaries.`,
+    `- **Performance**: No unnecessary loops, no N+1 queries, no blocking in async contexts.`,
+    `- **Error Handling**: Appropriate error handling at system boundaries. No swallowed errors.`,
+    `- **Test Coverage**: Are new code paths tested? Edge cases covered?`,
+    `- **TypeScript Best Practices**: Proper typing (no unnecessary \`any\`), correct React patterns, proper async/await.`,
+    `- **Naming & Readability**: Clear names, no misleading comments, self-documenting code.`,
+    ``,
+    `## Output \u2014 You MUST do exactly ONE of:`,
+    ``,
+    `### If code passes review:`,
+    `Use the \`approve_code_review\` tool with a brief summary of what looks good.`,
+    ``,
+    `### If changes are needed:`,
+    `Use the \`request_code_changes\` tool with specific issues:`,
+    `- Reference specific files and line numbers`,
+    `- Explain what's wrong and suggest fixes`,
+    `- Focus on substantive issues, not style nitpicks (linting handles that)`,
+    ``,
+    `## Rules`,
+    `- You are READ-ONLY. Do NOT modify any files.`,
+    `- Do NOT re-review things CI already validates (formatting, lint rules).`,
+    `- Be concise \u2014 the task agent needs actionable feedback, not essays.`,
+    `- Max 5-7 issues per review. Prioritize the most important ones.`
+  ].join("\n");
+}
 
 // src/execution/system-prompt.ts
 function formatProjectAgentLine(pa) {
@@ -2410,6 +2470,18 @@ ${context.plan}`);
   }
   return parts;
 }
+function buildCodeReviewInstructions(context) {
+  const parts = [
+    `You are performing an automated code review for this task.`,
+    `The PR branch is "${context.githubBranch}"${context.baseBranch ? ` based on "${context.baseBranch}"` : ""}.`,
+    `Begin your code review by running \`git diff ${context.baseBranch ?? "dev"}..HEAD\` to see all changes.`,
+    ``,
+    `CRITICAL: You are in Code Review mode. You are READ-ONLY \u2014 do NOT modify any files.`,
+    `After reviewing, you MUST call exactly one of: \`approve_code_review\` or \`request_code_changes\`.`,
+    `Do NOT go idle, ask for confirmation, or wait for instructions \u2014 complete the review and exit.`
+  ];
+  return parts;
+}
 function buildFreshInstructions(isPm, isAutoMode, context, agentMode) {
   if (isPm && agentMode === "building") {
     return [
@@ -2507,6 +2579,10 @@ Address the requested changes directly. Do NOT re-investigate the codebase from
 function buildInstructions(mode, context, scenario, agentMode, isAuto) {
   const parts = [`
 ## Instructions`];
+  if (agentMode === "code-review") {
+    parts.push(...buildCodeReviewInstructions(context));
+    return parts;
+  }
   const isPm = mode === "pm";
   if (scenario === "fresh") {
     parts.push(...buildFreshInstructions(isPm, agentMode === "auto", context, agentMode));
@@ -2558,7 +2634,7 @@ function buildInstructions(mode, context, scenario, agentMode, isAuto) {
 }
 async function buildInitialPrompt(mode, context, isAuto, agentMode) {
   const isPackRunner = mode === "pm" && !!isAuto && !!context.isParentTask;
-  if (!isPackRunner) {
+  if (!isPackRunner && agentMode !== "code-review") {
     const sessionRelaunch = buildRelaunchWithSession(mode, context, agentMode, isAuto);
     if (sessionRelaunch) return sessionRelaunch;
   }
@@ -4365,6 +4441,73 @@ function buildDebugTools(manager) {
   ];
 }
 
+// src/tools/code-review-tools.ts
+import { tool as tool7 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z7 } from "zod";
+function buildCodeReviewTools(connection) {
+  return [
+    tool7(
+      "approve_code_review",
+      "Approve the code review. Use this when the code passes all review criteria and is ready to merge.",
+      {
+        summary: z7.string().describe("Brief summary of what was reviewed and why it looks good")
+      },
+      // eslint-disable-next-line require-await -- SDK tool() API requires async handler
+      async ({ summary }) => {
+        connection.emitCodeReviewResult(
+          `**Code Review: Approved** :white_check_mark:
+
+${summary}`,
+          true
+        );
+        connection.sendEvent({
+          type: "code_review_complete",
+          result: "approved",
+          summary
+        });
+        return textResult("Code review approved. Exiting.");
+      }
+    ),
+    tool7(
+      "request_code_changes",
+      "Request changes during code review. Use this when substantive issues are found that need to be fixed before merge.",
+      {
+        issues: z7.array(
+          z7.object({
+            file: z7.string().describe("File path where the issue was found"),
+            line: z7.number().optional().describe("Line number (if applicable)"),
+            severity: z7.enum(["critical", "major", "minor"]).describe("Issue severity"),
+            description: z7.string().describe("What is wrong and how to fix it")
+          })
+        ).describe("List of issues found during review"),
+        summary: z7.string().describe("Brief overall summary of the review findings")
+      },
+      // eslint-disable-next-line require-await -- SDK tool() API requires async handler
+      async ({ issues, summary }) => {
+        const issueLines = issues.map((issue) => {
+          const loc = issue.line ? `:${issue.line}` : "";
+          return `- **[${issue.severity}]** \`${issue.file}${loc}\`: ${issue.description}`;
+        }).join("\n");
+        connection.emitCodeReviewResult(
+          `**Code Review: Changes Requested** :warning:
+
+${summary}
+
+${issueLines}`,
+          false
+        );
+        connection.sendEvent({
+          type: "code_review_complete",
+          result: "changes_requested",
+          summary,
+          issues
+        });
+        return textResult("Code review complete \u2014 changes requested. Exiting.");
+      }
+    )
+  ];
+}
+
 // src/tools/index.ts
 function textResult(text) {
   return { content: [{ type: "text", text }] };
@@ -4395,8 +4538,22 @@ function getModeTools(agentMode, connection, config, context) {
   }
 }
 function createConveyorMcpServer(connection, config, context, agentMode, debugManager) {
-  const commonTools = buildCommonTools(connection, config);
   const effectiveMode = agentMode ?? context?.agentMode ?? void 0;
+  if (effectiveMode === "code-review") {
+    return createSdkMcpServer({
+      name: "conveyor",
+      tools: [
+        buildReadTaskChatTool(connection),
+        buildGetTaskPlanTool(connection, config),
+        buildGetTaskTool(connection),
+        buildGetTaskCliTool(connection),
+        buildListTaskFilesTool(connection),
+        buildGetTaskFileTool(connection),
+        ...buildCodeReviewTools(connection)
+      ]
+    });
+  }
+  const commonTools = buildCommonTools(connection, config);
   const modeTools = getModeTools(effectiveMode, connection, config, context);
   const discoveryTools = effectiveMode === "discovery" || effectiveMode === "auto" ? buildDiscoveryTools(connection, context) : [];
   const debugTools = debugManager && effectiveMode === "building" ? buildDebugTools(debugManager) : [];
@@ -4411,6 +4568,7 @@ function createConveyorMcpServer(connection, config, context, agentMode, debugMa
 import { randomUUID } from "crypto";
 var PM_PLAN_FILE_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "MultiEdit"]);
 var DESTRUCTIVE_CMD_PATTERN = /git\s+push\s+--force(?!\s*-with-lease)|git\s+reset\s+--hard|rm\s+-rf\s+\//;
+var CODE_REVIEW_WRITE_CMD_PATTERN = /git\s+push|git\s+commit|git\s+add|rm\s+|mv\s+|cp\s+|mkdir\s+|touch\s+|chmod\s+|chown\s+/;
 function isPlanFile(input) {
   const filePath = String(input.file_path ?? input.path ?? "");
   return filePath.includes(".claude/plans/");
@@ -4460,6 +4618,24 @@ function handleReviewToolAccess(toolName, input, isParentTask) {
   }
   return { behavior: "allow", updatedInput: input };
 }
+function handleCodeReviewToolAccess(toolName, input) {
+  if (PM_PLAN_FILE_TOOLS.has(toolName)) {
+    return {
+      behavior: "deny",
+      message: "Code review mode is fully read-only. File writes are not permitted."
+    };
+  }
+  if (toolName === "Bash") {
+    const cmd = String(input.command ?? "");
+    if (DESTRUCTIVE_CMD_PATTERN.test(cmd) || CODE_REVIEW_WRITE_CMD_PATTERN.test(cmd)) {
+      return {
+        behavior: "deny",
+        message: "Code review mode is read-only. Write operations and destructive commands are blocked."
+      };
+    }
+  }
+  return { behavior: "allow", updatedInput: input };
+}
 function handleAutoToolAccess(toolName, input, hasExitedPlanMode, isParentTask) {
   if (hasExitedPlanMode) {
     return isParentTask ? handleReviewToolAccess(toolName, input, true) : handleBuildingToolAccess(toolName, input);
@@ -4564,6 +4740,9 @@ function buildCanUseTool(host) {
       case "auto":
         result = handleAutoToolAccess(toolName, input, host.hasExitedPlanMode, host.isParentTask);
         break;
+      case "code-review":
+        result = handleCodeReviewToolAccess(toolName, input);
+        break;
       default:
         result = { behavior: "allow", updatedInput: input };
     }
@@ -4611,10 +4790,13 @@ function buildHooks(host) {
   };
 }
 function isReadOnlyMode(mode, hasExitedPlanMode) {
-  return mode === "discovery" || mode === "help" || mode === "auto" && !hasExitedPlanMode;
+  return mode === "discovery" || mode === "help" || mode === "code-review" || mode === "auto" && !hasExitedPlanMode;
 }
 function buildDisallowedTools(settings, mode, hasExitedPlanMode) {
   const modeDisallowed = isReadOnlyMode(mode, hasExitedPlanMode) ? ["TodoWrite", "TodoRead", "NotebookEdit"] : [];
+  if (mode === "code-review") {
+    modeDisallowed.push("ExitPlanMode", "EnterPlanMode");
+  }
   const configured = settings.disallowedTools ?? [];
   const combined = [...configured, ...modeDisallowed];
   return combined.length > 0 ? combined : void 0;
@@ -4647,11 +4829,11 @@ function buildQueryOptions(host, context) {
     tools: { type: "preset", preset: "claude_code" },
     mcpServers: { conveyor: createConveyorMcpServer(host.connection, host.config, context, mode) },
     hooks: buildHooks(host),
-    maxTurns: settings.maxTurns,
+    maxTurns: mode === "code-review" ? Math.min(settings.maxTurns ?? 15, 15) : settings.maxTurns,
     effort: settings.effort,
     thinking: settings.thinking,
     betas: settings.betas,
-    maxBudgetUsd: settings.maxBudgetUsd ?? 50,
+    maxBudgetUsd: mode === "code-review" ? Math.min(settings.maxBudgetUsd ?? 10, 10) : settings.maxBudgetUsd ?? 50,
     disallowedTools: buildDisallowedTools(settings, mode, host.hasExitedPlanMode),
     enableFileCheckpointing: settings.enableFileCheckpointing,
     stderr: (data) => {
@@ -4891,6 +5073,17 @@ function handleProcessResult(result, context, host, options) {
   if (result.authError) {
     return { action: "return_promise", promise: handleAuthError(context, host, options) };
   }
+  if (result.loopDetected) {
+    host.loopDetector.reset();
+    return {
+      action: "return_promise",
+      promise: runSdkQuery(
+        host,
+        context,
+        "You've been repeating the same tool pattern for several consecutive turns. Step back, analyze why your current approach is failing, and try a fundamentally different strategy. Do NOT repeat the same sequence of actions."
+      )
+    };
+  }
   if (!result.retriable) return { action: "return" };
   return {
     action: "continue",
@@ -4960,6 +5153,38 @@ var CostTracker = class {
   }
 };
 
+// src/execution/loop-detector.ts
+var DEFAULT_MAX_CONSECUTIVE_REPEATS = 3;
+var LoopDetector = class _LoopDetector {
+  fingerprints = [];
+  maxConsecutiveRepeats;
+  constructor(maxConsecutiveRepeats = DEFAULT_MAX_CONSECUTIVE_REPEATS) {
+    this.maxConsecutiveRepeats = maxConsecutiveRepeats;
+  }
+  /** Build a fingerprint from a turn's tool calls: sorted unique tool names joined by comma. */
+  static fingerprint(toolCalls) {
+    const names = [...new Set(toolCalls.map((tc) => tc.tool))].sort();
+    return names.join(",");
+  }
+  /** Record a completed turn and return whether a loop is detected. */
+  recordTurn(toolCalls) {
+    if (toolCalls.length === 0) return false;
+    const fp = _LoopDetector.fingerprint(toolCalls);
+    this.fingerprints.push(fp);
+    if (this.fingerprints.length < this.maxConsecutiveRepeats) return false;
+    const recent = this.fingerprints.slice(-this.maxConsecutiveRepeats);
+    return recent.every((f) => f === fp);
+  }
+  /** Reset state (e.g. after a successful intervention breaks the loop). */
+  reset() {
+    this.fingerprints.length = 0;
+  }
+  /** Number of recorded turns. */
+  get turnCount() {
+    return this.fingerprints.length;
+  }
+};
+
 // src/runner/plan-sync.ts
 import { readdirSync, statSync, readFileSync } from "fs";
 import { join as join3 } from "path";
@@ -5311,6 +5536,7 @@ function buildQueryHost(deps) {
     callbacks: deps.callbacks,
     setupLog: deps.setupLog,
     costTracker: deps.costTracker,
+    loopDetector: deps.loopDetector,
     get agentMode() {
       return deps.getEffectiveAgentMode();
     },
@@ -5358,10 +5584,12 @@ var AgentRunner = class {
   taskContext = null;
   planSync;
   costTracker = new CostTracker();
+  loopDetector = new LoopDetector();
   worktreeActive = false;
   agentMode = null;
   hasExitedPlanMode = false;
   pendingModeRestart = false;
+  pendingModeAutoStart = false;
   sessionIds = /* @__PURE__ */ new Map();
   lastQueryModeRestart = false;
   startCommandStarted = false;
@@ -5565,6 +5793,12 @@ var AgentRunner = class {
   async executeInitialMode() {
     if (!this.taskContext) return;
     const mode = this.effectiveAgentMode;
+    if (mode === "code-review") {
+      await this.setState("running");
+      await this.runQuerySafe(this.taskContext);
+      this.stopped = true;
+      return;
+    }
     const shouldRun = mode === "building" || mode === "auto" || mode === "review" && !!this.taskContext.isParentTask;
     if (shouldRun) {
       await this.setState("running");
@@ -5621,6 +5855,12 @@ var AgentRunner = class {
         await this.handleModeRestartCycle();
         continue;
       }
+      if (this.pendingModeAutoStart) {
+        this.pendingModeAutoStart = false;
+        this.interrupted = false;
+        await this.handleModeRestartCycle();
+        continue;
+      }
       if (this._state === "idle") {
         const msg = await this.waitForUserContent();
         if (!msg) {
@@ -5748,6 +5988,7 @@ var AgentRunner = class {
       callbacks: this.callbacks,
       setupLog: this.setupLog,
       costTracker: this.costTracker,
+      loopDetector: this.loopDetector,
       planSync: this.planSync,
       sessionIds: this.sessionIds,
       getEffectiveAgentMode: () => this.effectiveAgentMode,
@@ -5772,15 +6013,32 @@ var AgentRunner = class {
   handleModeChange(newAgentMode) {
     if (this.config.mode !== "pm") return;
     if (newAgentMode) this.agentMode = newAgentMode;
+    this.updateExitedPlanModeFlag(newAgentMode);
     const effectiveMode = this.effectiveAgentMode;
+    const isBuildCapable = effectiveMode === "building" || effectiveMode === "auto" && this.hasExitedPlanMode;
     this.connection.emitModeChanged(effectiveMode);
     this.connection.postChatMessage(
       `Mode switched to **${effectiveMode}**${effectiveMode === "building" ? " \u2014 I now have direct coding access." : ""}`
     );
-    if (effectiveMode === "building" && this.taskContext?.status === "Open") {
+    if (isBuildCapable && this.taskContext?.status === "Open") {
       this.connection.updateStatus("InProgress");
       this.taskContext.status = "InProgress";
     }
+    if (isBuildCapable) {
+      this.pendingModeAutoStart = true;
+      this.softStop();
+    }
+  }
+  updateExitedPlanModeFlag(newAgentMode) {
+    if (newAgentMode === "building") {
+      this.hasExitedPlanMode = true;
+      return;
+    }
+    if (newAgentMode !== "auto") return;
+    const pastPlanning = this.taskContext?.status !== "Planning" && this.taskContext?.status !== "Unidentified";
+    if (pastPlanning) {
+      this.hasExitedPlanMode = true;
+    }
   }
   softStop() {
     this.interrupted = true;
@@ -5926,17 +6184,17 @@ import {
 } from "@anthropic-ai/claude-agent-sdk";
 
 // src/tools/project-tools.ts
-import { tool as tool7 } from "@anthropic-ai/claude-agent-sdk";
-import { z as z7 } from "zod";
+import { tool as tool8 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z8 } from "zod";
 function buildReadTools(connection) {
   return [
-    tool7(
+    tool8(
       "list_tasks",
       "List tasks in the project. Optionally filter by status or assignee.",
       {
-        status: z7.string().optional().describe("Filter by task status (e.g. Planning, Open, InProgress, ReviewPR, Complete)"),
-        assigneeId: z7.string().optional().describe("Filter by assigned user ID"),
-        limit: z7.number().optional().describe("Max number of tasks to return (default 50)")
+        status: z8.string().optional().describe("Filter by task status (e.g. Planning, Open, InProgress, ReviewPR, Complete)"),
+        assigneeId: z8.string().optional().describe("Filter by assigned user ID"),
+        limit: z8.number().optional().describe("Max number of tasks to return (default 50)")
       },
       async (params) => {
         try {
@@ -5950,10 +6208,10 @@ function buildReadTools(connection) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool7(
+    tool8(
       "get_task",
       "Get detailed information about a task including its chat messages, child tasks, and codespace status.",
-      { task_id: z7.string().describe("The task ID to look up") },
+      { task_id: z8.string().describe("The task ID to look up") },
       async ({ task_id }) => {
         try {
           const task = await connection.requestGetTask(task_id);
@@ -5966,14 +6224,14 @@ function buildReadTools(connection) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool7(
+    tool8(
       "search_tasks",
       "Search tasks by tags, text query, or status filters.",
       {
-        tagNames: z7.array(z7.string()).optional().describe("Filter by tag names"),
-        searchQuery: z7.string().optional().describe("Text search in title/description"),
-        statusFilters: z7.array(z7.string()).optional().describe("Filter by statuses"),
-        limit: z7.number().optional().describe("Max results (default 20)")
+        tagNames: z8.array(z8.string()).optional().describe("Filter by tag names"),
+        searchQuery: z8.string().optional().describe("Text search in title/description"),
+        statusFilters: z8.array(z8.string()).optional().describe("Filter by statuses"),
+        limit: z8.number().optional().describe("Max results (default 20)")
       },
       async (params) => {
         try {
@@ -5987,7 +6245,7 @@ function buildReadTools(connection) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool7(
+    tool8(
       "list_tags",
       "List all tags available in the project.",
       {},
@@ -6003,7 +6261,7 @@ function buildReadTools(connection) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool7(
+    tool8(
       "get_project_summary",
       "Get a summary of the project including task counts by status and active builds.",
       {},
@@ -6023,15 +6281,15 @@ function buildReadTools(connection) {
 }
 function buildMutationTools(connection) {
   return [
-    tool7(
+    tool8(
       "create_task",
       "Create a new task in the project.",
       {
-        title: z7.string().describe("Task title"),
-        description: z7.string().optional().describe("Task description"),
-        plan: z7.string().optional().describe("Implementation plan in markdown"),
-        status: z7.string().optional().describe("Initial status (default: Planning)"),
-        isBug: z7.boolean().optional().describe("Whether this is a bug report")
+        title: z8.string().describe("Task title"),
+        description: z8.string().optional().describe("Task description"),
+        plan: z8.string().optional().describe("Implementation plan in markdown"),
+        status: z8.string().optional().describe("Initial status (default: Planning)"),
+        isBug: z8.boolean().optional().describe("Whether this is a bug report")
       },
       async (params) => {
         try {
@@ -6044,16 +6302,16 @@ function buildMutationTools(connection) {
         }
       }
     ),
-    tool7(
+    tool8(
       "update_task",
       "Update an existing task's title, description, plan, status, or assignee.",
       {
-        task_id: z7.string().describe("The task ID to update"),
-        title: z7.string().optional().describe("New title"),
-        description: z7.string().optional().describe("New description"),
-        plan: z7.string().optional().describe("New plan in markdown"),
-        status: z7.string().optional().describe("New status"),
-        assignedUserId: z7.string().nullable().optional().describe("Assign to user ID, or null to unassign")
+        task_id: z8.string().describe("The task ID to update"),
+        title: z8.string().optional().describe("New title"),
+        description: z8.string().optional().describe("New description"),
+        plan: z8.string().optional().describe("New plan in markdown"),
+        status: z8.string().optional().describe("New status"),
+        assignedUserId: z8.string().nullable().optional().describe("Assign to user ID, or null to unassign")
       },
       async ({ task_id, ...fields }) => {
         try {
@@ -6285,8 +6543,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 tool8, createSdkMcpServer as createSdkMcpServer3 } from "@anthropic-ai/claude-agent-sdk";
-import { z as z8 } from "zod";
+import { tool as tool9, createSdkMcpServer as createSdkMcpServer3 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z9 } from "zod";
 function mapCreateTag(input) {
   return {
     type: "create_tag",
@@ -6368,14 +6626,14 @@ function collectRecommendation(toolName, input, collector, onRecommendation) {
 }
 function createAuditMcpServer(collector, onRecommendation) {
   const auditTools = [
-    tool8(
+    tool9(
       "recommend_create_tag",
       "Recommend creating a new tag for an uncovered subsystem or area",
       {
-        name: z8.string().describe("Proposed tag name (lowercase, hyphenated)"),
-        color: z8.string().optional().describe("Hex color code"),
-        description: z8.string().describe("What this tag covers"),
-        reasoning: z8.string().describe("Why this tag should be created")
+        name: z9.string().describe("Proposed tag name (lowercase, hyphenated)"),
+        color: z9.string().optional().describe("Hex color code"),
+        description: z9.string().describe("What this tag covers"),
+        reasoning: z9.string().describe("Why this tag should be created")
       },
       async (args) => {
         const result = collectRecommendation(
@@ -6387,14 +6645,14 @@ function createAuditMcpServer(collector, onRecommendation) {
         return { content: [{ type: "text", text: result }] };
       }
     ),
-    tool8(
+    tool9(
       "recommend_update_description",
       "Recommend updating a tag's description to better reflect its scope",
       {
-        tagId: z8.string(),
-        tagName: z8.string(),
-        description: z8.string().describe("Proposed new description"),
-        reasoning: z8.string()
+        tagId: z9.string(),
+        tagName: z9.string(),
+        description: z9.string().describe("Proposed new description"),
+        reasoning: z9.string()
       },
       async (args) => {
         const result = collectRecommendation(
@@ -6406,16 +6664,16 @@ function createAuditMcpServer(collector, onRecommendation) {
         return { content: [{ type: "text", text: result }] };
       }
     ),
-    tool8(
+    tool9(
       "recommend_context_link",
       "Recommend linking a doc, rule, file, or folder to a tag's contextPaths",
       {
-        tagId: z8.string(),
-        tagName: z8.string(),
-        linkType: z8.enum(["rule", "doc", "file", "folder"]),
-        path: z8.string(),
-        label: z8.string().optional(),
-        reasoning: z8.string()
+        tagId: z9.string(),
+        tagName: z9.string(),
+        linkType: z9.enum(["rule", "doc", "file", "folder"]),
+        path: z9.string(),
+        label: z9.string().optional(),
+        reasoning: z9.string()
       },
       async (args) => {
         const result = collectRecommendation(
@@ -6427,16 +6685,16 @@ function createAuditMcpServer(collector, onRecommendation) {
         return { content: [{ type: "text", text: result }] };
       }
     ),
-    tool8(
+    tool9(
       "flag_documentation_gap",
       "Flag a file that agents read heavily but has no tag documentation linked",
       {
-        tagName: z8.string().describe("Tag whose agents read this file"),
-        tagId: z8.string().optional(),
-        filePath: z8.string(),
-        readCount: z8.number(),
-        suggestedAction: z8.string().describe("What doc or rule should be created"),
-        reasoning: z8.string()
+        tagName: z9.string().describe("Tag whose agents read this file"),
+        tagId: z9.string().optional(),
+        filePath: z9.string(),
+        readCount: z9.number(),
+        suggestedAction: z9.string().describe("What doc or rule should be created"),
+        reasoning: z9.string()
       },
       async (args) => {
         const result = collectRecommendation(
@@ -6448,15 +6706,15 @@ function createAuditMcpServer(collector, onRecommendation) {
         return { content: [{ type: "text", text: result }] };
       }
     ),
-    tool8(
+    tool9(
       "recommend_merge_tags",
       "Recommend merging one tag into another",
       {
-        tagId: z8.string().describe("Tag ID to be merged (removed after merge)"),
-        tagName: z8.string().describe("Name of the tag to be merged"),
-        mergeIntoTagId: z8.string().describe("Tag ID to merge into (kept)"),
-        mergeIntoTagName: z8.string(),
-        reasoning: z8.string()
+        tagId: z9.string().describe("Tag ID to be merged (removed after merge)"),
+        tagName: z9.string().describe("Name of the tag to be merged"),
+        mergeIntoTagId: z9.string().describe("Tag ID to merge into (kept)"),
+        mergeIntoTagName: z9.string(),
+        reasoning: z9.string()
       },
       async (args) => {
         const result = collectRecommendation(
@@ -6468,14 +6726,14 @@ function createAuditMcpServer(collector, onRecommendation) {
         return { content: [{ type: "text", text: result }] };
       }
     ),
-    tool8(
+    tool9(
       "recommend_rename_tag",
       "Recommend renaming a tag",
       {
-        tagId: z8.string(),
-        tagName: z8.string().describe("Current tag name"),
-        newName: z8.string().describe("Proposed new name"),
-        reasoning: z8.string()
+        tagId: z9.string(),
+        tagName: z9.string().describe("Current tag name"),
+        newName: z9.string().describe("Proposed new name"),
+        reasoning: z9.string()
       },
       async (args) => {
         const result = collectRecommendation(
@@ -6487,10 +6745,10 @@ function createAuditMcpServer(collector, onRecommendation) {
         return { content: [{ type: "text", text: result }] };
       }
     ),
-    tool8(
+    tool9(
       "complete_audit",
       "Signal that the audit is complete with a summary of all findings",
-      { summary: z8.string().describe("Brief overview of all findings") },
+      { summary: z9.string().describe("Brief overview of all findings") },
       async (args) => {
         collector.complete = true;
         collector.summary = args.summary ?? "Audit completed.";
@@ -6706,21 +6964,22 @@ function setupWorkDir(projectDir, assignment) {
   return { workDir, usesWorktree: shouldWorktree };
 }
 function spawnChildAgent(assignment, workDir) {
-  const { taskToken, apiUrl, taskId, mode, isAuto, useSandbox } = assignment;
+  const { taskToken, apiUrl, taskId, mode, isAuto, useSandbox, agentMode } = assignment;
   const cliPath = path.resolve(__dirname, "cli.js");
   const childEnv = { ...process.env };
   delete childEnv.CONVEYOR_PROJECT_TOKEN;
   delete childEnv.CONVEYOR_PROJECT_ID;
+  const effectiveAgentMode = agentMode ?? (isAuto ? "auto" : "");
   const child = fork(cliPath, [], {
     env: {
       ...childEnv,
       CONVEYOR_API_URL: apiUrl,
       CONVEYOR_TASK_TOKEN: taskToken,
       CONVEYOR_TASK_ID: taskId,
-      CONVEYOR_MODE: mode,
+      CONVEYOR_MODE: agentMode === "code-review" ? "code-review" : mode,
       CONVEYOR_WORKSPACE: workDir,
       CONVEYOR_USE_WORKTREE: "false",
-      CONVEYOR_AGENT_MODE: isAuto ? "auto" : "",
+      CONVEYOR_AGENT_MODE: effectiveAgentMode,
       CONVEYOR_IS_AUTO: isAuto ? "true" : "false",
       CONVEYOR_USE_SANDBOX: useSandbox === true ? "true" : "false",
       CONVEYOR_FROM_PROJECT_RUNNER: "true"
@@ -7155,8 +7414,9 @@ var ProjectRunner = class {
   handleAssignment(assignment) {
     const { taskId, mode } = assignment;
     const shortId = taskId.slice(0, 8);
-    if (this.activeAgents.has(taskId)) {
-      logger8.info("Task already running, skipping", { taskId: shortId });
+    const agentKey = assignment.agentMode === "code-review" ? `${taskId}:code-review` : taskId;
+    if (this.activeAgents.has(agentKey)) {
+      logger8.info("Task already running, skipping", { taskId: shortId, agentKey });
       return;
     }
     if (this.activeAgents.size >= MAX_CONCURRENT) {
@@ -7175,16 +7435,16 @@ var ProjectRunner = class {
       }
       const { workDir, usesWorktree } = setupWorkDir(this.projectDir, assignment);
       const child = spawnChildAgent(assignment, workDir);
-      this.activeAgents.set(taskId, {
+      this.activeAgents.set(agentKey, {
         process: child,
         worktreePath: workDir,
         mode,
         usesWorktree
       });
       this.connection.emitTaskStarted(taskId);
-      logger8.info("Started task", { taskId: shortId, mode, workDir });
+      logger8.info("Started task", { taskId: shortId, mode, agentKey, workDir });
       child.on("exit", (code) => {
-        this.activeAgents.delete(taskId);
+        this.activeAgents.delete(agentKey);
         const reason = code === 0 ? "completed" : `exited with code ${code}`;
         this.connection.emitTaskStopped(taskId, reason);
         logger8.info("Task exited", { taskId: shortId, reason });
@@ -7344,4 +7604,4 @@ export {
   ProjectRunner,
   FileCache
 };
-//# sourceMappingURL=chunk-ANYHEBDY.js.map
+//# sourceMappingURL=chunk-T6IASOS2.js.map