nexus-agents 2.47.0 → 2.50.0

package/dist/{chunk-ZGKZIEUM.js → chunk-APQJV46Q.js}

@@ -66,7 +66,7 @@ import {
 import {
   DEFAULT_TASK_TTL_MS,
   clampTaskTtl
-} from "./chunk-3YYS74BL.js";
+} from "./chunk-NAN7IILE.js";
 import {
   createSessionMemory
 } from "./chunk-ULDKSIS7.js";
@@ -823,16 +823,16 @@ function classifyEnvKeys(nexusKeys, env) {
   }
   return { knownRecord, unknownVars };
 }
-function logValidationWarnings(logger54, unknownVars, invalidVars) {
+function logValidationWarnings(logger55, unknownVars, invalidVars) {
   for (const u of unknownVars) {
     const hint = u.suggestion !== null ? ` (did you mean ${u.suggestion}?)` : "";
-    logger54.warn(`Unknown environment variable: ${u.name}${hint}`);
+    logger55.warn(`Unknown environment variable: ${u.name}${hint}`);
   }
   for (const inv of invalidVars) {
-    logger54.warn(`Invalid environment variable ${inv.name}="${inv.value}": ${inv.error}`);
+    logger55.warn(`Invalid environment variable ${inv.name}="${inv.value}": ${inv.error}`);
   }
 }
-function validateNexusEnv(logger54) {
+function validateNexusEnv(logger55) {
   const nexusKeys = Object.keys(process.env).filter((k) => k.startsWith("NEXUS_"));
   const { knownRecord, unknownVars } = classifyEnvKeys(nexusKeys, process.env);
   const invalidVars = [];
@@ -847,8 +847,8 @@ function validateNexusEnv(logger54) {
       });
     }
   }
-  if (logger54 !== void 0) {
-    logValidationWarnings(logger54, unknownVars, invalidVars);
+  if (logger55 !== void 0) {
+    logValidationWarnings(logger55, unknownVars, invalidVars);
   }
   return { unknownVars, invalidVars };
 }
@@ -1724,8 +1724,8 @@ function deepMerge(target, source) {
   }
   return result;
 }
-function loadDefaultConfig(logger54) {
-  logger54.debug("No config file found, using defaults");
+function loadDefaultConfig(logger55) {
+  logger55.debug("No config file found, using defaults");
   const validated = AppConfigSchema.safeParse(defaultConfig);
   if (!validated.success) {
     return err(
@@ -1741,7 +1741,7 @@ function loadDefaultConfig(logger54) {
     warnings: ["No config file found, using default configuration"]
   });
 }
-function readAndParseConfig(configPath, mergeDefaults, logger54) {
+function readAndParseConfig(configPath, mergeDefaults, logger55) {
   let content;
   try {
     content = readFileSync(configPath, "utf-8");
@@ -1758,7 +1758,7 @@ function readAndParseConfig(configPath, mergeDefaults, logger54) {
   const parseResult2 = parseYaml(content);
   if (!parseResult2.ok) return err(parseResult2.error);
   if (mergeDefaults && typeof parseResult2.value === "object" && parseResult2.value !== null) {
-    logger54.debug("Merged config with defaults");
+    logger55.debug("Merged config with defaults");
     return ok(
       deepMerge(
         defaultConfig,
@@ -1768,7 +1768,7 @@ function readAndParseConfig(configPath, mergeDefaults, logger54) {
   }
   return ok(parseResult2.value);
 }
-function validateConfig(configData, configPath, logger54) {
+function validateConfig(configData, configPath, logger55) {
   const validation = AppConfigSchema.safeParse(configData);
   if (!validation.success) {
     const issues = formatZodIssuesAsArray(validation.error);
@@ -1777,12 +1777,12 @@ function validateConfig(configData, configPath, logger54) {
 ${issues.join("\n")}`, "VALIDATION_ERROR")
     );
   }
-  logger54.info("Configuration loaded successfully", { configPath });
+  logger55.info("Configuration loaded successfully", { configPath });
   return ok({ config: validation.data, configPath, usingDefaults: false, warnings: [] });
 }
 function loadConfig(options = {}) {
   const { configPath: explicitPath, cwd = process.cwd(), mergeDefaults = true } = options;
-  const logger54 = options.logger ?? createLogger({ component: "ConfigLoader" });
+  const logger55 = options.logger ?? createLogger({ component: "ConfigLoader" });
   let configPath;
   if (explicitPath !== void 0) {
     const validation = validatePath(explicitPath, cwd);
@@ -1791,10 +1791,10 @@ function loadConfig(options = {}) {
   } else {
     configPath = findConfigPath(cwd);
   }
-  if (configPath === void 0) return loadDefaultConfig(logger54);
-  const parseResult2 = readAndParseConfig(configPath, mergeDefaults, logger54);
+  if (configPath === void 0) return loadDefaultConfig(logger55);
+  const parseResult2 = readAndParseConfig(configPath, mergeDefaults, logger55);
   if (!parseResult2.ok) return err(parseResult2.error);
-  return validateConfig(parseResult2.value, configPath, logger54);
+  return validateConfig(parseResult2.value, configPath, logger55);
 }
 var loadedConfig;
 function getConfig(options) {
@@ -2726,12 +2726,12 @@ function removeItemsDirectly(items, targetTokens, manager) {
   };
 }
 async function summarizeAndRemoveItems(options) {
-  const { items, targetTokens, manager, adapter, logger: logger54, customPrompt } = options;
+  const { items, targetTokens, manager, adapter, logger: logger55, customPrompt } = options;
   const content = items.map((item) => item.content).join("\n\n---\n\n");
   const prompt = customPrompt ?? SLIDING_WINDOW_PROMPT;
   const summaryResult = await generateSummary(content, prompt, adapter);
   if (!summaryResult.ok) {
-    logger54.warn("Summarization failed, removing items without summary");
+    logger55.warn("Summarization failed, removing items without summary");
     return removeItemsDirectly(items, targetTokens, manager);
   }
   let tokensFreed = 0;
@@ -2744,7 +2744,7 @@ async function summarizeAndRemoveItems(options) {
   if (summaryAddResult.item !== void 0) {
     tokensFreed -= summaryAddResult.tokenCount;
   }
-  logger54.info("Summarization pruning completed", {
+  logger55.info("Summarization pruning completed", {
     summarizedItems: items.length,
     tokensFreed,
     targetReached: tokensFreed >= targetTokens
@@ -2802,7 +2802,7 @@ function scoreByPriorityWeightedAge(candidates) {
   return scores.map((s) => s.item);
 }
 function removeItemsToTarget(options) {
-  const { sortedItems, targetTokens, categories, manager, minItemsPerCategory, logger: logger54 } = options;
+  const { sortedItems, targetTokens, categories, manager, minItemsPerCategory, logger: logger55 } = options;
   const categoryRemaining = /* @__PURE__ */ new Map();
   for (const category of categories) {
     categoryRemaining.set(category, manager.getByCategory(category).length);
@@ -2819,7 +2819,7 @@ function removeItemsToTarget(options) {
     categoryRemaining.set(item.category, remaining - 1);
   }
   const targetReached = tokensFreed >= targetTokens;
-  logger54.info("Pruning completed", {
+  logger55.info("Pruning completed", {
     itemsRemoved: removedItems.length,
     tokensFreed,
     targetTokens,
@@ -3284,7 +3284,7 @@ function generateBudgetWarning(utilizationPercent, tokensUsed, budgetLimit, scop
     scope
   };
 }
-function logBudgetWarning(warning, logger54) {
+function logBudgetWarning(warning, logger55) {
   const context = {
     scope: warning.scope,
     usagePercent: Math.round(warning.usagePercent),
@@ -3293,13 +3293,13 @@ function logBudgetWarning(warning, logger54) {
   };
   switch (warning.level) {
     case "critical":
-      logger54.warn(warning.message, context);
+      logger55.warn(warning.message, context);
       break;
     case "warning":
-      logger54.warn(warning.message, context);
+      logger55.warn(warning.message, context);
       break;
     case "info":
-      logger54.info(warning.message, context);
+      logger55.info(warning.message, context);
       break;
   }
 }
@@ -3355,8 +3355,8 @@ function createHardModeResult(params) {
     )
   };
 }
-function logWarnModeExceeded(params, logger54) {
-  logger54.warn("Token budget would be exceeded (warn mode - continuing)", {
+function logWarnModeExceeded(params, logger55) {
+  logger55.warn("Token budget would be exceeded (warn mode - continuing)", {
     exceedsSession: params.exceedsSession,
     exceedsTask: params.exceedsTask,
     estimatedTokens: params.estimatedTokens,
@@ -3385,9 +3385,9 @@ var TokenBudgetTracker = class {
    * @param config - Token budget configuration
    * @param logger - Optional logger instance
    */
-  constructor(config = {}, logger54) {
+  constructor(config = {}, logger55) {
     this.config = { ...DEFAULT_TOKEN_BUDGET_CONFIG, ...config };
-    this.logger = logger54 ?? createLogger({ component: "token-budget-tracker" });
+    this.logger = logger55 ?? createLogger({ component: "token-budget-tracker" });
   }
   /**
    * Check if an operation is within budget.
@@ -3540,7 +3540,7 @@ var TokenBudgetTracker = class {
 
 // src/agents/base-agent-state-helpers.ts
 function performLegacyStateTransition(params) {
-  const { stateMachine, logger: logger54, newState } = params;
+  const { stateMachine, logger: logger55, newState } = params;
   const currentState = stateMachine.state;
   if (newState === "error") {
     stateMachine.forceError({ reason: "setState called with error" });
@@ -3550,7 +3550,7 @@ function performLegacyStateTransition(params) {
   if (event !== void 0 && stateMachine.canTransition(event)) {
     const result = stateMachine.transition(event);
     if (!result.ok) {
-      logger54.warn("State transition failed", {
+      logger55.warn("State transition failed", {
         from: currentState,
         to: newState,
         event,
@@ -3558,7 +3558,7 @@ function performLegacyStateTransition(params) {
       });
     }
   } else if (currentState !== newState) {
-    logger54.debug("Unmapped state change (legacy)", { from: currentState, to: newState });
+    logger55.debug("Unmapped state change (legacy)", { from: currentState, to: newState });
   }
 }
 
@@ -3714,7 +3714,7 @@ function getAgentStateKey(agentId) {
 }
 
 // src/agents/memory-operations.ts
-async function persistMemoryState(backend, state, logger54) {
+async function persistMemoryState(backend, state, logger55) {
   const key = getAgentStateKey(state.agentId);
   const metadata = {
     importance: MemoryImportance.HIGH,
@@ -3726,12 +3726,12 @@ async function persistMemoryState(backend, state, logger54) {
   };
   const result = await backend.store(key, updatedState, metadata);
   if (!result.ok) {
-    logger54.error("Failed to persist agent memory state", result.error, { agentId: state.agentId });
+    logger55.error("Failed to persist agent memory state", result.error, { agentId: state.agentId });
     return err(
       new AgentMemoryError("Failed to persist memory state", { error: result.error.message })
     );
   }
-  logger54.debug("Persisted agent memory state", {
+  logger55.debug("Persisted agent memory state", {
     agentId: state.agentId,
     learningsCount: state.taskLearnings.length,
     patternsCount: state.executionPatterns.length,
@@ -3739,16 +3739,16 @@ async function persistMemoryState(backend, state, logger54) {
   });
   return ok(void 0);
 }
-async function loadMemoryState(backend, agentId, role, logger54) {
+async function loadMemoryState(backend, agentId, role, logger55) {
   const key = getAgentStateKey(agentId);
   const result = await backend.retrieve(key);
   if (!result.ok) {
-    logger54.debug("No existing memory state found, creating fresh state", { agentId });
+    logger55.debug("No existing memory state found, creating fresh state", { agentId });
     return ok(createInitialMemoryState(agentId, role));
   }
   const loaded = result.value;
   if (loaded === null || typeof loaded !== "object") {
-    logger54.warn("Invalid memory state format, creating fresh state", { agentId });
+    logger55.warn("Invalid memory state format, creating fresh state", { agentId });
     return ok(createInitialMemoryState(agentId, role));
   }
   const state = {
@@ -3759,7 +3759,7 @@ async function loadMemoryState(backend, agentId, role, logger54) {
     executionPatterns: Array.isArray(loaded.executionPatterns) ? loaded.executionPatterns : [],
     errorResolutions: Array.isArray(loaded.errorResolutions) ? loaded.errorResolutions : []
   };
-  logger54.debug("Loaded agent memory state", {
+  logger55.debug("Loaded agent memory state", {
     agentId,
     learningsCount: state.taskLearnings.length,
     patternsCount: state.executionPatterns.length,
@@ -3767,13 +3767,13 @@ async function loadMemoryState(backend, agentId, role, logger54) {
   });
   return ok(state);
 }
-async function loadRelevantTypedMemories(typedMemory, role, limit, logger54) {
+async function loadRelevantTypedMemories(typedMemory, role, limit, logger55) {
   const result = await typedMemory.filterByRelevance(role, limit);
   if (!result.ok) {
-    logger54.warn("Failed to load relevant typed memories", { role, error: result.error.message });
+    logger55.warn("Failed to load relevant typed memories", { role, error: result.error.message });
     return result;
   }
-  logger54.debug("Loaded relevant typed memories", {
+  logger55.debug("Loaded relevant typed memories", {
     role,
     count: result.value.length,
     types: [...new Set(result.value.map((e) => e.type))]
@@ -3887,10 +3887,10 @@ function initializeMemoryInfrastructure(options) {
 
 // src/agents/base-agent-constructor-helpers.ts
 function setupStateMachine(params) {
-  const { agentId, logger: logger54, eventBus, options } = params;
+  const { agentId, logger: logger55, eventBus, options } = params;
   const stateMachine = new AgentStateMachine(options);
   stateMachine.onStateChange((transition) => {
-    logger54.debug("State transition", {
+    logger55.debug("State transition", {
       from: transition.from,
       to: transition.to,
       event: transition.event
@@ -3904,9 +3904,9 @@ function setupStateMachine(params) {
   return stateMachine;
 }
 function initializeInfrastructure(params) {
-  const { agentId, role, logger: logger54, adapter, pruningConfig, memoryConfig } = params;
+  const { agentId, role, logger: logger55, adapter, pruningConfig, memoryConfig } = params;
   const pruningOpts = {
-    logger: logger54,
+    logger: logger55,
     ...pruningConfig !== void 0 ? { config: pruningConfig } : {},
     ...adapter !== void 0 ? { adapter } : {}
   };
@@ -3914,7 +3914,7 @@ function initializeInfrastructure(params) {
   const memoryOpts = {
     agentId,
     role,
-    logger: logger54,
+    logger: logger55,
     ...memoryConfig !== void 0 ? { config: memoryConfig } : {}
   };
   const memory = initializeMemoryInfrastructure(memoryOpts);
@@ -4146,14 +4146,14 @@ function transformTaskError(error, agentId, taskId) {
   return new AgentError(`Task execution failed: ${message}`, opts);
 }
 function finalizeTaskSuccess(params) {
-  const { task, result, startTime, stateMachine, budgetTracker, logger: logger54 } = params;
+  const { task, result, startTime, stateMachine, budgetTracker, logger: logger55 } = params;
   const durationMs = getTimeProvider().now() - startTime;
   if (stateMachine.state === "thinking") {
     stateMachine.transition("plan_completed", { taskId: task.id });
   }
   stateMachine.transition("task_completed", { taskId: task.id, durationMs });
   const budgetStats = budgetTracker.endTask();
-  logger54.info("Task completed", {
+  logger55.info("Task completed", {
     taskId: task.id,
     durationMs,
     tokensUsed: result.metadata.tokensUsed,
@@ -4181,7 +4181,7 @@ function recordFailedTaskError(params) {
   });
 }
 async function persistMemoryAfterTask(params) {
-  const { memoryEnabled, memoryBackend, memoryState, persistenceMode, task, startTime, logger: logger54 } = params;
+  const { memoryEnabled, memoryBackend, memoryState, persistenceMode, task, startTime, logger: logger55 } = params;
   if (!memoryEnabled || memoryState === null) {
     return memoryState;
   }
@@ -4196,9 +4196,9 @@ async function persistMemoryAfterTask(params) {
     successRate
   });
   if (memoryBackend !== void 0) {
-    await persistMemoryState(memoryBackend, updatedState, logger54);
+    await persistMemoryState(memoryBackend, updatedState, logger55);
   }
-  logger54.debug("Memory persisted after task completion", {
+  logger55.debug("Memory persisted after task completion", {
     taskId: task.id,
     durationMs
   });
@@ -4209,15 +4209,15 @@ function categorizeTaskType(description) {
   return categorizeTaskByKeywords(desc);
 }
 async function persistMemoryOnCleanup(params) {
-  const { memoryEnabled, memoryBackend, memoryState, persistenceMode, logger: logger54 } = params;
+  const { memoryEnabled, memoryBackend, memoryState, persistenceMode, logger: logger55 } = params;
   if (!memoryEnabled || memoryBackend === void 0 || memoryState === null) {
     return;
   }
   if (persistenceMode === "none") {
     return;
   }
-  await persistMemoryState(memoryBackend, memoryState, logger54);
-  logger54.debug("Memory state persisted during cleanup");
+  await persistMemoryState(memoryBackend, memoryState, logger55);
+  logger55.debug("Memory state persisted during cleanup");
 }
 
 // src/agents/base-agent-execute-flow.ts
@@ -4343,14 +4343,14 @@ function createInitialPruningMetrics() {
 
 // src/agents/base-agent-memory-ops.ts
 async function flushMemoryState(params) {
-  const { memoryEnabled, memoryBackend, memoryState, logger: logger54 } = params;
+  const { memoryEnabled, memoryBackend, memoryState, logger: logger55 } = params;
   if (!memoryEnabled) {
     return ok(void 0);
   }
   if (memoryBackend === void 0 || memoryState === null) {
     return ok(void 0);
   }
-  return persistMemoryState(memoryBackend, memoryState, logger54);
+  return persistMemoryState(memoryBackend, memoryState, logger55);
 }
 function recordLearningToState(params) {
   const { memoryEnabled, memoryState, learning } = params;
@@ -5605,13 +5605,13 @@ function shouldFinalize(pattern, participants, results, votes, reviews) {
 
 // src/agents/collaboration/collaboration-session-helpers.ts
 var MAX_EVENT_LISTENERS = 50;
-function emitEventToListeners(listeners, event, logger54) {
+function emitEventToListeners(listeners, event, logger55) {
   for (const listener of listeners) {
     try {
       listener(event);
     } catch (e) {
       const errorObj = e instanceof Error ? e : new Error(String(e));
-      logger54.error("Event listener error", errorObj, { eventType: event.type });
+      logger55.error("Event listener error", errorObj, { eventType: event.type });
     }
   }
 }
@@ -9284,9 +9284,9 @@ var DEFAULT_WAVE_CONFIG = {
 var WaveScheduler = class {
   config;
   logger;
-  constructor(config = {}, logger54) {
+  constructor(config = {}, logger55) {
     this.config = { ...DEFAULT_WAVE_CONFIG, ...config };
-    this.logger = logger54 ?? createLogger({ component: "wave-scheduler" });
+    this.logger = logger55 ?? createLogger({ component: "wave-scheduler" });
   }
   /**
    * Execute tasks in waves respecting dependencies and concurrency limits.
@@ -9520,8 +9520,8 @@ function chunkByDirectory(files, basePath) {
     items
   }));
 }
-function createWaveScheduler(config = {}, logger54) {
-  return new WaveScheduler(config, logger54);
+function createWaveScheduler(config = {}, logger55) {
+  return new WaveScheduler(config, logger55);
 }
 
 // src/agents/experts/expert-types.ts
@@ -14863,9 +14863,9 @@ var SkillLibrary = class {
   config;
   logger;
   store;
-  constructor(config = {}, logger54) {
+  constructor(config = {}, logger55) {
     this.config = { ...DEFAULT_SKILL_LIBRARY_CONFIG2, ...config };
-    this.logger = logger54 ?? createLogger({ component: "SkillLibrary" });
+    this.logger = logger55 ?? createLogger({ component: "SkillLibrary" });
     this.store = {
       skills: /* @__PURE__ */ new Map(),
       executions: /* @__PURE__ */ new Map(),
@@ -15140,8 +15140,8 @@ var SkillLibrary = class {
     return scored.sort((a, b) => b.score - a.score).map((s) => s.skill);
   }
 };
-function createSkillLibrary(config, logger54) {
-  return new SkillLibrary(config, logger54);
+function createSkillLibrary(config, logger55) {
+  return new SkillLibrary(config, logger55);
 }
 
 // src/agents/skills/skill-composer.ts
@@ -15156,10 +15156,10 @@ var SkillComposer = class {
   config;
   logger;
   library;
-  constructor(library, config = {}, logger54) {
+  constructor(library, config = {}, logger55) {
     this.library = library;
     this.config = { ...DEFAULT_COMPOSER_CONFIG, ...config };
-    this.logger = logger54 ?? createLogger({ component: "SkillComposer" });
+    this.logger = logger55 ?? createLogger({ component: "SkillComposer" });
   }
   /**
    * Creates a composition plan for a task.
@@ -15389,8 +15389,8 @@ var SkillComposer = class {
     return errors;
   }
 };
-function createSkillComposer(library, config, logger54) {
-  return new SkillComposer(library, config, logger54);
+function createSkillComposer(library, config, logger55) {
+  return new SkillComposer(library, config, logger55);
 }
 
 // src/agents/skills/skill-dependency-graph-helpers.ts
@@ -16085,10 +16085,10 @@ var SkillLoader = class {
   library;
   logger;
   mappingIndex;
-  constructor(library, config, logger54) {
+  constructor(library, config, logger55) {
     this.library = library;
     this.config = { ...DEFAULT_SKILL_LOADER_CONFIG, ...config };
-    this.logger = logger54 ?? createLogger({ component: "SkillLoader" });
+    this.logger = logger55 ?? createLogger({ component: "SkillLoader" });
     this.mappingIndex = /* @__PURE__ */ new Map();
     for (const mapping of this.config.mappings) {
       this.mappingIndex.set(mapping.role, mapping);
@@ -16311,8 +16311,8 @@ var SkillLoader = class {
     return ok(orderResult.value);
   }
 };
-function createSkillLoader(library, config, logger54) {
-  return new SkillLoader(library, config, logger54);
+function createSkillLoader(library, config, logger55) {
+  return new SkillLoader(library, config, logger55);
 }
 
 // src/agents/skills/external-pack-loader.ts
@@ -16374,13 +16374,13 @@ function validateManifest(raw, packName, source) {
   }
   return ok(parseResult2.data);
 }
-async function loadExternalPack(packSource, logger54) {
+async function loadExternalPack(packSource, logger55) {
   const { name, source, enabled } = packSource;
   if (!enabled) {
-    logger54.debug("Skipping disabled external pack", { name, source });
+    logger55.debug("Skipping disabled external pack", { name, source });
     return ok({ packName: name, skillCount: 0, skills: [] });
   }
-  logger54.info("Loading external skill pack", { name, source });
+  logger55.info("Loading external skill pack", { name, source });
   try {
     const importPath = await resolveImportPath(source);
     const module = await import(importPath);
@@ -16390,7 +16390,7 @@ async function loadExternalPack(packSource, logger54) {
       return validationResult;
     }
     const manifest = validationResult.value;
-    logger54.info("External pack loaded successfully", {
+    logger55.info("External pack loaded successfully", {
       name: manifest.name,
       version: manifest.version,
       skillCount: manifest.skills.length
@@ -16411,22 +16411,22 @@ async function loadExternalPack(packSource, logger54) {
     );
   }
 }
-async function loadAllExternalPacks(packs, logger54) {
+async function loadAllExternalPacks(packs, logger55) {
   const loaded = [];
   const errors = [];
   for (const pack of packs) {
-    const result = await loadExternalPack(pack, logger54);
+    const result = await loadExternalPack(pack, logger55);
     if (result.ok) {
       loaded.push(result.value);
     } else {
       errors.push(result.error);
-      logger54.warn("Failed to load external pack", {
+      logger55.warn("Failed to load external pack", {
         name: pack.name,
         error: result.error.message
       });
     }
   }
-  logger54.info("External pack loading complete", {
+  logger55.info("External pack loading complete", {
     loaded: loaded.length,
     errors: errors.length,
     totalSkills: loaded.reduce((sum, r) => sum + r.skillCount, 0)
@@ -16888,9 +16888,9 @@ var SicaVersionManager = class {
   versions;
   events;
   activeVersionId;
-  constructor(config = {}, logger54) {
+  constructor(config = {}, logger55) {
     this.config = { ...DEFAULT_SICA_CONFIG2, ...config };
-    this.logger = logger54 ?? createLogger({ component: "SicaVersionManager" });
+    this.logger = logger55 ?? createLogger({ component: "SicaVersionManager" });
     this.versions = /* @__PURE__ */ new Map();
     this.events = [];
     this.activeVersionId = null;
@@ -21310,9 +21310,9 @@ var TemplateRegistry = class {
     await this.ensureInitialized();
     const { templates, errors } = await loadTemplatesFromDirectory(directoryPath);
     if (errors.length > 0) {
-      const logger54 = createLogger({ component: "TemplateRegistry" });
+      const logger55 = createLogger({ component: "TemplateRegistry" });
       for (const error of errors) {
-        logger54.warn("Template loading warning", { error: error.message });
+        logger55.warn("Template loading warning", { error: error.message });
       }
     }
     let loadedCount = 0;
@@ -21324,8 +21324,8 @@ var TemplateRegistry = class {
           loadedCount++;
         }
       } catch (regError) {
-        const logger54 = createLogger({ component: "TemplateRegistry" });
-        logger54.warn("Template registration failed", {
+        const logger55 = createLogger({ component: "TemplateRegistry" });
+        logger55.warn("Template registration failed", {
           template: definition.name,
           error: regError instanceof Error ? regError.message : String(regError)
         });
@@ -22174,11 +22174,11 @@ var BudgetCircuitError = class extends NexusError {
 
 // src/workflows/budget-circuit-breaker.ts
 var BudgetCircuitBreaker = class {
-  constructor(maxTokens, config, logger54) {
+  constructor(maxTokens, config, logger55) {
     this.maxTokens = maxTokens;
     this.config = { ...DEFAULT_BUDGET_CIRCUIT_CONFIG, ...config };
     this.lastStateChange = getTimeProvider().now();
-    this.logger = logger54 ?? createLogger({ component: "budget-circuit-breaker" });
+    this.logger = logger55 ?? createLogger({ component: "budget-circuit-breaker" });
   }
   state = "closed";
   lastStateChange;
@@ -22488,10 +22488,10 @@ function createSkippedResult() {
     circuitState: "closed"
   };
 }
-function logEnforcementResult(logger54, stepId, result, currentUsagePercent) {
+function logEnforcementResult(logger55, stepId, result, currentUsagePercent) {
   const usagePercent = Math.round(currentUsagePercent * 100);
   if (!result.allowed) {
-    logger54.warn("Budget enforcement blocked step", {
+    logger55.warn("Budget enforcement blocked step", {
       stepId,
       reason: result.reason,
       circuitState: result.circuitState,
@@ -22501,14 +22501,14 @@ function logEnforcementResult(logger54, stepId, result, currentUsagePercent) {
     return;
   }
   if (result.warning !== void 0) {
-    logger54.warn("Budget enforcement warning", {
+    logger55.warn("Budget enforcement warning", {
       stepId,
       warning: result.warning,
       currentUsage: usagePercent
     });
     return;
   }
-  logger54.debug("Budget enforcement passed for step", {
+  logger55.debug("Budget enforcement passed for step", {
     stepId,
     currentUsage: usagePercent,
     allocatedTokens: result.allocatedTokens
@@ -22544,15 +22544,15 @@ function buildFinalOutput(stepResults) {
 }
 
 // src/workflows/workflow-engine-execution.ts
-function createContextManagerForWorkflow(config, workflow, logger54) {
+function createContextManagerForWorkflow(config, workflow, logger55) {
   if (config.contextManagerConfig === void 0) return void 0;
   const budget = workflow.defaultBudget ?? config.defaultBudget;
-  return new ContextManager({ ...config.contextManagerConfig, budget, logger: logger54 });
+  return new ContextManager({ ...config.contextManagerConfig, budget, logger: logger55 });
 }
-function createBudgetCircuitBreakerForWorkflow(contextManager, workflow, config, logger54) {
+function createBudgetCircuitBreakerForWorkflow(contextManager, workflow, config, logger55) {
   const budgetConfig = {
     engineDefaultBudget: config.defaultBudget,
-    logger: logger54
+    logger: logger55
   };
   if (workflow.defaultBudget !== void 0) {
     budgetConfig.workflowDefaultBudget = workflow.defaultBudget;
@@ -22587,12 +22587,12 @@ function applyInputDefaults(workflow, inputs) {
   return merged;
 }
 function initializeExecution(params) {
-  const { workflow, inputs, config, logger: logger54 } = params;
+  const { workflow, inputs, config, logger: logger55 } = params;
   const executionId = generateUUID();
   const startTime = getTimeProvider().now();
   const resolvedInputs = applyInputDefaults(workflow, inputs);
-  const contextManager = createContextManagerForWorkflow(config, workflow, logger54);
-  const budgetCircuitBreaker = config.enableBudgetEnforcement ? createBudgetCircuitBreakerForWorkflow(contextManager, workflow, config, logger54) : void 0;
+  const contextManager = createContextManagerForWorkflow(config, workflow, logger55);
+  const budgetCircuitBreaker = config.enableBudgetEnforcement ? createBudgetCircuitBreakerForWorkflow(contextManager, workflow, config, logger55) : void 0;
   const context = {
     workflowId: workflow.name,
     executionId,
@@ -22612,7 +22612,7 @@ function initializeExecution(params) {
     startTime
   };
   if (contextManager !== void 0) {
-    logger54.debug("Context manager initialized for workflow execution", {
+    logger55.debug("Context manager initialized for workflow execution", {
       executionId,
       workflowName: workflow.name,
       budget: workflow.defaultBudget ?? config.defaultBudget
@@ -22621,10 +22621,10 @@ function initializeExecution(params) {
   return { executionId, context, startTime, execution };
 }
 function enforceStepBudgets(options) {
-  const { steps, context, workflow, totalSteps, config, logger: logger54 } = options;
+  const { steps, context, workflow, totalSteps, config, logger: logger55 } = options;
   const budgetConfig = {
     engineDefaultBudget: config.defaultBudget,
-    logger: logger54
+    logger: logger55
   };
   if (workflow.defaultBudget !== void 0) {
     budgetConfig.workflowDefaultBudget = workflow.defaultBudget;
@@ -22909,29 +22909,29 @@ function createExpertFactoryWithAdapter(adapter) {
   };
   return new ExpertFactoryAdapter(factoryWrapper);
 }
-function adaptLoggerForStepExecutor(logger54) {
+function adaptLoggerForStepExecutor(logger55) {
   return {
     debug: (message, data) => {
-      logger54.debug(message, data);
+      logger55.debug(message, data);
     },
     info: (message, data) => {
-      logger54.info(message, data);
+      logger55.info(message, data);
     },
     warn: (message, data) => {
-      logger54.warn(message, data);
+      logger55.warn(message, data);
     },
     error: (message, data) => {
       if (data !== void 0) {
         const errorContext = { ...data };
-        logger54.error(message, void 0, errorContext);
+        logger55.error(message, void 0, errorContext);
       } else {
-        logger54.error(message);
+        logger55.error(message);
       }
     }
   };
 }
-function createRealStepExecutorCallback(expertFactory, logger54, workflowId) {
-  const adaptedLogger = adaptLoggerForStepExecutor(logger54);
+function createRealStepExecutorCallback(expertFactory, logger55, workflowId) {
+  const adaptedLogger = adaptLoggerForStepExecutor(logger55);
   const executor = createStepExecutor({ expertFactory, logger: adaptedLogger });
   return async (step, ctx) => {
     const startTime = getTimeProvider().now();
@@ -22947,7 +22947,7 @@ function createRealStepExecutorCallback(expertFactory, logger54, workflowId) {
     }
     const result = await executor.execute(step, workflowCtx);
     if (!result.ok) {
-      logger54.warn("Step execution failed", {
+      logger55.warn("Step execution failed", {
         stepId: step.id,
         error: result.error.message
       });
@@ -23007,10 +23007,10 @@ function adaptExecutionPlan(plannerPlan) {
   }));
   return { phases };
 }
-function createMockStepExecutor(logger54) {
+function createMockStepExecutor(logger55) {
   return (step, _ctx) => {
     const startTime = getTimeProvider().now();
-    logger54.debug("Executing step (mock)", {
+    logger55.debug("Executing step (mock)", {
       stepId: step.id,
       agent: step.agent,
       action: step.action
@@ -23019,16 +23019,16 @@ function createMockStepExecutor(logger54) {
   };
 }
 function resolveStepExecutor(options) {
-  const { logger: logger54, expertFactory, workflowId, useMockExecutor } = options;
+  const { logger: logger55, expertFactory, workflowId, useMockExecutor } = options;
   if (useMockExecutor === true) {
-    logger54.warn(
+    logger55.warn(
       "useMockExecutor enabled; workflow steps will return mock results (NOT RECOMMENDED)"
     );
-    return createMockStepExecutor(logger54);
+    return createMockStepExecutor(logger55);
   }
   if (expertFactory !== void 0 && workflowId !== void 0) {
-    logger54.info("Using real StepExecutor with ExpertFactory", { workflowId });
-    return createRealStepExecutorCallback(expertFactory, logger54, workflowId);
+    logger55.info("Using real StepExecutor with ExpertFactory", { workflowId });
+    return createRealStepExecutorCallback(expertFactory, logger55, workflowId);
   }
   if (expertFactory !== void 0 && workflowId === void 0) {
     throw new WorkflowExecutionUnavailableError("expertFactory provided but workflowId missing");
@@ -23039,9 +23039,9 @@ function resolveStepExecutor(options) {
 }
 function createExecutePhase(options) {
   const stepExecutor = resolveStepExecutor(options);
-  const { logger: logger54 } = options;
+  const { logger: logger55 } = options;
   return async (steps, context, executionOptions) => {
-    logger54.debug("Executing phase", {
+    logger55.debug("Executing phase", {
       stepCount: steps.length,
       executionId: context.executionId,
       maxConcurrency: executionOptions.maxConcurrency
@@ -23092,26 +23092,26 @@ function createAdaptedExecutionPlan() {
     return ok(adaptExecutionPlan(planResult.value));
   };
 }
-function resolveExpertFactory(config, logger54) {
+function resolveExpertFactory(config, logger55) {
   if (config?.expertFactory !== void 0) {
     return config.expertFactory;
   }
   if (config?.modelAdapter !== void 0) {
-    logger54.info("Created ExpertFactory with provided model adapter");
+    logger55.info("Created ExpertFactory with provided model adapter");
     return createExpertFactoryWithAdapter(config.modelAdapter);
   }
   return void 0;
 }
 function createWorkflowEngineDeps(config) {
-  const logger54 = config?.logger ?? createLogger({ component: "WorkflowEngine" });
+  const logger55 = config?.logger ?? createLogger({ component: "WorkflowEngine" });
   const builtInTemplates = config?.builtInTemplates ?? cachedBuiltInTemplates ?? /* @__PURE__ */ new Map();
-  const expertFactory = resolveExpertFactory(config, logger54);
+  const expertFactory = resolveExpertFactory(config, logger55);
   return {
     parseWorkflow: createParseWorkflow(),
     loadWorkflowFile: createLoadWorkflowFile(),
     createExecutionPlan: createAdaptedExecutionPlan(),
     executePhase: createExecutePhase({
-      logger: logger54,
+      logger: logger55,
       expertFactory,
       workflowId: "default",
       useMockExecutor: config?.useMockExecutor
@@ -23142,32 +23142,32 @@ async function createInitializedWorkflowEngine(config) {
 function shouldSkipAdapterDetection(config) {
   return config?.modelAdapter !== void 0 || config?.expertFactory !== void 0 || config?.useMockExecutor === true;
 }
-function tryAutoDetectAdapter(logger54) {
+function tryAutoDetectAdapter(logger55) {
   try {
-    logger54.info("Auto-detecting model adapter for workflow execution");
-    const registry = getGlobalRegistry({ logger: logger54 });
+    logger55.info("Auto-detecting model adapter for workflow execution");
+    const registry = getGlobalRegistry({ logger: logger55 });
     const adapter = registry.getDefault();
-    logger54.info("Using unified registry default adapter");
+    logger55.info("Using unified registry default adapter");
     return adapter;
   } catch (error) {
     const message = getErrorMessage(error);
-    logger54.warn("No model adapter available, using mock executor", { error: message });
+    logger55.warn("No model adapter available, using mock executor", { error: message });
     return void 0;
   }
 }
 function createWorkflowEngineDepsAsync(config) {
-  const logger54 = config?.logger ?? createLogger({ component: "WorkflowEngine" });
+  const logger55 = config?.logger ?? createLogger({ component: "WorkflowEngine" });
   if (shouldSkipAdapterDetection(config)) {
-    logger54.debug("Skipping adapter detection - using provided config");
+    logger55.debug("Skipping adapter detection - using provided config");
     return Promise.resolve(createWorkflowEngineDeps(config));
   }
-  const adapter = tryAutoDetectAdapter(logger54);
+  const adapter = tryAutoDetectAdapter(logger55);
   if (adapter !== void 0) {
-    return Promise.resolve(createWorkflowEngineDeps({ ...config, modelAdapter: adapter, logger: logger54 }));
+    return Promise.resolve(createWorkflowEngineDeps({ ...config, modelAdapter: adapter, logger: logger55 }));
   }
   if (config?.useMockExecutor === true) {
-    logger54.warn("Using mock executor as explicitly configured (no real adapter available)");
-    return Promise.resolve(createWorkflowEngineDeps({ ...config, useMockExecutor: true, logger: logger54 }));
+    logger55.warn("Using mock executor as explicitly configured (no real adapter available)");
+    return Promise.resolve(createWorkflowEngineDeps({ ...config, useMockExecutor: true, logger: logger55 }));
   }
   return Promise.reject(
     new WorkflowExecutionUnavailableError(
@@ -23249,23 +23249,23 @@ function createToolLogger(parentLogger, toolName, requestId) {
   }
   return parentLogger.child(context);
 }
-function logToolStart(logger54, toolName, args) {
-  logger54.info("Tool execution started", {
+function logToolStart(logger55, toolName, args) {
+  logger55.info("Tool execution started", {
     tool: toolName,
     hasArgs: args !== void 0,
     argKeys: args !== void 0 ? Object.keys(args) : []
   });
 }
-function logToolSuccess(logger54, toolName, durationMs, resultInfo) {
-  logger54.info("Tool execution completed", {
+function logToolSuccess(logger55, toolName, durationMs, resultInfo) {
+  logger55.info("Tool execution completed", {
     tool: toolName,
     durationMs,
     success: true,
     ...resultInfo
   });
 }
-function logToolError(logger54, toolName, error, durationMs) {
-  logger54.error("Tool execution failed", error, {
+function logToolError(logger55, toolName, error, durationMs) {
+  logger55.error("Tool execution failed", error, {
     tool: toolName,
     durationMs,
     success: false,
@@ -23278,8 +23278,8 @@ function createTimer() {
     elapsed: () => getTimeProvider().now() - startTime
   };
 }
-function withLogging(toolName, handler2, logger54) {
-  const toolLogger = createToolLogger(logger54, toolName);
+function withLogging(toolName, handler2, logger55) {
+  const toolLogger = createToolLogger(logger55, toolName);
   return async (args) => {
     const timer = createTimer();
     logToolStart(toolLogger, toolName, args);
@@ -23365,9 +23365,9 @@ var AuthHandler = class {
   config;
   logger;
   storedToken;
-  constructor(config, logger54) {
+  constructor(config, logger55) {
     this.config = resolveAuthConfig(config);
-    this.logger = logger54 ?? createLogger({ component: "AuthHandler" });
+    this.logger = logger55 ?? createLogger({ component: "AuthHandler" });
     if (this.config.enabled) this.loadToken();
   }
   /**
@@ -23466,22 +23466,22 @@ var AuthHandler = class {
 };
 
 // src/mcp/middleware/tool-error-handler.ts
-function toolErrorResponse(prefix, error, logger54) {
+function toolErrorResponse(prefix, error, logger55) {
   const message = getErrorMessage(error);
-  if (logger54 !== void 0) {
+  if (logger55 !== void 0) {
     const errorObj = error instanceof Error ? error : new Error(message);
-    logger54.error(prefix, errorObj);
+    logger55.error(prefix, errorObj);
   }
   return {
     isError: true,
     content: [{ type: "text", text: `${prefix}: ${message}` }]
   };
 }
-async function withToolError(prefix, logger54, fn) {
+async function withToolError(prefix, logger55, fn) {
   try {
     return await fn();
   } catch (error) {
-    return toolErrorResponse(prefix, error, logger54);
+    return toolErrorResponse(prefix, error, logger55);
   }
 }
 
@@ -25961,47 +25961,47 @@ function createSubscriptions(eventBus, subs, handler2) {
   }
   return subscriptions;
 }
-function createCleanupFunction(subscriptions, eventBus, logger54) {
+function createCleanupFunction(subscriptions, eventBus, logger55) {
   return () => {
-    logger54.debug("Cleaning up EventBus bridge subscriptions");
+    logger55.debug("Cleaning up EventBus bridge subscriptions");
     for (const sub of subscriptions) {
       sub.unsubscribe();
     }
-    logger54.info("EventBus bridge cleanup complete", {
+    logger55.info("EventBus bridge cleanup complete", {
       unsubscribedCount: subscriptions.length,
       finalStats: eventBus.getStats()
     });
   };
 }
-function initializeEventBusBridge(observer, logger54, config) {
+function initializeEventBusBridge(observer, logger55, config) {
   const mergedConfig = mergeConfig2(config);
   if (!mergedConfig.enabled) {
-    logger54.debug("EventBus bridge disabled by configuration");
+    logger55.debug("EventBus bridge disabled by configuration");
     return { initialized: false, subscriptionCount: 0, cleanup: () => {
     } };
   }
   const eventBus = getGlobalEventBus({ maxHistorySize: mergedConfig.maxHistorySize });
   const logConfig = mergedConfig.logging;
-  logger54.info("Initializing EventBus bridge for MCP server", {
+  logger55.info("Initializing EventBus bridge for MCP server", {
     maxHistorySize: mergedConfig.maxHistorySize,
     subscriptions: mergedConfig.subscriptions
   });
   const handler2 = (event) => {
-    handleEvent(event, observer, logger54, logConfig);
+    handleEvent(event, observer, logger55, logConfig);
   };
   const subscriptions = createSubscriptions(eventBus, mergedConfig.subscriptions, handler2);
-  logger54.info("EventBus bridge initialized", {
+  logger55.info("EventBus bridge initialized", {
     subscriptionCount: subscriptions.length,
     eventBusStats: eventBus.getStats()
   });
-  const cleanup = createCleanupFunction(subscriptions, eventBus, logger54);
+  const cleanup = createCleanupFunction(subscriptions, eventBus, logger55);
   return {
     initialized: true,
     subscriptionCount: subscriptions.length,
     cleanup
   };
 }
-function handleEvent(event, observer, logger54, logConfig) {
+function handleEvent(event, observer, logger55, logConfig) {
   const isImportant = IMPORTANT_TOPICS.has(event.topic);
   const logLevel = isImportant ? logConfig.importantEventLevel : logConfig.frequentEventLevel;
   const logContext = {
@@ -26012,9 +26012,9 @@ function handleEvent(event, observer, logger54, logConfig) {
     timestamp: event.timestamp
   };
   if (logLevel === "info") {
-    logger54.info(`EventBus: ${event.topic}`, logContext);
+    logger55.info(`EventBus: ${event.topic}`, logContext);
   } else {
-    logger54.debug(`EventBus: ${event.topic}`, logContext);
+    logger55.debug(`EventBus: ${event.topic}`, logContext);
   }
   recordEventToObserver(event, observer);
 }
@@ -26192,19 +26192,19 @@ var PROMPT_DEFINITIONS = [
 ];
 
 // src/mcp/prompts/index.ts
-function registerPrompts(server, logger54) {
+function registerPrompts(server, logger55) {
   const registered = [];
   for (const definition of PROMPT_DEFINITIONS) {
-    registerSinglePrompt(server, definition, logger54);
+    registerSinglePrompt(server, definition, logger55);
     registered.push(definition.name);
   }
-  logger54.info("Prompt templates registered", {
+  logger55.info("Prompt templates registered", {
     count: registered.length,
     prompts: registered
   });
   return { prompts: registered };
 }
-function registerSinglePrompt(server, definition, logger54) {
+function registerSinglePrompt(server, definition, logger55) {
   server.registerPrompt(
     definition.name,
     {
@@ -26212,7 +26212,7 @@ function registerSinglePrompt(server, definition, logger54) {
       argsSchema: definition.argsSchema
     },
     (args) => {
-      logger54.debug("Prompt requested", { prompt: definition.name });
+      logger55.debug("Prompt requested", { prompt: definition.name });
       const messages = definition.buildMessages(args);
       return {
         description: definition.description,
@@ -26252,7 +26252,7 @@ function buildModelsPayload() {
     }))
   };
 }
-function registerModelsResource(server, logger54) {
+function registerModelsResource(server, logger55) {
   server.registerResource(
     MODELS_RESOURCE_NAME,
     MODELS_RESOURCE_URI,
@@ -26261,7 +26261,7 @@ function registerModelsResource(server, logger54) {
       mimeType: "application/json"
     },
     () => {
-      logger54.debug("Reading models resource");
+      logger55.debug("Reading models resource");
       const payload = buildModelsPayload();
       return {
         contents: [
@@ -26274,7 +26274,7 @@ function registerModelsResource(server, logger54) {
       };
     }
   );
-  logger54.info("Registered models resource", { uri: MODELS_RESOURCE_URI });
+  logger55.info("Registered models resource", { uri: MODELS_RESOURCE_URI });
 }
 
 // src/indexer/research-index/research-index-base-types.ts
@@ -27065,10 +27065,10 @@ ${topicLines}
 // src/mcp/resources/research-resource.ts
 var RESEARCH_RESOURCE_URI = "nexus://research/papers";
 var RESEARCH_RESOURCE_NAME = "research-papers";
-function buildResearchPayload(logger54) {
+function buildResearchPayload(logger55) {
   const result = parseRegistry();
   if (!result.ok) {
-    logger54.debug("Research registry not available", {
+    logger55.debug("Research registry not available", {
       error: result.error.message
     });
     return {
@@ -27102,7 +27102,7 @@ function buildResearchPayload(logger54) {
     stats: index.stats
   };
 }
-function registerResearchResource(server, logger54) {
+function registerResearchResource(server, logger55) {
   server.registerResource(
     RESEARCH_RESOURCE_NAME,
     RESEARCH_RESOURCE_URI,
@@ -27111,9 +27111,9 @@ function registerResearchResource(server, logger54) {
       mimeType: "application/json"
     },
     () => {
-      logger54.debug("Reading research resource");
+      logger55.debug("Reading research resource");
       try {
-        const payload = buildResearchPayload(logger54);
+        const payload = buildResearchPayload(logger55);
         return {
           contents: [
             {
@@ -27124,7 +27124,7 @@ function registerResearchResource(server, logger54) {
           ]
         };
       } catch (error) {
-        logger54.warn("Failed to build research payload", {
+        logger55.warn("Failed to build research payload", {
           error: getErrorMessage(error)
         });
         return {
@@ -27139,7 +27139,7 @@ function registerResearchResource(server, logger54) {
       }
     }
   );
-  logger54.info("Registered research resource", { uri: RESEARCH_RESOURCE_URI });
+  logger55.info("Registered research resource", { uri: RESEARCH_RESOURCE_URI });
 }
 
 // src/mcp/tools/create-expert.ts
@@ -27240,29 +27240,29 @@ var ROLE_TO_TASK_CATEGORY = {
   pm_expert: "planning",
   ux_expert: "planning"
 };
-function resolveAdapterForModelPreference(modelPreference, fallbackAdapter, logger54) {
-  const registry = getGlobalRegistry({ logger: logger54 });
+function resolveAdapterForModelPreference(modelPreference, fallbackAdapter, logger55) {
+  const registry = getGlobalRegistry({ logger: logger55 });
   const adapter = registry.getAdapterForModel(modelPreference);
   if (adapter === registry.getDefault() && fallbackAdapter !== void 0) {
-    logger54.debug("Model preference not in registry, using fallback adapter", { modelPreference });
+    logger55.debug("Model preference not in registry, using fallback adapter", { modelPreference });
     return fallbackAdapter;
   }
-  logger54.info("Routing expert to CLI for model preference", { modelPreference });
+  logger55.info("Routing expert to CLI for model preference", { modelPreference });
   return adapter;
 }
-function resolveAdapterForRole(role, fallbackAdapter, logger54) {
+function resolveAdapterForRole(role, fallbackAdapter, logger55) {
   const category = ROLE_TO_TASK_CATEGORY[role];
   if (category === void 0) return fallbackAdapter;
-  const registry = getGlobalRegistry({ logger: logger54 });
+  const registry = getGlobalRegistry({ logger: logger55 });
   const adapter = registry.getAdapter(category);
-  logger54.info("Auto-routing expert to specialized CLI", {
+  logger55.info("Auto-routing expert to specialized CLI", {
     role,
     category,
     preferredCli: registry.getRouting(category)?.primaryCli
   });
   return adapter;
 }
-function getExpertFallbackChain(role, excludeCli, logger54) {
+function getExpertFallbackChain(role, excludeCli, logger55) {
   const category = ROLE_TO_TASK_CATEGORY[role];
   if (category === void 0) return [];
   const bucketType = CATEGORY_TO_FALLBACK_TYPE[category];
@@ -27271,7 +27271,7 @@ function getExpertFallbackChain(role, excludeCli, logger54) {
     bucketType
   );
   const filtered = chain.filter((cli) => cli !== excludeCli);
-  logger54.debug("Expert fallback chain resolved", { role, category, excludeCli, chain: filtered });
+  logger55.debug("Expert fallback chain resolved", { role, category, excludeCli, chain: filtered });
   return [...filtered];
 }
 
@@ -27377,16 +27377,16 @@ function buildResponse(expert) {
   };
 }
 function createExpertFromFactory(deps, expertType, modelPreference, role) {
-  const logger54 = deps.logger ?? createLogger({ tool: "create_expert" });
+  const logger55 = deps.logger ?? createLogger({ tool: "create_expert" });
   const options = {};
   if (modelPreference !== void 0) {
     options.modelOverrides = { modelId: modelPreference };
   }
   let adapter;
   if (modelPreference !== void 0) {
-    adapter = resolveAdapterForModelPreference(modelPreference, deps.modelAdapter, logger54);
+    adapter = resolveAdapterForModelPreference(modelPreference, deps.modelAdapter, logger55);
   } else if (role !== void 0) {
-    adapter = resolveAdapterForRole(role, deps.modelAdapter, logger54);
+    adapter = resolveAdapterForRole(role, deps.modelAdapter, logger55);
   } else {
     adapter = deps.modelAdapter;
   }
@@ -27457,7 +27457,7 @@ function createCreateExpertHandler(deps) {
   };
 }
 function registerCreateExpertTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "create_expert" });
+  const logger55 = deps.logger ?? createLogger({ tool: "create_expert" });
   const toolSchema = {
     role: z56.enum([
       "code_expert",
@@ -27477,23 +27477,23 @@ function registerCreateExpertTool(server, deps) {
   const secureHandler = createSecureHandler(createCreateExpertHandler(deps), {
     toolName: "create_expert",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("create_expert", deps.security);
-  const wrappedHandler = wrapToolWithTimeout("create_expert", secureHandler, { timeoutMs, logger: logger54 });
+  const wrappedHandler = wrapToolWithTimeout("create_expert", secureHandler, { timeoutMs, logger: logger55 });
   server.registerTool(
     "create_expert",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered create_expert tool with secure handler and timeout protection");
+  logger55.info("Registered create_expert tool with secure handler and timeout protection");
 }
-function createDefaultDeps(rateLimiter, logger54) {
+function createDefaultDeps(rateLimiter, logger55) {
   return {
     expertFactory: ExpertFactory,
     expertRegistry: /* @__PURE__ */ new Map(),
     rateLimiter,
-    ...logger54 !== void 0 ? { logger: logger54 } : {}
+    ...logger55 !== void 0 ? { logger: logger55 } : {}
   };
 }
 function getAvailableRoles() {
@@ -27528,7 +27528,7 @@ function buildExpertsPayload() {
     experts
   };
 }
-function registerExpertsResource(server, logger54) {
+function registerExpertsResource(server, logger55) {
   server.registerResource(
     EXPERTS_RESOURCE_NAME,
     EXPERTS_RESOURCE_URI,
@@ -27537,7 +27537,7 @@ function registerExpertsResource(server, logger54) {
       mimeType: "application/json"
     },
     () => {
-      logger54.debug("Reading experts resource");
+      logger55.debug("Reading experts resource");
       const payload = buildExpertsPayload();
       return {
         contents: [
@@ -27550,12 +27550,12 @@ function registerExpertsResource(server, logger54) {
       };
     }
   );
-  logger54.info("Registered experts resource", { uri: EXPERTS_RESOURCE_URI });
+  logger55.info("Registered experts resource", { uri: EXPERTS_RESOURCE_URI });
 }
 
 // src/mcp/resources/index.ts
-function registerResources(server, logger54) {
-  const log3 = logger54 ?? createLogger({ component: "mcp-resources" });
+function registerResources(server, logger55) {
+  const log3 = logger55 ?? createLogger({ component: "mcp-resources" });
   log3.info("Registering MCP resources");
   registerModelsResource(server, log3);
   registerResearchResource(server, log3);
@@ -27669,11 +27669,11 @@ function validateWorkflowInputs(workflow, inputs) {
   };
 }
 async function loadWorkflowFromPath(deps, filePath) {
-  const { workflowEngine, logger: logger54 } = deps;
+  const { workflowEngine, logger: logger55 } = deps;
   const allowedDirs = getAllowedWorkflowDirs(deps);
   const pathValidation = validateWorkflowPath(filePath, allowedDirs);
   if (!pathValidation.ok) {
-    logger54?.warn("Workflow path validation failed", {
+    logger55?.warn("Workflow path validation failed", {
       path: filePath,
       error: pathValidation.error.message
     });
@@ -27692,8 +27692,8 @@ async function loadWorkflowFromPath(deps, filePath) {
   return result;
 }
 async function loadWorkflowFromName(deps, name) {
-  const { workflowEngine, logger: logger54 } = deps;
-  logger54?.debug("Looking up built-in template", { name });
+  const { workflowEngine, logger: logger55 } = deps;
+  logger55?.debug("Looking up built-in template", { name });
   const templates = await workflowEngine.listTemplates();
   const found = templates.find((t) => t.name === name);
   if (found === void 0) {
@@ -27717,9 +27717,9 @@ async function loadWorkflowFromName(deps, name) {
   return { ok: true, value: definition };
 }
 async function loadWorkflow(deps, template) {
-  const { logger: logger54 } = deps;
+  const { logger: logger55 } = deps;
   if (isFilePath(template)) {
-    logger54?.debug("Loading workflow from file", { path: template });
+    logger55?.debug("Loading workflow from file", { path: template });
     return loadWorkflowFromPath(deps, template);
   }
   return loadWorkflowFromName(deps, template);
@@ -27766,15 +27766,15 @@ function formatValidationErrors(validation) {
 
 // src/mcp/tools/run-workflow.ts
 async function executeWorkflow(deps, workflow, inputs) {
-  const { workflowEngine, logger: logger54 } = deps;
-  logger54?.info("Executing workflow", {
+  const { workflowEngine, logger: logger55 } = deps;
+  logger55?.info("Executing workflow", {
     workflowName: workflow.name,
     inputCount: Object.keys(inputs).length
   });
   const startTime = getTimeProvider().now();
   const result = await workflowEngine.execute(workflow, inputs);
   if (!result.ok) {
-    logger54?.error("Workflow execution failed", result.error, {
+    logger55?.error("Workflow execution failed", result.error, {
       workflowName: workflow.name
     });
     return {
@@ -27783,7 +27783,7 @@ async function executeWorkflow(deps, workflow, inputs) {
     };
   }
   const workflowResult = result.value;
-  logger54?.info("Workflow completed", {
+  logger55?.info("Workflow completed", {
     workflowName: workflow.name,
     durationMs: getTimeProvider().now() - startTime,
     stepCount: workflowResult.stepResults.length
@@ -27896,16 +27896,16 @@ function createRunWorkflowHandler(deps) {
   };
 }
 function registerRunWorkflowTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "run_workflow" });
+  const logger55 = deps.logger ?? createLogger({ tool: "run_workflow" });
   const notifier = deps.notifier ?? createMcpNotifier(server);
   const depsWithNotifier = { ...deps, notifier };
   const secureHandler = createSecureHandler(createRunWorkflowHandler(depsWithNotifier), {
     toolName: "run_workflow",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("run_workflow", deps.security);
-  const wrappedHandler = wrapToolWithTimeout("run_workflow", secureHandler, { timeoutMs, logger: logger54 });
+  const wrappedHandler = wrapToolWithTimeout("run_workflow", secureHandler, { timeoutMs, logger: logger55 });
   server.registerTool(
     "run_workflow",
     {
@@ -27914,7 +27914,7 @@ function registerRunWorkflowTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered run_workflow tool with secure handler and timeout protection");
+  logger55.info("Registered run_workflow tool with secure handler and timeout protection");
 }
 
 // src/orchestration/graph/graph-types.ts
@@ -30078,8 +30078,8 @@ var OrchestratorAdapter = class {
   history = [];
   logger;
   agent = null;
-  constructor(logger54) {
-    this.logger = logger54 ?? createLogger({ component: "OrchestratorAdapter" });
+  constructor(logger55) {
+    this.logger = logger55 ?? createLogger({ component: "OrchestratorAdapter" });
   }
   setOrchestrator(agent) {
     this.agent = agent;
@@ -30219,10 +30219,10 @@ var WorkflowOrchestratorAdapter = class {
   logger;
   executions = /* @__PURE__ */ new Map();
   history = [];
-  constructor(engine, logger54) {
+  constructor(engine, logger55) {
     this.id = `workflow-${randomUUID10().slice(0, 8)}`;
     this.engine = engine;
-    this.logger = logger54 ?? createLogger({ component: "WorkflowOrchestratorAdapter" });
+    this.logger = logger55 ?? createLogger({ component: "WorkflowOrchestratorAdapter" });
   }
   async execute(definition, inputs, _options) {
     if (definition.type !== "workflow") {
@@ -30414,22 +30414,22 @@ var OrchestratorFactory = class {
   }
 };
 async function createOrchestratorFactory(config) {
-  const logger54 = config?.logger ?? createLogger({ component: "OrchestratorFactory" });
-  logger54.info("Initializing OrchestratorFactory");
+  const logger55 = config?.logger ?? createLogger({ component: "OrchestratorFactory" });
+  logger55.info("Initializing OrchestratorFactory");
   let workflowEngine;
   try {
     const workflowConfig = {
       ...config?.workflowConfig,
-      logger: logger54
+      logger: logger55
     };
     if (config?.modelAdapter !== void 0) {
       workflowConfig.modelAdapter = config.modelAdapter;
     }
     workflowEngine = await createProductionWorkflowEngine(workflowConfig);
-    logger54.info("WorkflowEngine initialized");
+    logger55.info("WorkflowEngine initialized");
   } catch (error) {
     const message = getErrorMessage(error);
-    logger54.warn("WorkflowEngine initialization failed, workflow orchestration unavailable", {
+    logger55.warn("WorkflowEngine initialization failed, workflow orchestration unavailable", {
       error: message
     });
   }
@@ -30440,12 +30440,12 @@ async function createOrchestratorFactory(config) {
 var MAX_OUTCOMES2 = 200;
 var AMBIGUITY_THRESHOLD = 0.7;
 function createWorkflowRouter(options) {
-  const logger54 = options?.logger ?? createLogger({ component: "WorkflowRouter" });
-  const analyzer = options?.analyzer ?? createSharedTaskAnalyzer({ logger: logger54 });
+  const logger55 = options?.logger ?? createLogger({ component: "WorkflowRouter" });
+  const analyzer = options?.analyzer ?? createSharedTaskAnalyzer({ logger: logger55 });
   const outcomes = [];
   return {
     route(signals, routerOpts) {
-      return routeTask(signals, analyzer, logger54, routerOpts);
+      return routeTask(signals, analyzer, logger55, routerOpts);
     },
     recordOutcome(outcome) {
       recordPatternOutcome(outcomes, outcome);
@@ -30487,7 +30487,7 @@ function buildDecision(input) {
   }
   return base;
 }
-function routeTask(signals, analyzer, logger54, _opts) {
+function routeTask(signals, analyzer, logger55, _opts) {
   const analysis = analyzer.analyze(signals.description);
   const enriched = enrichSignals(signals, analysis);
   const matchedRules = [];
@@ -30497,7 +30497,7 @@ function routeTask(signals, analyzer, logger54, _opts) {
     if (result !== void 0) {
       matchedRules.push(rule.name);
       collectAlternatives(alternatives, result.pattern);
-      logger54.info("Workflow pattern selected", {
+      logger55.info("Workflow pattern selected", {
         pattern: result.pattern,
         rule: rule.name,
         confidence: result.confidence,
@@ -30507,7 +30507,7 @@ function routeTask(signals, analyzer, logger54, _opts) {
       return buildDecision({ result, matchedRules, alternatives, analysis });
     }
   }
-  logger54.info("Using fallback pattern", { pattern: "graph", taskType: analysis.taskType });
+  logger55.info("Using fallback pattern", { pattern: "graph", taskType: analysis.taskType });
   const fallback = {
     pattern: "graph",
     reasoning: "No specific rule matched \u2014 using Graph DAG as the most general pattern",
@@ -30794,11 +30794,11 @@ function createMockTechLead() {
 var globalSicaConfig;
 var sicaEnabled = false;
 function initializeSica(options) {
-  const { sicaConfig, logger: logger54 } = options;
+  const { sicaConfig, logger: logger55 } = options;
   if (sicaConfig?.enabled !== true) {
     sicaEnabled = false;
     globalSicaConfig = void 0;
-    logger54.info("SICA self-improvement disabled by configuration");
+    logger55.info("SICA self-improvement disabled by configuration");
     return {
       enabled: false,
       reason: sicaConfig?.enabled === false ? "disabled in config" : "not enabled (opt-in feature)"
@@ -30806,7 +30806,7 @@ function initializeSica(options) {
   }
   sicaEnabled = true;
   globalSicaConfig = sicaConfig;
-  logger54.info("SICA self-improvement enabled", {
+  logger55.info("SICA self-improvement enabled", {
     improvementThreshold: sicaConfig.improvementThreshold,
     maxActiveVersions: sicaConfig.maxActiveVersions,
     cooldownMs: sicaConfig.improvementCooldownMs
@@ -30824,18 +30824,18 @@ function getSicaConfig() {
 }
 
 // src/mcp/tools/orchestrate-sica.ts
-function createOrchestratorWithSica(logger54, adapter) {
-  const orchestrator = new Orchestrator({ logger: logger54, ...adapter !== void 0 ? { adapter } : {} });
+function createOrchestratorWithSica(logger55, adapter) {
+  const orchestrator = new Orchestrator({ logger: logger55, ...adapter !== void 0 ? { adapter } : {} });
   if (!isSicaEnabled()) {
-    logger54.debug("SICA not enabled, using plain orchestrator");
+    logger55.debug("SICA not enabled, using plain orchestrator");
     return orchestrator;
   }
   const sicaConfig = getSicaConfig();
   if (sicaConfig === void 0) {
-    logger54.debug("SICA config unavailable, using plain orchestrator");
+    logger55.debug("SICA config unavailable, using plain orchestrator");
     return orchestrator;
   }
-  logger54.info("Creating SICA-wrapped orchestrator", {
+  logger55.info("Creating SICA-wrapped orchestrator", {
     improvementThreshold: sicaConfig.improvementThreshold,
     maxActiveVersions: sicaConfig.maxActiveVersions
   });
@@ -30855,9 +30855,9 @@ function createOrchestratorWithSica(logger54, adapter) {
       improvementCooldownMs: sicaConfig.improvementCooldownMs,
       enableObservability: sicaConfig.enableObservability
     },
-    logger: logger54
+    logger: logger55
   });
-  return createSicaOrchestratorAdapter(sicaAgent, logger54);
+  return createSicaOrchestratorAdapter(sicaAgent, logger55);
 }
 function createSicaOrchestratorAdapter(sicaAgent, _logger) {
   return {
@@ -30913,7 +30913,7 @@ var PersistedCatalogSchema = z62.object({
 function getCatalogPath() {
   return path4.join(os2.homedir(), CATALOG_DIR, CATALOG_FILE);
 }
-function loadPersistedCatalog(logger54) {
+function loadPersistedCatalog(logger55) {
   const filePath = getCatalogPath();
   try {
     if (!fs4.existsSync(filePath)) return [];
@@ -30921,21 +30921,21 @@ function loadPersistedCatalog(logger54) {
     const parsed = JSON.parse(content);
     const result = PersistedCatalogSchema.safeParse(parsed);
     if (!result.success) {
-      logger54.warn("Invalid pending catalog file, starting fresh", {
+      logger55.warn("Invalid pending catalog file, starting fresh", {
         errors: result.error.issues.map((i) => i.message)
       });
       return [];
     }
     return result.data.references;
   } catch (error) {
-    logger54.debug("Could not load pending catalog, starting fresh", {
+    logger55.debug("Could not load pending catalog, starting fresh", {
       error: getErrorMessage(error),
       filePath
     });
     return [];
   }
 }
-function savePersistedCatalog(references, logger54) {
+function savePersistedCatalog(references, logger55) {
   const dirPath = path4.join(os2.homedir(), CATALOG_DIR);
   const filePath = getCatalogPath();
   const tempPath = `${filePath}.tmp.${String(process.pid)}`;
@@ -30957,7 +30957,7 @@ function savePersistedCatalog(references, logger54) {
     } catch {
     }
     const message = getErrorMessage(error);
-    logger54.warn("Failed to persist pending catalog", { error: message });
+    logger55.warn("Failed to persist pending catalog", { error: message });
   }
 }
 var ARXIV_PATTERN = /\b(\d{4}\.\d{4,5})\b/g;
@@ -30967,8 +30967,8 @@ var ResearchAutoCatalog = class _ResearchAutoCatalog {
   pendingReferences = [];
   /** Maximum pending references to hold in memory. */
   static MAX_PENDING = 100;
-  constructor(logger54) {
-    this.logger = logger54 ?? createLogger({ component: "research-auto-catalog" });
+  constructor(logger55) {
+    this.logger = logger55 ?? createLogger({ component: "research-auto-catalog" });
     const persisted = loadPersistedCatalog(this.logger);
     if (persisted.length > 0) {
       this.pendingReferences.push(...persisted.slice(0, _ResearchAutoCatalog.MAX_PENDING));
@@ -31123,8 +31123,8 @@ var ResearchAutoCatalog = class _ResearchAutoCatalog {
   }
 };
 var autoCatalogInstance;
-function getAutoCatalog(logger54) {
-  autoCatalogInstance ??= new ResearchAutoCatalog(logger54);
+function getAutoCatalog(logger55) {
+  autoCatalogInstance ??= new ResearchAutoCatalog(logger55);
   return autoCatalogInstance;
 }
 
@@ -31314,10 +31314,15 @@ function assignDependencyAwareWaves(entries) {
       }
     }
   }
-  return entries.map((entry) => ({
-    ...entry,
-    wave: roleToWave.get(entry.role) ?? entry.wave
-  }));
+  return entries.map((entry) => {
+    const deps = EXPERT_DEPENDENCIES[entry.role];
+    const presentDeps = deps?.filter((d) => roleToWave.has(d)) ?? [];
+    return {
+      ...entry,
+      wave: roleToWave.get(entry.role) ?? entry.wave,
+      ...presentDeps.length > 0 ? { dependsOn: presentDeps } : {}
+    };
+  });
 }
 function mapHintToRole(hint) {
   const lower = hint.toLowerCase();
@@ -32896,12 +32901,12 @@ function computeExpertReliability() {
   }
   return reliability;
 }
-function computeAgentPlan(task, logger54) {
+function computeAgentPlan(task, logger55) {
   try {
     const analyzer = new SharedTaskAnalyzer();
     const analysis = analyzer.analyze(task);
     if (analysis.complexity === "simple") {
-      logger54.debug("Skipping AOrchestra planning for simple task", {
+      logger55.debug("Skipping AOrchestra planning for simple task", {
         taskType: analysis.taskType
       });
       return void 0;
@@ -32913,9 +32918,9 @@ function computeAgentPlan(task, logger54) {
       if (rate < 0.5) excludedExperts.push({ role, rate: Math.round(rate * 100) / 100 });
     }
     if (excludedExperts.length > 0) {
-      logger54.warn("Experts excluded by reliability filter", { excludedExperts });
+      logger55.warn("Experts excluded by reliability filter", { excludedExperts });
     }
-    logger54.info("AOrchestra plan", {
+    logger55.info("AOrchestra plan", {
       experts: plan.totalExperts,
       taskType: plan.taskType,
       complexity: plan.complexity,
@@ -32923,7 +32928,7 @@ function computeAgentPlan(task, logger54) {
     });
     return plan;
   } catch (planError) {
-    logger54.warn("AOrchestra planning failed", {
+    logger55.warn("AOrchestra planning failed", {
       error: getErrorMessage(planError)
     });
     return void 0;
@@ -32993,7 +32998,7 @@ async function executeOnAdapter(opts) {
   }
 }
 function createWorkerExecutor(config) {
-  const { taskDescription, modelAdapter, logger: logger54, learnings, perWorkerRouting } = config;
+  const { taskDescription, modelAdapter, logger: logger55, learnings, perWorkerRouting } = config;
   const effectiveFallbackCli = modelAdapter.providerId;
   return async (entry, priorWaveResults) => {
     const workerStartMs = getTimeProvider().now();
@@ -33002,7 +33007,7 @@ function createWorkerExecutor(config) {
       modelAdapter,
       effectiveFallbackCli,
       perWorkerRouting === true,
-      logger54
+      logger55
     );
     return executeOnAdapter({
       entry,
@@ -33176,15 +33181,15 @@ function prepareBudgetedEntries(plan, maxCalls, log3) {
   return entries;
 }
 async function executeWorkerDispatch(options) {
-  const { agentPlan, taskDescription, modelAdapter, logger: logger54, maxConcurrency } = options;
+  const { agentPlan, taskDescription, modelAdapter, logger: logger55, maxConcurrency } = options;
   const maxCalls = resolveMaxWorkerCalls(options.maxWorkerCalls);
   const startMs = getTimeProvider().now();
-  const entries = prepareBudgetedEntries(agentPlan, maxCalls, logger54);
+  const entries = prepareBudgetedEntries(agentPlan, maxCalls, logger55);
   const qualityGate = options.qualityGate === false ? void 0 : options.qualityGate;
   const executorConfig = {
     taskDescription,
     modelAdapter,
-    logger: logger54,
+    logger: logger55,
     ...options.learnings !== void 0 ? { learnings: options.learnings } : {},
     ...options.perWorkerRouting !== void 0 ? { perWorkerRouting: options.perWorkerRouting } : {}
   };
@@ -33205,8 +33210,8 @@ async function executeWorkerDispatch(options) {
   };
   await runSynthesisPhase(state, options, maxCalls);
   const refined = await runRefinementPhase(state, entries, options, maxCalls);
-  const base = buildDispatchResult(state.results, startMs, logger54, state.totalModelCalls);
-  logDispatchInsights(state.results, logger54);
+  const base = buildDispatchResult(state.results, startMs, logger55, state.totalModelCalls);
+  logDispatchInsights(state.results, logger55);
   return {
     ...base,
     ...refined ? { refined: true } : {},
@@ -33264,18 +33269,18 @@ function recordWorkerOutcomes(results, taskDescription) {
     });
   }
 }
-function buildDispatchResult(results, startMs, logger54, totalModelCalls) {
+function buildDispatchResult(results, startMs, logger55, totalModelCalls) {
   const successCount = results.filter((r) => r.status === "success").length;
   const errorCount = results.filter((r) => r.status === "error").length;
   const conflicts = detectConflicts(results);
   if (conflicts.length > 0) {
-    logger54.warn("Worker output conflicts detected \u2014 human review recommended", {
+    logger55.warn("Worker output conflicts detected \u2014 human review recommended", {
       conflictCount: conflicts.length,
       files: conflicts.map((c) => c.filePath)
     });
   }
   const durationMs = getTimeProvider().now() - startMs;
-  logger54.info("Worker dispatch complete", {
+  logger55.info("Worker dispatch complete", {
     totalWorkers: results.length,
     successCount,
     errorCount,
@@ -34343,11 +34348,11 @@ function buildOutputFromOrchestratorResult(taskId, orchResult, durationMs, routi
     }
   };
 }
-function createOrchestratorFromDeps(deps, logger54, orchestratorType) {
+function createOrchestratorFromDeps(deps, logger55, orchestratorType) {
   if (deps.orchestrator !== void 0) return deps.orchestrator;
-  const techLead = deps.techLead ?? createOrchestratorWithSica(logger54, deps.modelAdapter);
+  const techLead = deps.techLead ?? createOrchestratorWithSica(logger55, deps.modelAdapter);
   const factory = new OrchestratorFactory({
-    logger: logger54,
+    logger: logger55,
     techLead
   });
   return factory.create(orchestratorType ?? "tech_lead");
@@ -34461,16 +34466,16 @@ function recordOrchestrationError(errorMessage, taskDescription, durationMs) {
   }
 }
 function routeAndPrepare(input, deps, router) {
-  const logger54 = deps.logger ?? createLogger({ tool: "orchestrate" });
-  const workflowRouter = router ?? createWorkflowRouter({ logger: logger54 });
+  const logger55 = deps.logger ?? createLogger({ tool: "orchestrate" });
+  const workflowRouter = router ?? createWorkflowRouter({ logger: logger55 });
   const decision = workflowRouter.route({ description: input.task });
   const orchType = mapPatternToOrchestratorType(decision.pattern);
-  logger54.info("Workflow pattern selected", {
+  logger55.info("Workflow pattern selected", {
     pattern: decision.pattern,
     orchestratorType: orchType
   });
-  const orchestrator = createOrchestratorFromDeps(deps, logger54, orchType);
-  return { workflowRouter, decision, orchestrator, logger: logger54 };
+  const orchestrator = createOrchestratorFromDeps(deps, logger55, orchType);
+  return { workflowRouter, decision, orchestrator, logger: logger55 };
 }
 function buildRoutingInfo(decision) {
   return {
@@ -34489,10 +34494,10 @@ function recordRouterOutcome(workflowRouter, decision, success, durationMs) {
     timestamp: getTimeProvider().now()
   });
 }
-function handleOrchestrationException(error, taskId, task, logger54) {
+function handleOrchestrationException(error, taskId, task, logger55) {
   const message = error instanceof Error ? error.message : "Unknown error";
   const cause = error instanceof Error ? error : void 0;
-  logger54.error("Orchestration exception", cause, { taskId });
+  logger55.error("Orchestration exception", cause, { taskId });
   recordOrchestrationError(message, task);
   return err(
     new OrchestrationError(
@@ -34501,13 +34506,13 @@ function handleOrchestrationException(error, taskId, task, logger54) {
     )
   );
 }
-function startHeartbeatTracking(label, logger54) {
+function startHeartbeatTracking(label, logger55) {
   const monitor = getHeartbeatMonitor();
   const sessionId = monitor.startSession(label);
   const timer = setInterval(() => {
     monitor.heartbeat(sessionId);
     if (monitor.isStalled(sessionId)) {
-      logger54.warn("Orchestration session stalled", { label, sessionId });
+      logger55.warn("Orchestration session stalled", { label, sessionId });
     }
   }, HEARTBEAT_TIMEOUTS.heartbeatIntervalMs);
   return {
@@ -34579,7 +34584,7 @@ function handleOrchestratorSuccess(ctx) {
   return ok(output2);
 }
 async function executeOrchestration(input, deps, router) {
-  const { workflowRouter, decision, orchestrator, logger: logger54 } = routeAndPrepare(input, deps, router);
+  const { workflowRouter, decision, orchestrator, logger: logger55 } = routeAndPrepare(input, deps, router);
   const taskId = generateTaskId();
   const startTime = getTimeProvider().now();
   const fastResult = trySimpleTaskFastPath({
@@ -34588,15 +34593,15 @@ async function executeOrchestration(input, deps, router) {
     decision,
     workflowRouter,
     startTime,
-    logger: logger54
+    logger: logger55
   });
   if (fastResult !== void 0) return fastResult;
-  logger54.info("Starting orchestration", { taskId, taskLength: input.task.length });
-  recordTaskStateInit(taskId, input.task, logger54);
+  logger55.info("Starting orchestration", { taskId, taskLength: input.task.length });
+  recordTaskStateInit(taskId, input.task, logger55);
   const task = await createTaskFromInput(input, taskId);
   const definition = { type: "task", task };
-  const hb = startHeartbeatTracking(`orchestrate-${taskId}`, logger54);
-  const policy = await deriveOrchestratePolicy(input.task, deps, logger54);
+  const hb = startHeartbeatTracking(`orchestrate-${taskId}`, logger55);
+  const policy = await deriveOrchestratePolicy(input.task, deps, logger55);
   try {
     return await runOrchestratorWithStateTracking({
       taskId,
@@ -34607,23 +34612,23 @@ async function executeOrchestration(input, deps, router) {
       decision,
       workflowRouter,
       startTime,
-      logger: logger54
+      logger: logger55
     });
   } catch (error) {
-    recordTaskStateBlocker(taskId, error instanceof Error ? error.message : String(error), logger54);
-    recordTaskStateStage(taskId, "blocked", logger54);
-    return handleOrchestrationException(error, taskId, input.task, logger54);
+    recordTaskStateBlocker(taskId, error instanceof Error ? error.message : String(error), logger55);
+    recordTaskStateStage(taskId, "blocked", logger55);
+    return handleOrchestrationException(error, taskId, input.task, logger55);
   } finally {
     hb.cleanup();
   }
 }
 async function runOrchestratorWithStateTracking(params) {
-  const { taskId, taskInput, definition, orchestrator, policy, logger: logger54 } = params;
-  recordTaskStateStage(taskId, "executing", logger54);
+  const { taskId, taskInput, definition, orchestrator, policy, logger: logger55 } = params;
+  recordTaskStateStage(taskId, "executing", logger55);
   const result = await withAccessPolicy(policy, () => orchestrator.execute(definition, {}));
   if (!result.ok) {
-    recordTaskStateBlocker(taskId, result.error.message, logger54);
-    recordTaskStateStage(taskId, "blocked", logger54);
+    recordTaskStateBlocker(taskId, result.error.message, logger55);
+    recordTaskStateStage(taskId, "blocked", logger55);
     return handleOrchestratorFailure({
       error: result.error,
       taskId,
@@ -34631,10 +34636,10 @@ async function runOrchestratorWithStateTracking(params) {
       decision: params.decision,
       workflowRouter: params.workflowRouter,
       startTime: params.startTime,
-      logger: logger54
+      logger: logger55
     });
   }
-  recordTaskStateStage(taskId, "complete", logger54);
+  recordTaskStateStage(taskId, "complete", logger55);
   return handleOrchestratorSuccess({
     orchResult: result.value,
     taskId,
@@ -34642,13 +34647,13 @@ async function runOrchestratorWithStateTracking(params) {
     decision: params.decision,
     workflowRouter: params.workflowRouter,
     startTime: params.startTime,
-    logger: logger54
+    logger: logger55
   });
 }
 function isTaskStateEnabled() {
   return process.env["NEXUS_TASK_STATE_ENABLED"] === "1";
 }
-function recordTaskStateInit(taskId, taskText, logger54) {
+function recordTaskStateInit(taskId, taskText, logger55) {
   if (!isTaskStateEnabled()) return;
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const initial = {
@@ -34661,36 +34666,36 @@ function recordTaskStateInit(taskId, taskText, logger54) {
   };
   const result = initTaskState(initial);
   if (!result.ok) {
-    logger54.warn("task-state: init failed, continuing", {
+    logger55.warn("task-state: init failed, continuing", {
       taskId,
       error: result.error.message,
       taskLength: taskText.length
     });
   }
 }
-function recordTaskStateStage(taskId, stage, logger54) {
+function recordTaskStateStage(taskId, stage, logger55) {
   if (!isTaskStateEnabled()) return;
   const result = updateStage(taskId, stage, (/* @__PURE__ */ new Date()).toISOString());
   if (!result.ok) {
-    logger54.warn("task-state: stage update failed", {
+    logger55.warn("task-state: stage update failed", {
       taskId,
       stage,
       error: result.error.message
     });
   }
 }
-function recordTaskStateBlocker(taskId, blocker, logger54) {
+function recordTaskStateBlocker(taskId, blocker, logger55) {
   if (!isTaskStateEnabled()) return;
   const ts = (/* @__PURE__ */ new Date()).toISOString();
   const result = appendBlocker(taskId, { ts, blocker });
   if (!result.ok) {
-    logger54.warn("task-state: blocker record failed", {
+    logger55.warn("task-state: blocker record failed", {
       taskId,
       error: result.error.message
     });
   }
 }
-async function deriveOrchestratePolicy(taskText, deps, logger54) {
+async function deriveOrchestratePolicy(taskText, deps, logger55) {
   const mode = resolveAccessPolicyMode();
   try {
     const opts = {
@@ -34700,7 +34705,7 @@ async function deriveOrchestratePolicy(taskText, deps, logger54) {
     };
     const policy = await deriveAccessPolicy(taskText, opts);
     if (mode !== "off") {
-      logger54.info("access-policy: derived", {
+      logger55.info("access-policy: derived", {
         mode,
         source: policy.source,
         allowedToolsWildcard: policy.allowedTools === "*"
@@ -34708,7 +34713,7 @@ async function deriveOrchestratePolicy(taskText, deps, logger54) {
     }
     return policy;
   } catch (error) {
-    logger54.warn("access-policy: derivation failed, falling back to off", {
+    logger55.warn("access-policy: derivation failed, falling back to off", {
       error: getErrorMessage(error)
     });
     return {
@@ -34722,15 +34727,15 @@ async function deriveOrchestratePolicy(taskText, deps, logger54) {
     };
   }
 }
-function instrumentV2Orchestrate(input, logger54) {
+function instrumentV2Orchestrate(input, logger55) {
   const tc = orchestrateInputToTaskContract(input);
   void executeOrchestratePipeline(tc).then((m) => {
-    logger54.info("V2 orchestrate pipeline", { ...m });
+    logger55.info("V2 orchestrate pipeline", { ...m });
   }).catch((error) => {
-    logger54.debug("V2 orchestrate pipeline failed", { error: getErrorMessage(error) });
+    logger55.debug("V2 orchestrate pipeline failed", { error: getErrorMessage(error) });
   });
 }
-async function tryWorkerDispatch(agentPlan, task, deps, logger54, notifier) {
+async function tryWorkerDispatch(agentPlan, task, deps, logger55, notifier) {
   const adapter = deps.modelAdapter;
   if (agentPlan === void 0 || !isWorkerDispatchEnabled() || adapter === void 0) {
     return void 0;
@@ -34743,14 +34748,14 @@ async function tryWorkerDispatch(agentPlan, task, deps, logger54, notifier) {
         agentPlan,
         taskDescription: task,
         modelAdapter: adapter,
-        logger: logger54,
+        logger: logger55,
         synthesize: true,
         refine: true,
         perWorkerRouting: true
       })
     );
   } catch (dispatchError) {
-    logger54.warn("Worker dispatch failed, continuing with standard orchestration", {
+    logger55.warn("Worker dispatch failed, continuing with standard orchestration", {
       error: dispatchError instanceof Error ? dispatchError.message : String(dispatchError)
     });
     return void 0;
@@ -34823,7 +34828,7 @@ function createOrchestrateHandler(deps) {
   };
 }
 function registerOrchestrateTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "orchestrate" });
+  const logger55 = deps.logger ?? createLogger({ tool: "orchestrate" });
   const notifier = deps.notifier ?? createMcpNotifier(server);
   const depsWithNotifier = { ...deps, notifier };
   const description = "Orchestrate a task by analyzing it, breaking it into subtasks if needed, and coordinating expert agents";
@@ -34831,18 +34836,18 @@ function registerOrchestrateTool(server, deps) {
     toolName: "orchestrate",
     securityTier: "user-facing",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const wrappedHandler = wrapToolWithTimeout("orchestrate", secureHandler, {
     timeoutMs: MCP_TIMEOUTS.perTool["orchestrate"] ?? MCP_TIMEOUTS.defaultMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "orchestrate",
     { description, inputSchema: ORCHESTRATE_TOOL_SCHEMA },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered orchestrate tool with secure handler and timeout protection");
+  logger55.info("Registered orchestrate tool with secure handler and timeout protection");
 }
 
 // src/mcp/tools/delegate-to-model-types.ts
@@ -35185,21 +35190,21 @@ function mapCompositeDecisionToOutput(decision, estimatedTokens) {
     }))
   };
 }
-async function routeViaCompositeRouter(task, router, feedbackIntegration, logger54) {
+async function routeViaCompositeRouter(task, router, feedbackIntegration, logger55) {
   const result = await router.route({ content: task });
   if (!result.ok) {
-    logger54.warn("CompositeRouter routing failed", { error: result.error.message });
+    logger55.warn("CompositeRouter routing failed", { error: result.error.message });
     return null;
   }
   const decision = result.value;
   let routingId;
   if (feedbackIntegration) {
     routingId = feedbackIntegration.recordRoutingDecision(decision);
-    logger54.debug("Recorded routing decision", { routingId, cliName: decision.cliName });
+    logger55.debug("Recorded routing decision", { routingId, cliName: decision.cliName });
   }
   return { decision, routingId, feedbackIntegration };
 }
-function recordRoutingOutcome(result, durationMs, logger54) {
+function recordRoutingOutcome(result, durationMs, logger55) {
   if (result.routingId === void 0 || result.feedbackIntegration === void 0) return;
   try {
     const topsisScore = result.decision.topsisScore ?? 0;
@@ -35212,13 +35217,13 @@ function recordRoutingOutcome(result, durationMs, logger54) {
       tokenUsage: 0
       // delegate-to-model is a recommendation, not execution
     });
-    logger54.debug("Recorded routing outcome", {
+    logger55.debug("Recorded routing outcome", {
       routingId: result.routingId,
       topsisScore,
       success: topsisScore >= TOPSIS_CONFIDENCE_THRESHOLD
     });
   } catch (error) {
-    logger54.warn("Failed to record routing outcome", { error: getErrorMessage(error) });
+    logger55.warn("Failed to record routing outcome", { error: getErrorMessage(error) });
   }
 }
 
@@ -35239,9 +35244,9 @@ function classifyWithGovernance(toolName, params, overrides) {
   const promotionReason = promoted ? buildPromotionReason(domain, params) : null;
   return { tier, promoted, domain, votingThreshold, promotionReason };
 }
-function auditGovernancePromotion(classification, toolName, logger54) {
+function auditGovernancePromotion(classification, toolName, logger55) {
   if (!classification.promoted) return;
-  const log3 = logger54 ?? createLogger({ component: "governance" });
+  const log3 = logger55 ?? createLogger({ component: "governance" });
   log3.warn("Governance promotion", {
     tool: toolName,
     domain: classification.domain,
@@ -35340,9 +35345,9 @@ function recordToOutcomeStore2(task, model, startMs, governance) {
     });
   }
 }
-function classifyDelegateGovernance(input, logger54) {
+function classifyDelegateGovernance(input, logger55) {
   const classification = classifyWithGovernance("delegate_to_model", { task: input.task });
-  auditGovernancePromotion(classification, "delegate_to_model", logger54);
+  auditGovernancePromotion(classification, "delegate_to_model", logger55);
   return classification;
 }
 function enrichWithGovernance(output2, governance) {
@@ -35356,10 +35361,10 @@ function enrichWithGovernance(output2, governance) {
     }
   };
 }
-function instrumentV2Pipeline(input, logger54) {
+function instrumentV2Pipeline(input, logger55) {
   const tc = delegateInputToTaskContract(input);
   void executeDelegatePipeline(tc).then((m) => {
-    logger54.info("V2 delegate pipeline", { ...m });
+    logger55.info("V2 delegate pipeline", { ...m });
   });
 }
 function notifyAndRecord(opts) {
@@ -35433,18 +35438,18 @@ function createDelegateHandler(deps) {
   };
 }
 function registerDelegateToModelTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "delegate_to_model" });
+  const logger55 = deps.logger ?? createLogger({ tool: "delegate_to_model" });
   const notifier = deps.notifier ?? createMcpNotifier(server);
   const depsWithNotifier = { ...deps, notifier };
   const secureHandler = createSecureHandler(createDelegateHandler(depsWithNotifier), {
     toolName: "delegate_to_model",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("delegate_to_model", deps.security);
   const wrappedHandler = wrapToolWithTimeout("delegate_to_model", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "delegate_to_model",
@@ -35455,7 +35460,7 @@ function registerDelegateToModelTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered delegate_to_model tool with secure handler and timeout protection");
+  logger55.info("Registered delegate_to_model tool with secure handler and timeout protection");
 }
 
 // src/mcp/tools/run-graph-workflow-multicli-templates.ts
@@ -36394,7 +36399,7 @@ function listExpertsHandler(args, ctx) {
   return Promise.resolve(toolSuccessStructured(data));
 }
 function registerListExpertsTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "list_experts" });
+  const logger55 = deps.logger ?? createLogger({ tool: "list_experts" });
   const toolSchema = {
     format: z68.enum(["full", "names"]).optional().describe("Output format: full (with details) or names (just role names)")
   };
@@ -36402,10 +36407,10 @@ function registerListExpertsTool(server, deps) {
   const secureHandler = createSecureHandler(listExpertsHandler, {
     toolName: "list_experts",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("list_experts", deps.security);
-  const wrappedHandler = wrapToolWithTimeout("list_experts", secureHandler, { timeoutMs, logger: logger54 });
+  const wrappedHandler = wrapToolWithTimeout("list_experts", secureHandler, { timeoutMs, logger: logger55 });
   const outputSchema = {
     experts: z68.array(
       z68.object({
@@ -36422,7 +36427,7 @@ function registerListExpertsTool(server, deps) {
     { description, inputSchema: toolSchema, outputSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered list_experts tool with secure handler and timeout protection");
+  logger55.info("Registered list_experts tool with secure handler and timeout protection");
 }
 
 // src/mcp/tools/list-workflows.ts
@@ -36478,7 +36483,7 @@ function createListWorkflowsHandler(workflowEngine) {
   };
 }
 function registerListWorkflowsTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "list_workflows" });
+  const logger55 = deps.logger ?? createLogger({ tool: "list_workflows" });
   const toolSchema = {
     category: z69.string().optional().describe("Filter by category (e.g., development, security)"),
     format: z69.enum(["full", "names"]).optional().describe("Output format: full (with details) or names (just template names)")
@@ -36487,13 +36492,13 @@ function registerListWorkflowsTool(server, deps) {
   const secureHandler = createSecureHandler(createListWorkflowsHandler(deps.workflowEngine), {
     toolName: "list_workflows",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = deps.security?.timeout?.defaultTimeoutMs;
   const wrappedHandler = wrapToolWithTimeout(
     "list_workflows",
     secureHandler,
-    timeoutMs !== void 0 ? { timeoutMs, logger: logger54 } : { logger: logger54 }
+    timeoutMs !== void 0 ? { timeoutMs, logger: logger55 } : { logger: logger55 }
   );
   const outputSchema = {
     workflows: z69.array(
@@ -36512,7 +36517,7 @@ function registerListWorkflowsTool(server, deps) {
     { description, inputSchema: toolSchema, outputSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered list_workflows tool with secure handler and timeout protection");
+  logger55.info("Registered list_workflows tool with secure handler and timeout protection");
 }
 
 // src/mcp/tools/execute-expert.ts
@@ -36596,12 +36601,12 @@ function recordExpertError2(expertId, role, errorMessage) {
     });
   }
 }
-function autoCatalogScan(output2, expertId, logger54) {
+function autoCatalogScan(output2, expertId, logger55) {
   try {
     const catalog = getAutoCatalog();
     catalog.scanAndRecord(output2, "execute_expert");
   } catch (error) {
-    logger54?.debug("Best-effort auto-catalog scan failed", {
+    logger55?.debug("Best-effort auto-catalog scan failed", {
       error: getErrorMessage(error),
       expertId
     });
@@ -36659,11 +36664,11 @@ function computeExpertContextUtilization(observation, threshold = DEFAULT_CONTEX
     threshold
   };
 }
-function observeExpertContext(observation, logger54, threshold = resolveContextWarnThreshold()) {
+function observeExpertContext(observation, logger55, threshold = resolveContextWarnThreshold()) {
   try {
     const util = computeExpertContextUtilization(observation, threshold);
     if (util.warned) {
-      logger54?.warn("context_warning", {
+      logger55?.warn("context_warning", {
         event: "context_warning",
         expertId: observation.expertId,
         role: observation.role,
@@ -36676,7 +36681,7 @@ function observeExpertContext(observation, logger54, threshold = resolveContextW
         taskLength: observation.taskDescription.length
       });
     } else {
-      logger54?.debug("context_utilization", {
+      logger55?.debug("context_utilization", {
         event: "context_utilization",
         expertId: observation.expertId,
         role: observation.role,
@@ -36764,7 +36769,7 @@ function buildSuccessResponse(params) {
   }
   return response;
 }
-function observeExpertContextIfOk(result, expert, task, durationMs, logger54) {
+function observeExpertContextIfOk(result, expert, task, durationMs, logger55) {
   if (!result.ok) return;
   const expertModelId = expert.expertConfig.modelPreference?.modelId;
   const observation = {
@@ -36775,9 +36780,9 @@ function observeExpertContextIfOk(result, expert, task, durationMs, logger54) {
     taskDescription: task.description,
     durationMs
   };
-  observeExpertContext(observation, logger54);
+  observeExpertContext(observation, logger55);
 }
-async function deriveExpertAccessPolicy(task, logger54) {
+async function deriveExpertAccessPolicy(task, logger55) {
   const mode = resolveAccessPolicyMode();
   try {
     const policy = await deriveAccessPolicy(task.description, {
@@ -36785,14 +36790,14 @@ async function deriveExpertAccessPolicy(task, logger54) {
       trustTier: "1"
     });
     if (mode !== "off") {
-      logger54?.info("access-policy: derived (expert)", {
+      logger55?.info("access-policy: derived (expert)", {
         mode,
         source: policy.source
       });
     }
     return policy;
   } catch (error) {
-    logger54?.warn("access-policy: derivation failed, falling back to off (expert)", {
+    logger55?.warn("access-policy: derivation failed, falling back to off (expert)", {
       error: getErrorMessage(error)
     });
     return {
@@ -36838,11 +36843,11 @@ function isExpertDegraded(role) {
   }
   return consecutive >= DEGRADATION_CONSECUTIVE_THRESHOLD;
 }
-async function tryExpertFallback(expert, task, logger54) {
+async function tryExpertFallback(expert, task, logger55) {
   const roleKey = `${expert.role}_expert`;
   const category = ROLE_TO_TASK_CATEGORY[roleKey];
   if (category === void 0) return void 0;
-  const effectiveLogger = logger54 ?? createLogger({ tool: "execute_expert" });
+  const effectiveLogger = logger55 ?? createLogger({ tool: "execute_expert" });
   const registry = getGlobalRegistry({ logger: effectiveLogger });
   const routing = registry.getRouting(category);
   const primaryCli = routing?.primaryCli ?? "unknown";
@@ -36851,7 +36856,7 @@ async function tryExpertFallback(expert, task, logger54) {
   const fallbackCli = chain[0];
   if (fallbackCli === void 0) return void 0;
   const fallbackAdapter = registry.getAdapterForCli(fallbackCli);
-  logger54?.info("Retrying expert with fallback CLI", { role: expert.role, fallbackCli });
+  logger55?.info("Retrying expert with fallback CLI", { role: expert.role, fallbackCli });
   const fallbackResult = createExpert(expert.expertConfig, { adapter: fallbackAdapter });
   if (!fallbackResult.ok) return void 0;
   const result = await fallbackResult.value.execute(task);
@@ -36869,7 +36874,7 @@ async function tryExpertFallback(expert, task, logger54) {
   };
 }
 async function classifyExpertResult(opts) {
-  const { result, expert, task, args, durationMs, logger: logger54 } = opts;
+  const { result, expert, task, args, durationMs, logger: logger55 } = opts;
   const modelId = expert.expertConfig.modelPreference?.modelId;
   const info = {
     expertId: args.expertId,
@@ -36878,19 +36883,19 @@ async function classifyExpertResult(opts) {
   };
   if (!result.ok) {
     if (isRateLimitFailure(result.error.message)) {
-      const fallback = await tryExpertFallback(expert, task, logger54);
+      const fallback = await tryExpertFallback(expert, task, logger55);
       if (fallback !== void 0) return fallback;
     }
-    logger54?.warn("Expert execution failed", {
+    logger55?.warn("Expert execution failed", {
       expertId: args.expertId,
       error: result.error.message
     });
     return handleExpertFailure(args.task, info, result.error.message, durationMs);
   }
-  logger54?.info("Expert execution completed", { expertId: args.expertId, durationMs });
+  logger55?.info("Expert execution completed", { expertId: args.expertId, durationMs });
   handleExpertSuccess(args.task, info, durationMs);
   if (typeof result.value.output === "string") {
-    autoCatalogScan(result.value.output, args.expertId, logger54);
+    autoCatalogScan(result.value.output, args.expertId, logger55);
   }
   return {
     ok: true,
@@ -36978,7 +36983,7 @@ var EXECUTE_EXPERT_TOOL_SCHEMA = {
   context: z70.record(z70.string(), z70.unknown()).optional().describe("Additional context metadata for the task"),
   timeoutMs: z70.number().int().min(EXPERT_TIMEOUT_FLOOR_MS).max(9e5).optional().describe("Optional timeout in ms (120s-900s). Overrides auto-detected timeout.")
 };
-function createTaskHandler(deps, logger54) {
+function createTaskHandler(deps, logger55) {
   const notifier = deps.notifier ?? NOOP_NOTIFIER;
   return {
     createTask: (args, extra) => {
@@ -36990,7 +36995,7 @@ function createTaskHandler(deps, logger54) {
       const { taskStore } = extra;
       const ttl = clampTaskTtl(DEFAULT_TASK_TTL_MS);
       const taskPromise = taskStore.createTask({ ttl, pollInterval: 5e3 }).then((task) => {
-        logger54.info("Task created for execute_expert", {
+        logger55.info("Task created for execute_expert", {
           taskId: task.taskId,
           expertId: validatedArgs.expertId
         });
@@ -37015,7 +37020,7 @@ function createTaskHandler(deps, logger54) {
 }
 async function runBackgroundExpertTask(opts) {
   const { deps, args, taskId, taskStore, notifier } = opts;
-  const logger54 = deps.logger ?? createLogger({ tool: "execute_expert" });
+  const logger55 = deps.logger ?? createLogger({ tool: "execute_expert" });
   try {
     notifier.info("execute_expert", {
       event: "expert_start",
@@ -37045,13 +37050,13 @@ async function runBackgroundExpertTask(opts) {
     });
   } catch (error) {
     const message = getErrorMessage(error);
-    logger54.warn("Background expert task failed", { taskId, error: message });
+    logger55.warn("Background expert task failed", { taskId, error: message });
     try {
       await taskStore.storeTaskResult(taskId, "failed", {
         ...toolError(`Expert execution error: ${message}`)
       });
     } catch (storeError) {
-      logger54.warn("Failed to store task failure result", {
+      logger55.warn("Failed to store task failure result", {
         taskId,
         error: getErrorMessage(storeError)
       });
@@ -37059,7 +37064,7 @@ async function runBackgroundExpertTask(opts) {
   }
 }
 function registerExecuteExpertTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "execute_expert" });
+  const logger55 = deps.logger ?? createLogger({ tool: "execute_expert" });
   const notifier = deps.notifier ?? createMcpNotifier(server);
   const depsWithNotifier = { ...deps, notifier };
   const description = "Execute a task using a previously created expert agent. Returns the expert analysis including output, confidence, and token usage.";
@@ -37070,9 +37075,9 @@ function registerExecuteExpertTool(server, deps) {
       inputSchema: EXECUTE_EXPERT_TOOL_SCHEMA,
       execution: { taskSupport: "optional" }
     },
-    createTaskHandler(depsWithNotifier, logger54)
+    createTaskHandler(depsWithNotifier, logger55)
   );
-  logger54.info("Registered execute_expert tool with MCP Tasks support (taskSupport: optional)");
+  logger55.info("Registered execute_expert tool with MCP Tasks support (taskSupport: optional)");
 }
 
 // src/mcp/tools/research-query.ts
@@ -38416,15 +38421,15 @@ function createResearchQueryHandler(deps) {
       return toolError(`Validation error: ${formatZodError(validationResult.error)}`);
     }
     ctx.logger.debug("Executing research query", { action: validationResult.data.action });
-    const logger54 = deps.logger ?? createLogger({ tool: "research_query" });
-    return withToolError("Research query failed", logger54, async () => {
+    const logger55 = deps.logger ?? createLogger({ tool: "research_query" });
+    return withToolError("Research query failed", logger55, async () => {
       const result = await executeQuery(validationResult.data);
       return toolSuccess(JSON.stringify(result, null, 2));
     });
   };
 }
 function registerResearchQueryTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "research_query" });
+  const logger55 = deps.logger ?? createLogger({ tool: "research_query" });
   const toolSchema = {
     action: z73.enum(["status", "overlap", "stats", "search"]).describe("Query action: status, overlap, stats, or search"),
     techniqueId: z73.string().optional().describe("Technique ID for status/overlap queries"),
@@ -38436,19 +38441,19 @@ function registerResearchQueryTool(server, deps) {
   const secureHandler = createSecureHandler(createResearchQueryHandler(deps), {
     toolName: "research_query",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("research_query", deps.security);
   const wrappedHandler = wrapToolWithTimeout("research_query", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "research_query",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered research_query tool with secure handler and timeout protection");
+  logger55.info("Registered research_query tool with secure handler and timeout protection");
 }
 
 // src/mcp/tools/research-add.ts
@@ -38459,7 +38464,7 @@ var ResearchAddInputSchema = z74.object({
   priority: z74.enum(["P1", "P2", "P3", "P4"]).optional().describe("Priority level for the paper"),
   dryRun: z74.boolean().optional().default(false).describe("Preview what would be added without persisting")
 });
-async function executeResearchAdd(input, logger54) {
+async function executeResearchAdd(input, logger55) {
   const exists = await paperExists(input.arxivId);
   if (exists) {
     return {
@@ -38478,7 +38483,7 @@ async function executeResearchAdd(input, logger54) {
   });
   if (result.success && !input.dryRun) {
     try {
-      const memory = getToolMemory(logger54);
+      const memory = getToolMemory(logger55);
       memory.recordLearning({
         pattern: `Added paper: ${result.title} (${result.paperId})`,
         context: `topic=${input.topic ?? "general"}, priority=${input.priority ?? "unset"}`,
@@ -38486,7 +38491,7 @@ async function executeResearchAdd(input, logger54) {
         source: "research_add"
       });
     } catch {
-      logger54.debug("Failed to record learning in session memory");
+      logger55.debug("Failed to record learning in session memory");
     }
   }
   const qualityNote = result.success && !input.dryRun ? " [evidence_tier=low \u2014 arXiv preprint, no citation data yet. Run backfill-research-quality.ts to enrich.]" : "";
@@ -38505,9 +38510,9 @@ function createResearchAddHandler(deps) {
       return toolError(`Validation error: ${formatZodError(validationResult.error)}`);
     }
     ctx.logger.debug("Adding research paper", { arxivId: validationResult.data.arxivId });
-    const logger54 = deps.logger ?? createLogger({ tool: "research_add" });
-    return withToolError("Failed to add paper", logger54, async () => {
-      const result = await executeResearchAdd(validationResult.data, logger54);
+    const logger55 = deps.logger ?? createLogger({ tool: "research_add" });
+    return withToolError("Failed to add paper", logger55, async () => {
+      const result = await executeResearchAdd(validationResult.data, logger55);
       if (!result.success) {
         return toolError(result.message);
       }
@@ -38516,7 +38521,7 @@ function createResearchAddHandler(deps) {
   };
 }
 function registerResearchAddTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "research_add" });
+  const logger55 = deps.logger ?? createLogger({ tool: "research_add" });
   const toolSchema = {
     arxivId: z74.string().regex(/^\d{4}\.\d{4,5}$/).describe('arXiv paper ID (e.g., "2401.12345")'),
     topic: z74.string().optional().describe("Research topic to categorize the paper under"),
@@ -38527,19 +38532,19 @@ function registerResearchAddTool(server, deps) {
   const secureHandler = createSecureHandler(createResearchAddHandler(deps), {
     toolName: "research_add",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("research_add", deps.security);
   const wrappedHandler = wrapToolWithTimeout("research_add", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "research_add",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered research_add tool with secure handler and timeout protection");
+  logger55.info("Registered research_add tool with secure handler and timeout protection");
 }
 
 // src/mcp/tools/research-add-source.ts
@@ -38616,9 +38621,9 @@ function buildResponse2(params) {
     dryRun: params.dryRun
   };
 }
-function recordAddSourceLearning(logger54, name, sourceId, type, qualityScore) {
+function recordAddSourceLearning(logger55, name, sourceId, type, qualityScore) {
   try {
-    const memory = getToolMemory(logger54);
+    const memory = getToolMemory(logger55);
     memory.recordLearning({
       pattern: `Added source: ${name} (${sourceId})`,
       context: `type=${type}, quality=${String(qualityScore)}`,
@@ -38626,7 +38631,7 @@ function recordAddSourceLearning(logger54, name, sourceId, type, qualityScore) {
       source: "research_add_source"
     });
   } catch {
-    logger54.debug("Failed to record learning in session memory");
+    logger55.debug("Failed to record learning in session memory");
   }
 }
 function prepareSource(input) {
@@ -38634,7 +38639,7 @@ function prepareSource(input) {
   const score = computeSourceQualityScore(entry);
   return { entry, score };
 }
-async function executeResearchAddSource(input, logger54) {
+async function executeResearchAddSource(input, logger55) {
   const sourceId = generateSourceId(input.url);
   const exists = await sourceExistsInRegistry(input.url);
   if (exists) {
@@ -38669,8 +38674,8 @@ async function executeResearchAddSource(input, logger54) {
       dryRun: false
     });
   }
-  recordAddSourceLearning(logger54, input.name, sourceId, input.type, score);
-  logger54.info("Added research source", { sourceId, name: input.name, qualityScore: score });
+  recordAddSourceLearning(logger55, input.name, sourceId, input.type, score);
+  logger55.info("Added research source", { sourceId, name: input.name, qualityScore: score });
   return buildResponse2({
     success: true,
     sourceId,
@@ -38687,9 +38692,9 @@ function createResearchAddSourceHandler(deps) {
       return toolError(`Validation error: ${formatZodError(validationResult.error)}`);
     }
     ctx.logger.debug("Adding research source", { url: validationResult.data.url });
-    const logger54 = deps.logger ?? createLogger({ tool: "research_add_source" });
-    return withToolError("Failed to add source", logger54, async () => {
-      const result = await executeResearchAddSource(validationResult.data, logger54);
+    const logger55 = deps.logger ?? createLogger({ tool: "research_add_source" });
+    return withToolError("Failed to add source", logger55, async () => {
+      const result = await executeResearchAddSource(validationResult.data, logger55);
       if (!result.success) {
         return toolError(result.message);
       }
@@ -38698,7 +38703,7 @@ function createResearchAddSourceHandler(deps) {
   };
 }
 function registerResearchAddSourceTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "research_add_source" });
+  const logger55 = deps.logger ?? createLogger({ tool: "research_add_source" });
   const toolSchema = {
     url: z75.string().min(1).describe("Source URL"),
     name: z75.string().min(1).describe("Display name"),
@@ -38723,12 +38728,12 @@ function registerResearchAddSourceTool(server, deps) {
     toolName: "research_add_source",
     securityTier: "external",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("research_add_source", deps.security);
   const wrappedHandler = wrapToolWithTimeout("research_add_source", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "research_add_source",
@@ -38781,7 +38786,7 @@ function toDiscoveredItems(sources) {
     discoveredAt: s.discoveredAt
   }));
 }
-async function discoverFromExtendedSource(source, topic, maxResults, logger54, sinceDate) {
+async function discoverFromExtendedSource(source, topic, maxResults, logger55, sinceDate) {
   let result;
   switch (source) {
     case "google_ai":
@@ -38809,7 +38814,7 @@ async function discoverFromExtendedSource(source, topic, maxResults, logger54, s
       return { items: [], failed: true };
   }
   if (!result.ok) {
-    logger54.warn(`${source} discovery failed`, {
+    logger55.warn(`${source} discovery failed`, {
       source,
       errorCode: result.error.code,
       error: result.error.message
@@ -38849,24 +38854,24 @@ function markExistingItems(items, existingIds) {
 }
 var ARXIV_ORG_SOURCES = /* @__PURE__ */ new Set(["google_ai", "meta_fair", "microsoft", "deepmind"]);
 var INDEPENDENT_SOURCES = ["semantic_scholar", "papers_with_code", "openalex"];
-async function queryExtendedSource(src, input, logger54, acc) {
+async function queryExtendedSource(src, input, logger55, acc) {
   acc.sources.push(src);
   try {
     const result = await discoverFromExtendedSource(
       src,
       input.topic,
       input.maxResults,
-      logger54,
+      logger55,
       input.sinceDate
     );
     if (result.failed) acc.failedSources.push(src);
     acc.items = acc.items.concat(result.items);
   } catch (error) {
     acc.failedSources.push(src);
-    logger54.warn("Source discovery failed", { source: src, error: getErrorMessage(error) });
+    logger55.warn("Source discovery failed", { source: src, error: getErrorMessage(error) });
   }
 }
-async function queryAllSources(input, logger54) {
+async function queryAllSources(input, logger55) {
   const acc = { sources: [], failedSources: [], items: [] };
   const isAll = input.source === "all";
   const shouldQuery = (src) => isAll || input.source === src;
@@ -38876,11 +38881,11 @@ async function queryAllSources(input, logger54) {
     if (r.ok) acc.items = acc.items.concat(toDiscoveredItems(r.value));
     else {
       acc.failedSources.push("arxiv");
-      logger54.warn("arxiv discovery failed", { error: r.error.message });
+      logger55.warn("arxiv discovery failed", { error: r.error.message });
     }
   }
   for (const src of ARXIV_ORG_SOURCES) {
-    if (!isAll && input.source === src) await queryExtendedSource(src, input, logger54, acc);
+    if (!isAll && input.source === src) await queryExtendedSource(src, input, logger55, acc);
   }
   if (shouldQuery("github")) {
     acc.sources.push("github");
@@ -38888,15 +38893,15 @@ async function queryAllSources(input, logger54) {
     if (r.ok) acc.items = acc.items.concat(toDiscoveredItems(r.value));
     else {
       acc.failedSources.push("github");
-      logger54.warn("github discovery failed", { error: r.error.message });
+      logger55.warn("github discovery failed", { error: r.error.message });
     }
   }
   for (const src of INDEPENDENT_SOURCES) {
-    if (shouldQuery(src)) await queryExtendedSource(src, input, logger54, acc);
+    if (shouldQuery(src)) await queryExtendedSource(src, input, logger55, acc);
   }
   return acc;
 }
-async function executeDiscovery(rawInput, logger54) {
+async function executeDiscovery(rawInput, logger55) {
   const input = {
     ...rawInput,
     topic: normalizeTopicToCanonical(rawInput.topic)
@@ -38906,7 +38911,7 @@ async function executeDiscovery(rawInput, logger54) {
     sources: sourcesToQuery,
     failedSources,
     items: allItems
-  } = await queryAllSources(input, logger54);
+  } = await queryAllSources(input, logger55);
   markExistingItems(allItems, existingIds);
   const totalFound = allItems.length;
   const inRegistry = allItems.filter((i) => i.alreadyInRegistry).length;
@@ -38918,7 +38923,7 @@ async function executeDiscovery(rawInput, logger54) {
   ).slice(0, input.maxResults);
   const filteredOut = totalFound - inRegistry - relevantItems.length;
   if (filteredOut > 0) {
-    logger54.debug("Filtered out irrelevant results", {
+    logger55.debug("Filtered out irrelevant results", {
       threshold,
       filteredOut,
       remaining: relevantItems.length
@@ -38998,10 +39003,10 @@ function createResearchDiscoverHandler(deps) {
       topic: validationResult.data.topic,
       source: validationResult.data.source
     });
-    const logger54 = deps.logger ?? createLogger({ tool: "research_discover" });
+    const logger55 = deps.logger ?? createLogger({ tool: "research_discover" });
     const startMs = Date.now();
-    const response = await withToolError("Discovery failed", logger54, async () => {
-      const result = await executeDiscovery(validationResult.data, logger54);
+    const response = await withToolError("Discovery failed", logger55, async () => {
+      const result = await executeDiscovery(validationResult.data, logger55);
       recordDiscoverySuccess(result.topic, result.newItems, result.sourcesQueried);
       return toolSuccess(JSON.stringify(result, null, 2));
     });
@@ -39016,7 +39021,7 @@ function createResearchDiscoverHandler(deps) {
   };
 }
 function registerResearchDiscoverTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "research_discover" });
+  const logger55 = deps.logger ?? createLogger({ tool: "research_discover" });
   const toolSchema = {
     topic: z76.string().min(1).max(200).describe("Research topic to search for"),
     source: z76.enum([
@@ -39039,19 +39044,19 @@ function registerResearchDiscoverTool(server, deps) {
   const secureHandler = createSecureHandler(createResearchDiscoverHandler(deps), {
     toolName: "research_discover",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("research_discover", deps.security);
   const wrappedHandler = wrapToolWithTimeout("research_discover", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "research_discover",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered research_discover tool with secure handler and timeout protection");
+  logger55.info("Registered research_discover tool with secure handler and timeout protection");
 }
 
 // src/mcp/tools/research-analyze.ts
@@ -39292,15 +39297,15 @@ function createResearchAnalyzeHandler(deps) {
     ctx.logger.debug("Analyzing research registry", {
       focus: validationResult.data.focus
     });
-    const logger54 = deps.logger ?? createLogger({ tool: "research_analyze" });
-    return withToolError("Analysis failed", logger54, async () => {
+    const logger55 = deps.logger ?? createLogger({ tool: "research_analyze" });
+    return withToolError("Analysis failed", logger55, async () => {
       const result = await executeAnalysis(validationResult.data);
       return toolSuccess(JSON.stringify(result, null, 2));
     });
   };
 }
 function registerResearchAnalyzeTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "research_analyze" });
+  const logger55 = deps.logger ?? createLogger({ tool: "research_analyze" });
   const toolSchema = {
     focus: z77.enum(["gaps", "trends", "priorities", "stale", "coverage"]).describe("Analysis focus area"),
     topic: z77.string().optional().describe("Optional topic filter")
@@ -39309,19 +39314,19 @@ function registerResearchAnalyzeTool(server, deps) {
   const secureHandler = createSecureHandler(createResearchAnalyzeHandler(deps), {
     toolName: "research_analyze",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("research_analyze", deps.security);
   const wrappedHandler = wrapToolWithTimeout("research_analyze", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "research_analyze",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered research_analyze tool with secure handler and timeout protection");
+  logger55.info("Registered research_analyze tool with secure handler and timeout protection");
 }
 
 // src/mcp/tools/research-catalog-review.ts
@@ -39344,7 +39349,7 @@ function handleList() {
     data: { pending, count: pending.length }
   };
 }
-async function approveArxivRef(identifier, topic, shouldCreateIssue, logger54) {
+async function approveArxivRef(identifier, topic, shouldCreateIssue, logger55) {
   const catalog = getAutoCatalog();
   const exists = await paperExists(identifier);
   if (exists) {
@@ -39356,7 +39361,7 @@ async function approveArxivRef(identifier, topic, shouldCreateIssue, logger54) {
   if (!result.success) {
     return { action: "approve", success: false, message: `Failed: ${result.message}` };
   }
-  logger54.info("Approved paper", { paperId: result.paperId });
+  logger55.info("Approved paper", { paperId: result.paperId });
   if (shouldCreateIssue) {
     const body = formatResearchIssueBody([
       {
@@ -39380,11 +39385,11 @@ async function approveArxivRef(identifier, topic, shouldCreateIssue, logger54) {
         data: { ...result, issueUrl: issueResult.value.url }
       };
     }
-    logger54.warn("Issue creation failed after approve", { error: issueResult.error.message });
+    logger55.warn("Issue creation failed after approve", { error: issueResult.error.message });
   }
   return { action: "approve", success: true, message: `Added: ${result.title}`, data: result };
 }
-async function handleApprove(input, logger54) {
+async function handleApprove(input, logger55) {
   if (input.identifier === void 0 || input.identifier === "") {
     return { action: "approve", success: false, message: "identifier is required" };
   }
@@ -39398,7 +39403,7 @@ async function handleApprove(input, logger54) {
     };
   }
   if (ref.type === "arxiv") {
-    return approveArxivRef(ref.identifier, input.topic, input.createIssue, logger54);
+    return approveArxivRef(ref.identifier, input.topic, input.createIssue, logger55);
   }
   catalog.markReviewed(ref.identifier);
   return { action: "approve", success: true, message: `Reviewed: ${ref.identifier}` };
@@ -39429,12 +39434,12 @@ function handleFlush() {
     message: `Flushed ${String(count)} references from catalog`
   };
 }
-async function executeCatalogReview(input, logger54) {
+async function executeCatalogReview(input, logger55) {
   switch (input.action) {
     case "list":
       return handleList();
     case "approve":
-      return handleApprove(input, logger54);
+      return handleApprove(input, logger55);
     case "dismiss":
       return handleDismiss(input);
     case "flush":
@@ -39448,9 +39453,9 @@ function createCatalogReviewHandler(deps) {
       return toolError(`Validation error: ${formatZodError(validationResult.error)}`);
     }
     ctx.logger.debug("Catalog review", { action: validationResult.data.action });
-    const logger54 = deps.logger ?? createLogger({ tool: "research_catalog_review" });
-    return withToolError("Catalog review failed", logger54, async () => {
-      const result = await executeCatalogReview(validationResult.data, logger54);
+    const logger55 = deps.logger ?? createLogger({ tool: "research_catalog_review" });
+    return withToolError("Catalog review failed", logger55, async () => {
+      const result = await executeCatalogReview(validationResult.data, logger55);
       if (!result.success) {
         return toolError(result.message);
       }
@@ -39459,7 +39464,7 @@ function createCatalogReviewHandler(deps) {
   };
 }
 function registerResearchCatalogReviewTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "research_catalog_review" });
+  const logger55 = deps.logger ?? createLogger({ tool: "research_catalog_review" });
   const toolSchema = {
     action: z78.enum(["list", "approve", "dismiss", "flush"]).describe("Action to perform on cataloged references"),
     identifier: z78.string().optional().describe("Reference identifier for approve/dismiss"),
@@ -39470,19 +39475,19 @@ function registerResearchCatalogReviewTool(server, deps) {
   const secureHandler = createSecureHandler(createCatalogReviewHandler(deps), {
     toolName: "research_catalog_review",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("research_catalog_review", deps.security);
   const wrappedHandler = wrapToolWithTimeout("research_catalog_review", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "research_catalog_review",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered research_catalog_review tool");
+  logger55.info("Registered research_catalog_review tool");
 }
 
 // src/mcp/tools/research-synthesize.ts
@@ -39496,8 +39501,8 @@ function createResearchSynthesizeHandler(deps) {
     if (!validationResult.success) {
       return toolError(`Validation error: ${formatZodError(validationResult.error)}`);
     }
-    const logger54 = deps.logger ?? createLogger({ tool: "research_synthesize" });
-    return withToolError("Synthesis failed", logger54, async () => {
+    const logger55 = deps.logger ?? createLogger({ tool: "research_synthesize" });
+    return withToolError("Synthesis failed", logger55, async () => {
       const result = await synthesizeResearch(validationResult.data.topic);
       if (!result.ok) {
         return toolError(`Synthesis failed: ${result.error.message}`);
@@ -39507,7 +39512,7 @@ function createResearchSynthesizeHandler(deps) {
   };
 }
 function registerResearchSynthesizeTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "research_synthesize" });
+  const logger55 = deps.logger ?? createLogger({ tool: "research_synthesize" });
   const toolSchema = {
     topic: z79.string().optional().describe("Optional topic filter for single-cluster synthesis")
   };
@@ -39515,19 +39520,19 @@ function registerResearchSynthesizeTool(server, deps) {
   const secureHandler = createSecureHandler(createResearchSynthesizeHandler(deps), {
     toolName: "research_synthesize",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("research_synthesize", deps.security);
   const wrappedHandler = wrapToolWithTimeout("research_synthesize", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "research_synthesize",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered research_synthesize tool");
+  logger55.info("Registered research_synthesize tool");
 }
 
 // src/mcp/tools/issue-triage-tool.ts
@@ -39581,7 +39586,7 @@ function createIssueTriageHandler(_deps) {
   };
 }
 function registerIssueTriageTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "issue_triage" });
+  const logger55 = deps.logger ?? createLogger({ tool: "issue_triage" });
   const toolSchema = {
     issueUrl: z80.string().min(1).describe("GitHub issue URL (e.g., https://github.com/owner/repo/issues/123)"),
     dryRun: z80.boolean().optional().default(true).describe("Read-only mode (default: true)")
@@ -39591,19 +39596,19 @@ function registerIssueTriageTool(server, deps) {
     toolName: "issue_triage",
     securityTier: "external",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("issue_triage", deps.security);
   const wrappedHandler = wrapToolWithTimeout("issue_triage", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "issue_triage",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered issue_triage tool with secure handler and timeout protection");
+  logger55.info("Registered issue_triage tool with secure handler and timeout protection");
 }
 var triageLogger = createLogger({ tool: "issue-triage" });
 function recordTriageSuccess(category, confidence, durationMs) {
@@ -39840,7 +39845,7 @@ function createEventCollector(events, enableAuditTrail) {
     auditBridge?.(event);
   };
 }
-async function handleRunGraphWorkflow(input, logger54) {
+async function handleRunGraphWorkflow(input, logger55) {
   const startTime = getTimeProvider().now();
   const resolved = resolveGraph(input.workflow, startTime);
   if (!resolved.ok) return resolved.error;
@@ -39848,7 +39853,7 @@ async function handleRunGraphWorkflow(input, logger54) {
   const checkpointStore = input.enableCheckpointing ? createCheckpointStore() : void 0;
   const onEvent = createEventCollector(events, input.enableAuditTrail);
   const executionId = `graph-${input.workflow}-${String(Date.now())}`;
-  logger54.info("Executing graph workflow", {
+  logger55.info("Executing graph workflow", {
     workflow: input.workflow,
     executionId,
     checkpointing: input.enableCheckpointing,
@@ -39891,7 +39896,7 @@ var GRAPH_WORKFLOW_SCHEMA = {
   enableCheckpointing: z81.boolean().optional().describe("Enable checkpoint saving"),
   enableAuditTrail: z81.boolean().optional().describe("Enable audit trail logging")
 };
-function createGraphWorkflowHandler(logger54, notifier) {
+function createGraphWorkflowHandler(logger55, notifier) {
   return async (args, _ctx) => {
     const parsed = RunGraphWorkflowInputSchema.safeParse(args);
     if (!parsed.success) {
@@ -39904,7 +39909,7 @@ function createGraphWorkflowHandler(logger54, notifier) {
       event: "graph_workflow_start",
       workflow: parsed.data.workflow
     });
-    const result = await handleRunGraphWorkflow(parsed.data, logger54);
+    const result = await handleRunGraphWorkflow(parsed.data, logger55);
     const succeeded = result.status === "completed";
     notifier.info("run_graph_workflow", {
       event: succeeded ? "graph_workflow_complete" : "graph_workflow_failed",
@@ -39918,22 +39923,22 @@ function createGraphWorkflowHandler(logger54, notifier) {
   };
 }
 function registerRunGraphWorkflowTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "run_graph_workflow" });
+  const logger55 = deps.logger ?? createLogger({ tool: "run_graph_workflow" });
   const notifier = deps.notifier ?? createMcpNotifier(server);
-  const handler2 = createGraphWorkflowHandler(logger54, notifier);
+  const handler2 = createGraphWorkflowHandler(logger55, notifier);
   const secureHandler = createSecureHandler(handler2, {
     toolName: "run_graph_workflow",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("run_graph_workflow", deps.security);
-  const wrapped = wrapToolWithTimeout("run_graph_workflow", secureHandler, { timeoutMs, logger: logger54 });
+  const wrapped = wrapToolWithTimeout("run_graph_workflow", secureHandler, { timeoutMs, logger: logger55 });
   server.registerTool(
     "run_graph_workflow",
     { description: GRAPH_WORKFLOW_DESCRIPTION, inputSchema: GRAPH_WORKFLOW_SCHEMA },
     toSdkCallback(wrapped)
   );
-  logger54.info("Registered run_graph_workflow tool");
+  logger55.info("Registered run_graph_workflow tool");
 }
 function toEventSummary(event) {
   const hasNodeId = "nodeId" in event;
@@ -40485,7 +40490,7 @@ var ExecuteSpecInputSchema = z82.object({
   spec: z82.string().min(1).max(5e4).describe("Markdown specification to execute"),
   dryRun: z82.boolean().optional().default(false).describe("Parse and decompose only")
 });
-function createDryRunResponse(input, logger54) {
+function createDryRunResponse(input, logger55) {
   const parseResult2 = parseSpec(input.spec);
   if (!parseResult2.ok) {
     return toolError(`Parse error: ${parseResult2.error.message}`);
@@ -40494,14 +40499,14 @@ function createDryRunResponse(input, logger54) {
   if (!dagResult.ok) {
     return toolError(`Decompose error: ${dagResult.error.message}`);
   }
-  logger54.info("Dry run completed", {
+  logger55.info("Dry run completed", {
     title: parseResult2.value.title,
     nodes: dagResult.value.nodes.length
   });
   const output2 = { mode: "dry_run", spec: parseResult2.value, dag: dagResult.value };
   return toolSuccess(JSON.stringify(output2, null, 2));
 }
-async function createFullResponse(input, logger54) {
+async function createFullResponse(input, logger55) {
   const startMs = Date.now();
   const result = await executeSpec(input.spec);
   const durationMs = Date.now() - startMs;
@@ -40511,7 +40516,7 @@ async function createFullResponse(input, logger54) {
   }
   const analysis = analyzeFailures(result.value);
   const satisfaction = result.value.validation.satisfaction;
-  logger54.info("Spec execution completed", {
+  logger55.info("Spec execution completed", {
     satisfaction,
     passed: analysis.ok ? analysis.value.passed : false
   });
@@ -40525,24 +40530,24 @@ async function createFullResponse(input, logger54) {
   return toolSuccess(JSON.stringify(output2, null, 2));
 }
 function registerExecuteSpecTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "execute_spec" });
+  const logger55 = deps.logger ?? createLogger({ tool: "execute_spec" });
   const handler2 = async (args, _ctx) => {
     const parsed = ExecuteSpecInputSchema.safeParse(args);
     if (!parsed.success) {
       return toolError(`Invalid input: ${formatZodError(parsed.error)}`);
     }
     if (parsed.data.dryRun) {
-      return createDryRunResponse(parsed.data, logger54);
+      return createDryRunResponse(parsed.data, logger55);
     }
-    return createFullResponse(parsed.data, logger54);
+    return createFullResponse(parsed.data, logger55);
   };
   const secureHandler = createSecureHandler(handler2, {
     toolName: "execute_spec",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("execute_spec", deps.security);
-  const wrapped = wrapToolWithTimeout("execute_spec", secureHandler, { timeoutMs, logger: logger54 });
+  const wrapped = wrapToolWithTimeout("execute_spec", secureHandler, { timeoutMs, logger: logger55 });
   const toolSchema = {
     spec: z82.string().min(1).max(5e4).describe(
       'Markdown specification to execute. Must contain "## Requirements" and "## Acceptance Criteria" sections.'
@@ -40555,7 +40560,7 @@ function registerExecuteSpecTool(server, deps) {
     { description, inputSchema: toolSchema },
     toSdkCallback(wrapped)
   );
-  logger54.info("Registered execute_spec tool");
+  logger55.info("Registered execute_spec tool");
 }
 var specLogger = createLogger({ tool: "execute-spec" });
 function recordSpecSuccess(satisfaction, durationMs) {
@@ -40617,29 +40622,29 @@ var MemoryQueryInputSchema = z83.object({
 });
 var reflectionCache;
 var reflectionAdapter;
-function getReflectiveRetriever(logger54) {
+function getReflectiveRetriever(logger55) {
   const enabled = isReflectiveMemoryEnabled();
   const shadow = isReflectiveShadowMode();
   if (!enabled && !shadow) return void 0;
   if (reflectionAdapter === void 0) {
     try {
-      const registry = getGlobalRegistry({ logger: logger54 });
+      const registry = getGlobalRegistry({ logger: logger55 });
       reflectionAdapter = registry.getDefault();
     } catch {
-      logger54.warn("No adapter for reflection, using keyword retrieval");
+      logger55.warn("No adapter for reflection, using keyword retrieval");
       return void 0;
     }
   }
   reflectionCache ??= new ReflectionCache();
   return new ReflectiveRetriever({
     adapter: reflectionAdapter,
-    logger: logger54,
+    logger: logger55,
     shadowMode: shadow,
     cache: reflectionCache
   });
 }
-async function resolveReflection(query, logger54) {
-  const retriever = getReflectiveRetriever(logger54);
+async function resolveReflection(query, logger55) {
+  const retriever = getReflectiveRetriever(logger55);
   if (retriever === void 0) return { effectiveQuery: query };
   const reflection = await retriever.enhance(query);
   const reflected = reflection.reflected;
@@ -40651,14 +40656,14 @@ async function resolveReflection(query, logger54) {
     reflection
   };
 }
-async function executeMemoryQuery(input, logger54) {
+async function executeMemoryQuery(input, logger55) {
   const toolMemory = getToolMemory();
   const { effectiveQuery, expandedQuery, reflection } = await resolveReflection(
     input.query,
-    logger54
+    logger55
   );
   const results = await toolMemory.queryBySource(input.source, effectiveQuery, input.limit);
-  logger54.debug("Memory query executed", {
+  logger55.debug("Memory query executed", {
     query: input.query,
     effectiveQuery: effectiveQuery !== input.query ? effectiveQuery : void 0,
     resultCount: results.length,
@@ -40685,7 +40690,7 @@ async function memoryQueryHandler(args, ctx) {
   });
 }
 function registerMemoryQueryTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "memory_query" });
+  const logger55 = deps.logger ?? createLogger({ tool: "memory_query" });
   const toolSchema = {
     query: z83.string().min(1).max(500).describe("Search query to match against memory contents"),
     limit: z83.number().int().min(1).max(50).optional().describe("Maximum results to return (default: 10, max: 50)"),
@@ -40695,16 +40700,16 @@ function registerMemoryQueryTool(server, deps) {
   const secureHandler = createSecureHandler(memoryQueryHandler, {
     toolName: "memory_query",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("memory_query", deps.security);
-  const wrappedHandler = wrapToolWithTimeout("memory_query", secureHandler, { timeoutMs, logger: logger54 });
+  const wrappedHandler = wrapToolWithTimeout("memory_query", secureHandler, { timeoutMs, logger: logger55 });
   server.registerTool(
     "memory_query",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered memory_query tool");
+  logger55.info("Registered memory_query tool");
 }
 
 // src/mcp/tools/memory-stats.ts
@@ -40712,7 +40717,7 @@ import { z as z84 } from "zod";
 var MemoryStatsInputSchema = z84.object({
   includeDecay: z84.boolean().optional().default(true).describe("Include decay statistics (default: true)")
 });
-async function collectMemoryStats(input, logger54) {
+async function collectMemoryStats(input, logger55) {
   const toolMemory = getToolMemory();
   const sessionStats = {
     learningsCount: 0,
@@ -40749,7 +40754,7 @@ async function collectMemoryStats(input, logger54) {
     mobimem: toolMemory.isMobiMemAvailable(),
     decay: toolMemory.isDecayManagerAvailable()
   };
-  logger54.debug("Memory stats collected", { backends });
+  logger55.debug("Memory stats collected", { backends });
   return {
     backends,
     session: sessionStats,
@@ -40771,7 +40776,7 @@ async function memoryStatsHandler(args, ctx) {
   });
 }
 function registerMemoryStatsTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "memory_stats" });
+  const logger55 = deps.logger ?? createLogger({ tool: "memory_stats" });
   const toolSchema = {
     includeDecay: z84.boolean().optional().describe("Include decay statistics (default: true)")
   };
@@ -40779,16 +40784,16 @@ function registerMemoryStatsTool(server, deps) {
   const secureHandler = createSecureHandler(memoryStatsHandler, {
     toolName: "memory_stats",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("memory_stats", deps.security);
-  const wrappedHandler = wrapToolWithTimeout("memory_stats", secureHandler, { timeoutMs, logger: logger54 });
+  const wrappedHandler = wrapToolWithTimeout("memory_stats", secureHandler, { timeoutMs, logger: logger55 });
   server.registerTool(
     "memory_stats",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered memory_stats tool");
+  logger55.info("Registered memory_stats tool");
 }
 
 // src/mcp/tools/memory-write.ts
@@ -40877,12 +40882,12 @@ function isDuplicateWrite(key, content) {
   recentWriteKeys.set(cacheKey, (/* @__PURE__ */ new Date()).toISOString());
   return false;
 }
-async function executeMemoryWrite(input, logger54) {
+async function executeMemoryWrite(input, logger55) {
   if (isDuplicateWrite(input.key, input.content)) {
-    logger54.debug("Skipping duplicate memory write", { key: input.key, backend: input.backend });
+    logger55.debug("Skipping duplicate memory write", { key: input.key, backend: input.backend });
     return { success: true, backend: input.backend, key: input.key, deduplicated: true };
   }
-  logger54.debug("Writing to memory", {
+  logger55.debug("Writing to memory", {
     backend: input.backend,
     key: input.key,
     contentLength: input.content.length
@@ -40914,7 +40919,7 @@ async function memoryWriteHandler(args, ctx) {
   });
 }
 function registerMemoryWriteTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "memory_write" });
+  const logger55 = deps.logger ?? createLogger({ tool: "memory_write" });
   const toolSchema = {
     key: z85.string().min(1).max(200).describe("Memory identifier or subject"),
     content: z85.string().min(1).max(5e3).describe("Memory content to store"),
@@ -40928,16 +40933,16 @@ function registerMemoryWriteTool(server, deps) {
   const secureHandler = createSecureHandler(memoryWriteHandler, {
     toolName: "memory_write",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("memory_write", deps.security);
-  const wrappedHandler = wrapToolWithTimeout("memory_write", secureHandler, { timeoutMs, logger: logger54 });
+  const wrappedHandler = wrapToolWithTimeout("memory_write", secureHandler, { timeoutMs, logger: logger55 });
   server.registerTool(
     "memory_write",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered memory_write tool");
+  logger55.info("Registered memory_write tool");
 }
 
 // src/mcp/tools/weather-report-tool.ts
@@ -40982,7 +40987,7 @@ function weatherReportHandler(args, ctx) {
   }
 }
 function registerWeatherReportTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "weather_report" });
+  const logger55 = deps.logger ?? createLogger({ tool: "weather_report" });
   const toolSchema = {
     cli: z86.enum(["claude", "gemini", "codex", "opencode"]).optional().describe("Filter by CLI"),
     category: z86.enum([
@@ -41003,19 +41008,19 @@ function registerWeatherReportTool(server, deps) {
   const secureHandler = createSecureHandler(weatherReportHandler, {
     toolName: "weather_report",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("weather_report", deps.security);
   const wrappedHandler = wrapToolWithTimeout("weather_report", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "weather_report",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered weather_report tool");
+  logger55.info("Registered weather_report tool");
 }
 
 // src/mcp/tools/registry-import-types.ts
@@ -41133,7 +41138,7 @@ function registryImportHandler(args, ctx) {
   }
 }
 function registerRegistryImportTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "registry_import" });
+  const logger55 = deps.logger ?? createLogger({ tool: "registry_import" });
   const toolSchema = {
     provider: z88.enum(["anthropic", "google", "openai"]).describe("Model provider (anthropic, google, openai)"),
     modelId: z88.string().min(1).describe("Provider model identifier"),
@@ -41143,19 +41148,19 @@ function registerRegistryImportTool(server, deps) {
   const secureHandler = createSecureHandler(registryImportHandler, {
     toolName: "registry_import",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("registry_import", deps.security);
   const wrappedHandler = wrapToolWithTimeout("registry_import", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "registry_import",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered registry_import tool");
+  logger55.info("Registered registry_import tool");
 }
 
 // src/mcp/tools/repo-analyze-types.ts
@@ -41185,7 +41190,7 @@ async function repoAnalyzeHandler(args, ctx) {
   }
 }
 function registerRepoAnalyzeTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "repo_analyze" });
+  const logger55 = deps.logger ?? createLogger({ tool: "repo_analyze" });
   const toolSchema = {
     repo: z90.string().min(1).describe('GitHub repository in "owner/name" format or full URL'),
     depth: z90.enum(["shallow", "deep"]).optional().describe("Analysis depth: shallow (tree + README) or deep")
@@ -41194,19 +41199,19 @@ function registerRepoAnalyzeTool(server, deps) {
   const secureHandler = createSecureHandler(repoAnalyzeHandler, {
     toolName: "repo_analyze",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("repo_analyze", deps.security);
   const wrappedHandler = wrapToolWithTimeout("repo_analyze", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "repo_analyze",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered repo_analyze tool");
+  logger55.info("Registered repo_analyze tool");
 }
 
 // src/mcp/tools/repo-security-plan-types.ts
@@ -41235,7 +41240,7 @@ async function handler(args, ctx) {
   }
 }
 function registerRepoSecurityPlanTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "repo_security_plan" });
+  const logger55 = deps.logger ?? createLogger({ tool: "repo_security_plan" });
   const toolSchema = {
     repo: z92.string().min(1).describe('GitHub repository in "owner/name" format or full URL'),
     categories: z92.array(z92.string().max(50)).max(10).optional().describe('Filter to specific categories (e.g., ["sast", "sca", "secrets"])'),
@@ -41245,19 +41250,19 @@ function registerRepoSecurityPlanTool(server, deps) {
   const secureHandler = createSecureHandler(handler, {
     toolName: "repo_security_plan",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("repo_security_plan", deps.security);
   const wrappedHandler = wrapToolWithTimeout("repo_security_plan", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "repo_security_plan",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered repo_security_plan tool");
+  logger55.info("Registered repo_security_plan tool");
 }
 
 // src/mcp/tools/search-codebase-tool.ts
@@ -41338,7 +41343,7 @@ ${output2}`);
   }
 }
 function registerSearchCodebaseTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "search_codebase" });
+  const logger55 = deps.logger ?? createLogger({ tool: "search_codebase" });
   const toolSchema = {
     query: z93.string().min(1).max(200).describe("Search query or file path"),
     directory: z93.string().max(500).optional().describe("Directory to index"),
@@ -41349,16 +41354,16 @@ function registerSearchCodebaseTool(server, deps) {
   const secureHandler = createSecureHandler(searchCodebaseHandler, {
     toolName: "search_codebase",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("search_codebase", deps.security);
-  const wrapped = wrapToolWithTimeout("search_codebase", secureHandler, { timeoutMs, logger: logger54 });
+  const wrapped = wrapToolWithTimeout("search_codebase", secureHandler, { timeoutMs, logger: logger55 });
   server.registerTool(
     "search_codebase",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrapped)
   );
-  logger54.info("Registered search_codebase tool");
+  logger55.info("Registered search_codebase tool");
 }
 
 // src/mcp/tools/extract-symbols-tool.ts
@@ -41416,7 +41421,7 @@ async function extractSymbolsHandler(args, ctx) {
   }
 }
 function registerExtractSymbolsTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "extract_symbols" });
+  const logger55 = deps.logger ?? createLogger({ tool: "extract_symbols" });
   const toolSchema = {
     filePath: z94.string().min(1).max(500).describe("Path to TypeScript/JavaScript file"),
     mode: z94.enum(["index", "full"]).optional().describe("index (default): names+lines. full: includes source text")
@@ -41425,19 +41430,19 @@ function registerExtractSymbolsTool(server, deps) {
   const secureHandler = createSecureHandler(extractSymbolsHandler, {
     toolName: "extract_symbols",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("extract_symbols", deps.security);
   const wrapped = wrapToolWithTimeout("extract_symbols", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "extract_symbols",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrapped)
   );
-  logger54.info("Registered extract_symbols tool");
+  logger55.info("Registered extract_symbols tool");
 }
 
 // src/mcp/tools/query-trace-tool.ts
@@ -41535,7 +41540,7 @@ function queryTraceHandler(args, ctx) {
   });
 }
 function registerQueryTraceTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "query_trace" });
+  const logger55 = deps.logger ?? createLogger({ tool: "query_trace" });
   const toolSchema = {
     runId: z95.string().min(1).max(128).regex(/^[a-zA-Z0-9_-]+$/, "runId must be alphanumeric, hyphens, or underscores").describe("Run ID to query traces for"),
     eventType: z95.string().max(100).regex(/^[a-zA-Z0-9._-]+$/).optional().describe("Filter by event type (e.g., model.called)"),
@@ -41545,16 +41550,16 @@ function registerQueryTraceTool(server, deps) {
   const secureHandler = createSecureHandler(queryTraceHandler, {
     toolName: "query_trace",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("query_trace", deps.security);
-  const wrappedHandler = wrapToolWithTimeout("query_trace", secureHandler, { timeoutMs, logger: logger54 });
+  const wrappedHandler = wrapToolWithTimeout("query_trace", secureHandler, { timeoutMs, logger: logger55 });
   server.registerTool(
     "query_trace",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered query_trace tool");
+  logger55.info("Registered query_trace tool");
 }
 
 // src/pipeline/stage-types.ts
@@ -44017,7 +44022,7 @@ function queryTaskStateHandler(args, ctx) {
   return Promise.resolve(toolSuccess(JSON.stringify(response, null, 2)));
 }
 function registerQueryTaskStateTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "query_task_state" });
+  const logger55 = deps.logger ?? createLogger({ tool: "query_task_state" });
   const toolSchema = {
     taskId: z100.string().min(1).max(128).describe("Task ID whose structured state log should be read")
   };
@@ -44025,19 +44030,19 @@ function registerQueryTaskStateTool(server, deps) {
   const secureHandler = createSecureHandler(queryTaskStateHandler, {
     toolName: "query_task_state",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("query_task_state", deps.security);
   const wrappedHandler = wrapToolWithTimeout("query_task_state", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "query_task_state",
     { description, inputSchema: toolSchema },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered query_task_state tool");
+  logger55.info("Registered query_task_state tool");
 }
 
 // src/mcp/tools/pipeline-tool.ts
@@ -44521,9 +44526,9 @@ function wrapWithObservability(toolName, cb, eventBus) {
 
 // src/mcp/tools/index.ts
 function registerTools(server, options) {
-  const logger54 = options?.logger ?? createMcpLogger({ component: "tools" });
-  const rateLimiter = options?.rateLimiter ?? createDefaultRateLimiter("mcp-tools", logger54);
-  logger54.info("Tool registration infrastructure initialized");
+  const logger55 = options?.logger ?? createMcpLogger({ component: "tools" });
+  const rateLimiter = options?.rateLimiter ?? createDefaultRateLimiter("mcp-tools", logger55);
+  logger55.info("Tool registration infrastructure initialized");
   void server;
   return {
     tools: [
@@ -44559,7 +44564,7 @@ function registerTools(server, options) {
       "run_dev_pipeline",
       "run_pipeline"
     ],
-    logger: logger54,
+    logger: logger55,
     rateLimiter
   };
 }
@@ -44572,32 +44577,32 @@ var TIER_NAMES = {
 };
 function createGateway(config = {}) {
   const enabled = config.enabled !== false;
-  const logger54 = config.logger ?? createLogger({ component: "gateway" });
+  const logger55 = config.logger ?? createLogger({ component: "gateway" });
   const overrides = config.tierOverrides;
   return {
     enabled,
     wrapTool(toolName, handler2) {
       if (!enabled) return handler2;
-      return createGatewayHandler(toolName, handler2, logger54, overrides);
+      return createGatewayHandler(toolName, handler2, logger55, overrides);
     }
   };
 }
-function createGatewayHandler(toolName, handler2, logger54, overrides) {
+function createGatewayHandler(toolName, handler2, logger55, overrides) {
   return async (args) => {
     const params = asRecord2(args);
     const tier = classifyRequestTier(toolName, params, overrides);
     const tierName = TIER_NAMES[tier];
     const startMs = getTimeProvider().now();
-    logger54.debug("Gateway dispatch", { tool: toolName, tier, tierName });
+    logger55.debug("Gateway dispatch", { tool: toolName, tier, tierName });
     try {
       const result = await handler2(args);
       const durationMs = getTimeProvider().now() - startMs;
       const success = result.isError !== true;
       const entry = { tool: toolName, tier, tierName, durationMs, success };
       if (success) {
-        logger54.info("Gateway completed", { ...entry });
+        logger55.info("Gateway completed", { ...entry });
       } else {
-        logger54.warn("Gateway completed with error", { ...entry });
+        logger55.warn("Gateway completed with error", { ...entry });
       }
       return result;
     } catch (error) {
@@ -44609,7 +44614,7 @@ function createGatewayHandler(toolName, handler2, logger54, overrides) {
         durationMs,
         success: false
       };
-      logger54.error("Gateway handler threw", error instanceof Error ? error : void 0, {
+      logger55.error("Gateway handler threw", error instanceof Error ? error : void 0, {
         ...entry
       });
       throw error;
@@ -47042,7 +47047,7 @@ var FileAuditStorage = class _FileAuditStorage {
    * @param logger - Optional logger instance
    * @returns Result with FileAuditStorage or SecurityError
    */
-  static create(config, logger54) {
+  static create(config, logger55) {
     const validation = config.allowedRoot !== void 0 ? validateLogDir(config.logDir, config.allowedRoot) : validateLogDirBasic(config.logDir);
     if (!validation.ok) {
       return { ok: false, error: validation.error };
@@ -47051,7 +47056,7 @@ var FileAuditStorage = class _FileAuditStorage {
       ...config,
       logDir: validation.value
     };
-    return { ok: true, value: new _FileAuditStorage(validatedConfig, logger54, true) };
+    return { ok: true, value: new _FileAuditStorage(validatedConfig, logger55, true) };
   }
   /**
    * Constructor for FileAuditStorage.
@@ -47064,8 +47069,8 @@ var FileAuditStorage = class _FileAuditStorage {
    * @param skipValidation - Internal flag, set by create() after validation
    * @throws SecurityError if path validation fails and skipValidation is false
    */
-  constructor(config, logger54, skipValidation = false) {
-    this.logger = logger54 ?? createLogger({ component: "FileAuditStorage" });
+  constructor(config, logger55, skipValidation = false) {
+    this.logger = logger55 ?? createLogger({ component: "FileAuditStorage" });
     if (!skipValidation) {
       const validation = validateLogDirBasic(config.logDir);
       if (!validation.ok) {
@@ -47246,13 +47251,13 @@ var AuditLogger = class {
   flushTimer = null;
   flushIntervalMs;
   closed = false;
-  constructor(config, storage, logger54) {
+  constructor(config, storage, logger55) {
     const validated = AuditLogConfigSchema.safeParse(config);
     if (!validated.success) {
       const issues = validated.error.issues.map((i) => i.path.join(".") + ": " + i.message).join("; ");
       throw new AuditError("Invalid AuditLogConfig: " + issues);
     }
-    this.logger = logger54 ?? createLogger({ component: "AuditLogger" });
+    this.logger = logger55 ?? createLogger({ component: "AuditLogger" });
     this.enableHashChain = validated.data.enableHashChain;
     this.minSeverity = validated.data.minSeverity;
     this.categories = validated.data.categories;
@@ -47425,8 +47430,8 @@ var AuditLogger = class {
     this.logger.info("AuditLogger closed");
   }
 };
-function createAuditLogger(config, storage, logger54) {
-  return new AuditLogger(config, storage, logger54);
+function createAuditLogger(config, storage, logger55) {
+  return new AuditLogger(config, storage, logger55);
 }
 
 // src/security/sandbox/sandbox-types.ts
@@ -49454,6 +49459,124 @@ function buildSuccessResult(instance2, patch, modelName, startTime, state) {
   };
 }
 
+// src/swe-bench/verify-loop.ts
+var DEFAULT_MAX_VERIFY_RETRIES = 2;
+var FAILURE_PATTERNS = [
+  {
+    category: "patch_not_applicable",
+    regex: /patch .*?does not apply|hunk #\d+ FAILED|Reversed .*patch detected/i,
+    summarizer: (m) => `Patch did not apply cleanly: ${m[0]}`
+  },
+  {
+    category: "syntax_error",
+    regex: /SyntaxError: (.*?)(?:\n|$)|IndentationError: (.*?)(?:\n|$)/,
+    summarizer: (m) => `Syntax error in generated patch: ${m[1] ?? m[2] ?? m[0]}`.trim()
+  },
+  {
+    category: "timeout",
+    regex: /Timeout\b|timed out after \d+\s?s\b|TIMEOUT_EXCEEDED/i,
+    summarizer: (m) => `Test run exceeded timeout: ${m[0]}`
+  },
+  {
+    category: "missing_dependency",
+    regex: /ModuleNotFoundError: No module named '([^']+)'|ImportError: cannot import name '([^']+)'|No module named "([^"]+)"/,
+    summarizer: (m) => `Missing dependency: ${m[1] ?? m[2] ?? m[3] ?? "unknown"}. Patch may need an import.`
+  },
+  {
+    category: "runtime_error",
+    regex: /([A-Z][a-zA-Z]+Error): (.*?)(?:\n|$)/,
+    summarizer: (m) => `Runtime error ${m[1] ?? ""}: ${m[2] ?? ""}`.trim()
+  },
+  {
+    category: "test_failure",
+    regex: /FAILED .*?::(\S+)|AssertionError|FAIL: (\S+)/,
+    summarizer: (_m, stderr, stdout) => {
+      const failed = extractFailedTests(stderr, stdout);
+      return failed.length > 0 ? `Tests still failing: ${failed.slice(0, 5).join(", ")}` : "One or more tests failed after patch";
+    }
+  }
+];
+function classifyPatchFailure(stderr, stdout) {
+  const haystack = `${stderr}
+${stdout}`;
+  for (const pattern of FAILURE_PATTERNS) {
+    const match = pattern.regex.exec(haystack);
+    if (match !== null) {
+      return {
+        category: pattern.category,
+        summary: pattern.summarizer(match, stderr, stdout),
+        affectedTests: extractFailedTests(stderr, stdout)
+      };
+    }
+  }
+  return {
+    category: "unknown",
+    summary: haystack.trim().slice(0, 200) || "No failure details captured",
+    affectedTests: extractFailedTests(stderr, stdout)
+  };
+}
+function extractFailedTests(stderr, stdout) {
+  const combined = `${stderr}
+${stdout}`;
+  const results = /* @__PURE__ */ new Set();
+  const pytestPattern = /FAILED (\S+::\S+)/g;
+  let match;
+  while ((match = pytestPattern.exec(combined)) !== null) {
+    if (match[1] !== void 0) results.add(match[1]);
+  }
+  const unittestPattern = /FAIL: (\S+) \(/g;
+  while ((match = unittestPattern.exec(combined)) !== null) {
+    if (match[1] !== void 0) results.add(match[1]);
+  }
+  return Array.from(results);
+}
+var ALWAYS_RETRYABLE = /* @__PURE__ */ new Set([
+  "patch_not_applicable",
+  "syntax_error",
+  "missing_dependency",
+  "test_failure",
+  "runtime_error",
+  "incomplete_fix"
+]);
+var NEVER_RETRYABLE = /* @__PURE__ */ new Set(["timeout"]);
+function shouldRetry(category, iteration, maxRetries = DEFAULT_MAX_VERIFY_RETRIES) {
+  if (iteration >= maxRetries) return false;
+  if (NEVER_RETRYABLE.has(category)) return false;
+  if (ALWAYS_RETRYABLE.has(category)) return true;
+  return iteration < 1;
+}
+function buildRetryHint(classification, iteration, maxRetries = DEFAULT_MAX_VERIFY_RETRIES) {
+  const header = `Verification attempt ${String(iteration + 1)}/${String(maxRetries + 1)} failed.`;
+  const bodyLines = [
+    header,
+    `Category: ${classification.category}`,
+    `Summary: ${classification.summary}`
+  ];
+  if (classification.affectedTests.length > 0) {
+    const count = String(classification.affectedTests.length);
+    const names = classification.affectedTests.slice(0, 5).join(", ");
+    const overflow = classification.affectedTests.length > 5 ? ", ..." : "";
+    bodyLines.push(`Affected tests (${count}): ${names}${overflow}`);
+  }
+  bodyLines.push("Fix the root cause, not the symptom. Re-emit the full patch.");
+  return bodyLines.join("\n");
+}
+function buildVerifyOutcome(params) {
+  const maxRetries = params.maxRetries ?? DEFAULT_MAX_VERIFY_RETRIES;
+  if (params.passed) {
+    return { ok: true, iteration: params.iteration, willRetry: false };
+  }
+  const classification = classifyPatchFailure(params.stderr, params.stdout);
+  const willRetry = shouldRetry(classification.category, params.iteration, maxRetries);
+  return {
+    ok: false,
+    iteration: params.iteration,
+    classification,
+    retryHint: buildRetryHint(classification, params.iteration, maxRetries),
+    willRetry
+  };
+}
+
 // src/swe-bench/agent-runner.ts
 async function runIteration(opts) {
   const { executor, context, previousError, previousPatch, systemPromptOverride, contextSummary } = opts;
@@ -49558,7 +49681,10 @@ async function runAgentOnInstance(instance2, options) {
     startTime,
     onMessage,
     systemPrompt: options.systemPrompt,
-    iterationContext: createEmptyContext()
+    iterationContext: createEmptyContext(),
+    verifyAttempts: 0,
+    ...options.verifyAdapter !== void 0 ? { verifyAdapter: options.verifyAdapter } : {},
+    ...options.maxVerifyRetries !== void 0 ? { maxVerifyRetries: options.maxVerifyRetries } : {}
   };
   const result = await runIterationLoop(executor, context, state, loopOptions);
   return { ok: true, value: result };
@@ -49609,6 +49735,54 @@ function buildDuplicateResult(instanceId, startTime, state, onMessage) {
   onMessage?.("Duplicate patch detected, terminating early");
   return buildFailedResult(instanceId, "Duplicate patch \u2014 agent is stuck", startTime, state);
 }
+async function invokeVerifyAdapter(adapter, patch, context, options) {
+  const { passed, stderr, stdout } = await adapter.verify(context.instance, patch, context.workDir);
+  return buildVerifyOutcome({
+    passed,
+    iteration: options.verifyAttempts - 1,
+    stderr,
+    stdout,
+    ...options.maxVerifyRetries !== void 0 ? { maxRetries: options.maxVerifyRetries } : {}
+  });
+}
+function applyVerifyRetry(outcome, state, onMessage) {
+  const category = outcome.classification?.category ?? "unknown";
+  onMessage?.(`Verify failed (${category}); retrying with hint`);
+  state.lastError = outcome.retryHint ?? "Verification failed; re-emit the patch";
+  state.lastPatch = state.finalPatch;
+  state.finalPatch = void 0;
+}
+async function runPostPatchVerify(context, state, options) {
+  const adapter = options.verifyAdapter;
+  if (adapter === void 0 || state.finalPatch === void 0) return true;
+  options.verifyAttempts += 1;
+  options.onMessage?.(`Verifying patch (attempt ${String(options.verifyAttempts)})`);
+  const outcome = await invokeVerifyAdapter(adapter, state.finalPatch, context, options);
+  if (outcome.ok) return true;
+  if (!outcome.willRetry) {
+    const category = outcome.classification?.category ?? "unknown";
+    options.onMessage?.(`Verify failed (${category}); no more retries`);
+    return true;
+  }
+  applyVerifyRetry(outcome, state, options.onMessage);
+  return false;
+}
+async function handleIterationDone(context, state, options, seenPatches) {
+  if (isDuplicatePatch(state.finalPatch, seenPatches)) {
+    state.finalPatch = void 0;
+    return {
+      result: buildDuplicateResult(
+        context.instance.instance_id,
+        options.startTime,
+        state,
+        options.onMessage
+      )
+    };
+  }
+  options.onMessage?.("Patch applies successfully");
+  const verifyOk = await runPostPatchVerify(context, state, options);
+  return verifyOk ? "break" : "continue";
+}
 async function runIterationLoop(executor, context, state, options) {
   const { config, startTime, onMessage } = options;
   const seenPatches = /* @__PURE__ */ new Set();
@@ -49619,12 +49793,10 @@ async function runIterationLoop(executor, context, state, options) {
     onMessage?.(`Iteration ${state.iterations.toString()}/${config.max_iterations.toString()}`);
     const done = await executeOneIteration(executor, context, state, options);
     if (done) {
-      if (isDuplicatePatch(state.finalPatch, seenPatches)) {
-        state.finalPatch = void 0;
-        return buildDuplicateResult(context.instance.instance_id, startTime, state, onMessage);
-      }
-      onMessage?.("Patch applies successfully");
-      break;
+      const control = await handleIterationDone(context, state, options, seenPatches);
+      if (control === "break") break;
+      if (control === "continue") continue;
+      return control.result;
     }
     if (isDuplicatePatch(state.lastPatch, seenPatches)) {
       return buildDuplicateResult(context.instance.instance_id, startTime, state, onMessage);
@@ -49657,6 +49829,73 @@ function createMockExecutor(responses) {
   };
 }
 
+// src/swe-bench/harness-verify-adapter.ts
+var logger51 = createLogger({ component: "harness-verify-adapter" });
+function translateEvaluationResult(result) {
+  const stderr = buildStderr(result);
+  const stdout = buildStdout(result);
+  return {
+    passed: result.resolved,
+    stderr,
+    stdout
+  };
+}
+function buildStderr(result) {
+  if (!result.patchApplied) {
+    return `patch does not apply: ${result.patchError ?? "unknown error"}`;
+  }
+  if (result.status === "timeout") {
+    return `Test run timed out after ${String(result.durationMs)}ms`;
+  }
+  if (result.status === "error") {
+    return `Runtime error during evaluation: ${result.patchError ?? "unknown"}`;
+  }
+  const failed = result.testResults.filter((t) => t.status === "failed");
+  if (failed.length === 0) return "";
+  const lines = failed.slice(0, 20).map((t) => `FAILED ${t.testName}${t.errorMessage !== void 0 ? `: ${t.errorMessage}` : ""}`);
+  return lines.join("\n");
+}
+function buildStdout(result) {
+  const summary = [
+    `Instance: ${result.instanceId}`,
+    `Status: ${result.status}`,
+    `Patch applied: ${String(result.patchApplied)}`,
+    `Tests: ${String(result.testsPassed)}/${String(result.testsTotal)} passed`,
+    `Duration: ${String(result.durationMs)}ms`
+  ];
+  if (result.testsFailed > 0) summary.push(`Failed: ${String(result.testsFailed)}`);
+  return summary.join("\n");
+}
+var HarnessVerifyAdapter = class {
+  constructor(harness, modelNameOrPath, evalConfig) {
+    this.harness = harness;
+    this.modelNameOrPath = modelNameOrPath;
+    this.evalConfig = evalConfig;
+  }
+  async verify(instance2, patch, _workDir) {
+    const prediction = {
+      instance_id: instance2.instance_id,
+      model_name_or_path: this.modelNameOrPath,
+      model_patch: patch
+    };
+    try {
+      const result = await this.harness.evaluateInstance(prediction, this.evalConfig);
+      return translateEvaluationResult(result);
+    } catch (cause) {
+      const msg = cause instanceof Error ? cause.message : String(cause);
+      logger51.warn("Harness verify failed, treating as unresolved", {
+        instanceId: instance2.instance_id,
+        error: msg
+      });
+      return {
+        passed: false,
+        stderr: `Harness evaluation failed: ${msg}`,
+        stdout: ""
+      };
+    }
+  }
+};
+
 // src/swe-bench/nexus-agent-executor.ts
 var EXECUTOR_DEFAULTS = {
   modelId: getCliModelName(getDefaultModelForCli("claude")),
@@ -50674,8 +50913,8 @@ async function safeExec(command, timeoutMs = COMMAND_TIMEOUT_MS) {
 function bytesToGB(bytes) {
   return (bytes / BYTES_PER_GB).toFixed(1);
 }
-async function validatePython(logger54) {
-  const log3 = logger54 ?? createLogger({ component: "environment-validator" });
+async function validatePython(logger55) {
+  const log3 = logger55 ?? createLogger({ component: "environment-validator" });
   const pythonCommands = ["python3", "python3.11", "python3.10", "python"];
   for (const cmd of pythonCommands) {
     const result = await safeExec(`${cmd} --version`);
@@ -50699,8 +50938,8 @@ async function validatePython(logger54) {
   log3.warn("No compatible Python found (need 3.10 or 3.11)");
   return { available: false };
 }
-async function validateSwebench(logger54) {
-  const log3 = logger54 ?? createLogger({ component: "environment-validator" });
+async function validateSwebench(logger55) {
+  const log3 = logger55 ?? createLogger({ component: "environment-validator" });
   const result = await safeExec('python3 -c "import swebench; print(swebench.__version__)"');
   const importVersion = result?.stdout.trim();
   if (importVersion !== void 0 && importVersion !== "") {
@@ -50720,8 +50959,8 @@ async function validateSwebench(logger54) {
   log3.warn("swebench package not found");
   return { installed: false };
 }
-async function validateDocker(logger54) {
-  const log3 = logger54 ?? createLogger({ component: "environment-validator" });
+async function validateDocker(logger55) {
+  const log3 = logger55 ?? createLogger({ component: "environment-validator" });
   const versionResult = await safeExec('docker version --format "{{.Server.Version}}"');
   if (!versionResult) {
     log3.warn("Docker not available or daemon not running");
@@ -50744,8 +50983,8 @@ async function validateDocker(logger54) {
   log3.warn("Docker daemon not running");
   return { running: false };
 }
-async function validateDiskSpace(logger54) {
-  const log3 = logger54 ?? createLogger({ component: "environment-validator" });
+async function validateDiskSpace(logger55) {
+  const log3 = logger55 ?? createLogger({ component: "environment-validator" });
   const result = await safeExec("df -B1 . | tail -1");
   if (!result) {
     log3.warn("Could not determine disk space");
@@ -50796,8 +51035,8 @@ function collectWarnings(diskSpace) {
 }
 
 // src/swe-bench/environment-validator.ts
-async function validateEnvironment(logger54) {
-  const log3 = logger54 ?? createLogger({ component: "environment-validator" });
+async function validateEnvironment(logger55) {
+  const log3 = logger55 ?? createLogger({ component: "environment-validator" });
   log3.info("Validating SWE-bench environment");
   const [python, swebench, docker, diskSpace] = await Promise.all([
     validatePython(log3),
@@ -50925,7 +51164,7 @@ function mapResolutionStatus(raw) {
 import { exec as exec2 } from "child_process";
 import { promisify as promisify6 } from "util";
 var execAsync2 = promisify6(exec2);
-async function getSwebenchVersion(logger54) {
+async function getSwebenchVersion(logger55) {
   try {
     const result = await execAsync2(
       `${PYTHON_COMMAND} -c "import swebench; print(swebench.__version__)"`,
@@ -50933,15 +51172,15 @@ async function getSwebenchVersion(logger54) {
     );
     const version = result.stdout.trim();
     if (version) {
-      logger54?.debug("swebench version detected", { version });
+      logger55?.debug("swebench version detected", { version });
       return version;
     }
   } catch (err2) {
-    logger54?.debug("Failed to get swebench version", { error: String(err2) });
+    logger55?.debug("Failed to get swebench version", { error: String(err2) });
   }
   return null;
 }
-async function getPythonVersion(logger54) {
+async function getPythonVersion(logger55) {
   try {
     const result = await execAsync2(`${PYTHON_COMMAND} --version`, {
       timeout: QUICK_COMMAND_TIMEOUT_MS,
@@ -50949,15 +51188,15 @@ async function getPythonVersion(logger54) {
     });
     const match = result.stdout.trim().match(/Python\s+(\d+\.\d+\.\d+)/);
     if (match?.[1] !== void 0) {
-      logger54?.debug("Python version detected", { version: match[1] });
+      logger55?.debug("Python version detected", { version: match[1] });
       return match[1];
     }
   } catch (err2) {
-    logger54?.debug("Failed to get Python version", { error: String(err2) });
+    logger55?.debug("Failed to get Python version", { error: String(err2) });
   }
   return null;
 }
-async function getDockerVersion(logger54) {
+async function getDockerVersion(logger55) {
   try {
     const result = await execAsync2('docker version --format "{{.Server.Version}}"', {
       timeout: QUICK_COMMAND_TIMEOUT_MS,
@@ -50965,27 +51204,27 @@ async function getDockerVersion(logger54) {
     });
     const version = result.stdout.trim();
     if (version) {
-      logger54?.debug("Docker version detected", { version });
+      logger55?.debug("Docker version detected", { version });
       return version;
     }
   } catch (err2) {
-    logger54?.debug("Failed to get Docker version", { error: String(err2) });
+    logger55?.debug("Failed to get Docker version", { error: String(err2) });
   }
   return null;
 }
 
 // src/swe-bench/harness-output-parsing.ts
 import * as fs12 from "fs/promises";
-function parseHarnessOutput(output2, logger54) {
+function parseHarnessOutput(output2, logger55) {
   try {
     const parsed = JSON.parse(output2);
     if (!isValidHarnessOutput(parsed)) {
-      logger54?.warn("Invalid harness output structure");
+      logger55?.warn("Invalid harness output structure");
       return null;
     }
     return parsed;
   } catch (err2) {
-    logger54?.warn("Failed to parse harness output", { error: String(err2) });
+    logger55?.warn("Failed to parse harness output", { error: String(err2) });
     return null;
   }
 }
@@ -50994,12 +51233,12 @@ function isValidHarnessOutput(obj) {
   const o = obj;
   return typeof o.run_id === "string" && typeof o.dataset_name === "string" && typeof o.model_name_or_path === "string" && Array.isArray(o.instance_results);
 }
-async function parseHarnessLogFile(logPath, logger54) {
+async function parseHarnessLogFile(logPath, logger55) {
   try {
     const content = await fs12.readFile(logPath, "utf-8");
-    return parseHarnessOutput(content, logger54);
+    return parseHarnessOutput(content, logger55);
   } catch (err2) {
-    logger54?.warn("Failed to read harness log file", { logPath, error: String(err2) });
+    logger55?.warn("Failed to read harness log file", { logPath, error: String(err2) });
     return null;
   }
 }
@@ -51119,7 +51358,7 @@ function countValidPredictions(content) {
   const lines = content.trim().split("\n").filter(Boolean);
   return lines.filter(isValidPredictionLine).length;
 }
-async function validatePredictionsFile(predictionsPath, logger54) {
+async function validatePredictionsFile(predictionsPath, logger55) {
   try {
     const stat5 = await fs13.stat(predictionsPath);
     if (!stat5.isFile()) {
@@ -51130,19 +51369,19 @@ async function validatePredictionsFile(predictionsPath, logger54) {
     if (validCount === 0) {
       return { valid: false, lineCount: 0, error: "No valid predictions found" };
     }
-    logger54?.debug("Predictions file validated", { lineCount: validCount, path: predictionsPath });
+    logger55?.debug("Predictions file validated", { lineCount: validCount, path: predictionsPath });
     return { valid: true, lineCount: validCount };
   } catch (err2) {
     const errorMsg = err2 instanceof Error ? err2.message : String(err2);
     return { valid: false, lineCount: 0, error: errorMsg };
   }
 }
-async function ensureOutputDir(outputDir, logger54) {
+async function ensureOutputDir(outputDir, logger55) {
   try {
     await fs13.mkdir(outputDir, { recursive: true });
-    logger54?.debug("Output directory ensured", { path: outputDir });
+    logger55?.debug("Output directory ensured", { path: outputDir });
   } catch (err2) {
-    logger54?.warn("Failed to create output directory", { path: outputDir, error: String(err2) });
+    logger55?.warn("Failed to create output directory", { path: outputDir, error: String(err2) });
     throw new HarnessExecutorError(
       `Failed to create output directory: ${outputDir}`,
       "EXECUTION_FAILED",
@@ -51150,10 +51389,10 @@ async function ensureOutputDir(outputDir, logger54) {
     );
   }
 }
-function spawnHarnessProcess(config, logger54) {
+function spawnHarnessProcess(config, logger55) {
   const args = [HARNESS_SCRIPT.split(" ")[0] ?? "-m", ...HARNESS_SCRIPT.split(" ").slice(1)];
   args.push(...buildHarnessArgs(config));
-  logger54?.info("Spawning harness process", { command: PYTHON_COMMAND, args });
+  logger55?.info("Spawning harness process", { command: PYTHON_COMMAND, args });
   const proc = spawn(PYTHON_COMMAND, args, {
     stdio: ["ignore", "pipe", "pipe"],
     env: { ...process.env }
@@ -51241,20 +51480,20 @@ function handleProcessClose(options) {
     }
   });
 }
-async function handleProcessExitAsync(code, config, stderr, logger54) {
+async function handleProcessExitAsync(code, config, stderr, logger55) {
   if (code !== 0) {
-    logger54.error("Harness process failed", new Error(stderr), { exitCode: code });
+    logger55.error("Harness process failed", new Error(stderr), { exitCode: code });
     throw new HarnessExecutorError(
       `Harness process exited with code ${String(code)}`,
       "EXECUTION_FAILED"
     );
   }
-  return parseResultsFile(config, logger54);
+  return parseResultsFile(config, logger55);
 }
-async function parseResultsFile(config, logger54) {
+async function parseResultsFile(config, logger55) {
   const resultsPath = getResultsFilePath(config);
-  logger54.info("Parsing results file", { path: resultsPath });
-  const rawOutput = await parseHarnessLogFile(resultsPath, logger54);
+  logger55.info("Parsing results file", { path: resultsPath });
+  const rawOutput = await parseHarnessLogFile(resultsPath, logger55);
   if (rawOutput === null) {
     throw new HarnessExecutorError(`Failed to parse results from: ${resultsPath}`, "PARSE_ERROR");
   }
@@ -51312,8 +51551,8 @@ var HarnessExecutor = class {
   logger;
   currentProcess = null;
   isCancelled = false;
-  constructor(logger54) {
-    this.logger = logger54 ?? createLogger({ component: "harness-executor" });
+  constructor(logger55) {
+    this.logger = logger55 ?? createLogger({ component: "harness-executor" });
   }
   /**
    * Validates that the environment is ready for harness execution.
@@ -51465,11 +51704,11 @@ var HarnessExecutor = class {
 };
 
 // src/swe-bench/harness-executor-factory.ts
-function createHarnessExecutor(logger54) {
-  return new HarnessExecutor(logger54);
+function createHarnessExecutor(logger55) {
+  return new HarnessExecutor(logger55);
 }
-async function createValidatedExecutor(logger54) {
-  const executor = createHarnessExecutor(logger54);
+async function createValidatedExecutor(logger55) {
+  const executor = createHarnessExecutor(logger55);
   const validation = await executor.validate();
   return { executor, validation };
 }
@@ -51589,8 +51828,8 @@ var EvaluationHarness = class {
   logger;
   executor;
   isCancelled = false;
-  constructor(logger54) {
-    this.logger = logger54 ?? createLogger({ component: "evaluation-harness" });
+  constructor(logger55) {
+    this.logger = logger55 ?? createLogger({ component: "evaluation-harness" });
     this.executor = createHarnessExecutor(this.logger);
   }
   /**
@@ -51750,11 +51989,11 @@ var EvaluationHarness = class {
     return returnValue;
   }
 };
-function createEvaluationHarness(logger54) {
-  return new EvaluationHarness(logger54);
+function createEvaluationHarness(logger55) {
+  return new EvaluationHarness(logger55);
 }
-async function createValidatedHarness(logger54) {
-  const harness = createEvaluationHarness(logger54);
+async function createValidatedHarness(logger55) {
+  const harness = createEvaluationHarness(logger55);
   const validation = await harness.validate();
   if (!validation.ready) {
     return err(
@@ -52009,9 +52248,9 @@ function handlePatchError(err2, options) {
     backupCreated: options.createBackup && !options.dryRun
   };
 }
-async function executePatch(patchPath, options, reverse, logger54) {
+async function executePatch(patchPath, options, reverse, logger55) {
   const args = buildPatchArgs(patchPath, options, reverse);
-  logger54.debug("Executing patch command", { args, cwd: options.workDir });
+  logger55.debug("Executing patch command", { args, cwd: options.workDir });
   try {
     const { stdout, stderr } = await execFileAsync5("patch", args, {
       cwd: options.workDir,
@@ -52043,8 +52282,8 @@ ${stderr}`.trim();
 // src/swe-bench/patch-applicator.ts
 var PatchApplicator = class {
   logger;
-  constructor(logger54) {
-    this.logger = logger54 ?? createLogger({ component: "patch-applicator" });
+  constructor(logger55) {
+    this.logger = logger55 ?? createLogger({ component: "patch-applicator" });
   }
   /**
    * Validates a patch without applying it.
@@ -52120,8 +52359,8 @@ var PatchApplicator = class {
     };
   }
 };
-function createPatchApplicator(logger54) {
-  return new PatchApplicator(logger54);
+function createPatchApplicator(logger55) {
+  return new PatchApplicator(logger55);
 }
 function validatePatch(patch) {
   return parsePatch(patch);
@@ -52320,9 +52559,9 @@ function attachOutputCapture(proc, maxOutputBytes) {
   };
 }
 function executeInDocker(options) {
-  const { command, config, startTime, state, createCancelledResult: createCancelledResult2, handleTestError, logger: logger54 } = options;
+  const { command, config, startTime, state, createCancelledResult: createCancelledResult2, handleTestError, logger: logger55 } = options;
   const image = config.dockerImage ?? "python:3.11-slim";
-  logger54.debug("Executing tests in Docker", { image, command });
+  logger55.debug("Executing tests in Docker", { image, command });
   const dockerArgs = buildDockerArgs(command, config, image);
   return new Promise((resolve18) => {
     const proc = spawn2("docker", dockerArgs, {
@@ -52379,8 +52618,8 @@ var TestRunner = class {
     currentProcess: null,
     isCancelled: false
   };
-  constructor(logger54) {
-    this.logger = logger54 ?? createLogger({ component: "test-runner" });
+  constructor(logger55) {
+    this.logger = logger55 ?? createLogger({ component: "test-runner" });
   }
   /**
    * Detects the test framework used by the repository.
@@ -52601,8 +52840,8 @@ ${stderr}`.trim();
     };
   }
 };
-function createTestRunner(logger54) {
-  return new TestRunner(logger54);
+function createTestRunner(logger55) {
+  return new TestRunner(logger55);
 }
 async function runTests(workDir, options) {
   const runner = createTestRunner();
@@ -52911,8 +53150,8 @@ function identifyWeaknesses(result, competitors) {
 // src/swe-bench/report-generator.ts
 var ReportGenerator = class {
   logger;
-  constructor(logger54) {
-    this.logger = logger54 ?? createLogger({ component: "report-generator" });
+  constructor(logger55) {
+    this.logger = logger55 ?? createLogger({ component: "report-generator" });
   }
   /**
    * Generates a full evaluation report.
@@ -53175,8 +53414,8 @@ var ReportGenerator = class {
     };
   }
 };
-function createReportGenerator(logger54) {
-  return new ReportGenerator(logger54);
+function createReportGenerator(logger55) {
+  return new ReportGenerator(logger55);
 }
 async function generateReport(result, config, competitors) {
   const generator = createReportGenerator();
@@ -53323,7 +53562,7 @@ var TraceLogger = class {
 };
 
 // src/pipeline/event-bus-bridge.ts
-var logger51 = createLogger({ component: "EventBusBridge" });
+var logger52 = createLogger({ component: "EventBusBridge" });
 function toV1Topic(prefix, event) {
   return `${prefix}.${event.type}`;
 }
@@ -53355,10 +53594,10 @@ function createEventBusBridge(options) {
       forwardCount++;
     } catch (error) {
       const msg = getErrorMessage(error);
-      logger51.warn("Failed to forward pipeline event", { type: event.type, error: msg });
+      logger52.warn("Failed to forward pipeline event", { type: event.type, error: msg });
     }
   });
-  logger51.info("EventBus bridge initialized", { prefix });
+  logger52.info("EventBus bridge initialized", { prefix });
   return {
     forwarded: () => forwardCount,
     dispose: unsub
@@ -53366,7 +53605,7 @@ function createEventBusBridge(options) {
 }
 
 // src/adapters/stdin-lifecycle.ts
-var logger52 = createLogger({ component: "StdinLifecycleMonitor" });
+var logger53 = createLogger({ component: "StdinLifecycleMonitor" });
 var StdinLifecycleMonitor = class {
   callbacks = /* @__PURE__ */ new Set();
   started = false;
@@ -53391,7 +53630,7 @@ var StdinLifecycleMonitor = class {
       try {
         await cb();
       } catch (error) {
-        logger52.warn("Stdin shutdown callback failed", { error: String(error) });
+        logger53.warn("Stdin shutdown callback failed", { error: String(error) });
       }
     }
   }
@@ -53405,7 +53644,7 @@ function getStdinLifecycleMonitor() {
 // src/pipeline/task-tracker.ts
 import * as fs18 from "fs";
 import * as path19 from "path";
-var logger53 = createLogger({ component: "task-tracker" });
+var logger54 = createLogger({ component: "task-tracker" });
 async function exec4(cmd, args, timeout = 15e3) {
   const { execFile: execFile6 } = await import("child_process");
   const { promisify: promisify9 } = await import("util");
@@ -53431,7 +53670,7 @@ var GitHubTaskTracker = class {
     const result = await provider.createIssue(title, body, this.config.labels);
     if (!result.ok) throw new Error("Failed to create issue");
     const id = String(result.value.number);
-    logger53.info("Created GitHub issue via SCM provider", { id });
+    logger54.info("Created GitHub issue via SCM provider", { id });
     return { id, title, status: "open", url: result.value.url };
   }
   async updateStatus(taskId, status) {
@@ -53459,7 +53698,7 @@ var GitLabTaskTracker = class {
     );
     const match = /\/(\d+)$/.exec(url);
     const id = match?.[1] ?? url;
-    logger53.info("Created GitLab issue", { id, url });
+    logger54.info("Created GitLab issue", { id, url });
     return { id, title, status: "open", url };
   }
   async updateStatus(taskId, status) {
@@ -54165,6 +54404,8 @@ export {
   AgentRunnerError,
   runAgentOnInstance,
   createMockExecutor,
+  translateEvaluationResult,
+  HarnessVerifyAdapter,
   NexusAgentExecutor,
   createNexusExecutorFromEnv,
   CliAgentExecutor,
@@ -54260,4 +54501,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-ZGKZIEUM.js.map
+//# sourceMappingURL=chunk-APQJV46Q.js.map