@probelabs/probe 0.6.0-rc303 → 0.6.0-rc305

package/cjs/agent/ProbeAgent.cjs

@@ -22274,6 +22274,87 @@ var init_dist3 = __esm({
   }
 });
 
+// src/utils/provider.js
+function createProviderInstance(config2) {
+  switch (config2.provider) {
+    case "anthropic":
+      return (0, import_anthropic.createAnthropic)({
+        apiKey: config2.apiKey,
+        ...config2.baseURL && { baseURL: config2.baseURL }
+      });
+    case "openai":
+      return (0, import_openai.createOpenAI)({
+        compatibility: "strict",
+        apiKey: config2.apiKey,
+        ...config2.baseURL && { baseURL: config2.baseURL }
+      });
+    case "google":
+      return (0, import_google.createGoogleGenerativeAI)({
+        apiKey: config2.apiKey,
+        ...config2.baseURL && { baseURL: config2.baseURL }
+      });
+    case "bedrock": {
+      const bedrockConfig = {};
+      if (config2.apiKey) {
+        bedrockConfig.apiKey = config2.apiKey;
+      } else if (config2.accessKeyId && config2.secretAccessKey) {
+        bedrockConfig.accessKeyId = config2.accessKeyId;
+        bedrockConfig.secretAccessKey = config2.secretAccessKey;
+        if (config2.sessionToken) {
+          bedrockConfig.sessionToken = config2.sessionToken;
+        }
+      }
+      if (config2.region) bedrockConfig.region = config2.region;
+      if (config2.baseURL) bedrockConfig.baseURL = config2.baseURL;
+      return createAmazonBedrock(bedrockConfig);
+    }
+    default:
+      throw new Error(`Unknown provider "${config2.provider}"`);
+  }
+}
+function resolveApiKey(providerName) {
+  switch (providerName) {
+    case "anthropic":
+      return process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN;
+    case "openai":
+      return process.env.OPENAI_API_KEY;
+    case "google":
+      return process.env.GOOGLE_GENERATIVE_AI_API_KEY || process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY;
+    case "bedrock":
+      return process.env.AWS_BEDROCK_API_KEY;
+    default:
+      return void 0;
+  }
+}
+async function createLanguageModel(providerName, modelName) {
+  if (!providerName) return null;
+  const resolvedModel = modelName || DEFAULT_MODELS[providerName];
+  if (!resolvedModel) return null;
+  try {
+    const apiKey = resolveApiKey(providerName);
+    const provider = createProviderInstance({ provider: providerName, ...apiKey ? { apiKey } : {} });
+    return provider(resolvedModel);
+  } catch {
+    return null;
+  }
+}
+var import_anthropic, import_openai, import_google, DEFAULT_MODELS;
+var init_provider = __esm({
+  "src/utils/provider.js"() {
+    "use strict";
+    import_anthropic = require("@ai-sdk/anthropic");
+    import_openai = require("@ai-sdk/openai");
+    import_google = require("@ai-sdk/google");
+    init_dist3();
+    DEFAULT_MODELS = {
+      anthropic: "claude-sonnet-4-6",
+      openai: "gpt-5.2",
+      google: "gemini-2.5-flash",
+      bedrock: "anthropic.claude-sonnet-4-6"
+    };
+  }
+});
+
 // node_modules/gpt-tokenizer/esm/bpeRanks/o200k_base.js
 var c0, c1, bpe, o200k_base_default;
 var init_o200k_base = __esm({
@@ -24014,16 +24095,128 @@ var init_tokenCounter = __esm({
 });
 
 // src/agent/otelLogBridge.js
-var import_module, _require;
+function getOtelApi() {
+  if (otelApiAttempted) return otelApi;
+  otelApiAttempted = true;
+  try {
+    otelApi = (function(name15) {
+      return _require(name15);
+    })("@opentelemetry/api");
+  } catch {
+  }
+  return otelApi;
+}
+function getOtelLogger() {
+  if (otelLoggerAttempted) return otelLogger;
+  otelLoggerAttempted = true;
+  try {
+    const { logs } = (function(name15) {
+      return _require(name15);
+    })("@opentelemetry/api-logs");
+    otelLogger = logs.getLogger("probe-agent");
+  } catch {
+  }
+  return otelLogger;
+}
+function getTraceSuffix() {
+  try {
+    const api2 = getOtelApi();
+    if (!api2) return "";
+    const span = api2.trace.getSpan(api2.context.active());
+    const ctx = span?.spanContext?.();
+    if (!ctx?.traceId) return "";
+    return ` [trace_id=${ctx.traceId} span_id=${ctx.spanId}]`;
+  } catch {
+    return "";
+  }
+}
+function emitOtelLog(msg, level) {
+  try {
+    const logger = getOtelLogger();
+    if (!logger) return;
+    const api2 = getOtelApi();
+    let traceId, spanId;
+    if (api2) {
+      const span = api2.trace.getSpan(api2.context.active());
+      const ctx = span?.spanContext?.();
+      if (ctx?.traceId) {
+        traceId = ctx.traceId;
+        spanId = ctx.spanId;
+      }
+    }
+    logger.emit({
+      severityNumber: OTEL_SEVERITY[level] || 9,
+      severityText: level.toUpperCase(),
+      body: msg,
+      attributes: {
+        "probe.logger": true,
+        ...traceId ? { trace_id: traceId, span_id: spanId } : {}
+      }
+    });
+  } catch {
+  }
+}
+function patchConsole() {
+  if (patched) return;
+  const methods = ["log", "info", "warn", "error"];
+  const c = globalThis.console;
+  for (const m of methods) {
+    const orig = c[m].bind(c);
+    originals[m] = orig;
+    c[m] = (...args) => {
+      const msgParts = args.map(
+        (a) => typeof a === "string" ? a : a instanceof Error ? a.message : JSON.stringify(a)
+      );
+      const msg = msgParts.join(" ");
+      emitOtelLog(msg, m === "log" ? "log" : m);
+      const suffix = getTraceSuffix();
+      if (suffix) {
+        if (typeof args[0] === "string") {
+          args[0] = args[0] + suffix;
+        } else {
+          args.push(suffix);
+        }
+      }
+      return orig(...args);
+    };
+  }
+  patched = true;
+}
+var import_module, _require, OTEL_SEVERITY, patched, originals, otelApi, otelApiAttempted, otelLogger, otelLoggerAttempted;
 var init_otelLogBridge = __esm({
   "src/agent/otelLogBridge.js"() {
     "use strict";
     import_module = require("module");
     _require = (0, import_module.createRequire)("file:///");
+    OTEL_SEVERITY = {
+      log: 9,
+      // INFO
+      info: 9,
+      // INFO
+      warn: 13,
+      // WARN
+      error: 17,
+      // ERROR
+      debug: 5
+      // DEBUG
+    };
+    patched = false;
+    originals = {};
+    otelApi = null;
+    otelApiAttempted = false;
+    otelLogger = null;
+    otelLoggerAttempted = false;
   }
 });
 
 // src/agent/simpleTelemetry.js
+var simpleTelemetry_exports = {};
+__export(simpleTelemetry_exports, {
+  SimpleAppTracer: () => SimpleAppTracer,
+  SimpleTelemetry: () => SimpleTelemetry,
+  initializeSimpleTelemetryFromOptions: () => initializeSimpleTelemetryFromOptions,
+  truncateForSpan: () => truncateForSpan
+});
 function truncateForSpan(text, maxLen = 4096) {
   if (!text || text.length <= maxLen) return text || "";
   const half = Math.floor((maxLen - 40) / 2);
@@ -24032,13 +24225,455 @@ function truncateForSpan(text, maxLen = 4096) {
 ... [${omitted} chars omitted] ...
 ` + text.substring(text.length - half);
 }
-var import_fs, import_path;
+function initializeSimpleTelemetryFromOptions(options) {
+  const telemetry = new SimpleTelemetry({
+    serviceName: "probe-agent",
+    enableFile: options.traceFile !== void 0,
+    enableConsole: options.traceConsole,
+    filePath: options.traceFile || "./traces.jsonl"
+  });
+  patchConsole();
+  return telemetry;
+}
+var import_fs, import_path, SimpleTelemetry, SimpleAppTracer;
 var init_simpleTelemetry = __esm({
   "src/agent/simpleTelemetry.js"() {
     "use strict";
     import_fs = require("fs");
     import_path = require("path");
     init_otelLogBridge();
+    SimpleTelemetry = class {
+      constructor(options = {}) {
+        this.serviceName = options.serviceName || "probe-agent";
+        this.enableFile = options.enableFile || false;
+        this.enableConsole = options.enableConsole || false;
+        this.filePath = options.filePath || "./traces.jsonl";
+        this.stream = null;
+        if (this.enableFile) {
+          this.initializeFileExporter();
+        }
+      }
+      initializeFileExporter() {
+        try {
+          const dir = (0, import_path.dirname)(this.filePath);
+          if (!(0, import_fs.existsSync)(dir)) {
+            (0, import_fs.mkdirSync)(dir, { recursive: true });
+          }
+          this.stream = (0, import_fs.createWriteStream)(this.filePath, { flags: "a" });
+          this.stream.on("error", (error40) => {
+            console.error(`[SimpleTelemetry] Stream error: ${error40.message}`);
+          });
+          console.log(`[SimpleTelemetry] File exporter initialized: ${this.filePath}`);
+        } catch (error40) {
+          console.error(`[SimpleTelemetry] Failed to initialize file exporter: ${error40.message}`);
+        }
+      }
+      createSpan(name15, attributes = {}) {
+        const span = {
+          traceId: this.generateTraceId(),
+          spanId: this.generateSpanId(),
+          name: name15,
+          startTime: Date.now(),
+          attributes: { ...attributes, service: this.serviceName },
+          events: [],
+          status: "OK"
+        };
+        return {
+          ...span,
+          addEvent: (eventName, eventAttributes = {}) => {
+            span.events.push({
+              name: eventName,
+              time: Date.now(),
+              attributes: eventAttributes
+            });
+          },
+          setAttributes: (attrs) => {
+            Object.assign(span.attributes, attrs);
+          },
+          setStatus: (status) => {
+            span.status = status;
+          },
+          end: () => {
+            span.endTime = Date.now();
+            span.duration = span.endTime - span.startTime;
+            this.exportSpan(span);
+          }
+        };
+      }
+      exportSpan(span) {
+        const spanData = {
+          ...span,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        if (this.enableConsole) {
+          console.log("[Trace]", JSON.stringify(spanData, null, 2));
+        }
+        if (this.enableFile && this.stream) {
+          this.stream.write(JSON.stringify(spanData) + "\n");
+        }
+      }
+      generateTraceId() {
+        return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+      }
+      generateSpanId() {
+        return Math.random().toString(36).substring(2, 10);
+      }
+      async flush() {
+        if (this.stream) {
+          return new Promise((resolve9) => {
+            this.stream.once("drain", resolve9);
+            if (!this.stream.writableNeedDrain) {
+              resolve9();
+            }
+          });
+        }
+      }
+      async shutdown() {
+        if (this.stream) {
+          return new Promise((resolve9) => {
+            this.stream.end(() => {
+              console.log(`[SimpleTelemetry] File stream closed: ${this.filePath}`);
+              resolve9();
+            });
+          });
+        }
+      }
+    };
+    SimpleAppTracer = class {
+      constructor(telemetry, sessionId = null) {
+        this.telemetry = telemetry;
+        this.sessionId = sessionId || this.generateSessionId();
+      }
+      generateSessionId() {
+        return Math.random().toString(36).substring(2, 15);
+      }
+      isEnabled() {
+        return this.telemetry !== null;
+      }
+      createSessionSpan(attributes = {}) {
+        if (!this.isEnabled()) return null;
+        return this.telemetry.createSpan("agent.session", {
+          "session.id": this.sessionId,
+          ...attributes
+        });
+      }
+      createAISpan(modelName, provider, attributes = {}) {
+        if (!this.isEnabled()) return null;
+        return this.telemetry.createSpan("ai.request", {
+          "ai.model": modelName,
+          "ai.provider": provider,
+          "session.id": this.sessionId,
+          ...attributes
+        });
+      }
+      createToolSpan(toolName, attributes = {}) {
+        if (!this.isEnabled()) return null;
+        return this.telemetry.createSpan("tool.call", {
+          "tool.name": toolName,
+          "session.id": this.sessionId,
+          ...attributes
+        });
+      }
+      addEvent(name15, attributes = {}) {
+        if (this.telemetry && this.telemetry.enableConsole) {
+          console.log("[Event]", name15, attributes);
+        }
+      }
+      /**
+       * Record a generic event (used by completionPrompt and other features)
+       */
+      // visor-disable: SimpleAppTracer uses this.sessionId because it's a per-session instance. AppTracer extracts from attributes because it's a singleton managing multiple sessions. Different architectures require different approaches.
+      recordEvent(name15, attributes = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(name15, {
+          "session.id": this.sessionId,
+          ...attributes
+        });
+      }
+      /**
+       * Record delegation events
+       */
+      recordDelegationEvent(eventType, data2 = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`delegation.${eventType}`, {
+          "session.id": this.sessionId,
+          ...data2
+        });
+      }
+      /**
+       * Record JSON validation events
+       */
+      recordJsonValidationEvent(eventType, data2 = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`json_validation.${eventType}`, {
+          "session.id": this.sessionId,
+          ...data2
+        });
+      }
+      /**
+       * Record Mermaid validation events
+       */
+      recordMermaidValidationEvent(eventType, data2 = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`mermaid_validation.${eventType}`, {
+          "session.id": this.sessionId,
+          ...data2
+        });
+      }
+      /**
+       * Record task management events
+       */
+      recordTaskEvent(eventType, data2 = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`task.${eventType}`, {
+          "session.id": this.sessionId,
+          ...data2
+        });
+      }
+      /**
+       * Record MCP (Model Context Protocol) events
+       * Tracks server connections, tool discovery, method filtering, and tool execution
+       */
+      recordMcpEvent(eventType, data2 = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`mcp.${eventType}`, {
+          "session.id": this.sessionId,
+          ...data2
+        });
+      }
+      /**
+       * Record bash tool events
+       * Tracks command permission checks, allowed/denied commands, and execution
+       */
+      recordBashEvent(eventType, data2 = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`bash.${eventType}`, {
+          "session.id": this.sessionId,
+          ...data2
+        });
+      }
+      setAttributes(attributes) {
+        if (this.telemetry && this.telemetry.enableConsole) {
+          console.log("[Attributes]", attributes);
+        }
+      }
+      /**
+       * Hash content for deduplication/comparison purposes
+       * @param {string} content - The content to hash
+       * @returns {string} - Hex string hash
+       */
+      hashContent(content) {
+        let hash2 = 0;
+        const len = Math.min(content.length, 1e3);
+        for (let i = 0; i < len; i++) {
+          hash2 = (hash2 << 5) - hash2 + content.charCodeAt(i);
+          hash2 |= 0;
+        }
+        return hash2.toString(16);
+      }
+      /**
+       * Record a conversation turn (assistant response or tool result)
+       * @param {string} role - The role (assistant, tool_result)
+       * @param {string} content - The turn content
+       * @param {Object} metadata - Additional metadata
+       */
+      recordConversationTurn(role, content, metadata = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`conversation.turn.${role}`, {
+          "session.id": this.sessionId,
+          "conversation.role": role,
+          "conversation.content": content.substring(0, 1e4),
+          "conversation.content.length": content.length,
+          "conversation.content.hash": this.hashContent(content),
+          ...metadata
+        });
+      }
+      /**
+       * Record error events with classification
+       * @param {string} errorType - The type of error (wrapped_tool, unrecognized_tool, no_tool_call, circuit_breaker, etc.)
+       * @param {Object} errorDetails - Error details including message, stack, context
+       */
+      recordErrorEvent(errorType, errorDetails = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`error.${errorType}`, {
+          "session.id": this.sessionId,
+          "error.type": errorType,
+          "error.message": errorDetails.message?.substring(0, 1e3) || null,
+          "error.stack": errorDetails.stack?.substring(0, 2e3) || null,
+          "error.recoverable": errorDetails.recoverable ?? true,
+          "error.context": JSON.stringify(errorDetails.context || {}).substring(0, 1e3),
+          ...Object.fromEntries(
+            Object.entries(errorDetails).filter(([k]) => !["message", "stack", "context", "recoverable"].includes(k)).map(([k, v]) => [`error.${k}`, v])
+          )
+        });
+      }
+      /**
+       * Record AI thinking/reasoning content
+       * @param {string} thinkingContent - The thinking content from AI response
+       * @param {Object} metadata - Additional metadata
+       */
+      recordThinkingContent(thinkingContent, metadata = {}) {
+        if (!this.isEnabled() || !thinkingContent) return;
+        this.addEvent("ai.thinking", {
+          "session.id": this.sessionId,
+          "ai.thinking.content": thinkingContent.substring(0, 5e4),
+          "ai.thinking.length": thinkingContent.length,
+          "ai.thinking.hash": this.hashContent(thinkingContent),
+          ...metadata
+        });
+      }
+      /**
+       * Record AI tool call decision
+       * @param {string} toolName - The tool name AI decided to call
+       * @param {Object} params - The parameters AI provided
+       * @param {Object} metadata - Additional metadata
+       */
+      recordToolDecision(toolName, params, metadata = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent("ai.tool_decision", {
+          "session.id": this.sessionId,
+          "ai.tool_decision.name": toolName,
+          "ai.tool_decision.params": JSON.stringify(params || {}).substring(0, 2e3),
+          ...metadata
+        });
+      }
+      /**
+       * Record tool result after execution
+       * @param {string} toolName - The tool that was executed
+       * @param {string|Object} result - The tool result
+       * @param {boolean} success - Whether the tool succeeded
+       * @param {number} durationMs - Execution duration in milliseconds
+       * @param {Object} metadata - Additional metadata
+       */
+      recordToolResult(toolName, result, success2, durationMs, metadata = {}) {
+        if (!this.isEnabled()) return;
+        const resultStr = typeof result === "string" ? result : JSON.stringify(result);
+        this.addEvent("tool.result", {
+          "session.id": this.sessionId,
+          "tool.name": toolName,
+          "tool.result": resultStr.substring(0, 1e4),
+          "tool.result.length": resultStr.length,
+          "tool.result.hash": this.hashContent(resultStr),
+          "tool.duration_ms": durationMs,
+          "tool.success": success2,
+          ...metadata
+        });
+      }
+      /**
+       * Record MCP tool execution start
+       * @param {string} toolName - MCP tool name
+       * @param {string} serverName - MCP server name
+       * @param {Object} params - Tool parameters
+       * @param {Object} metadata - Additional metadata
+       */
+      recordMcpToolStart(toolName, serverName, params, metadata = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent("mcp.tool.start", {
+          "session.id": this.sessionId,
+          "mcp.tool.name": toolName,
+          "mcp.tool.server": serverName || "unknown",
+          "mcp.tool.params": JSON.stringify(params || {}).substring(0, 2e3),
+          ...metadata
+        });
+      }
+      /**
+       * Record MCP tool execution end
+       * @param {string} toolName - MCP tool name
+       * @param {string} serverName - MCP server name
+       * @param {string|Object} result - Tool result
+       * @param {boolean} success - Whether succeeded
+       * @param {number} durationMs - Execution duration
+       * @param {string} errorMessage - Error message if failed
+       * @param {Object} metadata - Additional metadata
+       */
+      recordMcpToolEnd(toolName, serverName, result, success2, durationMs, errorMessage = null, metadata = {}) {
+        if (!this.isEnabled()) return;
+        const resultStr = typeof result === "string" ? result : JSON.stringify(result || "");
+        this.addEvent("mcp.tool.end", {
+          "session.id": this.sessionId,
+          "mcp.tool.name": toolName,
+          "mcp.tool.server": serverName || "unknown",
+          "mcp.tool.result": resultStr.substring(0, 1e4),
+          "mcp.tool.result.length": resultStr.length,
+          "mcp.tool.duration_ms": durationMs,
+          "mcp.tool.success": success2,
+          "mcp.tool.error": errorMessage,
+          ...metadata
+        });
+      }
+      /**
+       * Record iteration lifecycle event
+       * @param {string} eventType - start or end
+       * @param {number} iteration - Iteration number
+       * @param {Object} data - Additional data
+       */
+      recordIterationEvent(eventType, iteration, data2 = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`iteration.${eventType}`, {
+          "session.id": this.sessionId,
+          "iteration": iteration,
+          ...data2
+        });
+      }
+      /**
+       * Record per-turn token breakdown
+       * @param {number} iteration - Iteration number
+       * @param {Object} tokenData - Token metrics
+       */
+      recordTokenTurn(iteration, tokenData = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent("tokens.turn", {
+          "session.id": this.sessionId,
+          "iteration": iteration,
+          "tokens.input": tokenData.inputTokens || 0,
+          "tokens.output": tokenData.outputTokens || 0,
+          "tokens.total": (tokenData.inputTokens || 0) + (tokenData.outputTokens || 0),
+          "tokens.cache_read": tokenData.cacheReadTokens || 0,
+          "tokens.cache_write": tokenData.cacheWriteTokens || 0,
+          "tokens.context_used": tokenData.contextTokens || 0,
+          "tokens.context_remaining": tokenData.maxContextTokens ? tokenData.maxContextTokens - (tokenData.contextTokens || 0) : null
+        });
+      }
+      async withSpan(spanName, fn, attributes = {}, onResult = null) {
+        if (!this.isEnabled()) {
+          return fn();
+        }
+        const span = this.telemetry.createSpan(spanName, {
+          "session.id": this.sessionId,
+          ...attributes
+        });
+        try {
+          const result = await fn();
+          span.setStatus("OK");
+          if (onResult) {
+            try {
+              onResult(span, result);
+            } catch (_) {
+            }
+          }
+          return result;
+        } catch (error40) {
+          span.setStatus("ERROR");
+          span.addEvent("exception", {
+            "exception.message": error40.message,
+            "exception.stack": error40.stack
+          });
+          throw error40;
+        } finally {
+          span.end();
+        }
+      }
+      async flush() {
+        if (this.telemetry) {
+          await this.telemetry.flush();
+        }
+      }
+      async shutdown() {
+        if (this.telemetry) {
+          await this.telemetry.shutdown();
+        }
+      }
+    };
   }
 });
 
@@ -26267,6 +26902,7 @@ async function delegate({
     });
     let parentAbortHandler;
     let parentAbortHardCancelId = null;
+    let raceSettled = false;
     const parentAbortPromise = new Promise((_, reject2) => {
       if (parentAbortSignal) {
         if (parentAbortSignal.aborted) {
@@ -26275,6 +26911,7 @@ async function delegate({
           return;
         }
         parentAbortHandler = () => {
+          if (raceSettled) return;
           subagent.triggerGracefulWindDown();
           if (debug) {
             console.error(`[DELEGATE] Parent abort signal received \u2014 triggered graceful wind-down on subagent ${sessionId}`);
@@ -26287,6 +26924,7 @@ async function delegate({
             });
           }
           parentAbortHardCancelId = setTimeout(() => {
+            if (raceSettled) return;
             if (debug) {
               console.error(`[DELEGATE] Graceful wind-down deadline expired \u2014 hard cancelling subagent ${sessionId}`);
             }
@@ -26312,6 +26950,7 @@ async function delegate({
     try {
       response = await Promise.race(racers);
     } finally {
+      raceSettled = true;
       if (parentAbortHandler && parentAbortSignal) {
         parentAbortSignal.removeEventListener("abort", parentAbortHandler);
       }
@@ -26352,10 +26991,12 @@ async function delegate({
         "delegation.success": true
       });
       if (delegationSpan) {
+        const { truncateForSpan: truncateForSpan2 } = await Promise.resolve().then(() => (init_simpleTelemetry(), simpleTelemetry_exports));
         delegationSpan.setAttributes({
           "delegation.result.success": true,
           "delegation.result.response_length": response.length,
-          "delegation.result.duration_ms": duration3
+          "delegation.result.duration_ms": duration3,
+          "delegation.result": truncateForSpan2(response, 4096)
         });
         delegationSpan.setStatus({ code: 1 });
         delegationSpan.end();
@@ -26408,9 +27049,13 @@ var init_delegate = __esm({
     init_ProbeAgent();
     DelegationManager = class {
       constructor(options = {}) {
-        this.maxConcurrent = options.maxConcurrent ?? parseInt(process.env.MAX_CONCURRENT_DELEGATIONS || "3", 10);
-        this.maxPerSession = options.maxPerSession ?? parseInt(process.env.MAX_DELEGATIONS_PER_SESSION || "10", 10);
-        this.defaultQueueTimeout = options.queueTimeout ?? parseInt(process.env.DELEGATION_QUEUE_TIMEOUT || "60000", 10);
+        const parseSafe = (val, fallback) => {
+          const n = parseInt(val, 10);
+          return Number.isNaN(n) ? fallback : n;
+        };
+        this.maxConcurrent = options.maxConcurrent ?? parseSafe(process.env.MAX_CONCURRENT_DELEGATIONS, 3);
+        this.maxPerSession = options.maxPerSession ?? parseSafe(process.env.MAX_DELEGATIONS_PER_SESSION, 10);
+        this.defaultQueueTimeout = options.queueTimeout ?? parseSafe(process.env.DELEGATION_QUEUE_TIMEOUT, 6e4);
         this.sessionDelegations = /* @__PURE__ */ new Map();
         this.globalActive = 0;
         this.waitQueue = [];
@@ -27248,12 +27893,16 @@ function resolveTargetPath(target, cwd) {
   }
   return filePart + suffix;
 }
-var import_path6, searchSchema, searchAllSchema, querySchema, extractSchema, delegateSchema, listSkillsSchema, useSkillSchema, listFilesSchema, searchFilesSchema, readImageSchema, bashSchema, analyzeAllSchema, executePlanSchema, cleanupExecutePlanSchema, searchDescription, searchDelegateDescription, queryDescription, extractDescription, delegateDescription, analyzeAllDescription;
+var import_path6, searchDelegateSchema, searchSchema, searchAllSchema, querySchema, extractSchema, delegateSchema, listSkillsSchema, useSkillSchema, listFilesSchema, searchFilesSchema, readImageSchema, bashSchema, analyzeAllSchema, executePlanSchema, cleanupExecutePlanSchema, searchDescription, searchDelegateDescription, queryDescription, extractDescription, delegateDescription, analyzeAllDescription;
 var init_common = __esm({
   "src/tools/common.js"() {
     "use strict";
     init_zod();
     import_path6 = require("path");
+    searchDelegateSchema = external_exports2.object({
+      query: external_exports2.string().describe('Natural language question about the code (e.g., "How does authentication work?", "Where is the rate limiting middleware?"). Do NOT use keyword syntax \u2014 just describe what you are looking for in plain English. A subagent will handle keyword searches for you.'),
+      path: external_exports2.string().optional().default(".").describe("Path to search in.")
+    });
     searchSchema = external_exports2.object({
       query: external_exports2.string().describe("Search query \u2014 natural language questions or Elasticsearch-style keywords both work. For keywords: use quotes for exact phrases, AND/OR for boolean logic, - for negation. Probe handles stemming and camelCase/snake_case splitting automatically, so do NOT try case or style variations of the same keyword."),
       path: external_exports2.string().optional().default(".").describe('Path to search in. For dependencies use "go:github.com/owner/repo", "js:package_name", or "rust:cargo_name" etc.'),
@@ -27319,7 +27968,17 @@ var init_common = __esm({
       clearSessionStore: external_exports2.boolean().optional().default(false).describe("Clear the session store (persisted data across execute_plan calls)")
     });
     searchDescription = 'Search code in the repository. Free-form questions are accepted, but Elasticsearch-style keyword queries work best. Use this tool first for any code-related questions. NOTE: By default, search handles stemming, case-insensitive matching, and camelCase/snake_case splitting automatically \u2014 do NOT manually try keyword variations like "getAllUsers" then "get_all_users" then "GetAllUsers". One search covers all variations.';
-    searchDelegateDescription = 'Search code in the repository by asking a question. Accepts natural language questions (e.g., "How does authentication work?", "Where is the user validation logic?"). A specialized subagent breaks down your question into targeted keyword searches and returns extracted code blocks. Do NOT formulate keyword queries yourself \u2014 just ask the question naturally.';
+    searchDelegateDescription = `Find where relevant code is located by asking a natural language question. A subagent searches the codebase and returns file locations grouped by relevance, with reasons explaining why each group matters. Use extract() to read the actual code from the returned locations.
+
+Returns JSON: { "confidence": "high|medium|low", "groups": [{ "reason": "why these files matter", "files": ["path#Symbol", ...] }] }
+
+IMPORTANT \u2014 each call spawns a subagent (expensive, takes minutes). Be deliberate:
+- Ask plain English questions about WHERE code is, NOT keyword queries. Good: "How are user sessions extracted from cookies?" Bad: "ctxGetSession OR GetSession"
+- Each call should explore a DIFFERENT ANGLE of the problem. Don't rephrase \u2014 reframe:
+  Good: 1) "How are sessions extracted from HTTP requests?" 2) "What middleware runs before route handlers?" 3) "How is the session cookie parsed and validated?"
+  Bad: 1) "How does session extraction work?" 2) "Where is the session extracted?" 3) "Find session extraction code" \u2190 same question reworded
+- If a search returned no useful results, ask about a DIFFERENT part of the system. Think: what upstream/downstream component touches this?
+- After getting results, use extract() to read the files you need \u2014 search only locates, extract reads.`;
     queryDescription = "Search code using ast-grep structural pattern matching. Use this tool to find specific code structures like functions, classes, or methods.";
     extractDescription = "Extract code blocks from files based on file paths and optional line numbers. Use this tool to see complete context after finding relevant files. Line numbers from output can be used with edit start_line/end_line for precise editing.";
     delegateDescription = "Automatically delegate big distinct tasks to specialized probe subagents within the agentic loop. Used by AI agents to break down complex requests into focused, parallel tasks.";
@@ -27443,6 +28102,72 @@ function autoQuoteSearchTerms(query2) {
   });
   return result.join(" ");
 }
+async function checkDelegateDedup(newQuery, previousQueries, model, debug) {
+  if (!model || previousQueries.length === 0) {
+    return { action: "allow", reason: "no previous queries" };
+  }
+  const previousList = previousQueries.map((q, i) => {
+    let line = `${i + 1}. "${q.query}" (path: ${q.path}, found results: ${q.hadResults})`;
+    if (q.reason) line += `
+   Outcome: ${q.reason}`;
+    if (q.groups && q.groups.length > 0) {
+      line += `
+   Found: ${q.groups.map((g) => g.reason).join("; ")}`;
+    }
+    return line;
+  }).join("\n");
+  try {
+    const result = await (0, import_ai.generateText)({
+      model,
+      maxTokens: 150,
+      temperature: 0,
+      prompt: `You decide if a code search query is redundant given previous queries in the same session.
+
+PREVIOUS QUERIES:
+${previousList}
+
+NEW QUERY: "${newQuery}"
+
+Respond with exactly one line: ACTION|REASON
+For rewrites: rewrite|REASON|REWRITTEN_QUERY
+
+BLOCK when:
+- Same concept, different phrasing: "find X" / "definition of X" / "where is X" / "X implementation" \u2192 all the same
+- Synonym or narrower term of a previous query: "dedup" \u2192 "duplicate" \u2192 "unique" \u2192 all the same concept
+- Single generic word that's just a synonym of a previous failed query
+- Query is trying to brute-force the same concept with different keywords after previous failures
+
+REWRITE when:
+- Previous query was too narrow and failed, new query targets the same goal but could use a FUNDAMENTALLY different search strategy (e.g. searching for a caller instead of the function name, or searching the config/registration site instead of the implementation)
+- Previous query found WRONG results (e.g. found "FallbackManager" when looking for "dedup logic") \u2014 rewrite to target the actual concept more precisely using implementation-level terms
+
+ALLOW only when:
+- The new query targets a COMPLETELY DIFFERENT feature, module, or subsystem \u2014 not just a different word for the same thing
+
+Only BLOCK when you are CERTAIN the queries target the same concept. When uncertain, ALLOW \u2014 a missed dedup is cheaper than blocking a valid search.
+
+Examples:
+- Prev: "wrapToolWithEmitter" \u2192 New: "definition of wrapToolWithEmitter" \u2192 block|Same symbol
+- Prev: "search dedup" (no results) \u2192 New: "dedup" \u2192 block|Synonym of failed query
+- Prev: "dedup" (no results) \u2192 New: "duplicate" \u2192 block|Synonym of failed query
+- Prev: "dedup" (no results) \u2192 New: "unique" \u2192 block|Synonym of failed query
+- Prev: "auth middleware" \u2192 New: "rate limiting" \u2192 allow|Different subsystem
+- Prev: "search dedup" (no results) \u2192 New: "previousSearches Map" \u2192 rewrite|Searching for implementation detail instead of concept|previousSearches OR searchKey`
+    });
+    const line = result.text.trim().split("\n")[0];
+    const parts = line.split("|");
+    const action = (parts[0] || "").toLowerCase().trim();
+    if (action === "block") {
+      return { action: "block", reason: parts[1]?.trim() || "duplicate query" };
+    } else if (action === "rewrite" && parts[2]) {
+      return { action: "rewrite", reason: parts[1]?.trim() || "refined query", rewritten: parts[2].trim() };
+    }
+    return { action: "allow", reason: parts[1]?.trim() || "new concept" };
+  } catch (err) {
+    if (debug) console.error("[DEDUP-LLM] Error:", err.message);
+    return { action: "allow", reason: "dedup check failed, allowing" };
+  }
+}
 function normalizeTargets(targets) {
   if (!Array.isArray(targets)) return [];
   const seen = /* @__PURE__ */ new Set();
@@ -27505,8 +28230,8 @@ function fallbackTargetsFromText(text) {
   }
   return candidates;
 }
-function parseDelegatedTargets(rawResponse) {
-  if (!rawResponse || typeof rawResponse !== "string") return [];
+function parseDelegatedResponse(rawResponse) {
+  if (!rawResponse || typeof rawResponse !== "string") return null;
   const trimmed = rawResponse.trim();
   const tryParse = (text) => {
     try {
@@ -27523,14 +28248,37 @@ function parseDelegatedTargets(rawResponse) {
     }
   }
   if (parsed) {
-    if (Array.isArray(parsed)) {
-      return normalizeTargets(parsed);
+    if (Array.isArray(parsed.groups)) {
+      return {
+        confidence: parsed.confidence || "medium",
+        reason: parsed.reason || "",
+        groups: parsed.groups.map((g) => ({
+          reason: g.reason || "",
+          files: normalizeTargets(g.files || [])
+        })).filter((g) => g.files.length > 0),
+        searches: Array.isArray(parsed.searches) ? parsed.searches : []
+      };
     }
     if (Array.isArray(parsed.targets)) {
-      return normalizeTargets(parsed.targets);
+      const files2 = normalizeTargets(parsed.targets);
+      if (files2.length > 0) {
+        return { confidence: "medium", reason: "", groups: [{ reason: "Search results", files: files2 }], searches: [] };
+      }
+      return null;
     }
+    if (Array.isArray(parsed)) {
+      const files2 = normalizeTargets(parsed);
+      if (files2.length > 0) {
+        return { confidence: "medium", reason: "", groups: [{ reason: "Search results", files: files2 }], searches: [] };
+      }
+      return null;
+    }
+  }
+  const files = normalizeTargets(fallbackTargetsFromText(trimmed));
+  if (files.length > 0) {
+    return { confidence: "low", reason: "", groups: [{ reason: "Search results", files }], searches: [] };
   }
-  return normalizeTargets(fallbackTargetsFromText(trimmed));
+  return null;
 }
 function splitTargetSuffix(target) {
   const searchStart = target.length > 2 && target[1] === ":" && /[a-zA-Z]/.test(target[0]) ? 2 : 0;
@@ -27544,159 +28292,78 @@ function splitTargetSuffix(target) {
   return { filePart: target, suffix: "" };
 }
 function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, allowTests }) {
-  return [
-    "You are a code-search subagent. Your job is to find ALL relevant code locations for the given query.",
-    "",
-    "The query may be complex - it could be a natural language question, a multi-part request, or a simple keyword.",
-    "Break down complex queries into multiple searches to cover all aspects.",
-    "",
-    "Available tools:",
-    "- search: Find code matching keywords or patterns. Results are paginated \u2014 use nextPage=true when results are relevant to get more. Run multiple searches for different aspects.",
-    "- extract: Verify code snippets to ensure targets are actually relevant before including them.",
-    "- listFiles: Understand directory structure to find where relevant code might live.",
-    "",
-    "CRITICAL - How probe search works (do NOT ignore):",
-    "- By default (exact=false), probe ALREADY handles stemming, case-insensitive matching, and camelCase/snake_case splitting automatically.",
-    '- Searching "allowed_ips" ALREADY matches "AllowedIPs", "allowedIps", "allowed_ips", etc. Do NOT manually try case/style variations.',
-    '- Searching "getUserData" ALREADY matches "get", "user", "data" and their variations.',
-    "- NEVER repeat the same search query \u2014 you will get the same results. Changing the path does NOT change this.",
-    "- NEVER search trivial variations of the same keyword (e.g., AllowedIPs then allowedIps then allowed_ips). This is wasteful \u2014 probe handles it.",
-    "",
-    "When a search returns no results:",
-    '- If you searched a SUBFOLDER (e.g., path="gateway/"), the term might exist elsewhere.',
-    "  Try searching from the workspace root (omit the path parameter) or a different directory.",
-    "  But do NOT retry the same subfolder with different quoting \u2014 that will not help.",
-    "- If you searched the WORKSPACE ROOT and got no results, the term does not exist in this codebase.",
-    '  Changing quotes, adding "func " prefix, or switching to method syntax will NOT help.',
-    "- These are ALL the same failed search, NOT different searches:",
-    '    search("func ctxGetData") \u2192 no results',
-    '    search("ctxGetData")      \u2192 no results  \u2190 WASTED, same concept, different quoting',
-    "    search(ctxGetData)         \u2192 no results  \u2190 WASTED, same concept, no quotes",
-    '    search("ctx.GetData")      \u2192 no results  \u2190 WASTED, method syntax of same concept',
-    '  After the FIRST "no results" at a given scope, either widen the search path or try',
-    "  a fundamentally different approach: search for a broader concept, use listFiles",
-    "  to discover actual function names, or extract a known file to read real code.",
-    "- If 2 searches return no results for a concept (across different scopes), the code likely",
-    "  uses different naming than you expect \u2014 discover the real names via extract or listFiles.",
-    "",
-    "When to use exact=true:",
-    "- Use exact=true when searching for a KNOWN symbol name (function, type, variable, struct).",
-    "- exact=true matches the literal string only \u2014 no stemming, no splitting.",
-    '- This is ideal for precise lookups: exact=true "ForwardMessage", exact=true "SessionLimiter", exact=true "ThrottleRetryLimit".',
-    "- IMPORTANT: Use exact=true when searching for strings containing punctuation, quotes, or empty values.",
-    "  Default BM25 search strips punctuation and treats quoted empty strings as noise.",
-    `  Example: searching for 'description: ""' with exact=false will NOT find empty description fields \u2014 it just matches "description".`,
-    `  Use exact=true for literal patterns like 'description: ""', 'value: \\'\\'', or any YAML/config field with specific punctuation.`,
-    "- Do NOT use exact=true for exploratory/conceptual queries \u2014 use the default for those.",
-    "",
-    "Combining searches with OR:",
-    '- Multiple unquoted words use OR logic: rate limit matches files containing EITHER "rate" OR "limit".',
-    `- IMPORTANT: Multiple quoted terms use AND logic by default: '"RateLimit" "middleware"' requires BOTH in the same file.`,
-    `- To search for ANY of several quoted symbols, use the explicit OR operator: '"ForwardMessage" OR "SessionLimiter"'.`,
-    '- Without quotes, camelCase like limitDRL gets split into "limit" + "DRL" \u2014 not what you want for symbol lookup.',
-    "- Use OR to search for multiple related symbols in ONE search instead of separate searches.",
-    "- This is much faster than running separate searches sequentially.",
-    `- Example: search '"ForwardMessage" OR "SessionLimiter"' finds files with either exact symbol in one call.`,
-    `- Example: search '"limitDRL" OR "doRollingWindowWrite"' finds both rate limiting functions at once.`,
-    "- Use AND (or just put quoted terms together) when you need both terms in the same file.",
-    "",
-    "Parallel tool calls:",
-    "- When you need to search for INDEPENDENT concepts, call multiple search tools IN PARALLEL (same response).",
-    "- Do NOT wait for one search to finish before starting the next if they are independent.",
-    '- Example: for "rate limiting and session management", call search "rate limiting" AND search "session management" in parallel.',
-    "- Similarly, call multiple extract tools in parallel when verifying different files.",
-    "",
-    "GOOD search strategy (do this):",
-    '  Query: "How does authentication work and how are sessions managed?"',
-    '  \u2192 search "authentication" + search "session management" IN PARALLEL (two independent concepts)',
-    '  Query: "Find the IP allowlist middleware"',
-    '  \u2192 search "allowlist middleware" (one search, probe handles IP/ip/Ip variations)',
-    '  Query: "Find ForwardMessage and SessionLimiter"',
-    `  \u2192 search '"ForwardMessage" OR "SessionLimiter"' (one OR search finds both exact symbols)`,
-    '  OR: search exact=true "ForwardMessage" + search exact=true "SessionLimiter" IN PARALLEL',
-    '  Query: "Find limitDRL and limitRedis functions"',
-    `  \u2192 search '"limitDRL" OR "limitRedis"' (one OR search, quoted to prevent camelCase splitting)`,
-    '  Query: "Find ThrottleRetryLimit usage"',
-    '  \u2192 search exact=true "ThrottleRetryLimit" (one search, if no results the symbol does not exist \u2014 stop)',
-    '  Query: "How does BM25 scoring work with SIMD optimization?"',
-    '  \u2192 search "BM25 scoring" + search "SIMD optimization" IN PARALLEL (two different concepts)',
-    "",
-    "BAD search strategy (never do this):",
-    '  \u2192 search "AllowedIPs" \u2192 search "allowedIps" \u2192 search "allowed_ips" (WRONG: case/style variations, probe handles them)',
-    `  \u2192 search "limitDRL" \u2192 search "LimitDRL" (WRONG: case variation \u2014 combine with OR: '"limitDRL" OR "limitRedis"')`,
-    '  \u2192 search "throttle_retry_limit" after searching "ThrottleRetryLimit" (WRONG: snake_case variation, probe handles it)',
-    '  \u2192 search "ThrottleRetryLimit" path=tyk \u2192 search "ThrottleRetryLimit" path=gateway \u2192 search "ThrottleRetryLimit" path=apidef (WRONG: same query on different paths \u2014 probe searches recursively)',
-    '  \u2192 search "func (k *RateLimitAndQuotaCheck) handleRateLimitFailure" (WRONG: do not search full function signatures, just use exact=true "handleRateLimitFailure")',
-    '  \u2192 search "ForwardMessage" \u2192 search "ForwardMessage" \u2192 search "ForwardMessage" (WRONG: repeating the exact same query)',
-    '  \u2192 search "authentication" \u2192 wait \u2192 search "session management" \u2192 wait (WRONG: these are independent, run them in parallel)',
-    "",
-    "  WORST pattern \u2014 retrying a non-existent function with quote/syntax variations (this wastes 30 minutes):",
-    '  \u2192 search "func ctxGetData" \u2192 no results',
-    '  \u2192 search "ctxGetData" \u2192 no results          \u2190 WRONG: same term without "func" prefix',
-    '  \u2192 search "ctx.GetData" \u2192 no results          \u2190 WRONG: method syntax of same concept',
-    '  \u2192 search "ctx.SetData" \u2192 no results          \u2190 WRONG: Set variant of same concept',
-    "  \u2192 search ctxGetData \u2192 no results             \u2190 WRONG: unquoted version of same term",
-    "  \u2192 extract api.go \u2192 extract api.go \u2192 extract api.go (8 times!) \u2190 WRONG: re-reading same file",
-    '  FIX: After "func ctxGetData" returns no results in gateway/:',
-    "  Option A: Widen scope \u2014 search from the workspace root (omit path) in case the",
-    "    function is defined in a different package (e.g., apidef/, user/, config/).",
-    "  Option B: Discover real names \u2014 extract a file you KNOW uses context (e.g., a",
-    "    middleware file) and READ what functions it actually calls.",
-    "  Option C: Browse \u2014 use listFiles to see what files exist and extract the relevant ones.",
-    "  NEVER: retry the same concept with different quoting in the same directory.",
-    "",
-    "Keyword tips:",
-    "- Common programming keywords are filtered as stopwords when unquoted: function, class, return, new, struct, impl, var, let, const, etc.",
-    '- Avoid searching for these alone \u2014 combine with a specific term (e.g., "middleware function" is fine, "function" alone is too generic).',
-    '- To bypass stopword filtering: wrap terms in quotes ("return", "struct") or set exact=true. Both disable stemming and splitting too.',
-    '- camelCase terms are split: getUserData becomes "get", "user", "data" \u2014 so one search covers all naming styles.',
-    '- Do NOT search for full function signatures like "func (r *Type) Method(args)". Just search for the method name with exact=true.',
-    '- Do NOT search for file names (e.g., "sliding_log.go"). Use listFiles to discover files by name.',
-    "",
-    "PAGINATION:",
-    "- Search results are paginated (~20k tokens per page).",
-    "- If your search returned relevant files, call the same query with nextPage=true to check for more.",
-    '- Keep paginating while results stay relevant. Stop when results are off-topic or "All results retrieved".',
-    "",
-    "WHEN TO STOP:",
-    "- After you have explored the main concept AND related subsystems.",
-    "- Once you have 5-15 targets covering different aspects of the query.",
-    '- If you get a "DUPLICATE SEARCH BLOCKED" message, do NOT rephrase the same query \u2014 try a FUNDAMENTALLY different approach:',
-    "  * Switch between exact=true and exact=false",
-    "  * Search for a broader term and filter results manually",
-    "  * Use listFiles to browse the directory structure directly",
-    "  * Look for related/surrounding patterns instead of the exact string",
-    "- If 2-3 genuinely different search approaches fail, STOP and report what you tried and why it failed.",
-    "  Do NOT keep trying variations of the same failing concept.",
-    "",
-    "Strategy:",
-    "1. Analyze the query \u2014 identify key concepts, then brainstorm SYNONYMS and alternative terms for each.",
-    '   Code naming often differs from the concept: "authentication" \u2192 verify, credentials, login, auth;',
-    '   "rate limiting" \u2192 throttle, quota, limiter, bucket; "error handling" \u2192 catch, recover, panic.',
-    "   Think about what a developer would NAME the function/struct/variable, not just the concept.",
-    "2. Run INDEPENDENT searches in PARALLEL \u2014 search for the main concept AND synonyms simultaneously.",
-    "   After each search, check if results are relevant. If yes, call nextPage=true for more results.",
-    `3. Combine related symbols into OR searches: '"symbolA" OR "symbolB"' finds files with either.`,
-    "4. For known symbol names use exact=true. For concepts use default (exact=false).",
-    "5. After your first round of searches, READ the extracted code and look for connected code:",
-    "   - Function calls to other important functions \u2192 include those targets.",
-    "   - Type references and imports \u2192 include type definitions.",
-    "   - Registered handlers/middleware \u2192 include all registered items.",
-    "6. If a search returns results, use extract to verify relevance. Run multiple extracts in parallel too.",
-    "7. If a search returns NO results: widen the path scope if you searched a subfolder, or move on. Do NOT retry with quote/syntax variations \u2014 they search the same index.",
-    "8. Once you have enough targets (typically 5-15), output your final JSON answer immediately.",
-    "",
-    `Query: ${searchQuery}`,
-    `Search path(s): ${searchPath}`,
-    `Options: exact=${exact ? "true" : "false"}, language=${language || "auto"}, allow_tests=${allowTests ? "true" : "false"}.`,
-    "",
-    'Return ONLY valid JSON: {"targets": ["path/to/file.ext#Symbol", "path/to/file.ext:line", "path/to/file.ext:start-end"]}',
-    'IMPORTANT: Use ABSOLUTE file paths in targets (e.g., "/full/path/to/file.ext#Symbol"). If you only have relative paths, make them relative to the search path above.',
-    "Prefer #Symbol when a function/class name is clear; otherwise use line numbers.",
-    "Deduplicate targets. Do NOT explain or answer - ONLY return the JSON targets.",
-    "",
-    "Remember: if your search returned relevant results, use nextPage=true to check for more before outputting."
-  ].join("\n");
+  return `<role>
+You are a code-location subagent. Your job is to find WHERE relevant code lives for the given question.
+You are NOT answering the question \u2014 you are finding the code locations that would help answer it.
+</role>
+
+<task>
+<question>${searchQuery}</question>
+<search-path>${searchPath}</search-path>
+<options language="${language || "auto"}" allow_tests="${allowTests ? "true" : "false"}" />
+</task>
+
+<tools>
+<tool name="search">
+Find code matching keywords or patterns. Results are paginated \u2014 use nextPage=true when results are relevant to get more.
+</tool>
+<tool name="extract">
+Read code to verify a file is actually relevant before including it.
+</tool>
+<tool name="listFiles">
+Browse directory structure to discover where code might live.
+</tool>
+</tools>
+
+<search-engine-behavior>
+- Probe handles stemming, case-insensitive matching, and camelCase/snake_case splitting automatically.
+- "allowed_ips" ALREADY matches "AllowedIPs", "allowedIps", etc. Do NOT try case/style variations.
+- NEVER repeat the same search query \u2014 you will get the same results.
+- If a search returns no results at workspace root, the term does not exist. Move on.
+- If a search returns no results in a subfolder, try the workspace root or a different directory.
+- Use exact=true for known symbol names. Use default for conceptual/exploratory queries.
+- Combine related symbols with OR: "SymbolA" OR "SymbolB" finds files with either.
+- Run INDEPENDENT searches in PARALLEL \u2014 do not wait between unrelated searches.
+</search-engine-behavior>
+
+<strategy>
+1. Analyze the question \u2014 identify key concepts and brainstorm what a developer would NAME the relevant code.
+2. Start your first search with the FULL search-path provided above. Do NOT narrow to a subdirectory on first try \u2014 the code may live anywhere in the tree.
+3. Search for the main concept and synonyms in parallel.
+4. Use extract to verify relevance \u2014 skim the code to confirm it ACTUALLY relates to the question.
+5. Follow the trail: if you find a function, look for its callers, type definitions, and registered handlers.
+6. Group your findings by WHY they are relevant (not by how you found them).
+</strategy>
+
+<relevance-filtering priority="critical">
+- Only include files you have VERIFIED are relevant by reading them with extract.
+- Do NOT include files just because they matched a keyword \u2014 confirm the match is meaningful.
+- A file that mentions "session" in a comment is NOT relevant to "How do sessions work?" \u2014 look for the actual implementation.
+- Fewer verified-relevant files are far more valuable than many unverified keyword matches.
+- If a file is tangentially related but not core to the question, leave it out.
+- If NO files are truly relevant, return EMPTY groups with confidence "low". An honest empty result is far better than a wrong result. Never fill groups with loosely related files just to have something.
+</relevance-filtering>
+
+<stop-conditions>
+- Once you have found locations covering the main concept and related subsystems.
+- If 2-3 different search approaches fail, stop and report what you have.
+- Do NOT keep trying quote/syntax variations of the same failing keyword.
+</stop-conditions>
+
+<on-iteration-limit>
+If you run out of tool iterations, you MUST still output your JSON response with whatever you found so far.
+Set confidence to "low" if your search was incomplete.
+Include ALL files you verified as relevant, even if coverage is partial.
+The "searches" field helps the caller understand what was attempted.
+</on-iteration-limit>
+
+<output-rules>
+- Return ONLY valid JSON matching the schema. No markdown, no explanation.
+- ONLY include files you have verified are relevant. No noise.
+- Group files by RELEVANCE to the question, not by search query.
+- Use ABSOLUTE file paths. Prefer #Symbol for functions/classes; otherwise use line ranges.
+- Deduplicate files across groups.
+</output-rules>`;
 }
 var import_ai, import_fs5, CODE_SEARCH_SCHEMA, searchTool, queryTool, extractTool, delegateTool, analyzeAllTool;
 var init_vercel = __esm({
@@ -27712,17 +28379,54 @@ var init_vercel = __esm({
     import_fs5 = require("fs");
     init_error_types();
     init_hashline();
+    init_provider();
     init_simpleTelemetry();
     CODE_SEARCH_SCHEMA = {
       type: "object",
       properties: {
-        targets: {
+        confidence: {
+          type: "string",
+          enum: ["high", "medium", "low"],
+          description: "How confident you are that these locations answer the question."
+        },
+        reason: {
+          type: "string",
+          description: "Brief explanation of confidence level \u2014 what was found, partially found, or not found."
+        },
+        groups: {
           type: "array",
-          items: { type: "string" },
-          description: 'List of file targets like "path/to/file.ext#Symbol" or "path/to/file.ext:line" or "path/to/file.ext:start-end".'
+          items: {
+            type: "object",
+            properties: {
+              reason: {
+                type: "string",
+                description: "Why these files are relevant \u2014 what aspect of the question they address (not how the code works)."
+              },
+              files: {
+                type: "array",
+                items: { type: "string" },
+                description: 'File targets like "path/to/file.ext#Symbol" or "path/to/file.ext:10-20".'
+              }
+            },
+            required: ["reason", "files"]
+          },
+          description: "Groups of related files, each with a reason explaining why they matter."
+        },
+        searches: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              query: { type: "string", description: "The search query used." },
+              path: { type: "string", description: "The path searched in." },
+              had_results: { type: "boolean", description: "Whether the search returned any results." }
+            },
+            required: ["query", "path", "had_results"]
+          },
+          description: "All search queries executed during this session, with their paths and outcomes."
         }
       },
-      required: ["targets"],
+      required: ["confidence", "reason", "groups", "searches"],
       additionalProperties: false
     };
     searchTool = (options = {}) => {
@@ -27747,14 +28451,16 @@ var init_vercel = __esm({
       const MAX_CONSECUTIVE_NO_RESULTS = 4;
       const failedConcepts = /* @__PURE__ */ new Map();
       const MAX_PAGES_PER_QUERY = 3;
+      const previousDelegations = [];
+      let cachedDedupModel = void 0;
       function normalizeQueryConcept(query2) {
         if (!query2) return "";
-        return query2.replace(/^["']|["']$/g, "").replace(/\./g, "").replace(/[_\-\s]+/g, "").toLowerCase().trim();
+        return query2.replace(/^["']|["']$/g, "").replace(/^(definition\s+of|implementation\s+of|usage\s+of|find|where\s+is|how\s+does|locate|show\s+me|get|look\s+for)\s+/i, "").replace(/^["']|["']$/g, "").replace(/\./g, "").replace(/[_\-\s]+/g, "").toLowerCase().trim();
       }
       return (0, import_ai.tool)({
         name: "search",
         description: searchDelegate ? searchDelegateDescription : searchDescription,
-        inputSchema: searchSchema,
+        inputSchema: searchDelegate ? searchDelegateSchema : searchSchema,
         execute: async ({ query: searchQuery, path: path9, allow_tests, exact, maxTokens: paramMaxTokens, language, session, nextPage, workingDirectory }) => {
           if (!exact && searchQuery) {
             const originalQuery = searchQuery;
@@ -27799,7 +28505,8 @@ var init_vercel = __esm({
             return await search(searchOptions);
           };
           if (!searchDelegate) {
-            const searchKey = `${searchPath}::${searchQuery}::${exact || false}`;
+            const searchKey = `${searchPath}::${searchQuery}::${exact || false}::${language || ""}`;
+            let circuitBreakerWarning = "";
             if (!nextPage) {
               if (previousSearches.has(searchKey)) {
                 const blockCount = (dupBlockCounts.get(searchKey) || 0) + 1;
@@ -27840,19 +28547,13 @@ Change your strategy:${scopeHint}
               }
               if (consecutiveNoResults >= MAX_CONSECUTIVE_NO_RESULTS) {
                 if (debug) {
-                  console.error(`[CIRCUIT-BREAKER] ${consecutiveNoResults} consecutive no-result searches, blocking: "${searchQuery}"`);
+                  console.error(`[CIRCUIT-BREAKER] ${consecutiveNoResults} consecutive no-result searches, warning: "${searchQuery}"`);
                 }
                 const isSubfolderCB = path9 && path9 !== effectiveSearchCwd && path9 !== ".";
-                const cbScopeHint = isSubfolderCB ? `
-- You have been searching in "${path9}" \u2014 try searching from the workspace root or a different directory` : "";
-                return `CIRCUIT BREAKER: Your last ${consecutiveNoResults} searches ALL returned no results. You appear to be guessing function/type names that don't match what's actually in the code.
-
-Change your approach:${cbScopeHint}
-1. Use extract on files you already found \u2014 read the actual code to discover real function names
-2. Use listFiles to browse directories and see what files/functions actually exist
-3. If you found some results earlier, those are likely sufficient \u2014 provide your final answer
+                const cbScopeHint = isSubfolderCB ? ` You have been searching in "${path9}" \u2014 consider searching from the workspace root or a different directory.` : "";
+                circuitBreakerWarning = `
 
-Retrying search query variations will not help. Discover real names from real code instead.`;
+\u26A0\uFE0F CIRCUIT BREAKER: Your last ${consecutiveNoResults} searches ALL returned no results.${cbScopeHint} You MUST change your approach: use extract on files you already found, use listFiles to browse directories, or provide your final answer. Guessing names will not help.`;
               }
             } else {
               const pageCount = (paginationCounts.get(searchKey) || 0) + 1;
@@ -27874,9 +28575,9 @@ Retrying search query variations will not help. Discover real names from real co
                   console.error(`[NO-RESULTS] consecutiveNoResults=${consecutiveNoResults}, concept "${normalizeQueryConcept(searchQuery)}" failed ${failedConcepts.get(normalizedKey)}x`);
                 }
                 if (/^[A-Z]+-\d+$/.test(searchQuery.trim()) || /^[A-Z]+-\d+$/.test(searchQuery.replace(/"/g, "").trim())) {
-                  return result + "\n\n\u26A0\uFE0F Your query looks like a ticket/issue ID (e.g., JIRA-1234). Ticket IDs are rarely present in source code. Search for the technical concepts described in the ticket instead (e.g., function names, error messages, variable names).";
+                  return result + "\n\n\u26A0\uFE0F Your query looks like a ticket/issue ID (e.g., JIRA-1234). Ticket IDs are rarely present in source code. Search for the technical concepts described in the ticket instead (e.g., function names, error messages, variable names)." + circuitBreakerWarning;
                 }
-                if (consecutiveNoResults >= MAX_CONSECUTIVE_NO_RESULTS - 1) {
+                if (consecutiveNoResults >= MAX_CONSECUTIVE_NO_RESULTS - 1 && !circuitBreakerWarning) {
                   const isSubfolderWarn = path9 && path9 !== effectiveSearchCwd && path9 !== ".";
                   const warnScopeHint = isSubfolderWarn ? ` You are searching in "${path9}" \u2014 consider searching from the workspace root or a different directory.` : "";
                   return result + `
@@ -27892,7 +28593,7 @@ Retrying search query variations will not help. Discover real names from real co
                 options.fileTracker.trackFilesFromOutput(result, effectiveSearchCwd).catch(() => {
                 });
               }
-              return result;
+              return typeof result === "string" ? result + circuitBreakerWarning : result;
             } catch (error40) {
               console.error("Error executing search command:", error40);
               const formatted = formatErrorForAI(error40);
@@ -27902,12 +28603,58 @@ Retrying search query variations will not help. Discover real names from real co
               return formatted;
             }
           }
+          const delegatePath = searchPath || "";
+          let effectiveQuery = searchQuery;
+          if (previousDelegations.length > 0) {
+            if (cachedDedupModel === void 0) {
+              const dedupProvider = options.searchDelegateProvider || process.env.PROBE_SEARCH_DELEGATE_PROVIDER || options.provider || process.env.FORCE_PROVIDER || null;
+              const dedupModelName = options.searchDelegateModel || process.env.PROBE_SEARCH_DELEGATE_MODEL || options.model || process.env.MODEL_NAME || null;
+              if (debug) {
+                console.error(`[DEDUP-LLM] Creating model: provider=${dedupProvider}, model=${dedupModelName}`);
+              }
+              cachedDedupModel = await createLanguageModel(dedupProvider, dedupModelName);
+              if (debug) {
+                console.error(`[DEDUP-LLM] Model created: ${cachedDedupModel ? "success" : "null"}`);
+              }
+            }
+            const dedupSpanAttrs = {
+              "dedup.query": searchQuery,
+              "dedup.previous_count": String(previousDelegations.length),
+              "dedup.previous_queries": previousDelegations.map((d) => d.query).join(" | ")
+            };
+            const dedup = options.tracer?.withSpan ? await options.tracer.withSpan("search.delegate.dedup", async () => {
+              return await checkDelegateDedup(searchQuery, previousDelegations, cachedDedupModel, debug);
+            }, dedupSpanAttrs, (span, result) => {
+              span.setAttributes({
+                "dedup.action": result.action,
+                "dedup.reason": result.reason || "",
+                "dedup.rewritten": result.rewritten || ""
+              });
+            }) : await checkDelegateDedup(searchQuery, previousDelegations, cachedDedupModel, debug);
+            if (debug) {
+              console.error(`[DEDUP-LLM] Query: "${searchQuery}" \u2192 ${dedup.action}: ${dedup.reason}${dedup.rewritten ? ` \u2192 "${dedup.rewritten}"` : ""}`);
+            }
+            if (dedup.action === "block") {
+              const prevQueries = previousDelegations.map((d) => `"${d.query}"`).join(", ");
+              return `DELEGATE BLOCKED: "${searchQuery}" is semantically duplicate of previous delegation(s) [${prevQueries}]. ${dedup.reason}
+
+Do NOT re-delegate the same concept. Use extract() on files already found, or synthesize your answer from existing results.`;
+            }
+            if (dedup.action === "rewrite" && dedup.rewritten) {
+              effectiveQuery = dedup.rewritten;
+              if (debug) {
+                console.error(`[DEDUP-LLM] Rewritten query: "${searchQuery}" \u2192 "${effectiveQuery}"`);
+              }
+            }
+          }
+          const delegationRecord = { query: effectiveQuery, path: delegatePath, hadResults: false };
+          previousDelegations.push(delegationRecord);
           try {
             if (debug) {
-              console.error(`Delegating search with query: "${searchQuery}", path: "${searchPath}"`);
+              console.error(`Delegating search with query: "${effectiveQuery}", path: "${searchPath}"${effectiveQuery !== searchQuery ? ` (rewritten from: "${searchQuery}")` : ""}`);
             }
             const delegateTask = buildSearchDelegateTask({
-              searchQuery,
+              searchQuery: effectiveQuery,
               searchPath,
               exact,
               language,
@@ -27934,18 +28681,33 @@ Retrying search query variations will not help. Discover real names from real co
             });
             const delegateResult = options.tracer?.withSpan ? await options.tracer.withSpan("search.delegate", runDelegation, {
               "search.query": searchQuery,
-              "search.path": searchPath
+              "search.path": searchPath,
+              ...effectiveQuery !== searchQuery ? { "search.query.rewritten": effectiveQuery } : {}
             }, (span, result) => {
-              const text = typeof result === "string" ? result : "";
+              const text = typeof result === "string" ? result : JSON.stringify(result) || "";
+              if (debug) console.error(`[search-delegate] onResult: type=${typeof result}, length=${text.length}`);
               span.setAttributes({
                 "search.delegate.output": truncateForSpan(text),
-                "search.delegate.output_length": text.length
+                "search.delegate.output_length": String(text.length)
               });
             }) : await runDelegation();
-            const targets = parseDelegatedTargets(delegateResult);
-            if (!targets.length) {
+            const structured = parseDelegatedResponse(delegateResult);
+            if (delegationRecord && structured) {
+              delegationRecord.hadResults = structured.groups.length > 0;
+              delegationRecord.reason = structured.reason || "";
+              delegationRecord.groups = structured.groups.map((g) => ({ reason: g.reason }));
+            }
+            if (!structured || structured.groups.length === 0) {
+              if (structured && structured.confidence === "low" && structured.reason) {
+                if (debug) {
+                  console.error(`Delegated search explicitly found nothing: ${structured.reason}`);
+                }
+                return `NOT FOUND: The search delegate thoroughly searched for "${searchQuery}" and concluded: ${structured.reason}
+
+Do NOT search for analogies or loosely related concepts. If the feature does not exist in the codebase, say so in your final answer.`;
+              }
               if (debug) {
-                console.error("Delegated search returned no targets; falling back to raw search");
+                console.error("Delegated search returned no results; falling back to raw search");
               }
               const fallbackResult = maybeAnnotate(await runRawSearch());
               if (options.fileTracker && typeof fallbackResult === "string") {
@@ -27956,57 +28718,35 @@ Retrying search query variations will not help. Discover real names from real co
             }
             const delegateBase = options.allowedFolders?.[0] || options.cwd || ".";
             const resolutionBase = searchPaths[0] || options.cwd || ".";
-            const resolvedTargets = targets.map((target) => resolveTargetPath(target, delegateBase));
-            const validatedTargets = [];
-            for (const target of resolvedTargets) {
-              const { filePart, suffix } = splitTargetSuffix(target);
-              if ((0, import_fs5.existsSync)(filePart)) {
-                validatedTargets.push(target);
-                continue;
-              }
-              let fixed = false;
-              const parts = filePart.split("/").filter(Boolean);
-              for (let i = 0; i < parts.length - 1; i++) {
-                if (parts[i] === parts[i + 1]) {
-                  const candidate = "/" + [...parts.slice(0, i), ...parts.slice(i + 1)].join("/");
-                  if ((0, import_fs5.existsSync)(candidate)) {
-                    validatedTargets.push(candidate + suffix);
-                    if (debug) console.error(`[search-delegate] Fixed doubled path segment: ${filePart} \u2192 ${candidate}`);
-                    fixed = true;
-                    break;
+            const wsPrefix = resolutionBase.endsWith("/") ? resolutionBase : resolutionBase + "/";
+            for (const group of structured.groups) {
+              group.files = group.files.map((target) => resolveTargetPath(target, delegateBase)).map((target) => {
+                const { filePart, suffix } = splitTargetSuffix(target);
+                if ((0, import_fs5.existsSync)(filePart)) return target;
+                const parts = filePart.split("/").filter(Boolean);
+                for (let i = 0; i < parts.length - 1; i++) {
+                  if (parts[i] === parts[i + 1]) {
+                    const candidate = "/" + [...parts.slice(0, i), ...parts.slice(i + 1)].join("/");
+                    if ((0, import_fs5.existsSync)(candidate)) {
+                      if (debug) console.error(`[search-delegate] Fixed doubled path: ${filePart} \u2192 ${candidate}`);
+                      return candidate + suffix;
+                    }
                   }
                 }
-              }
-              if (fixed) continue;
-              for (const altBase of [resolutionBase, options.cwd].filter(Boolean)) {
-                if (altBase === delegateBase) continue;
-                const altResolved = resolveTargetPath(target, altBase);
-                const { filePart: altFile } = splitTargetSuffix(altResolved);
-                if ((0, import_fs5.existsSync)(altFile)) {
-                  validatedTargets.push(altResolved);
-                  if (debug) console.error(`[search-delegate] Resolved with alt base: ${filePart} \u2192 ${altFile}`);
-                  fixed = true;
-                  break;
+                for (const altBase of [resolutionBase, options.cwd].filter(Boolean)) {
+                  if (altBase === delegateBase) continue;
+                  const altResolved = resolveTargetPath(target, altBase);
+                  const { filePart: altFile } = splitTargetSuffix(altResolved);
+                  if ((0, import_fs5.existsSync)(altFile)) {
+                    if (debug) console.error(`[search-delegate] Resolved with alt base: ${filePart} \u2192 ${altFile}`);
+                    return altResolved;
+                  }
                 }
-              }
-              if (fixed) continue;
-              if (debug) console.error(`[search-delegate] Warning: target may not exist: ${filePart}`);
-              validatedTargets.push(target);
-            }
-            const extractOptions = {
-              files: validatedTargets,
-              cwd: resolutionBase,
-              allowTests: allow_tests ?? true
-            };
-            if (outline) {
-              extractOptions.format = "xml";
+                if (debug) console.error(`[search-delegate] Warning: target may not exist: ${filePart}`);
+                return target;
+              }).map((target) => target.split(wsPrefix).join(""));
             }
-            const extractResult = await extract(extractOptions);
-            if (resolutionBase && typeof extractResult === "string") {
-              const wsPrefix = resolutionBase.endsWith("/") ? resolutionBase : resolutionBase + "/";
-              return maybeAnnotate(extractResult.split(wsPrefix).join(""));
-            }
-            return maybeAnnotate(extractResult);
+            return JSON.stringify(structured, null, 2);
           } catch (error40) {
             console.error("Delegated search failed, falling back to raw search:", error40);
             try {
@@ -49649,7 +50389,10 @@ var init_TaskManager = __esm({
        * @throws {Error} If dependencies are invalid or create a cycle
        */
       createTask(taskData) {
-        const id = this._generateId();
+        const id = taskData.id || this._generateId();
+        if (taskData.id && this.tasks.has(taskData.id)) {
+          throw new Error(`Task ID "${taskData.id}" already exists. Choose a different ID. Available tasks: ${this._getAvailableTaskIds()}`);
+        }
         const now = this._now();
         const dependencies = taskData.dependencies || [];
         for (const depId of dependencies) {
@@ -49717,33 +50460,30 @@ var init_TaskManager = __esm({
             }
           }
         }
-        const idMap = /* @__PURE__ */ new Map();
-        const batchAutoIds = /* @__PURE__ */ new Set();
-        let nextCounter = this.taskCounter;
+        const batchIds = /* @__PURE__ */ new Set();
         for (const taskData of tasksData) {
-          nextCounter++;
-          const autoId = `task-${nextCounter}`;
-          batchAutoIds.add(autoId);
           if (taskData.id) {
-            idMap.set(taskData.id, autoId);
+            if (this.tasks.has(taskData.id)) {
+              throw new Error(`Task ID "${taskData.id}" already exists. Choose a different ID. Available tasks: ${this._getAvailableTaskIds()}`);
+            }
+            if (batchIds.has(taskData.id)) {
+              throw new Error(`Duplicate task ID "${taskData.id}" in batch. Each task must have a unique ID.`);
+            }
+            batchIds.add(taskData.id);
           }
         }
         const resolvedTasksData = tasksData.map((taskData) => {
           const resolved = { ...taskData };
-          delete resolved.id;
           if (resolved.dependencies) {
             resolved.dependencies = resolved.dependencies.map((depId) => {
-              if (idMap.has(depId)) return idMap.get(depId);
-              if (this.tasks.has(depId) || batchAutoIds.has(depId)) return depId;
-              const batchIds = idMap.size > 0 ? Array.from(idMap.keys()).join(", ") : "(none provided)";
-              throw new Error(`Dependency "${depId}" does not exist. Each task in the batch must have an "id" field, and dependencies must reference those IDs. Current batch IDs: ${batchIds}. Existing tasks: ${this._getAvailableTaskIds()}`);
+              if (batchIds.has(depId) || this.tasks.has(depId)) return depId;
+              const knownIds = batchIds.size > 0 ? Array.from(batchIds).join(", ") : "(none provided)";
+              throw new Error(`Dependency "${depId}" does not exist. Each task in the batch must have an "id" field, and dependencies must reference those IDs. Current batch IDs: ${knownIds}. Existing tasks: ${this._getAvailableTaskIds()}`);
             });
           }
           if (resolved.after) {
-            if (idMap.has(resolved.after)) {
-              resolved.after = idMap.get(resolved.after);
-            } else if (!this.tasks.has(resolved.after) && !batchAutoIds.has(resolved.after)) {
-              throw new Error(`Task "${resolved.after}" does not exist. Cannot insert after non-existent task. Available tasks: ${this._getAvailableTaskIds()}${idMap.size > 0 ? `, batch IDs: ${Array.from(idMap.keys()).join(", ")}` : ""}`);
+            if (!batchIds.has(resolved.after) && !this.tasks.has(resolved.after)) {
+              throw new Error(`Task "${resolved.after}" does not exist. Cannot insert after non-existent task. Available tasks: ${this._getAvailableTaskIds()}${batchIds.size > 0 ? `, batch IDs: ${Array.from(batchIds).join(", ")}` : ""}`);
             }
           }
           return resolved;
@@ -98133,14 +98873,11 @@ function buildFallbackProvidersFromEnv(options = {}) {
   }
   return providers;
 }
-var import_anthropic, import_openai, import_google, FALLBACK_STRATEGIES, DEFAULT_MODELS, FallbackManager;
+var FALLBACK_STRATEGIES, DEFAULT_MODELS2, FallbackManager;
 var init_FallbackManager = __esm({
   "src/agent/FallbackManager.js"() {
     "use strict";
-    import_anthropic = require("@ai-sdk/anthropic");
-    import_openai = require("@ai-sdk/openai");
-    import_google = require("@ai-sdk/google");
-    init_dist3();
+    init_provider();
     FALLBACK_STRATEGIES = {
       SAME_MODEL: "same-model",
       // Try same model on different providers
@@ -98151,12 +98888,7 @@ var init_FallbackManager = __esm({
       CUSTOM: "custom"
       // Use custom provider list
     };
-    DEFAULT_MODELS = {
-      anthropic: "claude-sonnet-4-6",
-      openai: "gpt-5.2",
-      google: "gemini-2.5-flash",
-      bedrock: "anthropic.claude-sonnet-4-6"
-    };
+    DEFAULT_MODELS2 = DEFAULT_MODELS;
     FallbackManager = class {
       /**
        * Create a new FallbackManager
@@ -98229,45 +98961,7 @@ var init_FallbackManager = __esm({
        */
       _createProviderInstance(config2) {
         try {
-          switch (config2.provider) {
-            case "anthropic":
-              return (0, import_anthropic.createAnthropic)({
-                apiKey: config2.apiKey,
-                ...config2.baseURL && { baseURL: config2.baseURL }
-              });
-            case "openai":
-              return (0, import_openai.createOpenAI)({
-                compatibility: "strict",
-                apiKey: config2.apiKey,
-                ...config2.baseURL && { baseURL: config2.baseURL }
-              });
-            case "google":
-              return (0, import_google.createGoogleGenerativeAI)({
-                apiKey: config2.apiKey,
-                ...config2.baseURL && { baseURL: config2.baseURL }
-              });
-            case "bedrock": {
-              const bedrockConfig = {};
-              if (config2.apiKey) {
-                bedrockConfig.apiKey = config2.apiKey;
-              } else if (config2.accessKeyId && config2.secretAccessKey) {
-                bedrockConfig.accessKeyId = config2.accessKeyId;
-                bedrockConfig.secretAccessKey = config2.secretAccessKey;
-                if (config2.sessionToken) {
-                  bedrockConfig.sessionToken = config2.sessionToken;
-                }
-              }
-              if (config2.region) {
-                bedrockConfig.region = config2.region;
-              }
-              if (config2.baseURL) {
-                bedrockConfig.baseURL = config2.baseURL;
-              }
-              return createAmazonBedrock(bedrockConfig);
-            }
-            default:
-              throw new Error(`FallbackManager: Unknown provider "${config2.provider}"`);
-          }
+          return createProviderInstance(config2);
         } catch (error40) {
           const providerName = this._getProviderDisplayName(config2);
           throw new Error(`Failed to create provider instance for ${providerName}: ${error40.message}`);
@@ -98280,7 +98974,7 @@ var init_FallbackManager = __esm({
        * @private
        */
       _getModelName(config2) {
-        return config2.model || DEFAULT_MODELS[config2.provider];
+        return config2.model || DEFAULT_MODELS2[config2.provider];
       }
       /**
        * Get provider display name for logging
@@ -100197,14 +100891,11 @@ function debugLogToolResults(toolResults) {
     console.log(`[DEBUG]   tool: ${tr.toolName} | args: ${debugTruncate(argsStr)} | result: ${debugTruncate(resultStr)}`);
   }
 }
-var import_dotenv2, import_anthropic2, import_openai2, import_google2, import_ai6, import_crypto9, import_events4, import_fs15, import_promises6, import_path18, ENGINE_ACTIVITY_TIMEOUT_DEFAULT, ENGINE_ACTIVITY_TIMEOUT_MIN, ENGINE_ACTIVITY_TIMEOUT_MAX, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
+var import_dotenv2, import_ai6, import_crypto9, import_events4, import_fs15, import_promises6, import_path18, ENGINE_ACTIVITY_TIMEOUT_DEFAULT, ENGINE_ACTIVITY_TIMEOUT_MIN, ENGINE_ACTIVITY_TIMEOUT_MAX, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
     import_dotenv2 = __toESM(require_main(), 1);
-    import_anthropic2 = require("@ai-sdk/anthropic");
-    import_openai2 = require("@ai-sdk/openai");
-    import_google2 = require("@ai-sdk/google");
-    init_dist3();
+    init_provider();
     import_ai6 = require("ai");
     import_crypto9 = require("crypto");
     import_events4 = require("events");
@@ -101443,11 +102134,8 @@ var init_ProbeAgent = __esm({
        * Initialize Anthropic model
        */
       initializeAnthropicModel(apiKey, apiUrl, modelName) {
-        this.provider = (0, import_anthropic2.createAnthropic)({
-          apiKey,
-          ...apiUrl && { baseURL: apiUrl }
-        });
-        this.model = modelName || "claude-sonnet-4-6";
+        this.provider = createProviderInstance({ provider: "anthropic", apiKey, ...apiUrl && { baseURL: apiUrl } });
+        this.model = modelName || DEFAULT_MODELS.anthropic;
         this.apiType = "anthropic";
         if (this.debug) {
           console.log(`Using Anthropic API with model: ${this.model}${apiUrl ? ` (URL: ${apiUrl})` : ""}`);
@@ -101457,12 +102145,8 @@ var init_ProbeAgent = __esm({
        * Initialize OpenAI model
        */
       initializeOpenAIModel(apiKey, apiUrl, modelName) {
-        this.provider = (0, import_openai2.createOpenAI)({
-          compatibility: "strict",
-          apiKey,
-          ...apiUrl && { baseURL: apiUrl }
-        });
-        this.model = modelName || "gpt-5.2";
+        this.provider = createProviderInstance({ provider: "openai", apiKey, ...apiUrl && { baseURL: apiUrl } });
+        this.model = modelName || DEFAULT_MODELS.openai;
         this.apiType = "openai";
         if (this.debug) {
           console.log(`Using OpenAI API with model: ${this.model}${apiUrl ? ` (URL: ${apiUrl})` : ""}`);
@@ -101472,10 +102156,7 @@ var init_ProbeAgent = __esm({
        * Initialize Google model
        */
       initializeGoogleModel(apiKey, apiUrl, modelName) {
-        this.provider = (0, import_google2.createGoogleGenerativeAI)({
-          apiKey,
-          ...apiUrl && { baseURL: apiUrl }
-        });
+        this.provider = createProviderInstance({ provider: "google", apiKey, ...apiUrl && { baseURL: apiUrl } });
         this.model = modelName || "gemini-2.5-pro";
         this.apiType = "google";
         if (this.debug) {
@@ -101919,24 +102600,16 @@ var init_ProbeAgent = __esm({
        * Initialize AWS Bedrock model
        */
       initializeBedrockModel(accessKeyId, secretAccessKey, region, sessionToken, apiKey, baseURL, modelName) {
-        const config2 = {};
-        if (apiKey) {
-          config2.apiKey = apiKey;
-        } else if (accessKeyId && secretAccessKey) {
-          config2.accessKeyId = accessKeyId;
-          config2.secretAccessKey = secretAccessKey;
-          if (sessionToken) {
-            config2.sessionToken = sessionToken;
-          }
-        }
-        if (region) {
-          config2.region = region;
-        }
-        if (baseURL) {
-          config2.baseURL = baseURL;
-        }
-        this.provider = createAmazonBedrock(config2);
-        this.model = modelName || "anthropic.claude-sonnet-4-6";
+        this.provider = createProviderInstance({
+          provider: "bedrock",
+          apiKey,
+          accessKeyId,
+          secretAccessKey,
+          sessionToken,
+          region,
+          baseURL
+        });
+        this.model = modelName || DEFAULT_MODELS.bedrock;
         this.apiType = "bedrock";
         if (this.debug) {
           const authMethod = apiKey ? "API Key" : "AWS Credentials";
@@ -102519,7 +103192,7 @@ ${this.architectureContext.content}
         } else {
           systemPrompt += predefinedPrompts["code-explorer"] + "\n\n";
         }
-        const searchToolDesc1 = this.searchDelegate ? '- search: Ask natural language questions to find code (e.g., "How does authentication work?"). A subagent handles keyword searches and returns extracted code blocks. Do NOT formulate keyword queries \u2014 just ask questions.' : "- search: Find code patterns using keyword queries with Elasticsearch syntax. Handles stemming and case variations automatically \u2014 do NOT try manual keyword variations.";
+        const searchToolDesc1 = this.searchDelegate ? '- search: Ask natural language questions to find code locations (e.g., "How does authentication work?"). Returns structured JSON with file locations grouped by relevance. Use extract() on the returned files to read the actual code. Do NOT formulate keyword queries \u2014 just ask questions.' : "- search: Find code patterns using keyword queries with Elasticsearch syntax. Handles stemming and case variations automatically \u2014 do NOT try manual keyword variations.";
         systemPrompt += `You have access to powerful code search and analysis tools through MCP:
 ${searchToolDesc1}
 - extract: Extract specific code sections with context
@@ -102529,8 +103202,8 @@ ${searchToolDesc1}
           systemPrompt += `
 - bash: Execute bash commands for system operations (building, running tests, git, etc.). NEVER use bash for code exploration (no grep, cat, find, head, tail) \u2014 always use search and extract tools instead, they are faster and more accurate.`;
         }
-        const searchGuidance1 = this.searchDelegate ? "1. Start with search \u2014 ask a question about what you want to understand. It returns extracted code blocks directly." : "1. Start with search to find relevant code patterns. One search per concept is usually enough \u2014 probe handles stemming and case variations.";
-        const extractGuidance1 = this.searchDelegate ? "2. Use extract only if you need more context or a full file" : "2. Use extract to get detailed context when needed";
+        const searchGuidance1 = this.searchDelegate ? "1. Start with search \u2014 ask a question about what you want to understand. It returns file locations grouped by relevance (JSON with confidence and groups)." : "1. Start with search to find relevant code patterns. One search per concept is usually enough \u2014 probe handles stemming and case variations.";
+        const extractGuidance1 = this.searchDelegate ? '2. Use extract on the file locations returned by search to read the actual code. Each group has a "reason" explaining why those files matter.' : "2. Use extract to get detailed context when needed";
         systemPrompt += `
 
 When exploring code:
@@ -102574,7 +103247,7 @@ Workspace: ${this.allowedFolders.join(", ")}`;
         } else {
           systemPrompt += predefinedPrompts["code-explorer"] + "\n\n";
         }
-        const searchToolDesc2 = this.searchDelegate ? '- search: Ask natural language questions to find code (e.g., "How does authentication work?"). A subagent handles keyword searches and returns extracted code blocks. Do NOT formulate keyword queries \u2014 just ask questions.' : "- search: Find code patterns using keyword queries with Elasticsearch syntax. Handles stemming and case variations automatically \u2014 do NOT try manual keyword variations.";
+        const searchToolDesc2 = this.searchDelegate ? '- search: Ask natural language questions to find code locations (e.g., "How does authentication work?"). Returns structured JSON with file locations grouped by relevance. Use extract() on the returned files to read the actual code. Do NOT formulate keyword queries \u2014 just ask questions.' : "- search: Find code patterns using keyword queries with Elasticsearch syntax. Handles stemming and case variations automatically \u2014 do NOT try manual keyword variations.";
         systemPrompt += `You have access to powerful code search and analysis tools through MCP:
 ${searchToolDesc2}
 - extract: Extract specific code sections with context
@@ -102584,8 +103257,8 @@ ${searchToolDesc2}
           systemPrompt += `
 - bash: Execute bash commands for system operations (building, running tests, git, etc.). NEVER use bash for code exploration (no grep, cat, find, head, tail) \u2014 always use search and extract tools instead, they are faster and more accurate.`;
         }
-        const searchGuidance2 = this.searchDelegate ? "1. Start with search \u2014 ask a question about what you want to understand. It returns extracted code blocks directly." : "1. Start with search to find relevant code patterns. One search per concept is usually enough \u2014 probe handles stemming and case variations.";
-        const extractGuidance2 = this.searchDelegate ? "2. Use extract only if you need more context or a full file" : "2. Use extract to get detailed context when needed";
+        const searchGuidance2 = this.searchDelegate ? "1. Start with search \u2014 ask a question about what you want to understand. It returns file locations grouped by relevance (JSON with confidence and groups)." : "1. Start with search to find relevant code patterns. One search per concept is usually enough \u2014 probe handles stemming and case variations.";
+        const extractGuidance2 = this.searchDelegate ? '2. Use extract on the file locations returned by search to read the actual code. Each group has a "reason" explaining why those files matter.' : "2. Use extract to get detailed context when needed";
         systemPrompt += `
 
 When exploring code:
@@ -102645,10 +103318,10 @@ Workspace: ${this.allowedFolders.join(", ")}`;
 Follow these instructions carefully:
 1. Analyze the user's request.
 2. Use the available tools step-by-step to fulfill the request.
-3. You MUST use the search tool before answering ANY code-related question. NEVER answer from memory or general knowledge \u2014 your answers must be grounded in actual code found via search/extract.${this.searchDelegate ? " Ask natural language questions \u2014 the search subagent handles keyword formulation and returns extracted code blocks. Use extract only to expand context or read full files." : " Search handles stemming and case variations automatically \u2014 do NOT try keyword variations manually. Read full files only if really necessary."}
+3. You MUST use the search tool before answering ANY code-related question. NEVER answer from memory or general knowledge \u2014 your answers must be grounded in actual code found via search/extract.${this.searchDelegate ? " Ask natural language questions \u2014 the search subagent handles keyword formulation and returns file locations grouped by relevance. Then use extract() on those locations to read the actual code." : " Search handles stemming and case variations automatically \u2014 do NOT try keyword variations manually. Read full files only if really necessary."}
 4. Ensure to get really deep and understand the full picture before answering. Follow call chains \u2014 if function A calls B, search for B too. Look for related subsystems (e.g., if asked about rate limiting, also check for quota, throttling, smoothing).
 5. Once the task is fully completed, provide your final answer directly as text. Always cite specific files and line numbers as evidence. Do NOT output planning or thinking text \u2014 go straight to the answer.
-6. ${this.searchDelegate ? "Ask clear, specific questions when searching. Each search should target a distinct concept or question." : "Prefer concise and focused search queries. Use specific keywords and phrases to narrow down results."}
+6. ${this.searchDelegate ? 'Ask clear, specific questions when searching. Each search should target a distinct concept or question. NEVER re-search the same concept with different phrasing \u2014 if you already searched for "wrapToolWithEmitter", do NOT search again for "definition of wrapToolWithEmitter" or "how wrapToolWithEmitter works". Use extract() on the files already found instead. Limit yourself to one search per distinct concept. When formulating queries, describe WHAT you are looking for, not WHERE \u2014 the search agent will search the full codebase. Do NOT include file names or class names in the query unless that IS the concept (e.g., say "search dedup logic" not "search dedup ProbeAgent").' : "Prefer concise and focused search queries. Use specific keywords and phrases to narrow down results."}
 7. NEVER use bash for code exploration (no grep, cat, find, head, tail, awk, sed) \u2014 always use search and extract tools instead. Bash is only for system operations like building, running tests, or git commands.${this.allowEdit ? `
 7. When modifying files, choose the appropriate tool:
     - Use 'edit' for all code modifications:
@@ -103375,9 +104048,11 @@ Provide your BEST answer NOW using the information you have already gathered. Do
                     const searchesTried = _toolCallLog.filter((tc) => tc.name === "search").map((tc) => `"${tc.args.query || ""}"${tc.args.exact ? " (exact)" : ""}`).filter((v, i, a) => a.indexOf(v) === i);
                     const searchSummary = searchesTried.length > 0 ? `
 Searches attempted: ${searchesTried.join(", ")}` : "";
+                    const isCodeSearcher = this.promptType === "code-searcher";
+                    const lastIterMessage = isCodeSearcher ? `\u26A0\uFE0F LAST ITERATION \u2014 you are out of tool calls. Output your JSON response NOW with whatever files you have verified so far. Set confidence to "low" if your search was incomplete. Include the "searches" array listing all search queries you made with their paths and outcomes.${searchSummary}` : `\u26A0\uFE0F LAST ITERATION \u2014 you are out of tool calls. Provide your BEST answer NOW with the information gathered so far. If you could not find what was requested, explain exactly what you searched for and why it did not work, so the caller can try a different approach.${searchSummary}`;
                     return {
                       toolChoice: "none",
-                      userMessage: `\u26A0\uFE0F LAST ITERATION \u2014 you are out of tool calls. Provide your BEST answer NOW with the information gathered so far. If you could not find what was requested, explain exactly what you searched for and why it did not work, so the caller can try a different approach.${searchSummary}`
+                      userMessage: lastIterMessage
                     };
                   }
                   if (steps.length >= 2) {
@@ -103912,29 +104587,41 @@ Be thorough \u2014 this is the user's only response. Include all useful informat
             if (!finalResult || finalResult === DEFAULT_MAX_ITER_MSG) {
               try {
                 const searchQueries = [];
+                const searchDetails = [];
                 const toolCounts = {};
                 for (const tc of _toolCallLog) {
                   toolCounts[tc.name] = (toolCounts[tc.name] || 0) + 1;
                   if (tc.name === "search") {
                     const q = tc.args.query || "";
+                    const p = tc.args.path || ".";
                     const exact = tc.args.exact ? " (exact)" : "";
                     searchQueries.push(`"${q}"${exact}`);
+                    searchDetails.push({ query: q, path: p, had_results: false });
                   }
                 }
                 const toolBreakdown = Object.entries(toolCounts).map(([name15, count]) => `${name15}: ${count}x`).join(", ");
                 const uniqueSearches = [...new Set(searchQueries)];
-                let summary = `I was unable to complete your request after ${currentIteration} tool iterations.
+                if (this.promptType === "code-searcher") {
+                  finalResult = JSON.stringify({
+                    confidence: "low",
+                    reason: "Search incomplete \u2014 iteration limit reached",
+                    groups: [],
+                    searches: searchDetails
+                  });
+                } else {
+                  let summary = `I was unable to complete your request after ${currentIteration} tool iterations.
 
 `;
-                summary += `Tool calls made: ${toolBreakdown || "none"}
+                  summary += `Tool calls made: ${toolBreakdown || "none"}
 `;
-                if (uniqueSearches.length > 0) {
-                  summary += `Search queries tried: ${uniqueSearches.join(", ")}
+                  if (uniqueSearches.length > 0) {
+                    summary += `Search queries tried: ${uniqueSearches.join(", ")}
 `;
-                }
-                summary += `
+                  }
+                  summary += `
 The search approach may be fundamentally wrong for this query. Consider: using exact=true for literal string matching, using bash/grep for pattern-based file searches, or trying a completely different strategy instead of repeating similar searches.`;
-                finalResult = summary;
+                  finalResult = summary;
+                }
               } catch {
                 finalResult = DEFAULT_MAX_ITER_MSG;
               }