@rallycry/conveyor-agent 6.0.3 → 6.0.4

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

@@ -179,6 +179,7 @@ var ConveyorConnection = class _ConveyorConnection {
   constructor(config) {
     this.config = config;
   }
+  // oxlint-disable-next-line max-lines-per-function -- socket setup requires registering many event handlers
   connect() {
     return new Promise((resolve2, reject) => {
       let settled = false;
@@ -474,6 +475,18 @@ var ConveyorConnection = class _ConveyorConnection {
     if (!this.socket) return;
     this.socket.emit("agentRunner:modeTransition", payload);
   }
+  emitDebugStateChanged(state) {
+    if (!this.socket) return;
+    this.socket.emit("agentRunner:debugStateChanged", { state });
+  }
+  emitDebugSessionComplete(summary) {
+    if (!this.socket) return;
+    this.socket.emit("agentRunner:debugSessionComplete", { summary });
+  }
+  emitDebugReproduceRequested(hypothesis) {
+    if (!this.socket) return;
+    this.socket.emit("agentRunner:debugReproduceRequested", { hypothesis });
+  }
   searchIncidents(status, source) {
     return searchIncidents(this.socket, status, source);
   }
@@ -945,7 +958,8 @@ import { request as httpRequest } from "http";
 var logger2 = createServiceLogger("TunnelClient");
 var RECONNECT_BASE_MS = 1e3;
 var RECONNECT_MAX_MS = 3e4;
-var TunnelClient = class {
+var TunnelClient = class _TunnelClient {
+  static STABLE_MS = 3e4;
   apiUrl;
   token;
   localPort;
@@ -953,6 +967,7 @@ var TunnelClient = class {
   stopped = false;
   reconnectAttempts = 0;
   reconnectTimer = null;
+  connectedAt = 0;
   constructor(apiUrl, token, localPort) {
     this.apiUrl = apiUrl;
     this.token = token;
@@ -971,15 +986,16 @@ var TunnelClient = class {
     }
     this.ws.binaryType = "arraybuffer";
     this.ws.addEventListener("open", () => {
-      this.reconnectAttempts = 0;
+      this.connectedAt = Date.now();
       logger2.info("Tunnel connected", { port: this.localPort });
     });
-    this.ws.addEventListener("close", () => {
-      logger2.info("Tunnel disconnected");
+    this.ws.addEventListener("close", (event) => {
+      logger2.info("Tunnel disconnected", { code: event.code, reason: event.reason });
       this.scheduleReconnect();
     });
     this.ws.addEventListener("error", (event) => {
-      logger2.warn("Tunnel error", { error: String(event) });
+      const msg = "message" in event ? event.message : "unknown";
+      logger2.warn("Tunnel error", { error: msg });
     });
     this.ws.addEventListener("message", (event) => {
       this.handleMessage(event.data);
@@ -998,8 +1014,12 @@ var TunnelClient = class {
   }
   scheduleReconnect() {
     if (this.stopped) return;
+    if (Date.now() - this.connectedAt >= _TunnelClient.STABLE_MS) {
+      this.reconnectAttempts = 0;
+    }
     const delay = Math.min(RECONNECT_BASE_MS * 2 ** this.reconnectAttempts, RECONNECT_MAX_MS);
     this.reconnectAttempts++;
+    logger2.info("Tunnel reconnecting", { delay, attempt: this.reconnectAttempts });
     this.reconnectTimer = setTimeout(() => this.connect(), delay);
   }
   // ---------------------------------------------------------------------------
@@ -1866,11 +1886,10 @@ function buildPropertyInstructions(context) {
     ``,
     `### Proactive Property Management`,
     `As you plan this task, proactively fill in task properties when you have enough context:`,
-    `- Once you understand the scope, use set_story_points to assign a value`,
-    `- Use set_task_tags to categorize the work`,
-    `- For icons: FIRST call list_icons to check for existing matches. Use set_task_icon if one fits.`,
+    `- Use update_task_properties to set any combination of: title, story points, tags, and icon`,
+    `- You can update all properties at once or just one at a time as needed`,
+    `- For icons: FIRST call list_icons to check for existing matches, then use update_task_properties with iconId.`,
     `  Only call generate_task_icon if no existing icon is a good fit.`,
-    `- Use set_task_title if the current title doesn't accurately reflect the plan`,
     ``,
     `Don't wait for the user to ask \u2014 fill these in naturally as the plan takes shape.`,
     `If the user adjusts the plan significantly, update the properties to match.`
@@ -1913,10 +1932,8 @@ function buildDiscoveryPrompt(context) {
     `### Self-Identification Tools`,
     `Use these MCP tools to set your own task properties:`,
     `- \`update_task\` \u2014 save your plan and description`,
-    `- \`set_story_points\` \u2014 assign story points`,
-    `- \`set_task_title\` \u2014 set an accurate title`,
-    `- \`set_task_tags\` \u2014 categorize the work`,
-    `- \`set_task_icon\` / \`generate_task_icon\` \u2014 set a task icon (call \`list_icons\` first)`,
+    `- \`update_task_properties\` \u2014 set title, story points, tags, and icon (any combination)`,
+    `- \`generate_task_icon\` \u2014 generate a new icon if needed (call \`list_icons\` first)`,
     ``,
     `### Self-Update vs Subtasks`,
     `- If the work fits in a single task (1-3 SP), update YOUR OWN plan and properties \u2014 do not create subtasks`,
@@ -1924,7 +1941,7 @@ function buildDiscoveryPrompt(context) {
     ``,
     `### Finishing Planning`,
     `Once your plan is complete and all required properties are set, call the **ExitPlanMode** tool.`,
-    `- Required before ExitPlanMode will succeed: **plan** (via update_task), **story points** (via set_story_points), **title** (via set_task_title)`,
+    `- Required before ExitPlanMode will succeed: **plan** (via update_task), **story points** (via update_task_properties), **title** (via update_task_properties)`,
     `- ExitPlanMode validates these properties and moves the task to Open status`,
     `- It does NOT start building \u2014 the team controls when to switch to Build mode`
   ];
@@ -1940,13 +1957,13 @@ function buildAutoPrompt(context) {
     `### Phase 1: Discovery & Planning (current)`,
     `- You have read-only codebase access (can read files, run git commands, search code)`,
     `- You can write plan files in .claude/plans/ only \u2014 no other file writes`,
-    `- You have MCP tools for task properties: update_task, set_story_points, set_task_tags, set_task_icon, set_task_title`,
+    `- You have MCP tools for task properties: update_task, update_task_properties`,
     ``,
     `### Required before transitioning:`,
     `Before calling ExitPlanMode, you MUST fill in ALL of these:`,
     `1. **Plan** \u2014 Save a clear implementation plan using update_task`,
-    `2. **Story Points** \u2014 Assign via set_story_points`,
-    `3. **Title** \u2014 Set an accurate title via set_task_title (if the current one is vague or "Untitled")`,
+    `2. **Story Points** \u2014 Assign via update_task_properties`,
+    `3. **Title** \u2014 Set an accurate title via update_task_properties (if the current one is vague or "Untitled")`,
     ``,
     `### Transitioning to Building:`,
     `When your plan is complete and all required properties are set, call the **ExitPlanMode** tool.`,
@@ -2102,7 +2119,37 @@ Git safety \u2014 STRICT rules:`,
     `- If \`git push\` fails with "non-fast-forward", run \`git push --force-with-lease origin ${context.githubBranch}\`. This branch is exclusively yours \u2014 force-with-lease is safe.`
   ];
 }
-function buildSystemPrompt(mode, context, config, setupLog, agentMode) {
+function buildDebugModeSection(hypothesisTracker) {
+  const lines = [
+    `
+## Debug Mode`,
+    `You have access to debug tools that let you set breakpoints, inspect live state,`,
+    `and capture client-side behavior. Use these when:`,
+    `- You can't find the bug from code reading alone`,
+    `- The bug is state-dependent or timing-dependent`,
+    `- You need to verify a hypothesis about runtime behavior`,
+    ``,
+    `Debugging workflow:`,
+    `1. Form a hypothesis about the root cause`,
+    `2. Identify 2-5 strategic locations to observe (don't over-instrument)`,
+    `3. Set breakpoints or probes at those locations`,
+    `4. Ask the user to reproduce on the preview link`,
+    `5. Analyze the captured data \u2014 confirm or refute your hypothesis`,
+    `6. If refuted, refine hypothesis and repeat (max 3 iterations)`,
+    `7. Exit debug mode and implement the fix`,
+    ``,
+    `Keep debug sessions focused. You don't need to see everything \u2014`,
+    `just the data that tests your hypothesis.`
+  ];
+  if (hypothesisTracker?.isActive()) {
+    const debugContext = hypothesisTracker.getDebugContext();
+    if (debugContext) {
+      lines.push(``, debugContext);
+    }
+  }
+  return lines.join("\n");
+}
+function buildSystemPrompt(mode, context, config, setupLog, agentMode, options) {
   const isPm = mode === "pm";
   const isPmActive = isPm && agentMode === "building";
   const isPackRunner = isPm && !!config.isAuto && !!context.isParentTask;
@@ -2141,6 +2188,9 @@ Your responses are sent directly to the task chat \u2014 the team sees everythin
       `Use the mcp__conveyor__create_pull_request tool to open PRs \u2014 do NOT use gh CLI or shell commands for PR creation.`
     );
   }
+  if (options?.hasDebugTools) {
+    parts.push(buildDebugModeSection(options.hypothesisTracker));
+  }
   const modePrompt = buildModePrompt(agentMode, context);
   if (modePrompt) {
     parts.push(modePrompt);
@@ -2350,7 +2400,7 @@ CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or g
       `You are operating autonomously. Begin planning immediately.`,
       `1. Explore the codebase to understand the architecture and relevant files`,
       `2. Draft a clear implementation plan and save it with update_task`,
-      `3. Set story points (set_story_points), tags (set_task_tags), and title (set_task_title)`,
+      `3. Set story points, tags, and title (update_task_properties)`,
       `4. When the plan and all required properties are set, call ExitPlanMode to transition to building`,
       `Do NOT wait for team input \u2014 proceed autonomously.`
     ];
@@ -2960,7 +3010,7 @@ function buildIconTools(connection) {
   return [
     tool3(
       "list_icons",
-      "List available icons (default library + user-created). Returns icon IDs, names, and whether they're defaults. Call this FIRST before set_task_icon to check for existing matches.",
+      "List available icons (default library + user-created). Returns icon IDs, names, and whether they're defaults. Call this FIRST before update_task_properties to check for existing matches.",
       {},
       async () => {
         try {
@@ -2974,23 +3024,6 @@ function buildIconTools(connection) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool3(
-      "set_task_icon",
-      "Assign an existing icon to this task by its ID. Use list_icons first to find a matching icon.",
-      {
-        iconId: z3.string().describe("The icon ID to assign")
-      },
-      async ({ iconId }) => {
-        try {
-          await Promise.resolve(connection.updateTaskProperties({ iconId }));
-          return textResult("Icon assigned to task.");
-        } catch (error) {
-          return textResult(
-            `Failed to set icon: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
-        }
-      }
-    ),
     tool3(
       "generate_task_icon",
       "Generate a new SVG icon using AI and assign it to this task. Only use if no existing icon from list_icons is a good fit. Provide a concise visual description.",
@@ -3017,55 +3050,1288 @@ function buildDiscoveryTools(connection, context) {
   const spDescription = buildStoryPointDescription(context?.storyPoints);
   return [
     tool3(
-      "set_story_points",
-      "Set the story point estimate for this task. Use after understanding the scope of the work.",
-      { value: z3.number().describe(spDescription) },
-      async ({ value }) => {
+      "update_task_properties",
+      "Set one or more task properties in a single call. All fields are optional \u2014 only include the fields you want to update.",
+      {
+        title: z3.string().optional().describe("The new task title"),
+        storyPointValue: z3.number().optional().describe(spDescription),
+        tagIds: z3.array(z3.string()).optional().describe("Array of tag IDs to assign"),
+        iconId: z3.string().optional().describe("Icon ID to assign (use list_icons first)")
+      },
+      async ({ title, storyPointValue, tagIds, iconId }) => {
         try {
-          await Promise.resolve(connection.updateTaskProperties({ storyPointValue: value }));
-          return textResult(`Story points set to ${value}`);
+          const updateFields = {};
+          if (title !== void 0) updateFields.title = title;
+          if (storyPointValue !== void 0) updateFields.storyPointValue = storyPointValue;
+          if (tagIds !== void 0) updateFields.tagIds = tagIds;
+          if (iconId !== void 0) updateFields.iconId = iconId;
+          await Promise.resolve(connection.updateTaskProperties(updateFields));
+          const updatedFields = [];
+          if (title !== void 0) updatedFields.push(`title to "${title}"`);
+          if (storyPointValue !== void 0)
+            updatedFields.push(`story points to ${storyPointValue}`);
+          if (tagIds !== void 0) updatedFields.push(`tags (${tagIds.length} tag(s))`);
+          if (iconId !== void 0) updatedFields.push(`icon`);
+          return textResult(`Task properties updated: ${updatedFields.join(", ")}`);
         } catch (error) {
           return textResult(
-            `Failed to set story points: ${error instanceof Error ? error.message : "Unknown error"}`
+            `Failed to update task properties: ${error instanceof Error ? error.message : "Unknown error"}`
           );
         }
       }
     ),
-    tool3(
-      "set_task_tags",
-      "Assign tags to this task from the project's available tags. Use the tag IDs from the project tags list.",
+    ...buildIconTools(connection)
+  ];
+}
+
+// src/tools/debug-tools.ts
+import { tool as tool6 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z6 } from "zod";
+
+// src/tools/telemetry-tools.ts
+import { tool as tool4 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z4 } from "zod";
+
+// src/debug/telemetry-injector.ts
+var BUFFER_SIZE = 200;
+var BODY_MAX_BYTES = 1024;
+var MAX_DEPTH = 3;
+var EXCLUDED_EXTENSIONS = [
+  ".js",
+  ".css",
+  ".ico",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".svg",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".map",
+  ".webp"
+];
+var EXCLUDED_PATHS = ["/_next/", "/__nextjs", "/favicon", "/_healthz", "/healthz", "/health"];
+var EXCLUDED_SOCKET_EVENTS = ["ping", "pong", "connection", "disconnect", "websocket", "upgrade"];
+function scriptPreamble() {
+  return `(function() {
+  if (globalThis.__conveyorTelemetry) {
+    return JSON.stringify({ success: true, alreadyInjected: true, patches: globalThis.__conveyorTelemetry._patches });
+  }
+
+  var BUFFER_SIZE = ${BUFFER_SIZE};
+  var BODY_MAX_BYTES = ${BODY_MAX_BYTES};
+  var MAX_DEPTH = ${MAX_DEPTH};
+  var excludedExtensions = ${JSON.stringify(EXCLUDED_EXTENSIONS)};
+  var excludedPaths = ${JSON.stringify(EXCLUDED_PATHS)};
+  var excludedSocketEvents = ${JSON.stringify(EXCLUDED_SOCKET_EVENTS)};`;
+}
+function scriptHelpers() {
+  return `
+  function truncate(str, max) {
+    if (typeof str !== 'string') return '';
+    if (str.length <= max) return str;
+    return str.slice(0, max) + '...[truncated]';
+  }
+
+  function safeStringify(obj, depth) {
+    if (depth === undefined) depth = MAX_DEPTH;
+    try {
+      if (obj === null || obj === undefined) return String(obj);
+      if (typeof obj === 'string') return obj;
+      if (typeof obj !== 'object') return String(obj);
+      if (depth <= 0) return '[Object]';
+      var seen = new Set();
+      return JSON.stringify(obj, function(key, value) {
+        if (typeof value === 'object' && value !== null) {
+          if (seen.has(value)) return '[Circular]';
+          seen.add(value);
+        }
+        return value;
+      }, 0).slice(0, BODY_MAX_BYTES);
+    } catch (e) {
+      return '[unserializable]';
+    }
+  }
+
+  function isExcludedUrl(url) {
+    if (!url) return false;
+    var lower = url.toLowerCase();
+    for (var i = 0; i < excludedExtensions.length; i++) {
+      if (lower.endsWith(excludedExtensions[i])) return true;
+    }
+    for (var j = 0; j < excludedPaths.length; j++) {
+      if (lower.indexOf(excludedPaths[j]) !== -1) return true;
+    }
+    return false;
+  }
+
+  function isExcludedSocketEvent(event) {
+    return excludedSocketEvents.indexOf(event) !== -1;
+  }
+
+  function nowMs() { return Date.now(); }`;
+}
+function scriptBuffer() {
+  return `
+  var buffer = [];
+
+  function pushEvent(event) {
+    buffer.push(event);
+    if (buffer.length > BUFFER_SIZE) { buffer.shift(); }
+  }
+
+  function getEvents(filter, limit) {
+    var result = buffer;
+    if (filter) {
+      if (filter.type) {
+        result = result.filter(function(e) { return e.type === filter.type; });
+      }
+      if (filter.urlPattern) {
+        var re;
+        try { re = new RegExp(filter.urlPattern, 'i'); } catch(e) { re = null; }
+        if (re) {
+          result = result.filter(function(e) { return e.type === 'http' && re.test(e.url); });
+        }
+      }
+      if (filter.minDuration) {
+        var minD = filter.minDuration;
+        result = result.filter(function(e) { return ('duration' in e) && e.duration >= minD; });
+      }
+      if (filter.errorOnly) {
+        result = result.filter(function(e) {
+          return e.type === 'error' || (e.type === 'http' && e.status >= 400);
+        });
+      }
+      if (filter.since) {
+        var since = filter.since;
+        result = result.filter(function(e) { return e.timestamp >= since; });
+      }
+    }
+    if (limit && limit > 0) { result = result.slice(-limit); }
+    return result;
+  }
+
+  function clear() { buffer = []; }
+
+  var patches = { express: false, prisma: false, socketIo: false, errorHandler: false };`;
+}
+function scriptPatchExpress() {
+  return `
+  function patchExpress() {
+    try {
+      var http = require('http');
+      var originalEmit = http.Server.prototype.emit;
+      http.Server.prototype.emit = function(event) {
+        if (event === 'request') {
+          var req = arguments[1];
+          var res = arguments[2];
+          if (req && res && !isExcludedUrl(req.url)) {
+            var start = nowMs();
+            var reqBody = '';
+            if (req.readable) {
+              var chunks = [];
+              var origPush = req.push;
+              req.push = function(chunk) {
+                if (chunk) { chunks.push(typeof chunk === 'string' ? chunk : chunk.toString()); }
+                return origPush.apply(this, arguments);
+              };
+              var origReqEmit = req.emit;
+              req.emit = function(evt) {
+                if (evt === 'end') { reqBody = truncate(chunks.join(''), BODY_MAX_BYTES); }
+                return origReqEmit.apply(this, arguments);
+              };
+            }
+            var origEnd = res.end;
+            res.end = function(chunk) {
+              var resBody = '';
+              if (chunk) { resBody = truncate(typeof chunk === 'string' ? chunk : chunk.toString(), BODY_MAX_BYTES); }
+              var duration = nowMs() - start;
+              pushEvent({
+                type: 'http', timestamp: start, method: req.method || 'UNKNOWN',
+                url: req.url || '/', status: res.statusCode || 0, duration: duration,
+                requestBody: reqBody || undefined, responseBody: resBody || undefined,
+                error: res.statusCode >= 400 ? ('HTTP ' + res.statusCode) : undefined
+              });
+              return origEnd.apply(this, arguments);
+            };
+          }
+        }
+        return originalEmit.apply(this, arguments);
+      };
+      patches.express = true;
+    } catch (e) {}
+  }`;
+}
+function scriptPatchPrisma() {
+  return `
+  function patchPrisma() {
+    try {
+      var prismaClient = globalThis.prisma || globalThis.__prisma;
+      if (!prismaClient) {
+        var cacheKeys = Object.keys(require.cache || {});
+        for (var i = 0; i < cacheKeys.length; i++) {
+          var mod = require.cache[cacheKeys[i]];
+          if (mod && mod.exports && typeof mod.exports.$on === 'function') {
+            prismaClient = mod.exports;
+            break;
+          }
+        }
+      }
+      if (prismaClient && typeof prismaClient.$on === 'function') {
+        prismaClient.$on('query', function(e) {
+          pushEvent({
+            type: 'db', timestamp: nowMs(),
+            query: truncate(e.query || '', BODY_MAX_BYTES),
+            params: truncate(safeStringify(e.params), BODY_MAX_BYTES),
+            duration: e.duration || 0
+          });
+        });
+        patches.prisma = true;
+      }
+    } catch (e) {}
+  }`;
+}
+function scriptPatchSocketIo() {
+  return `
+  function patchSocketIo() {
+    try {
+      var io = globalThis.io || globalThis.__io;
+      if (io && io.sockets) {
+        var origOn = io.sockets.constructor.prototype.on;
+        if (origOn) {
+          io.sockets.constructor.prototype.on = function(event, handler) {
+            if (!isExcludedSocketEvent(event)) {
+              var wrappedHandler = function() {
+                var args = Array.prototype.slice.call(arguments);
+                pushEvent({
+                  type: 'socket', timestamp: nowMs(), event: event, direction: 'in',
+                  data: truncate(safeStringify(args[0]), BODY_MAX_BYTES),
+                  namespace: (this.nsp && this.nsp.name) || '/'
+                });
+                return handler.apply(this, arguments);
+              };
+              return origOn.call(this, event, wrappedHandler);
+            }
+            return origOn.call(this, event, handler);
+          };
+        }
+        var origEmit = io.sockets.constructor.prototype.emit;
+        if (origEmit) {
+          io.sockets.constructor.prototype.emit = function(event) {
+            if (!isExcludedSocketEvent(event)) {
+              var args = Array.prototype.slice.call(arguments, 1);
+              pushEvent({
+                type: 'socket', timestamp: nowMs(), event: event, direction: 'out',
+                data: truncate(safeStringify(args[0]), BODY_MAX_BYTES),
+                namespace: (this.nsp && this.nsp.name) || '/'
+              });
+            }
+            return origEmit.apply(this, arguments);
+          };
+        }
+        patches.socketIo = true;
+      }
+    } catch (e) {}
+  }`;
+}
+function scriptPatchErrors() {
+  return `
+  function patchErrorHandler() {
+    try {
+      process.on('uncaughtException', function(err) {
+        pushEvent({
+          type: 'error', timestamp: nowMs(),
+          message: err.message || String(err),
+          stack: truncate(err.stack || '', BODY_MAX_BYTES),
+          context: 'uncaughtException'
+        });
+      });
+      process.on('unhandledRejection', function(reason) {
+        var msg = (reason && reason.message) ? reason.message : String(reason);
+        var stack = (reason && reason.stack) ? reason.stack : '';
+        pushEvent({
+          type: 'error', timestamp: nowMs(), message: msg,
+          stack: truncate(stack, BODY_MAX_BYTES), context: 'unhandledRejection'
+        });
+      });
+      patches.errorHandler = true;
+    } catch (e) {}
+  }`;
+}
+function scriptInit() {
+  return `
+  patchExpress();
+  patchPrisma();
+  patchSocketIo();
+  patchErrorHandler();
+
+  globalThis.__conveyorTelemetry = {
+    getEvents: getEvents,
+    clear: clear,
+    getStatus: function() {
+      return { active: true, eventCount: buffer.length, patches: patches };
+    },
+    _patches: patches,
+    _buffer: buffer
+  };
+
+  return JSON.stringify({ success: true, alreadyInjected: false, patches: patches });
+})();`;
+}
+function generateTelemetryScript() {
+  return [
+    scriptPreamble(),
+    scriptHelpers(),
+    scriptBuffer(),
+    scriptPatchExpress(),
+    scriptPatchPrisma(),
+    scriptPatchSocketIo(),
+    scriptPatchErrors(),
+    scriptInit()
+  ].join("\n");
+}
+async function injectTelemetry(cdpClient) {
+  try {
+    const script = generateTelemetryScript();
+    const result = await cdpClient.evaluate(script);
+    if (result.type === "error") {
+      return { success: false, error: result.value };
+    }
+    try {
+      const parsed = JSON.parse(result.value);
+      return {
+        success: parsed.success === true,
+        patches: parsed.patches
+      };
+    } catch {
+      return { success: true };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown injection error"
+    };
+  }
+}
+async function queryTelemetry(cdpClient, filter, limit) {
+  const filterJson = JSON.stringify(filter ?? {});
+  const limitVal = limit ?? 20;
+  const result = await cdpClient.evaluate(
+    `JSON.stringify(globalThis.__conveyorTelemetry ? globalThis.__conveyorTelemetry.getEvents(${filterJson}, ${limitVal}) : [])`
+  );
+  if (result.type === "error") {
+    throw new Error(`Telemetry query failed: ${result.value}`);
+  }
+  try {
+    let val = result.value;
+    if (val.startsWith('"') && val.endsWith('"')) {
+      val = JSON.parse(val);
+    }
+    return JSON.parse(val);
+  } catch {
+    return [];
+  }
+}
+async function clearTelemetry(cdpClient) {
+  await cdpClient.evaluate(
+    `globalThis.__conveyorTelemetry ? (globalThis.__conveyorTelemetry.clear(), 'cleared') : 'not active'`
+  );
+}
+async function getTelemetryStatus(cdpClient) {
+  const result = await cdpClient.evaluate(
+    `JSON.stringify(globalThis.__conveyorTelemetry ? globalThis.__conveyorTelemetry.getStatus() : { active: false, eventCount: 0, patches: { express: false, prisma: false, socketIo: false, errorHandler: false } })`
+  );
+  if (result.type === "error") {
+    return {
+      active: false,
+      eventCount: 0,
+      patches: { express: false, prisma: false, socketIo: false, errorHandler: false }
+    };
+  }
+  try {
+    let val = result.value;
+    if (val.startsWith('"') && val.endsWith('"')) {
+      val = JSON.parse(val);
+    }
+    return JSON.parse(val);
+  } catch {
+    return {
+      active: false,
+      eventCount: 0,
+      patches: { express: false, prisma: false, socketIo: false, errorHandler: false }
+    };
+  }
+}
+
+// src/tools/telemetry-tools.ts
+function requireDebugClient(manager) {
+  if (!manager.isDebugMode()) {
+    return "Debug mode is not active. Use debug_enter_mode first.";
+  }
+  const client = manager.getClient();
+  if (!client?.isConnected()) {
+    return "CDP client is not connected. Try exiting and re-entering debug mode.";
+  }
+  return client;
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : "Unknown error";
+}
+function buildGetTelemetryTool(manager) {
+  return tool4(
+    "debug_get_telemetry",
+    "Query structured telemetry events (HTTP requests, database queries, Socket.IO events, errors) captured from the running dev server. Returns filtered, structured data instead of raw logs.",
+    {
+      type: z4.enum(["http", "db", "socket", "error"]).optional().describe("Filter by event type"),
+      urlPattern: z4.string().optional().describe("Regex pattern to filter HTTP events by URL"),
+      minDuration: z4.number().optional().describe("Minimum duration in ms \u2014 only return events slower than this"),
+      errorOnly: z4.boolean().optional().describe("Only return error events and HTTP 4xx/5xx responses"),
+      since: z4.number().optional().describe("Only return events after this timestamp (ms since epoch)"),
+      limit: z4.number().optional().describe("Max events to return (default: 20, from most recent)")
+    },
+    async ({ type, urlPattern, minDuration, errorOnly, since, limit }) => {
+      const clientOrErr = requireDebugClient(manager);
+      if (typeof clientOrErr === "string") return textResult(clientOrErr);
+      try {
+        const filter = {
+          ...type && { type },
+          ...urlPattern && { urlPattern },
+          ...minDuration && { minDuration },
+          ...errorOnly && { errorOnly },
+          ...since && { since }
+        };
+        const hasFilter = Object.keys(filter).length > 0;
+        const events = await queryTelemetry(clientOrErr, hasFilter ? filter : void 0, limit);
+        if (events.length === 0) {
+          return textResult("No telemetry events found matching the filter.");
+        }
+        return textResult(JSON.stringify(events, null, 2));
+      } catch (error) {
+        return textResult(`Failed to query telemetry: ${formatError(error)}`);
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildClearTelemetryTool(manager) {
+  return tool4(
+    "debug_clear_telemetry",
+    "Clear all captured telemetry events from the buffer. Useful to reset before reproducing a specific issue.",
+    {},
+    async () => {
+      const clientOrErr = requireDebugClient(manager);
+      if (typeof clientOrErr === "string") return textResult(clientOrErr);
+      try {
+        await clearTelemetry(clientOrErr);
+        return textResult("Telemetry buffer cleared.");
+      } catch (error) {
+        return textResult(`Failed to clear telemetry: ${formatError(error)}`);
+      }
+    }
+  );
+}
+function buildTelemetryStatusTool(manager) {
+  return tool4(
+    "debug_telemetry_status",
+    "Check if telemetry is active, how many events have been captured, and which framework patches (Express, Prisma, Socket.IO) were successfully applied.",
+    {},
+    async () => {
+      const clientOrErr = requireDebugClient(manager);
+      if (typeof clientOrErr === "string") return textResult(clientOrErr);
+      try {
+        const status = await getTelemetryStatus(clientOrErr);
+        return textResult(JSON.stringify(status, null, 2));
+      } catch (error) {
+        return textResult(`Failed to get telemetry status: ${formatError(error)}`);
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildTelemetryTools(manager) {
+  return [
+    buildGetTelemetryTool(manager),
+    buildClearTelemetryTool(manager),
+    buildTelemetryStatusTool(manager)
+  ];
+}
+
+// src/tools/client-debug-tools.ts
+import { tool as tool5 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z5 } from "zod";
+function requirePlaywrightClient(manager) {
+  if (!manager.isClientDebugMode()) {
+    return "Client debug mode is not active. Use debug_enter_mode with clientSide: true first.";
+  }
+  const client = manager.getPlaywrightClient();
+  if (!client?.isConnected()) {
+    return "Playwright client is not connected. Try exiting and re-entering debug mode.";
+  }
+  return client;
+}
+function formatError2(error) {
+  return error instanceof Error ? error.message : "Unknown error";
+}
+function buildClientBreakpointTools(manager) {
+  return [
+    tool5(
+      "debug_set_client_breakpoint",
+      "Set a breakpoint in client-side code running in the headless Chromium browser. V8 resolves source maps automatically, so original .tsx/.ts file paths work. Use this for React components, client utilities, and browser-side code.",
+      {
+        file: z5.string().describe(
+          "Original source file path (e.g., src/components/App.tsx) \u2014 source maps resolve automatically"
+        ),
+        line: z5.number().describe("Line number (1-based) in the original source file"),
+        condition: z5.string().optional().describe("JavaScript condition expression \u2014 breakpoint only triggers when truthy")
+      },
+      async ({ file, line, condition }) => {
+        const clientOrErr = requirePlaywrightClient(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          const breakpointId = await clientOrErr.setBreakpoint(file, line, condition);
+          const condStr = condition ? ` (condition: ${condition})` : "";
+          const sourceMapNote = clientOrErr.hasSourceMaps() === false ? "\n\u26A0\uFE0F Source maps not detected \u2014 breakpoints will reference bundled code." : "";
+          return textResult(
+            `Client breakpoint set: ${file}:${line}${condStr}
+Breakpoint ID: ${breakpointId}${sourceMapNote}`
+          );
+        } catch (error) {
+          return textResult(`Failed to set client breakpoint: ${formatError2(error)}`);
+        }
+      }
+    ),
+    tool5(
+      "debug_remove_client_breakpoint",
+      "Remove a previously set client-side breakpoint by its ID.",
+      {
+        breakpointId: z5.string().describe("The breakpoint ID returned by debug_set_client_breakpoint")
+      },
+      async ({ breakpointId }) => {
+        const clientOrErr = requirePlaywrightClient(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          await clientOrErr.removeBreakpoint(breakpointId);
+          return textResult(`Client breakpoint ${breakpointId} removed.`);
+        } catch (error) {
+          return textResult(`Failed to remove client breakpoint: ${formatError2(error)}`);
+        }
+      }
+    ),
+    tool5(
+      "debug_list_client_breakpoints",
+      "List all active client-side breakpoints with their file, line, and condition.",
+      {},
+      // oxlint-disable-next-line require-await
+      async () => {
+        const clientOrErr = requirePlaywrightClient(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        const breakpoints = clientOrErr.listBreakpoints();
+        if (breakpoints.length === 0) {
+          return textResult("No client breakpoints set.");
+        }
+        return textResult(JSON.stringify(breakpoints, null, 2));
+      },
+      { annotations: { readOnlyHint: true } }
+    )
+  ];
+}
+function buildClientInspectionTools(manager) {
+  return [
+    tool5(
+      "debug_inspect_client_paused",
+      "When the client-side debugger is paused at a breakpoint, returns the call stack and local variables. Includes React component state, props, and hooks when paused inside a component.",
+      {},
+      async () => {
+        const clientOrErr = requirePlaywrightClient(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        const queuedHits = manager.drainClientBreakpointHitQueue();
+        if (!clientOrErr.isPaused()) {
+          if (queuedHits.length > 0) {
+            return textResult(
+              `Client debugger was paused but has since resumed. Recent breakpoint hits:
+${JSON.stringify(queuedHits, null, 2)}`
+            );
+          }
+          return textResult(
+            "Client debugger is not currently paused. Set client breakpoints and trigger the code path in the browser to pause execution."
+          );
+        }
+        try {
+          const callStack = clientOrErr.getCallStack();
+          const topFrame = callStack[0];
+          let variables = [];
+          if (topFrame) {
+            try {
+              variables = await clientOrErr.getScopeVariables(topFrame.callFrameId);
+            } catch {
+            }
+          }
+          const result = {
+            side: "client",
+            reason: clientOrErr.getPausedState()?.reason,
+            hitBreakpoints: clientOrErr.getPausedState()?.hitBreakpoints,
+            callStack,
+            localVariables: variables
+          };
+          return textResult(JSON.stringify(result, null, 2));
+        } catch (error) {
+          return textResult(`Failed to inspect client paused state: ${formatError2(error)}`);
+        }
+      },
+      { annotations: { readOnlyHint: true } }
+    ),
+    tool5(
+      "debug_evaluate_client",
+      "Evaluate a JavaScript expression in the client-side browser context. When paused at a client breakpoint, evaluates in the paused scope. Can access DOM, window, React internals, etc.",
       {
-        tagIds: z3.array(z3.string()).describe("Array of tag IDs to assign")
+        expression: z5.string().describe("JavaScript expression to evaluate in the browser context"),
+        frameIndex: z5.number().optional().describe("Call stack frame index (0 = top frame). Defaults to the top frame.")
       },
-      async ({ tagIds }) => {
+      async ({ expression, frameIndex }) => {
+        const clientOrErr = requirePlaywrightClient(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          let callFrameId;
+          if (clientOrErr.isPaused()) {
+            const callStack = clientOrErr.getCallStack();
+            const frame = callStack[frameIndex ?? 0];
+            callFrameId = frame?.callFrameId;
+          }
+          const result = await clientOrErr.evaluate(expression, callFrameId);
+          return textResult(`(${result.type}) ${result.value}`);
+        } catch (error) {
+          return textResult(`Client evaluation failed: ${formatError2(error)}`);
+        }
+      }
+    )
+  ];
+}
+function buildClientExecutionTools(manager) {
+  return [
+    tool5(
+      "debug_continue_client",
+      "Resume client-side execution after the browser debugger has paused at a breakpoint.",
+      {},
+      async () => {
+        const clientOrErr = requirePlaywrightClient(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        if (!clientOrErr.isPaused()) {
+          return textResult("Client debugger is not paused.");
+        }
         try {
-          await Promise.resolve(connection.updateTaskProperties({ tagIds }));
-          return textResult(`Tags assigned: ${tagIds.length} tag(s)`);
+          await clientOrErr.resume();
+          return textResult("Client execution resumed.");
         } catch (error) {
+          return textResult(`Failed to resume client: ${formatError2(error)}`);
+        }
+      }
+    )
+  ];
+}
+function buildClientInteractionTools(manager) {
+  return [
+    tool5(
+      "debug_client_screenshot",
+      "Take a screenshot of the current page state in the headless browser. Returns the image as base64-encoded PNG.",
+      {},
+      async () => {
+        const clientOrErr = requirePlaywrightClient(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          const base64 = await clientOrErr.screenshot();
+          return {
+            content: [
+              imageBlock(base64, "image/png"),
+              {
+                type: "text",
+                text: `Screenshot captured (${clientOrErr.getCurrentUrl()})`
+              }
+            ]
+          };
+        } catch (error) {
+          return textResult(`Failed to capture screenshot: ${formatError2(error)}`);
+        }
+      },
+      { annotations: { readOnlyHint: true } }
+    ),
+    tool5(
+      "debug_navigate_client",
+      "Navigate the headless browser to a specific URL. Use this to reproduce specific flows or visit different pages.",
+      {
+        url: z5.string().describe("URL to navigate to (e.g., http://localhost:3000/dashboard)")
+      },
+      async ({ url }) => {
+        const clientOrErr = requirePlaywrightClient(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          await clientOrErr.navigate(url);
+          return textResult(`Navigated to: ${clientOrErr.getCurrentUrl()}`);
+        } catch (error) {
+          return textResult(`Failed to navigate: ${formatError2(error)}`);
+        }
+      }
+    ),
+    tool5(
+      "debug_click_client",
+      "Click an element on the page in the headless browser. Use CSS selectors to target elements. Useful for reproducing bugs by interacting with the UI programmatically.",
+      {
+        selector: z5.string().describe(
+          "CSS selector of the element to click (e.g., 'button.submit', '#login-form input[type=submit]')"
+        )
+      },
+      async ({ selector }) => {
+        const clientOrErr = requirePlaywrightClient(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          await clientOrErr.click(selector);
+          return textResult(`Clicked: ${selector}`);
+        } catch (error) {
+          return textResult(`Failed to click "${selector}": ${formatError2(error)}`);
+        }
+      }
+    )
+  ];
+}
+function buildClientConsoleTool(manager) {
+  return tool5(
+    "debug_get_client_console",
+    "Get console messages captured from the headless browser. Includes console.log, warn, error, etc.",
+    {
+      level: z5.string().optional().describe("Filter by console level: log, warn, error, info, debug"),
+      limit: z5.number().optional().describe("Maximum number of recent messages to return (default: all)")
+    },
+    // oxlint-disable-next-line require-await
+    async ({ level, limit }) => {
+      const clientOrErr = requirePlaywrightClient(manager);
+      if (typeof clientOrErr === "string") return textResult(clientOrErr);
+      const messages = clientOrErr.getConsoleMessages(level, limit);
+      if (messages.length === 0) {
+        const filterDesc = level ? ` (level: ${level})` : "";
+        return textResult(`No console messages captured${filterDesc}.`);
+      }
+      const formatted = messages.map((m) => {
+        const time = new Date(m.timestamp).toLocaleTimeString("en-US", { hour12: false });
+        const loc = m.url ? ` [${m.url}${m.line ? `:${m.line}` : ""}]` : "";
+        return `[${time}] ${m.level.toUpperCase()}: ${m.text}${loc}`;
+      }).join("\n");
+      return textResult(`${messages.length} console message(s):
+${formatted}`);
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildClientNetworkTool(manager) {
+  return tool5(
+    "debug_get_client_network",
+    "Get network requests captured from the headless browser. Shows URLs, methods, status codes, and timing.",
+    {
+      filter: z5.string().optional().describe("Regex pattern to filter requests by URL"),
+      limit: z5.number().optional().describe("Maximum number of recent requests to return (default: all)")
+    },
+    // oxlint-disable-next-line require-await
+    async ({ filter, limit }) => {
+      const clientOrErr = requirePlaywrightClient(manager);
+      if (typeof clientOrErr === "string") return textResult(clientOrErr);
+      const requests = clientOrErr.getNetworkRequests(filter, limit);
+      if (requests.length === 0) {
+        const filterDesc = filter ? ` matching "${filter}"` : "";
+        return textResult(`No network requests captured${filterDesc}.`);
+      }
+      const formatted = requests.map((r) => {
+        const time = new Date(r.timestamp).toLocaleTimeString("en-US", { hour12: false });
+        const status = r.status ? ` \u2192 ${r.status}` : " \u2192 (pending)";
+        const dur = r.duration ? ` (${r.duration}ms)` : "";
+        return `[${time}] ${r.method} ${r.url}${status}${dur}`;
+      }).join("\n");
+      return textResult(`${requests.length} network request(s):
+${formatted}`);
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildClientErrorsTool(manager) {
+  return tool5(
+    "debug_get_client_errors",
+    "Get uncaught errors captured from the headless browser. Includes error messages and source-mapped stack traces.",
+    {
+      limit: z5.number().optional().describe("Maximum number of recent errors to return (default: all)")
+    },
+    // oxlint-disable-next-line require-await
+    async ({ limit }) => {
+      const clientOrErr = requirePlaywrightClient(manager);
+      if (typeof clientOrErr === "string") return textResult(clientOrErr);
+      const errors = clientOrErr.getPageErrors(limit);
+      if (errors.length === 0) {
+        return textResult("No uncaught page errors captured.");
+      }
+      const formatted = errors.map((e) => {
+        const time = new Date(e.timestamp).toLocaleTimeString("en-US", { hour12: false });
+        const stack = e.stack ? `
+  ${e.stack.split("\n").slice(0, 5).join("\n  ")}` : "";
+        return `[${time}] ${e.message}${stack}`;
+      }).join("\n\n");
+      return textResult(`${errors.length} page error(s):
+${formatted}`);
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildClientCaptureTools(manager) {
+  return [
+    buildClientConsoleTool(manager),
+    buildClientNetworkTool(manager),
+    buildClientErrorsTool(manager)
+  ];
+}
+function buildClientDebugTools(manager) {
+  return [
+    ...buildClientBreakpointTools(manager),
+    ...buildClientInspectionTools(manager),
+    ...buildClientExecutionTools(manager),
+    ...buildClientInteractionTools(manager),
+    ...buildClientCaptureTools(manager)
+  ];
+}
+
+// src/tools/debug-tools.ts
+function requireDebugClient2(manager) {
+  if (!manager.isDebugMode()) {
+    return "Debug mode is not active. Use debug_enter_mode first.";
+  }
+  const client = manager.getClient();
+  if (!client?.isConnected()) {
+    return "CDP client is not connected. Try exiting and re-entering debug mode.";
+  }
+  return client;
+}
+function formatError3(error) {
+  return error instanceof Error ? error.message : "Unknown error";
+}
+async function handleEnterDebugMode(manager, {
+  hypothesis,
+  serverSide,
+  clientSide,
+  previewUrl
+}) {
+  const wantServer = serverSide ?? !clientSide;
+  const wantClient = clientSide ?? false;
+  const alreadyMsg = checkAlreadyActive(manager, wantServer, wantClient);
+  if (alreadyMsg) return textResult(alreadyMsg);
+  await manager.enterDebugMode(void 0, {
+    serverSide: wantServer && !manager.isDebugMode(),
+    clientSide: wantClient && !manager.isClientDebugMode(),
+    previewUrl
+  });
+  return textResult(buildActivationMessage(manager, hypothesis));
+}
+function checkAlreadyActive(manager, wantServer, wantClient) {
+  if (wantServer && manager.isDebugMode() && !wantClient) return "Already in server debug mode.";
+  if (wantClient && manager.isClientDebugMode() && !wantServer)
+    return "Already in client debug mode.";
+  if (wantServer && manager.isDebugMode() && wantClient && manager.isClientDebugMode()) {
+    return "Already in both server and client debug mode.";
+  }
+  return null;
+}
+function buildActivationMessage(manager, hypothesis) {
+  const modes = [];
+  if (manager.isDebugMode()) modes.push("server");
+  if (manager.isClientDebugMode()) modes.push("client");
+  const modeStr = modes.join(" + ");
+  const sourceMapWarning = manager.getPlaywrightClient()?.hasSourceMaps() === false ? "\n\u26A0\uFE0F Source maps not detected in the client \u2014 client breakpoints will reference bundled code." : "";
+  return hypothesis ? `Debug mode activated (${modeStr}). Hypothesis: ${hypothesis}
+Set breakpoints to test your hypothesis.${sourceMapWarning}` : `Debug mode activated (${modeStr}). Set breakpoints to begin debugging.${sourceMapWarning}`;
+}
+function buildDebugLifecycleTools(manager) {
+  return [
+    tool6(
+      "debug_enter_mode",
+      "Activate debug mode: restarts the dev server with Node.js --inspect flag and connects the CDP debugger. Optionally launch a headless Chromium browser for client-side debugging. Use serverSide for backend breakpoints, clientSide for frontend breakpoints, or both for full-stack.",
+      {
+        hypothesis: z6.string().optional().describe("Your hypothesis about the bug \u2014 helps track debugging intent"),
+        serverSide: z6.boolean().optional().describe(
+          "Enable server-side Node.js debugging (default: true if clientSide is not set)"
+        ),
+        clientSide: z6.boolean().optional().describe("Enable client-side browser debugging via headless Chromium + Playwright"),
+        previewUrl: z6.string().optional().describe(
+          "Preview URL for client-side debugging (e.g., http://localhost:3000). Required when clientSide is true."
+        )
+      },
+      async (params) => {
+        try {
+          return await handleEnterDebugMode(manager, params);
+        } catch (error) {
+          return textResult(`Failed to enter debug mode: ${formatError3(error)}`);
+        }
+      }
+    ),
+    tool6(
+      "debug_exit_mode",
+      "Exit debug mode: removes all breakpoints, disconnects the debugger, and restarts the dev server normally.",
+      {},
+      async () => {
+        try {
+          if (!manager.isDebugMode()) {
+            return textResult("Not in debug mode.");
+          }
+          await manager.exitDebugMode();
+          return textResult("Debug mode deactivated. Dev server restarted normally.");
+        } catch (error) {
+          return textResult(`Failed to exit debug mode: ${formatError3(error)}`);
+        }
+      }
+    )
+  ];
+}
+function buildBreakpointTools(manager) {
+  return [
+    tool6(
+      "debug_set_breakpoint",
+      "Set a breakpoint at the specified file and line number. Optionally provide a condition expression that must evaluate to true for the breakpoint to pause execution.",
+      {
+        file: z6.string().describe("Absolute or relative file path to set the breakpoint in"),
+        line: z6.number().describe("Line number (1-based) to set the breakpoint on"),
+        condition: z6.string().optional().describe("JavaScript condition expression \u2014 breakpoint only triggers when truthy")
+      },
+      async ({ file, line, condition }) => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          const client = clientOrErr;
+          const breakpointId = await client.setBreakpoint(file, line, condition);
+          const condStr = condition ? ` (condition: ${condition})` : "";
           return textResult(
-            `Failed to set tags: ${error instanceof Error ? error.message : "Unknown error"}`
+            `Breakpoint set: ${file}:${line}${condStr}
+Breakpoint ID: ${breakpointId}`
           );
+        } catch (error) {
+          return textResult(`Failed to set breakpoint: ${formatError3(error)}`);
         }
       }
     ),
-    tool3(
-      "set_task_title",
-      "Update the task title to better reflect the planned work.",
+    tool6(
+      "debug_remove_breakpoint",
+      "Remove a previously set breakpoint by its ID.",
+      {
+        breakpointId: z6.string().describe("The breakpoint ID returned by debug_set_breakpoint")
+      },
+      async ({ breakpointId }) => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          const client = clientOrErr;
+          await client.removeBreakpoint(breakpointId);
+          return textResult(`Breakpoint ${breakpointId} removed.`);
+        } catch (error) {
+          return textResult(`Failed to remove breakpoint: ${formatError3(error)}`);
+        }
+      }
+    ),
+    tool6(
+      "debug_list_breakpoints",
+      "List all currently active breakpoints with their file, line, and condition.",
+      {},
+      // oxlint-disable-next-line require-await
+      async () => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        const breakpoints = clientOrErr.listBreakpoints();
+        if (breakpoints.length === 0) {
+          return textResult("No breakpoints set.");
+        }
+        return textResult(JSON.stringify(breakpoints, null, 2));
+      },
+      { annotations: { readOnlyHint: true } }
+    )
+  ];
+}
+function buildInspectionTools(manager) {
+  return [
+    tool6(
+      "debug_inspect_paused",
+      "When the debugger is paused at a breakpoint, returns the call stack and local variables. Check this after a breakpoint is hit to understand the current execution state.",
+      {},
+      async () => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        const client = clientOrErr;
+        const queuedHits = manager.drainBreakpointHitQueue();
+        if (!client.isPaused()) {
+          if (queuedHits.length > 0) {
+            return textResult(
+              `Debugger was paused but has since resumed. Recent breakpoint hits:
+${JSON.stringify(queuedHits, null, 2)}`
+            );
+          }
+          return textResult(
+            "Debugger is not currently paused. Set breakpoints and trigger the code path to pause execution."
+          );
+        }
+        try {
+          const callStack = client.getCallStack();
+          const topFrame = callStack[0];
+          let variables = [];
+          if (topFrame) {
+            try {
+              variables = await client.getScopeVariables(topFrame.callFrameId);
+            } catch {
+            }
+          }
+          const result = {
+            reason: client.getPausedState()?.reason,
+            hitBreakpoints: client.getPausedState()?.hitBreakpoints,
+            callStack,
+            localVariables: variables
+          };
+          return textResult(JSON.stringify(result, null, 2));
+        } catch (error) {
+          return textResult(`Failed to inspect paused state: ${formatError3(error)}`);
+        }
+      },
+      { annotations: { readOnlyHint: true } }
+    ),
+    tool6(
+      "debug_evaluate",
+      "Evaluate a JavaScript expression in the current paused scope (or globally if not paused). When paused, use frameIndex to evaluate in a specific call frame.",
       {
-        title: z3.string().describe("The new task title")
+        expression: z6.string().describe("The JavaScript expression to evaluate"),
+        frameIndex: z6.number().optional().describe("Call stack frame index (0 = top frame). Defaults to the top frame.")
       },
-      async ({ title }) => {
+      async ({ expression, frameIndex }) => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
         try {
-          await Promise.resolve(connection.updateTaskProperties({ title }));
-          return textResult(`Task title updated to: ${title}`);
+          const client = clientOrErr;
+          let callFrameId;
+          if (client.isPaused()) {
+            const callStack = client.getCallStack();
+            const frame = callStack[frameIndex ?? 0];
+            callFrameId = frame?.callFrameId;
+          }
+          const result = await client.evaluate(expression, callFrameId);
+          return textResult(`(${result.type}) ${result.value}`);
         } catch (error) {
+          return textResult(`Evaluation failed: ${formatError3(error)}`);
+        }
+      }
+    )
+  ];
+}
+function buildProbeManagementTools(manager) {
+  return [
+    tool6(
+      "debug_add_probe",
+      "Add a debug probe at a specific code location. Captures expression values each time the line executes \u2014 without pausing or modifying source files. Like console.log but better: structured, no diff pollution, auto-cleaned on debug exit.",
+      {
+        file: z6.string().describe("File path to probe"),
+        line: z6.number().describe("Line number (1-based) to probe"),
+        expressions: z6.array(z6.string()).describe(
+          'JavaScript expressions to capture when the line executes (e.g., ["req.params.id", "user.role"])'
+        ),
+        label: z6.string().optional().describe("Optional label for this probe (defaults to file:line)")
+      },
+      async ({ file, line, expressions, label }) => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          const probeId = await clientOrErr.setLogpoint(file, line, expressions, label);
+          const probeLabel = label ?? `${file}:${line}`;
+          const exprList = expressions.join(", ");
           return textResult(
-            `Failed to update title: ${error instanceof Error ? error.message : "Unknown error"}`
+            `Probe "${probeLabel}" set at ${file}:${line}
+Capturing: ${exprList}
+Probe ID: ${probeId}
+
+Trigger the code path, then use debug_get_probe_results to see captured values.`
           );
+        } catch (error) {
+          return textResult(`Failed to add probe: ${formatError3(error)}`);
         }
       }
     ),
-    ...buildIconTools(connection)
+    tool6(
+      "debug_remove_probe",
+      "Remove a previously set debug probe by its ID.",
+      {
+        probeId: z6.string().describe("The probe ID returned by debug_add_probe")
+      },
+      async ({ probeId }) => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          await clientOrErr.removeProbe(probeId);
+          return textResult(`Probe ${probeId} removed.`);
+        } catch (error) {
+          return textResult(`Failed to remove probe: ${formatError3(error)}`);
+        }
+      }
+    ),
+    tool6(
+      "debug_list_probes",
+      "List all active debug probes with their file, line, expressions, and labels.",
+      {},
+      // oxlint-disable-next-line require-await
+      async () => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        const probes = clientOrErr.listProbes();
+        if (probes.length === 0) {
+          return textResult("No probes set.");
+        }
+        const lines = probes.map(
+          (p) => `${p.probeId}: "${p.label}" at ${p.file}:${p.line} \u2014 [${p.expressions.join(", ")}]`
+        );
+        return textResult(lines.join("\n"));
+      },
+      { annotations: { readOnlyHint: true } }
+    )
+  ];
+}
+function buildProbeResultTools(manager) {
+  return [
+    tool6(
+      "debug_get_probe_results",
+      "Fetch captured probe hit data. Returns expression values from each time a probed line executed.",
+      {
+        probeId: z6.string().optional().describe("Filter results by probe ID (resolves to its label)"),
+        label: z6.string().optional().describe("Filter results by probe label"),
+        limit: z6.number().optional().describe("Maximum number of recent hits to return (default: all)")
+      },
+      async ({ probeId, label, limit }) => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        try {
+          let filterLabel = label;
+          if (probeId && !filterLabel) {
+            const probe = clientOrErr.listProbes().find((p) => p.probeId === probeId);
+            if (probe) filterLabel = probe.label;
+          }
+          const hits = await clientOrErr.getProbeResults(filterLabel, limit);
+          if (hits.length === 0) {
+            const filterDesc = filterLabel ? ` for "${filterLabel}"` : "";
+            return textResult(
+              `No probe hits${filterDesc}. Make sure the probed code path has been triggered.`
+            );
+          }
+          const formatted = formatProbeHits(hits);
+          return textResult(formatted);
+        } catch (error) {
+          return textResult(`Failed to get probe results: ${formatError3(error)}`);
+        }
+      },
+      { annotations: { readOnlyHint: true } }
+    )
+  ];
+}
+function formatProbeHits(hits) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const hit of hits) {
+    const group = grouped.get(hit.label) ?? [];
+    group.push(hit);
+    grouped.set(hit.label, group);
+  }
+  const sections = [];
+  for (const [label, labelHits] of grouped) {
+    const header = `Probe "${label}" \u2014 hit ${labelHits.length} time${labelHits.length === 1 ? "" : "s"}:`;
+    const lines = labelHits.map((hit) => {
+      const time = new Date(hit.timestamp).toLocaleTimeString("en-US", { hour12: false });
+      const entries = Object.entries(hit.data).map(([key, val]) => `${key}=${formatProbeValue(val)}`).join(", ");
+      return `  [${time}] ${entries}`;
+    });
+    sections.push([header, ...lines].join("\n"));
+  }
+  return sections.join("\n\n");
+}
+function formatProbeValue(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") {
+    return value.length > 100 ? `"${value.slice(0, 97)}..."` : `"${value}"`;
+  }
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) {
+    return `Array(${value.length})`;
+  }
+  if (typeof value === "object") {
+    const keys = Object.keys(value);
+    if (keys.length <= 3) {
+      const preview = keys.map((k) => `${k}: ${formatProbeValue(value[k])}`).join(", ");
+      return `{${preview}}`;
+    }
+    return `Object(${keys.length} keys)`;
+  }
+  return String(value);
+}
+function buildExecutionControlTools(manager) {
+  return [
+    tool6(
+      "debug_continue",
+      "Resume execution after the debugger has paused at a breakpoint.",
+      {},
+      async () => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        if (!clientOrErr.isPaused()) {
+          return textResult("Debugger is not paused.");
+        }
+        try {
+          await clientOrErr.resume();
+          return textResult("Execution resumed.");
+        } catch (error) {
+          return textResult(`Failed to resume: ${formatError3(error)}`);
+        }
+      }
+    ),
+    tool6(
+      "debug_step_over",
+      "Step over the current line while paused at a breakpoint. Executes the current line and pauses at the next line in the same function.",
+      {},
+      async () => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        if (!clientOrErr.isPaused()) {
+          return textResult("Debugger is not paused.");
+        }
+        try {
+          await clientOrErr.stepOver();
+          return textResult("Stepped over. Use debug_inspect_paused to see current state.");
+        } catch (error) {
+          return textResult(`Failed to step over: ${formatError3(error)}`);
+        }
+      }
+    ),
+    tool6(
+      "debug_step_into",
+      "Step into the function call on the current line while paused at a breakpoint. Pauses at the first line inside the called function.",
+      {},
+      async () => {
+        const clientOrErr = requireDebugClient2(manager);
+        if (typeof clientOrErr === "string") return textResult(clientOrErr);
+        if (!clientOrErr.isPaused()) {
+          return textResult("Debugger is not paused.");
+        }
+        try {
+          await clientOrErr.stepInto();
+          return textResult("Stepped into. Use debug_inspect_paused to see current state.");
+        } catch (error) {
+          return textResult(`Failed to step into: ${formatError3(error)}`);
+        }
+      }
+    )
+  ];
+}
+function buildDebugTools(manager) {
+  return [
+    ...buildDebugLifecycleTools(manager),
+    ...buildBreakpointTools(manager),
+    ...buildProbeManagementTools(manager),
+    ...buildProbeResultTools(manager),
+    ...buildInspectionTools(manager),
+    ...buildExecutionControlTools(manager),
+    ...buildTelemetryTools(manager),
+    ...buildClientDebugTools(manager)
   ];
 }
 
@@ -3098,14 +4364,15 @@ function getModeTools(agentMode, connection, config, context) {
       return config.mode === "pm" ? buildPmTools(connection, context?.storyPoints, { includePackTools: false }) : [];
   }
 }
-function createConveyorMcpServer(connection, config, context, agentMode) {
+function createConveyorMcpServer(connection, config, context, agentMode, debugManager) {
   const commonTools = buildCommonTools(connection, config);
   const effectiveMode = agentMode ?? context?.agentMode ?? void 0;
   const modeTools = getModeTools(effectiveMode, connection, config, context);
   const discoveryTools = effectiveMode === "discovery" || effectiveMode === "auto" ? buildDiscoveryTools(connection, context) : [];
+  const debugTools = debugManager && effectiveMode === "building" ? buildDebugTools(debugManager) : [];
   return createSdkMcpServer({
     name: "conveyor",
-    tools: [...commonTools, ...modeTools, ...discoveryTools]
+    tools: [...commonTools, ...modeTools, ...discoveryTools, ...debugTools]
   });
 }
 
@@ -3183,9 +4450,9 @@ async function handleExitPlanMode(host, input) {
     const taskProps = await host.connection.getTaskProperties();
     const missingProps = [];
     if (!taskProps.plan?.trim()) missingProps.push("plan (save via update_task)");
-    if (!taskProps.storyPointId) missingProps.push("story points (use set_story_points)");
+    if (!taskProps.storyPointId) missingProps.push("story points (use update_task_properties)");
     if (!taskProps.title || taskProps.title === "Untitled")
-      missingProps.push("title (use set_task_title)");
+      missingProps.push("title (use update_task_properties)");
     if (missingProps.length > 0) {
       return {
         behavior: "deny",
@@ -3361,7 +4628,7 @@ function buildQueryOptions(host, context) {
     },
     settingSources,
     cwd: host.config.workspaceDir,
-    permissionMode: needsCanUseTool ? "acceptEdits" : "bypassPermissions",
+    permissionMode: needsCanUseTool ? "plan" : "bypassPermissions",
     allowDangerouslySkipPermissions: !needsCanUseTool,
     canUseTool: buildCanUseTool(host),
     tools: { type: "preset", preset: "claude_code" },
@@ -4645,17 +5912,17 @@ import {
 } 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";
+import { tool as tool7 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z7 } from "zod";
 function buildReadTools(connection) {
   return [
-    tool4(
+    tool7(
       "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)")
+        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)")
       },
       async (params) => {
         try {
@@ -4669,10 +5936,10 @@ function buildReadTools(connection) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool4(
+    tool7(
       "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") },
+      { task_id: z7.string().describe("The task ID to look up") },
       async ({ task_id }) => {
         try {
           const task = await connection.requestGetTask(task_id);
@@ -4685,14 +5952,14 @@ function buildReadTools(connection) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool4(
+    tool7(
       "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)")
+        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)")
       },
       async (params) => {
         try {
@@ -4706,7 +5973,7 @@ function buildReadTools(connection) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool4(
+    tool7(
       "list_tags",
       "List all tags available in the project.",
       {},
@@ -4722,7 +5989,7 @@ function buildReadTools(connection) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool4(
+    tool7(
       "get_project_summary",
       "Get a summary of the project including task counts by status and active builds.",
       {},
@@ -4742,15 +6009,15 @@ function buildReadTools(connection) {
 }
 function buildMutationTools(connection) {
   return [
-    tool4(
+    tool7(
       "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")
+        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")
       },
       async (params) => {
         try {
@@ -4763,16 +6030,16 @@ function buildMutationTools(connection) {
         }
       }
     ),
-    tool4(
+    tool7(
       "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")
+        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")
       },
       async ({ task_id, ...fields }) => {
         try {
@@ -5004,8 +6271,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 tool5, createSdkMcpServer as createSdkMcpServer3 } from "@anthropic-ai/claude-agent-sdk";
-import { z as z5 } from "zod";
+import { tool as tool8, createSdkMcpServer as createSdkMcpServer3 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z8 } from "zod";
 function mapCreateTag(input) {
   return {
     type: "create_tag",
@@ -5087,14 +6354,14 @@ function collectRecommendation(toolName, input, collector, onRecommendation) {
 }
 function createAuditMcpServer(collector, onRecommendation) {
   const auditTools = [
-    tool5(
+    tool8(
       "recommend_create_tag",
       "Recommend creating a new tag for an uncovered subsystem or area",
       {
-        name: z5.string().describe("Proposed tag name (lowercase, hyphenated)"),
-        color: z5.string().optional().describe("Hex color code"),
-        description: z5.string().describe("What this tag covers"),
-        reasoning: z5.string().describe("Why this tag should be created")
+        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")
       },
       async (args) => {
         const result = collectRecommendation(
@@ -5106,14 +6373,14 @@ function createAuditMcpServer(collector, onRecommendation) {
         return { content: [{ type: "text", text: result }] };
       }
     ),
-    tool5(
+    tool8(
       "recommend_update_description",
       "Recommend updating a tag's description to better reflect its scope",
       {
-        tagId: z5.string(),
-        tagName: z5.string(),
-        description: z5.string().describe("Proposed new description"),
-        reasoning: z5.string()
+        tagId: z8.string(),
+        tagName: z8.string(),
+        description: z8.string().describe("Proposed new description"),
+        reasoning: z8.string()
       },
       async (args) => {
         const result = collectRecommendation(
@@ -5125,16 +6392,16 @@ function createAuditMcpServer(collector, onRecommendation) {
         return { content: [{ type: "text", text: result }] };
       }
     ),
-    tool5(
+    tool8(
       "recommend_context_link",
       "Recommend linking a doc, rule, file, or folder to a tag's contextPaths",
       {
-        tagId: z5.string(),
-        tagName: z5.string(),
-        linkType: z5.enum(["rule", "doc", "file", "folder"]),
-        path: z5.string(),
-        label: z5.string().optional(),
-        reasoning: z5.string()
+        tagId: z8.string(),
+        tagName: z8.string(),
+        linkType: z8.enum(["rule", "doc", "file", "folder"]),
+        path: z8.string(),
+        label: z8.string().optional(),
+        reasoning: z8.string()
       },
       async (args) => {
         const result = collectRecommendation(
@@ -5146,16 +6413,16 @@ function createAuditMcpServer(collector, onRecommendation) {
         return { content: [{ type: "text", text: result }] };
       }
     ),
-    tool5(
+    tool8(
       "flag_documentation_gap",
       "Flag a file that agents read heavily but has no tag documentation linked",
       {
-        tagName: z5.string().describe("Tag whose agents read this file"),
-        tagId: z5.string().optional(),
-        filePath: z5.string(),
-        readCount: z5.number(),
-        suggestedAction: z5.string().describe("What doc or rule should be created"),
-        reasoning: z5.string()
+        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()
       },
       async (args) => {
         const result = collectRecommendation(
@@ -5167,15 +6434,15 @@ function createAuditMcpServer(collector, onRecommendation) {
         return { content: [{ type: "text", text: result }] };
       }
     ),
-    tool5(
+    tool8(
       "recommend_merge_tags",
       "Recommend merging one tag into another",
       {
-        tagId: z5.string().describe("Tag ID to be merged (removed after merge)"),
-        tagName: z5.string().describe("Name of the tag to be merged"),
-        mergeIntoTagId: z5.string().describe("Tag ID to merge into (kept)"),
-        mergeIntoTagName: z5.string(),
-        reasoning: z5.string()
+        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()
       },
       async (args) => {
         const result = collectRecommendation(
@@ -5187,14 +6454,14 @@ function createAuditMcpServer(collector, onRecommendation) {
         return { content: [{ type: "text", text: result }] };
       }
     ),
-    tool5(
+    tool8(
       "recommend_rename_tag",
       "Recommend renaming a tag",
       {
-        tagId: z5.string(),
-        tagName: z5.string().describe("Current tag name"),
-        newName: z5.string().describe("Proposed new name"),
-        reasoning: z5.string()
+        tagId: z8.string(),
+        tagName: z8.string().describe("Current tag name"),
+        newName: z8.string().describe("Proposed new name"),
+        reasoning: z8.string()
       },
       async (args) => {
         const result = collectRecommendation(
@@ -5206,10 +6473,10 @@ function createAuditMcpServer(collector, onRecommendation) {
         return { content: [{ type: "text", text: result }] };
       }
     ),
-    tool5(
+    tool8(
       "complete_audit",
       "Signal that the audit is complete with a summary of all findings",
-      { summary: z5.string().describe("Brief overview of all findings") },
+      { summary: z8.string().describe("Brief overview of all findings") },
       async (args) => {
         collector.complete = true;
         collector.summary = args.summary ?? "Audit completed.";
@@ -6055,6 +7322,7 @@ export {
   ProjectConnection,
   createServiceLogger,
   errorMeta,
+  injectTelemetry,
   ensureWorktree,
   removeWorktree,
   loadConveyorConfig,
@@ -6062,4 +7330,4 @@ export {
   ProjectRunner,
   FileCache
 };
-//# sourceMappingURL=chunk-SL5MRNSI.js.map
+//# sourceMappingURL=chunk-NKZSUGND.js.map