llmist 16.0.2 → 16.0.4

package/dist/index.cjs

@@ -658,11 +658,11 @@ var init_execution_tree = __esm({
             yield this.eventQueue.shift();
           }
           if (this.isCompleted) break;
-          const event = await new Promise((resolve) => {
+          const event = await new Promise((resolve2) => {
             if (this.eventQueue.length > 0) {
-              resolve(this.eventQueue.shift());
+              resolve2(this.eventQueue.shift());
             } else {
-              this.eventWaiters.push(resolve);
+              this.eventWaiters.push(resolve2);
             }
           });
           yield event;
@@ -3978,6 +3978,23 @@ var init_hook_validators = __esm({
   }
 });
 
+// src/agent/safe-observe.ts
+async function safeObserve(fn, logger2, label) {
+  try {
+    await fn();
+  } catch (error) {
+    const message = label ? `Observer error in ${label}:` : "Observer threw error (ignoring)";
+    logger2.error(message, {
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+var init_safe_observe = __esm({
+  "src/agent/safe-observe.ts"() {
+    "use strict";
+  }
+});
+
 // src/gadgets/registry.ts
 var GadgetRegistry;
 var init_registry = __esm({
@@ -4084,6 +4101,62 @@ var init_registry = __esm({
 });
 
 // src/agent/file-logging.ts
+function createFileLoggingState() {
+  return {
+    counters: /* @__PURE__ */ new Map(),
+    subagentDirectories: /* @__PURE__ */ new Map(),
+    activeDirectoryByContext: /* @__PURE__ */ new Map()
+  };
+}
+function getDefaultState() {
+  if (!defaultState) {
+    defaultState = createFileLoggingState();
+  }
+  return defaultState;
+}
+function getNextCounter(state, directory) {
+  const current = state.counters.get(directory) ?? 0;
+  const next = current + 1;
+  state.counters.set(directory, next);
+  return next;
+}
+function getContextKey(subagentContext) {
+  if (!subagentContext) return "root:0";
+  return `${subagentContext.parentGadgetInvocationId}:${subagentContext.depth}`;
+}
+function resetFileLoggingState() {
+  defaultState = void 0;
+}
+function findParentContextKey(state, currentDepth) {
+  const parentDepth = currentDepth - 1;
+  if (parentDepth === 0) return "root:0";
+  for (const [key, _path] of state.activeDirectoryByContext) {
+    if (key.endsWith(`:${parentDepth}`)) {
+      return key;
+    }
+  }
+  return "root:0";
+}
+function resolveLoggingDirectory(state, baseDirectory, counterPadding, subagentContext) {
+  const contextKey = getContextKey(subagentContext);
+  if (!subagentContext) {
+    state.activeDirectoryByContext.set(contextKey, baseDirectory);
+    return baseDirectory;
+  }
+  const { parentGadgetInvocationId, depth } = subagentContext;
+  const parentContextKey = findParentContextKey(state, depth);
+  const parentDir = state.activeDirectoryByContext.get(parentContextKey) ?? baseDirectory;
+  const subagentKey = `${parentDir}:${parentGadgetInvocationId}`;
+  let fullPath = state.subagentDirectories.get(subagentKey);
+  if (!fullPath) {
+    const chronoNumber = getNextCounter(state, parentDir);
+    const subdirName = `${formatCallNumber(chronoNumber, counterPadding)}-${parentGadgetInvocationId}`;
+    fullPath = (0, import_node_path3.join)(parentDir, subdirName);
+    state.subagentDirectories.set(subagentKey, fullPath);
+  }
+  state.activeDirectoryByContext.set(contextKey, fullPath);
+  return fullPath;
+}
 function formatLlmRequest(messages) {
   const lines = [];
   for (const msg of messages) {
@@ -4100,16 +4173,20 @@ async function writeLogFile(dir, filename, content) {
   await (0, import_promises2.mkdir)(dir, { recursive: true });
   await (0, import_promises2.writeFile)((0, import_node_path3.join)(dir, filename), content, "utf-8");
 }
-function createFileLoggingHooks(options) {
+function createFileLoggingHooks(options, state = getDefaultState()) {
   const {
-    directory,
     startingCounter = 1,
     counterPadding = 4,
     skipSubagents = true,
     formatRequest = formatLlmRequest,
     onFileWritten
   } = options;
-  let callCounter = startingCounter - 1;
+  const baseDirectory = (0, import_node_path3.resolve)(options.directory);
+  if (!state.counters.has(baseDirectory)) {
+    state.counters.set(baseDirectory, startingCounter - 1);
+  }
+  let currentCallNumber = 0;
+  let currentDirectory = baseDirectory;
   return {
     observers: {
       /**
@@ -4119,17 +4196,25 @@ function createFileLoggingHooks(options) {
         if (skipSubagents && context.subagentContext) {
           return;
         }
-        callCounter++;
-        const filename = `${formatCallNumber(callCounter, counterPadding)}.request`;
+        currentDirectory = resolveLoggingDirectory(
+          state,
+          baseDirectory,
+          counterPadding,
+          context.subagentContext
+        );
+        currentCallNumber = getNextCounter(state, currentDirectory);
+        const filename = `${formatCallNumber(currentCallNumber, counterPadding)}.request`;
         const content = formatRequest(context.options.messages);
         try {
-          await writeLogFile(directory, filename, content);
+          await writeLogFile(currentDirectory, filename, content);
           if (onFileWritten) {
             onFileWritten({
-              filePath: (0, import_node_path3.join)(directory, filename),
+              filePath: (0, import_node_path3.join)(currentDirectory, filename),
               type: "request",
-              callNumber: callCounter,
-              contentLength: content.length
+              callNumber: currentCallNumber,
+              contentLength: content.length,
+              parentGadgetInvocationId: context.subagentContext?.parentGadgetInvocationId,
+              depth: context.subagentContext?.depth
             });
           }
         } catch (error) {
@@ -4143,16 +4228,22 @@ function createFileLoggingHooks(options) {
         if (skipSubagents && context.subagentContext) {
           return;
         }
-        const filename = `${formatCallNumber(callCounter, counterPadding)}.response`;
+        if (currentCallNumber === 0) {
+          console.warn("[file-logging] Skipping response write: no matching request recorded");
+          return;
+        }
+        const filename = `${formatCallNumber(currentCallNumber, counterPadding)}.response`;
         const content = context.rawResponse;
         try {
-          await writeLogFile(directory, filename, content);
+          await writeLogFile(currentDirectory, filename, content);
           if (onFileWritten) {
             onFileWritten({
-              filePath: (0, import_node_path3.join)(directory, filename),
+              filePath: (0, import_node_path3.join)(currentDirectory, filename),
               type: "response",
-              callNumber: callCounter,
-              contentLength: content.length
+              callNumber: currentCallNumber,
+              contentLength: content.length,
+              parentGadgetInvocationId: context.subagentContext?.parentGadgetInvocationId,
+              depth: context.subagentContext?.depth
             });
           }
         } catch (error) {
@@ -4169,7 +4260,7 @@ function getEnvFileLoggingHooks() {
   }
   return createFileLoggingHooks({ directory });
 }
-var import_promises2, import_node_path3, ENV_LOG_RAW_DIRECTORY;
+var import_promises2, import_node_path3, defaultState, ENV_LOG_RAW_DIRECTORY;
 var init_file_logging = __esm({
   "src/agent/file-logging.ts"() {
     "use strict";
@@ -4358,6 +4449,8 @@ var init_hook_presets = __esm({
       /**
        * Tracks cumulative token usage across all LLM calls.
        *
+       * @public
+       *
        * **Output:**
        * - Per-call token count with 📊 emoji
        * - Cumulative total across all calls
@@ -4620,6 +4713,8 @@ var init_hook_presets = __esm({
       /**
        * Logs detailed error information for debugging and troubleshooting.
        *
+       * @public
+       *
        * **Output:**
        * - LLM errors with ❌ emoji, including model and recovery status
        * - Gadget errors with full context (parameters, error message)
@@ -4698,6 +4793,8 @@ var init_hook_presets = __esm({
       /**
        * Tracks context compaction events.
        *
+       * @public
+       *
        * **Output:**
        * - Compaction events with 🗜️ emoji
        * - Strategy name, tokens before/after, and savings
@@ -4811,6 +4908,8 @@ var init_hook_presets = __esm({
       /**
        * Returns empty hook configuration for clean output without any logging.
        *
+       * @public
+       *
        * **Output:**
        * - None. Returns {} (empty object).
        *
@@ -4968,6 +5067,8 @@ var init_hook_presets = __esm({
       /**
        * Composite preset combining logging, timing, tokenTracking, and errorLogging.
        *
+       * @public
+       *
        * This is the recommended preset for development and initial production deployments,
        * providing comprehensive observability with a single method call.
        *
@@ -11918,7 +12019,9 @@ ${endPrefix}`
        */
       /**
        * Build AgentOptions with the given user prompt.
-       * Centralizes options construction for ask(), askWithImage(), and askWithContent().
+       * Centralizes options construction for ask(), askWithImage(), askWithContent(), and build().
+       *
+       * @param userPrompt - Optional user prompt (omitted for build() which has no prompt)
        */
       buildAgentOptions(userPrompt) {
         if (!this.client) {
@@ -11960,7 +12063,12 @@ ${endPrefix}`
           // Tree context for shared tree model (subagents share parent's tree)
           parentTree: this.parentContext?.tree,
           parentNodeId: this.parentContext?.nodeId,
-          baseDepth: this.parentContext ? (this.parentContext.depth ?? 0) + 1 : 0
+          baseDepth: this.parentContext ? (this.parentContext.depth ?? 0) + 1 : 0,
+          // Parent observer hooks for subagent visibility
+          parentObservers: this.parentObservers,
+          // Shared rate limit tracker and retry config (for coordinated limits across subagents)
+          sharedRateLimitTracker: this.sharedRateLimitTracker,
+          sharedRetryConfig: this.sharedRetryConfig
         };
       }
       ask(userPrompt) {
@@ -12112,52 +12220,7 @@ ${endPrefix}`
        * ```
        */
       build() {
-        if (!this.client) {
-          const { LLMist: LLMistClass } = (init_client(), __toCommonJS(client_exports));
-          this.client = new LLMistClass();
-        }
-        const registry = GadgetRegistry.from(this.gadgets);
-        const options = {
-          client: this.client,
-          model: this.model ?? "openai:gpt-5-nano",
-          systemPrompt: this.systemPrompt,
-          // No userPrompt - agent.run() will throw if called directly
-          registry,
-          maxIterations: this.maxIterations,
-          budget: this.budget,
-          temperature: this.temperature,
-          logger: this.logger,
-          hooks: this.composeHooks(),
-          promptConfig: this.promptConfig,
-          initialMessages: this.initialMessages,
-          requestHumanInput: this.requestHumanInput,
-          gadgetStartPrefix: this.gadgetStartPrefix,
-          gadgetEndPrefix: this.gadgetEndPrefix,
-          gadgetArgPrefix: this.gadgetArgPrefix,
-          textOnlyHandler: this.textOnlyHandler,
-          textWithGadgetsHandler: this.textWithGadgetsHandler,
-          defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs,
-          gadgetExecutionMode: this.gadgetExecutionMode,
-          maxGadgetsPerResponse: this.maxGadgetsPerResponse,
-          gadgetOutputLimit: this.gadgetOutputLimit,
-          gadgetOutputLimitPercent: this.gadgetOutputLimitPercent,
-          compactionConfig: this.compactionConfig,
-          retryConfig: this.retryConfig,
-          rateLimitConfig: this.rateLimitConfig,
-          signal: this.signal,
-          reasoning: this.reasoningConfig,
-          caching: this.cachingConfig,
-          subagentConfig: this.subagentConfig,
-          // Tree context for shared tree model (subagents share parent's tree)
-          parentTree: this.parentContext?.tree,
-          parentNodeId: this.parentContext?.nodeId,
-          baseDepth: this.parentContext ? (this.parentContext.depth ?? 0) + 1 : 0,
-          // Parent observer hooks for subagent visibility
-          parentObservers: this.parentObservers,
-          // Shared rate limit tracker and retry config (for coordinated limits across subagents)
-          sharedRateLimitTracker: this.sharedRateLimitTracker,
-          sharedRetryConfig: this.sharedRetryConfig
-        };
+        const options = this.buildAgentOptions();
         return new Agent(AGENT_INTERNAL_KEY, options);
       }
     };
@@ -13445,137 +13508,549 @@ var init_executor = __esm({
   }
 });
 
-// src/agent/tree-hook-bridge.ts
-function findParentGadgetInvocationId(tree, nodeId) {
-  let currentId = nodeId;
-  while (currentId) {
-    const node = tree.getNode(currentId);
-    if (!node) break;
-    currentId = node.parentId;
-    if (!currentId) break;
-    const parentNode = tree.getNode(currentId);
-    if (parentNode?.type === "gadget") {
-      return parentNode.invocationId;
-    }
-  }
-  return void 0;
-}
-function getIterationFromTree(tree, nodeId) {
-  let currentId = nodeId;
-  while (currentId) {
-    const node = tree.getNode(currentId);
-    if (!node) break;
-    if (node.type === "llm_call") {
-      return node.iteration;
-    }
-    currentId = node.parentId;
-  }
-  return 0;
-}
-function buildSubagentContext(tree, event) {
-  const parentGadgetInvocationId = findParentGadgetInvocationId(tree, event.nodeId);
-  if (!parentGadgetInvocationId) {
-    return void 0;
-  }
-  return {
-    parentGadgetInvocationId,
-    depth: event.depth
-  };
-}
-function getSubagentContextForNode(tree, nodeId) {
-  const node = tree.getNode(nodeId);
-  if (!node) return void 0;
-  const parentGadgetInvocationId = findParentGadgetInvocationId(tree, nodeId);
-  if (!parentGadgetInvocationId) {
-    return void 0;
-  }
-  return {
-    parentGadgetInvocationId,
-    depth: node.depth
-  };
-}
-async function safeObserve(fn, logger2, eventType) {
-  try {
-    await fn();
-  } catch (error) {
-    logger2.warn(`Observer error in ${eventType}:`, error);
-  }
-}
-function chainObserverCall(chainMap, key, fn, logger2, eventType, cleanup = false) {
-  const previousPromise = chainMap.get(key) ?? Promise.resolve();
-  const newPromise = previousPromise.then(() => safeObserve(fn, logger2, eventType));
-  chainMap.set(key, newPromise);
-  if (cleanup) {
-    newPromise.finally(() => chainMap.delete(key));
-  }
-}
-function bridgeTreeToHooks(tree, hooks, logger2) {
-  const gadgetPromiseChains = /* @__PURE__ */ new Map();
-  const llmPromiseChains = /* @__PURE__ */ new Map();
-  return tree.onAll((event) => {
-    const subagentContext = buildSubagentContext(tree, event);
-    switch (event.type) {
-      // =================================================================
-      // GADGET EVENTS - Bridged for subagent visibility
-      // =================================================================
-      // When a subagent executes gadgets, these events propagate through
-      // the shared tree to the parent's hooks.
-      // Only bridged for subagent events (depth > 0) to avoid double-calling
-      // root agent events which are handled directly in stream-processor.ts
-      case "gadget_start": {
-        if (subagentContext && hooks.observers?.onGadgetExecutionStart) {
-          const gadgetEvent = event;
-          const gadgetNode = tree.getNode(event.nodeId);
-          const context = {
-            iteration: getIterationFromTree(tree, event.nodeId),
-            gadgetName: gadgetEvent.name,
-            invocationId: gadgetEvent.invocationId,
-            parameters: gadgetNode?.parameters ?? {},
-            logger: logger2,
-            subagentContext
-          };
-          chainObserverCall(
-            gadgetPromiseChains,
-            gadgetEvent.invocationId,
-            () => hooks.observers?.onGadgetExecutionStart?.(context),
-            logger2,
-            "onGadgetExecutionStart",
-            false
-            // Don't cleanup - wait for completion event
-          );
-        }
-        break;
+// src/agent/gadget-concurrency-manager.ts
+var GadgetConcurrencyManager;
+var init_gadget_concurrency_manager = __esm({
+  "src/agent/gadget-concurrency-manager.ts"() {
+    "use strict";
+    init_logger();
+    GadgetConcurrencyManager = class {
+      registry;
+      subagentConfig;
+      logger;
+      /** Track active execution count per gadget name */
+      activeCountByGadget = /* @__PURE__ */ new Map();
+      /** Queue of gadgets waiting for a concurrency slot (per gadget name) */
+      concurrencyQueue = /* @__PURE__ */ new Map();
+      /** All active gadget promises, keyed by invocationId */
+      inFlightExecutions = /* @__PURE__ */ new Map();
+      /** Queue of exclusive gadgets deferred until in-flight gadgets complete */
+      exclusiveQueue = [];
+      constructor(options) {
+        this.registry = options.registry;
+        this.subagentConfig = options.subagentConfig;
+        this.logger = options.logger ?? createLogger({ name: "llmist:gadget-concurrency-manager" });
       }
-      case "gadget_complete": {
-        if (subagentContext && hooks.observers?.onGadgetExecutionComplete) {
-          const gadgetEvent = event;
-          const gadgetNode = tree.getNode(event.nodeId);
-          const context = {
-            iteration: getIterationFromTree(tree, event.nodeId),
-            gadgetName: gadgetEvent.name,
-            invocationId: gadgetEvent.invocationId,
-            parameters: gadgetNode?.parameters ?? {},
-            finalResult: gadgetEvent.result,
-            executionTimeMs: gadgetEvent.executionTimeMs,
-            cost: gadgetEvent.cost,
-            logger: logger2,
-            subagentContext
-          };
-          chainObserverCall(
-            gadgetPromiseChains,
-            gadgetEvent.invocationId,
-            () => hooks.observers?.onGadgetExecutionComplete?.(context),
-            logger2,
-            "onGadgetExecutionComplete",
-            true
-            // Cleanup after completion
-          );
+      // ==========================================================================
+      // Concurrency limit resolution
+      // ==========================================================================
+      /**
+       * Get the effective concurrency limit for a gadget.
+       * Uses "most restrictive wins" strategy: the lowest non-zero value from
+       * external config (SubagentConfig) and gadget's intrinsic maxConcurrent.
+       *
+       * This ensures gadget authors can set safety floors (e.g., maxConcurrent: 1
+       * for file writers) that cannot be weakened by external configuration.
+       *
+       * @returns 0 if unlimited, otherwise the effective limit
+       */
+      getConcurrencyLimit(gadgetName) {
+        const configLimit = this.subagentConfig?.[gadgetName]?.maxConcurrent;
+        const gadget = this.registry.get(gadgetName);
+        const gadgetLimit = gadget?.maxConcurrent;
+        const config = configLimit || Number.POSITIVE_INFINITY;
+        const intrinsic = gadgetLimit || Number.POSITIVE_INFINITY;
+        const effective = Math.min(config, intrinsic);
+        return effective === Number.POSITIVE_INFINITY ? 0 : effective;
+      }
+      // ==========================================================================
+      // Concurrency checks
+      // ==========================================================================
+      /**
+       * Check whether a gadget call can start immediately given current concurrency state.
+       * Returns false if:
+       * - The gadget is exclusive and other gadgets are in-flight
+       * - The gadget has a concurrency limit and it is already reached
+       *
+       * Does NOT modify any state.
+       */
+      canStart(call) {
+        const gadget = this.registry.get(call.gadgetName);
+        if (gadget?.exclusive && this.inFlightExecutions.size > 0) {
+          return false;
         }
-        break;
+        const limit = this.getConcurrencyLimit(call.gadgetName);
+        if (limit > 0) {
+          const activeCount = this.activeCountByGadget.get(call.gadgetName) ?? 0;
+          if (activeCount >= limit) {
+            return false;
+          }
+        }
+        return true;
       }
-      case "gadget_error": {
-        if (subagentContext && hooks.observers?.onGadgetExecutionComplete) {
-          const gadgetEvent = event;
+      /**
+       * Check whether a gadget is marked as exclusive.
+       */
+      isExclusive(gadgetName) {
+        const gadget = this.registry.get(gadgetName);
+        return gadget?.exclusive === true;
+      }
+      /**
+       * Get the current count of in-flight (actively executing) gadgets.
+       */
+      get inFlightCount() {
+        return this.inFlightExecutions.size;
+      }
+      /**
+       * Get the total count of actively executing gadgets across all gadget types.
+       * Used to know when all work is truly complete.
+       */
+      getTotalActiveGadgetCount() {
+        let total = 0;
+        for (const count of this.activeCountByGadget.values()) {
+          total += count;
+        }
+        return total;
+      }
+      /**
+       * Check if there are any gadgets waiting in concurrency queues.
+       */
+      hasQueuedGadgets() {
+        for (const queue of this.concurrencyQueue.values()) {
+          if (queue.length > 0) return true;
+        }
+        return false;
+      }
+      /**
+       * Get total count of queued gadgets across all queues.
+       */
+      getQueuedGadgetCount() {
+        let count = 0;
+        for (const queue of this.concurrencyQueue.values()) {
+          count += queue.length;
+        }
+        return count;
+      }
+      /**
+       * Check if there are exclusive gadgets waiting.
+       */
+      get hasExclusiveQueued() {
+        return this.exclusiveQueue.length > 0;
+      }
+      /**
+       * Drain and return all exclusive gadgets from the queue.
+       * The caller is responsible for executing them.
+       */
+      drainExclusiveQueue() {
+        const queue = this.exclusiveQueue;
+        this.exclusiveQueue = [];
+        return queue;
+      }
+      // ==========================================================================
+      // State mutation
+      // ==========================================================================
+      /**
+       * Track an in-flight gadget execution.
+       * Increments the active count for the gadget name and registers the promise.
+       *
+       * @param invocationId - Unique ID for this execution
+       * @param gadgetName - Name of the gadget being executed
+       * @param promise - The execution promise to track
+       */
+      trackExecution(invocationId, gadgetName, promise) {
+        const currentCount = this.activeCountByGadget.get(gadgetName) ?? 0;
+        this.activeCountByGadget.set(gadgetName, currentCount + 1);
+        this.inFlightExecutions.set(invocationId, promise);
+      }
+      /**
+       * Called when a gadget execution completes.
+       * Decrements active count and triggers queue processing if a slot opened up.
+       *
+       * @param gadgetName - Name of the gadget that completed
+       * @returns The next queued gadget call for this gadget, if one was promoted, otherwise null
+       */
+      onComplete(gadgetName) {
+        const newCount = (this.activeCountByGadget.get(gadgetName) ?? 1) - 1;
+        this.activeCountByGadget.set(gadgetName, newCount);
+        return this.promoteFromQueue(gadgetName);
+      }
+      /**
+       * Queue a gadget for later execution due to a concurrency limit being reached.
+       *
+       * @param call - The gadget call to defer
+       */
+      queueForLater(call) {
+        this.logger.debug("Gadget queued due to concurrency limit", {
+          gadgetName: call.gadgetName,
+          invocationId: call.invocationId,
+          activeCount: this.activeCountByGadget.get(call.gadgetName) ?? 0,
+          limit: this.getConcurrencyLimit(call.gadgetName)
+        });
+        const queue = this.concurrencyQueue.get(call.gadgetName) ?? [];
+        queue.push(call);
+        this.concurrencyQueue.set(call.gadgetName, queue);
+      }
+      /**
+       * Queue a gadget for exclusive execution (after all in-flight complete).
+       *
+       * @param call - The exclusive gadget call to defer
+       */
+      queueExclusive(call) {
+        this.logger.debug("Deferring exclusive gadget until in-flight gadgets complete", {
+          gadgetName: call.gadgetName,
+          invocationId: call.invocationId,
+          inFlightCount: this.inFlightExecutions.size
+        });
+        this.exclusiveQueue.push(call);
+      }
+      /**
+       * Clear the inFlightExecutions map after all promises have completed.
+       * Called after waitForAll resolves.
+       */
+      clearInFlight() {
+        this.inFlightExecutions.clear();
+      }
+      // ==========================================================================
+      // Waiting
+      // ==========================================================================
+      /**
+       * Wait for all currently in-flight gadget executions to complete.
+       * Resolves when the Promise.all of all tracked promises resolves.
+       *
+       * Note: new executions may be started during waiting (from the queue).
+       * Callers should loop until inFlightCount === 0 AND hasQueuedGadgets() === false.
+       */
+      async waitForAll() {
+        if (this.inFlightExecutions.size === 0) return;
+        await Promise.all(this.inFlightExecutions.values());
+      }
+      /**
+       * Get a promise that resolves when all current in-flight executions complete.
+       * Returns a resolved promise if no executions are in-flight.
+       */
+      getAllDonePromise() {
+        if (this.inFlightExecutions.size === 0) {
+          return Promise.resolve("done");
+        }
+        return Promise.all(this.inFlightExecutions.values()).then(() => "done");
+      }
+      // ==========================================================================
+      // Private helpers
+      // ==========================================================================
+      /**
+       * Check the concurrency queue for a gadget name and promote the next queued
+       * call if a slot is available.
+       *
+       * @param gadgetName - The gadget name to check
+       * @returns The promoted call, or null if queue is empty or limit still reached
+       */
+      promoteFromQueue(gadgetName) {
+        const queue = this.concurrencyQueue.get(gadgetName);
+        if (!queue || queue.length === 0) return null;
+        const limit = this.getConcurrencyLimit(gadgetName);
+        const activeCount = this.activeCountByGadget.get(gadgetName) ?? 0;
+        if (limit === 0 || activeCount < limit) {
+          const nextCall = queue.shift();
+          this.logger.debug("Processing queued gadget", {
+            gadgetName,
+            invocationId: nextCall.invocationId,
+            remainingInQueue: queue.length
+          });
+          return nextCall;
+        }
+        return null;
+      }
+    };
+  }
+});
+
+// src/agent/gadget-dependency-resolver.ts
+var GadgetDependencyResolver;
+var init_gadget_dependency_resolver = __esm({
+  "src/agent/gadget-dependency-resolver.ts"() {
+    "use strict";
+    GadgetDependencyResolver = class {
+      /** Gadgets waiting for their dependencies to complete */
+      gadgetsAwaitingDependencies = /* @__PURE__ */ new Map();
+      /** Completed gadget results, keyed by invocation ID */
+      completedResults = /* @__PURE__ */ new Map();
+      /** Invocation IDs of gadgets that have failed (error or skipped due to dependency) */
+      failedInvocations = /* @__PURE__ */ new Set();
+      /** Invocation IDs completed in previous iterations (read-only) */
+      priorCompletedInvocations;
+      /** Invocation IDs that failed in previous iterations (read-only) */
+      priorFailedInvocations;
+      constructor(options = {}) {
+        this.priorCompletedInvocations = options.priorCompletedInvocations ?? /* @__PURE__ */ new Set();
+        this.priorFailedInvocations = options.priorFailedInvocations ?? /* @__PURE__ */ new Set();
+      }
+      // ==========================================================================
+      // State mutation
+      // ==========================================================================
+      /**
+       * Queue a gadget call that is waiting for one or more dependencies to complete.
+       * Call this when a gadget's dependencies are not yet all satisfied.
+       *
+       * @param call - The parsed gadget call to defer
+       */
+      addPending(call) {
+        this.gadgetsAwaitingDependencies.set(call.invocationId, call);
+      }
+      /**
+       * Record that a gadget completed successfully.
+       * This may unblock other gadgets that depend on this invocation.
+       *
+       * Also marks as failed if the result contains an error.
+       *
+       * @param result - The completed gadget execution result
+       */
+      markComplete(result) {
+        this.completedResults.set(result.invocationId, result);
+        if (result.error) {
+          this.failedInvocations.add(result.invocationId);
+        }
+      }
+      /**
+       * Mark an invocation ID as failed without recording a full result.
+       * Use this for gadgets that are skipped before execution (e.g., limit exceeded,
+       * self-referential dependency, dependency skip).
+       *
+       * @param invocationId - The invocation ID to mark as failed
+       */
+      markFailed(invocationId) {
+        this.failedInvocations.add(invocationId);
+      }
+      /**
+       * Remove a gadget from the pending queue (called just before execution).
+       *
+       * @param invocationId - The invocation ID to remove from pending
+       */
+      removePending(invocationId) {
+        this.gadgetsAwaitingDependencies.delete(invocationId);
+      }
+      /**
+       * Clear all remaining pending gadgets (e.g., after handling unresolvable deps).
+       */
+      clearPending() {
+        this.gadgetsAwaitingDependencies.clear();
+      }
+      // ==========================================================================
+      // Queries
+      // ==========================================================================
+      /**
+       * Get all gadget calls currently waiting for dependencies.
+       * Returns entries as [invocationId, call] pairs.
+       */
+      getPendingEntries() {
+        return Array.from(this.gadgetsAwaitingDependencies.entries());
+      }
+      /**
+       * Get the number of gadgets currently waiting for dependencies.
+       */
+      get pendingCount() {
+        return this.gadgetsAwaitingDependencies.size;
+      }
+      /**
+       * Check whether a given invocation ID has been completed successfully
+       * (either in this iteration or a prior one).
+       */
+      isCompleted(invocationId) {
+        return this.completedResults.has(invocationId) || this.priorCompletedInvocations.has(invocationId);
+      }
+      /**
+       * Check whether a given invocation ID has failed
+       * (either in this iteration or a prior one).
+       */
+      isFailed(invocationId) {
+        return this.failedInvocations.has(invocationId) || this.priorFailedInvocations.has(invocationId);
+      }
+      /**
+       * Get the execution result for a completed invocation, if available.
+       * Only returns results from the current iteration; prior iterations
+       * are tracked by ID only.
+       */
+      getCompletedResult(invocationId) {
+        return this.completedResults.get(invocationId);
+      }
+      /**
+       * Check if all dependencies for a gadget call are satisfied.
+       * A dependency is satisfied if it completed in this or a prior iteration.
+       *
+       * @param call - The gadget call whose dependencies to check
+       * @returns true if all deps are satisfied, false if any are still pending
+       */
+      isAllSatisfied(call) {
+        return call.dependencies.every((dep) => this.isCompleted(dep));
+      }
+      /**
+       * Find the first failed dependency for a gadget call, if any.
+       * A dependency is considered failed if it failed in this or a prior iteration.
+       *
+       * @param call - The gadget call to check
+       * @returns The invocation ID of the failed dependency, or undefined if none
+       */
+      getFailedDependency(call) {
+        return call.dependencies.find((dep) => this.isFailed(dep));
+      }
+      /**
+       * Separate the pending gadgets into two groups:
+       * - Those ready to execute (all deps satisfied)
+       * - Those ready to skip (at least one dep has failed)
+       *
+       * Gadgets that are neither ready nor skippable remain pending.
+       *
+       * @returns Object with `readyToExecute` and `readyToSkip` arrays
+       */
+      getReadyCalls() {
+        const readyToExecute = [];
+        const readyToSkip = [];
+        for (const [_invocationId, call] of this.gadgetsAwaitingDependencies) {
+          const failedDep = this.getFailedDependency(call);
+          if (failedDep) {
+            readyToSkip.push({ call, failedDep });
+            continue;
+          }
+          if (this.isAllSatisfied(call)) {
+            readyToExecute.push(call);
+          }
+        }
+        return { readyToExecute, readyToSkip };
+      }
+      // ==========================================================================
+      // Cross-iteration accessors (for Agent to accumulate state)
+      // ==========================================================================
+      /**
+       * Get all invocation IDs that completed successfully in this iteration.
+       * Used by Agent to accumulate completed IDs across iterations.
+       */
+      getCompletedInvocationIds() {
+        return new Set(this.completedResults.keys());
+      }
+      /**
+       * Get all invocation IDs that failed in this iteration.
+       * Used by Agent to accumulate failed IDs across iterations.
+       */
+      getFailedInvocationIds() {
+        return new Set(this.failedInvocations);
+      }
+    };
+  }
+});
+
+// src/agent/tree-hook-bridge.ts
+function findParentGadgetInvocationId(tree, nodeId) {
+  let currentId = nodeId;
+  while (currentId) {
+    const node = tree.getNode(currentId);
+    if (!node) break;
+    currentId = node.parentId;
+    if (!currentId) break;
+    const parentNode = tree.getNode(currentId);
+    if (parentNode?.type === "gadget") {
+      return parentNode.invocationId;
+    }
+  }
+  return void 0;
+}
+function getIterationFromTree(tree, nodeId) {
+  let currentId = nodeId;
+  while (currentId) {
+    const node = tree.getNode(currentId);
+    if (!node) break;
+    if (node.type === "llm_call") {
+      return node.iteration;
+    }
+    currentId = node.parentId;
+  }
+  return 0;
+}
+function buildSubagentContext(tree, event) {
+  const parentGadgetInvocationId = findParentGadgetInvocationId(tree, event.nodeId);
+  if (!parentGadgetInvocationId) {
+    return void 0;
+  }
+  return {
+    parentGadgetInvocationId,
+    depth: event.depth
+  };
+}
+function getSubagentContextForNode(tree, nodeId) {
+  const node = tree.getNode(nodeId);
+  if (!node) return void 0;
+  const parentGadgetInvocationId = findParentGadgetInvocationId(tree, nodeId);
+  if (!parentGadgetInvocationId) {
+    return void 0;
+  }
+  return {
+    parentGadgetInvocationId,
+    depth: node.depth
+  };
+}
+function chainObserverCall(chainMap, key, fn, logger2, eventType, cleanup = false) {
+  const previousPromise = chainMap.get(key) ?? Promise.resolve();
+  const newPromise = previousPromise.then(() => safeObserve(fn, logger2, eventType));
+  chainMap.set(key, newPromise);
+  if (cleanup) {
+    newPromise.finally(() => chainMap.delete(key));
+  }
+}
+function bridgeTreeToHooks(tree, hooks, logger2) {
+  const gadgetPromiseChains = /* @__PURE__ */ new Map();
+  const llmPromiseChains = /* @__PURE__ */ new Map();
+  return tree.onAll((event) => {
+    const subagentContext = buildSubagentContext(tree, event);
+    switch (event.type) {
+      // =================================================================
+      // GADGET EVENTS - Bridged for subagent visibility
+      // =================================================================
+      // When a subagent executes gadgets, these events propagate through
+      // the shared tree to the parent's hooks.
+      // Only bridged for subagent events (depth > 0) to avoid double-calling
+      // root agent events which are handled directly in stream-processor.ts
+      case "gadget_start": {
+        if (subagentContext && hooks.observers?.onGadgetExecutionStart) {
+          const gadgetEvent = event;
+          const gadgetNode = tree.getNode(event.nodeId);
+          const context = {
+            iteration: getIterationFromTree(tree, event.nodeId),
+            gadgetName: gadgetEvent.name,
+            invocationId: gadgetEvent.invocationId,
+            parameters: gadgetNode?.parameters ?? {},
+            logger: logger2,
+            subagentContext
+          };
+          chainObserverCall(
+            gadgetPromiseChains,
+            gadgetEvent.invocationId,
+            () => hooks.observers?.onGadgetExecutionStart?.(context),
+            logger2,
+            "onGadgetExecutionStart",
+            false
+            // Don't cleanup - wait for completion event
+          );
+        }
+        break;
+      }
+      case "gadget_complete": {
+        if (subagentContext && hooks.observers?.onGadgetExecutionComplete) {
+          const gadgetEvent = event;
+          const gadgetNode = tree.getNode(event.nodeId);
+          const context = {
+            iteration: getIterationFromTree(tree, event.nodeId),
+            gadgetName: gadgetEvent.name,
+            invocationId: gadgetEvent.invocationId,
+            parameters: gadgetNode?.parameters ?? {},
+            finalResult: gadgetEvent.result,
+            executionTimeMs: gadgetEvent.executionTimeMs,
+            cost: gadgetEvent.cost,
+            logger: logger2,
+            subagentContext
+          };
+          chainObserverCall(
+            gadgetPromiseChains,
+            gadgetEvent.invocationId,
+            () => hooks.observers?.onGadgetExecutionComplete?.(context),
+            logger2,
+            "onGadgetExecutionComplete",
+            true
+            // Cleanup after completion
+          );
+        }
+        break;
+      }
+      case "gadget_error": {
+        if (subagentContext && hooks.observers?.onGadgetExecutionComplete) {
+          const gadgetEvent = event;
           const gadgetNode = tree.getNode(event.nodeId);
           const context = {
             iteration: getIterationFromTree(tree, event.nodeId),
@@ -13724,6 +14199,82 @@ function bridgeTreeToHooks(tree, hooks, logger2) {
 var init_tree_hook_bridge = __esm({
   "src/agent/tree-hook-bridge.ts"() {
     "use strict";
+    init_safe_observe();
+  }
+});
+
+// src/agent/observer-notifier.ts
+async function notifyGadgetSkipped(ctx) {
+  const gadgetNode = ctx.tree?.getNodeByInvocationId(ctx.invocationId);
+  const subagentContext = ctx.tree && gadgetNode ? getSubagentContextForNode(ctx.tree, gadgetNode.id) : void 0;
+  const context = {
+    iteration: ctx.iteration,
+    gadgetName: ctx.gadgetName,
+    invocationId: ctx.invocationId,
+    parameters: ctx.parameters,
+    failedDependency: ctx.failedDependency,
+    failedDependencyError: ctx.failedDependencyError,
+    logger: ctx.logger,
+    subagentContext
+  };
+  if (ctx.hooks?.onGadgetSkipped) {
+    const hookFn = ctx.hooks.onGadgetSkipped;
+    await safeObserve(() => hookFn(context), ctx.logger);
+  }
+  if (ctx.parentObservers?.onGadgetSkipped) {
+    const hookFn = ctx.parentObservers.onGadgetSkipped;
+    await safeObserve(() => hookFn(context), ctx.logger);
+  }
+}
+async function notifyGadgetStart(ctx) {
+  const gadgetNode = ctx.tree?.getNodeByInvocationId(ctx.invocationId);
+  const subagentContext = ctx.tree && gadgetNode ? getSubagentContextForNode(ctx.tree, gadgetNode.id) : void 0;
+  const context = {
+    iteration: ctx.iteration,
+    gadgetName: ctx.gadgetName,
+    invocationId: ctx.invocationId,
+    parameters: ctx.parameters,
+    logger: ctx.logger,
+    subagentContext
+  };
+  if (ctx.hooks?.onGadgetExecutionStart) {
+    const hookFn = ctx.hooks.onGadgetExecutionStart;
+    await safeObserve(() => hookFn(context), ctx.logger);
+  }
+  if (ctx.parentObservers?.onGadgetExecutionStart) {
+    const hookFn = ctx.parentObservers.onGadgetExecutionStart;
+    await safeObserve(() => hookFn(context), ctx.logger);
+  }
+}
+async function notifyGadgetComplete(ctx) {
+  const gadgetNode = ctx.tree?.getNodeByInvocationId(ctx.invocationId);
+  const subagentContext = ctx.tree && gadgetNode ? getSubagentContextForNode(ctx.tree, gadgetNode.id) : void 0;
+  const context = {
+    iteration: ctx.iteration,
+    gadgetName: ctx.gadgetName,
+    invocationId: ctx.invocationId,
+    parameters: ctx.parameters,
+    finalResult: ctx.finalResult,
+    error: ctx.error,
+    executionTimeMs: ctx.executionTimeMs,
+    cost: ctx.cost,
+    logger: ctx.logger,
+    subagentContext
+  };
+  if (ctx.hooks?.onGadgetExecutionComplete) {
+    const hookFn = ctx.hooks.onGadgetExecutionComplete;
+    await safeObserve(() => hookFn(context), ctx.logger);
+  }
+  if (ctx.parentObservers?.onGadgetExecutionComplete) {
+    const hookFn = ctx.parentObservers.onGadgetExecutionComplete;
+    await safeObserve(() => hookFn(context), ctx.logger);
+  }
+}
+var init_observer_notifier = __esm({
+  "src/agent/observer-notifier.ts"() {
+    "use strict";
+    init_safe_observe();
+    init_tree_hook_bridge();
   }
 });
 
@@ -13735,11 +14286,13 @@ var init_stream_processor = __esm({
     init_executor();
     init_parser();
     init_logger();
+    init_gadget_concurrency_manager();
+    init_gadget_dependency_resolver();
     init_hook_validators();
-    init_tree_hook_bridge();
+    init_observer_notifier();
+    init_safe_observe();
     StreamProcessor = class {
       iteration;
-      registry;
       hooks;
       logger;
       parser;
@@ -13751,33 +14304,12 @@ var init_stream_processor = __esm({
       // Gadget execution mode
       gadgetExecutionMode;
       responseText = "";
-      observerFailureCount = 0;
-      // Dependency tracking for gadget execution DAG
-      /** Gadgets waiting for their dependencies to complete */
-      gadgetsAwaitingDependencies = /* @__PURE__ */ new Map();
-      /** Completed gadget results, keyed by invocation ID */
-      completedResults = /* @__PURE__ */ new Map();
-      /** Invocation IDs of gadgets that have failed (error or skipped due to dependency) */
-      failedInvocations = /* @__PURE__ */ new Set();
-      /** Promises for independent gadgets currently executing (fire-and-forget) */
-      inFlightExecutions = /* @__PURE__ */ new Map();
+      // Dependency resolution is delegated to GadgetDependencyResolver
+      dependencyResolver;
+      // Concurrency management is delegated to GadgetConcurrencyManager
+      concurrencyManager;
       /** Queue of completed gadget results ready to be yielded (for real-time streaming) */
       completedResultsQueue = [];
-      // Concurrency limiting
-      /** Subagent configuration map for checking maxConcurrent limits */
-      subagentConfig;
-      /** Track active execution count per gadget name */
-      activeCountByGadget = /* @__PURE__ */ new Map();
-      /** Queue of gadgets waiting for a concurrency slot (per gadget name) */
-      concurrencyQueue = /* @__PURE__ */ new Map();
-      // Exclusive gadget support
-      /** Queue of exclusive gadgets deferred until in-flight gadgets complete */
-      exclusiveQueue = [];
-      // Cross-iteration dependency tracking
-      /** Invocation IDs completed in previous iterations (read-only reference from Agent) */
-      priorCompletedInvocations;
-      /** Invocation IDs that failed in previous iterations (read-only reference from Agent) */
-      priorFailedInvocations;
       // Parent observer hooks for subagent visibility
       parentObservers;
       // Gadget limiting per response
@@ -13786,16 +14318,21 @@ var init_stream_processor = __esm({
       limitExceeded = false;
       constructor(options) {
         this.iteration = options.iteration;
-        this.registry = options.registry;
         this.hooks = options.hooks ?? {};
         this.logger = options.logger ?? createLogger({ name: "llmist:stream-processor" });
         this.tree = options.tree;
         this.parentNodeId = options.parentNodeId ?? null;
         this.baseDepth = options.baseDepth ?? 0;
         this.gadgetExecutionMode = options.gadgetExecutionMode ?? "parallel";
-        this.priorCompletedInvocations = options.priorCompletedInvocations ?? /* @__PURE__ */ new Set();
-        this.priorFailedInvocations = options.priorFailedInvocations ?? /* @__PURE__ */ new Set();
-        this.subagentConfig = options.subagentConfig;
+        this.dependencyResolver = new GadgetDependencyResolver({
+          priorCompletedInvocations: options.priorCompletedInvocations,
+          priorFailedInvocations: options.priorFailedInvocations
+        });
+        this.concurrencyManager = new GadgetConcurrencyManager({
+          registry: options.registry,
+          subagentConfig: options.subagentConfig,
+          logger: this.logger.getSubLogger({ name: "concurrency" })
+        });
         this.parentObservers = options.parentObservers;
         this.maxGadgetsPerResponse = options.maxGadgetsPerResponse ?? 0;
         this.parser = new GadgetCallParser({
@@ -14037,7 +14574,7 @@ var init_stream_processor = __esm({
               gadgetName: call.gadgetName,
               invocationId: call.invocationId
             });
-            this.failedInvocations.add(call.invocationId);
+            this.dependencyResolver.markFailed(call.invocationId);
             const errorMessage = `Gadget "${call.invocationId}" cannot depend on itself (self-referential dependency)`;
             const skipEvent = {
               type: "gadget_skipped",
@@ -14048,39 +14585,21 @@ var init_stream_processor = __esm({
               failedDependencyError: errorMessage
             };
             yield skipEvent;
-            const skippedGadgetNode = this.tree?.getNodeByInvocationId(call.invocationId);
-            const skippedSubagentContext = this.tree && skippedGadgetNode ? getSubagentContextForNode(this.tree, skippedGadgetNode.id) : void 0;
-            if (this.hooks.observers?.onGadgetSkipped) {
-              const context = {
-                iteration: this.iteration,
-                gadgetName: call.gadgetName,
-                invocationId: call.invocationId,
-                parameters: call.parameters ?? {},
-                failedDependency: call.invocationId,
-                failedDependencyError: errorMessage,
-                logger: this.logger,
-                subagentContext: skippedSubagentContext
-              };
-              await this.safeObserve(() => this.hooks.observers.onGadgetSkipped(context));
-            }
-            if (this.parentObservers?.onGadgetSkipped) {
-              const context = {
-                iteration: this.iteration,
-                gadgetName: call.gadgetName,
-                invocationId: call.invocationId,
-                parameters: call.parameters ?? {},
-                failedDependency: call.invocationId,
-                failedDependencyError: errorMessage,
-                logger: this.logger,
-                subagentContext: skippedSubagentContext
-              };
-              await this.safeObserve(() => this.parentObservers.onGadgetSkipped(context));
-            }
+            await notifyGadgetSkipped({
+              tree: this.tree,
+              hooks: this.hooks.observers,
+              parentObservers: this.parentObservers,
+              logger: this.logger,
+              iteration: this.iteration,
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters: call.parameters ?? {},
+              failedDependency: call.invocationId,
+              failedDependencyError: errorMessage
+            });
             return;
           }
-          const failedDep = call.dependencies.find(
-            (dep) => this.failedInvocations.has(dep) || this.priorFailedInvocations.has(dep)
-          );
+          const failedDep = this.dependencyResolver.getFailedDependency(call);
           if (failedDep) {
             const skipEvents = await this.handleFailedDependency(call, failedDep);
             for (const evt of skipEvents) {
@@ -14088,16 +14607,16 @@ var init_stream_processor = __esm({
             }
             return;
           }
-          const unsatisfied = call.dependencies.filter(
-            (dep) => !this.completedResults.has(dep) && !this.priorCompletedInvocations.has(dep)
-          );
-          if (unsatisfied.length > 0) {
+          if (!this.dependencyResolver.isAllSatisfied(call)) {
+            const unsatisfied = call.dependencies.filter(
+              (dep) => !this.dependencyResolver.isCompleted(dep)
+            );
             this.logger.debug("Queueing gadget for later - waiting on dependencies", {
               gadgetName: call.gadgetName,
               invocationId: call.invocationId,
               waitingOn: unsatisfied
             });
-            this.gadgetsAwaitingDependencies.set(call.invocationId, call);
+            this.dependencyResolver.addPending(call);
             return;
           }
           const limitCheckGen2 = this.checkGadgetLimitExceeded(call);
@@ -14126,28 +14645,12 @@ var init_stream_processor = __esm({
         if (limitResult.value === true) {
           return;
         }
-        const gadget = this.registry.get(call.gadgetName);
-        if (gadget?.exclusive && this.inFlightExecutions.size > 0) {
-          this.logger.debug("Deferring exclusive gadget until in-flight gadgets complete", {
-            gadgetName: call.gadgetName,
-            invocationId: call.invocationId,
-            inFlightCount: this.inFlightExecutions.size
-          });
-          this.exclusiveQueue.push(call);
+        if (this.concurrencyManager.isExclusive(call.gadgetName) && this.concurrencyManager.inFlightCount > 0) {
+          this.concurrencyManager.queueExclusive(call);
           return;
         }
-        const limit = this.getConcurrencyLimit(call.gadgetName);
-        const activeCount = this.activeCountByGadget.get(call.gadgetName) ?? 0;
-        if (limit > 0 && activeCount >= limit) {
-          this.logger.debug("Gadget queued due to concurrency limit", {
-            gadgetName: call.gadgetName,
-            invocationId: call.invocationId,
-            activeCount,
-            limit
-          });
-          const queue = this.concurrencyQueue.get(call.gadgetName) ?? [];
-          queue.push(call);
-          this.concurrencyQueue.set(call.gadgetName, queue);
+        if (!this.concurrencyManager.canStart(call)) {
+          this.concurrencyManager.queueForLater(call);
           return;
         }
         if (this.gadgetExecutionMode === "sequential") {
@@ -14158,57 +14661,19 @@ var init_stream_processor = __esm({
           this.startGadgetWithConcurrencyTracking(call);
         }
       }
-      /**
-       * Get the effective concurrency limit for a gadget.
-       * Uses "most restrictive wins" strategy: the lowest non-zero value from
-       * external config (SubagentConfig) and gadget's intrinsic maxConcurrent.
-       *
-       * This ensures gadget authors can set safety floors (e.g., maxConcurrent: 1
-       * for file writers) that cannot be weakened by external configuration.
-       *
-       * @returns 0 if unlimited, otherwise the effective limit
-       */
-      getConcurrencyLimit(gadgetName) {
-        const configLimit = this.subagentConfig?.[gadgetName]?.maxConcurrent;
-        const gadget = this.registry.get(gadgetName);
-        const gadgetLimit = gadget?.maxConcurrent;
-        const config = configLimit || Number.POSITIVE_INFINITY;
-        const intrinsic = gadgetLimit || Number.POSITIVE_INFINITY;
-        const effective = Math.min(config, intrinsic);
-        return effective === Number.POSITIVE_INFINITY ? 0 : effective;
-      }
       /**
        * Start a gadget execution with concurrency tracking.
-       * Increments active count, starts execution, and schedules queue processing on completion.
+       * Delegates tracking to GadgetConcurrencyManager; schedules queue processing on completion.
        */
       startGadgetWithConcurrencyTracking(call) {
         const gadgetName = call.gadgetName;
-        const currentCount = this.activeCountByGadget.get(gadgetName) ?? 0;
-        this.activeCountByGadget.set(gadgetName, currentCount + 1);
         const executionPromise = this.executeGadgetAndCollect(call).finally(() => {
-          const newCount = (this.activeCountByGadget.get(gadgetName) ?? 1) - 1;
-          this.activeCountByGadget.set(gadgetName, newCount);
-          this.processQueuedGadget(gadgetName);
+          const nextCall = this.concurrencyManager.onComplete(gadgetName);
+          if (nextCall) {
+            this.startGadgetWithConcurrencyTracking(nextCall);
+          }
         });
-        this.inFlightExecutions.set(call.invocationId, executionPromise);
-      }
-      /**
-       * Process the next queued gadget for a given gadget name if a slot is available.
-       */
-      processQueuedGadget(gadgetName) {
-        const queue = this.concurrencyQueue.get(gadgetName);
-        if (!queue || queue.length === 0) return;
-        const limit = this.getConcurrencyLimit(gadgetName);
-        const activeCount = this.activeCountByGadget.get(gadgetName) ?? 0;
-        if (limit === 0 || activeCount < limit) {
-          const nextCall = queue.shift();
-          this.logger.debug("Processing queued gadget", {
-            gadgetName,
-            invocationId: nextCall.invocationId,
-            remainingInQueue: queue.length
-          });
-          this.startGadgetWithConcurrencyTracking(nextCall);
-        }
+        this.concurrencyManager.trackExecution(call.invocationId, gadgetName, executionPromise);
       }
       /**
        * Execute a gadget through the full hook lifecycle and yield events.
@@ -14263,30 +14728,16 @@ var init_stream_processor = __esm({
             this.tree.startGadget(gadgetNode.id);
           }
         }
-        const gadgetStartNode = this.tree?.getNodeByInvocationId(call.invocationId);
-        const gadgetStartSubagentContext = this.tree && gadgetStartNode ? getSubagentContextForNode(this.tree, gadgetStartNode.id) : void 0;
-        if (this.hooks.observers?.onGadgetExecutionStart) {
-          const context = {
-            iteration: this.iteration,
-            gadgetName: call.gadgetName,
-            invocationId: call.invocationId,
-            parameters,
-            logger: this.logger,
-            subagentContext: gadgetStartSubagentContext
-          };
-          await this.safeObserve(() => this.hooks.observers.onGadgetExecutionStart(context));
-        }
-        if (this.parentObservers?.onGadgetExecutionStart) {
-          const context = {
-            iteration: this.iteration,
-            gadgetName: call.gadgetName,
-            invocationId: call.invocationId,
-            parameters,
-            logger: this.logger,
-            subagentContext: gadgetStartSubagentContext
-          };
-          await this.safeObserve(() => this.parentObservers.onGadgetExecutionStart(context));
-        }
+        await notifyGadgetStart({
+          tree: this.tree,
+          hooks: this.hooks.observers,
+          parentObservers: this.parentObservers,
+          logger: this.logger,
+          iteration: this.iteration,
+          gadgetName: call.gadgetName,
+          invocationId: call.invocationId,
+          parameters
+        });
         let result;
         if (shouldSkip) {
           result = {
@@ -14299,7 +14750,7 @@ var init_stream_processor = __esm({
         } else {
           result = await this.executor.execute(call);
         }
-        if (result.result && this.hooks.interceptors?.interceptGadgetResult) {
+        if ((result.result || result.error) && this.hooks.interceptors?.interceptGadgetResult) {
           const context = {
             iteration: this.iteration,
             gadgetName: result.gadgetName,
@@ -14308,7 +14759,12 @@ var init_stream_processor = __esm({
             executionTimeMs: result.executionTimeMs,
             logger: this.logger
           };
-          result.result = this.hooks.interceptors.interceptGadgetResult(result.result, context);
+          if (result.result) {
+            result.result = this.hooks.interceptors.interceptGadgetResult(result.result, context);
+          }
+          if (result.error) {
+            result.error = this.hooks.interceptors.interceptGadgetResult(result.error, context);
+          }
         }
         if (this.hooks.controllers?.afterGadgetExecution) {
           const context = {
@@ -14355,42 +14811,21 @@ var init_stream_processor = __esm({
             }
           }
         }
-        const gadgetCompleteNode = this.tree?.getNodeByInvocationId(result.invocationId);
-        const gadgetCompleteSubagentContext = this.tree && gadgetCompleteNode ? getSubagentContextForNode(this.tree, gadgetCompleteNode.id) : void 0;
-        if (this.hooks.observers?.onGadgetExecutionComplete) {
-          const context = {
-            iteration: this.iteration,
-            gadgetName: result.gadgetName,
-            invocationId: result.invocationId,
-            parameters,
-            finalResult: result.result,
-            error: result.error,
-            executionTimeMs: result.executionTimeMs,
-            cost: result.cost,
-            logger: this.logger,
-            subagentContext: gadgetCompleteSubagentContext
-          };
-          await this.safeObserve(() => this.hooks.observers.onGadgetExecutionComplete(context));
-        }
-        if (this.parentObservers?.onGadgetExecutionComplete) {
-          const context = {
-            iteration: this.iteration,
-            gadgetName: result.gadgetName,
-            invocationId: result.invocationId,
-            parameters,
-            finalResult: result.result,
-            error: result.error,
-            executionTimeMs: result.executionTimeMs,
-            cost: result.cost,
-            logger: this.logger,
-            subagentContext: gadgetCompleteSubagentContext
-          };
-          await this.safeObserve(() => this.parentObservers.onGadgetExecutionComplete(context));
-        }
-        this.completedResults.set(result.invocationId, result);
-        if (result.error) {
-          this.failedInvocations.add(result.invocationId);
-        }
+        await notifyGadgetComplete({
+          tree: this.tree,
+          hooks: this.hooks.observers,
+          parentObservers: this.parentObservers,
+          logger: this.logger,
+          iteration: this.iteration,
+          gadgetName: result.gadgetName,
+          invocationId: result.invocationId,
+          parameters,
+          finalResult: result.result,
+          error: result.error,
+          executionTimeMs: result.executionTimeMs,
+          cost: result.cost
+        });
+        this.dependencyResolver.markComplete(result);
         yield { type: "gadget_result", result };
       }
       /**
@@ -14422,77 +14857,45 @@ var init_stream_processor = __esm({
        * Clears the inFlightExecutions map after all gadgets complete.
        */
       async *waitForInFlightExecutions() {
-        if (this.inFlightExecutions.size === 0 && !this.hasQueuedGadgets() && this.exclusiveQueue.length === 0) {
+        if (this.concurrencyManager.inFlightCount === 0 && !this.concurrencyManager.hasQueuedGadgets() && !this.concurrencyManager.hasExclusiveQueued) {
           return;
         }
         this.logger.debug("Waiting for in-flight gadget executions", {
-          count: this.inFlightExecutions.size,
-          invocationIds: Array.from(this.inFlightExecutions.keys()),
-          queuedCount: this.getQueuedGadgetCount()
+          count: this.concurrencyManager.inFlightCount,
+          queuedCount: this.concurrencyManager.getQueuedGadgetCount()
         });
         const POLL_INTERVAL_MS = 100;
-        while (this.inFlightExecutions.size > 0 || this.hasQueuedGadgets()) {
-          const allDone = this.inFlightExecutions.size > 0 ? Promise.all(this.inFlightExecutions.values()).then(() => "done") : Promise.resolve("done");
+        while (this.concurrencyManager.inFlightCount > 0 || this.concurrencyManager.hasQueuedGadgets()) {
+          const allDone = this.concurrencyManager.getAllDonePromise();
           const result = await Promise.race([
             allDone,
-            new Promise((resolve) => setTimeout(() => resolve("poll"), POLL_INTERVAL_MS))
+            new Promise((resolve2) => setTimeout(() => resolve2("poll"), POLL_INTERVAL_MS))
           ]);
           yield* this.drainCompletedResults();
-          if (result === "done" && this.getTotalActiveGadgetCount() === 0 && !this.hasQueuedGadgets()) {
+          if (result === "done" && this.concurrencyManager.getTotalActiveGadgetCount() === 0 && !this.concurrencyManager.hasQueuedGadgets()) {
             break;
           }
         }
-        this.inFlightExecutions.clear();
-        if (this.exclusiveQueue.length > 0) {
+        this.concurrencyManager.clearInFlight();
+        if (this.concurrencyManager.hasExclusiveQueued) {
+          const exclusiveQueue = this.concurrencyManager.drainExclusiveQueue();
           this.logger.debug("Processing deferred exclusive gadgets", {
-            count: this.exclusiveQueue.length
+            count: exclusiveQueue.length
           });
-          const queue = this.exclusiveQueue;
-          this.exclusiveQueue = [];
-          for (const call of queue) {
+          for (const call of exclusiveQueue) {
             for await (const evt of this.executeGadgetGenerator(call)) {
               yield evt;
             }
           }
         }
       }
-      /**
-       * Check if there are any gadgets waiting in concurrency queues.
-       */
-      hasQueuedGadgets() {
-        for (const queue of this.concurrencyQueue.values()) {
-          if (queue.length > 0) return true;
-        }
-        return false;
-      }
-      /**
-       * Get total count of queued gadgets across all queues.
-       */
-      getQueuedGadgetCount() {
-        let count = 0;
-        for (const queue of this.concurrencyQueue.values()) {
-          count += queue.length;
-        }
-        return count;
-      }
-      /**
-       * Get total count of actively executing gadgets across all types.
-       * Used to know when all work is truly complete (not just when allDone resolves).
-       */
-      getTotalActiveGadgetCount() {
-        let total = 0;
-        for (const count of this.activeCountByGadget.values()) {
-          total += count;
-        }
-        return total;
-      }
       /**
        * Handle a gadget that cannot execute because a dependency failed.
        * Calls the onDependencySkipped controller to allow customization.
        */
       async handleFailedDependency(call, failedDep) {
         const events = [];
-        const depResult = this.completedResults.get(failedDep);
+        const depResult = this.dependencyResolver.getCompletedResult(failedDep);
         const depError = depResult?.error ?? "Dependency failed";
         let action = { action: "skip" };
         if (this.hooks.controllers?.onDependencySkipped) {
@@ -14508,7 +14911,7 @@ var init_stream_processor = __esm({
           action = await this.hooks.controllers.onDependencySkipped(context);
         }
         if (action.action === "skip") {
-          this.failedInvocations.add(call.invocationId);
+          this.dependencyResolver.markFailed(call.invocationId);
           if (this.tree) {
             const gadgetNode = this.tree.getNodeByInvocationId(call.invocationId);
             if (gadgetNode) {
@@ -14524,34 +14927,18 @@ var init_stream_processor = __esm({
             failedDependencyError: depError
           };
           events.push(skipEvent);
-          const gadgetNodeForSkip = this.tree?.getNodeByInvocationId(call.invocationId);
-          const skipSubagentContext = this.tree && gadgetNodeForSkip ? getSubagentContextForNode(this.tree, gadgetNodeForSkip.id) : void 0;
-          if (this.hooks.observers?.onGadgetSkipped) {
-            const context = {
-              iteration: this.iteration,
-              gadgetName: call.gadgetName,
-              invocationId: call.invocationId,
-              parameters: call.parameters ?? {},
-              failedDependency: failedDep,
-              failedDependencyError: depError,
-              logger: this.logger,
-              subagentContext: skipSubagentContext
-            };
-            await this.safeObserve(() => this.hooks.observers.onGadgetSkipped(context));
-          }
-          if (this.parentObservers?.onGadgetSkipped) {
-            const context = {
-              iteration: this.iteration,
-              gadgetName: call.gadgetName,
-              invocationId: call.invocationId,
-              parameters: call.parameters ?? {},
-              failedDependency: failedDep,
-              failedDependencyError: depError,
-              logger: this.logger,
-              subagentContext: skipSubagentContext
-            };
-            await this.safeObserve(() => this.parentObservers.onGadgetSkipped(context));
-          }
+          await notifyGadgetSkipped({
+            tree: this.tree,
+            hooks: this.hooks.observers,
+            parentObservers: this.parentObservers,
+            logger: this.logger,
+            iteration: this.iteration,
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            parameters: call.parameters ?? {},
+            failedDependency: failedDep,
+            failedDependencyError: depError
+          });
           this.logger.info("Gadget skipped due to failed dependency", {
             gadgetName: call.gadgetName,
             invocationId: call.invocationId,
@@ -14574,7 +14961,7 @@ var init_stream_processor = __esm({
             result: action.fallbackResult,
             executionTimeMs: 0
           };
-          this.completedResults.set(call.invocationId, fallbackResult);
+          this.dependencyResolver.markComplete(fallbackResult);
           events.push({ type: "gadget_result", result: fallbackResult });
           this.logger.info("Using fallback result for gadget with failed dependency", {
             gadgetName: call.gadgetName,
@@ -14605,7 +14992,7 @@ var init_stream_processor = __esm({
             limit: this.maxGadgetsPerResponse,
             currentCount: this.gadgetStartedCount
           });
-          this.failedInvocations.add(call.invocationId);
+          this.dependencyResolver.markFailed(call.invocationId);
           if (this.tree) {
             const gadgetNode = this.tree.getNodeByInvocationId(call.invocationId);
             if (gadgetNode) {
@@ -14626,34 +15013,18 @@ var init_stream_processor = __esm({
             failedDependencyError: errorMessage
           };
           yield skipEvent;
-          const limitSkipNode = this.tree?.getNodeByInvocationId(call.invocationId);
-          const limitSkipSubagentContext = this.tree && limitSkipNode ? getSubagentContextForNode(this.tree, limitSkipNode.id) : void 0;
-          if (this.hooks.observers?.onGadgetSkipped) {
-            const context = {
-              iteration: this.iteration,
-              gadgetName: call.gadgetName,
-              invocationId: call.invocationId,
-              parameters: call.parameters ?? {},
-              failedDependency: "maxGadgetsPerResponse",
-              failedDependencyError: errorMessage,
-              logger: this.logger,
-              subagentContext: limitSkipSubagentContext
-            };
-            await this.safeObserve(() => this.hooks.observers.onGadgetSkipped(context));
-          }
-          if (this.parentObservers?.onGadgetSkipped) {
-            const context = {
-              iteration: this.iteration,
-              gadgetName: call.gadgetName,
-              invocationId: call.invocationId,
-              parameters: call.parameters ?? {},
-              failedDependency: "maxGadgetsPerResponse",
-              failedDependencyError: errorMessage,
-              logger: this.logger,
-              subagentContext: limitSkipSubagentContext
-            };
-            await this.safeObserve(() => this.parentObservers.onGadgetSkipped(context));
-          }
+          await notifyGadgetSkipped({
+            tree: this.tree,
+            hooks: this.hooks.observers,
+            parentObservers: this.parentObservers,
+            logger: this.logger,
+            iteration: this.iteration,
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            parameters: call.parameters ?? {},
+            failedDependency: "maxGadgetsPerResponse",
+            failedDependencyError: errorMessage
+          });
           return true;
         }
         this.gadgetStartedCount++;
@@ -14671,27 +15042,11 @@ var init_stream_processor = __esm({
           return;
         }
         let progress = true;
-        while (progress && this.gadgetsAwaitingDependencies.size > 0) {
+        while (progress && this.dependencyResolver.pendingCount > 0) {
           progress = false;
-          const readyToExecute = [];
-          const readyToSkip = [];
-          for (const [_invocationId, call] of this.gadgetsAwaitingDependencies) {
-            const failedDep = call.dependencies.find(
-              (dep) => this.failedInvocations.has(dep) || this.priorFailedInvocations.has(dep)
-            );
-            if (failedDep) {
-              readyToSkip.push({ call, failedDep });
-              continue;
-            }
-            const allSatisfied = call.dependencies.every(
-              (dep) => this.completedResults.has(dep) || this.priorCompletedInvocations.has(dep)
-            );
-            if (allSatisfied) {
-              readyToExecute.push(call);
-            }
-          }
+          const { readyToExecute, readyToSkip } = this.dependencyResolver.getReadyCalls();
           for (const { call, failedDep } of readyToSkip) {
-            this.gadgetsAwaitingDependencies.delete(call.invocationId);
+            this.dependencyResolver.removePending(call.invocationId);
             const skipEvents = await this.handleFailedDependency(call, failedDep);
             for (const evt of skipEvents) {
               yield evt;
@@ -14700,7 +15055,7 @@ var init_stream_processor = __esm({
           }
           if (readyToExecute.length > 0) {
             for (const call of readyToExecute) {
-              this.gadgetsAwaitingDependencies.delete(call.invocationId);
+              this.dependencyResolver.removePending(call.invocationId);
             }
             if (this.gadgetExecutionMode === "sequential") {
               this.logger.debug("Executing ready gadgets sequentially", {
@@ -14753,11 +15108,12 @@ var init_stream_processor = __esm({
             progress = true;
           }
         }
-        if (this.gadgetsAwaitingDependencies.size > 0) {
-          const pendingIds = new Set(this.gadgetsAwaitingDependencies.keys());
-          for (const [invocationId, call] of this.gadgetsAwaitingDependencies) {
+        if (this.dependencyResolver.pendingCount > 0) {
+          const pendingEntries = this.dependencyResolver.getPendingEntries();
+          const pendingIds = new Set(pendingEntries.map(([id]) => id));
+          for (const [invocationId, call] of pendingEntries) {
             const missingDeps = call.dependencies.filter(
-              (dep) => !this.completedResults.has(dep) && !this.priorCompletedInvocations.has(dep)
+              (dep) => !this.dependencyResolver.isCompleted(dep)
             );
             const circularDeps = missingDeps.filter((dep) => pendingIds.has(dep));
             const trulyMissingDeps = missingDeps.filter((dep) => !pendingIds.has(dep));
@@ -14777,7 +15133,7 @@ var init_stream_processor = __esm({
               circularDependencies: circularDeps,
               missingDependencies: trulyMissingDeps
             });
-            this.failedInvocations.add(invocationId);
+            this.dependencyResolver.markFailed(invocationId);
             const skipEvent = {
               type: "gadget_skipped",
               gadgetName: call.gadgetName,
@@ -14787,51 +15143,20 @@ var init_stream_processor = __esm({
               failedDependencyError: errorMessage
             };
             yield skipEvent;
-            const gadgetNodeForTimeout = this.tree?.getNodeByInvocationId(invocationId);
-            const timeoutSubagentContext = this.tree && gadgetNodeForTimeout ? getSubagentContextForNode(this.tree, gadgetNodeForTimeout.id) : void 0;
-            if (this.hooks.observers?.onGadgetSkipped) {
-              const context = {
-                iteration: this.iteration,
-                gadgetName: call.gadgetName,
-                invocationId,
-                parameters: call.parameters ?? {},
-                failedDependency: missingDeps[0],
-                failedDependencyError: errorMessage,
-                logger: this.logger,
-                subagentContext: timeoutSubagentContext
-              };
-              await this.safeObserve(() => this.hooks.observers.onGadgetSkipped(context));
-            }
-            if (this.parentObservers?.onGadgetSkipped) {
-              const context = {
-                iteration: this.iteration,
-                gadgetName: call.gadgetName,
-                invocationId,
-                parameters: call.parameters ?? {},
-                failedDependency: missingDeps[0],
-                failedDependencyError: errorMessage,
-                logger: this.logger,
-                subagentContext: timeoutSubagentContext
-              };
-              await this.safeObserve(() => this.parentObservers.onGadgetSkipped(context));
-            }
+            await notifyGadgetSkipped({
+              tree: this.tree,
+              hooks: this.hooks.observers,
+              parentObservers: this.parentObservers,
+              logger: this.logger,
+              iteration: this.iteration,
+              gadgetName: call.gadgetName,
+              invocationId,
+              parameters: call.parameters ?? {},
+              failedDependency: missingDeps[0],
+              failedDependencyError: errorMessage
+            });
           }
-          this.gadgetsAwaitingDependencies.clear();
-        }
-      }
-      /**
-       * Safely execute an observer, catching and logging any errors.
-       * Observers are non-critical, so errors are logged but don't crash the system.
-       */
-      async safeObserve(fn) {
-        try {
-          await fn();
-        } catch (error) {
-          this.observerFailureCount++;
-          this.logger.error("Observer threw error (ignoring)", {
-            error: error instanceof Error ? error.message : String(error),
-            failureCount: this.observerFailureCount
-          });
+          this.dependencyResolver.clearPending();
         }
       }
       /**
@@ -14840,7 +15165,7 @@ var init_stream_processor = __esm({
        */
       async runObserversInParallel(observers) {
         if (observers.length === 0) return;
-        await Promise.allSettled(observers.map((observer) => this.safeObserve(observer)));
+        await Promise.allSettled(observers.map((observer) => safeObserve(observer, this.logger)));
       }
       // ==========================================================================
       // Public accessors for cross-iteration dependency tracking
@@ -14850,14 +15175,14 @@ var init_stream_processor = __esm({
        * Used by Agent to accumulate completed IDs across iterations.
        */
       getCompletedInvocationIds() {
-        return new Set(this.completedResults.keys());
+        return this.dependencyResolver.getCompletedInvocationIds();
       }
       /**
        * Get all invocation IDs that failed in this iteration.
        * Used by Agent to accumulate failed IDs across iterations.
        */
       getFailedInvocationIds() {
-        return new Set(this.failedInvocations);
+        return this.dependencyResolver.getFailedInvocationIds();
       }
     };
   }
@@ -14884,6 +15209,7 @@ var init_agent = __esm({
     init_event_handlers();
     init_gadget_output_store();
     init_hook_validators();
+    init_safe_observe();
     init_stream_processor();
     init_tree_hook_bridge();
     Agent = class {
@@ -15372,7 +15698,7 @@ var init_agent = __esm({
                       }
                     );
                     this.retryConfig.onRetry?.(error, streamAttempt);
-                    await this.safeObserve(async () => {
+                    await safeObserve(async () => {
                       if (this.hooks.observers?.onRetryAttempt) {
                         const subagentContext = getSubagentContextForNode(this.tree, currentLLMNodeId);
                         const hookContext = {
@@ -15386,7 +15712,7 @@ var init_agent = __esm({
                         };
                         await this.hooks.observers.onRetryAttempt(hookContext);
                       }
-                    });
+                    }, this.logger);
                     await this.sleep(finalDelay);
                     streamMetadata = null;
                     gadgetCallCount = 0;
@@ -15416,7 +15742,7 @@ var init_agent = __esm({
               this.logger.silly("LLM response details", {
                 rawResponse: result.rawResponse
               });
-              await this.safeObserve(async () => {
+              await safeObserve(async () => {
                 if (this.hooks.observers?.onLLMCallComplete) {
                   const subagentContext = getSubagentContextForNode(this.tree, currentLLMNodeId);
                   const context = {
@@ -15432,7 +15758,7 @@ var init_agent = __esm({
                   };
                   await this.hooks.observers.onLLMCallComplete(context);
                 }
-              });
+              }, this.logger);
               this.completeLLMCallInTree(currentLLMNodeId, result);
               const finalMessage = await this.processAfterLLMCallController(
                 currentIteration,
@@ -15466,7 +15792,7 @@ var init_agent = __esm({
               }
             } catch (error) {
               const errorHandled = await this.handleLLMError(error, currentIteration);
-              await this.safeObserve(async () => {
+              await safeObserve(async () => {
                 if (this.hooks.observers?.onLLMCallError) {
                   const options = llmOptions ?? {
                     model: this.model,
@@ -15485,7 +15811,7 @@ var init_agent = __esm({
                   };
                   await this.hooks.observers.onLLMCallError(context);
                 }
-              });
+              }, this.logger);
               if (!errorHandled) {
                 throw error;
               }
@@ -15512,7 +15838,7 @@ var init_agent = __esm({
           if (currentLLMNodeId) {
             const node = this.tree.getNode(currentLLMNodeId);
             if (node && node.type === "llm_call" && !node.completedAt) {
-              await this.safeObserve(async () => {
+              await safeObserve(async () => {
                 if (this.hooks.observers?.onLLMCallComplete) {
                   const subagentContext = getSubagentContextForNode(this.tree, currentLLMNodeId);
                   const context = {
@@ -15534,7 +15860,7 @@ var init_agent = __esm({
                   };
                   await this.hooks.observers.onLLMCallComplete(context);
                 }
-              });
+              }, this.logger);
               this.tree.completeLLMCall(currentLLMNodeId, {
                 finishReason: "interrupted"
               });
@@ -15554,7 +15880,7 @@ var init_agent = __esm({
           const throttleDelay = this.rateLimitTracker.getRequiredDelayMs();
           if (throttleDelay > 0) {
             this.logger.debug("Rate limit throttling", { delayMs: throttleDelay });
-            await this.safeObserve(async () => {
+            await safeObserve(async () => {
               if (this.hooks.observers?.onRateLimitThrottle) {
                 const subagentContext = getSubagentContextForNode(this.tree, llmNodeId);
                 const context = {
@@ -15566,7 +15892,7 @@ var init_agent = __esm({
                 };
                 await this.hooks.observers.onRateLimitThrottle(context);
               }
-            });
+            }, this.logger);
             await this.sleep(throttleDelay);
           }
           this.rateLimitTracker.reserveRequest();
@@ -15577,7 +15903,7 @@ var init_agent = __esm({
        * Simple sleep utility for rate limit delays.
        */
       sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
+        return new Promise((resolve2) => setTimeout(resolve2, ms));
       }
       /**
        * Handle LLM error through controller.
@@ -15629,18 +15955,6 @@ var init_agent = __esm({
         }
         return true;
       }
-      /**
-       * Safely execute an observer, catching and logging any errors.
-       */
-      async safeObserve(fn) {
-        try {
-          await fn();
-        } catch (error) {
-          this.logger.error("Observer threw error (ignoring)", {
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
       /**
        * Resolve max tokens from model catalog.
        */
@@ -15709,7 +16023,7 @@ var init_agent = __esm({
           iteration,
           reason: this.signal.reason
         });
-        await this.safeObserve(async () => {
+        await safeObserve(async () => {
           if (this.hooks.observers?.onAbort) {
             const context = {
               iteration,
@@ -15718,7 +16032,7 @@ var init_agent = __esm({
             };
             await this.hooks.observers.onAbort(context);
           }
-        });
+        }, this.logger);
         return true;
       }
       /**
@@ -15737,7 +16051,7 @@ var init_agent = __esm({
           tokensBefore: compactionEvent.tokensBefore,
           tokensAfter: compactionEvent.tokensAfter
         });
-        await this.safeObserve(async () => {
+        await safeObserve(async () => {
           if (this.hooks.observers?.onCompaction) {
             await this.hooks.observers.onCompaction({
               iteration,
@@ -15747,7 +16061,7 @@ var init_agent = __esm({
               logger: this.logger
             });
           }
-        });
+        }, this.logger);
         return { type: "compaction", event: compactionEvent };
       }
       /**
@@ -15800,7 +16114,7 @@ var init_agent = __esm({
           parentId: this.parentNodeId,
           request: llmOptions.messages
         });
-        await this.safeObserve(async () => {
+        await safeObserve(async () => {
           if (this.hooks.observers?.onLLMCallStart) {
             const subagentContext = getSubagentContextForNode(this.tree, llmNode.id);
             const context = {
@@ -15811,7 +16125,7 @@ var init_agent = __esm({
             };
             await this.hooks.observers.onLLMCallStart(context);
           }
-        });
+        }, this.logger);
         if (this.hooks.controllers?.beforeLLMCall) {
           const context = {
             iteration,
@@ -15834,7 +16148,7 @@ var init_agent = __esm({
             llmOptions = { ...llmOptions, ...action.modifiedOptions };
           }
         }
-        await this.safeObserve(async () => {
+        await safeObserve(async () => {
           if (this.hooks.observers?.onLLMCallReady) {
             const subagentContext = getSubagentContextForNode(this.tree, llmNode.id);
             const context = {
@@ -15848,7 +16162,7 @@ var init_agent = __esm({
             };
             await this.hooks.observers.onLLMCallReady(context);
           }
-        });
+        }, this.logger);
         return { options: llmOptions, llmNodeId: llmNode.id };
       }
       /**
@@ -16033,6 +16347,7 @@ __export(index_exports, {
   collectText: () => collectText,
   complete: () => complete,
   createAnthropicProviderFromEnv: () => createAnthropicProviderFromEnv,
+  createFileLoggingState: () => createFileLoggingState,
   createGadget: () => createGadget,
   createGadgetOutputViewer: () => createGadgetOutputViewer,
   createGeminiProviderFromEnv: () => createGeminiProviderFromEnv,
@@ -16095,6 +16410,7 @@ __export(index_exports, {
   parseManifest: () => parseManifest,
   parseRetryAfterHeader: () => parseRetryAfterHeader,
   randomDelay: () => randomDelay,
+  resetFileLoggingState: () => resetFileLoggingState,
   resolveConfig: () => resolveConfig,
   resolveHintTemplate: () => resolveHintTemplate,
   resolveModel: () => resolveModel,
@@ -16772,10 +17088,10 @@ function randomDelay(min, max) {
 }
 async function humanDelay(min = 50, max = 150) {
   const delay = randomDelay(min, max);
-  return new Promise((resolve) => setTimeout(resolve, delay));
+  return new Promise((resolve2) => setTimeout(resolve2, delay));
 }
 async function withTimeout(fn, timeoutMs, signal) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     if (signal?.aborted) {
       reject(new Error("Operation aborted"));
       return;
@@ -16801,7 +17117,7 @@ async function withTimeout(fn, timeoutMs, signal) {
         settled = true;
         clearTimeout(timeoutId);
         signal?.removeEventListener("abort", abortHandler);
-        resolve(result);
+        resolve2(result);
       }
     }).catch((error) => {
       if (!settled) {
@@ -16834,7 +17150,7 @@ async function withRetry(fn, options = {}) {
       }
       const waitTime = Math.min(currentDelay, maxDelay);
       onRetry?.(error, attempt + 1, waitTime);
-      await new Promise((resolve) => setTimeout(resolve, waitTime));
+      await new Promise((resolve2) => setTimeout(resolve2, waitTime));
       if (backoff === "exponential") {
         currentDelay *= 2;
       } else {
@@ -16914,6 +17230,7 @@ function getHostExports2(ctx) {
   collectText,
   complete,
   createAnthropicProviderFromEnv,
+  createFileLoggingState,
   createGadget,
   createGadgetOutputViewer,
   createGeminiProviderFromEnv,
@@ -16976,6 +17293,7 @@ function getHostExports2(ctx) {
   parseManifest,
   parseRetryAfterHeader,
   randomDelay,
+  resetFileLoggingState,
   resolveConfig,
   resolveHintTemplate,
   resolveModel,