@probelabs/probe 0.6.0-rc299 → 0.6.0-rc301

package/cjs/index.cjs

@@ -25877,229 +25877,805 @@ var init_tokenCounter = __esm({
   }
 });
 
-// src/agent/storage/StorageAdapter.js
-var StorageAdapter;
-var init_StorageAdapter = __esm({
-  "src/agent/storage/StorageAdapter.js"() {
-    "use strict";
-    StorageAdapter = class {
-      /**
-       * Load conversation history for a session
-       * @param {string} sessionId - Session identifier
-       * @returns {Promise<Array<Object>>} Array of message objects with {role, content, ...}
-       */
-      async loadHistory(sessionId) {
-        throw new Error("StorageAdapter.loadHistory() must be implemented by subclass");
-      }
-      /**
-       * Save a message to storage
-       * @param {string} sessionId - Session identifier
-       * @param {Object} message - Message object { role, content, ... }
-       * @returns {Promise<void>}
-       */
-      async saveMessage(sessionId, message) {
-        throw new Error("StorageAdapter.saveMessage() must be implemented by subclass");
-      }
-      /**
-       * Clear history for a session
-       * @param {string} sessionId - Session identifier
-       * @returns {Promise<void>}
-       */
-      async clearHistory(sessionId) {
-        throw new Error("StorageAdapter.clearHistory() must be implemented by subclass");
+// src/agent/otelLogBridge.js
+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;
       }
-      /**
-       * Get session metadata (optional)
-       * @param {string} sessionId - Session identifier
-       * @returns {Promise<Object|null>} Session metadata or null
-       */
-      async getSessionMetadata(sessionId) {
-        return null;
+    }
+    logger.emit({
+      severityNumber: OTEL_SEVERITY[level] || 9,
+      severityText: level.toUpperCase(),
+      body: msg,
+      attributes: {
+        "probe.logger": true,
+        ...traceId ? { trace_id: traceId, span_id: spanId } : {}
       }
-      /**
-       * Update session activity timestamp (optional)
-       * @param {string} sessionId - Session identifier
-       * @returns {Promise<void>}
-       */
-      async updateSessionActivity(sessionId) {
+    });
+  } 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/storage/InMemoryStorageAdapter.js
-var InMemoryStorageAdapter;
-var init_InMemoryStorageAdapter = __esm({
-  "src/agent/storage/InMemoryStorageAdapter.js"() {
+// src/agent/simpleTelemetry.js
+function truncateForSpan(text, maxLen = 4096) {
+  if (!text || text.length <= maxLen) return text || "";
+  const half = Math.floor((maxLen - 40) / 2);
+  const omitted = text.length - half * 2;
+  return text.substring(0, half) + `
+... [${omitted} chars omitted] ...
+` + text.substring(text.length - half);
+}
+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_fs4, import_path5, SimpleTelemetry, SimpleAppTracer;
+var init_simpleTelemetry = __esm({
+  "src/agent/simpleTelemetry.js"() {
     "use strict";
-    init_StorageAdapter();
-    InMemoryStorageAdapter = class extends StorageAdapter {
-      constructor() {
-        super();
-        this.sessions = /* @__PURE__ */ new Map();
+    import_fs4 = require("fs");
+    import_path5 = 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();
+        }
       }
-      async loadHistory(sessionId) {
-        const session = this.sessions.get(sessionId);
-        return session ? session.messages : [];
+      initializeFileExporter() {
+        try {
+          const dir = (0, import_path5.dirname)(this.filePath);
+          if (!(0, import_fs4.existsSync)(dir)) {
+            (0, import_fs4.mkdirSync)(dir, { recursive: true });
+          }
+          this.stream = (0, import_fs4.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}`);
+        }
       }
-      async saveMessage(sessionId, message) {
-        if (!this.sessions.has(sessionId)) {
-          this.sessions.set(sessionId, {
-            messages: [],
-            metadata: {
-              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-              lastActivity: (/* @__PURE__ */ new Date()).toISOString()
+      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();
             }
           });
         }
-        const session = this.sessions.get(sessionId);
-        session.messages.push(message);
-        session.metadata.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
       }
-      async clearHistory(sessionId) {
-        this.sessions.delete(sessionId);
+      async shutdown() {
+        if (this.stream) {
+          return new Promise((resolve9) => {
+            this.stream.end(() => {
+              console.log(`[SimpleTelemetry] File stream closed: ${this.filePath}`);
+              resolve9();
+            });
+          });
+        }
       }
-      async getSessionMetadata(sessionId) {
-        const session = this.sessions.get(sessionId);
-        return session ? session.metadata : null;
+    };
+    SimpleAppTracer = class {
+      constructor(telemetry, sessionId = null) {
+        this.telemetry = telemetry;
+        this.sessionId = sessionId || this.generateSessionId();
       }
-      async updateSessionActivity(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (session) {
-          session.metadata.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+      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);
         }
       }
-    };
-  }
-});
-
-// src/agent/hooks/HookManager.js
-var HookManager, HOOK_TYPES;
-var init_HookManager = __esm({
-  "src/agent/hooks/HookManager.js"() {
-    "use strict";
-    HookManager = class {
-      constructor() {
-        this.hooks = /* @__PURE__ */ new Map();
+      /**
+       * 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
+        });
       }
       /**
-       * Register a hook callback
-       * @param {string} hookName - Name of the hook
-       * @param {Function} callback - Callback function
-       * @returns {Function} Unregister function
+       * Record delegation events
        */
-      on(hookName, callback) {
-        if (!this.hooks.has(hookName)) {
-          this.hooks.set(hookName, /* @__PURE__ */ new Set());
-        }
-        this.hooks.get(hookName).add(callback);
-        return () => this.off(hookName, callback);
+      recordDelegationEvent(eventType, data2 = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`delegation.${eventType}`, {
+          "session.id": this.sessionId,
+          ...data2
+        });
       }
       /**
-       * Register a one-time hook callback
-       * @param {string} hookName - Name of the hook
-       * @param {Function} callback - Callback function
-       * @returns {Function} Unregister function
+       * Record JSON validation events
        */
-      once(hookName, callback) {
-        const wrappedCallback = async (data2) => {
-          this.off(hookName, wrappedCallback);
-          await callback(data2);
-        };
-        return this.on(hookName, wrappedCallback);
+      recordJsonValidationEvent(eventType, data2 = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`json_validation.${eventType}`, {
+          "session.id": this.sessionId,
+          ...data2
+        });
       }
       /**
-       * Unregister a hook callback
-       * @param {string} hookName - Name of the hook
-       * @param {Function} callback - Callback function
+       * Record Mermaid validation events
        */
-      off(hookName, callback) {
-        const callbacks = this.hooks.get(hookName);
-        if (callbacks) {
-          callbacks.delete(callback);
-        }
+      recordMermaidValidationEvent(eventType, data2 = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`mermaid_validation.${eventType}`, {
+          "session.id": this.sessionId,
+          ...data2
+        });
       }
       /**
-       * Emit a hook event
-       * @param {string} hookName - Name of the hook
-       * @param {any} data - Data to pass to callbacks
-       * @returns {Promise<void>}
+       * Record task management events
        */
-      async emit(hookName, data2) {
-        const callbacks = this.hooks.get(hookName);
-        if (!callbacks || callbacks.size === 0) return;
-        const promises = Array.from(callbacks).map((callback) => {
-          try {
-            return Promise.resolve(callback(data2));
-          } catch (error40) {
-            return Promise.reject(error40);
-          }
+      recordTaskEvent(eventType, data2 = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`task.${eventType}`, {
+          "session.id": this.sessionId,
+          ...data2
         });
-        const results = await Promise.allSettled(promises);
-        results.forEach((result, index) => {
-          if (result.status === "rejected") {
-            console.error(`[HookManager] Error in hook "${hookName}" (callback ${index + 1}):`, result.reason);
-          }
+      }
+      /**
+       * 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
         });
       }
       /**
-       * Clear all hooks or hooks for a specific event
-       * @param {string} [hookName] - Optional hook name to clear
+       * Record bash tool events
+       * Tracks command permission checks, allowed/denied commands, and execution
        */
-      clear(hookName) {
-        if (hookName) {
-          this.hooks.delete(hookName);
-        } else {
-          this.hooks.clear();
+      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);
         }
       }
       /**
-       * Get list of registered hook names
-       * @returns {string[]} Array of hook names
+       * Hash content for deduplication/comparison purposes
+       * @param {string} content - The content to hash
+       * @returns {string} - Hex string hash
        */
-      getHookNames() {
-        return Array.from(this.hooks.keys());
+      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);
       }
       /**
-       * Get number of callbacks for a hook
-       * @param {string} hookName - Name of the hook
-       * @returns {number} Number of callbacks
+       * 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
        */
-      getCallbackCount(hookName) {
-        const callbacks = this.hooks.get(hookName);
-        return callbacks ? callbacks.size : 0;
+      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
+        });
       }
-    };
-    HOOK_TYPES = {
-      // Lifecycle hooks
-      AGENT_INITIALIZED: "agent:initialized",
-      AGENT_CLEANUP: "agent:cleanup",
-      // Message hooks
-      MESSAGE_USER: "message:user",
-      MESSAGE_ASSISTANT: "message:assistant",
-      MESSAGE_SYSTEM: "message:system",
-      // Tool execution hooks
-      TOOL_START: "tool:start",
-      TOOL_END: "tool:end",
-      TOOL_ERROR: "tool:error",
-      // AI streaming hooks
-      AI_STREAM_START: "ai:stream:start",
-      AI_STREAM_DELTA: "ai:stream:delta",
-      AI_STREAM_END: "ai:stream:end",
-      // Storage hooks
-      STORAGE_LOAD: "storage:load",
-      STORAGE_SAVE: "storage:save",
-      STORAGE_CLEAR: "storage:clear",
-      // Iteration hooks
-      ITERATION_START: "iteration:start",
-      ITERATION_END: "iteration:end"
-    };
-  }
-});
-
-// src/agent/imageConfig.js
-function isFormatSupportedByProvider(extension, provider) {
-  if (!extension || typeof extension !== "string") {
+      /**
+       * 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();
+        }
+      }
+    };
+  }
+});
+
+// src/agent/storage/StorageAdapter.js
+var StorageAdapter;
+var init_StorageAdapter = __esm({
+  "src/agent/storage/StorageAdapter.js"() {
+    "use strict";
+    StorageAdapter = class {
+      /**
+       * Load conversation history for a session
+       * @param {string} sessionId - Session identifier
+       * @returns {Promise<Array<Object>>} Array of message objects with {role, content, ...}
+       */
+      async loadHistory(sessionId) {
+        throw new Error("StorageAdapter.loadHistory() must be implemented by subclass");
+      }
+      /**
+       * Save a message to storage
+       * @param {string} sessionId - Session identifier
+       * @param {Object} message - Message object { role, content, ... }
+       * @returns {Promise<void>}
+       */
+      async saveMessage(sessionId, message) {
+        throw new Error("StorageAdapter.saveMessage() must be implemented by subclass");
+      }
+      /**
+       * Clear history for a session
+       * @param {string} sessionId - Session identifier
+       * @returns {Promise<void>}
+       */
+      async clearHistory(sessionId) {
+        throw new Error("StorageAdapter.clearHistory() must be implemented by subclass");
+      }
+      /**
+       * Get session metadata (optional)
+       * @param {string} sessionId - Session identifier
+       * @returns {Promise<Object|null>} Session metadata or null
+       */
+      async getSessionMetadata(sessionId) {
+        return null;
+      }
+      /**
+       * Update session activity timestamp (optional)
+       * @param {string} sessionId - Session identifier
+       * @returns {Promise<void>}
+       */
+      async updateSessionActivity(sessionId) {
+      }
+    };
+  }
+});
+
+// src/agent/storage/InMemoryStorageAdapter.js
+var InMemoryStorageAdapter;
+var init_InMemoryStorageAdapter = __esm({
+  "src/agent/storage/InMemoryStorageAdapter.js"() {
+    "use strict";
+    init_StorageAdapter();
+    InMemoryStorageAdapter = class extends StorageAdapter {
+      constructor() {
+        super();
+        this.sessions = /* @__PURE__ */ new Map();
+      }
+      async loadHistory(sessionId) {
+        const session = this.sessions.get(sessionId);
+        return session ? session.messages : [];
+      }
+      async saveMessage(sessionId, message) {
+        if (!this.sessions.has(sessionId)) {
+          this.sessions.set(sessionId, {
+            messages: [],
+            metadata: {
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              lastActivity: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          });
+        }
+        const session = this.sessions.get(sessionId);
+        session.messages.push(message);
+        session.metadata.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      async clearHistory(sessionId) {
+        this.sessions.delete(sessionId);
+      }
+      async getSessionMetadata(sessionId) {
+        const session = this.sessions.get(sessionId);
+        return session ? session.metadata : null;
+      }
+      async updateSessionActivity(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+          session.metadata.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+        }
+      }
+    };
+  }
+});
+
+// src/agent/hooks/HookManager.js
+var HookManager, HOOK_TYPES;
+var init_HookManager = __esm({
+  "src/agent/hooks/HookManager.js"() {
+    "use strict";
+    HookManager = class {
+      constructor() {
+        this.hooks = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Register a hook callback
+       * @param {string} hookName - Name of the hook
+       * @param {Function} callback - Callback function
+       * @returns {Function} Unregister function
+       */
+      on(hookName, callback) {
+        if (!this.hooks.has(hookName)) {
+          this.hooks.set(hookName, /* @__PURE__ */ new Set());
+        }
+        this.hooks.get(hookName).add(callback);
+        return () => this.off(hookName, callback);
+      }
+      /**
+       * Register a one-time hook callback
+       * @param {string} hookName - Name of the hook
+       * @param {Function} callback - Callback function
+       * @returns {Function} Unregister function
+       */
+      once(hookName, callback) {
+        const wrappedCallback = async (data2) => {
+          this.off(hookName, wrappedCallback);
+          await callback(data2);
+        };
+        return this.on(hookName, wrappedCallback);
+      }
+      /**
+       * Unregister a hook callback
+       * @param {string} hookName - Name of the hook
+       * @param {Function} callback - Callback function
+       */
+      off(hookName, callback) {
+        const callbacks = this.hooks.get(hookName);
+        if (callbacks) {
+          callbacks.delete(callback);
+        }
+      }
+      /**
+       * Emit a hook event
+       * @param {string} hookName - Name of the hook
+       * @param {any} data - Data to pass to callbacks
+       * @returns {Promise<void>}
+       */
+      async emit(hookName, data2) {
+        const callbacks = this.hooks.get(hookName);
+        if (!callbacks || callbacks.size === 0) return;
+        const promises = Array.from(callbacks).map((callback) => {
+          try {
+            return Promise.resolve(callback(data2));
+          } catch (error40) {
+            return Promise.reject(error40);
+          }
+        });
+        const results = await Promise.allSettled(promises);
+        results.forEach((result, index) => {
+          if (result.status === "rejected") {
+            console.error(`[HookManager] Error in hook "${hookName}" (callback ${index + 1}):`, result.reason);
+          }
+        });
+      }
+      /**
+       * Clear all hooks or hooks for a specific event
+       * @param {string} [hookName] - Optional hook name to clear
+       */
+      clear(hookName) {
+        if (hookName) {
+          this.hooks.delete(hookName);
+        } else {
+          this.hooks.clear();
+        }
+      }
+      /**
+       * Get list of registered hook names
+       * @returns {string[]} Array of hook names
+       */
+      getHookNames() {
+        return Array.from(this.hooks.keys());
+      }
+      /**
+       * Get number of callbacks for a hook
+       * @param {string} hookName - Name of the hook
+       * @returns {number} Number of callbacks
+       */
+      getCallbackCount(hookName) {
+        const callbacks = this.hooks.get(hookName);
+        return callbacks ? callbacks.size : 0;
+      }
+    };
+    HOOK_TYPES = {
+      // Lifecycle hooks
+      AGENT_INITIALIZED: "agent:initialized",
+      AGENT_CLEANUP: "agent:cleanup",
+      // Message hooks
+      MESSAGE_USER: "message:user",
+      MESSAGE_ASSISTANT: "message:assistant",
+      MESSAGE_SYSTEM: "message:system",
+      // Tool execution hooks
+      TOOL_START: "tool:start",
+      TOOL_END: "tool:end",
+      TOOL_ERROR: "tool:error",
+      // AI streaming hooks
+      AI_STREAM_START: "ai:stream:start",
+      AI_STREAM_DELTA: "ai:stream:delta",
+      AI_STREAM_END: "ai:stream:end",
+      // Storage hooks
+      STORAGE_LOAD: "storage:load",
+      STORAGE_SAVE: "storage:save",
+      STORAGE_CLEAR: "storage:clear",
+      // Iteration hooks
+      ITERATION_START: "iteration:start",
+      ITERATION_END: "iteration:end"
+    };
+  }
+});
+
+// src/agent/imageConfig.js
+function isFormatSupportedByProvider(extension, provider) {
+  if (!extension || typeof extension !== "string") {
     return false;
   }
   if (extension.includes("/") || extension.includes("\\") || extension.includes("..")) {
@@ -27105,8 +27681,8 @@ function parseAndResolvePaths(pathStr, cwd) {
   if (/["']/.test(pathStr)) {
     const paths2 = splitQuotedString(pathStr);
     return paths2.map((p) => {
-      if ((0, import_path5.isAbsolute)(p)) return p;
-      return cwd ? (0, import_path5.resolve)(cwd, p) : p;
+      if ((0, import_path6.isAbsolute)(p)) return p;
+      return cwd ? (0, import_path6.resolve)(cwd, p) : p;
     });
   }
   let paths = pathStr.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
@@ -27118,8 +27694,8 @@ function parseAndResolvePaths(pathStr, cwd) {
     return allLookLikePaths ? parts : [p];
   });
   return paths.map((p) => {
-    if ((0, import_path5.isAbsolute)(p)) return p;
-    return cwd ? (0, import_path5.resolve)(cwd, p) : p;
+    if ((0, import_path6.isAbsolute)(p)) return p;
+    return cwd ? (0, import_path6.resolve)(cwd, p) : p;
   });
 }
 function resolveTargetPath(target, cwd) {
@@ -27137,17 +27713,17 @@ function resolveTargetPath(target, cwd) {
     filePart = target;
     suffix = "";
   }
-  if (!(0, import_path5.isAbsolute)(filePart) && cwd) {
-    filePart = (0, import_path5.resolve)(cwd, filePart);
+  if (!(0, import_path6.isAbsolute)(filePart) && cwd) {
+    filePart = (0, import_path6.resolve)(cwd, filePart);
   }
   return filePart + suffix;
 }
-var import_path5, searchSchema, searchAllSchema, querySchema, extractSchema, delegateSchema, listSkillsSchema, useSkillSchema, listFilesSchema, searchFilesSchema, readImageSchema, bashSchema, analyzeAllSchema, executePlanSchema, cleanupExecutePlanSchema, searchDescription, searchDelegateDescription, queryDescription, extractDescription, delegateDescription, bashDescription, analyzeAllDescription;
+var import_path6, searchSchema, searchAllSchema, querySchema, extractSchema, delegateSchema, listSkillsSchema, useSkillSchema, listFilesSchema, searchFilesSchema, readImageSchema, bashSchema, analyzeAllSchema, executePlanSchema, cleanupExecutePlanSchema, searchDescription, searchDelegateDescription, queryDescription, extractDescription, delegateDescription, bashDescription, analyzeAllDescription;
 var init_common = __esm({
   "src/tools/common.js"() {
     "use strict";
     init_zod();
-    import_path5 = require("path");
+    import_path6 = require("path");
     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.'),
@@ -27310,7 +27886,7 @@ var init_symbolEdit = __esm({
 // src/tools/fileTracker.js
 function normalizePath(filePath) {
   if (!filePath) return filePath;
-  return (0, import_path6.resolve)(filePath);
+  return (0, import_path7.resolve)(filePath);
 }
 function computeContentHash(content) {
   const normalized = (content || "").split("\n").map((l) => l.trimEnd()).join("\n");
@@ -27350,12 +27926,12 @@ function parseFilePathsFromOutput(output) {
   }
   return paths;
 }
-var import_crypto2, import_path6, FileTracker;
+var import_crypto2, import_path7, FileTracker;
 var init_fileTracker = __esm({
   "src/tools/fileTracker.js"() {
     "use strict";
     import_crypto2 = require("crypto");
-    import_path6 = require("path");
+    import_path7 = require("path");
     init_symbolEdit();
     FileTracker = class {
       /**
@@ -27456,7 +28032,7 @@ var init_fileTracker = __esm({
         const symbolPromises = [];
         for (const target of targets) {
           const filePath = extractFilePath(target);
-          const resolved = (0, import_path6.isAbsolute)(filePath) ? filePath : (0, import_path6.resolve)(cwd, filePath);
+          const resolved = (0, import_path7.isAbsolute)(filePath) ? filePath : (0, import_path7.resolve)(cwd, filePath);
           if (!seenPaths.has(resolved)) {
             seenPaths.add(resolved);
             this.markFileSeen(resolved);
@@ -27496,7 +28072,7 @@ var init_fileTracker = __esm({
       async trackFilesFromOutput(output, cwd) {
         const paths = parseFilePathsFromOutput(output);
         for (const filePath of paths) {
-          const resolved = (0, import_path6.isAbsolute)(filePath) ? filePath : (0, import_path6.resolve)(cwd, filePath);
+          const resolved = (0, import_path7.isAbsolute)(filePath) ? filePath : (0, import_path7.resolve)(cwd, filePath);
           this.markFileSeen(resolved);
         }
       }
@@ -31643,22 +32219,22 @@ var init_esm3 = __esm({
 });
 
 // node_modules/path-scurry/dist/esm/index.js
-var import_node_path, import_node_url, import_fs4, actualFS, import_promises, realpathSync2, defaultFS, fsFromOption, uncDriveRegexp, uncToDrive, eitherSep, UNKNOWN, IFIFO, IFCHR, IFDIR, IFBLK, IFREG, IFLNK, IFSOCK, IFMT, IFMT_UNKNOWN, READDIR_CALLED, LSTAT_CALLED, ENOTDIR, ENOENT, ENOREADLINK, ENOREALPATH, ENOCHILD, TYPEMASK, entToType, normalizeCache, normalize2, normalizeNocaseCache, normalizeNocase, ResolveCache, ChildrenCache, setAsCwd, PathBase, PathWin32, PathPosix, PathScurryBase, PathScurryWin32, PathScurryPosix, PathScurryDarwin, Path, PathScurry;
+var import_node_path, import_node_url, import_fs5, actualFS, import_promises, realpathSync2, defaultFS, fsFromOption, uncDriveRegexp, uncToDrive, eitherSep, UNKNOWN, IFIFO, IFCHR, IFDIR, IFBLK, IFREG, IFLNK, IFSOCK, IFMT, IFMT_UNKNOWN, READDIR_CALLED, LSTAT_CALLED, ENOTDIR, ENOENT, ENOREADLINK, ENOREALPATH, ENOCHILD, TYPEMASK, entToType, normalizeCache, normalize2, normalizeNocaseCache, normalizeNocase, ResolveCache, ChildrenCache, setAsCwd, PathBase, PathWin32, PathPosix, PathScurryBase, PathScurryWin32, PathScurryPosix, PathScurryDarwin, Path, PathScurry;
 var init_esm4 = __esm({
   "node_modules/path-scurry/dist/esm/index.js"() {
     init_esm2();
     import_node_path = require("node:path");
     import_node_url = require("node:url");
-    import_fs4 = require("fs");
+    import_fs5 = require("fs");
     actualFS = __toESM(require("node:fs"), 1);
     import_promises = require("node:fs/promises");
     init_esm3();
-    realpathSync2 = import_fs4.realpathSync.native;
+    realpathSync2 = import_fs5.realpathSync.native;
     defaultFS = {
-      lstatSync: import_fs4.lstatSync,
-      readdir: import_fs4.readdir,
-      readdirSync: import_fs4.readdirSync,
-      readlinkSync: import_fs4.readlinkSync,
+      lstatSync: import_fs5.lstatSync,
+      readdir: import_fs5.readdir,
+      readdirSync: import_fs5.readdirSync,
+      readlinkSync: import_fs5.readlinkSync,
       realpathSync: realpathSync2,
       promises: {
         lstat: import_promises.lstat,
@@ -34595,7 +35171,7 @@ function createWrappedTools(baseTools) {
   }
   return wrappedTools;
 }
-var import_child_process6, import_util13, import_crypto3, import_events, import_fs5, import_fs6, import_path7, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
+var import_child_process6, import_util13, import_crypto3, import_events, import_fs6, import_fs7, import_path8, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
 var init_probeTool = __esm({
   "src/agent/probeTool.js"() {
     "use strict";
@@ -34604,9 +35180,9 @@ var init_probeTool = __esm({
     import_util13 = require("util");
     import_crypto3 = require("crypto");
     import_events = require("events");
-    import_fs5 = __toESM(require("fs"), 1);
-    import_fs6 = require("fs");
-    import_path7 = __toESM(require("path"), 1);
+    import_fs6 = __toESM(require("fs"), 1);
+    import_fs7 = require("fs");
+    import_path8 = __toESM(require("path"), 1);
     init_esm5();
     init_symlink_utils();
     toolCallEmitter = new import_events.EventEmitter();
@@ -34695,17 +35271,17 @@ var init_probeTool = __esm({
       execute: async (params) => {
         const { directory = ".", workingDirectory } = params;
         const baseCwd = workingDirectory || process.cwd();
-        const secureBaseDir = import_path7.default.resolve(baseCwd);
+        const secureBaseDir = import_path8.default.resolve(baseCwd);
         const isDependencyPath = directory.startsWith("/dep/") || directory.startsWith("go:") || directory.startsWith("js:") || directory.startsWith("rust:");
         let targetDir;
-        if (import_path7.default.isAbsolute(directory)) {
-          targetDir = import_path7.default.resolve(directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path7.default.sep) && targetDir !== secureBaseDir) {
+        if (import_path8.default.isAbsolute(directory)) {
+          targetDir = import_path8.default.resolve(directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path8.default.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Cannot access directory outside workspace: ${directory}`);
           }
         } else {
-          targetDir = import_path7.default.resolve(secureBaseDir, directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path7.default.sep) && targetDir !== secureBaseDir) {
+          targetDir = import_path8.default.resolve(secureBaseDir, directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path8.default.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Access denied: ${directory}`);
           }
         }
@@ -34714,7 +35290,7 @@ var init_probeTool = __esm({
           console.log(`[DEBUG] Listing files in directory: ${targetDir}`);
         }
         try {
-          const files = await import_fs6.promises.readdir(targetDir, { withFileTypes: true });
+          const files = await import_fs7.promises.readdir(targetDir, { withFileTypes: true });
           const formatSize = (size) => {
             if (size < 1024) return `${size}B`;
             if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)}K`;
@@ -34722,7 +35298,7 @@ var init_probeTool = __esm({
             return `${(size / (1024 * 1024 * 1024)).toFixed(1)}G`;
           };
           const entries = await Promise.all(files.map(async (file2) => {
-            const fullPath = import_path7.default.join(targetDir, file2.name);
+            const fullPath = import_path8.default.join(targetDir, file2.name);
             const entryType = await getEntryType(file2, fullPath);
             return {
               name: file2.name,
@@ -34759,17 +35335,17 @@ var init_probeTool = __esm({
           throw new Error("Pattern is required for file search");
         }
         const baseCwd = workingDirectory || process.cwd();
-        const secureBaseDir = import_path7.default.resolve(baseCwd);
+        const secureBaseDir = import_path8.default.resolve(baseCwd);
         const isDependencyPath = directory.startsWith("/dep/") || directory.startsWith("go:") || directory.startsWith("js:") || directory.startsWith("rust:");
         let targetDir;
-        if (import_path7.default.isAbsolute(directory)) {
-          targetDir = import_path7.default.resolve(directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path7.default.sep) && targetDir !== secureBaseDir) {
+        if (import_path8.default.isAbsolute(directory)) {
+          targetDir = import_path8.default.resolve(directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path8.default.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Cannot access directory outside workspace: ${directory}`);
           }
         } else {
-          targetDir = import_path7.default.resolve(secureBaseDir, directory);
-          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path7.default.sep) && targetDir !== secureBaseDir) {
+          targetDir = import_path8.default.resolve(secureBaseDir, directory);
+          if (!isDependencyPath && !targetDir.startsWith(secureBaseDir + import_path8.default.sep) && targetDir !== secureBaseDir) {
             throw new Error(`Path traversal attempt detected. Access denied: ${directory}`);
           }
         }
@@ -73424,11 +74000,11 @@ function loadMCPConfigurationFromPath(configPath) {
   if (!configPath) {
     throw new Error("Config path is required");
   }
-  if (!(0, import_fs7.existsSync)(configPath)) {
+  if (!(0, import_fs8.existsSync)(configPath)) {
     throw new Error(`MCP configuration file not found: ${configPath}`);
   }
   try {
-    const content = (0, import_fs7.readFileSync)(configPath, "utf8");
+    const content = (0, import_fs8.readFileSync)(configPath, "utf8");
     const config2 = JSON.parse(content);
     if (process.env.DEBUG === "1" || process.env.DEBUG_MCP === "1") {
       console.error(`[MCP DEBUG] Loaded configuration from: ${configPath}`);
@@ -73443,19 +74019,19 @@ function loadMCPConfiguration() {
     // Environment variable path
     process.env.MCP_CONFIG_PATH,
     // Local project paths
-    (0, import_path8.join)(process.cwd(), ".mcp", "config.json"),
-    (0, import_path8.join)(process.cwd(), "mcp.config.json"),
+    (0, import_path9.join)(process.cwd(), ".mcp", "config.json"),
+    (0, import_path9.join)(process.cwd(), "mcp.config.json"),
     // Home directory paths
-    (0, import_path8.join)((0, import_os3.homedir)(), ".config", "probe", "mcp.json"),
-    (0, import_path8.join)((0, import_os3.homedir)(), ".mcp", "config.json"),
+    (0, import_path9.join)((0, import_os3.homedir)(), ".config", "probe", "mcp.json"),
+    (0, import_path9.join)((0, import_os3.homedir)(), ".mcp", "config.json"),
     // Claude-style config location
-    (0, import_path8.join)((0, import_os3.homedir)(), "Library", "Application Support", "Claude", "mcp_config.json")
+    (0, import_path9.join)((0, import_os3.homedir)(), "Library", "Application Support", "Claude", "mcp_config.json")
   ].filter(Boolean);
   let config2 = null;
   for (const configPath of configPaths) {
-    if ((0, import_fs7.existsSync)(configPath)) {
+    if ((0, import_fs8.existsSync)(configPath)) {
       try {
-        const content = (0, import_fs7.readFileSync)(configPath, "utf8");
+        const content = (0, import_fs8.readFileSync)(configPath, "utf8");
         config2 = JSON.parse(content);
         if (process.env.DEBUG === "1" || process.env.DEBUG_MCP === "1") {
           console.error(`[MCP DEBUG] Loaded configuration from: ${configPath}`);
@@ -73576,16 +74152,16 @@ function parseEnabledServers(config2) {
   }
   return servers;
 }
-var import_fs7, import_path8, import_os3, import_url4, __filename4, __dirname4, DEFAULT_TIMEOUT, MAX_TIMEOUT, DEFAULT_CONFIG;
+var import_fs8, import_path9, import_os3, import_url4, __filename4, __dirname4, DEFAULT_TIMEOUT, MAX_TIMEOUT, DEFAULT_CONFIG;
 var init_config = __esm({
   "src/agent/mcp/config.js"() {
     "use strict";
-    import_fs7 = require("fs");
-    import_path8 = require("path");
+    import_fs8 = require("fs");
+    import_path9 = require("path");
     import_os3 = require("os");
     import_url4 = require("url");
     __filename4 = (0, import_url4.fileURLToPath)("file:///");
-    __dirname4 = (0, import_path8.dirname)(__filename4);
+    __dirname4 = (0, import_path9.dirname)(__filename4);
     DEFAULT_TIMEOUT = 3e4;
     MAX_TIMEOUT = (() => {
       if (process.env.MCP_MAX_TIMEOUT) {
@@ -73599,7 +74175,7 @@ var init_config = __esm({
         // Example probe server configuration
         "probe-local": {
           command: "node",
-          args: [(0, import_path8.join)(__dirname4, "../../../examples/chat/mcpServer.js")],
+          args: [(0, import_path9.join)(__dirname4, "../../../examples/chat/mcpServer.js")],
           transport: "stdio",
           enabled: false
         },
@@ -81749,17 +82325,17 @@ async function parseSkillFile(skillFilePath, directoryName) {
       description,
       skillFilePath,
       directoryName,
-      sourceDir: (0, import_path9.dirname)(skillFilePath)
+      sourceDir: (0, import_path10.dirname)(skillFilePath)
     },
     error: null
   };
 }
-var import_promises2, import_path9, import_yaml, SKILL_NAME_REGEX, MAX_SKILL_NAME_LENGTH, MAX_DESCRIPTION_CHARS;
+var import_promises2, import_path10, import_yaml, SKILL_NAME_REGEX, MAX_SKILL_NAME_LENGTH, MAX_DESCRIPTION_CHARS;
 var init_parser7 = __esm({
   "src/agent/skills/parser.js"() {
     "use strict";
     import_promises2 = require("fs/promises");
-    import_path9 = require("path");
+    import_path10 = require("path");
     import_yaml = __toESM(require_dist(), 1);
     SKILL_NAME_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
     MAX_SKILL_NAME_LENGTH = 64;
@@ -81769,12 +82345,12 @@ var init_parser7 = __esm({
 
 // src/agent/skills/registry.js
 function isPathInside(basePath, targetPath) {
-  const base2 = (0, import_path10.resolve)(basePath);
-  const target = (0, import_path10.resolve)(targetPath);
-  const rel = (0, import_path10.relative)(base2, target);
+  const base2 = (0, import_path11.resolve)(basePath);
+  const target = (0, import_path11.resolve)(targetPath);
+  const rel = (0, import_path11.relative)(base2, target);
   if (rel === "") return true;
-  if (rel === ".." || rel.startsWith(`..${import_path10.sep}`)) return false;
-  if ((0, import_path10.isAbsolute)(rel)) return false;
+  if (rel === ".." || rel.startsWith(`..${import_path11.sep}`)) return false;
+  if ((0, import_path11.isAbsolute)(rel)) return false;
   return true;
 }
 function isSafeEntryName(name15) {
@@ -81782,19 +82358,19 @@ function isSafeEntryName(name15) {
   if (name15.includes("\0")) return false;
   return !name15.includes("/") && !name15.includes("\\");
 }
-var import_fs8, import_promises3, import_path10, DEFAULT_SKILL_DIRS, SKILL_FILE_NAME, SkillRegistry;
+var import_fs9, import_promises3, import_path11, DEFAULT_SKILL_DIRS, SKILL_FILE_NAME, SkillRegistry;
 var init_registry = __esm({
   "src/agent/skills/registry.js"() {
     "use strict";
-    import_fs8 = require("fs");
+    import_fs9 = require("fs");
     import_promises3 = require("fs/promises");
-    import_path10 = require("path");
+    import_path11 = require("path");
     init_parser7();
     DEFAULT_SKILL_DIRS = [".claude/skills", ".codex/skills", "skills", ".skills"];
     SKILL_FILE_NAME = "SKILL.md";
     SkillRegistry = class {
       constructor({ repoRoot, skillDirs = DEFAULT_SKILL_DIRS, debug = false } = {}) {
-        this.repoRoot = repoRoot ? (0, import_path10.resolve)(repoRoot) : process.cwd();
+        this.repoRoot = repoRoot ? (0, import_path11.resolve)(repoRoot) : process.cwd();
         this.repoRootReal = null;
         this.skillDirs = Array.isArray(skillDirs) && skillDirs.length > 0 ? skillDirs : DEFAULT_SKILL_DIRS;
         this.debug = debug;
@@ -81848,8 +82424,8 @@ var init_registry = __esm({
         }
       }
       async _resolveSkillDir(skillDir) {
-        const resolved = (0, import_path10.isAbsolute)(skillDir) ? (0, import_path10.resolve)(skillDir) : (0, import_path10.resolve)(this.repoRoot, skillDir);
-        const repoRoot = this.repoRootReal || (0, import_path10.resolve)(this.repoRoot);
+        const resolved = (0, import_path11.isAbsolute)(skillDir) ? (0, import_path11.resolve)(skillDir) : (0, import_path11.resolve)(this.repoRoot, skillDir);
+        const repoRoot = this.repoRootReal || (0, import_path11.resolve)(this.repoRoot);
         const resolvedReal = await this._resolveRealPath(resolved);
         if (!resolvedReal) return null;
         if (!isPathInside(repoRoot, resolvedReal)) {
@@ -81861,7 +82437,7 @@ var init_registry = __esm({
         return resolvedReal;
       }
       async _scanSkillDir(dirPath) {
-        if (!(0, import_fs8.existsSync)(dirPath)) return [];
+        if (!(0, import_fs9.existsSync)(dirPath)) return [];
         let entries;
         try {
           entries = await (0, import_promises3.readdir)(dirPath, { withFileTypes: true });
@@ -81880,8 +82456,8 @@ var init_registry = __esm({
             }
             continue;
           }
-          const skillFolder = (0, import_path10.join)(dirPath, entry.name);
-          const skillFilePath = (0, import_path10.join)(skillFolder, SKILL_FILE_NAME);
+          const skillFolder = (0, import_path11.join)(dirPath, entry.name);
+          const skillFilePath = (0, import_path11.join)(skillFolder, SKILL_FILE_NAME);
           let skillStat;
           try {
             skillStat = await (0, import_promises3.lstat)(skillFilePath);
@@ -81901,7 +82477,7 @@ var init_registry = __esm({
             }
             continue;
           }
-          if (!(0, import_fs8.existsSync)(skillFilePath)) continue;
+          if (!(0, import_fs9.existsSync)(skillFilePath)) continue;
           const { skill, error: error40 } = await parseSkillFile(skillFilePath, entry.name);
           if (!skill) {
             if (error40) {
@@ -82826,9 +83402,9 @@ async function truncateIfNeeded(content, tokenCounter, sessionId, maxTokens) {
   let tempFilePath = null;
   let fileError = null;
   try {
-    const tempDir = (0, import_path11.join)((0, import_os4.tmpdir)(), "probe-output");
+    const tempDir = (0, import_path12.join)((0, import_os4.tmpdir)(), "probe-output");
     await (0, import_promises4.mkdir)(tempDir, { recursive: true });
-    tempFilePath = (0, import_path11.join)(tempDir, `tool-output-${sessionId || "unknown"}-${(0, import_crypto4.randomUUID)()}.txt`);
+    tempFilePath = (0, import_path12.join)(tempDir, `tool-output-${sessionId || "unknown"}-${(0, import_crypto4.randomUUID)()}.txt`);
     await (0, import_promises4.writeFile)(tempFilePath, content, "utf8");
   } catch (err) {
     fileError = err.message || "Unknown file system error";
@@ -82876,13 +83452,13 @@ ${truncatedBody}
     error: fileError || void 0
   };
 }
-var import_promises4, import_os4, import_path11, import_crypto4, DEFAULT_MAX_OUTPUT_TOKENS, CHARS_PER_TOKEN, TAIL_TOKENS, MIN_LIMIT_FOR_TAIL;
+var import_promises4, import_os4, import_path12, import_crypto4, DEFAULT_MAX_OUTPUT_TOKENS, CHARS_PER_TOKEN, TAIL_TOKENS, MIN_LIMIT_FOR_TAIL;
 var init_outputTruncator = __esm({
   "src/agent/outputTruncator.js"() {
     "use strict";
     import_promises4 = require("fs/promises");
     import_os4 = require("os");
-    import_path11 = require("path");
+    import_path12 = require("path");
     import_crypto4 = require("crypto");
     DEFAULT_MAX_OUTPUT_TOKENS = 2e4;
     CHARS_PER_TOKEN = 4;
@@ -94220,8 +94796,8 @@ async function executeBashCommand(command, options = {}) {
   } = options;
   let cwd = workingDirectory;
   try {
-    cwd = (0, import_path12.resolve)(cwd);
-    if (!(0, import_fs9.existsSync)(cwd)) {
+    cwd = (0, import_path13.resolve)(cwd);
+    if (!(0, import_fs10.existsSync)(cwd)) {
       throw new Error(`Working directory does not exist: ${cwd}`);
     }
   } catch (error40) {
@@ -94477,7 +95053,7 @@ function validateExecutionOptions(options = {}) {
   if (options.workingDirectory) {
     if (typeof options.workingDirectory !== "string") {
       errors.push("workingDirectory must be a string");
-    } else if (!(0, import_fs9.existsSync)(options.workingDirectory)) {
+    } else if (!(0, import_fs10.existsSync)(options.workingDirectory)) {
       errors.push(`workingDirectory does not exist: ${options.workingDirectory}`);
     }
   }
@@ -94490,24 +95066,24 @@ function validateExecutionOptions(options = {}) {
     warnings
   };
 }
-var import_child_process7, import_path12, import_fs9;
+var import_child_process7, import_path13, import_fs10;
 var init_bashExecutor = __esm({
   "src/agent/bashExecutor.js"() {
     "use strict";
     import_child_process7 = require("child_process");
-    import_path12 = require("path");
-    import_fs9 = require("fs");
+    import_path13 = require("path");
+    import_fs10 = require("fs");
     init_bashCommandUtils();
   }
 });
 
 // src/tools/bash.js
-var import_ai, import_path13, bashTool;
+var import_ai, import_path14, bashTool;
 var init_bash = __esm({
   "src/tools/bash.js"() {
     "use strict";
     import_ai = require("ai");
-    import_path13 = require("path");
+    import_path14 = require("path");
     init_bashPermissions();
     init_bashExecutor();
     init_path_validation();
@@ -94624,12 +95200,12 @@ For code exploration, try these safe alternatives:
 - npm list, pip list for package information`;
             }
             const defaultDir = getDefaultWorkingDirectory();
-            const workingDir = workingDirectory ? (0, import_path13.isAbsolute)(workingDirectory) ? (0, import_path13.resolve)(workingDirectory) : (0, import_path13.resolve)(defaultDir, workingDirectory) : defaultDir;
+            const workingDir = workingDirectory ? (0, import_path14.isAbsolute)(workingDirectory) ? (0, import_path14.resolve)(workingDirectory) : (0, import_path14.resolve)(defaultDir, workingDirectory) : defaultDir;
             if (allowedFolders && allowedFolders.length > 0) {
               const resolvedWorkingDir = safeRealpath(workingDir);
               const isAllowed = allowedFolders.some((folder) => {
                 const resolvedFolder = safeRealpath(folder);
-                return resolvedWorkingDir === resolvedFolder || resolvedWorkingDir.startsWith(resolvedFolder + import_path13.sep);
+                return resolvedWorkingDir === resolvedFolder || resolvedWorkingDir.startsWith(resolvedFolder + import_path14.sep);
               });
               if (!isAllowed) {
                 const relativeDir = toRelativePath(workingDir, workspaceRoot);
@@ -95943,12 +96519,12 @@ async function createEnhancedClaudeCLIEngine(options = {}) {
       console.log("[DEBUG] Built-in MCP server started");
       console.log("[DEBUG] MCP URL:", `http://${host}:${port}/mcp`);
     }
-    mcpConfigPath = import_path14.default.join(import_os5.default.tmpdir(), `probe-mcp-${session.id}.json`);
+    mcpConfigPath = import_path15.default.join(import_os5.default.tmpdir(), `probe-mcp-${session.id}.json`);
     const mcpConfig = {
       mcpServers: {
         probe: {
           command: "node",
-          args: [import_path14.default.join(process.cwd(), "mcp-probe-server.js")],
+          args: [import_path15.default.join(process.cwd(), "mcp-probe-server.js")],
           env: {
             PROBE_WORKSPACE: process.cwd(),
             DEBUG: debug ? "true" : "false"
@@ -96373,14 +96949,14 @@ function combinePrompts(systemPrompt, customPrompt, agent) {
   }
   return systemPrompt || "";
 }
-var import_child_process8, import_crypto6, import_promises5, import_path14, import_os5, import_events3;
+var import_child_process8, import_crypto6, import_promises5, import_path15, import_os5, import_events3;
 var init_enhanced_claude_code = __esm({
   "src/agent/engines/enhanced-claude-code.js"() {
     "use strict";
     import_child_process8 = require("child_process");
     import_crypto6 = require("crypto");
     import_promises5 = __toESM(require("fs/promises"), 1);
-    import_path14 = __toESM(require("path"), 1);
+    import_path15 = __toESM(require("path"), 1);
     import_os5 = __toESM(require("os"), 1);
     import_events3 = require("events");
     init_built_in_server();
@@ -96751,7 +97327,7 @@ function debugLogToolResults(toolResults) {
     console.log(`[DEBUG]   tool: ${tr.toolName} | args: ${debugTruncate(argsStr)} | result: ${debugTruncate(resultStr)}`);
   }
 }
-var import_dotenv, import_anthropic2, import_openai2, import_google2, import_ai4, import_crypto8, import_events4, import_fs10, import_promises6, import_path15, 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_dotenv, import_anthropic2, import_openai2, import_google2, import_ai4, import_crypto8, import_events4, import_fs11, import_promises6, import_path16, 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"() {
     "use strict";
@@ -96763,10 +97339,11 @@ var init_ProbeAgent = __esm({
     import_ai4 = require("ai");
     import_crypto8 = require("crypto");
     import_events4 = require("events");
-    import_fs10 = require("fs");
+    import_fs11 = require("fs");
     import_promises6 = require("fs/promises");
-    import_path15 = require("path");
+    import_path16 = require("path");
     init_tokenCounter();
+    init_simpleTelemetry();
     init_InMemoryStorageAdapter();
     init_HookManager();
     init_imageConfig();
@@ -97430,7 +98007,7 @@ var init_ProbeAgent = __esm({
               if (!imagePath) {
                 throw new Error("Image path is required");
               }
-              const filename = (0, import_path15.basename)(imagePath);
+              const filename = (0, import_path16.basename)(imagePath);
               const extension = filename.toLowerCase().split(".").pop();
               if (!extension || !SUPPORTED_IMAGE_EXTENSIONS.includes(extension)) {
                 throw new Error(`Invalid or unsupported image extension: ${extension}. Supported formats: ${SUPPORTED_IMAGE_EXTENSIONS.join(", ")}`);
@@ -98170,10 +98747,10 @@ var init_ProbeAgent = __esm({
             execute: async (params) => {
               let resolvedWorkingDirectory = this.workspaceRoot || this.cwd || this.allowedFolders && this.allowedFolders[0] || process.cwd();
               if (params.workingDirectory) {
-                const requestedDir = safeRealpath((0, import_path15.isAbsolute)(params.workingDirectory) ? (0, import_path15.resolve)(params.workingDirectory) : (0, import_path15.resolve)(resolvedWorkingDirectory, params.workingDirectory));
+                const requestedDir = safeRealpath((0, import_path16.isAbsolute)(params.workingDirectory) ? (0, import_path16.resolve)(params.workingDirectory) : (0, import_path16.resolve)(resolvedWorkingDirectory, params.workingDirectory));
                 const isWithinAllowed = !this.allowedFolders || this.allowedFolders.length === 0 || this.allowedFolders.some((folder) => {
                   const resolvedFolder = safeRealpath(folder);
-                  return requestedDir === resolvedFolder || requestedDir.startsWith(resolvedFolder + import_path15.sep);
+                  return requestedDir === resolvedFolder || requestedDir.startsWith(resolvedFolder + import_path16.sep);
                 });
                 if (isWithinAllowed) {
                   resolvedWorkingDirectory = requestedDir;
@@ -98262,7 +98839,7 @@ var init_ProbeAgent = __esm({
                 });
                 let toolResultContent = typeof result === "string" ? result : JSON.stringify(result, null, 2);
                 if (this.workspaceRoot && toolResultContent) {
-                  const wsPrefix = this.workspaceRoot.endsWith(import_path15.sep) ? this.workspaceRoot : this.workspaceRoot + import_path15.sep;
+                  const wsPrefix = this.workspaceRoot.endsWith(import_path16.sep) ? this.workspaceRoot : this.workspaceRoot + import_path16.sep;
                   toolResultContent = toolResultContent.split(wsPrefix).join("");
                 }
                 const { cleanedContent, extractedBlocks } = extractRawOutputBlocks(toolResultContent);
@@ -98632,7 +99209,7 @@ var init_ProbeAgent = __esm({
           let resolvedPath = imagePath;
           if (!imagePath.includes("/") && !imagePath.includes("\\")) {
             for (const dir of listFilesDirectories) {
-              const potentialPath = (0, import_path15.resolve)(dir, imagePath);
+              const potentialPath = (0, import_path16.resolve)(dir, imagePath);
               const loaded = await this.loadImageIfValid(potentialPath);
               if (loaded) {
                 if (this.debug) {
@@ -98657,7 +99234,7 @@ var init_ProbeAgent = __esm({
         let match2;
         while ((match2 = fileHeaderPattern.exec(content)) !== null) {
           const filePath = match2[1].trim();
-          const dir = (0, import_path15.dirname)(filePath);
+          const dir = (0, import_path16.dirname)(filePath);
           if (dir && dir !== ".") {
             directories.push(dir);
             if (this.debug) {
@@ -98702,17 +99279,17 @@ var init_ProbeAgent = __esm({
           const allowedDirs = this.allowedFolders && this.allowedFolders.length > 0 ? this.allowedFolders : [process.cwd()];
           let absolutePath;
           let isPathAllowed2 = false;
-          if ((0, import_path15.isAbsolute)(imagePath)) {
-            absolutePath = safeRealpath((0, import_path15.resolve)(imagePath));
+          if ((0, import_path16.isAbsolute)(imagePath)) {
+            absolutePath = safeRealpath((0, import_path16.resolve)(imagePath));
             isPathAllowed2 = allowedDirs.some((dir) => {
               const resolvedDir = safeRealpath(dir);
-              return absolutePath === resolvedDir || absolutePath.startsWith(resolvedDir + import_path15.sep);
+              return absolutePath === resolvedDir || absolutePath.startsWith(resolvedDir + import_path16.sep);
             });
           } else {
             for (const dir of allowedDirs) {
               const resolvedDir = safeRealpath(dir);
-              const resolvedPath = safeRealpath((0, import_path15.resolve)(dir, imagePath));
-              if (resolvedPath === resolvedDir || resolvedPath.startsWith(resolvedDir + import_path15.sep)) {
+              const resolvedPath = safeRealpath((0, import_path16.resolve)(dir, imagePath));
+              if (resolvedPath === resolvedDir || resolvedPath.startsWith(resolvedDir + import_path16.sep)) {
                 absolutePath = resolvedPath;
                 isPathAllowed2 = true;
                 break;
@@ -98900,8 +99477,8 @@ var init_ProbeAgent = __esm({
         const hasConfiguredName = !!configuredName;
         let guidanceCandidates = [];
         if (hasConfiguredName) {
-          const targetName = (0, import_path15.basename)(configuredName);
-          if (configuredName !== targetName || configuredName.includes("/") || configuredName.includes("\\") || configuredName.includes("..") || (0, import_path15.isAbsolute)(configuredName)) {
+          const targetName = (0, import_path16.basename)(configuredName);
+          if (configuredName !== targetName || configuredName.includes("/") || configuredName.includes("\\") || configuredName.includes("..") || (0, import_path16.isAbsolute)(configuredName)) {
             console.warn(`[WARN] Invalid architectureFileName (must be a simple filename): ${configuredName}`);
           } else if (targetName) {
             const targetLower = targetName.toLowerCase();
@@ -98914,7 +99491,7 @@ var init_ProbeAgent = __esm({
         } else {
           guidanceCandidates = ["agents.md", "claude.md"];
         }
-        if (!(0, import_fs10.existsSync)(rootDirectory)) {
+        if (!(0, import_fs11.existsSync)(rootDirectory)) {
           this._architectureContextLoaded = true;
           return null;
         }
@@ -98968,7 +99545,7 @@ var init_ProbeAgent = __esm({
         pushEntry(architectureMatch);
         const contexts = [];
         for (const entry of uniqueEntries) {
-          const filePath = (0, import_path15.resolve)(rootDirectory, entry.name);
+          const filePath = (0, import_path16.resolve)(rootDirectory, entry.name);
           try {
             const content = await (0, import_promises6.readFile)(filePath, "utf8");
             let kind = "other";
@@ -99033,10 +99610,10 @@ ${this.architectureContext.content}
       }
       _getSkillsRepoRoot() {
         if (this.workspaceRoot) {
-          return (0, import_path15.resolve)(this.workspaceRoot);
+          return (0, import_path16.resolve)(this.workspaceRoot);
         }
         if (this.allowedFolders && this.allowedFolders.length > 0) {
-          return (0, import_path15.resolve)(this.allowedFolders[0]);
+          return (0, import_path16.resolve)(this.allowedFolders[0]);
         }
         return process.cwd();
       }
@@ -100105,7 +100682,7 @@ Double-check your response based on the criteria above. If everything looks good
               };
               let aiResult;
               if (this.tracer) {
-                const inputPreview = message.length > 1e3 ? message.substring(0, 1e3) + "... [truncated]" : message;
+                const inputPreview = truncateForSpan(message, 4096);
                 aiResult = await this.tracer.withSpan("ai.request", executeAIRequest, {
                   "ai.model": this.model,
                   "ai.provider": this.clientApiProvider || "auto",
@@ -100115,6 +100692,12 @@ Double-check your response based on the criteria above. If everything looks good
                   "max_tokens": maxResponseTokens,
                   "temperature": 0.3,
                   "message_count": currentMessages.length
+                }, (span, result) => {
+                  const text = result?.finalText || "";
+                  span.setAttributes({
+                    "ai.output": truncateForSpan(text),
+                    "ai.output_length": text.length
+                  });
                 });
               } else {
                 aiResult = await executeAIRequest();
@@ -100138,6 +100721,9 @@ Double-check your response based on the criteria above. If everything looks good
               } else if (aiResult.finalText) {
                 finalResult = aiResult.finalText;
               }
+              if (finalResult === null || finalResult === void 0) {
+                finalResult = "";
+              }
               if (gracefulTimeoutState.triggered) {
                 const timeoutNotice = "**Note: This response was generated under a time constraint. The research may be incomplete, and some planned searches or analysis steps were not completed.**\n\n";
                 if (!finalResult || finalResult === DEFAULT_MAX_ITER_MSG || finalResult.startsWith("I was unable to complete your request after")) {
@@ -102451,7 +103037,7 @@ function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, all
     "Remember: if your search returned relevant results, use nextPage=true to check for more before outputting."
   ].join("\n");
 }
-var import_ai5, import_fs11, CODE_SEARCH_SCHEMA, searchTool, queryTool, extractTool, delegateTool, analyzeAllTool;
+var import_ai5, import_fs12, CODE_SEARCH_SCHEMA, searchTool, queryTool, extractTool, delegateTool, analyzeAllTool;
 var init_vercel = __esm({
   "src/tools/vercel.js"() {
     "use strict";
@@ -102462,9 +103048,10 @@ var init_vercel = __esm({
     init_delegate();
     init_analyzeAll();
     init_common();
-    import_fs11 = require("fs");
+    import_fs12 = require("fs");
     init_error_types();
     init_hashline();
+    init_simpleTelemetry();
     CODE_SEARCH_SCHEMA = {
       type: "object",
       properties: {
@@ -102620,6 +103207,7 @@ var init_vercel = __esm({
               tracer: options.tracer || null,
               enableBash: false,
               bashConfig: null,
+              allowEdit: options.allowEdit || false,
               architectureFileName: options.architectureFileName || null,
               promptType: "code-searcher",
               allowedTools: ["search", "extract", "listFiles"],
@@ -102630,6 +103218,12 @@ var init_vercel = __esm({
             const delegateResult = options.tracer?.withSpan ? await options.tracer.withSpan("search.delegate", runDelegation, {
               "search.query": searchQuery,
               "search.path": searchPath
+            }, (span, result) => {
+              const text = typeof result === "string" ? result : "";
+              span.setAttributes({
+                "search.delegate.output": truncateForSpan(text),
+                "search.delegate.output_length": text.length
+              });
             }) : await runDelegation();
             const targets = parseDelegatedTargets(delegateResult);
             if (!targets.length) {
@@ -102649,7 +103243,7 @@ var init_vercel = __esm({
             const validatedTargets = [];
             for (const target of resolvedTargets) {
               const { filePart, suffix } = splitTargetSuffix(target);
-              if ((0, import_fs11.existsSync)(filePart)) {
+              if ((0, import_fs12.existsSync)(filePart)) {
                 validatedTargets.push(target);
                 continue;
               }
@@ -102658,7 +103252,7 @@ var init_vercel = __esm({
               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_fs11.existsSync)(candidate)) {
+                  if ((0, import_fs12.existsSync)(candidate)) {
                     validatedTargets.push(candidate + suffix);
                     if (debug) console.error(`[search-delegate] Fixed doubled path segment: ${filePart} \u2192 ${candidate}`);
                     fixed = true;
@@ -102671,7 +103265,7 @@ var init_vercel = __esm({
                 if (altBase === delegateBase) continue;
                 const altResolved = resolveTargetPath(target, altBase);
                 const { filePart: altFile } = splitTargetSuffix(altResolved);
-                if ((0, import_fs11.existsSync)(altFile)) {
+                if ((0, import_fs12.existsSync)(altFile)) {
                   validatedTargets.push(altResolved);
                   if (debug) console.error(`[search-delegate] Resolved with alt base: ${filePart} \u2192 ${altFile}`);
                   fixed = true;
@@ -102796,13 +103390,13 @@ var init_vercel = __esm({
                 const { join: pathJoin, sep: pathSep } = await import("path");
                 extractFiles = extractFiles.map((target) => {
                   const { filePart, suffix } = splitTargetSuffix(target);
-                  if ((0, import_fs11.existsSync)(filePart)) return target;
+                  if ((0, import_fs12.existsSync)(filePart)) return target;
                   const cwdPrefix = effectiveCwd.endsWith(pathSep) ? effectiveCwd : effectiveCwd + pathSep;
                   const relativePart = filePart.startsWith(cwdPrefix) ? filePart.slice(cwdPrefix.length) : null;
                   if (relativePart) {
                     for (const folder of options.allowedFolders) {
                       const candidate = pathJoin(folder, relativePart);
-                      if ((0, import_fs11.existsSync)(candidate)) {
+                      if ((0, import_fs12.existsSync)(candidate)) {
                         if (debug) console.error(`[extract] Auto-fixed path: ${filePart} \u2192 ${candidate}`);
                         return candidate + suffix;
                       }
@@ -102815,7 +103409,7 @@ var init_vercel = __esm({
                     if (filePart.startsWith(wsParent)) {
                       const tail = filePart.slice(wsParent.length);
                       const candidate = pathJoin(folderPrefix, tail);
-                      if (candidate !== filePart && (0, import_fs11.existsSync)(candidate)) {
+                      if (candidate !== filePart && (0, import_fs12.existsSync)(candidate)) {
                         if (debug) console.error(`[extract] Auto-fixed path via workspace: ${filePart} \u2192 ${candidate}`);
                         return candidate + suffix;
                       }
@@ -102874,6 +103468,7 @@ var init_vercel = __esm({
         workspaceRoot,
         enableBash = false,
         bashConfig,
+        allowEdit = false,
         architectureFileName,
         enableMcp = false,
         mcpConfig = null,
@@ -102968,6 +103563,7 @@ var init_vercel = __esm({
             model,
             tracer,
             enableBash,
+            allowEdit,
             bashConfig,
             architectureFileName,
             searchDelegate,
@@ -103309,12 +103905,12 @@ function isPathAllowed(filePath, allowedFolders) {
   if (!allowedFolders || allowedFolders.length === 0) {
     const resolvedPath2 = safeRealpath(filePath);
     const cwd = safeRealpath(process.cwd());
-    return resolvedPath2 === cwd || resolvedPath2.startsWith(cwd + import_path16.sep);
+    return resolvedPath2 === cwd || resolvedPath2.startsWith(cwd + import_path17.sep);
   }
   const resolvedPath = safeRealpath(filePath);
   return allowedFolders.some((folder) => {
     const allowedPath = safeRealpath(folder);
-    return resolvedPath === allowedPath || resolvedPath.startsWith(allowedPath + import_path16.sep);
+    return resolvedPath === allowedPath || resolvedPath.startsWith(allowedPath + import_path17.sep);
   });
 }
 function parseFileToolOptions(options = {}) {
@@ -103354,7 +103950,7 @@ Example: <edit><file_path>${file_path}</file_path><symbol>${allMatches[0].qualif
       return `Error editing ${file_path}: Symbol "${symbol17}" has changed since you last read it. Use the extract tool with targets="${file_path}#${symbol17}" to re-read the current content, then retry.`;
     }
   }
-  const content = await import_fs12.promises.readFile(resolvedPath, "utf-8");
+  const content = await import_fs13.promises.readFile(resolvedPath, "utf-8");
   const lines = content.split("\n");
   if (position) {
     const refIndent = detectBaseIndent(symbolInfo.code);
@@ -103365,7 +103961,7 @@ Example: <edit><file_path>${file_path}</file_path><symbol>${allMatches[0].qualif
     } else {
       lines.splice(symbolInfo.startLine - 1, 0, ...newLines, "");
     }
-    await import_fs12.promises.writeFile(resolvedPath, lines.join("\n"), "utf-8");
+    await import_fs13.promises.writeFile(resolvedPath, lines.join("\n"), "utf-8");
     if (fileTracker) {
       const updated = await findSymbol(resolvedPath, symbol17, cwd || process.cwd());
       if (updated) {
@@ -103383,7 +103979,7 @@ Example: <edit><file_path>${file_path}</file_path><symbol>${allMatches[0].qualif
     const reindented = reindent(new_string, originalIndent);
     const newLines = reindented.split("\n");
     lines.splice(symbolInfo.startLine - 1, symbolInfo.endLine - symbolInfo.startLine + 1, ...newLines);
-    await import_fs12.promises.writeFile(resolvedPath, lines.join("\n"), "utf-8");
+    await import_fs13.promises.writeFile(resolvedPath, lines.join("\n"), "utf-8");
     if (fileTracker) {
       const updated = await findSymbol(resolvedPath, symbol17, cwd || process.cwd());
       if (updated) {
@@ -103438,7 +104034,7 @@ async function handleLineEdit({ resolvedPath, file_path, start_line, end_line, n
   if (position !== void 0 && position !== null && position !== "before" && position !== "after") {
     return 'Error editing file: Invalid position - must be "before" or "after". Use position="before" to insert before the line, or position="after" to insert after it.';
   }
-  const content = await import_fs12.promises.readFile(resolvedPath, "utf-8");
+  const content = await import_fs13.promises.readFile(resolvedPath, "utf-8");
   const fileLines = content.split("\n");
   if (startLine > fileLines.length) {
     return `Error editing file: Line ${startLine} is beyond file length (${fileLines.length} lines). Use 'extract' to read the current file content.`;
@@ -103467,20 +104063,20 @@ async function handleLineEdit({ resolvedPath, file_path, start_line, end_line, n
   const newLines = cleaned === "" ? [] : cleaned.split("\n");
   if (position === "after") {
     fileLines.splice(startLine, 0, ...newLines);
-    await import_fs12.promises.writeFile(resolvedPath, fileLines.join("\n"), "utf-8");
+    await import_fs13.promises.writeFile(resolvedPath, fileLines.join("\n"), "utf-8");
     if (fileTracker) await fileTracker.trackFileAfterWrite(resolvedPath);
     const action = `${newLines.length} line${newLines.length !== 1 ? "s" : ""} inserted after line ${startLine}`;
     return buildLineEditResponse(file_path, startLine, startLine, newLines.length, fileLines, startLine, action, modifications);
   } else if (position === "before") {
     fileLines.splice(startLine - 1, 0, ...newLines);
-    await import_fs12.promises.writeFile(resolvedPath, fileLines.join("\n"), "utf-8");
+    await import_fs13.promises.writeFile(resolvedPath, fileLines.join("\n"), "utf-8");
     if (fileTracker) await fileTracker.trackFileAfterWrite(resolvedPath);
     const action = `${newLines.length} line${newLines.length !== 1 ? "s" : ""} inserted before line ${startLine}`;
     return buildLineEditResponse(file_path, startLine, startLine, newLines.length, fileLines, startLine - 1, action, modifications);
   } else {
     const replacedCount = endLine - startLine + 1;
     fileLines.splice(startLine - 1, replacedCount, ...newLines);
-    await import_fs12.promises.writeFile(resolvedPath, fileLines.join("\n"), "utf-8");
+    await import_fs13.promises.writeFile(resolvedPath, fileLines.join("\n"), "utf-8");
     if (fileTracker) await fileTracker.trackFileAfterWrite(resolvedPath);
     let action;
     if (newLines.length === 0) {
@@ -103493,14 +104089,14 @@ async function handleLineEdit({ resolvedPath, file_path, start_line, end_line, n
     return buildLineEditResponse(file_path, startLine, endLine, newLines.length, fileLines, startLine - 1, action, modifications);
   }
 }
-var import_ai6, import_fs12, import_path16, import_fs13, editTool, createTool, multiEditTool, editSchema, createSchema, multiEditSchema, editDescription, createDescription, multiEditDescription, editToolDefinition, createToolDefinition, multiEditToolDefinition;
+var import_ai6, import_fs13, import_path17, import_fs14, editTool, createTool, multiEditTool, editSchema, createSchema, multiEditSchema, editDescription, createDescription, multiEditDescription, editToolDefinition, createToolDefinition, multiEditToolDefinition;
 var init_edit = __esm({
   "src/tools/edit.js"() {
     "use strict";
     import_ai6 = require("ai");
-    import_fs12 = require("fs");
-    import_path16 = require("path");
     import_fs13 = require("fs");
+    import_path17 = require("path");
+    import_fs14 = require("fs");
     init_path_validation();
     init_fuzzyMatch();
     init_symbolEdit();
@@ -103576,7 +104172,7 @@ Parameters:
               return `Error editing file: Invalid new_string - must be a string. Provide the replacement content as a string value (empty string "" is valid for deletions).`;
             }
             const effectiveCwd = workingDirectory || cwd || process.cwd();
-            const resolvedPath = (0, import_path16.isAbsolute)(file_path) ? file_path : (0, import_path16.resolve)(effectiveCwd, file_path);
+            const resolvedPath = (0, import_path17.isAbsolute)(file_path) ? file_path : (0, import_path17.resolve)(effectiveCwd, file_path);
             if (debug) {
               console.error(`[Edit] Attempting to edit file: ${resolvedPath}`);
             }
@@ -103584,7 +104180,7 @@ Parameters:
               const relativePath = toRelativePath(resolvedPath, workspaceRoot);
               return `Error editing file: Permission denied - ${relativePath} is outside allowed directories. Use a file path within the project workspace.`;
             }
-            if (!(0, import_fs13.existsSync)(resolvedPath)) {
+            if (!(0, import_fs14.existsSync)(resolvedPath)) {
               return `Error editing file: File not found - ${file_path}. Verify the path is correct and the file exists. Use 'search' to find files by name, or 'create' to make a new file.`;
             }
             if (options.fileTracker && !options.fileTracker.isFileSeen(resolvedPath)) {
@@ -103612,7 +104208,7 @@ Parameters:
 Use the extract tool with targets="${displayPath}" to re-read the file, then retry.`;
               }
             }
-            const content = await import_fs12.promises.readFile(resolvedPath, "utf-8");
+            const content = await import_fs13.promises.readFile(resolvedPath, "utf-8");
             let matchTarget = old_string;
             let matchStrategy = "exact";
             if (!content.includes(old_string)) {
@@ -103644,7 +104240,7 @@ Use the extract tool with targets="${displayPath}" to re-read the file, then ret
             if (newContent === content) {
               return `Error editing file: No changes made - the replacement result is identical to the original. Verify that old_string and new_string are actually different. If fuzzy matching was used, the matched text may already equal new_string.`;
             }
-            await import_fs12.promises.writeFile(resolvedPath, newContent, "utf-8");
+            await import_fs13.promises.writeFile(resolvedPath, newContent, "utf-8");
             if (options.fileTracker) {
               await options.fileTracker.trackFileAfterWrite(resolvedPath);
               options.fileTracker.recordTextEdit(resolvedPath);
@@ -103707,7 +104303,7 @@ Important:
               return `Error creating file: Invalid content - must be a string. Provide the file content as a string value (empty string "" is valid for an empty file).`;
             }
             const effectiveCwd = workingDirectory || cwd || process.cwd();
-            const resolvedPath = (0, import_path16.isAbsolute)(file_path) ? file_path : (0, import_path16.resolve)(effectiveCwd, file_path);
+            const resolvedPath = (0, import_path17.isAbsolute)(file_path) ? file_path : (0, import_path17.resolve)(effectiveCwd, file_path);
             if (debug) {
               console.error(`[Create] Attempting to create file: ${resolvedPath}`);
             }
@@ -103715,13 +104311,13 @@ Important:
               const relativePath = toRelativePath(resolvedPath, workspaceRoot);
               return `Error creating file: Permission denied - ${relativePath} is outside allowed directories. Use a file path within the project workspace.`;
             }
-            if ((0, import_fs13.existsSync)(resolvedPath) && !overwrite) {
+            if ((0, import_fs14.existsSync)(resolvedPath) && !overwrite) {
               return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
             }
-            const existed = (0, import_fs13.existsSync)(resolvedPath);
-            const dir = (0, import_path16.dirname)(resolvedPath);
-            await import_fs12.promises.mkdir(dir, { recursive: true });
-            await import_fs12.promises.writeFile(resolvedPath, content, "utf-8");
+            const existed = (0, import_fs14.existsSync)(resolvedPath);
+            const dir = (0, import_path17.dirname)(resolvedPath);
+            await import_fs13.promises.mkdir(dir, { recursive: true });
+            await import_fs13.promises.writeFile(resolvedPath, content, "utf-8");
             if (options.fileTracker) await options.fileTracker.trackFileAfterWrite(resolvedPath);
             const action = existed && overwrite ? "overwrote" : "created";
             const bytes = Buffer.byteLength(content, "utf-8");
@@ -104362,10 +104958,10 @@ async function listFilesByLevel(options) {
     maxFiles = 100,
     respectGitignore = true
   } = options;
-  if (!import_fs14.default.existsSync(directory)) {
+  if (!import_fs15.default.existsSync(directory)) {
     throw new Error(`Directory does not exist: ${directory}`);
   }
-  const gitDirExists = import_fs14.default.existsSync(import_path17.default.join(directory, ".git"));
+  const gitDirExists = import_fs15.default.existsSync(import_path18.default.join(directory, ".git"));
   if (gitDirExists && respectGitignore) {
     try {
       return await listFilesUsingGit(directory, maxFiles);
@@ -104380,8 +104976,8 @@ async function listFilesUsingGit(directory, maxFiles) {
   const { stdout } = await execAsync3("git ls-files", { cwd: directory });
   const files = stdout.split("\n").filter(Boolean);
   const sortedFiles = files.sort((a, b) => {
-    const depthA = a.split(import_path17.default.sep).length;
-    const depthB = b.split(import_path17.default.sep).length;
+    const depthA = a.split(import_path18.default.sep).length;
+    const depthB = b.split(import_path18.default.sep).length;
     return depthA - depthB;
   });
   return sortedFiles.slice(0, maxFiles);
@@ -104396,25 +104992,25 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   while (queue.length > 0 && result.length < maxFiles) {
     const { dir, level } = queue.shift();
     try {
-      const entries = import_fs14.default.readdirSync(dir, { withFileTypes: true });
+      const entries = import_fs15.default.readdirSync(dir, { withFileTypes: true });
       const files = entries.filter((entry) => {
-        const fullPath = import_path17.default.join(dir, entry.name);
+        const fullPath = import_path18.default.join(dir, entry.name);
         return getEntryTypeSync(entry, fullPath).isFile;
       });
       for (const file2 of files) {
         if (result.length >= maxFiles) break;
-        const filePath = import_path17.default.join(dir, file2.name);
-        const relativePath = import_path17.default.relative(directory, filePath);
+        const filePath = import_path18.default.join(dir, file2.name);
+        const relativePath = import_path18.default.relative(directory, filePath);
         if (shouldIgnore(relativePath, ignorePatterns)) continue;
         result.push(relativePath);
       }
       const dirs = entries.filter((entry) => {
-        const fullPath = import_path17.default.join(dir, entry.name);
+        const fullPath = import_path18.default.join(dir, entry.name);
         return getEntryTypeSync(entry, fullPath).isDirectory;
       });
       for (const subdir of dirs) {
-        const subdirPath = import_path17.default.join(dir, subdir.name);
-        const relativeSubdirPath = import_path17.default.relative(directory, subdirPath);
+        const subdirPath = import_path18.default.join(dir, subdir.name);
+        const relativeSubdirPath = import_path18.default.relative(directory, subdirPath);
         if (shouldIgnore(relativeSubdirPath, ignorePatterns)) continue;
         if (subdir.name === "node_modules" || subdir.name === ".git") continue;
         queue.push({ dir: subdirPath, level: level + 1 });
@@ -104426,12 +105022,12 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   return result;
 }
 function loadGitignorePatterns(directory) {
-  const gitignorePath = import_path17.default.join(directory, ".gitignore");
-  if (!import_fs14.default.existsSync(gitignorePath)) {
+  const gitignorePath = import_path18.default.join(directory, ".gitignore");
+  if (!import_fs15.default.existsSync(gitignorePath)) {
     return [];
   }
   try {
-    const content = import_fs14.default.readFileSync(gitignorePath, "utf8");
+    const content = import_fs15.default.readFileSync(gitignorePath, "utf8");
     return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   } catch (error40) {
     console.error(`Warning: Could not read .gitignore: ${error40.message}`);
@@ -104449,12 +105045,12 @@ function shouldIgnore(filePath, ignorePatterns) {
   }
   return false;
 }
-var import_fs14, import_path17, import_util14, import_child_process10, execAsync3;
+var import_fs15, import_path18, import_util14, import_child_process10, execAsync3;
 var init_file_lister = __esm({
   "src/utils/file-lister.js"() {
     "use strict";
-    import_fs14 = __toESM(require("fs"), 1);
-    import_path17 = __toESM(require("path"), 1);
+    import_fs15 = __toESM(require("fs"), 1);
+    import_path18 = __toESM(require("path"), 1);
     import_util14 = require("util");
     import_child_process10 = require("child_process");
     init_symlink_utils();
@@ -104462,568 +105058,6 @@ var init_file_lister = __esm({
   }
 });
 
-// src/agent/otelLogBridge.js
-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
-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_fs15, import_path18, SimpleTelemetry, SimpleAppTracer;
-var init_simpleTelemetry = __esm({
-  "src/agent/simpleTelemetry.js"() {
-    "use strict";
-    import_fs15 = require("fs");
-    import_path18 = 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_path18.dirname)(this.filePath);
-          if (!(0, import_fs15.existsSync)(dir)) {
-            (0, import_fs15.mkdirSync)(dir, { recursive: true });
-          }
-          this.stream = (0, import_fs15.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 = {}) {
-        if (!this.isEnabled()) {
-          return fn();
-        }
-        const span = this.telemetry.createSpan(spanName, {
-          "session.id": this.sessionId,
-          ...attributes
-        });
-        try {
-          const result = await fn();
-          span.setStatus("OK");
-          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();
-        }
-      }
-    };
-  }
-});
-
 // src/agent/storage/index.js
 var init_storage = __esm({
   "src/agent/storage/index.js"() {