nexus-agents 2.88.1 → 2.89.1

package/dist/{chunk-K5KMPKKG.js → chunk-RAUA6B2M.js}

@@ -42,7 +42,7 @@ import {
   writeJobComplete,
   writeJobFailed,
   writeJobPending
-} from "./chunk-QA6YV4YF.js";
+} from "./chunk-7QTWFRHH.js";
 import {
   REGISTRY_PATH,
   getProjectRoot,
@@ -82,7 +82,7 @@ import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-VTVZRR5E.js";
+} from "./chunk-MXHJMSYQ.js";
 import {
   getAvailabilityCache,
   resolveFallback
@@ -1116,12 +1116,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;
@@ -1134,7 +1134,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
@@ -1192,7 +1192,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);
@@ -1209,7 +1209,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,
@@ -1672,7 +1672,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),
@@ -1681,13 +1681,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;
   }
 }
@@ -1743,8 +1743,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,
@@ -1773,9 +1773,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.
@@ -1928,7 +1928,7 @@ var TokenBudgetTracker = class {
 
 // src/agents/base-agent-state-helpers.ts
 function transitionToState(params) {
-  const { stateMachine, logger: logger54, newState } = params;
+  const { stateMachine, logger: logger55, newState } = params;
   const currentState = stateMachine.state;
   if (newState === "error") {
     stateMachine.forceError({ reason: "transitionToState called with error" });
@@ -1938,7 +1938,7 @@ function transitionToState(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,
@@ -1946,7 +1946,7 @@ function transitionToState(params) {
       });
     }
   } else if (currentState !== newState) {
-    logger54.debug("Unmapped state change", { from: currentState, to: newState });
+    logger55.debug("Unmapped state change", { from: currentState, to: newState });
   }
 }
 
@@ -2102,7 +2102,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,
@@ -2114,12 +2114,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,
@@ -2127,16 +2127,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 = {
@@ -2147,7 +2147,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,
@@ -2155,13 +2155,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))]
@@ -2275,10 +2275,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
@@ -2292,9 +2292,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 } : {}
   };
@@ -2302,7 +2302,7 @@ function initializeInfrastructure(params) {
   const memoryOpts = {
     agentId,
     role,
-    logger: logger54,
+    logger: logger55,
     ...memoryConfig !== void 0 ? { config: memoryConfig } : {}
   };
   const memory = initializeMemoryInfrastructure(memoryOpts);
@@ -2534,14 +2534,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,
@@ -2569,7 +2569,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;
   }
@@ -2584,9 +2584,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
   });
@@ -2597,15 +2597,15 @@ function categorizeTaskType(description2) {
   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
@@ -2748,14 +2748,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;
@@ -4018,13 +4018,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 });
     }
   }
 }
@@ -7699,9 +7699,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.
@@ -7935,8 +7935,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
@@ -12797,9 +12797,9 @@ var SkillLibrary = class {
   config;
   logger;
   store;
-  constructor(config = {}, logger54) {
+  constructor(config = {}, logger55) {
     this.config = { ...DEFAULT_SKILL_LIBRARY_CONFIG, ...config };
-    this.logger = logger54 ?? createLogger({ component: "SkillLibrary" });
+    this.logger = logger55 ?? createLogger({ component: "SkillLibrary" });
     this.store = {
       skills: /* @__PURE__ */ new Map(),
       executions: /* @__PURE__ */ new Map(),
@@ -13117,8 +13117,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
@@ -13133,10 +13133,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.
@@ -13366,8 +13366,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
@@ -14062,10 +14062,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);
@@ -14288,8 +14288,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
@@ -14351,13 +14351,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);
@@ -14367,7 +14367,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
@@ -14388,22 +14388,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)
@@ -15311,9 +15311,9 @@ var SicaVersionManager = class {
   versions;
   events;
   activeVersionId;
-  constructor(config = {}, logger54) {
+  constructor(config = {}, logger55) {
     this.config = { ...DEFAULT_SICA_CONFIG, ...config };
-    this.logger = logger54 ?? createLogger({ component: "SicaVersionManager" });
+    this.logger = logger55 ?? createLogger({ component: "SicaVersionManager" });
     this.versions = /* @__PURE__ */ new Map();
     this.events = [];
     this.activeVersionId = null;
@@ -19722,9 +19722,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;
@@ -19736,8 +19736,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)
         });
@@ -20589,11 +20589,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;
@@ -20903,10 +20903,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,
@@ -20916,14 +20916,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
@@ -20959,15 +20959,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;
@@ -21002,12 +21002,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,
@@ -21027,7 +21027,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
@@ -21036,10 +21036,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;
@@ -21339,29 +21339,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();
@@ -21377,7 +21377,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
       });
@@ -21437,10 +21437,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
@@ -21449,16 +21449,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");
@@ -21469,9 +21469,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
@@ -21522,26 +21522,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
@@ -21572,32 +21572,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(
@@ -21679,23 +21679,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,
@@ -21708,8 +21708,8 @@ function createTimer() {
     elapsed: () => getTimeProvider().now() - startTime
   };
 }
-function withLogging(toolName, handler3, logger54) {
-  const toolLogger = createToolLogger(logger54, toolName);
+function withLogging(toolName, handler3, logger55) {
+  const toolLogger = createToolLogger(logger55, toolName);
   return async (args) => {
     const timer = createTimer();
     logToolStart(toolLogger, toolName, args);
@@ -21794,9 +21794,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();
   }
   /**
@@ -21895,19 +21895,19 @@ 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 toolStructuredError({ errorCategory: "internal", message: `${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);
   }
 }
 
@@ -24387,47 +24387,47 @@ function createSubscriptions(eventBus, subs, handler3) {
   }
   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 handler3 = (event) => {
-    handleEvent(event, observer, logger54, logConfig);
+    handleEvent(event, observer, logger55, logConfig);
   };
   const subscriptions = createSubscriptions(eventBus, mergedConfig.subscriptions, handler3);
-  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 = {
@@ -24438,9 +24438,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);
 }
@@ -24618,19 +24618,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,
     {
@@ -24638,7 +24638,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,
@@ -24678,7 +24678,7 @@ function buildModelsPayload() {
     }))
   };
 }
-function registerModelsResource(server, logger54) {
+function registerModelsResource(server, logger55) {
   server.registerResource(
     MODELS_RESOURCE_NAME,
     MODELS_RESOURCE_URI,
@@ -24687,7 +24687,7 @@ function registerModelsResource(server, logger54) {
       mimeType: "application/json"
     },
     () => {
-      logger54.debug("Reading models resource");
+      logger55.debug("Reading models resource");
       const payload = buildModelsPayload();
       return {
         contents: [
@@ -24700,7 +24700,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
@@ -25511,10 +25511,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 {
@@ -25548,7 +25548,7 @@ function buildResearchPayload(logger54) {
     stats: index.stats
   };
 }
-function registerResearchResource(server, logger54) {
+function registerResearchResource(server, logger55) {
   server.registerResource(
     RESEARCH_RESOURCE_NAME,
     RESEARCH_RESOURCE_URI,
@@ -25557,9 +25557,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: [
             {
@@ -25570,7 +25570,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 {
@@ -25585,7 +25585,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
@@ -25686,29 +25686,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];
@@ -25717,7 +25717,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];
 }
 
@@ -25823,16 +25823,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;
   }
@@ -25906,7 +25906,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: z44.enum([
       "code_expert",
@@ -25926,23 +25926,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: description2, inputSchema: toolSchema, annotations: getToolAnnotations("create_expert") },
     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() {
@@ -25977,7 +25977,7 @@ function buildExpertsPayload() {
     experts
   };
 }
-function registerExpertsResource(server, logger54) {
+function registerExpertsResource(server, logger55) {
   server.registerResource(
     EXPERTS_RESOURCE_NAME,
     EXPERTS_RESOURCE_URI,
@@ -25986,7 +25986,7 @@ function registerExpertsResource(server, logger54) {
       mimeType: "application/json"
     },
     () => {
-      logger54.debug("Reading experts resource");
+      logger55.debug("Reading experts resource");
       const payload = buildExpertsPayload();
       return {
         contents: [
@@ -25999,12 +25999,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 log = logger54 ?? createLogger({ component: "mcp-resources" });
+function registerResources(server, logger55) {
+  const log = logger55 ?? createLogger({ component: "mcp-resources" });
   log.info("Registering MCP resources");
   registerModelsResource(server, log);
   registerResearchResource(server, log);
@@ -26156,11 +26156,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
     });
@@ -26179,8 +26179,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) {
@@ -26204,9 +26204,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);
@@ -26257,8 +26257,8 @@ function formatValidationErrors(validation) {
 // src/mcp/tools/run-workflow.ts
 import { randomUUID as randomUUID8 } from "crypto";
 async function executeWorkflow(deps, workflow, inputs, options) {
-  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,
     ...options?.phaseTimeoutMs !== void 0 ? { phaseTimeoutMs: options.phaseTimeoutMs } : {}
@@ -26266,7 +26266,7 @@ async function executeWorkflow(deps, workflow, inputs, options) {
   const startTime = getTimeProvider().now();
   const result = options?.phaseTimeoutMs !== void 0 ? await workflowEngine.execute(workflow, inputs, { phaseTimeoutMs: options.phaseTimeoutMs }) : 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 {
@@ -26275,7 +26275,7 @@ async function executeWorkflow(deps, workflow, inputs, options) {
     };
   }
   const workflowResult = result.value;
-  logger54?.info("Workflow completed", {
+  logger55?.info("Workflow completed", {
     workflowName: workflow.name,
     durationMs: getTimeProvider().now() - startTime,
     stepCount: workflowResult.stepResults.length
@@ -26481,16 +26481,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",
     {
@@ -26498,9 +26498,9 @@ function registerRunWorkflowTool(server, deps) {
       inputSchema: toolInputSchema,
       annotations: getToolAnnotations("run_workflow")
     },
-    toSdkCallbackWithBudgetCheck(wrappedHandler, "run_workflow", timeoutMs, logger54)
+    toSdkCallbackWithBudgetCheck(wrappedHandler, "run_workflow", timeoutMs, logger55)
   );
-  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
@@ -28818,8 +28818,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;
@@ -28959,10 +28959,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") {
@@ -29154,22 +29154,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
     });
   }
@@ -29180,12 +29180,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);
@@ -29227,7 +29227,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 = [];
@@ -29237,7 +29237,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,
@@ -29247,7 +29247,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",
@@ -29626,11 +29626,11 @@ function setAnalysis(snapshot, analysis) {
 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)"
@@ -29638,7 +29638,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
@@ -29656,18 +29656,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
   });
@@ -29687,9 +29687,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 {
@@ -29743,7 +29743,7 @@ var PersistedCatalogSchema = z51.object({
 function getCatalogPath() {
   return nexusDataPath(CATALOG_SUBDIR, CATALOG_FILE);
 }
-function loadPersistedCatalog(logger54) {
+function loadPersistedCatalog(logger55) {
   const filePath = getCatalogPath();
   try {
     if (!fs4.existsSync(filePath)) return [];
@@ -29751,21 +29751,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 = nexusDataPath(CATALOG_SUBDIR);
   const filePath = getCatalogPath();
   const tempPath = `${filePath}.tmp.${String(process.pid)}`;
@@ -29787,7 +29787,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;
@@ -29797,8 +29797,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));
@@ -29953,8 +29953,8 @@ var ResearchAutoCatalog = class _ResearchAutoCatalog {
   }
 };
 var autoCatalogInstance;
-function getAutoCatalog(logger54) {
-  autoCatalogInstance ??= new ResearchAutoCatalog(logger54);
+function getAutoCatalog(logger55) {
+  autoCatalogInstance ??= new ResearchAutoCatalog(logger55);
   return autoCatalogInstance;
 }
 
@@ -31761,12 +31761,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;
@@ -31778,9 +31778,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,
@@ -31788,7 +31788,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;
@@ -31868,7 +31868,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, signal) => {
     const workerStartMs = getTimeProvider().now();
@@ -31877,7 +31877,7 @@ function createWorkerExecutor(config) {
       modelAdapter,
       effectiveFallbackCli,
       perWorkerRouting === true,
-      logger54
+      logger55
     );
     return executeOnAdapter({
       entry,
@@ -32053,15 +32053,15 @@ function prepareBudgetedEntries(plan, maxCalls, log) {
   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 } : {}
   };
@@ -32082,8 +32082,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 } : {},
@@ -32141,18 +32141,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,
@@ -32947,7 +32947,12 @@ var TaskStageSchema = z55.enum([
   "executing",
   "verifying",
   "complete",
-  "blocked"
+  "blocked",
+  // #3091 / epic #2631: terminal failure stage. Distinct from `blocked`
+  // (recoverable, still in-flight) — `failed` is terminal and maps to the
+  // job-result `failed` status. Added so async-mode writers can record a
+  // failed run in StructuredTaskState instead of the Stage-1 sidecar.
+  "failed"
 ]);
 var TaskDecisionSchema = z55.object({
   ts: z55.iso.datetime(),
@@ -32996,6 +33001,7 @@ var TaskCancellationSchema = z55.object({
   /** Optional human-readable note carried back to the caller. */
   reason: z55.string().max(1e3).optional()
 });
+var TASK_RESULT_MAX_BYTES = 1048576;
 var StructuredTaskStateSchema = z55.object({
   taskId: z55.string().min(1),
   stage: TaskStageSchema,
@@ -33048,6 +33054,15 @@ var StructuredTaskStateSchema = z55.object({
    * second cancellation event).
    */
   cancellation: TaskCancellationSchema.optional(),
+  /**
+   * Creation timestamp (#3090 / epic #2631). Set by the reducer to the
+   * `init` entry's `ts` and never mutated thereafter — `updatedAt` advances
+   * with each write, but `createdAt` is fixed. Job-result readers need the
+   * original creation time; `updatedAt` alone can't supply it once any
+   * transition has been recorded. Optional for backward-compat with
+   * pre-#3090 logs (the reducer backfills it from the init entry).
+   */
+  createdAt: z55.iso.datetime().optional(),
   updatedAt: z55.iso.datetime()
 });
 var StructuredTaskLogEntrySchema = z55.discriminatedUnion("event", [
@@ -33170,6 +33185,31 @@ function appendBlocker(taskId, blocker, customDir) {
 function updateStage(taskId, stage, ts, customDir) {
   return appendLogEntry(taskId, { event: "stage", ts, stage }, customDir);
 }
+function appendResult(taskId, result, ts, customDir) {
+  let payload = result;
+  let serialized;
+  try {
+    serialized = JSON.stringify(result ?? null);
+  } catch (cause) {
+    const e = cause instanceof Error ? cause : new Error(String(cause));
+    return err(new Error(`Failed to serialize result for task ${taskId}: ${e.message}`));
+  }
+  const bytes = Buffer.byteLength(serialized, "utf-8");
+  if (bytes > TASK_RESULT_MAX_BYTES) {
+    payload = {
+      truncated: true,
+      originalBytes: bytes,
+      maxBytes: TASK_RESULT_MAX_BYTES,
+      note: "Result exceeded TASK_RESULT_MAX_BYTES \u2014 original dropped at write time."
+    };
+    logger30.warn("Task result truncated at write", {
+      taskId,
+      bytes,
+      max: TASK_RESULT_MAX_BYTES
+    });
+  }
+  return appendLogEntry(taskId, { event: "result", ts, result: payload }, customDir);
+}
 function readTaskState(taskId, customDir) {
   const idCheck = validateTaskId(taskId);
   if (!idCheck.ok) return err(idCheck.error);
@@ -33220,7 +33260,11 @@ function reduceLogEntries(taskId, entries) {
     ...initState,
     decisions: [...initState.decisions],
     blockers: initState.blockers.map((b) => ({ ...b })),
-    version: initState.version ?? 0
+    version: initState.version ?? 0,
+    // #3090: createdAt is fixed at the init entry's ts and never advances
+    // (unlike updatedAt). Prefer an explicit createdAt on the init state,
+    // else fall back to the init entry's ts.
+    createdAt: initState.createdAt ?? init.ts
   };
   for (const entry of entries) {
     if (entry === init) continue;
@@ -33319,7 +33363,6 @@ function applyLogEntry(state, entry) {
 }
 
 // src/mcp/tools/orchestrate.ts
-import { randomUUID as randomUUID11 } from "crypto";
 function generateTaskId() {
   const timestamp = getTimeProvider().now().toString(36);
   const random = getRandomProvider().random().toString(36).substring(2, 8);
@@ -33415,10 +33458,10 @@ 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 = createOrchestratorWithSica(logger54, deps.modelAdapter);
-  const factory = new OrchestratorFactory({ logger: logger54, techLead });
+  const techLead = createOrchestratorWithSica(logger55, deps.modelAdapter);
+  const factory = new OrchestratorFactory({ logger: logger55, techLead });
   return factory.create(orchestratorType ?? "orchestrator");
 }
 function createErrorOptions(taskId, cause) {
@@ -33530,16 +33573,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 {
@@ -33558,10 +33601,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(
@@ -33570,13 +33613,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 {
@@ -33647,9 +33690,10 @@ function handleOrchestratorSuccess(ctx) {
   });
   return ok(output2);
 }
-async function executeOrchestration(input, deps, router, snapshot, trustTier) {
-  const { workflowRouter, decision, orchestrator, logger: logger54 } = routeAndPrepare(input, deps, router);
-  const taskId = generateTaskId();
+async function executeOrchestration(input, deps, opts = {}) {
+  const { router, snapshot, trustTier, taskId: providedTaskId } = opts;
+  const { workflowRouter, decision, orchestrator, logger: logger55 } = routeAndPrepare(input, deps, router);
+  const taskId = providedTaskId ?? generateTaskId();
   const startTime = getTimeProvider().now();
   if (snapshot !== void 0) setRouting(snapshot, buildRoutingInfo(decision));
   const fastResult = trySimpleTaskFastPath({
@@ -33658,18 +33702,18 @@ async function executeOrchestration(input, deps, router, snapshot, trustTier) {
     decision,
     workflowRouter,
     startTime,
-    logger: logger54
+    logger: logger55
   });
   if (fastResult !== void 0) {
     if (snapshot !== void 0 && fastResult.ok) setAnalysis(snapshot, fastResult.value.analysis);
     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, trustTier);
+  const hb = startHeartbeatTracking(`orchestrate-${taskId}`, logger55);
+  const policy = await deriveOrchestratePolicy(input.task, deps, logger55, trustTier);
   try {
     return await runOrchestratorWithStateTracking({
       taskId,
@@ -33680,23 +33724,23 @@ async function executeOrchestration(input, deps, router, snapshot, trustTier) {
       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, "failed", 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, "failed", logger55);
     return handleOrchestratorFailure({
       error: result.error,
       taskId,
@@ -33704,10 +33748,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,
@@ -33715,7 +33759,7 @@ async function runOrchestratorWithStateTracking(params) {
     decision: params.decision,
     workflowRouter: params.workflowRouter,
     startTime: params.startTime,
-    logger: logger54
+    logger: logger55
   });
 }
 function isTaskStateEnabled() {
@@ -33724,7 +33768,7 @@ function isTaskStateEnabled() {
   const normalized = raw.toLowerCase();
   return normalized !== "0" && normalized !== "false";
 }
-function recordTaskStateInit(taskId, taskText, logger54) {
+function recordTaskStateInit(taskId, taskText, logger55) {
   if (!isTaskStateEnabled()) return;
   const now = getTimeProvider().nowIso();
   const initial = {
@@ -33737,36 +33781,48 @@ 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, getTimeProvider().nowIso());
   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 = getTimeProvider().nowIso();
   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, trustTier) {
+function recordTaskStateResult(taskId, result, logger55) {
+  if (!isTaskStateEnabled()) return;
+  const r = appendResult(taskId, result, getTimeProvider().nowIso());
+  if (!r.ok) {
+    logger55.warn("task-state: result record failed", { taskId, error: r.error.message });
+  }
+}
+function recordTaskStateFailure(taskId, message, logger55) {
+  if (!isTaskStateEnabled()) return;
+  recordTaskStateBlocker(taskId, message, logger55);
+  recordTaskStateStage(taskId, "failed", logger55);
+}
+async function deriveOrchestratePolicy(taskText, deps, logger55, trustTier) {
   const mode = resolveAccessPolicyMode();
   try {
     const opts = {
@@ -33776,7 +33832,7 @@ async function deriveOrchestratePolicy(taskText, deps, logger54, trustTier) {
     };
     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 === "*"
@@ -33784,7 +33840,7 @@ async function deriveOrchestratePolicy(taskText, deps, logger54, trustTier) {
     }
     return policy;
   } catch (error) {
-    logger54.warn("access-policy: derivation failed", {
+    logger55.warn("access-policy: derivation failed", {
       mode,
       error: getErrorMessage(error),
       failClosed: mode === "enforce" || mode === "confirm_risky"
@@ -33811,22 +33867,22 @@ async function deriveOrchestratePolicy(taskText, deps, logger54, trustTier) {
     };
   }
 }
-function instrumentV2Orchestrate(input, logger54, trustTier) {
+function instrumentV2Orchestrate(input, logger55, trustTier) {
   const tc = orchestrateInputToTaskContract(input, trustTier !== void 0 ? { trustTier } : {});
   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;
   }
   const abortSignal = abortSignalStorage.getStore();
   if (abortSignal?.aborted === true) {
-    logger54.info("Worker dispatch aborted before start (client cancelled)");
+    logger55.info("Worker dispatch aborted before start (client cancelled)");
     return void 0;
   }
   try {
@@ -33837,14 +33893,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;
@@ -33905,22 +33961,26 @@ function buildTimeoutOrchestrationResult(taskId, elapsedMs, reason, snapshot) {
   return ok(output2);
 }
 async function executeOrchestrationWithDeadline(params) {
-  const { input, deps, notifier, logger: logger54, trustTier } = params;
+  const { input, deps, notifier, logger: logger55, trustTier, taskId } = params;
   const overallDeadlineMs = getMcpSafeDeadlineMs(
     MCP_TIMEOUTS.perTool["orchestrate"] ?? MCP_TIMEOUTS.defaultMs,
     "orchestrate"
   );
-  const timeoutTaskId = generateTaskId();
+  const timeoutTaskId = taskId ?? generateTaskId();
   const snapshot = createOrchestrationStateSnapshot(getTimeProvider().now());
   return raceAgainstDeadline(
     withProgressHeartbeat(
       "orchestrate",
       notifier,
-      () => executeOrchestration(input, deps, void 0, snapshot, trustTier)
+      () => executeOrchestration(input, deps, {
+        snapshot,
+        ...trustTier !== void 0 ? { trustTier } : {},
+        ...taskId !== void 0 ? { taskId } : {}
+      })
     ),
     overallDeadlineMs,
     (elapsedMs) => {
-      logger54.warn("Orchestration overall deadline reached; returning partial result", {
+      logger55.warn("Orchestration overall deadline reached; returning partial result", {
         overallDeadlineMs,
         elapsedMs,
         stage: snapshot.stage
@@ -33935,19 +33995,19 @@ async function executeOrchestrationWithDeadline(params) {
   );
 }
 async function runOrchestratePipeline(params) {
-  const { input, deps, notifier, logger: logger54, trustTier } = params;
-  logger54.debug("Starting orchestration", { taskLength: input.task.length });
+  const { input, deps, notifier, logger: logger55, trustTier, taskId } = params;
+  logger55.debug("Starting orchestration", { taskLength: input.task.length });
   notifier.info("orchestrate", { event: "orchestrate_start", taskLength: input.task.length });
   const startMs = getTimeProvider().now();
   const v2Config = resolveV2Config();
-  if (v2Config.orchestrateEnabled) instrumentV2Orchestrate(input, logger54, trustTier);
-  await injectMemoryContextForOrchestrate(input, logger54);
-  const agentPlan = v2Config.aorchestraEnabled ? computeAgentPlan(input.task, logger54) : void 0;
+  if (v2Config.orchestrateEnabled) instrumentV2Orchestrate(input, logger55, trustTier);
+  await injectMemoryContextForOrchestrate(input, logger55);
+  const agentPlan = v2Config.aorchestraEnabled ? computeAgentPlan(input.task, logger55) : void 0;
   const workerDispatchResult = await tryWorkerDispatch(
     agentPlan,
     input.task,
     deps,
-    logger54,
+    logger55,
     notifier
   );
   recordAndReflect(workerDispatchResult, input.task, deps);
@@ -33955,8 +34015,9 @@ async function runOrchestratePipeline(params) {
     input,
     deps,
     notifier,
-    logger: logger54,
-    ...trustTier !== void 0 ? { trustTier } : {}
+    logger: logger55,
+    ...trustTier !== void 0 ? { trustTier } : {},
+    ...taskId !== void 0 ? { taskId } : {}
   });
   if (!result.ok) {
     return toolStructuredError({
@@ -33971,15 +34032,15 @@ async function runOrchestratePipeline(params) {
   });
   return assembleOrchestrateOutput(result.value, agentPlan, workerDispatchResult);
 }
-async function injectMemoryContextForOrchestrate(input, logger54) {
+async function injectMemoryContextForOrchestrate(input, logger55) {
   try {
     const ctx = await getContextForTask({
       task: input.task,
       category: inferTaskCategory(input.task),
-      logger: logger54
+      logger: logger55
     });
     const summary = summarizeContextForPrompt(ctx);
-    logger54.debug("orchestrate: unified memory context", {
+    logger55.debug("orchestrate: unified memory context", {
       beliefs: ctx.beliefs.length,
       similarMemories: ctx.similarMemories.length,
       recentLearnings: ctx.recentLearnings.length,
@@ -33992,7 +34053,7 @@ async function injectMemoryContextForOrchestrate(input, logger54) {
       mutable.context = { ...mutable.context ?? {}, priorMemorySummary: summary };
     }
   } catch (error) {
-    logger54.debug("orchestrate: context retrieval failed", { error: getErrorMessage(error) });
+    logger55.debug("orchestrate: context retrieval failed", { error: getErrorMessage(error) });
   }
 }
 function createOrchestrateHandler(deps) {
@@ -34055,7 +34116,11 @@ function dispatchAsyncOrchestrate(params) {
     tool: "orchestrate",
     idempotencyKey: params.input.idempotencyKey,
     inputs: params.input,
-    freshJobId: () => `job-orch-${randomUUID11()}`,
+    // #3091: jobId === taskId. The async job's id IS the orchestration's
+    // taskId, so get_job_result(jobId) resolves directly from the task-state
+    // log (orch-<ts>-<rand>) under the Stage-2 reader. Replaces the former
+    // opaque `job-orch-<uuid>` id.
+    freshJobId: () => generateTaskId(),
     replayEnvelope: buildReplayEnvelope,
     collisionEnvelope: buildCollisionEnvelope
   });
@@ -34088,6 +34153,7 @@ function recordPendingAndRegister(jobId, key, inputs) {
   }
 }
 async function runOrchestrateInBackground(jobId, params) {
+  const taskId = jobId;
   try {
     const result = await withDepthGuard(
       "orchestrate",
@@ -34096,20 +34162,23 @@ async function runOrchestrateInBackground(jobId, params) {
         deps: params.deps,
         notifier: params.notifier,
         logger: params.logger,
+        taskId,
         ...params.trustTier !== void 0 ? { trustTier: params.trustTier } : {}
       })
     );
     writeJobComplete(jobId, "orchestrate", result);
+    recordTaskStateResult(taskId, result, params.logger);
   } catch (err2) {
     const errObj = err2 instanceof Error ? err2 : new Error(String(err2));
     params.logger.error("Async orchestrate dispatch failed", errObj, { jobId });
     writeJobFailed(jobId, "orchestrate", errObj.message);
+    recordTaskStateFailure(taskId, errObj.message, params.logger);
   } finally {
     release("orchestrate");
   }
 }
 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 description2 = "Orchestrate a task by analyzing it, breaking it into subtasks if needed, and coordinating expert agents";
@@ -34117,12 +34186,12 @@ function registerOrchestrateTool(server, deps) {
     toolName: "orchestrate",
     securityTier: "user-facing",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const configuredTimeoutMs = MCP_TIMEOUTS.perTool["orchestrate"] ?? MCP_TIMEOUTS.defaultMs;
   const wrappedHandler = wrapToolWithTimeout("orchestrate", secureHandler, {
     timeoutMs: configuredTimeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "orchestrate",
@@ -34131,9 +34200,9 @@ function registerOrchestrateTool(server, deps) {
       inputSchema: ORCHESTRATE_TOOL_SCHEMA,
       annotations: getToolAnnotations("orchestrate")
     },
-    toSdkCallbackWithBudgetCheck(wrappedHandler, "orchestrate", configuredTimeoutMs, logger54)
+    toSdkCallbackWithBudgetCheck(wrappedHandler, "orchestrate", configuredTimeoutMs, logger55)
   );
-  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
@@ -34496,21 +34565,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;
@@ -34523,13 +34592,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) });
   }
 }
 
@@ -34550,9 +34619,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 log = logger54 ?? createLogger({ component: "governance" });
+  const log = logger55 ?? createLogger({ component: "governance" });
   log.warn("Governance promotion", {
     tool: toolName,
     domain: classification.domain,
@@ -34623,9 +34692,9 @@ function recordToMemory(task, model, usedRouter) {
     });
   }
 }
-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) {
@@ -34639,12 +34708,12 @@ function enrichWithGovernance(output2, governance) {
     }
   };
 }
-function instrumentV2Pipeline(input, logger54, trustTier) {
+function instrumentV2Pipeline(input, logger55, trustTier) {
   const tc = delegateInputToTaskContract(input, trustTier !== void 0 ? { trustTier } : {});
   void executeDelegatePipeline(tc).then((m) => {
-    logger54.info("V2 delegate pipeline", { ...m });
+    logger55.info("V2 delegate pipeline", { ...m });
   }).catch((error) => {
-    logger54.warn("V2 delegate instrumentation failed", { error: getErrorMessage(error) });
+    logger55.warn("V2 delegate instrumentation failed", { error: getErrorMessage(error) });
   });
 }
 function notifyAndRecord(opts) {
@@ -34720,18 +34789,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",
@@ -34743,7 +34812,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
@@ -35685,7 +35754,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: z57.enum(["full", "names"]).optional().describe("Output format: full (with details) or names (just role names)")
   };
@@ -35693,10 +35762,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: z57.array(
       z57.object({
@@ -35718,7 +35787,7 @@ function registerListExpertsTool(server, deps) {
     },
     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
@@ -35777,7 +35846,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: z58.string().optional().describe("Filter by category (e.g., development, security)"),
     format: z58.enum(["full", "names"]).optional().describe("Output format: full (with details) or names (just template names)")
@@ -35786,13 +35855,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: z58.array(
@@ -35816,7 +35885,7 @@ function registerListWorkflowsTool(server, deps) {
     },
     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
@@ -35900,12 +35969,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
     });
@@ -35964,11 +36033,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,
@@ -35981,7 +36050,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,
@@ -36069,7 +36138,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 = {
@@ -36080,9 +36149,9 @@ function observeExpertContextIfOk(result, expert, task, durationMs, logger54) {
     taskDescription: task.description,
     durationMs
   };
-  observeExpertContext(observation, logger54);
+  observeExpertContext(observation, logger55);
 }
-async function deriveExpertAccessPolicy(task, logger54, trustTier) {
+async function deriveExpertAccessPolicy(task, logger55, trustTier) {
   const mode = resolveAccessPolicyMode();
   try {
     const policy = await deriveAccessPolicy(task.description, {
@@ -36090,14 +36159,14 @@ async function deriveExpertAccessPolicy(task, logger54, trustTier) {
       trustTier: trustTier ?? "4"
     });
     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 (expert)", {
+    logger55?.warn("access-policy: derivation failed (expert)", {
       mode,
       error: getErrorMessage(error),
       failClosed: mode === "enforce" || mode === "confirm_risky"
@@ -36156,11 +36225,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";
@@ -36169,7 +36238,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 fallbackStart = getTimeProvider().now();
@@ -36189,7 +36258,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,
@@ -36198,19 +36267,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,
@@ -36298,7 +36367,7 @@ var EXECUTE_EXPERT_TOOL_SCHEMA = {
   context: z59.record(z59.string(), z59.unknown()).optional().describe("Additional context metadata for the task"),
   timeoutMs: z59.number().int().min(EXPERT_TIMEOUT_FLOOR_MS).max(EXPERT_TIMEOUTS.maxMs).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) => {
@@ -36310,7 +36379,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
         });
@@ -36335,7 +36404,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",
@@ -36368,7 +36437,7 @@ 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", {
         ...toolStructuredError({
@@ -36377,7 +36446,7 @@ async function runBackgroundExpertTask(opts) {
         })
       });
     } catch (storeError) {
-      logger54.warn("Failed to store task failure result", {
+      logger55.warn("Failed to store task failure result", {
         taskId,
         error: getErrorMessage(storeError)
       });
@@ -36385,7 +36454,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 description2 = "Run a task through an expert YOU PREVIOUSLY CREATED via `create_expert`. Requires the expertId returned by create_expert; not for ad-hoc execution. Returns the expert analysis including output, confidence, and token usage.";
@@ -36397,9 +36466,9 @@ function registerExecuteExpertTool(server, deps) {
       execution: { taskSupport: "optional" },
       annotations: getToolAnnotations("execute_expert")
     },
-    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
@@ -37798,15 +37867,15 @@ function createResearchQueryHandler(deps) {
       });
     }
     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 toolSuccessStructured(result);
     });
   };
 }
 function registerResearchQueryTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "research_query" });
+  const logger55 = deps.logger ?? createLogger({ tool: "research_query" });
   const toolSchema = {
     action: z62.enum(["status", "overlap", "stats", "search"]).describe("Query action: status, overlap, stats, or search"),
     techniqueId: z62.string().optional().describe("Technique ID for status/overlap queries"),
@@ -37818,12 +37887,12 @@ 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
   });
   const outputSchema = {
     action: z62.string(),
@@ -37840,7 +37909,7 @@ function registerResearchQueryTool(server, deps) {
     },
     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
@@ -37851,7 +37920,7 @@ var ResearchAddInputSchema = z63.object({
   priority: z63.enum(["P1", "P2", "P3", "P4"]).optional().describe("Priority level for the paper"),
   dryRun: z63.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 {
@@ -37871,7 +37940,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"}`,
@@ -37879,7 +37948,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.]" : "";
@@ -37901,9 +37970,9 @@ function createResearchAddHandler(deps) {
       });
     }
     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 toolStructuredError({
           errorCategory: result.errorCategory ?? "internal",
@@ -37915,7 +37984,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: z63.string().regex(/^\d{4}\.\d{4,5}$/).describe('arXiv paper ID (e.g., "2401.12345")'),
     topic: z63.string().optional().describe("Research topic to categorize the paper under"),
@@ -37926,12 +37995,12 @@ 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
   });
   const outputSchema = {
     success: z63.boolean(),
@@ -37950,7 +38019,7 @@ function registerResearchAddTool(server, deps) {
     },
     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
@@ -38028,9 +38097,9 @@ function buildResponse2(params) {
     ...params.errorCategory !== void 0 ? { errorCategory: params.errorCategory } : {}
   };
 }
-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)}`,
@@ -38038,7 +38107,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) {
@@ -38046,7 +38115,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) {
@@ -38083,8 +38152,8 @@ async function executeResearchAddSource(input, logger54) {
       errorCategory: "internal"
     });
   }
-  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,
@@ -38104,9 +38173,9 @@ function createResearchAddSourceHandler(deps) {
       });
     }
     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 toolStructuredError({
           errorCategory: result.errorCategory ?? "internal",
@@ -38118,7 +38187,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: z64.string().min(1).describe("Source URL"),
     name: z64.string().min(1).describe("Display name"),
@@ -38143,12 +38212,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",
@@ -38215,7 +38284,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":
@@ -38243,7 +38312,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
@@ -38283,24 +38352,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;
@@ -38310,11 +38379,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");
@@ -38322,15 +38391,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)
@@ -38340,7 +38409,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;
@@ -38352,7 +38421,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
@@ -38437,10 +38506,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);
       return toolSuccessStructured(result);
     });
     const durationMs = Date.now() - startMs;
@@ -38454,7 +38523,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: z65.string().min(1).max(200).describe("Research topic to search for"),
     source: z65.enum([
@@ -38477,12 +38546,12 @@ 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",
@@ -38494,7 +38563,7 @@ function registerResearchDiscoverTool(server, deps) {
     },
     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");
 }
 var RESEARCH_DISCOVER_OUTPUT_SCHEMA = {
   topic: z65.string().optional(),
@@ -38748,15 +38817,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 toolSuccessStructured(result);
     });
   };
 }
 function registerResearchAnalyzeTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "research_analyze" });
+  const logger55 = deps.logger ?? createLogger({ tool: "research_analyze" });
   const toolSchema = {
     focus: z66.enum(["gaps", "trends", "priorities", "stale", "coverage"]).describe("Analysis focus area"),
     topic: z66.string().optional().describe("Optional topic filter")
@@ -38765,12 +38834,12 @@ 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
   });
   const outputSchema = {
     focus: z66.string().optional(),
@@ -38788,7 +38857,7 @@ function registerResearchAnalyzeTool(server, deps) {
     },
     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
@@ -38811,7 +38880,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) {
@@ -38823,7 +38892,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([
       {
@@ -38847,11 +38916,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" };
   }
@@ -38865,7 +38934,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}` };
@@ -38896,12 +38965,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":
@@ -38918,9 +38987,9 @@ function createCatalogReviewHandler(deps) {
       });
     }
     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 toolStructuredError({ errorCategory: "validation", message: result.message });
       }
@@ -38929,7 +38998,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: z67.enum(["list", "approve", "dismiss", "flush"]).describe("Action to perform on cataloged references"),
     identifier: z67.string().optional().describe("Reference identifier for approve/dismiss"),
@@ -38940,12 +39009,12 @@ 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
   });
   const outputSchema = {
     action: z67.string().optional(),
@@ -38963,7 +39032,7 @@ function registerResearchCatalogReviewTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered research_catalog_review tool");
+  logger55.info("Registered research_catalog_review tool");
 }
 
 // src/mcp/tools/research-synthesize.ts
@@ -38980,8 +39049,8 @@ function createResearchSynthesizeHandler(deps) {
         message: `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 toolStructuredError({
@@ -38994,7 +39063,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: z68.string().optional().describe("Optional topic filter for single-cluster synthesis")
   };
@@ -39002,12 +39071,12 @@ 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
   });
   const outputSchema = {
     clusters: z68.array(z68.unknown()).optional(),
@@ -39025,7 +39094,7 @@ function registerResearchSynthesizeTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered research_synthesize tool");
+  logger55.info("Registered research_synthesize tool");
 }
 
 // src/mcp/tools/issue-triage-tool.ts
@@ -39085,7 +39154,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: z69.string().min(1).describe("GitHub issue URL (e.g., https://github.com/owner/repo/issues/123)"),
     dryRun: z69.boolean().optional().default(true).describe("Read-only mode (default: true)")
@@ -39095,19 +39164,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: description2, inputSchema: toolSchema, annotations: getToolAnnotations("issue_triage") },
     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) {
@@ -39345,7 +39414,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;
@@ -39353,7 +39422,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,
@@ -39396,7 +39465,7 @@ var GRAPH_WORKFLOW_SCHEMA = {
   enableCheckpointing: z70.boolean().optional().describe("Enable checkpoint saving"),
   enableAuditTrail: z70.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) {
@@ -39412,7 +39481,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",
@@ -39426,16 +39495,16 @@ 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 handler3 = createGraphWorkflowHandler(logger54, notifier);
+  const handler3 = createGraphWorkflowHandler(logger55, notifier);
   const secureHandler = createSecureHandler(handler3, {
     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",
     {
@@ -39445,7 +39514,7 @@ function registerRunGraphWorkflowTool(server, deps) {
     },
     toSdkCallback(wrapped)
   );
-  logger54.info("Registered run_graph_workflow tool");
+  logger55.info("Registered run_graph_workflow tool");
 }
 function toEventSummary(event) {
   const hasNodeId = "nodeId" in event;
@@ -39997,7 +40066,7 @@ var ExecuteSpecInputSchema = z71.object({
   spec: z71.string().min(1).max(5e4).describe("Markdown specification to execute"),
   dryRun: z71.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 toolStructuredError({
@@ -40012,14 +40081,14 @@ function createDryRunResponse(input, logger54) {
       message: `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;
@@ -40032,7 +40101,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
   });
@@ -40046,7 +40115,7 @@ 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 handler3 = async (args, _ctx) => {
     const parsed = ExecuteSpecInputSchema.safeParse(args);
     if (!parsed.success) {
@@ -40056,17 +40125,17 @@ function registerExecuteSpecTool(server, deps) {
       });
     }
     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(handler3, {
     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: z71.string().min(1).max(5e4).describe(
       'Markdown specification to execute. Must contain "## Requirements" and "## Acceptance Criteria" sections.'
@@ -40079,7 +40148,7 @@ function registerExecuteSpecTool(server, deps) {
     { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("execute_spec") },
     toSdkCallback(wrapped)
   );
-  logger54.info("Registered execute_spec tool");
+  logger55.info("Registered execute_spec tool");
 }
 var specLogger = createLogger({ tool: "execute-spec" });
 function recordSpecSuccess(satisfaction, durationMs) {
@@ -40141,29 +40210,29 @@ var MemoryQueryInputSchema = z72.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;
@@ -40175,14 +40244,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,
@@ -40212,7 +40281,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: z72.string().min(1).max(500).describe("Search query to match against memory contents"),
     limit: z72.number().int().min(1).max(50).optional().describe("Maximum results to return (default: 10, max: 50)"),
@@ -40222,10 +40291,10 @@ 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 });
   const outputSchema = {
     query: z72.string(),
     expandedQuery: z72.string().optional(),
@@ -40243,7 +40312,7 @@ function registerMemoryQueryTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered memory_query tool");
+  logger55.info("Registered memory_query tool");
 }
 
 // src/mcp/tools/memory-stats.ts
@@ -40251,7 +40320,7 @@ import { z as z73 } from "zod";
 var MemoryStatsInputSchema = z73.object({
   includeDecay: z73.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,
@@ -40288,8 +40357,8 @@ async function collectMemoryStats(input, logger54) {
     mobimem: toolMemory.isMobiMemAvailable(),
     decay: toolMemory.isDecayManagerAvailable()
   };
-  const registry = await collectRegistryStats(logger54);
-  logger54.debug("Memory stats collected", { backends, registryDomains: registry.length });
+  const registry = await collectRegistryStats(logger55);
+  logger55.debug("Memory stats collected", { backends, registryDomains: registry.length });
   return {
     backends,
     session: sessionStats,
@@ -40301,7 +40370,7 @@ async function collectMemoryStats(input, logger54) {
     collectedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-async function collectRegistryStats(logger54) {
+async function collectRegistryStats(logger55) {
   const registry = getMemoryRegistry();
   const rows = [];
   for (const domain of registry.domains()) {
@@ -40312,7 +40381,7 @@ async function collectRegistryStats(logger54) {
       rows.push({ domain, count: s.count, error: null });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      logger54.debug("Registry domain stats failed", { domain, error: message });
+      logger55.debug("Registry domain stats failed", { domain, error: message });
       rows.push({ domain, count: null, error: message });
     }
   }
@@ -40332,7 +40401,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: z73.boolean().optional().describe("Include decay statistics (default: true)")
   };
@@ -40340,10 +40409,10 @@ 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 });
   const outputSchema = {
     backends: z73.unknown(),
     session: z73.unknown().optional(),
@@ -40364,7 +40433,7 @@ function registerMemoryStatsTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered memory_stats tool");
+  logger55.info("Registered memory_stats tool");
 }
 
 // src/mcp/tools/memory-write.ts
@@ -40534,12 +40603,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
@@ -40577,7 +40646,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: z74.string().min(1).max(200).describe("Memory identifier or subject"),
     content: z74.string().min(1).max(5e3).describe("Memory content to store"),
@@ -40591,11 +40660,11 @@ function registerMemoryWriteTool(server, deps) {
   const secureHandler = createSecureHandler(memoryWriteHandler, {
     toolName: "memory_write",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const guardedHandler = withPrerequisite("memory_write", secureHandler);
   const timeoutMs = getToolTimeout("memory_write", deps.security);
-  const wrappedHandler = wrapToolWithTimeout("memory_write", guardedHandler, { timeoutMs, logger: logger54 });
+  const wrappedHandler = wrapToolWithTimeout("memory_write", guardedHandler, { timeoutMs, logger: logger55 });
   const outputSchema = {
     success: z74.boolean(),
     backend: z74.string(),
@@ -40613,7 +40682,7 @@ function registerMemoryWriteTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered memory_write tool");
+  logger55.info("Registered memory_write tool");
 }
 
 // src/mcp/tools/weather-report-tool.ts
@@ -40663,7 +40732,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: z75.enum(["claude", "gemini", "codex", "opencode"]).optional().describe("Filter by CLI"),
     category: z75.enum([
@@ -40684,19 +40753,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: description2, inputSchema: toolSchema, annotations: getToolAnnotations("weather_report") },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered weather_report tool");
+  logger55.info("Registered weather_report tool");
 }
 
 // src/mcp/tools/registry-import-types.ts
@@ -40819,7 +40888,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: z77.enum(["anthropic", "google", "openai"]).describe("Model provider (anthropic, google, openai)"),
     modelId: z77.string().min(1).describe("Provider model identifier"),
@@ -40829,20 +40898,20 @@ function registerRegistryImportTool(server, deps) {
   const secureHandler = createSecureHandler(registryImportHandler, {
     toolName: "registry_import",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const guardedHandler = withPrerequisite("registry_import", secureHandler);
   const timeoutMs = getToolTimeout("registry_import", deps.security);
   const wrappedHandler = wrapToolWithTimeout("registry_import", guardedHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "registry_import",
     { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("registry_import") },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered registry_import tool");
+  logger55.info("Registered registry_import tool");
 }
 
 // src/mcp/tools/repo-analyze-types.ts
@@ -40875,7 +40944,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: z79.string().min(1).describe('GitHub repository in "owner/name" format or full URL'),
     depth: z79.enum(["shallow", "deep"]).optional().describe("Analysis depth: shallow (tree + README) or deep")
@@ -40884,19 +40953,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: description2, inputSchema: toolSchema, annotations: getToolAnnotations("repo_analyze") },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered repo_analyze tool");
+  logger55.info("Registered repo_analyze tool");
 }
 
 // src/mcp/tools/repo-security-plan-types.ts
@@ -40928,7 +40997,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: z81.string().min(1).describe('GitHub repository in "owner/name" format or full URL'),
     categories: z81.array(z81.string().max(50)).max(10).optional().describe('Filter to specific categories (e.g., ["sast", "sca", "secrets"])'),
@@ -40938,19 +41007,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: description2, inputSchema: toolSchema, annotations: getToolAnnotations("repo_security_plan") },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered repo_security_plan tool");
+  logger55.info("Registered repo_security_plan tool");
 }
 
 // src/mcp/tools/search-codebase-tool.ts
@@ -41066,7 +41135,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: z82.string().min(1).max(200).describe("Search query or file path"),
     directory: z82.string().max(500).optional().describe("Directory to index"),
@@ -41077,16 +41146,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: description2, inputSchema: toolSchema, annotations: getToolAnnotations("search_codebase") },
     toSdkCallback(wrapped)
   );
-  logger54.info("Registered search_codebase tool");
+  logger55.info("Registered search_codebase tool");
 }
 
 // src/mcp/tools/extract-symbols-tool.ts
@@ -41153,7 +41222,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: z83.string().min(1).max(500).describe("Path to TypeScript/JavaScript file"),
     mode: z83.enum(["index", "full"]).optional().describe("index (default): names+lines. full: includes source text")
@@ -41162,19 +41231,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: description2, inputSchema: toolSchema, annotations: getToolAnnotations("extract_symbols") },
     toSdkCallback(wrapped)
   );
-  logger54.info("Registered extract_symbols tool");
+  logger55.info("Registered extract_symbols tool");
 }
 
 // src/mcp/tools/query-trace-tool.ts
@@ -41287,7 +41356,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: z84.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: z84.string().max(100).regex(/^[a-zA-Z0-9._-]+$/).optional().describe("Filter by event type (e.g., model.called)"),
@@ -41297,16 +41366,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: description2, inputSchema: toolSchema, annotations: getToolAnnotations("query_trace") },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered query_trace tool");
+  logger55.info("Registered query_trace tool");
 }
 
 // src/audit/audit-types.ts
@@ -41610,7 +41679,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 };
@@ -41619,7 +41688,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.
@@ -41632,8 +41701,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) {
@@ -41862,13 +41931,13 @@ var AuditLogger = class {
   closed = false;
   inFlightFlush = null;
   droppedEventCount = 0;
-  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;
@@ -42069,8 +42138,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/pipeline/stage-types.ts
@@ -43477,7 +43546,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-LB7GCDPG.js");
+        const { executeVoting } = await import("./consensus-vote-5NIBODVH.js");
         const votingResult = await executeVoting(
           {
             proposal: plan.slice(0, 4e3),
@@ -44758,15 +44827,15 @@ async function prReviewHandler(args, ctx) {
   }
 }
 function registerPrReviewTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "pr_review" });
+  const logger55 = deps.logger ?? createLogger({ tool: "pr_review" });
   const description2 = "Run multi-voter consensus review on a PR diff (#2233). 5 voters (architect, security, devex, catfish, scope_steward) each emit approve/request_changes/abstain with reasoning and citations. Reuses consensus_vote infra; experimental.";
   const secureHandler = createSecureHandler(prReviewHandler, {
     toolName: "pr_review",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("pr_review", deps.security);
-  const wrappedHandler = wrapToolWithTimeout("pr_review", secureHandler, { timeoutMs, logger: logger54 });
+  const wrappedHandler = wrapToolWithTimeout("pr_review", secureHandler, { timeoutMs, logger: logger55 });
   server.registerTool(
     "pr_review",
     {
@@ -44776,7 +44845,7 @@ function registerPrReviewTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered pr_review tool");
+  logger55.info("Registered pr_review tool");
 }
 
 // src/mcp/tools/survey-oss-landscape.ts
@@ -44837,7 +44906,7 @@ function parseCandidates(data) {
   });
   return { totalFound: data.total_count ?? candidates.length, candidates };
 }
-async function fetchGithubCandidates(input, logger54) {
+async function fetchGithubCandidates(input, logger55) {
   const query = encodeURIComponent(buildGithubQuery(input));
   const perPage = String(input.maxResults);
   const url = `${GITHUB_SEARCH_BASE}?q=${query}&sort=stars&order=desc&per_page=${perPage}`;
@@ -44849,7 +44918,7 @@ async function fetchGithubCandidates(input, logger54) {
   if (tokenResult.ok) {
     headers["Authorization"] = `Bearer ${tokenResult.value.value}`;
   } else {
-    logger54.debug("No GitHub token; using unauthenticated rate limit (60/hr)");
+    logger55.debug("No GitHub token; using unauthenticated rate limit (60/hr)");
   }
   const fetchResult = await fetchSource({ url, source: "github", headers });
   if (!fetchResult.ok) return fetchResult;
@@ -44880,12 +44949,12 @@ async function fetchGithubCandidates(input, logger54) {
   }
   return { ok: true, value: parseCandidates(parsed.data) };
 }
-async function executeSurvey(input, logger54) {
+async function executeSurvey(input, logger55) {
   const sourcesQueried = ["github"];
   const sourcesFailed = [];
-  const githubResult = await fetchGithubCandidates(input, logger54);
+  const githubResult = await fetchGithubCandidates(input, logger55);
   if (!githubResult.ok) {
-    logger54.warn("GitHub source failed", {
+    logger55.warn("GitHub source failed", {
       code: githubResult.error.code,
       message: githubResult.error.message
     });
@@ -44915,13 +44984,13 @@ function createSurveyHandler(deps) {
         message: `Validation error: ${formatZodError(validation.error)}`
       });
     }
-    const logger54 = deps.logger ?? createLogger({ tool: "survey_oss_landscape" });
+    const logger55 = deps.logger ?? createLogger({ tool: "survey_oss_landscape" });
     ctx.logger.debug("Surveying OSS landscape", {
       query: validation.data.query,
       maxResults: validation.data.maxResults
     });
-    return withToolError("Survey failed", logger54, async () => {
-      const result = await executeSurvey(validation.data, logger54);
+    return withToolError("Survey failed", logger55, async () => {
+      const result = await executeSurvey(validation.data, logger55);
       return toolSuccessStructured(result);
     });
   };
@@ -44935,16 +45004,16 @@ var SURVEY_OUTPUT_SCHEMA = {
 };
 var SURVEY_DESCRIPTION = 'Transient OSS project search. Returns a ranked list of GitHub repositories with license, last-commit, star-count, and one-line description. Does NOT persist to the research registry \u2014 use `research_add_source` for that. Best for one-off engineering decisions like "what tools exist in this space?".';
 function registerSurveyOssLandscapeTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "survey_oss_landscape" });
+  const logger55 = deps.logger ?? createLogger({ tool: "survey_oss_landscape" });
   const secureHandler = createSecureHandler(createSurveyHandler(deps), {
     toolName: "survey_oss_landscape",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("survey_oss_landscape", deps.security);
   const wrappedHandler = wrapToolWithTimeout("survey_oss_landscape", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "survey_oss_landscape",
@@ -44956,7 +45025,7 @@ function registerSurveyOssLandscapeTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered survey_oss_landscape tool");
+  logger55.info("Registered survey_oss_landscape tool");
 }
 
 // src/mcp/tools/vendor-publishing-audit.ts
@@ -45057,9 +45126,9 @@ function createVendorPublishingAuditHandler(deps) {
         message: `Validation error: ${formatZodError(validation.error)}`
       });
     }
-    const logger54 = deps.logger ?? createLogger({ tool: "vendor_publishing_audit" });
+    const logger55 = deps.logger ?? createLogger({ tool: "vendor_publishing_audit" });
     ctx.logger.debug("Vendor publishing audit", { vendor: validation.data.vendor });
-    return withToolError("Vendor publishing audit failed", logger54, () => {
+    return withToolError("Vendor publishing audit failed", logger55, () => {
       const result = lookupVendor(validation.data.vendor);
       return Promise.resolve(toolSuccessStructured(result));
     });
@@ -45083,16 +45152,16 @@ var VENDOR_PUBLISHING_OUTPUT_SCHEMA = {
 };
 var VENDOR_PUBLISHING_DESCRIPTION = "Look up a vendor's published-artifact signing infrastructure: GPG key fingerprints, SHA256SUMS URL pattern, signature shape (clearsigned / detached / detached-on-iso), release cadence, key rotation notes, and the vendor doc citation. Static lookup against a curated seed dataset; the vendor doc URL is the authoritative source. Returns `{known: false, knownVendors: [...]}` for vendors without a seed entry. v1 covers ubuntu, debian, fedora.";
 function registerVendorPublishingAuditTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "vendor_publishing_audit" });
+  const logger55 = deps.logger ?? createLogger({ tool: "vendor_publishing_audit" });
   const secureHandler = createSecureHandler(createVendorPublishingAuditHandler(deps), {
     toolName: "vendor_publishing_audit",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("vendor_publishing_audit", deps.security);
   const wrappedHandler = wrapToolWithTimeout("vendor_publishing_audit", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "vendor_publishing_audit",
@@ -45104,7 +45173,7 @@ function registerVendorPublishingAuditTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered vendor_publishing_audit tool");
+  logger55.info("Registered vendor_publishing_audit tool");
 }
 
 // src/mcp/tools/compare-data-feeds.ts
@@ -45290,12 +45359,12 @@ function createCompareDataFeedsHandler(deps) {
         message: `Validation error: ${formatZodError(validation.error)}`
       });
     }
-    const logger54 = deps.logger ?? createLogger({ tool: "compare_data_feeds" });
+    const logger55 = deps.logger ?? createLogger({ tool: "compare_data_feeds" });
     ctx.logger.debug("Comparing data feeds", {
       feedAPath: validation.data.feedAPath,
       feedBPath: validation.data.feedBPath
     });
-    return withToolError("Compare data feeds failed", logger54, () => {
+    return withToolError("Compare data feeds failed", logger55, () => {
       const result = executeCompare(validation.data);
       return Promise.resolve(toolSuccessStructured(result));
     });
@@ -45323,16 +45392,16 @@ var COMPARE_OUTPUT_SCHEMA = {
 };
 var COMPARE_DESCRIPTION = "Diff two upstream data feeds (YAML or JSON files) along coverage and per-field axes. Returns which entries exist in A, B, both, plus optional field-level diffs across matched entries. v1 takes file paths only (no URL fetch \u2014 that needs an SSRF design pass). Both feeds must be a top-level array OR a top-level object with exactly one array field.";
 function registerCompareDataFeedsTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "compare_data_feeds" });
+  const logger55 = deps.logger ?? createLogger({ tool: "compare_data_feeds" });
   const secureHandler = createSecureHandler(createCompareDataFeedsHandler(deps), {
     toolName: "compare_data_feeds",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("compare_data_feeds", deps.security);
   const wrappedHandler = wrapToolWithTimeout("compare_data_feeds", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "compare_data_feeds",
@@ -45344,7 +45413,7 @@ function registerCompareDataFeedsTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered compare_data_feeds tool");
+  logger55.info("Registered compare_data_feeds tool");
 }
 
 // src/mcp/tools/improvement-review.ts
@@ -45422,8 +45491,8 @@ function clamp2(score, max) {
 var FitnessScoreCalculator = class {
   logger;
   checks = [];
-  constructor(logger54) {
-    this.logger = logger54 ?? createLogger({ component: "FitnessScoreCalculator" });
+  constructor(logger55) {
+    this.logger = logger55 ?? createLogger({ component: "FitnessScoreCalculator" });
     this.registerDefaultChecks();
   }
   /** Register default fitness checks. */
@@ -45917,8 +45986,8 @@ var FitnessScoreCalculator = class {
     return base;
   }
 };
-function createFitnessScoreCalculator(logger54) {
-  return new FitnessScoreCalculator(logger54);
+function createFitnessScoreCalculator(logger55) {
+  return new FitnessScoreCalculator(logger55);
 }
 function calculateFitnessScore(version) {
   const calculator = createFitnessScoreCalculator();
@@ -46166,20 +46235,20 @@ async function fileSignalsAsIssues(signals, ctx) {
   return { issuesFiled, issuesSkipped };
 }
 async function runImprovementReview(input, deps = {}) {
-  const logger54 = deps.logger ?? createLogger({ component: "improvement_review" });
+  const logger55 = deps.logger ?? createLogger({ component: "improvement_review" });
   const { lookbackDays, fileIssues, minSampleSize, fitnessFloor } = input;
   const now = Date.now();
   const windowLabel = `${String(lookbackDays)}d`;
   const allOutcomes = getOutcomeStore().query();
   const windowed = filterByLookback(allOutcomes, lookbackDays, now);
-  const audit = safeFitnessAudit(now, { logger: logger54 });
+  const audit = safeFitnessAudit(now, { logger: logger55 });
   const signals = [
     ...detectCliPerformanceFloor(windowed, minSampleSize, windowLabel),
     ...detectFailureCategoryConcentration(windowed, windowLabel),
     ...detectFitnessSignals(audit, fitnessFloor)
   ];
   signals.sort((a, b) => SEVERITY_ORDER3[a.severity] - SEVERITY_ORDER3[b.severity]);
-  const { issuesFiled, issuesSkipped } = fileIssues ? await fileSignalsAsIssues(signals, { logger: logger54 }) : { issuesFiled: [], issuesSkipped: [] };
+  const { issuesFiled, issuesSkipped } = fileIssues ? await fileSignalsAsIssues(signals, { logger: logger55 }) : { issuesFiled: [], issuesSkipped: [] };
   return {
     window: windowLabel,
     totalOutcomes: windowed.length,
@@ -46209,17 +46278,17 @@ var TOOL_INPUT_SCHEMA = {
   fitnessFloor: z95.number().int().min(0).max(100).optional().describe("Fitness score below this threshold triggers a tech-debt signal (default 90).")
 };
 function registerImprovementReviewTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "improvement_review" });
+  const logger55 = deps.logger ?? createLogger({ tool: "improvement_review" });
   const secureHandler = createSecureHandler(reviewHandler, {
     toolName: "improvement_review",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const guardedHandler = withPrerequisite("improvement_review", secureHandler);
   const timeoutMs = getToolTimeout("improvement_review", deps.security);
   const wrappedHandler = wrapToolWithTimeout("improvement_review", guardedHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "improvement_review",
@@ -46230,7 +46299,7 @@ function registerImprovementReviewTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered improvement_review tool");
+  logger55.info("Registered improvement_review tool");
 }
 
 // src/mcp/tools/query-task-state-tool.ts
@@ -46269,7 +46338,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: z96.string().min(1).max(128).describe("Task ID whose structured state log should be read")
   };
@@ -46277,23 +46346,91 @@ 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: description2, inputSchema: toolSchema, annotations: getToolAnnotations("query_task_state") },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered query_task_state tool");
+  logger55.info("Registered query_task_state tool");
 }
 
 // src/mcp/tools/get-job-result-tool.ts
 import { z as z97 } from "zod";
+
+// src/mcp/jobs/task-state-source.ts
+var logger42 = createLogger({ component: "task-state-source" });
+var TOOL_NAME_BY_PREFIX = {
+  orch: "orchestrate",
+  rwf: "run_workflow",
+  cv: "consensus_vote"
+};
+function toolNameFromJobId(jobId) {
+  const dash = jobId.indexOf("-");
+  const prefix = dash === -1 ? jobId : jobId.slice(0, dash);
+  return TOOL_NAME_BY_PREFIX[prefix] ?? "unknown";
+}
+function statusFromState(state) {
+  if (state.cancellation !== void 0) return "cancelled";
+  if (state.stage === "complete") return "complete";
+  if (state.stage === "failed") return "failed";
+  return "pending";
+}
+function lastBlockerMessage(state) {
+  const last = state.blockers.at(-1);
+  return last?.blocker;
+}
+function jobResultFromTaskState(state, jobId) {
+  const status = statusFromState(state);
+  const isTerminal = status !== "pending";
+  const createdAt = state.createdAt ?? state.updatedAt;
+  const record = {
+    v: 1,
+    jobId,
+    toolName: toolNameFromJobId(jobId),
+    status,
+    createdAt,
+    ...isTerminal ? { completedAt: state.updatedAt } : {}
+  };
+  if (status === "complete") {
+    return { ...record, result: state.result };
+  }
+  if (status === "cancelled") {
+    const reason = state.cancellation?.reason;
+    return reason !== void 0 ? { ...record, error: reason } : record;
+  }
+  if (status === "failed") {
+    const msg = lastBlockerMessage(state);
+    return msg !== void 0 ? { ...record, error: msg } : record;
+  }
+  return record;
+}
+function readJobResultFromTaskState(jobId, customDir) {
+  const stateResult = readTaskState(jobId, customDir);
+  if (!stateResult.ok) return null;
+  return jobResultFromTaskState(stateResult.value, jobId);
+}
+function isTaskStateJobSource() {
+  return process.env["NEXUS_JOB_RESULT_SOURCE"]?.toLowerCase() === "task_state";
+}
+function resolveJobResult(jobId, customDir) {
+  if (isTaskStateJobSource()) {
+    const fromState = readJobResultFromTaskState(jobId, customDir);
+    if (fromState !== null) {
+      logger42.debug("Resolved job result from task-state", { jobId, status: fromState.status });
+      return fromState;
+    }
+  }
+  return readJobResult(jobId);
+}
+
+// src/mcp/tools/get-job-result-tool.ts
 var GetJobResultInputSchema = z97.object({
   jobId: z97.string().min(1).max(128).describe('Job ID returned by orchestrate({ mode: "async" })')
 });
@@ -46307,12 +46444,12 @@ function getJobResultHandler(args) {
       })
     );
   }
-  const record = readJobResult(parsed.data.jobId);
+  const record = resolveJobResult(parsed.data.jobId);
   if (record === null) {
     const response2 = {
       jobId: parsed.data.jobId,
       found: false,
-      errorMessage: "Unknown jobId, or the sidecar file is unreadable (corrupt / future schema). Re-check the jobId returned by the async-mode dispatch."
+      errorMessage: "Unknown jobId, or the result source is unreadable (corrupt / future schema). Re-check the jobId returned by the async-mode dispatch."
     };
     return Promise.resolve(toolSuccess(JSON.stringify(response2, null, 2)));
   }
@@ -46324,7 +46461,7 @@ function getJobResultHandler(args) {
   return Promise.resolve(toolSuccess(JSON.stringify(response, null, 2)));
 }
 function registerGetJobResultTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "get_job_result" });
+  const logger55 = deps.logger ?? createLogger({ tool: "get_job_result" });
   const toolSchema = {
     jobId: z97.string().min(1).max(128).describe('Job ID returned by orchestrate({ mode: "async" })')
   };
@@ -46332,19 +46469,19 @@ function registerGetJobResultTool(server, deps) {
   const secureHandler = createSecureHandler(getJobResultHandler, {
     toolName: "get_job_result",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("get_job_result", deps.security);
   const wrappedHandler = wrapToolWithTimeout("get_job_result", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "get_job_result",
     { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("get_job_result") },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered get_job_result tool");
+  logger55.info("Registered get_job_result tool");
 }
 
 // src/mcp/tools/list-jobs-tool.ts
@@ -46397,7 +46534,7 @@ function listJobsHandler(args) {
   return Promise.resolve(toolSuccess(JSON.stringify(response, null, 2)));
 }
 function registerListJobsTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "list_jobs" });
+  const logger55 = deps.logger ?? createLogger({ tool: "list_jobs" });
   const toolSchema = {
     toolName: z98.string().min(1).max(128).optional().describe("Filter to one tool (exact match)."),
     status: JobStatusSchema.optional().describe(
@@ -46409,19 +46546,19 @@ function registerListJobsTool(server, deps) {
   const secureHandler = createSecureHandler(listJobsHandler, {
     toolName: "list_jobs",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("list_jobs", deps.security);
   const wrappedHandler = wrapToolWithTimeout("list_jobs", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "list_jobs",
     { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("list_jobs") },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered list_jobs tool");
+  logger55.info("Registered list_jobs tool");
 }
 
 // src/mcp/tools/cancel-job-tool.ts
@@ -46478,7 +46615,7 @@ function cancelJobHandler(args) {
   return Promise.resolve(toolSuccess(JSON.stringify(response, null, 2)));
 }
 function registerCancelJobTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "cancel_job" });
+  const logger55 = deps.logger ?? createLogger({ tool: "cancel_job" });
   const toolSchema = {
     jobId: z99.string().min(1).max(128).describe("Job ID returned by orchestrate / run_workflow / consensus_vote in async mode"),
     reason: z99.string().max(1e3).optional().describe('Optional human-readable note (e.g. "user clicked cancel").')
@@ -46487,28 +46624,28 @@ function registerCancelJobTool(server, deps) {
   const secureHandler = createSecureHandler(cancelJobHandler, {
     toolName: "cancel_job",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("cancel_job", deps.security);
   const wrappedHandler = wrapToolWithTimeout("cancel_job", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "cancel_job",
     { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("cancel_job") },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered cancel_job tool");
+  logger55.info("Registered cancel_job tool");
 }
 
 // src/mcp/tools/ci-health-check-tool.ts
 import { z as z101 } from "zod";
 
 // src/mcp/tools/ci-health-log.ts
-import { appendFileSync as appendFileSync4, existsSync as existsSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync3 } from "fs";
+import { appendFileSync as appendFileSync4, existsSync as existsSync12, readFileSync as readFileSync10, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
 import { z as z100 } from "zod";
-var logger42 = createLogger({ component: "ci-health-log" });
+var logger43 = createLogger({ component: "ci-health-log" });
 var CiHealthEventSchema = z100.object({
   v: z100.literal(1),
   ts: z100.iso.datetime(),
@@ -46525,6 +46662,49 @@ var CiHealthEventSchema = z100.object({
 function logFilePath() {
   return nexusDataPathEnsure("ci-health", "events.jsonl");
 }
+var DEFAULT_CI_HEALTH_MAX_BYTES = 2097152;
+function maxLogBytes() {
+  const raw = process.env["NEXUS_CI_HEALTH_MAX_BYTES"];
+  if (raw === void 0 || raw === "") return DEFAULT_CI_HEALTH_MAX_BYTES;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : DEFAULT_CI_HEALTH_MAX_BYTES;
+}
+function capLogSize(path14) {
+  const max = maxLogBytes();
+  let size;
+  try {
+    size = statSync3(path14).size;
+  } catch {
+    return;
+  }
+  if (size <= max) return;
+  try {
+    const lines = readFileSync10(path14, "utf-8").split("\n").filter((l) => l !== "");
+    const kept = [];
+    let bytes = 0;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i];
+      const lineBytes = Buffer.byteLength(`${line}
+`, "utf-8");
+      if (kept.length > 0 && bytes + lineBytes > max) break;
+      kept.push(line);
+      bytes += lineBytes;
+    }
+    kept.reverse();
+    writeFileSync3(path14, kept.length > 0 ? `${kept.join("\n")}
+` : "");
+    logger43.warn("ci-health log exceeded size cap \u2014 dropped oldest events", {
+      maxBytes: max,
+      previousBytes: size,
+      droppedEvents: lines.length - kept.length,
+      keptEvents: kept.length
+    });
+  } catch (err2) {
+    logger43.warn("Failed to cap ci-health log size", {
+      error: err2 instanceof Error ? err2.message : String(err2)
+    });
+  }
+}
 function appendCiHealthEvent(event) {
   const record = {
     v: 1,
@@ -46532,10 +46712,12 @@ function appendCiHealthEvent(event) {
     ...event
   };
   try {
-    appendFileSync4(logFilePath(), `${JSON.stringify(record)}
+    const path14 = logFilePath();
+    appendFileSync4(path14, `${JSON.stringify(record)}
 `);
+    capLogSize(path14);
   } catch (err2) {
-    logger42.warn("Failed to append ci-health event", {
+    logger43.warn("Failed to append ci-health event", {
       error: err2 instanceof Error ? err2.message : String(err2)
     });
   }
@@ -46573,7 +46755,7 @@ function mapStatusPageStatus(raw) {
   if (raw === "partial_outage" || raw === "major_outage") return "outage";
   return "unknown";
 }
-async function checkGithubStatus(logger54) {
+async function checkGithubStatus(logger55) {
   try {
     const res = await fetch(STATUS_PAGE_URL, {
       // 5s budget — status page is fast, hangs here are themselves a degraded signal.
@@ -46601,7 +46783,7 @@ async function checkGithubStatus(logger54) {
       evidence: `GitHub Actions component reports: ${actions.status}`
     };
   } catch (err2) {
-    logger54.warn("Status page fetch failed", {
+    logger55.warn("Status page fetch failed", {
       error: err2 instanceof Error ? err2.message : String(err2)
     });
     return {
@@ -46614,7 +46796,7 @@ async function checkGithubStatus(logger54) {
 function countRecentRuns(runs, sinceMs) {
   return runs.filter((r) => r.created_at !== void 0 && Date.parse(r.created_at) >= sinceMs).length;
 }
-async function checkRepoActivity(repo, windowMinutes, logger54) {
+async function checkRepoActivity(repo, windowMinutes, logger55) {
   const sinceMs = Date.now() - windowMinutes * 6e4;
   try {
     const res = await fetch(`https://api.github.com/repos/${repo}/actions/runs?per_page=30`, {
@@ -46643,7 +46825,7 @@ async function checkRepoActivity(repo, windowMinutes, logger54) {
       evidence: `${String(recentCount)} workflow run(s) in last ${String(windowMinutes)} min on ${repo}`
     };
   } catch (err2) {
-    logger54.warn("Repo activity check failed", {
+    logger55.warn("Repo activity check failed", {
       repo,
       error: err2 instanceof Error ? err2.message : String(err2)
     });
@@ -46669,7 +46851,7 @@ function combineSignals(signals) {
   }
   return worst;
 }
-async function ciHealthCheckHandler(args, logger54) {
+async function ciHealthCheckHandler(args, logger55) {
   const parsed = CiHealthCheckInputSchema.safeParse(args);
   if (!parsed.success) {
     return toolStructuredError({
@@ -46679,9 +46861,9 @@ async function ciHealthCheckHandler(args, logger54) {
   }
   const { repo, activityWindowMinutes } = parsed.data;
   const signals = [];
-  signals.push(await checkGithubStatus(logger54));
+  signals.push(await checkGithubStatus(logger55));
   if (repo !== void 0) {
-    signals.push(await checkRepoActivity(repo, activityWindowMinutes, logger54));
+    signals.push(await checkRepoActivity(repo, activityWindowMinutes, logger55));
   }
   const response = {
     status: combineSignals(signals),
@@ -46695,20 +46877,20 @@ async function ciHealthCheckHandler(args, logger54) {
 }
 var DESCRIPTION = "Check CI infrastructure health before triggering / polling runs (#3076). Returns { status: healthy|degraded|outage|unknown, signals } composing GitHub status-page state + the configured repo's recent workflow-runs activity. Use BEFORE a long auto-merge wait to skip the wedge cycle when CI is broken org-wide. Read-only, idempotent, no network state mutated.";
 function registerCiHealthCheckTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "ci_health_check" });
+  const logger55 = deps.logger ?? createLogger({ tool: "ci_health_check" });
   const toolSchema = {
     repo: z101.string().regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/, "Must be owner/repo form").optional().describe("GitHub repo (owner/repo) to check for recent CI activity. Optional."),
     activityWindowMinutes: z101.number().int().min(5).max(180).optional().describe("Recent-runs lookback window in minutes (5-180; default 30).")
   };
-  const secureHandler = createSecureHandler((args) => ciHealthCheckHandler(args, logger54), {
+  const secureHandler = createSecureHandler((args) => ciHealthCheckHandler(args, logger55), {
     toolName: "ci_health_check",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("ci_health_check", deps.security);
   const wrappedHandler = wrapToolWithTimeout("ci_health_check", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "ci_health_check",
@@ -46719,7 +46901,7 @@ function registerCiHealthCheckTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered ci_health_check tool");
+  logger55.info("Registered ci_health_check tool");
 }
 
 // src/mcp/tools/verify-audit-chain-tool.ts
@@ -46731,7 +46913,7 @@ var VerifyAuditChainInputSchema = z102.object({
     "Filesystem path to the FileAuditStorage log directory. Tool reads all `audit-*.jsonl` files in lexicographic order and verifies the combined chain."
   )
 });
-async function loadAuditEvents(dir, logger54) {
+async function loadAuditEvents(dir, logger55) {
   const entries = await fs12.readdir(dir);
   const auditFiles = entries.filter((name) => name.startsWith("audit-") && name.endsWith(".jsonl")).sort();
   const events = [];
@@ -46742,7 +46924,7 @@ async function loadAuditEvents(dir, logger54) {
       content = await fs12.readFile(fullPath, "utf-8");
     } catch (cause) {
       const msg = cause instanceof Error ? cause.message : String(cause);
-      logger54.warn("Skipping unreadable audit log file", { filename, error: msg });
+      logger55.warn("Skipping unreadable audit log file", { filename, error: msg });
       continue;
     }
     for (const line of content.split("\n")) {
@@ -46753,14 +46935,14 @@ async function loadAuditEvents(dir, logger54) {
         if (validated.success) {
           events.push(validated.data);
         } else {
-          logger54.warn("Skipping malformed audit event", {
+          logger55.warn("Skipping malformed audit event", {
             filename,
             error: validated.error.message
           });
         }
       } catch (cause) {
         const msg = cause instanceof Error ? cause.message : String(cause);
-        logger54.warn("Skipping unparseable audit event", { filename, error: msg });
+        logger55.warn("Skipping unparseable audit event", { filename, error: msg });
       }
     }
   }
@@ -46802,7 +46984,7 @@ async function handler2(args, ctx) {
   return toolSuccess(JSON.stringify(response, null, 2));
 }
 function registerVerifyAuditChainTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "verify_audit_chain" });
+  const logger55 = deps.logger ?? createLogger({ tool: "verify_audit_chain" });
   const toolSchema = {
     logDir: z102.string().min(1).max(512).describe(
       "Filesystem path to the FileAuditStorage log directory. Tool reads all `audit-*.jsonl` files and verifies the combined hash chain."
@@ -46812,19 +46994,19 @@ function registerVerifyAuditChainTool(server, deps) {
   const secureHandler = createSecureHandler(handler2, {
     toolName: "verify_audit_chain",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("verify_audit_chain", deps.security);
   const wrappedHandler = wrapToolWithTimeout("verify_audit_chain", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "verify_audit_chain",
     { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("verify_audit_chain") },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered verify_audit_chain tool");
+  logger55.info("Registered verify_audit_chain tool");
 }
 
 // src/mcp/tools/pipeline-tool.ts
@@ -46903,7 +47085,7 @@ function selectStageRegistry(template, task, agentStages) {
   return createDevStageRegistry(agentStages);
 }
 var RUN_PIPELINE_DESCRIPTION = `Single unified entry point for all pipeline templates (${listTemplateIds().join("/")}). Auto-detects template from task content or accepts an explicit override.`;
-async function runPipelineHandler(args, logger54) {
+async function runPipelineHandler(args, logger55) {
   const parsed = PipelineInputSchema.safeParse(args);
   if (!parsed.success) {
     return toolStructuredError({
@@ -46913,7 +47095,7 @@ async function runPipelineHandler(args, logger54) {
   }
   const input = parsed.data;
   if (input.simulateVotes) {
-    warnIfSimulatedOutsideTests("run_pipeline", logger54);
+    warnIfSimulatedOutsideTests("run_pipeline", logger55);
   }
   try {
     const task = await resolveTask(input.task, input.specFile);
@@ -46937,14 +47119,14 @@ async function runPipelineHandler(args, logger54) {
   }
 }
 function registerPipelineTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "run_pipeline" });
-  const secureHandler = createSecureHandler((args) => runPipelineHandler(args, logger54), {
+  const logger55 = deps.logger ?? createLogger({ tool: "run_pipeline" });
+  const secureHandler = createSecureHandler((args) => runPipelineHandler(args, logger55), {
     toolName: "run_pipeline",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("run_pipeline", deps.security);
-  const wrapped = wrapToolWithTimeout("run_pipeline", secureHandler, { timeoutMs, logger: logger54 });
+  const wrapped = wrapToolWithTimeout("run_pipeline", secureHandler, { timeoutMs, logger: logger55 });
   server.registerTool(
     "run_pipeline",
     {
@@ -46954,7 +47136,7 @@ function registerPipelineTool(server, deps) {
     },
     toSdkCallback(wrapped)
   );
-  logger54.info("Registered run_pipeline tool");
+  logger55.info("Registered run_pipeline tool");
 }
 
 // src/mcp/tools/supply-chain-tradeoff-panel.ts
@@ -47209,17 +47391,17 @@ async function tradeoffPanelHandler(args, ctx) {
   }
 }
 function registerSupplyChainTradeoffPanelTool(server, deps) {
-  const logger54 = deps.logger ?? createLogger({ tool: "supply_chain_tradeoff_panel" });
+  const logger55 = deps.logger ?? createLogger({ tool: "supply_chain_tradeoff_panel" });
   const description2 = "Run a structured per-axis tradeoff vote on an engineering proposal (#2294). Default axes: build_time_determinism / supply_chain_risk / update_cadence. Voters answer EACH axis independently; aggregator surfaces per-axis verdicts so legitimate tradeoffs are not masked by a single approve/reject.";
   const secureHandler = createSecureHandler(tradeoffPanelHandler, {
     toolName: "supply_chain_tradeoff_panel",
     rateLimiter: deps.rateLimiter,
-    logger: logger54
+    logger: logger55
   });
   const timeoutMs = getToolTimeout("supply_chain_tradeoff_panel", deps.security);
   const wrappedHandler = wrapToolWithTimeout("supply_chain_tradeoff_panel", secureHandler, {
     timeoutMs,
-    logger: logger54
+    logger: logger55
   });
   server.registerTool(
     "supply_chain_tradeoff_panel",
@@ -47230,7 +47412,7 @@ function registerSupplyChainTradeoffPanelTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger54.info("Registered supply_chain_tradeoff_panel tool");
+  logger55.info("Registered supply_chain_tradeoff_panel tool");
 }
 
 // src/mcp/tools/tool-annotations.ts
@@ -47920,13 +48102,13 @@ var REGISTERED_TOOL_NAMES = [
   "improvement_review"
 ];
 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: [...REGISTERED_TOOL_NAMES],
-    logger: logger54,
+    logger: logger55,
     rateLimiter
   };
 }
@@ -47939,32 +48121,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, handler3) {
       if (!enabled) return handler3;
-      return createGatewayHandler(toolName, handler3, logger54, overrides);
+      return createGatewayHandler(toolName, handler3, logger55, overrides);
     }
   };
 }
-function createGatewayHandler(toolName, handler3, logger54, overrides) {
+function createGatewayHandler(toolName, handler3, 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 handler3(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) {
@@ -47976,7 +48158,7 @@ function createGatewayHandler(toolName, handler3, 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;
@@ -49111,7 +49293,7 @@ function analyzeTools(tools, config = {}) {
 }
 
 // src/cli-adapters/parsers/gemini-parser.ts
-var logger43 = createLogger({ component: "gemini-parser" });
+var logger44 = createLogger({ component: "gemini-parser" });
 var GeminiResponseParser = class {
   name = "gemini-parser";
   supportedVersionRange = ">=0.20.0 <1.0.0";
@@ -49126,7 +49308,7 @@ var GeminiResponseParser = class {
       }
       return data;
     } catch {
-      logger43.debug("Skipped malformed output line", { snippet: raw.slice(0, 100) });
+      logger44.debug("Skipped malformed output line", { snippet: raw.slice(0, 100) });
       return null;
     }
   }
@@ -49144,7 +49326,7 @@ var GeminiResponseParser = class {
       }
       return null;
     } catch {
-      logger43.debug("Skipped malformed output line", { snippet: raw.slice(0, 100) });
+      logger44.debug("Skipped malformed output line", { snippet: raw.slice(0, 100) });
       return null;
     }
   }
@@ -49163,7 +49345,7 @@ var GeminiResponseParser = class {
       if (models === null) return null;
       return this.aggregateModelTokens(models);
     } catch {
-      logger43.debug("Skipped malformed output line", { snippet: raw.slice(0, 100) });
+      logger44.debug("Skipped malformed output line", { snippet: raw.slice(0, 100) });
       return null;
     }
   }
@@ -49210,7 +49392,7 @@ var GeminiResponseParser = class {
       }
       return null;
     } catch {
-      logger43.debug("Skipped malformed output line", { snippet: raw.slice(0, 100) });
+      logger44.debug("Skipped malformed output line", { snippet: raw.slice(0, 100) });
       return null;
     }
   }
@@ -49241,7 +49423,7 @@ var AgreementCascadeConfigSchema = z107.object({
 });
 
 // src/cli-adapters/agreement-cascade-router.ts
-var logger44 = createLogger({ component: "agreement-cascade-router" });
+var logger45 = createLogger({ component: "agreement-cascade-router" });
 
 // src/cli-adapters/task-classifier.ts
 import { z as z108 } from "zod";
@@ -49266,7 +49448,7 @@ var ResponseCacheConfigSchema = z109.object({
 
 // src/cli-adapters/response-cache-utils.ts
 import { createHash as createHash4 } from "crypto";
-var logger45 = createLogger({ component: "ResponseCacheUtils" });
+var logger46 = createLogger({ component: "ResponseCacheUtils" });
 
 // src/cli-adapters/unified-routing-types.ts
 import { z as z110 } from "zod";
@@ -49365,7 +49547,7 @@ var FeedbackCollectorConfigSchema = z111.object({
 });
 
 // src/learning/outcome-feedback-helpers.ts
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 function countOutcomesByClass(outcomes) {
   const counts = {
     success: 0,
@@ -49418,7 +49600,7 @@ function generateRewardExplanation(outcome, reward) {
 }
 function createRoutingDecision(params) {
   return {
-    id: randomUUID12(),
+    id: randomUUID11(),
     timestamp: getTimeProvider().nowIso(),
     ...params
   };
@@ -49431,7 +49613,7 @@ function createTaskOutcome(params) {
 }
 
 // src/learning/outcome-feedback.ts
-var logger46 = createLogger({ component: "OutcomeFeedback" });
+var logger47 = createLogger({ component: "OutcomeFeedback" });
 var OutcomeFeedbackCollector = class {
   config;
   pendingDecisions = /* @__PURE__ */ new Map();
@@ -49446,7 +49628,7 @@ var OutcomeFeedbackCollector = class {
       ...DEFAULT_FEEDBACK_COLLECTOR_CONFIG,
       ...config
     });
-    logger46.info("OutcomeFeedbackCollector initialized", {
+    logger47.info("OutcomeFeedbackCollector initialized", {
       maxPendingDecisions: this.config.maxPendingDecisions,
       enableAutoReward: this.config.enableAutoReward
     });
@@ -49456,14 +49638,14 @@ var OutcomeFeedbackCollector = class {
    */
   registerLinUCBBandit(bandit) {
     this.linucbBandit = bandit;
-    logger46.debug("LinUCB bandit registered for feedback");
+    logger47.debug("LinUCB bandit registered for feedback");
   }
   /**
    * Register PreferenceRouter for direct feedback.
    */
   registerPreferenceRouter(router) {
     this.preferenceRouter = router;
-    logger46.debug("PreferenceRouter registered for feedback");
+    logger47.debug("PreferenceRouter registered for feedback");
   }
   /**
    * Subscribe to outcome processed events.
@@ -49487,7 +49669,7 @@ var OutcomeFeedbackCollector = class {
     this.pendingDecisions.set(decision.traceId, decision);
     this.decisionHistory.push(decision);
     this.trimHistory();
-    logger46.debug("Routing decision recorded", {
+    logger47.debug("Routing decision recorded", {
       id: decision.id,
       traceId: decision.traceId,
       routerType: decision.routerType,
@@ -49504,7 +49686,7 @@ var OutcomeFeedbackCollector = class {
       this.feedbackToRouters(decision, outcome, reward);
       this.notifyCallbacks(decision, outcome, reward);
     }
-    logger46.debug("Outcome recorded", {
+    logger47.debug("Outcome recorded", {
       routingDecisionId: outcome.routingDecisionId,
       outcomeClass: outcome.outcomeClass,
       qualityScore: outcome.qualityScore
@@ -49513,7 +49695,7 @@ var OutcomeFeedbackCollector = class {
   processOutcome(traceId, partialOutcome) {
     const decision = this.pendingDecisions.get(traceId);
     if (decision === void 0) {
-      logger46.warn("No pending decision found for trace", { traceId });
+      logger47.warn("No pending decision found for trace", { traceId });
       return;
     }
     const outcome = {
@@ -49576,7 +49758,7 @@ var OutcomeFeedbackCollector = class {
       if (decisionTime < cutoff) {
         this.pendingDecisions.delete(traceId);
         cleared++;
-        logger46.debug("Expired pending decision cleared", {
+        logger47.debug("Expired pending decision cleared", {
           id: decision.id,
           traceId,
           age: now - decisionTime
@@ -49598,7 +49780,7 @@ var OutcomeFeedbackCollector = class {
     this.pendingDecisions.clear();
     this.outcomes.length = 0;
     this.decisionHistory.length = 0;
-    logger46.info("OutcomeFeedbackCollector reset");
+    logger47.info("OutcomeFeedbackCollector reset");
   }
   feedbackToRouters(decision, outcome, reward) {
     if (!this.config.enableAutoReward) return;
@@ -49609,7 +49791,7 @@ var OutcomeFeedbackCollector = class {
     if (decision.routerType !== "linucb" || this.linucbBandit === void 0) return;
     if (decision.armIndex === void 0 || decision.banditContext === void 0) return;
     this.linucbBandit.update(decision.armIndex, decision.banditContext, reward.reward);
-    logger46.debug("LinUCB bandit updated", {
+    logger47.debug("LinUCB bandit updated", {
       armIndex: decision.armIndex,
       reward: reward.reward
     });
@@ -49623,7 +49805,7 @@ var OutcomeFeedbackCollector = class {
       decision.selectedTier === "strong" ? outcome.qualityScore : void 0,
       decision.selectedTier === "weak" ? outcome.qualityScore : void 0
     );
-    logger46.debug("PreferenceRouter updated", {
+    logger47.debug("PreferenceRouter updated", {
       strongModelPreferred,
       qualityScore: outcome.qualityScore
     });
@@ -49634,7 +49816,7 @@ var OutcomeFeedbackCollector = class {
         callback(decision, outcome, reward);
       } catch (err2) {
         const error = err2 instanceof Error ? err2 : new Error(String(err2));
-        logger46.error("Callback error", error);
+        logger47.error("Callback error", error);
       }
     }
   }
@@ -49674,7 +49856,7 @@ var DEFAULT_FEEDBACK_INTEGRATION_CONFIG = {
 };
 
 // src/learning/feedback-integration.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 var STEP_QUALITY_SCORING = {
   /** Base score for successful steps. */
   successBase: 0.8,
@@ -49750,8 +49932,8 @@ var FeedbackIntegration = class {
     });
   }
   recordRoutingDecision(decision, traceId) {
-    const id = randomUUID13();
-    const trace = traceId ?? randomUUID13();
+    const id = randomUUID12();
+    const trace = traceId ?? randomUUID12();
     const now = getTimeProvider().now();
     this.evictStaleEntriesThrottled(now);
     if (this.decisionMap.size >= MAX_DECISION_MAP_SIZE) {
@@ -49824,7 +50006,7 @@ var FeedbackIntegration = class {
     } = params;
     const outcomeClass = this.determineOutcomeClass(success, qualityScore);
     const completionRatio = success ? 1 : qualityScore / this.config.successQualityThreshold;
-    const trace = traceId ?? randomUUID13();
+    const trace = traceId ?? randomUUID12();
     const outcome = {
       routingDecisionId,
       timestamp: getTimeProvider().nowIso(),
@@ -50427,7 +50609,7 @@ import { execFile as execFile4 } from "child_process";
 import { promisify as promisify4 } from "util";
 import { resolve as resolve17, normalize as normalize2, sep as sep10 } from "path";
 var execFileAsync4 = promisify4(execFile4);
-var logger47 = createLogger({ component: "sandbox-executor" });
+var logger48 = createLogger({ component: "sandbox-executor" });
 function parseExecError(error) {
   const execError = error;
   const isTimeout = execError.killed === true;
@@ -50527,7 +50709,7 @@ var PolicySandboxExecutor = class {
     const baseEnv = createMinimalEnv(options.cwd);
     const sanitized = sanitizeEnvironment(process.env, policy.allowedEnvVars, options.env);
     if (sanitized.blocked.length > 0 && this.config.logViolations) {
-      logger47.debug("Blocked environment variables", { blocked: sanitized.blocked });
+      logger48.debug("Blocked environment variables", { blocked: sanitized.blocked });
     }
     return { ...baseEnv, ...sanitized.env };
   }
@@ -50549,7 +50731,7 @@ var PolicySandboxExecutor = class {
    * Creates a denied result when policy prevents execution.
    */
   createDeniedResult(command, _args, evaluation, startTime) {
-    logger47.warn("Sandbox policy denied execution", {
+    logger48.warn("Sandbox policy denied execution", {
       command,
       policy: evaluation.policyId,
       reason: evaluation.reason
@@ -50570,7 +50752,7 @@ var PolicySandboxExecutor = class {
    */
   createSuccessResult(command, _args, result, evaluation, startTime) {
     const durationMs = getTimeProvider().now() - startTime;
-    logger47.debug("Sandbox execution succeeded", { command, durationMs });
+    logger48.debug("Sandbox execution succeeded", { command, durationMs });
     return {
       success: result.exitCode === 0,
       exitCode: result.exitCode,
@@ -50610,9 +50792,9 @@ var PolicySandboxExecutor = class {
    */
   logExecutionError(command, execError, durationMs) {
     if (execError.isTimeout) {
-      logger47.warn("Sandbox execution timed out", { command, durationMs });
+      logger48.warn("Sandbox execution timed out", { command, durationMs });
     } else {
-      logger47.debug("Sandbox execution failed", {
+      logger48.debug("Sandbox execution failed", {
         command,
         exitCode: execError.exitCode,
         durationMs
@@ -50648,7 +50830,7 @@ var PolicySandboxExecutor = class {
    */
   logViolations(command, evaluation) {
     for (const violation of evaluation.violations) {
-      logger47.warn("Sandbox policy violation", {
+      logger48.warn("Sandbox policy violation", {
         command,
         type: violation.type,
         denied: violation.denied,
@@ -50663,7 +50845,7 @@ function createSandboxExecutor(config) {
 }
 
 // src/security/sandbox/sandbox-factory.ts
-var logger48 = createLogger({ component: "sandbox-factory" });
+var logger49 = createLogger({ component: "sandbox-factory" });
 var DEFAULT_OPTIONS3 = {
   mode: "policy",
   fallbackToPolicy: true
@@ -50685,7 +50867,7 @@ function createSandbox(options) {
   }
 }
 function createNoneMode() {
-  logger48.warn('Creating sandbox in "none" mode - NO ISOLATION');
+  logger49.warn('Creating sandbox in "none" mode - NO ISOLATION');
   const executor = new PolicySandboxExecutor({
     defaultPolicy: STANDARD_POLICY,
     enforce: false,
@@ -50699,7 +50881,7 @@ function createNoneMode() {
   };
 }
 function createPolicyMode(config) {
-  logger48.info('Creating sandbox in "policy" mode');
+  logger49.info('Creating sandbox in "policy" mode');
   const executor = new PolicySandboxExecutor(config);
   return {
     executor,
@@ -50708,7 +50890,7 @@ function createPolicyMode(config) {
   };
 }
 function createDeprecatedModeFallback(requestedMode, policyConfig) {
-  logger48.warn(`Sandbox mode "${requestedMode}" is no longer supported; using "policy" mode`, {
+  logger49.warn(`Sandbox mode "${requestedMode}" is no longer supported; using "policy" mode`, {
     requestedMode,
     actualMode: "policy",
     reason: "In-process Docker/Deno executors were deleted in #2551. Use the OpenCode sandbox bootstrap for real isolation (NEXUS_SANDBOX environment variable, see docs/guides/SANDBOXED-USAGE.md)."
@@ -50723,7 +50905,7 @@ function createDeprecatedModeFallback(requestedMode, policyConfig) {
 }
 
 // src/security/sandbox/sandbox-manager.ts
-var logger49 = createLogger({ component: "sandbox-manager" });
+var logger50 = createLogger({ component: "sandbox-manager" });
 var DEFAULT_CONFIG5 = {
   mode: "policy",
   fallbackToPolicy: true,
@@ -50735,7 +50917,7 @@ var isInitialized = false;
 var initWarning;
 async function initializeSandbox(config) {
   if (isInitialized && globalSandbox !== null) {
-    logger49.debug("Sandbox already initialized, skipping");
+    logger50.debug("Sandbox already initialized, skipping");
     const baseResult = {
       executor: globalSandbox,
       actualMode,
@@ -50747,7 +50929,7 @@ async function initializeSandbox(config) {
     return baseResult;
   }
   const finalConfig = { ...DEFAULT_CONFIG5, ...config };
-  logger49.info("Initializing sandbox", {
+  logger50.info("Initializing sandbox", {
     mode: finalConfig.mode,
     fallbackToPolicy: finalConfig.fallbackToPolicy
   });
@@ -50760,13 +50942,13 @@ async function initializeSandbox(config) {
   isInitialized = true;
   initWarning = result.warning;
   if (result.usedFallback) {
-    logger49.warn("Sandbox initialized with fallback", {
+    logger50.warn("Sandbox initialized with fallback", {
       requestedMode: finalConfig.mode,
       actualMode: result.actualMode,
       warning: result.warning
     });
   } else {
-    logger49.info("Sandbox initialized", {
+    logger50.info("Sandbox initialized", {
       mode: result.actualMode,
       executor: result.executor.name
     });
@@ -50778,7 +50960,7 @@ function getSandboxMode() {
 }
 
 // src/pipeline/feedback-subscriber.ts
-var logger50 = createLogger({ component: "FeedbackSubscriber" });
+var logger51 = createLogger({ component: "FeedbackSubscriber" });
 var VALID_CLIS = new Set(CLI_NAMES);
 function createFeedbackSubscriber(bus, store) {
   return bus.subscribe({ type: ["model.called", "stage.failed"] }, (event) => {
@@ -50786,7 +50968,7 @@ function createFeedbackSubscriber(bus, store) {
       handleEvent2(event, store);
     } catch (error) {
       const msg = getErrorMessage(error);
-      logger50.warn("Feedback subscriber error", { error: msg });
+      logger51.warn("Feedback subscriber error", { error: msg });
     }
   });
 }
@@ -50843,12 +51025,12 @@ function normalizeCli(cli) {
   if (VALID_CLIS.has(cli)) {
     return cli;
   }
-  logger50.warn("Unknown CLI in event", { cli });
+  logger51.warn("Unknown CLI in event", { cli });
   return void 0;
 }
 
 // src/pipeline/event-bus-bridge.ts
-var logger51 = createLogger({ component: "EventBusBridge" });
+var logger52 = createLogger({ component: "EventBusBridge" });
 function toV1Topic(prefix, event) {
   return `${prefix}.${event.type}`;
 }
@@ -50880,10 +51062,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
@@ -50891,7 +51073,7 @@ function createEventBusBridge(options) {
 }
 
 // src/adapters/stdin-lifecycle.ts
-var logger52 = createLogger({ component: "StdinLifecycleMonitor" });
+var logger53 = createLogger({ component: "StdinLifecycleMonitor" });
 var DEFAULT_PPID_POLL_MS = 3e4;
 var StdinLifecycleMonitor = class {
   callbacks = /* @__PURE__ */ new Set();
@@ -50941,7 +51123,7 @@ var StdinLifecycleMonitor = class {
       clearInterval(this.ppidTimer);
       this.ppidTimer = void 0;
     }
-    logger52.warn("Parent process gone \u2014 shutting down MCP server", { reason });
+    logger53.warn("Parent process gone \u2014 shutting down MCP server", { reason });
     await this.fireCallbacks();
   }
   async fireCallbacks() {
@@ -50949,7 +51131,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) });
       }
     }
   }
@@ -50963,7 +51145,7 @@ function getStdinLifecycleMonitor() {
 // src/pipeline/task-tracker.ts
 import * as fs14 from "fs";
 import * as path13 from "path";
-var logger53 = createLogger({ component: "task-tracker" });
+var logger54 = createLogger({ component: "task-tracker" });
 async function exec(cmd, args, timeout = 15e3) {
   const { execFile: execFile5 } = await import("child_process");
   const { promisify: promisify5 } = await import("util");
@@ -50989,7 +51171,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) {
@@ -51017,7 +51199,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) {
@@ -51692,4 +51874,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-K5KMPKKG.js.map
+//# sourceMappingURL=chunk-RAUA6B2M.js.map