nexus-agents 2.82.0 → 2.83.0

package/dist/{chunk-4XNVJS5A.js → chunk-PMLVZXAE.js}

@@ -1,16 +1,10 @@
-import {
-  CodebaseIndex
-} from "./chunk-AP2FD37C.js";
-import {
-  SharedMemoryStore
-} from "./chunk-ED6VQWNG.js";
 import {
   getTokenEnvVars,
   resolveToken
-} from "./chunk-G2DZBEMU.js";
+} from "./chunk-Z64MSLEK.js";
 import {
   executeExpert
-} from "./chunk-HMXQKDUV.js";
+} from "./chunk-NLPMYBIV.js";
 import {
   EventTopics,
   NOOP_NOTIFIER,
@@ -36,7 +30,7 @@ import {
   withAccessPolicy,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-FTT2IYYX.js";
+} from "./chunk-4BXQ2OZY.js";
 import {
   REGISTRY_PATH,
   getProjectRoot,
@@ -45,26 +39,27 @@ import {
   normalizeTopicToCanonical,
   savePapersRegistry,
   synthesizeResearch
-} from "./chunk-2R5UUBGA.js";
+} from "./chunk-AFPHR72D.js";
 import {
   IssueTriage,
   sanitizeInput
-} from "./chunk-HJUHDPXJ.js";
+} from "./chunk-BZUEUD4G.js";
 import {
   generateSecurityPlan
-} from "./chunk-W2AIGD35.js";
+} from "./chunk-RVRXKNND.js";
 import {
   analyzeGitHubRepo
-} from "./chunk-7J7PNOJQ.js";
+} from "./chunk-HFOQKCD2.js";
 import {
+  CodebaseIndex,
   extractSymbolIndex,
   extractSymbols
-} from "./chunk-BQ4YXGGQ.js";
+} from "./chunk-3ACDP4E6.js";
 import {
   getContextForTask,
   inferTaskCategory,
   summarizeContextForPrompt
-} from "./chunk-TXIUCEFT.js";
+} from "./chunk-3GJAAENS.js";
 import {
   DEFAULT_RELEVANCE_CONFIG,
   MemoryImportance,
@@ -72,19 +67,19 @@ import {
   generateHyphenId,
   generateUUID,
   getToolMemory
-} from "./chunk-U7JXQSEM.js";
+} from "./chunk-YO27YAEX.js";
 import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-S36LIUV2.js";
+} from "./chunk-AINOJRZX.js";
 import {
   getAvailabilityCache,
   resolveFallback
-} from "./chunk-GNG7URCR.js";
+} from "./chunk-3WUVWZUC.js";
 import {
   DEFAULTS
-} from "./chunk-SHWGK7X6.js";
+} from "./chunk-ZM5JKJHI.js";
 import {
   resolveInsideRoot
 } from "./chunk-NUBSJGQZ.js";
@@ -100,7 +95,7 @@ import {
   getAvailableClis,
   sleep,
   withTimeout
-} from "./chunk-2SQXJQTA.js";
+} from "./chunk-FHGDJKCZ.js";
 import {
   BUILT_IN_EXPERTS,
   BuiltInExpertTypeSchema,
@@ -112,12 +107,13 @@ import {
 } from "./chunk-PQHVC4BD.js";
 import {
   createSessionMemory
-} from "./chunk-HVZ52LOL.js";
+} from "./chunk-U6LDVJS7.js";
 import {
   AGENT_ROUTER_TIMEOUTS,
   API_TIMEOUTS,
   ARCHITECTURE_KEYWORDS,
   AgentError,
+  CLI_NAMES,
   CLI_SUBPROCESS_TIMEOUTS,
   DEFAULT_CLI,
   EXPERT_TIMEOUTS,
@@ -182,7 +178,7 @@ import {
   resolveModelIdentitySync,
   toExpertTaskAnalysisResult,
   withStep
-} from "./chunk-7VNVDFD5.js";
+} from "./chunk-RXVH52UI.js";
 import {
   getNexusDataDir,
   nexusDataPath
@@ -1105,12 +1101,12 @@ function removeItemsDirectly(items, targetTokens, manager) {
   };
 }
 async function summarizeAndRemoveItems(options) {
-  const { items, targetTokens, manager, adapter, logger: logger52, customPrompt } = options;
+  const { items, targetTokens, manager, adapter, logger: logger53, 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) {
-    logger52.warn("Summarization failed, removing items without summary");
+    logger53.warn("Summarization failed, removing items without summary");
     return removeItemsDirectly(items, targetTokens, manager);
   }
   let tokensFreed = 0;
@@ -1123,7 +1119,7 @@ async function summarizeAndRemoveItems(options) {
   if (summaryAddResult.item !== void 0) {
     tokensFreed -= summaryAddResult.tokenCount;
   }
-  logger52.info("Summarization pruning completed", {
+  logger53.info("Summarization pruning completed", {
     summarizedItems: items.length,
     tokensFreed,
     targetReached: tokensFreed >= targetTokens
@@ -1181,7 +1177,7 @@ function scoreByPriorityWeightedAge(candidates) {
   return scores.map((s) => s.item);
 }
 function removeItemsToTarget(options) {
-  const { sortedItems, targetTokens, categories, manager, minItemsPerCategory, logger: logger52 } = options;
+  const { sortedItems, targetTokens, categories, manager, minItemsPerCategory, logger: logger53 } = options;
   const categoryRemaining = /* @__PURE__ */ new Map();
   for (const category of categories) {
     categoryRemaining.set(category, manager.getByCategory(category).length);
@@ -1198,7 +1194,7 @@ function removeItemsToTarget(options) {
     categoryRemaining.set(item.category, remaining - 1);
   }
   const targetReached = tokensFreed >= targetTokens;
-  logger52.info("Pruning completed", {
+  logger53.info("Pruning completed", {
     itemsRemoved: removedItems.length,
     tokensFreed,
     targetTokens,
@@ -1661,7 +1657,7 @@ function generateBudgetWarning(utilizationPercent, tokensUsed, budgetLimit, scop
     scope
   };
 }
-function logBudgetWarning(warning, logger52) {
+function logBudgetWarning(warning, logger53) {
   const context = {
     scope: warning.scope,
     usagePercent: Math.round(warning.usagePercent),
@@ -1670,13 +1666,13 @@ function logBudgetWarning(warning, logger52) {
   };
   switch (warning.level) {
     case "critical":
-      logger52.warn(warning.message, context);
+      logger53.warn(warning.message, context);
       break;
     case "warning":
-      logger52.warn(warning.message, context);
+      logger53.warn(warning.message, context);
       break;
     case "info":
-      logger52.info(warning.message, context);
+      logger53.info(warning.message, context);
       break;
   }
 }
@@ -1732,8 +1728,8 @@ function createHardModeResult(params) {
     )
   };
 }
-function logWarnModeExceeded(params, logger52) {
-  logger52.warn("Token budget would be exceeded (warn mode - continuing)", {
+function logWarnModeExceeded(params, logger53) {
+  logger53.warn("Token budget would be exceeded (warn mode - continuing)", {
     exceedsSession: params.exceedsSession,
     exceedsTask: params.exceedsTask,
     estimatedTokens: params.estimatedTokens,
@@ -1762,9 +1758,9 @@ var TokenBudgetTracker = class {
    * @param config - Token budget configuration
    * @param logger - Optional logger instance
    */
-  constructor(config = {}, logger52) {
+  constructor(config = {}, logger53) {
     this.config = { ...DEFAULT_TOKEN_BUDGET_CONFIG, ...config };
-    this.logger = logger52 ?? createLogger({ component: "token-budget-tracker" });
+    this.logger = logger53 ?? createLogger({ component: "token-budget-tracker" });
   }
   /**
    * Check if an operation is within budget.
@@ -1917,7 +1913,7 @@ var TokenBudgetTracker = class {
 
 // src/agents/base-agent-state-helpers.ts
 function transitionToState(params) {
-  const { stateMachine, logger: logger52, newState } = params;
+  const { stateMachine, logger: logger53, newState } = params;
   const currentState = stateMachine.state;
   if (newState === "error") {
     stateMachine.forceError({ reason: "transitionToState called with error" });
@@ -1927,7 +1923,7 @@ function transitionToState(params) {
   if (event !== void 0 && stateMachine.canTransition(event)) {
     const result = stateMachine.transition(event);
     if (!result.ok) {
-      logger52.warn("State transition failed", {
+      logger53.warn("State transition failed", {
         from: currentState,
         to: newState,
         event,
@@ -1935,7 +1931,7 @@ function transitionToState(params) {
       });
     }
   } else if (currentState !== newState) {
-    logger52.debug("Unmapped state change", { from: currentState, to: newState });
+    logger53.debug("Unmapped state change", { from: currentState, to: newState });
   }
 }
 
@@ -2091,7 +2087,7 @@ function getAgentStateKey(agentId) {
 }
 
 // src/agents/memory-operations.ts
-async function persistMemoryState(backend, state, logger52) {
+async function persistMemoryState(backend, state, logger53) {
   const key = getAgentStateKey(state.agentId);
   const metadata = {
     importance: MemoryImportance.HIGH,
@@ -2103,12 +2099,12 @@ async function persistMemoryState(backend, state, logger52) {
   };
   const result = await backend.store(key, updatedState, metadata);
   if (!result.ok) {
-    logger52.error("Failed to persist agent memory state", result.error, { agentId: state.agentId });
+    logger53.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 })
     );
   }
-  logger52.debug("Persisted agent memory state", {
+  logger53.debug("Persisted agent memory state", {
     agentId: state.agentId,
     learningsCount: state.taskLearnings.length,
     patternsCount: state.executionPatterns.length,
@@ -2116,16 +2112,16 @@ async function persistMemoryState(backend, state, logger52) {
   });
   return ok(void 0);
 }
-async function loadMemoryState(backend, agentId, role, logger52) {
+async function loadMemoryState(backend, agentId, role, logger53) {
   const key = getAgentStateKey(agentId);
   const result = await backend.retrieve(key);
   if (!result.ok) {
-    logger52.debug("No existing memory state found, creating fresh state", { agentId });
+    logger53.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") {
-    logger52.warn("Invalid memory state format, creating fresh state", { agentId });
+    logger53.warn("Invalid memory state format, creating fresh state", { agentId });
     return ok(createInitialMemoryState(agentId, role));
   }
   const state = {
@@ -2136,7 +2132,7 @@ async function loadMemoryState(backend, agentId, role, logger52) {
     executionPatterns: Array.isArray(loaded.executionPatterns) ? loaded.executionPatterns : [],
     errorResolutions: Array.isArray(loaded.errorResolutions) ? loaded.errorResolutions : []
   };
-  logger52.debug("Loaded agent memory state", {
+  logger53.debug("Loaded agent memory state", {
     agentId,
     learningsCount: state.taskLearnings.length,
     patternsCount: state.executionPatterns.length,
@@ -2144,13 +2140,13 @@ async function loadMemoryState(backend, agentId, role, logger52) {
   });
   return ok(state);
 }
-async function loadRelevantTypedMemories(typedMemory, role, limit, logger52) {
+async function loadRelevantTypedMemories(typedMemory, role, limit, logger53) {
   const result = await typedMemory.filterByRelevance(role, limit);
   if (!result.ok) {
-    logger52.warn("Failed to load relevant typed memories", { role, error: result.error.message });
+    logger53.warn("Failed to load relevant typed memories", { role, error: result.error.message });
     return result;
   }
-  logger52.debug("Loaded relevant typed memories", {
+  logger53.debug("Loaded relevant typed memories", {
     role,
     count: result.value.length,
     types: [...new Set(result.value.map((e) => e.type))]
@@ -2264,10 +2260,10 @@ function initializeMemoryInfrastructure(options) {
 
 // src/agents/base-agent-constructor-helpers.ts
 function setupStateMachine(params) {
-  const { agentId, logger: logger52, eventBus, options } = params;
+  const { agentId, logger: logger53, eventBus, options } = params;
   const stateMachine = new AgentStateMachine(options);
   stateMachine.onStateChange((transition) => {
-    logger52.debug("State transition", {
+    logger53.debug("State transition", {
       from: transition.from,
       to: transition.to,
       event: transition.event
@@ -2281,9 +2277,9 @@ function setupStateMachine(params) {
   return stateMachine;
 }
 function initializeInfrastructure(params) {
-  const { agentId, role, logger: logger52, adapter, pruningConfig, memoryConfig } = params;
+  const { agentId, role, logger: logger53, adapter, pruningConfig, memoryConfig } = params;
   const pruningOpts = {
-    logger: logger52,
+    logger: logger53,
     ...pruningConfig !== void 0 ? { config: pruningConfig } : {},
     ...adapter !== void 0 ? { adapter } : {}
   };
@@ -2291,7 +2287,7 @@ function initializeInfrastructure(params) {
   const memoryOpts = {
     agentId,
     role,
-    logger: logger52,
+    logger: logger53,
     ...memoryConfig !== void 0 ? { config: memoryConfig } : {}
   };
   const memory = initializeMemoryInfrastructure(memoryOpts);
@@ -2523,14 +2519,14 @@ function transformTaskError(error, agentId, taskId) {
   return new AgentError(`Task execution failed: ${message}`, opts);
 }
 function finalizeTaskSuccess(params) {
-  const { task, result, startTime, stateMachine, budgetTracker, logger: logger52 } = params;
+  const { task, result, startTime, stateMachine, budgetTracker, logger: logger53 } = 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();
-  logger52.info("Task completed", {
+  logger53.info("Task completed", {
     taskId: task.id,
     durationMs,
     tokensUsed: result.metadata.tokensUsed,
@@ -2558,7 +2554,7 @@ function recordFailedTaskError(params) {
   });
 }
 async function persistMemoryAfterTask(params) {
-  const { memoryEnabled, memoryBackend, memoryState, persistenceMode, task, startTime, logger: logger52 } = params;
+  const { memoryEnabled, memoryBackend, memoryState, persistenceMode, task, startTime, logger: logger53 } = params;
   if (!memoryEnabled || memoryState === null) {
     return memoryState;
   }
@@ -2573,9 +2569,9 @@ async function persistMemoryAfterTask(params) {
     successRate
   });
   if (memoryBackend !== void 0) {
-    await persistMemoryState(memoryBackend, updatedState, logger52);
+    await persistMemoryState(memoryBackend, updatedState, logger53);
   }
-  logger52.debug("Memory persisted after task completion", {
+  logger53.debug("Memory persisted after task completion", {
     taskId: task.id,
     durationMs
   });
@@ -2586,15 +2582,15 @@ function categorizeTaskType(description2) {
   return categorizeTaskByKeywords(desc);
 }
 async function persistMemoryOnCleanup(params) {
-  const { memoryEnabled, memoryBackend, memoryState, persistenceMode, logger: logger52 } = params;
+  const { memoryEnabled, memoryBackend, memoryState, persistenceMode, logger: logger53 } = params;
   if (!memoryEnabled || memoryBackend === void 0 || memoryState === null) {
     return;
   }
   if (persistenceMode === "none") {
     return;
   }
-  await persistMemoryState(memoryBackend, memoryState, logger52);
-  logger52.debug("Memory state persisted during cleanup");
+  await persistMemoryState(memoryBackend, memoryState, logger53);
+  logger53.debug("Memory state persisted during cleanup");
 }
 
 // src/agents/base-agent-execute-flow.ts
@@ -2720,14 +2716,14 @@ function createInitialPruningMetrics() {
 
 // src/agents/base-agent-memory-ops.ts
 async function flushMemoryState(params) {
-  const { memoryEnabled, memoryBackend, memoryState, logger: logger52 } = params;
+  const { memoryEnabled, memoryBackend, memoryState, logger: logger53 } = params;
   if (!memoryEnabled) {
     return ok(void 0);
   }
   if (memoryBackend === void 0 || memoryState === null) {
     return ok(void 0);
   }
-  return persistMemoryState(memoryBackend, memoryState, logger52);
+  return persistMemoryState(memoryBackend, memoryState, logger53);
 }
 function recordLearningToState(params) {
   const { memoryEnabled, memoryState, learning } = params;
@@ -3976,13 +3972,13 @@ function shouldFinalize(pattern, participants, results, votes, reviews) {
 
 // src/agents/collaboration/collaboration-session-helpers.ts
 var MAX_EVENT_LISTENERS = 50;
-function emitEventToListeners(listeners, event, logger52) {
+function emitEventToListeners(listeners, event, logger53) {
   for (const listener of listeners) {
     try {
       listener(event);
     } catch (e) {
       const errorObj = e instanceof Error ? e : new Error(String(e));
-      logger52.error("Event listener error", errorObj, { eventType: event.type });
+      logger53.error("Event listener error", errorObj, { eventType: event.type });
     }
   }
 }
@@ -7657,9 +7653,9 @@ var DEFAULT_WAVE_CONFIG = {
 var WaveScheduler = class {
   config;
   logger;
-  constructor(config = {}, logger52) {
+  constructor(config = {}, logger53) {
     this.config = { ...DEFAULT_WAVE_CONFIG, ...config };
-    this.logger = logger52 ?? createLogger({ component: "wave-scheduler" });
+    this.logger = logger53 ?? createLogger({ component: "wave-scheduler" });
   }
   /**
    * Execute tasks in waves respecting dependencies and concurrency limits.
@@ -7893,8 +7889,8 @@ function chunkByDirectory(files, basePath) {
     items
   }));
 }
-function createWaveScheduler(config = {}, logger52) {
-  return new WaveScheduler(config, logger52);
+function createWaveScheduler(config = {}, logger53) {
+  return new WaveScheduler(config, logger53);
 }
 
 // src/agents/experts/expert-types.ts
@@ -12755,9 +12751,9 @@ var SkillLibrary = class {
   config;
   logger;
   store;
-  constructor(config = {}, logger52) {
+  constructor(config = {}, logger53) {
     this.config = { ...DEFAULT_SKILL_LIBRARY_CONFIG, ...config };
-    this.logger = logger52 ?? createLogger({ component: "SkillLibrary" });
+    this.logger = logger53 ?? createLogger({ component: "SkillLibrary" });
     this.store = {
       skills: /* @__PURE__ */ new Map(),
       executions: /* @__PURE__ */ new Map(),
@@ -13075,8 +13071,8 @@ var SkillLibrary = class {
     return scored.sort((a, b) => b.score - a.score).map((s) => s.skill);
   }
 };
-function createSkillLibrary(config, logger52) {
-  return new SkillLibrary(config, logger52);
+function createSkillLibrary(config, logger53) {
+  return new SkillLibrary(config, logger53);
 }
 
 // src/agents/skills/skill-composer.ts
@@ -13091,10 +13087,10 @@ var SkillComposer = class {
   config;
   logger;
   library;
-  constructor(library, config = {}, logger52) {
+  constructor(library, config = {}, logger53) {
     this.library = library;
     this.config = { ...DEFAULT_COMPOSER_CONFIG, ...config };
-    this.logger = logger52 ?? createLogger({ component: "SkillComposer" });
+    this.logger = logger53 ?? createLogger({ component: "SkillComposer" });
   }
   /**
    * Creates a composition plan for a task.
@@ -13324,8 +13320,8 @@ var SkillComposer = class {
     return errors;
   }
 };
-function createSkillComposer(library, config, logger52) {
-  return new SkillComposer(library, config, logger52);
+function createSkillComposer(library, config, logger53) {
+  return new SkillComposer(library, config, logger53);
 }
 
 // src/agents/skills/skill-dependency-graph-helpers.ts
@@ -14020,10 +14016,10 @@ var SkillLoader = class {
   library;
   logger;
   mappingIndex;
-  constructor(library, config, logger52) {
+  constructor(library, config, logger53) {
     this.library = library;
     this.config = { ...DEFAULT_SKILL_LOADER_CONFIG, ...config };
-    this.logger = logger52 ?? createLogger({ component: "SkillLoader" });
+    this.logger = logger53 ?? createLogger({ component: "SkillLoader" });
     this.mappingIndex = /* @__PURE__ */ new Map();
     for (const mapping of this.config.mappings) {
       this.mappingIndex.set(mapping.role, mapping);
@@ -14246,8 +14242,8 @@ var SkillLoader = class {
     return ok(orderResult.value);
   }
 };
-function createSkillLoader(library, config, logger52) {
-  return new SkillLoader(library, config, logger52);
+function createSkillLoader(library, config, logger53) {
+  return new SkillLoader(library, config, logger53);
 }
 
 // src/agents/skills/external-pack-loader.ts
@@ -14309,13 +14305,13 @@ function validateManifest(raw, packName, source) {
   }
   return ok(parseResult2.data);
 }
-async function loadExternalPack(packSource, logger52) {
+async function loadExternalPack(packSource, logger53) {
   const { name, source, enabled } = packSource;
   if (!enabled) {
-    logger52.debug("Skipping disabled external pack", { name, source });
+    logger53.debug("Skipping disabled external pack", { name, source });
     return ok({ packName: name, skillCount: 0, skills: [] });
   }
-  logger52.info("Loading external skill pack", { name, source });
+  logger53.info("Loading external skill pack", { name, source });
   try {
     const importPath = await resolveImportPath(source);
     const module = await import(importPath);
@@ -14325,7 +14321,7 @@ async function loadExternalPack(packSource, logger52) {
       return validationResult;
     }
     const manifest = validationResult.value;
-    logger52.info("External pack loaded successfully", {
+    logger53.info("External pack loaded successfully", {
       name: manifest.name,
       version: manifest.version,
       skillCount: manifest.skills.length
@@ -14346,22 +14342,22 @@ async function loadExternalPack(packSource, logger52) {
     );
   }
 }
-async function loadAllExternalPacks(packs, logger52) {
+async function loadAllExternalPacks(packs, logger53) {
   const loaded = [];
   const errors = [];
   for (const pack of packs) {
-    const result = await loadExternalPack(pack, logger52);
+    const result = await loadExternalPack(pack, logger53);
     if (result.ok) {
       loaded.push(result.value);
     } else {
       errors.push(result.error);
-      logger52.warn("Failed to load external pack", {
+      logger53.warn("Failed to load external pack", {
         name: pack.name,
         error: result.error.message
       });
     }
   }
-  logger52.info("External pack loading complete", {
+  logger53.info("External pack loading complete", {
     loaded: loaded.length,
     errors: errors.length,
     totalSkills: loaded.reduce((sum, r) => sum + r.skillCount, 0)
@@ -15269,9 +15265,9 @@ var SicaVersionManager = class {
   versions;
   events;
   activeVersionId;
-  constructor(config = {}, logger52) {
+  constructor(config = {}, logger53) {
     this.config = { ...DEFAULT_SICA_CONFIG, ...config };
-    this.logger = logger52 ?? createLogger({ component: "SicaVersionManager" });
+    this.logger = logger53 ?? createLogger({ component: "SicaVersionManager" });
     this.versions = /* @__PURE__ */ new Map();
     this.events = [];
     this.activeVersionId = null;
@@ -19680,9 +19676,9 @@ var TemplateRegistry = class {
     await this.ensureInitialized();
     const { templates, errors } = await loadTemplatesFromDirectory(directoryPath);
     if (errors.length > 0) {
-      const logger52 = createLogger({ component: "TemplateRegistry" });
+      const logger53 = createLogger({ component: "TemplateRegistry" });
       for (const error of errors) {
-        logger52.warn("Template loading warning", { error: error.message });
+        logger53.warn("Template loading warning", { error: error.message });
       }
     }
     let loadedCount = 0;
@@ -19694,8 +19690,8 @@ var TemplateRegistry = class {
           loadedCount++;
         }
       } catch (regError) {
-        const logger52 = createLogger({ component: "TemplateRegistry" });
-        logger52.warn("Template registration failed", {
+        const logger53 = createLogger({ component: "TemplateRegistry" });
+        logger53.warn("Template registration failed", {
           template: definition.name,
           error: regError instanceof Error ? regError.message : String(regError)
         });
@@ -20544,11 +20540,11 @@ var BudgetCircuitError = class extends NexusError {
 
 // src/workflows/budget-circuit-breaker.ts
 var BudgetCircuitBreaker = class {
-  constructor(maxTokens, config, logger52) {
+  constructor(maxTokens, config, logger53) {
     this.maxTokens = maxTokens;
     this.config = { ...DEFAULT_BUDGET_CIRCUIT_CONFIG, ...config };
     this.lastStateChange = getTimeProvider().now();
-    this.logger = logger52 ?? createLogger({ component: "budget-circuit-breaker" });
+    this.logger = logger53 ?? createLogger({ component: "budget-circuit-breaker" });
   }
   state = "closed";
   lastStateChange;
@@ -20858,10 +20854,10 @@ function createSkippedResult() {
     circuitState: "closed"
   };
 }
-function logEnforcementResult(logger52, stepId, result, currentUsagePercent) {
+function logEnforcementResult(logger53, stepId, result, currentUsagePercent) {
   const usagePercent = Math.round(currentUsagePercent * 100);
   if (!result.allowed) {
-    logger52.warn("Budget enforcement blocked step", {
+    logger53.warn("Budget enforcement blocked step", {
       stepId,
       reason: result.reason,
       circuitState: result.circuitState,
@@ -20871,14 +20867,14 @@ function logEnforcementResult(logger52, stepId, result, currentUsagePercent) {
     return;
   }
   if (result.warning !== void 0) {
-    logger52.warn("Budget enforcement warning", {
+    logger53.warn("Budget enforcement warning", {
       stepId,
       warning: result.warning,
       currentUsage: usagePercent
     });
     return;
   }
-  logger52.debug("Budget enforcement passed for step", {
+  logger53.debug("Budget enforcement passed for step", {
     stepId,
     currentUsage: usagePercent,
     allocatedTokens: result.allocatedTokens
@@ -20914,15 +20910,15 @@ function buildFinalOutput(stepResults) {
 }
 
 // src/workflows/workflow-engine-execution.ts
-function createContextManagerForWorkflow(config, workflow, logger52) {
+function createContextManagerForWorkflow(config, workflow, logger53) {
   if (config.contextManagerConfig === void 0) return void 0;
   const budget = workflow.defaultBudget ?? config.defaultBudget;
-  return new ContextManager({ ...config.contextManagerConfig, budget, logger: logger52 });
+  return new ContextManager({ ...config.contextManagerConfig, budget, logger: logger53 });
 }
-function createBudgetCircuitBreakerForWorkflow(contextManager, workflow, config, logger52) {
+function createBudgetCircuitBreakerForWorkflow(contextManager, workflow, config, logger53) {
   const budgetConfig = {
     engineDefaultBudget: config.defaultBudget,
-    logger: logger52
+    logger: logger53
   };
   if (workflow.defaultBudget !== void 0) {
     budgetConfig.workflowDefaultBudget = workflow.defaultBudget;
@@ -20957,12 +20953,12 @@ function applyInputDefaults(workflow, inputs) {
   return merged;
 }
 function initializeExecution(params) {
-  const { workflow, inputs, config, logger: logger52 } = params;
+  const { workflow, inputs, config, logger: logger53 } = params;
   const executionId = generateUUID();
   const startTime = getTimeProvider().now();
   const resolvedInputs = applyInputDefaults(workflow, inputs);
-  const contextManager = createContextManagerForWorkflow(config, workflow, logger52);
-  const budgetCircuitBreaker = config.enableBudgetEnforcement ? createBudgetCircuitBreakerForWorkflow(contextManager, workflow, config, logger52) : void 0;
+  const contextManager = createContextManagerForWorkflow(config, workflow, logger53);
+  const budgetCircuitBreaker = config.enableBudgetEnforcement ? createBudgetCircuitBreakerForWorkflow(contextManager, workflow, config, logger53) : void 0;
   const context = {
     workflowId: workflow.name,
     executionId,
@@ -20982,7 +20978,7 @@ function initializeExecution(params) {
     startTime
   };
   if (contextManager !== void 0) {
-    logger52.debug("Context manager initialized for workflow execution", {
+    logger53.debug("Context manager initialized for workflow execution", {
       executionId,
       workflowName: workflow.name,
       budget: workflow.defaultBudget ?? config.defaultBudget
@@ -20991,10 +20987,10 @@ function initializeExecution(params) {
   return { executionId, context, startTime, execution };
 }
 function enforceStepBudgets(options) {
-  const { steps, context, workflow, totalSteps, config, logger: logger52 } = options;
+  const { steps, context, workflow, totalSteps, config, logger: logger53 } = options;
   const budgetConfig = {
     engineDefaultBudget: config.defaultBudget,
-    logger: logger52
+    logger: logger53
   };
   if (workflow.defaultBudget !== void 0) {
     budgetConfig.workflowDefaultBudget = workflow.defaultBudget;
@@ -21279,29 +21275,29 @@ function createExpertFactoryWithAdapter(adapter) {
   };
   return new ExpertFactoryAdapter(factoryWrapper);
 }
-function adaptLoggerForStepExecutor(logger52) {
+function adaptLoggerForStepExecutor(logger53) {
   return {
     debug: (message, data) => {
-      logger52.debug(message, data);
+      logger53.debug(message, data);
     },
     info: (message, data) => {
-      logger52.info(message, data);
+      logger53.info(message, data);
     },
     warn: (message, data) => {
-      logger52.warn(message, data);
+      logger53.warn(message, data);
     },
     error: (message, data) => {
       if (data !== void 0) {
         const errorContext = { ...data };
-        logger52.error(message, void 0, errorContext);
+        logger53.error(message, void 0, errorContext);
       } else {
-        logger52.error(message);
+        logger53.error(message);
       }
     }
   };
 }
-function createRealStepExecutorCallback(expertFactory, logger52, workflowId) {
-  const adaptedLogger = adaptLoggerForStepExecutor(logger52);
+function createRealStepExecutorCallback(expertFactory, logger53, workflowId) {
+  const adaptedLogger = adaptLoggerForStepExecutor(logger53);
   const executor = createStepExecutor({ expertFactory, logger: adaptedLogger });
   return async (step, ctx) => {
     const startTime = getTimeProvider().now();
@@ -21317,7 +21313,7 @@ function createRealStepExecutorCallback(expertFactory, logger52, workflowId) {
     }
     const result = await executor.execute(step, workflowCtx);
     if (!result.ok) {
-      logger52.warn("Step execution failed", {
+      logger53.warn("Step execution failed", {
         stepId: step.id,
         error: result.error.message
       });
@@ -21377,10 +21373,10 @@ function adaptExecutionPlan(plannerPlan) {
   }));
   return { phases };
 }
-function createMockStepExecutor(logger52) {
+function createMockStepExecutor(logger53) {
   return (step, _ctx) => {
     const startTime = getTimeProvider().now();
-    logger52.debug("Executing step (mock)", {
+    logger53.debug("Executing step (mock)", {
       stepId: step.id,
       agent: step.agent,
       action: step.action
@@ -21389,16 +21385,16 @@ function createMockStepExecutor(logger52) {
   };
 }
 function resolveStepExecutor(options) {
-  const { logger: logger52, expertFactory, workflowId, useMockExecutor } = options;
+  const { logger: logger53, expertFactory, workflowId, useMockExecutor } = options;
   if (useMockExecutor === true) {
-    logger52.warn(
+    logger53.warn(
       "useMockExecutor enabled; workflow steps will return mock results (NOT RECOMMENDED)"
     );
-    return createMockStepExecutor(logger52);
+    return createMockStepExecutor(logger53);
   }
   if (expertFactory !== void 0 && workflowId !== void 0) {
-    logger52.info("Using real StepExecutor with ExpertFactory", { workflowId });
-    return createRealStepExecutorCallback(expertFactory, logger52, workflowId);
+    logger53.info("Using real StepExecutor with ExpertFactory", { workflowId });
+    return createRealStepExecutorCallback(expertFactory, logger53, workflowId);
   }
   if (expertFactory !== void 0 && workflowId === void 0) {
     throw new WorkflowExecutionUnavailableError("expertFactory provided but workflowId missing");
@@ -21409,9 +21405,9 @@ function resolveStepExecutor(options) {
 }
 function createExecutePhase(options) {
   const stepExecutor = resolveStepExecutor(options);
-  const { logger: logger52 } = options;
+  const { logger: logger53 } = options;
   return async (steps, context, executionOptions) => {
-    logger52.debug("Executing phase", {
+    logger53.debug("Executing phase", {
       stepCount: steps.length,
       executionId: context.executionId,
       maxConcurrency: executionOptions.maxConcurrency
@@ -21462,26 +21458,26 @@ function createAdaptedExecutionPlan() {
     return ok(adaptExecutionPlan(planResult.value));
   };
 }
-function resolveExpertFactory(config, logger52) {
+function resolveExpertFactory(config, logger53) {
   if (config?.expertFactory !== void 0) {
     return config.expertFactory;
   }
   if (config?.modelAdapter !== void 0) {
-    logger52.info("Created ExpertFactory with provided model adapter");
+    logger53.info("Created ExpertFactory with provided model adapter");
     return createExpertFactoryWithAdapter(config.modelAdapter);
   }
   return void 0;
 }
 function createWorkflowEngineDeps(config) {
-  const logger52 = config?.logger ?? createLogger({ component: "WorkflowEngine" });
+  const logger53 = config?.logger ?? createLogger({ component: "WorkflowEngine" });
   const builtInTemplates = config?.builtInTemplates ?? cachedBuiltInTemplates ?? /* @__PURE__ */ new Map();
-  const expertFactory = resolveExpertFactory(config, logger52);
+  const expertFactory = resolveExpertFactory(config, logger53);
   return {
     parseWorkflow: createParseWorkflow(),
     loadWorkflowFile: createLoadWorkflowFile(),
     createExecutionPlan: createAdaptedExecutionPlan(),
     executePhase: createExecutePhase({
-      logger: logger52,
+      logger: logger53,
       expertFactory,
       workflowId: "default",
       useMockExecutor: config?.useMockExecutor
@@ -21512,32 +21508,32 @@ async function createInitializedWorkflowEngine(config) {
 function shouldSkipAdapterDetection(config) {
   return config?.modelAdapter !== void 0 || config?.expertFactory !== void 0 || config?.useMockExecutor === true;
 }
-function tryAutoDetectAdapter(logger52) {
+function tryAutoDetectAdapter(logger53) {
   try {
-    logger52.info("Auto-detecting model adapter for workflow execution");
-    const registry = getGlobalRegistry({ logger: logger52 });
+    logger53.info("Auto-detecting model adapter for workflow execution");
+    const registry = getGlobalRegistry({ logger: logger53 });
     const adapter = registry.getDefault();
-    logger52.info("Using unified registry default adapter");
+    logger53.info("Using unified registry default adapter");
     return adapter;
   } catch (error) {
     const message = getErrorMessage(error);
-    logger52.warn("No model adapter available, using mock executor", { error: message });
+    logger53.warn("No model adapter available, using mock executor", { error: message });
     return void 0;
   }
 }
 function createWorkflowEngineDepsAsync(config) {
-  const logger52 = config?.logger ?? createLogger({ component: "WorkflowEngine" });
+  const logger53 = config?.logger ?? createLogger({ component: "WorkflowEngine" });
   if (shouldSkipAdapterDetection(config)) {
-    logger52.debug("Skipping adapter detection - using provided config");
+    logger53.debug("Skipping adapter detection - using provided config");
     return Promise.resolve(createWorkflowEngineDeps(config));
   }
-  const adapter = tryAutoDetectAdapter(logger52);
+  const adapter = tryAutoDetectAdapter(logger53);
   if (adapter !== void 0) {
-    return Promise.resolve(createWorkflowEngineDeps({ ...config, modelAdapter: adapter, logger: logger52 }));
+    return Promise.resolve(createWorkflowEngineDeps({ ...config, modelAdapter: adapter, logger: logger53 }));
   }
   if (config?.useMockExecutor === true) {
-    logger52.warn("Using mock executor as explicitly configured (no real adapter available)");
-    return Promise.resolve(createWorkflowEngineDeps({ ...config, useMockExecutor: true, logger: logger52 }));
+    logger53.warn("Using mock executor as explicitly configured (no real adapter available)");
+    return Promise.resolve(createWorkflowEngineDeps({ ...config, useMockExecutor: true, logger: logger53 }));
   }
   return Promise.reject(
     new WorkflowExecutionUnavailableError(
@@ -21619,23 +21615,23 @@ function createToolLogger(parentLogger, toolName, requestId) {
   }
   return parentLogger.child(context);
 }
-function logToolStart(logger52, toolName, args) {
-  logger52.info("Tool execution started", {
+function logToolStart(logger53, toolName, args) {
+  logger53.info("Tool execution started", {
     tool: toolName,
     hasArgs: args !== void 0,
     argKeys: args !== void 0 ? Object.keys(args) : []
   });
 }
-function logToolSuccess(logger52, toolName, durationMs, resultInfo) {
-  logger52.info("Tool execution completed", {
+function logToolSuccess(logger53, toolName, durationMs, resultInfo) {
+  logger53.info("Tool execution completed", {
     tool: toolName,
     durationMs,
     success: true,
     ...resultInfo
   });
 }
-function logToolError(logger52, toolName, error, durationMs) {
-  logger52.error("Tool execution failed", error, {
+function logToolError(logger53, toolName, error, durationMs) {
+  logger53.error("Tool execution failed", error, {
     tool: toolName,
     durationMs,
     success: false,
@@ -21648,8 +21644,8 @@ function createTimer() {
     elapsed: () => getTimeProvider().now() - startTime
   };
 }
-function withLogging(toolName, handler3, logger52) {
-  const toolLogger = createToolLogger(logger52, toolName);
+function withLogging(toolName, handler3, logger53) {
+  const toolLogger = createToolLogger(logger53, toolName);
   return async (args) => {
     const timer = createTimer();
     logToolStart(toolLogger, toolName, args);
@@ -21734,9 +21730,9 @@ var AuthHandler = class {
   config;
   logger;
   storedToken;
-  constructor(config, logger52) {
+  constructor(config, logger53) {
     this.config = resolveAuthConfig(config);
-    this.logger = logger52 ?? createLogger({ component: "AuthHandler" });
+    this.logger = logger53 ?? createLogger({ component: "AuthHandler" });
     if (this.config.enabled) this.loadToken();
   }
   /**
@@ -21835,19 +21831,19 @@ var AuthHandler = class {
 };
 
 // src/mcp/middleware/tool-error-handler.ts
-function toolErrorResponse(prefix, error, logger52) {
+function toolErrorResponse(prefix, error, logger53) {
   const message = getErrorMessage(error);
-  if (logger52 !== void 0) {
+  if (logger53 !== void 0) {
     const errorObj = error instanceof Error ? error : new Error(message);
-    logger52.error(prefix, errorObj);
+    logger53.error(prefix, errorObj);
   }
   return toolStructuredError({ errorCategory: "internal", message: `${prefix}: ${message}` });
 }
-async function withToolError(prefix, logger52, fn) {
+async function withToolError(prefix, logger53, fn) {
   try {
     return await fn();
   } catch (error) {
-    return toolErrorResponse(prefix, error, logger52);
+    return toolErrorResponse(prefix, error, logger53);
   }
 }
 
@@ -24327,47 +24323,47 @@ function createSubscriptions(eventBus, subs, handler3) {
   }
   return subscriptions;
 }
-function createCleanupFunction(subscriptions, eventBus, logger52) {
+function createCleanupFunction(subscriptions, eventBus, logger53) {
   return () => {
-    logger52.debug("Cleaning up EventBus bridge subscriptions");
+    logger53.debug("Cleaning up EventBus bridge subscriptions");
     for (const sub of subscriptions) {
       sub.unsubscribe();
     }
-    logger52.info("EventBus bridge cleanup complete", {
+    logger53.info("EventBus bridge cleanup complete", {
       unsubscribedCount: subscriptions.length,
       finalStats: eventBus.getStats()
     });
   };
 }
-function initializeEventBusBridge(observer, logger52, config) {
+function initializeEventBusBridge(observer, logger53, config) {
   const mergedConfig = mergeConfig2(config);
   if (!mergedConfig.enabled) {
-    logger52.debug("EventBus bridge disabled by configuration");
+    logger53.debug("EventBus bridge disabled by configuration");
     return { initialized: false, subscriptionCount: 0, cleanup: () => {
     } };
   }
   const eventBus = getGlobalEventBus({ maxHistorySize: mergedConfig.maxHistorySize });
   const logConfig = mergedConfig.logging;
-  logger52.info("Initializing EventBus bridge for MCP server", {
+  logger53.info("Initializing EventBus bridge for MCP server", {
     maxHistorySize: mergedConfig.maxHistorySize,
     subscriptions: mergedConfig.subscriptions
   });
   const handler3 = (event) => {
-    handleEvent(event, observer, logger52, logConfig);
+    handleEvent(event, observer, logger53, logConfig);
   };
   const subscriptions = createSubscriptions(eventBus, mergedConfig.subscriptions, handler3);
-  logger52.info("EventBus bridge initialized", {
+  logger53.info("EventBus bridge initialized", {
     subscriptionCount: subscriptions.length,
     eventBusStats: eventBus.getStats()
   });
-  const cleanup = createCleanupFunction(subscriptions, eventBus, logger52);
+  const cleanup = createCleanupFunction(subscriptions, eventBus, logger53);
   return {
     initialized: true,
     subscriptionCount: subscriptions.length,
     cleanup
   };
 }
-function handleEvent(event, observer, logger52, logConfig) {
+function handleEvent(event, observer, logger53, logConfig) {
   const isImportant = IMPORTANT_TOPICS.has(event.topic);
   const logLevel = isImportant ? logConfig.importantEventLevel : logConfig.frequentEventLevel;
   const logContext = {
@@ -24378,9 +24374,9 @@ function handleEvent(event, observer, logger52, logConfig) {
     timestamp: event.timestamp
   };
   if (logLevel === "info") {
-    logger52.info(`EventBus: ${event.topic}`, logContext);
+    logger53.info(`EventBus: ${event.topic}`, logContext);
   } else {
-    logger52.debug(`EventBus: ${event.topic}`, logContext);
+    logger53.debug(`EventBus: ${event.topic}`, logContext);
   }
   recordEventToObserver(event, observer);
 }
@@ -24558,19 +24554,19 @@ var PROMPT_DEFINITIONS = [
 ];
 
 // src/mcp/prompts/index.ts
-function registerPrompts(server, logger52) {
+function registerPrompts(server, logger53) {
   const registered = [];
   for (const definition of PROMPT_DEFINITIONS) {
-    registerSinglePrompt(server, definition, logger52);
+    registerSinglePrompt(server, definition, logger53);
     registered.push(definition.name);
   }
-  logger52.info("Prompt templates registered", {
+  logger53.info("Prompt templates registered", {
     count: registered.length,
     prompts: registered
   });
   return { prompts: registered };
 }
-function registerSinglePrompt(server, definition, logger52) {
+function registerSinglePrompt(server, definition, logger53) {
   server.registerPrompt(
     definition.name,
     {
@@ -24578,7 +24574,7 @@ function registerSinglePrompt(server, definition, logger52) {
       argsSchema: definition.argsSchema
     },
     (args) => {
-      logger52.debug("Prompt requested", { prompt: definition.name });
+      logger53.debug("Prompt requested", { prompt: definition.name });
       const messages = definition.buildMessages(args);
       return {
         description: definition.description,
@@ -24618,7 +24614,7 @@ function buildModelsPayload() {
     }))
   };
 }
-function registerModelsResource(server, logger52) {
+function registerModelsResource(server, logger53) {
   server.registerResource(
     MODELS_RESOURCE_NAME,
     MODELS_RESOURCE_URI,
@@ -24627,7 +24623,7 @@ function registerModelsResource(server, logger52) {
       mimeType: "application/json"
     },
     () => {
-      logger52.debug("Reading models resource");
+      logger53.debug("Reading models resource");
       const payload = buildModelsPayload();
       return {
         contents: [
@@ -24640,7 +24636,7 @@ function registerModelsResource(server, logger52) {
       };
     }
   );
-  logger52.info("Registered models resource", { uri: MODELS_RESOURCE_URI });
+  logger53.info("Registered models resource", { uri: MODELS_RESOURCE_URI });
 }
 
 // src/indexer/research-index/research-index-base-types.ts
@@ -25451,10 +25447,10 @@ ${topicLines}
 // src/mcp/resources/research-resource.ts
 var RESEARCH_RESOURCE_URI = "nexus://research/papers";
 var RESEARCH_RESOURCE_NAME = "research-papers";
-function buildResearchPayload(logger52) {
+function buildResearchPayload(logger53) {
   const result = parseRegistry();
   if (!result.ok) {
-    logger52.debug("Research registry not available", {
+    logger53.debug("Research registry not available", {
       error: result.error.message
     });
     return {
@@ -25488,7 +25484,7 @@ function buildResearchPayload(logger52) {
     stats: index.stats
   };
 }
-function registerResearchResource(server, logger52) {
+function registerResearchResource(server, logger53) {
   server.registerResource(
     RESEARCH_RESOURCE_NAME,
     RESEARCH_RESOURCE_URI,
@@ -25497,9 +25493,9 @@ function registerResearchResource(server, logger52) {
       mimeType: "application/json"
     },
     () => {
-      logger52.debug("Reading research resource");
+      logger53.debug("Reading research resource");
       try {
-        const payload = buildResearchPayload(logger52);
+        const payload = buildResearchPayload(logger53);
         return {
           contents: [
             {
@@ -25510,7 +25506,7 @@ function registerResearchResource(server, logger52) {
           ]
         };
       } catch (error) {
-        logger52.warn("Failed to build research payload", {
+        logger53.warn("Failed to build research payload", {
           error: getErrorMessage(error)
         });
         return {
@@ -25525,7 +25521,7 @@ function registerResearchResource(server, logger52) {
       }
     }
   );
-  logger52.info("Registered research resource", { uri: RESEARCH_RESOURCE_URI });
+  logger53.info("Registered research resource", { uri: RESEARCH_RESOURCE_URI });
 }
 
 // src/mcp/tools/create-expert.ts
@@ -25626,29 +25622,29 @@ var ROLE_TO_TASK_CATEGORY = {
   pm_expert: "planning",
   ux_expert: "planning"
 };
-function resolveAdapterForModelPreference(modelPreference, fallbackAdapter, logger52) {
-  const registry = getGlobalRegistry({ logger: logger52 });
+function resolveAdapterForModelPreference(modelPreference, fallbackAdapter, logger53) {
+  const registry = getGlobalRegistry({ logger: logger53 });
   const adapter = registry.getAdapterForModel(modelPreference);
   if (adapter === registry.getDefault() && fallbackAdapter !== void 0) {
-    logger52.debug("Model preference not in registry, using fallback adapter", { modelPreference });
+    logger53.debug("Model preference not in registry, using fallback adapter", { modelPreference });
     return fallbackAdapter;
   }
-  logger52.info("Routing expert to CLI for model preference", { modelPreference });
+  logger53.info("Routing expert to CLI for model preference", { modelPreference });
   return adapter;
 }
-function resolveAdapterForRole(role, fallbackAdapter, logger52) {
+function resolveAdapterForRole(role, fallbackAdapter, logger53) {
   const category = ROLE_TO_TASK_CATEGORY[role];
   if (category === void 0) return fallbackAdapter;
-  const registry = getGlobalRegistry({ logger: logger52 });
+  const registry = getGlobalRegistry({ logger: logger53 });
   const adapter = registry.getAdapter(category);
-  logger52.info("Auto-routing expert to specialized CLI", {
+  logger53.info("Auto-routing expert to specialized CLI", {
     role,
     category,
     preferredCli: registry.getRouting(category)?.primaryCli
   });
   return adapter;
 }
-function getExpertFallbackChain(role, excludeCli, logger52) {
+function getExpertFallbackChain(role, excludeCli, logger53) {
   const category = ROLE_TO_TASK_CATEGORY[role];
   if (category === void 0) return [];
   const bucketType = CATEGORY_TO_FALLBACK_TYPE[category];
@@ -25657,7 +25653,7 @@ function getExpertFallbackChain(role, excludeCli, logger52) {
     bucketType
   );
   const filtered = chain.filter((cli) => cli !== excludeCli);
-  logger52.debug("Expert fallback chain resolved", { role, category, excludeCli, chain: filtered });
+  logger53.debug("Expert fallback chain resolved", { role, category, excludeCli, chain: filtered });
   return [...filtered];
 }
 
@@ -25763,16 +25759,16 @@ function buildResponse(expert) {
   };
 }
 function createExpertFromFactory(deps, expertType, modelPreference, role) {
-  const logger52 = deps.logger ?? createLogger({ tool: "create_expert" });
+  const logger53 = 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, logger52);
+    adapter = resolveAdapterForModelPreference(modelPreference, deps.modelAdapter, logger53);
   } else if (role !== void 0) {
-    adapter = resolveAdapterForRole(role, deps.modelAdapter, logger52);
+    adapter = resolveAdapterForRole(role, deps.modelAdapter, logger53);
   } else {
     adapter = deps.modelAdapter;
   }
@@ -25846,7 +25842,7 @@ function createCreateExpertHandler(deps) {
   };
 }
 function registerCreateExpertTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "create_expert" });
+  const logger53 = deps.logger ?? createLogger({ tool: "create_expert" });
   const toolSchema = {
     role: z44.enum([
       "code_expert",
@@ -25866,23 +25862,23 @@ function registerCreateExpertTool(server, deps) {
   const secureHandler = createSecureHandler(createCreateExpertHandler(deps), {
     toolName: "create_expert",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("create_expert", deps.security);
-  const wrappedHandler = wrapToolWithTimeout("create_expert", secureHandler, { timeoutMs, logger: logger52 });
+  const wrappedHandler = wrapToolWithTimeout("create_expert", secureHandler, { timeoutMs, logger: logger53 });
   server.registerTool(
     "create_expert",
     { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("create_expert") },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered create_expert tool with secure handler and timeout protection");
+  logger53.info("Registered create_expert tool with secure handler and timeout protection");
 }
-function createDefaultDeps(rateLimiter, logger52) {
+function createDefaultDeps(rateLimiter, logger53) {
   return {
     expertFactory: ExpertFactory,
     expertRegistry: /* @__PURE__ */ new Map(),
     rateLimiter,
-    ...logger52 !== void 0 ? { logger: logger52 } : {}
+    ...logger53 !== void 0 ? { logger: logger53 } : {}
   };
 }
 function getAvailableRoles() {
@@ -25917,7 +25913,7 @@ function buildExpertsPayload() {
     experts
   };
 }
-function registerExpertsResource(server, logger52) {
+function registerExpertsResource(server, logger53) {
   server.registerResource(
     EXPERTS_RESOURCE_NAME,
     EXPERTS_RESOURCE_URI,
@@ -25926,7 +25922,7 @@ function registerExpertsResource(server, logger52) {
       mimeType: "application/json"
     },
     () => {
-      logger52.debug("Reading experts resource");
+      logger53.debug("Reading experts resource");
       const payload = buildExpertsPayload();
       return {
         contents: [
@@ -25939,12 +25935,12 @@ function registerExpertsResource(server, logger52) {
       };
     }
   );
-  logger52.info("Registered experts resource", { uri: EXPERTS_RESOURCE_URI });
+  logger53.info("Registered experts resource", { uri: EXPERTS_RESOURCE_URI });
 }
 
 // src/mcp/resources/index.ts
-function registerResources(server, logger52) {
-  const log = logger52 ?? createLogger({ component: "mcp-resources" });
+function registerResources(server, logger53) {
+  const log = logger53 ?? createLogger({ component: "mcp-resources" });
   log.info("Registering MCP resources");
   registerModelsResource(server, log);
   registerResearchResource(server, log);
@@ -26058,11 +26054,11 @@ function validateWorkflowInputs(workflow, inputs) {
   };
 }
 async function loadWorkflowFromPath(deps, filePath) {
-  const { workflowEngine, logger: logger52 } = deps;
+  const { workflowEngine, logger: logger53 } = deps;
   const allowedDirs = getAllowedWorkflowDirs(deps);
   const pathValidation = validateWorkflowPath(filePath, allowedDirs);
   if (!pathValidation.ok) {
-    logger52?.warn("Workflow path validation failed", {
+    logger53?.warn("Workflow path validation failed", {
       path: filePath,
       error: pathValidation.error.message
     });
@@ -26081,8 +26077,8 @@ async function loadWorkflowFromPath(deps, filePath) {
   return result;
 }
 async function loadWorkflowFromName(deps, name) {
-  const { workflowEngine, logger: logger52 } = deps;
-  logger52?.debug("Looking up built-in template", { name });
+  const { workflowEngine, logger: logger53 } = deps;
+  logger53?.debug("Looking up built-in template", { name });
   const templates = await workflowEngine.listTemplates();
   const found = templates.find((t) => t.name === name);
   if (found === void 0) {
@@ -26106,9 +26102,9 @@ async function loadWorkflowFromName(deps, name) {
   return { ok: true, value: definition };
 }
 async function loadWorkflow(deps, template) {
-  const { logger: logger52 } = deps;
+  const { logger: logger53 } = deps;
   if (isFilePath(template)) {
-    logger52?.debug("Loading workflow from file", { path: template });
+    logger53?.debug("Loading workflow from file", { path: template });
     return loadWorkflowFromPath(deps, template);
   }
   return loadWorkflowFromName(deps, template);
@@ -26158,15 +26154,15 @@ function formatValidationErrors(validation) {
 
 // src/mcp/tools/run-workflow.ts
 async function executeWorkflow(deps, workflow, inputs) {
-  const { workflowEngine, logger: logger52 } = deps;
-  logger52?.info("Executing workflow", {
+  const { workflowEngine, logger: logger53 } = deps;
+  logger53?.info("Executing workflow", {
     workflowName: workflow.name,
     inputCount: Object.keys(inputs).length
   });
   const startTime = getTimeProvider().now();
   const result = await workflowEngine.execute(workflow, inputs);
   if (!result.ok) {
-    logger52?.error("Workflow execution failed", result.error, {
+    logger53?.error("Workflow execution failed", result.error, {
       workflowName: workflow.name
     });
     return {
@@ -26175,7 +26171,7 @@ async function executeWorkflow(deps, workflow, inputs) {
     };
   }
   const workflowResult = result.value;
-  logger52?.info("Workflow completed", {
+  logger53?.info("Workflow completed", {
     workflowName: workflow.name,
     durationMs: getTimeProvider().now() - startTime,
     stepCount: workflowResult.stepResults.length
@@ -26288,16 +26284,16 @@ function createRunWorkflowHandler(deps) {
   };
 }
 function registerRunWorkflowTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "run_workflow" });
+  const logger53 = 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: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("run_workflow", deps.security);
-  const wrappedHandler = wrapToolWithTimeout("run_workflow", secureHandler, { timeoutMs, logger: logger52 });
+  const wrappedHandler = wrapToolWithTimeout("run_workflow", secureHandler, { timeoutMs, logger: logger53 });
   server.registerTool(
     "run_workflow",
     {
@@ -26305,9 +26301,9 @@ function registerRunWorkflowTool(server, deps) {
       inputSchema: toolInputSchema,
       annotations: getToolAnnotations("run_workflow")
     },
-    toSdkCallbackWithBudgetCheck(wrappedHandler, "run_workflow", timeoutMs, logger52)
+    toSdkCallbackWithBudgetCheck(wrappedHandler, "run_workflow", timeoutMs, logger53)
   );
-  logger52.info("Registered run_workflow tool with secure handler and timeout protection");
+  logger53.info("Registered run_workflow tool with secure handler and timeout protection");
 }
 
 // src/orchestration/graph/graph-types.ts
@@ -26693,7 +26689,7 @@ async function populateUnifiedContextOnState(state) {
   try {
     const taskCandidate = state["task"];
     if (typeof taskCandidate !== "string" || taskCandidate === "") return;
-    const { getContextForTask: getContextForTask2, inferTaskCategory: inferTaskCategory2 } = await import("./context-retriever-4JCGMWH7.js");
+    const { getContextForTask: getContextForTask2, inferTaskCategory: inferTaskCategory2 } = await import("./context-retriever-QY4FNTDZ.js");
     const ctx = await getContextForTask2({
       task: taskCandidate,
       category: inferTaskCategory2(taskCandidate),
@@ -28246,11 +28242,11 @@ var trustTierRule = {
   evaluate(context) {
     const tierVal = context.pipelineState.trustTier;
     const numericTier = tierVal === void 0 ? Number.NaN : Number(tierVal);
-    const tier = Number.isFinite(numericTier) ? numericTier : void 0;
-    if (tier !== void 0 && tier >= 3 && context.stageType === "execute") {
+    const tier = Number.isFinite(numericTier) ? numericTier : 4;
+    if (tier >= 3 && context.stageType === "execute") {
       return {
         allow: false,
-        reason: "Untrusted input cannot trigger execute stages",
+        reason: tierVal === void 0 || !Number.isFinite(numericTier) ? `Missing or invalid trustTier on pipeline state; defaulting to untrusted (4). Producer must set TaskContract.metadata.trustTier (#2957).` : "Untrusted input cannot trigger execute stages",
         escalateTo: "user"
       };
     }
@@ -28407,7 +28403,7 @@ function createDelegatePipeline(task) {
   const runner = new PipelineRunner();
   return runner.compile(plan);
 }
-function delegateInputToTaskContract(input) {
+function delegateInputToTaskContract(input, opts = {}) {
   const metadata = { source: "delegate_to_model" };
   if (input.preferred_capability !== void 0) {
     metadata["preferredCapability"] = input.preferred_capability;
@@ -28418,6 +28414,7 @@ function delegateInputToTaskContract(input) {
   if (input.billing_mode !== void 0) {
     metadata["billingMode"] = input.billing_mode;
   }
+  if (opts.trustTier !== void 0) metadata["trustTier"] = opts.trustTier;
   return buildBaseTaskContract({
     idPrefix: "delegate",
     task: input.task,
@@ -28520,10 +28517,11 @@ function buildPlan(task) {
 }
 
 // src/pipeline/v2-orchestrate.ts
-function orchestrateInputToTaskContract(input) {
+function orchestrateInputToTaskContract(input, opts = {}) {
   const metadata = { source: "orchestrate" };
   if (input.context !== void 0) metadata["context"] = input.context;
   if (input.maxIterations !== void 0) metadata["maxIterations"] = input.maxIterations;
+  if (opts.trustTier !== void 0) metadata["trustTier"] = opts.trustTier;
   return buildBaseTaskContract({
     idPrefix: "orchestrate",
     task: input.task,
@@ -28623,8 +28621,8 @@ var OrchestratorAdapter = class {
   history = [];
   logger;
   agent = null;
-  constructor(logger52) {
-    this.logger = logger52 ?? createLogger({ component: "OrchestratorAdapter" });
+  constructor(logger53) {
+    this.logger = logger53 ?? createLogger({ component: "OrchestratorAdapter" });
   }
   setOrchestrator(agent) {
     this.agent = agent;
@@ -28764,10 +28762,10 @@ var WorkflowOrchestratorAdapter = class {
   logger;
   executions = /* @__PURE__ */ new Map();
   history = [];
-  constructor(engine, logger52) {
+  constructor(engine, logger53) {
     this.id = `workflow-${randomUUID9().slice(0, 8)}`;
     this.engine = engine;
-    this.logger = logger52 ?? createLogger({ component: "WorkflowOrchestratorAdapter" });
+    this.logger = logger53 ?? createLogger({ component: "WorkflowOrchestratorAdapter" });
   }
   async execute(definition, inputs, _options) {
     if (definition.type !== "workflow") {
@@ -28959,22 +28957,22 @@ var OrchestratorFactory = class {
   }
 };
 async function createOrchestratorFactory(config) {
-  const logger52 = config?.logger ?? createLogger({ component: "OrchestratorFactory" });
-  logger52.info("Initializing OrchestratorFactory");
+  const logger53 = config?.logger ?? createLogger({ component: "OrchestratorFactory" });
+  logger53.info("Initializing OrchestratorFactory");
   let workflowEngine;
   try {
     const workflowConfig = {
       ...config?.workflowConfig,
-      logger: logger52
+      logger: logger53
     };
     if (config?.modelAdapter !== void 0) {
       workflowConfig.modelAdapter = config.modelAdapter;
     }
     workflowEngine = await createProductionWorkflowEngine(workflowConfig);
-    logger52.info("WorkflowEngine initialized");
+    logger53.info("WorkflowEngine initialized");
   } catch (error) {
     const message = getErrorMessage(error);
-    logger52.warn("WorkflowEngine initialization failed, workflow orchestration unavailable", {
+    logger53.warn("WorkflowEngine initialization failed, workflow orchestration unavailable", {
       error: message
     });
   }
@@ -28985,12 +28983,12 @@ async function createOrchestratorFactory(config) {
 var MAX_OUTCOMES2 = 200;
 var AMBIGUITY_THRESHOLD = 0.7;
 function createWorkflowRouter(options) {
-  const logger52 = options?.logger ?? createLogger({ component: "WorkflowRouter" });
-  const analyzer = options?.analyzer ?? createSharedTaskAnalyzer({ logger: logger52 });
+  const logger53 = options?.logger ?? createLogger({ component: "WorkflowRouter" });
+  const analyzer = options?.analyzer ?? createSharedTaskAnalyzer({ logger: logger53 });
   const outcomes = [];
   return {
     route(signals, routerOpts) {
-      return routeTask(signals, analyzer, logger52, routerOpts);
+      return routeTask(signals, analyzer, logger53, routerOpts);
     },
     recordOutcome(outcome) {
       recordPatternOutcome(outcomes, outcome);
@@ -29032,7 +29030,7 @@ function buildDecision(input) {
   }
   return base;
 }
-function routeTask(signals, analyzer, logger52, _opts) {
+function routeTask(signals, analyzer, logger53, _opts) {
   const analysis = analyzer.analyze(signals.description);
   const enriched = enrichSignals(signals, analysis);
   const matchedRules = [];
@@ -29042,7 +29040,7 @@ function routeTask(signals, analyzer, logger52, _opts) {
     if (result !== void 0) {
       matchedRules.push(rule.name);
       collectAlternatives(alternatives, result.pattern);
-      logger52.info("Workflow pattern selected", {
+      logger53.info("Workflow pattern selected", {
         pattern: result.pattern,
         rule: rule.name,
         confidence: result.confidence,
@@ -29052,7 +29050,7 @@ function routeTask(signals, analyzer, logger52, _opts) {
       return buildDecision({ result, matchedRules, alternatives, analysis });
     }
   }
-  logger52.info("Using fallback pattern", { pattern: "graph", taskType: analysis.taskType });
+  logger53.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",
@@ -29352,9 +29350,7 @@ function createMockTaskExecutor() {
 }
 function createMockOrchestrator() {
   const mockExecutor = createMockTaskExecutor();
-  const factory = new OrchestratorFactory({
-    techLead: mockExecutor
-  });
+  const factory = new OrchestratorFactory({ techLead: mockExecutor });
   return factory.create("orchestrator");
 }
 
@@ -29402,11 +29398,11 @@ function setAnalysis(snapshot, analysis) {
 var globalSicaConfig;
 var sicaEnabled = false;
 function initializeSica(options) {
-  const { sicaConfig, logger: logger52 } = options;
+  const { sicaConfig, logger: logger53 } = options;
   if (sicaConfig?.enabled !== true) {
     sicaEnabled = false;
     globalSicaConfig = void 0;
-    logger52.info("SICA self-improvement disabled by configuration");
+    logger53.info("SICA self-improvement disabled by configuration");
     return {
       enabled: false,
       reason: sicaConfig?.enabled === false ? "disabled in config" : "not enabled (opt-in feature)"
@@ -29414,7 +29410,7 @@ function initializeSica(options) {
   }
   sicaEnabled = true;
   globalSicaConfig = sicaConfig;
-  logger52.info("SICA self-improvement enabled", {
+  logger53.info("SICA self-improvement enabled", {
     improvementThreshold: sicaConfig.improvementThreshold,
     maxActiveVersions: sicaConfig.maxActiveVersions,
     cooldownMs: sicaConfig.improvementCooldownMs
@@ -29432,18 +29428,18 @@ function getSicaConfig() {
 }
 
 // src/mcp/tools/orchestrate-sica.ts
-function createOrchestratorWithSica(logger52, adapter) {
-  const orchestrator = new Orchestrator({ logger: logger52, ...adapter !== void 0 ? { adapter } : {} });
+function createOrchestratorWithSica(logger53, adapter) {
+  const orchestrator = new Orchestrator({ logger: logger53, ...adapter !== void 0 ? { adapter } : {} });
   if (!isSicaEnabled()) {
-    logger52.debug("SICA not enabled, using plain orchestrator");
+    logger53.debug("SICA not enabled, using plain orchestrator");
     return orchestrator;
   }
   const sicaConfig = getSicaConfig();
   if (sicaConfig === void 0) {
-    logger52.debug("SICA config unavailable, using plain orchestrator");
+    logger53.debug("SICA config unavailable, using plain orchestrator");
     return orchestrator;
   }
-  logger52.info("Creating SICA-wrapped orchestrator", {
+  logger53.info("Creating SICA-wrapped orchestrator", {
     improvementThreshold: sicaConfig.improvementThreshold,
     maxActiveVersions: sicaConfig.maxActiveVersions
   });
@@ -29463,9 +29459,9 @@ function createOrchestratorWithSica(logger52, adapter) {
       improvementCooldownMs: sicaConfig.improvementCooldownMs,
       enableObservability: sicaConfig.enableObservability
     },
-    logger: logger52
+    logger: logger53
   });
-  return createSicaOrchestratorAdapter(sicaAgent, logger52);
+  return createSicaOrchestratorAdapter(sicaAgent, logger53);
 }
 function createSicaOrchestratorAdapter(sicaAgent, _logger) {
   return {
@@ -29519,7 +29515,7 @@ var PersistedCatalogSchema = z51.object({
 function getCatalogPath() {
   return nexusDataPath(CATALOG_SUBDIR, CATALOG_FILE);
 }
-function loadPersistedCatalog(logger52) {
+function loadPersistedCatalog(logger53) {
   const filePath = getCatalogPath();
   try {
     if (!fs4.existsSync(filePath)) return [];
@@ -29527,21 +29523,21 @@ function loadPersistedCatalog(logger52) {
     const parsed = JSON.parse(content);
     const result = PersistedCatalogSchema.safeParse(parsed);
     if (!result.success) {
-      logger52.warn("Invalid pending catalog file, starting fresh", {
+      logger53.warn("Invalid pending catalog file, starting fresh", {
         errors: result.error.issues.map((i) => i.message)
       });
       return [];
     }
     return result.data.references;
   } catch (error) {
-    logger52.debug("Could not load pending catalog, starting fresh", {
+    logger53.debug("Could not load pending catalog, starting fresh", {
       error: getErrorMessage(error),
       filePath
     });
     return [];
   }
 }
-function savePersistedCatalog(references, logger52) {
+function savePersistedCatalog(references, logger53) {
   const dirPath = nexusDataPath(CATALOG_SUBDIR);
   const filePath = getCatalogPath();
   const tempPath = `${filePath}.tmp.${String(process.pid)}`;
@@ -29563,7 +29559,7 @@ function savePersistedCatalog(references, logger52) {
     } catch {
     }
     const message = getErrorMessage(error);
-    logger52.warn("Failed to persist pending catalog", { error: message });
+    logger53.warn("Failed to persist pending catalog", { error: message });
   }
 }
 var ARXIV_PATTERN = /\b(\d{4}\.\d{4,5})\b/g;
@@ -29573,8 +29569,8 @@ var ResearchAutoCatalog = class _ResearchAutoCatalog {
   pendingReferences = [];
   /** Maximum pending references to hold in memory. */
   static MAX_PENDING = 100;
-  constructor(logger52) {
-    this.logger = logger52 ?? createLogger({ component: "research-auto-catalog" });
+  constructor(logger53) {
+    this.logger = logger53 ?? createLogger({ component: "research-auto-catalog" });
     const persisted = loadPersistedCatalog(this.logger);
     if (persisted.length > 0) {
       this.pendingReferences.push(...persisted.slice(0, _ResearchAutoCatalog.MAX_PENDING));
@@ -29729,8 +29725,8 @@ var ResearchAutoCatalog = class _ResearchAutoCatalog {
   }
 };
 var autoCatalogInstance;
-function getAutoCatalog(logger52) {
-  autoCatalogInstance ??= new ResearchAutoCatalog(logger52);
+function getAutoCatalog(logger53) {
+  autoCatalogInstance ??= new ResearchAutoCatalog(logger53);
   return autoCatalogInstance;
 }
 
@@ -31516,12 +31512,12 @@ function computeExpertReliability() {
   }
   return reliability;
 }
-function computeAgentPlan(task, logger52) {
+function computeAgentPlan(task, logger53) {
   try {
     const analyzer = new SharedTaskAnalyzer();
     const analysis = analyzer.analyze(task);
     if (analysis.complexity === "simple") {
-      logger52.debug("Skipping AOrchestra planning for simple task", {
+      logger53.debug("Skipping AOrchestra planning for simple task", {
         taskType: analysis.taskType
       });
       return void 0;
@@ -31533,9 +31529,9 @@ function computeAgentPlan(task, logger52) {
       if (rate < 0.5) excludedExperts.push({ role, rate: Math.round(rate * 100) / 100 });
     }
     if (excludedExperts.length > 0) {
-      logger52.warn("Experts excluded by reliability filter", { excludedExperts });
+      logger53.warn("Experts excluded by reliability filter", { excludedExperts });
     }
-    logger52.info("AOrchestra plan", {
+    logger53.info("AOrchestra plan", {
       experts: plan.totalExperts,
       taskType: plan.taskType,
       complexity: plan.complexity,
@@ -31543,7 +31539,7 @@ function computeAgentPlan(task, logger52) {
     });
     return plan;
   } catch (planError) {
-    logger52.warn("AOrchestra planning failed", {
+    logger53.warn("AOrchestra planning failed", {
       error: getErrorMessage(planError)
     });
     return void 0;
@@ -31613,7 +31609,7 @@ async function executeOnAdapter(opts) {
   }
 }
 function createWorkerExecutor(config) {
-  const { taskDescription, modelAdapter, logger: logger52, learnings, perWorkerRouting } = config;
+  const { taskDescription, modelAdapter, logger: logger53, learnings, perWorkerRouting } = config;
   const effectiveFallbackCli = modelAdapter.providerId;
   return async (entry, priorWaveResults) => {
     const workerStartMs = getTimeProvider().now();
@@ -31622,7 +31618,7 @@ function createWorkerExecutor(config) {
       modelAdapter,
       effectiveFallbackCli,
       perWorkerRouting === true,
-      logger52
+      logger53
     );
     return executeOnAdapter({
       entry,
@@ -31796,15 +31792,15 @@ function prepareBudgetedEntries(plan, maxCalls, log) {
   return entries;
 }
 async function executeWorkerDispatch(options) {
-  const { agentPlan, taskDescription, modelAdapter, logger: logger52, maxConcurrency } = options;
+  const { agentPlan, taskDescription, modelAdapter, logger: logger53, maxConcurrency } = options;
   const maxCalls = resolveMaxWorkerCalls(options.maxWorkerCalls);
   const startMs = getTimeProvider().now();
-  const entries = prepareBudgetedEntries(agentPlan, maxCalls, logger52);
+  const entries = prepareBudgetedEntries(agentPlan, maxCalls, logger53);
   const qualityGate = options.qualityGate === false ? void 0 : options.qualityGate;
   const executorConfig = {
     taskDescription,
     modelAdapter,
-    logger: logger52,
+    logger: logger53,
     ...options.learnings !== void 0 ? { learnings: options.learnings } : {},
     ...options.perWorkerRouting !== void 0 ? { perWorkerRouting: options.perWorkerRouting } : {}
   };
@@ -31825,8 +31821,8 @@ async function executeWorkerDispatch(options) {
   };
   await runSynthesisPhase(state, options, maxCalls);
   const refined = await runRefinementPhase(state, entries, options, maxCalls);
-  const base = buildDispatchResult(state.results, startMs, logger52, state.totalModelCalls);
-  logDispatchInsights(state.results, logger52);
+  const base = buildDispatchResult(state.results, startMs, logger53, state.totalModelCalls);
+  logDispatchInsights(state.results, logger53);
   return {
     ...base,
     ...refined ? { refined: true } : {},
@@ -31884,18 +31880,18 @@ function recordWorkerOutcomes(results, taskDescription) {
     });
   }
 }
-function buildDispatchResult(results, startMs, logger52, totalModelCalls) {
+function buildDispatchResult(results, startMs, logger53, 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) {
-    logger52.warn("Worker output conflicts detected \u2014 human review recommended", {
+    logger53.warn("Worker output conflicts detected \u2014 human review recommended", {
       conflictCount: conflicts.length,
       files: conflicts.map((c) => c.filePath)
     });
   }
   const durationMs = getTimeProvider().now() - startMs;
-  logger52.info("Worker dispatch complete", {
+  logger53.info("Worker dispatch complete", {
     totalWorkers: results.length,
     successCount,
     errorCount,
@@ -33050,13 +33046,10 @@ function buildOutputFromOrchestratorResult(taskId, orchResult, durationMs, routi
     }
   };
 }
-function createOrchestratorFromDeps(deps, logger52, orchestratorType) {
+function createOrchestratorFromDeps(deps, logger53, orchestratorType) {
   if (deps.orchestrator !== void 0) return deps.orchestrator;
-  const techLead = createOrchestratorWithSica(logger52, deps.modelAdapter);
-  const factory = new OrchestratorFactory({
-    logger: logger52,
-    techLead
-  });
+  const techLead = createOrchestratorWithSica(logger53, deps.modelAdapter);
+  const factory = new OrchestratorFactory({ logger: logger53, techLead });
   return factory.create(orchestratorType ?? "orchestrator");
 }
 function createErrorOptions(taskId, cause) {
@@ -33168,16 +33161,16 @@ function recordOrchestrationError(errorMessage, taskDescription, durationMs) {
   }
 }
 function routeAndPrepare(input, deps, router) {
-  const logger52 = deps.logger ?? createLogger({ tool: "orchestrate" });
-  const workflowRouter = router ?? createWorkflowRouter({ logger: logger52 });
+  const logger53 = deps.logger ?? createLogger({ tool: "orchestrate" });
+  const workflowRouter = router ?? createWorkflowRouter({ logger: logger53 });
   const decision = workflowRouter.route({ description: input.task });
   const orchType = mapPatternToOrchestratorType(decision.pattern);
-  logger52.info("Workflow pattern selected", {
+  logger53.info("Workflow pattern selected", {
     pattern: decision.pattern,
     orchestratorType: orchType
   });
-  const orchestrator = createOrchestratorFromDeps(deps, logger52, orchType);
-  return { workflowRouter, decision, orchestrator, logger: logger52 };
+  const orchestrator = createOrchestratorFromDeps(deps, logger53, orchType);
+  return { workflowRouter, decision, orchestrator, logger: logger53 };
 }
 function buildRoutingInfo(decision) {
   return {
@@ -33196,10 +33189,10 @@ function recordRouterOutcome(workflowRouter, decision, success, durationMs) {
     timestamp: getTimeProvider().now()
   });
 }
-function handleOrchestrationException(error, taskId, task, logger52) {
+function handleOrchestrationException(error, taskId, task, logger53) {
   const message = error instanceof Error ? error.message : "Unknown error";
   const cause = error instanceof Error ? error : void 0;
-  logger52.error("Orchestration exception", cause, { taskId });
+  logger53.error("Orchestration exception", cause, { taskId });
   recordOrchestrationError(message, task);
   return err(
     new OrchestrationError(
@@ -33208,13 +33201,13 @@ function handleOrchestrationException(error, taskId, task, logger52) {
     )
   );
 }
-function startHeartbeatTracking(label, logger52) {
+function startHeartbeatTracking(label, logger53) {
   const monitor = getHeartbeatMonitor();
   const sessionId = monitor.startSession(label);
   const timer = setInterval(() => {
     monitor.heartbeat(sessionId);
     if (monitor.isStalled(sessionId)) {
-      logger52.warn("Orchestration session stalled", { label, sessionId });
+      logger53.warn("Orchestration session stalled", { label, sessionId });
     }
   }, HEARTBEAT_TIMEOUTS.heartbeatIntervalMs);
   return {
@@ -33285,8 +33278,8 @@ function handleOrchestratorSuccess(ctx) {
   });
   return ok(output2);
 }
-async function executeOrchestration(input, deps, router, snapshot) {
-  const { workflowRouter, decision, orchestrator, logger: logger52 } = routeAndPrepare(input, deps, router);
+async function executeOrchestration(input, deps, router, snapshot, trustTier) {
+  const { workflowRouter, decision, orchestrator, logger: logger53 } = routeAndPrepare(input, deps, router);
   const taskId = generateTaskId();
   const startTime = getTimeProvider().now();
   if (snapshot !== void 0) setRouting(snapshot, buildRoutingInfo(decision));
@@ -33296,18 +33289,18 @@ async function executeOrchestration(input, deps, router, snapshot) {
     decision,
     workflowRouter,
     startTime,
-    logger: logger52
+    logger: logger53
   });
   if (fastResult !== void 0) {
     if (snapshot !== void 0 && fastResult.ok) setAnalysis(snapshot, fastResult.value.analysis);
     return fastResult;
   }
-  logger52.info("Starting orchestration", { taskId, taskLength: input.task.length });
-  recordTaskStateInit(taskId, input.task, logger52);
+  logger53.info("Starting orchestration", { taskId, taskLength: input.task.length });
+  recordTaskStateInit(taskId, input.task, logger53);
   const task = await createTaskFromInput(input, taskId);
   const definition = { type: "task", task };
-  const hb = startHeartbeatTracking(`orchestrate-${taskId}`, logger52);
-  const policy = await deriveOrchestratePolicy(input.task, deps, logger52);
+  const hb = startHeartbeatTracking(`orchestrate-${taskId}`, logger53);
+  const policy = await deriveOrchestratePolicy(input.task, deps, logger53, trustTier);
   try {
     return await runOrchestratorWithStateTracking({
       taskId,
@@ -33318,23 +33311,23 @@ async function executeOrchestration(input, deps, router, snapshot) {
       decision,
       workflowRouter,
       startTime,
-      logger: logger52
+      logger: logger53
     });
   } catch (error) {
-    recordTaskStateBlocker(taskId, error instanceof Error ? error.message : String(error), logger52);
-    recordTaskStateStage(taskId, "blocked", logger52);
-    return handleOrchestrationException(error, taskId, input.task, logger52);
+    recordTaskStateBlocker(taskId, error instanceof Error ? error.message : String(error), logger53);
+    recordTaskStateStage(taskId, "blocked", logger53);
+    return handleOrchestrationException(error, taskId, input.task, logger53);
   } finally {
     hb.cleanup();
   }
 }
 async function runOrchestratorWithStateTracking(params) {
-  const { taskId, taskInput, definition, orchestrator, policy, logger: logger52 } = params;
-  recordTaskStateStage(taskId, "executing", logger52);
+  const { taskId, taskInput, definition, orchestrator, policy, logger: logger53 } = params;
+  recordTaskStateStage(taskId, "executing", logger53);
   const result = await withAccessPolicy(policy, () => orchestrator.execute(definition, {}));
   if (!result.ok) {
-    recordTaskStateBlocker(taskId, result.error.message, logger52);
-    recordTaskStateStage(taskId, "blocked", logger52);
+    recordTaskStateBlocker(taskId, result.error.message, logger53);
+    recordTaskStateStage(taskId, "blocked", logger53);
     return handleOrchestratorFailure({
       error: result.error,
       taskId,
@@ -33342,10 +33335,10 @@ async function runOrchestratorWithStateTracking(params) {
       decision: params.decision,
       workflowRouter: params.workflowRouter,
       startTime: params.startTime,
-      logger: logger52
+      logger: logger53
     });
   }
-  recordTaskStateStage(taskId, "complete", logger52);
+  recordTaskStateStage(taskId, "complete", logger53);
   return handleOrchestratorSuccess({
     orchResult: result.value,
     taskId,
@@ -33353,7 +33346,7 @@ async function runOrchestratorWithStateTracking(params) {
     decision: params.decision,
     workflowRouter: params.workflowRouter,
     startTime: params.startTime,
-    logger: logger52
+    logger: logger53
   });
 }
 function isTaskStateEnabled() {
@@ -33362,7 +33355,7 @@ function isTaskStateEnabled() {
   const normalized = raw.toLowerCase();
   return normalized !== "0" && normalized !== "false";
 }
-function recordTaskStateInit(taskId, taskText, logger52) {
+function recordTaskStateInit(taskId, taskText, logger53) {
   if (!isTaskStateEnabled()) return;
   const now = getTimeProvider().nowIso();
   const initial = {
@@ -33375,46 +33368,46 @@ function recordTaskStateInit(taskId, taskText, logger52) {
   };
   const result = initTaskState(initial);
   if (!result.ok) {
-    logger52.warn("task-state: init failed, continuing", {
+    logger53.warn("task-state: init failed, continuing", {
       taskId,
       error: result.error.message,
       taskLength: taskText.length
     });
   }
 }
-function recordTaskStateStage(taskId, stage, logger52) {
+function recordTaskStateStage(taskId, stage, logger53) {
   if (!isTaskStateEnabled()) return;
   const result = updateStage(taskId, stage, getTimeProvider().nowIso());
   if (!result.ok) {
-    logger52.warn("task-state: stage update failed", {
+    logger53.warn("task-state: stage update failed", {
       taskId,
       stage,
       error: result.error.message
     });
   }
 }
-function recordTaskStateBlocker(taskId, blocker, logger52) {
+function recordTaskStateBlocker(taskId, blocker, logger53) {
   if (!isTaskStateEnabled()) return;
   const ts = getTimeProvider().nowIso();
   const result = appendBlocker(taskId, { ts, blocker });
   if (!result.ok) {
-    logger52.warn("task-state: blocker record failed", {
+    logger53.warn("task-state: blocker record failed", {
       taskId,
       error: result.error.message
     });
   }
 }
-async function deriveOrchestratePolicy(taskText, deps, logger52) {
+async function deriveOrchestratePolicy(taskText, deps, logger53, trustTier) {
   const mode = resolveAccessPolicyMode();
   try {
     const opts = {
       mode,
-      trustTier: "1",
+      trustTier: trustTier ?? "4",
       ...deps.modelAdapter !== void 0 ? { adapter: deps.modelAdapter } : {}
     };
     const policy = await deriveAccessPolicy(taskText, opts);
     if (mode !== "off") {
-      logger52.info("access-policy: derived", {
+      logger53.info("access-policy: derived", {
         mode,
         source: policy.source,
         allowedToolsWildcard: policy.allowedTools === "*"
@@ -33422,7 +33415,7 @@ async function deriveOrchestratePolicy(taskText, deps, logger52) {
     }
     return policy;
   } catch (error) {
-    logger52.warn("access-policy: derivation failed", {
+    logger53.warn("access-policy: derivation failed", {
       mode,
       error: getErrorMessage(error),
       failClosed: mode === "enforce" || mode === "confirm_risky"
@@ -33449,22 +33442,22 @@ async function deriveOrchestratePolicy(taskText, deps, logger52) {
     };
   }
 }
-function instrumentV2Orchestrate(input, logger52) {
-  const tc = orchestrateInputToTaskContract(input);
+function instrumentV2Orchestrate(input, logger53, trustTier) {
+  const tc = orchestrateInputToTaskContract(input, trustTier !== void 0 ? { trustTier } : {});
   void executeOrchestratePipeline(tc).then((m) => {
-    logger52.info("V2 orchestrate pipeline", { ...m });
+    logger53.info("V2 orchestrate pipeline", { ...m });
   }).catch((error) => {
-    logger52.debug("V2 orchestrate pipeline failed", { error: getErrorMessage(error) });
+    logger53.debug("V2 orchestrate pipeline failed", { error: getErrorMessage(error) });
   });
 }
-async function tryWorkerDispatch(agentPlan, task, deps, logger52, notifier) {
+async function tryWorkerDispatch(agentPlan, task, deps, logger53, notifier) {
   const adapter = deps.modelAdapter;
   if (agentPlan === void 0 || !isWorkerDispatchEnabled() || adapter === void 0) {
     return void 0;
   }
   const abortSignal = abortSignalStorage.getStore();
   if (abortSignal?.aborted === true) {
-    logger52.info("Worker dispatch aborted before start (client cancelled)");
+    logger53.info("Worker dispatch aborted before start (client cancelled)");
     return void 0;
   }
   try {
@@ -33475,14 +33468,14 @@ async function tryWorkerDispatch(agentPlan, task, deps, logger52, notifier) {
         agentPlan,
         taskDescription: task,
         modelAdapter: adapter,
-        logger: logger52,
+        logger: logger53,
         synthesize: true,
         refine: true,
         perWorkerRouting: true
       })
     );
   } catch (dispatchError) {
-    logger52.warn("Worker dispatch failed, continuing with standard orchestration", {
+    logger53.warn("Worker dispatch failed, continuing with standard orchestration", {
       error: dispatchError instanceof Error ? dispatchError.message : String(dispatchError)
     });
     return void 0;
@@ -33543,7 +33536,7 @@ function buildTimeoutOrchestrationResult(taskId, elapsedMs, reason, snapshot) {
   return ok(output2);
 }
 async function executeOrchestrationWithDeadline(params) {
-  const { input, deps, notifier, logger: logger52 } = params;
+  const { input, deps, notifier, logger: logger53, trustTier } = params;
   const overallDeadlineMs = getMcpSafeDeadlineMs(
     MCP_TIMEOUTS.perTool["orchestrate"] ?? MCP_TIMEOUTS.defaultMs,
     "orchestrate"
@@ -33554,11 +33547,11 @@ async function executeOrchestrationWithDeadline(params) {
     withProgressHeartbeat(
       "orchestrate",
       notifier,
-      () => executeOrchestration(input, deps, void 0, snapshot)
+      () => executeOrchestration(input, deps, void 0, snapshot, trustTier)
     ),
     overallDeadlineMs,
     (elapsedMs) => {
-      logger52.warn("Orchestration overall deadline reached; returning partial result", {
+      logger53.warn("Orchestration overall deadline reached; returning partial result", {
         overallDeadlineMs,
         elapsedMs,
         stage: snapshot.stage
@@ -33573,23 +33566,29 @@ async function executeOrchestrationWithDeadline(params) {
   );
 }
 async function runOrchestratePipeline(params) {
-  const { input, deps, notifier, logger: logger52 } = params;
-  logger52.debug("Starting orchestration", { taskLength: input.task.length });
+  const { input, deps, notifier, logger: logger53, trustTier } = params;
+  logger53.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, logger52);
-  await injectMemoryContextForOrchestrate(input, logger52);
-  const agentPlan = v2Config.aorchestraEnabled ? computeAgentPlan(input.task, logger52) : void 0;
+  if (v2Config.orchestrateEnabled) instrumentV2Orchestrate(input, logger53, trustTier);
+  await injectMemoryContextForOrchestrate(input, logger53);
+  const agentPlan = v2Config.aorchestraEnabled ? computeAgentPlan(input.task, logger53) : void 0;
   const workerDispatchResult = await tryWorkerDispatch(
     agentPlan,
     input.task,
     deps,
-    logger52,
+    logger53,
     notifier
   );
   recordAndReflect(workerDispatchResult, input.task, deps);
-  const result = await executeOrchestrationWithDeadline({ input, deps, notifier, logger: logger52 });
+  const result = await executeOrchestrationWithDeadline({
+    input,
+    deps,
+    notifier,
+    logger: logger53,
+    ...trustTier !== void 0 ? { trustTier } : {}
+  });
   if (!result.ok) {
     return toolStructuredError({
       errorCategory: "internal",
@@ -33603,15 +33602,15 @@ async function runOrchestratePipeline(params) {
   });
   return assembleOrchestrateOutput(result.value, agentPlan, workerDispatchResult);
 }
-async function injectMemoryContextForOrchestrate(input, logger52) {
+async function injectMemoryContextForOrchestrate(input, logger53) {
   try {
     const ctx = await getContextForTask({
       task: input.task,
       category: inferTaskCategory(input.task),
-      logger: logger52
+      logger: logger53
     });
     const summary = summarizeContextForPrompt(ctx);
-    logger52.debug("orchestrate: unified memory context", {
+    logger53.debug("orchestrate: unified memory context", {
       beliefs: ctx.beliefs.length,
       similarMemories: ctx.similarMemories.length,
       recentLearnings: ctx.recentLearnings.length,
@@ -33624,7 +33623,7 @@ async function injectMemoryContextForOrchestrate(input, logger52) {
       mutable.context = { ...mutable.context ?? {}, priorMemorySummary: summary };
     }
   } catch (error) {
-    logger52.debug("orchestrate: context retrieval failed", { error: getErrorMessage(error) });
+    logger53.debug("orchestrate: context retrieval failed", { error: getErrorMessage(error) });
   }
 }
 function createOrchestrateHandler(deps) {
@@ -33645,7 +33644,9 @@ function createOrchestrateHandler(deps) {
           input: validated.data,
           deps,
           notifier,
-          logger: ctx.logger
+          logger: ctx.logger,
+          // Threaded from the secure-handler RequestContext (#2957).
+          trustTier: ctx.requestContext.trustTier
         })
       );
     } catch (depthError) {
@@ -33656,7 +33657,7 @@ function createOrchestrateHandler(deps) {
   };
 }
 function registerOrchestrateTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "orchestrate" });
+  const logger53 = 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";
@@ -33664,12 +33665,12 @@ function registerOrchestrateTool(server, deps) {
     toolName: "orchestrate",
     securityTier: "user-facing",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const configuredTimeoutMs = MCP_TIMEOUTS.perTool["orchestrate"] ?? MCP_TIMEOUTS.defaultMs;
   const wrappedHandler = wrapToolWithTimeout("orchestrate", secureHandler, {
     timeoutMs: configuredTimeoutMs,
-    logger: logger52
+    logger: logger53
   });
   server.registerTool(
     "orchestrate",
@@ -33678,9 +33679,9 @@ function registerOrchestrateTool(server, deps) {
       inputSchema: ORCHESTRATE_TOOL_SCHEMA,
       annotations: getToolAnnotations("orchestrate")
     },
-    toSdkCallbackWithBudgetCheck(wrappedHandler, "orchestrate", configuredTimeoutMs, logger52)
+    toSdkCallbackWithBudgetCheck(wrappedHandler, "orchestrate", configuredTimeoutMs, logger53)
   );
-  logger52.info("Registered orchestrate tool with secure handler and timeout protection");
+  logger53.info("Registered orchestrate tool with secure handler and timeout protection");
 }
 
 // src/mcp/tools/delegate-to-model-types.ts
@@ -34043,21 +34044,21 @@ function mapCompositeDecisionToOutput(decision, estimatedTokens) {
     }))
   };
 }
-async function routeViaCompositeRouter(task, router, feedbackIntegration, logger52) {
+async function routeViaCompositeRouter(task, router, feedbackIntegration, logger53) {
   const result = await router.route({ content: task });
   if (!result.ok) {
-    logger52.warn("CompositeRouter routing failed", { error: result.error.message });
+    logger53.warn("CompositeRouter routing failed", { error: result.error.message });
     return null;
   }
   const decision = result.value;
   let routingId;
   if (feedbackIntegration) {
     routingId = feedbackIntegration.recordRoutingDecision(decision);
-    logger52.debug("Recorded routing decision", { routingId, cliName: decision.cliName });
+    logger53.debug("Recorded routing decision", { routingId, cliName: decision.cliName });
   }
   return { decision, routingId, feedbackIntegration };
 }
-function recordRoutingOutcome(result, durationMs, logger52) {
+function recordRoutingOutcome(result, durationMs, logger53) {
   if (result.routingId === void 0 || result.feedbackIntegration === void 0) return;
   try {
     const topsisScore = result.decision.topsisScore ?? 0;
@@ -34070,13 +34071,13 @@ function recordRoutingOutcome(result, durationMs, logger52) {
       tokenUsage: 0
       // delegate-to-model is a recommendation, not execution
     });
-    logger52.debug("Recorded routing outcome", {
+    logger53.debug("Recorded routing outcome", {
       routingId: result.routingId,
       topsisScore,
       success: topsisScore >= TOPSIS_CONFIDENCE_THRESHOLD
     });
   } catch (error) {
-    logger52.warn("Failed to record routing outcome", { error: getErrorMessage(error) });
+    logger53.warn("Failed to record routing outcome", { error: getErrorMessage(error) });
   }
 }
 
@@ -34097,9 +34098,9 @@ function classifyWithGovernance(toolName, params, overrides) {
   const promotionReason = promoted ? buildPromotionReason(domain, params) : null;
   return { tier, promoted, domain, votingThreshold, promotionReason };
 }
-function auditGovernancePromotion(classification, toolName, logger52) {
+function auditGovernancePromotion(classification, toolName, logger53) {
   if (!classification.promoted) return;
-  const log = logger52 ?? createLogger({ component: "governance" });
+  const log = logger53 ?? createLogger({ component: "governance" });
   log.warn("Governance promotion", {
     tool: toolName,
     domain: classification.domain,
@@ -34170,9 +34171,9 @@ function recordToMemory(task, model, usedRouter) {
     });
   }
 }
-function classifyDelegateGovernance(input, logger52) {
+function classifyDelegateGovernance(input, logger53) {
   const classification = classifyWithGovernance("delegate_to_model", { task: input.task });
-  auditGovernancePromotion(classification, "delegate_to_model", logger52);
+  auditGovernancePromotion(classification, "delegate_to_model", logger53);
   return classification;
 }
 function enrichWithGovernance(output2, governance) {
@@ -34186,12 +34187,12 @@ function enrichWithGovernance(output2, governance) {
     }
   };
 }
-function instrumentV2Pipeline(input, logger52) {
-  const tc = delegateInputToTaskContract(input);
+function instrumentV2Pipeline(input, logger53, trustTier) {
+  const tc = delegateInputToTaskContract(input, trustTier !== void 0 ? { trustTier } : {});
   void executeDelegatePipeline(tc).then((m) => {
-    logger52.info("V2 delegate pipeline", { ...m });
+    logger53.info("V2 delegate pipeline", { ...m });
   }).catch((error) => {
-    logger52.warn("V2 delegate instrumentation failed", { error: getErrorMessage(error) });
+    logger53.warn("V2 delegate instrumentation failed", { error: getErrorMessage(error) });
   });
 }
 function notifyAndRecord(opts) {
@@ -34241,7 +34242,9 @@ function createDelegateHandler(deps) {
     notifier.info("delegate", { event: "routing_start", taskLength: input.task.length });
     ctx.logger.info("Analyzing task for model routing", { taskLength: input.task.length });
     const governance = classifyDelegateGovernance(input, ctx.logger);
-    if (resolveV2Config().delegateEnabled) instrumentV2Pipeline(input, ctx.logger);
+    if (resolveV2Config().delegateEnabled) {
+      instrumentV2Pipeline(input, ctx.logger, ctx.requestContext.trustTier);
+    }
     const baseOpts = {
       notifier,
       task: input.task,
@@ -34265,18 +34268,18 @@ function createDelegateHandler(deps) {
   };
 }
 function registerDelegateToModelTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "delegate_to_model" });
+  const logger53 = 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: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("delegate_to_model", deps.security);
   const wrappedHandler = wrapToolWithTimeout("delegate_to_model", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   server.registerTool(
     "delegate_to_model",
@@ -34288,7 +34291,7 @@ function registerDelegateToModelTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered delegate_to_model tool with secure handler and timeout protection");
+  logger53.info("Registered delegate_to_model tool with secure handler and timeout protection");
 }
 
 // src/mcp/tools/run-graph-workflow-multicli-templates.ts
@@ -35230,7 +35233,7 @@ function listExpertsHandler(args, ctx) {
   return Promise.resolve(toolSuccessStructured(data));
 }
 function registerListExpertsTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "list_experts" });
+  const logger53 = 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)")
   };
@@ -35238,10 +35241,10 @@ function registerListExpertsTool(server, deps) {
   const secureHandler = createSecureHandler(listExpertsHandler, {
     toolName: "list_experts",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("list_experts", deps.security);
-  const wrappedHandler = wrapToolWithTimeout("list_experts", secureHandler, { timeoutMs, logger: logger52 });
+  const wrappedHandler = wrapToolWithTimeout("list_experts", secureHandler, { timeoutMs, logger: logger53 });
   const outputSchema = {
     experts: z57.array(
       z57.object({
@@ -35263,7 +35266,7 @@ function registerListExpertsTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered list_experts tool with secure handler and timeout protection");
+  logger53.info("Registered list_experts tool with secure handler and timeout protection");
 }
 
 // src/mcp/tools/list-workflows.ts
@@ -35322,7 +35325,7 @@ function createListWorkflowsHandler(workflowEngine) {
   };
 }
 function registerListWorkflowsTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "list_workflows" });
+  const logger53 = 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)")
@@ -35331,13 +35334,13 @@ function registerListWorkflowsTool(server, deps) {
   const secureHandler = createSecureHandler(createListWorkflowsHandler(deps.workflowEngine), {
     toolName: "list_workflows",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = deps.security?.timeout?.defaultTimeoutMs;
   const wrappedHandler = wrapToolWithTimeout(
     "list_workflows",
     secureHandler,
-    timeoutMs !== void 0 ? { timeoutMs, logger: logger52 } : { logger: logger52 }
+    timeoutMs !== void 0 ? { timeoutMs, logger: logger53 } : { logger: logger53 }
   );
   const outputSchema = {
     workflows: z58.array(
@@ -35361,7 +35364,7 @@ function registerListWorkflowsTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered list_workflows tool with secure handler and timeout protection");
+  logger53.info("Registered list_workflows tool with secure handler and timeout protection");
 }
 
 // src/mcp/tools/execute-expert.ts
@@ -35445,12 +35448,12 @@ function recordExpertError2(expertId, role, errorMessage) {
     });
   }
 }
-function autoCatalogScan(output2, expertId, logger52) {
+function autoCatalogScan(output2, expertId, logger53) {
   try {
     const catalog = getAutoCatalog();
     catalog.scanAndRecord(output2, "execute_expert");
   } catch (error) {
-    logger52?.debug("Best-effort auto-catalog scan failed", {
+    logger53?.debug("Best-effort auto-catalog scan failed", {
       error: getErrorMessage(error),
       expertId
     });
@@ -35509,11 +35512,11 @@ function computeExpertContextUtilization(observation, threshold = DEFAULT_CONTEX
     threshold
   };
 }
-function observeExpertContext(observation, logger52, threshold = resolveContextWarnThreshold()) {
+function observeExpertContext(observation, logger53, threshold = resolveContextWarnThreshold()) {
   try {
     const util = computeExpertContextUtilization(observation, threshold);
     if (util.warned) {
-      logger52?.warn("context_warning", {
+      logger53?.warn("context_warning", {
         event: "context_warning",
         expertId: observation.expertId,
         role: observation.role,
@@ -35526,7 +35529,7 @@ function observeExpertContext(observation, logger52, threshold = resolveContextW
         taskLength: observation.taskDescription.length
       });
     } else {
-      logger52?.debug("context_utilization", {
+      logger53?.debug("context_utilization", {
         event: "context_utilization",
         expertId: observation.expertId,
         role: observation.role,
@@ -35614,7 +35617,7 @@ function buildSuccessResponse(params) {
   }
   return response;
 }
-function observeExpertContextIfOk(result, expert, task, durationMs, logger52) {
+function observeExpertContextIfOk(result, expert, task, durationMs, logger53) {
   if (!result.ok) return;
   const expertModelId = expert.expertConfig.modelPreference?.modelId;
   const observation = {
@@ -35625,24 +35628,24 @@ function observeExpertContextIfOk(result, expert, task, durationMs, logger52) {
     taskDescription: task.description,
     durationMs
   };
-  observeExpertContext(observation, logger52);
+  observeExpertContext(observation, logger53);
 }
-async function deriveExpertAccessPolicy(task, logger52) {
+async function deriveExpertAccessPolicy(task, logger53, trustTier) {
   const mode = resolveAccessPolicyMode();
   try {
     const policy = await deriveAccessPolicy(task.description, {
       mode,
-      trustTier: "1"
+      trustTier: trustTier ?? "4"
     });
     if (mode !== "off") {
-      logger52?.info("access-policy: derived (expert)", {
+      logger53?.info("access-policy: derived (expert)", {
         mode,
         source: policy.source
       });
     }
     return policy;
   } catch (error) {
-    logger52?.warn("access-policy: derivation failed (expert)", {
+    logger53?.warn("access-policy: derivation failed (expert)", {
       mode,
       error: getErrorMessage(error),
       failClosed: mode === "enforce" || mode === "confirm_risky"
@@ -35701,11 +35704,11 @@ function isExpertDegraded(role) {
   }
   return consecutive >= DEGRADATION_CONSECUTIVE_THRESHOLD;
 }
-async function tryExpertFallback(expert, task, logger52) {
+async function tryExpertFallback(expert, task, logger53) {
   const roleKey = `${expert.role}_expert`;
   const category = ROLE_TO_TASK_CATEGORY[roleKey];
   if (category === void 0) return void 0;
-  const effectiveLogger = logger52 ?? createLogger({ tool: "execute_expert" });
+  const effectiveLogger = logger53 ?? createLogger({ tool: "execute_expert" });
   const registry = getGlobalRegistry({ logger: effectiveLogger });
   const routing = registry.getRouting(category);
   const primaryCli = routing?.primaryCli ?? "unknown";
@@ -35714,7 +35717,7 @@ async function tryExpertFallback(expert, task, logger52) {
   const fallbackCli = chain[0];
   if (fallbackCli === void 0) return void 0;
   const fallbackAdapter = registry.getAdapterForCli(fallbackCli);
-  logger52?.info("Retrying expert with fallback CLI", { role: expert.role, fallbackCli });
+  logger53?.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();
@@ -35734,7 +35737,7 @@ async function tryExpertFallback(expert, task, logger52) {
   };
 }
 async function classifyExpertResult(opts) {
-  const { result, expert, task, args, durationMs, logger: logger52 } = opts;
+  const { result, expert, task, args, durationMs, logger: logger53 } = opts;
   const modelId = expert.expertConfig.modelPreference?.modelId;
   const info = {
     expertId: args.expertId,
@@ -35743,19 +35746,19 @@ async function classifyExpertResult(opts) {
   };
   if (!result.ok) {
     if (isRateLimitFailure(result.error.message)) {
-      const fallback = await tryExpertFallback(expert, task, logger52);
+      const fallback = await tryExpertFallback(expert, task, logger53);
       if (fallback !== void 0) return fallback;
     }
-    logger52?.warn("Expert execution failed", {
+    logger53?.warn("Expert execution failed", {
       expertId: args.expertId,
       error: result.error.message
     });
     return handleExpertFailure(args.task, info, result.error.message, durationMs);
   }
-  logger52?.info("Expert execution completed", { expertId: args.expertId, durationMs });
+  logger53?.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, logger52);
+    autoCatalogScan(result.value.output, args.expertId, logger53);
   }
   return {
     ok: true,
@@ -35792,7 +35795,7 @@ async function runExpertTask(deps, args, expert) {
       }, HEARTBEAT_TIMEOUTS.heartbeatIntervalMs);
       let result;
       try {
-        const policy = await deriveExpertAccessPolicy(task, deps.logger);
+        const policy = await deriveExpertAccessPolicy(task, deps.logger, void 0);
         result = await withAccessPolicy(policy, () => expert.execute(task));
       } finally {
         clearInterval(heartbeatTimer);
@@ -35843,7 +35846,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, logger52) {
+function createTaskHandler(deps, logger53) {
   const notifier = deps.notifier ?? NOOP_NOTIFIER;
   return {
     createTask: (args, extra) => {
@@ -35855,7 +35858,7 @@ function createTaskHandler(deps, logger52) {
       const { taskStore } = extra;
       const ttl = clampTaskTtl(DEFAULT_TASK_TTL_MS);
       const taskPromise = taskStore.createTask({ ttl, pollInterval: 5e3 }).then((task) => {
-        logger52.info("Task created for execute_expert", {
+        logger53.info("Task created for execute_expert", {
           taskId: task.taskId,
           expertId: validatedArgs.expertId
         });
@@ -35880,7 +35883,7 @@ function createTaskHandler(deps, logger52) {
 }
 async function runBackgroundExpertTask(opts) {
   const { deps, args, taskId, taskStore, notifier } = opts;
-  const logger52 = deps.logger ?? createLogger({ tool: "execute_expert" });
+  const logger53 = deps.logger ?? createLogger({ tool: "execute_expert" });
   try {
     notifier.info("execute_expert", {
       event: "expert_start",
@@ -35913,7 +35916,7 @@ async function runBackgroundExpertTask(opts) {
     });
   } catch (error) {
     const message = getErrorMessage(error);
-    logger52.warn("Background expert task failed", { taskId, error: message });
+    logger53.warn("Background expert task failed", { taskId, error: message });
     try {
       await taskStore.storeTaskResult(taskId, "failed", {
         ...toolStructuredError({
@@ -35922,7 +35925,7 @@ async function runBackgroundExpertTask(opts) {
         })
       });
     } catch (storeError) {
-      logger52.warn("Failed to store task failure result", {
+      logger53.warn("Failed to store task failure result", {
         taskId,
         error: getErrorMessage(storeError)
       });
@@ -35930,7 +35933,7 @@ async function runBackgroundExpertTask(opts) {
   }
 }
 function registerExecuteExpertTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "execute_expert" });
+  const logger53 = 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.";
@@ -35942,9 +35945,9 @@ function registerExecuteExpertTool(server, deps) {
       execution: { taskSupport: "optional" },
       annotations: getToolAnnotations("execute_expert")
     },
-    createTaskHandler(depsWithNotifier, logger52)
+    createTaskHandler(depsWithNotifier, logger53)
   );
-  logger52.info("Registered execute_expert tool with MCP Tasks support (taskSupport: optional)");
+  logger53.info("Registered execute_expert tool with MCP Tasks support (taskSupport: optional)");
 }
 
 // src/mcp/tools/research-query.ts
@@ -37343,15 +37346,15 @@ function createResearchQueryHandler(deps) {
       });
     }
     ctx.logger.debug("Executing research query", { action: validationResult.data.action });
-    const logger52 = deps.logger ?? createLogger({ tool: "research_query" });
-    return withToolError("Research query failed", logger52, async () => {
+    const logger53 = deps.logger ?? createLogger({ tool: "research_query" });
+    return withToolError("Research query failed", logger53, async () => {
       const result = await executeQuery(validationResult.data);
       return toolSuccessStructured(result);
     });
   };
 }
 function registerResearchQueryTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "research_query" });
+  const logger53 = 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"),
@@ -37363,12 +37366,12 @@ function registerResearchQueryTool(server, deps) {
   const secureHandler = createSecureHandler(createResearchQueryHandler(deps), {
     toolName: "research_query",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("research_query", deps.security);
   const wrappedHandler = wrapToolWithTimeout("research_query", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   const outputSchema = {
     action: z62.string(),
@@ -37385,7 +37388,7 @@ function registerResearchQueryTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered research_query tool with secure handler and timeout protection");
+  logger53.info("Registered research_query tool with secure handler and timeout protection");
 }
 
 // src/mcp/tools/research-add.ts
@@ -37396,7 +37399,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, logger52) {
+async function executeResearchAdd(input, logger53) {
   const exists = await paperExists(input.arxivId);
   if (exists) {
     return {
@@ -37416,7 +37419,7 @@ async function executeResearchAdd(input, logger52) {
   });
   if (result.success && !input.dryRun) {
     try {
-      const memory = getToolMemory(logger52);
+      const memory = getToolMemory(logger53);
       memory.recordLearning({
         pattern: `Added paper: ${result.title} (${result.paperId})`,
         context: `topic=${input.topic ?? "general"}, priority=${input.priority ?? "unset"}`,
@@ -37424,7 +37427,7 @@ async function executeResearchAdd(input, logger52) {
         source: "research_add"
       });
     } catch {
-      logger52.debug("Failed to record learning in session memory");
+      logger53.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.]" : "";
@@ -37446,9 +37449,9 @@ function createResearchAddHandler(deps) {
       });
     }
     ctx.logger.debug("Adding research paper", { arxivId: validationResult.data.arxivId });
-    const logger52 = deps.logger ?? createLogger({ tool: "research_add" });
-    return withToolError("Failed to add paper", logger52, async () => {
-      const result = await executeResearchAdd(validationResult.data, logger52);
+    const logger53 = deps.logger ?? createLogger({ tool: "research_add" });
+    return withToolError("Failed to add paper", logger53, async () => {
+      const result = await executeResearchAdd(validationResult.data, logger53);
       if (!result.success) {
         return toolStructuredError({
           errorCategory: result.errorCategory ?? "internal",
@@ -37460,7 +37463,7 @@ function createResearchAddHandler(deps) {
   };
 }
 function registerResearchAddTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "research_add" });
+  const logger53 = 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"),
@@ -37471,12 +37474,12 @@ function registerResearchAddTool(server, deps) {
   const secureHandler = createSecureHandler(createResearchAddHandler(deps), {
     toolName: "research_add",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("research_add", deps.security);
   const wrappedHandler = wrapToolWithTimeout("research_add", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   const outputSchema = {
     success: z63.boolean(),
@@ -37495,7 +37498,7 @@ function registerResearchAddTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered research_add tool with secure handler and timeout protection");
+  logger53.info("Registered research_add tool with secure handler and timeout protection");
 }
 
 // src/mcp/tools/research-add-source.ts
@@ -37573,9 +37576,9 @@ function buildResponse2(params) {
     ...params.errorCategory !== void 0 ? { errorCategory: params.errorCategory } : {}
   };
 }
-function recordAddSourceLearning(logger52, name, sourceId, type, qualityScore) {
+function recordAddSourceLearning(logger53, name, sourceId, type, qualityScore) {
   try {
-    const memory = getToolMemory(logger52);
+    const memory = getToolMemory(logger53);
     memory.recordLearning({
       pattern: `Added source: ${name} (${sourceId})`,
       context: `type=${type}, quality=${String(qualityScore)}`,
@@ -37583,7 +37586,7 @@ function recordAddSourceLearning(logger52, name, sourceId, type, qualityScore) {
       source: "research_add_source"
     });
   } catch {
-    logger52.debug("Failed to record learning in session memory");
+    logger53.debug("Failed to record learning in session memory");
   }
 }
 function prepareSource(input) {
@@ -37591,7 +37594,7 @@ function prepareSource(input) {
   const score = computeSourceQualityScore(entry);
   return { entry, score };
 }
-async function executeResearchAddSource(input, logger52) {
+async function executeResearchAddSource(input, logger53) {
   const sourceId = generateSourceId(input.url);
   const exists = await sourceExistsInRegistry(input.url);
   if (exists) {
@@ -37628,8 +37631,8 @@ async function executeResearchAddSource(input, logger52) {
       errorCategory: "internal"
     });
   }
-  recordAddSourceLearning(logger52, input.name, sourceId, input.type, score);
-  logger52.info("Added research source", { sourceId, name: input.name, qualityScore: score });
+  recordAddSourceLearning(logger53, input.name, sourceId, input.type, score);
+  logger53.info("Added research source", { sourceId, name: input.name, qualityScore: score });
   return buildResponse2({
     success: true,
     sourceId,
@@ -37649,9 +37652,9 @@ function createResearchAddSourceHandler(deps) {
       });
     }
     ctx.logger.debug("Adding research source", { url: validationResult.data.url });
-    const logger52 = deps.logger ?? createLogger({ tool: "research_add_source" });
-    return withToolError("Failed to add source", logger52, async () => {
-      const result = await executeResearchAddSource(validationResult.data, logger52);
+    const logger53 = deps.logger ?? createLogger({ tool: "research_add_source" });
+    return withToolError("Failed to add source", logger53, async () => {
+      const result = await executeResearchAddSource(validationResult.data, logger53);
       if (!result.success) {
         return toolStructuredError({
           errorCategory: result.errorCategory ?? "internal",
@@ -37663,7 +37666,7 @@ function createResearchAddSourceHandler(deps) {
   };
 }
 function registerResearchAddSourceTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "research_add_source" });
+  const logger53 = 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"),
@@ -37688,12 +37691,12 @@ function registerResearchAddSourceTool(server, deps) {
     toolName: "research_add_source",
     securityTier: "external",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("research_add_source", deps.security);
   const wrappedHandler = wrapToolWithTimeout("research_add_source", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   server.registerTool(
     "research_add_source",
@@ -37760,7 +37763,7 @@ function toDiscoveredItems(sources) {
     discoveredAt: s.discoveredAt
   }));
 }
-async function discoverFromExtendedSource(source, topic, maxResults, logger52, sinceDate) {
+async function discoverFromExtendedSource(source, topic, maxResults, logger53, sinceDate) {
   let result;
   switch (source) {
     case "google_ai":
@@ -37788,7 +37791,7 @@ async function discoverFromExtendedSource(source, topic, maxResults, logger52, s
       return { items: [], failed: true };
   }
   if (!result.ok) {
-    logger52.warn(`${source} discovery failed`, {
+    logger53.warn(`${source} discovery failed`, {
       source,
       errorCode: result.error.code,
       error: result.error.message
@@ -37828,24 +37831,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, logger52, acc) {
+async function queryExtendedSource(src, input, logger53, acc) {
   acc.sources.push(src);
   try {
     const result = await discoverFromExtendedSource(
       src,
       input.topic,
       input.maxResults,
-      logger52,
+      logger53,
       input.sinceDate
     );
     if (result.failed) acc.failedSources.push(src);
     acc.items = acc.items.concat(result.items);
   } catch (error) {
     acc.failedSources.push(src);
-    logger52.warn("Source discovery failed", { source: src, error: getErrorMessage(error) });
+    logger53.warn("Source discovery failed", { source: src, error: getErrorMessage(error) });
   }
 }
-async function queryAllSources(input, logger52) {
+async function queryAllSources(input, logger53) {
   const acc = { sources: [], failedSources: [], items: [] };
   const isAll = input.source === "all";
   const shouldQuery = (src) => isAll || input.source === src;
@@ -37855,11 +37858,11 @@ async function queryAllSources(input, logger52) {
     if (r.ok) acc.items = acc.items.concat(toDiscoveredItems(r.value));
     else {
       acc.failedSources.push("arxiv");
-      logger52.warn("arxiv discovery failed", { error: r.error.message });
+      logger53.warn("arxiv discovery failed", { error: r.error.message });
     }
   }
   for (const src of ARXIV_ORG_SOURCES) {
-    if (!isAll && input.source === src) await queryExtendedSource(src, input, logger52, acc);
+    if (!isAll && input.source === src) await queryExtendedSource(src, input, logger53, acc);
   }
   if (shouldQuery("github")) {
     acc.sources.push("github");
@@ -37867,15 +37870,15 @@ async function queryAllSources(input, logger52) {
     if (r.ok) acc.items = acc.items.concat(toDiscoveredItems(r.value));
     else {
       acc.failedSources.push("github");
-      logger52.warn("github discovery failed", { error: r.error.message });
+      logger53.warn("github discovery failed", { error: r.error.message });
     }
   }
   for (const src of INDEPENDENT_SOURCES) {
-    if (shouldQuery(src)) await queryExtendedSource(src, input, logger52, acc);
+    if (shouldQuery(src)) await queryExtendedSource(src, input, logger53, acc);
   }
   return acc;
 }
-async function executeDiscovery(rawInput, logger52) {
+async function executeDiscovery(rawInput, logger53) {
   const input = {
     ...rawInput,
     topic: normalizeTopicToCanonical(rawInput.topic)
@@ -37885,7 +37888,7 @@ async function executeDiscovery(rawInput, logger52) {
     sources: sourcesToQuery,
     failedSources,
     items: allItems
-  } = await queryAllSources(input, logger52);
+  } = await queryAllSources(input, logger53);
   markExistingItems(allItems, existingIds);
   const totalFound = allItems.length;
   const inRegistry = allItems.filter((i) => i.alreadyInRegistry).length;
@@ -37897,7 +37900,7 @@ async function executeDiscovery(rawInput, logger52) {
   ).slice(0, input.maxResults);
   const filteredOut = totalFound - inRegistry - relevantItems.length;
   if (filteredOut > 0) {
-    logger52.debug("Filtered out irrelevant results", {
+    logger53.debug("Filtered out irrelevant results", {
       threshold,
       filteredOut,
       remaining: relevantItems.length
@@ -37982,10 +37985,10 @@ function createResearchDiscoverHandler(deps) {
       topic: validationResult.data.topic,
       source: validationResult.data.source
     });
-    const logger52 = deps.logger ?? createLogger({ tool: "research_discover" });
+    const logger53 = deps.logger ?? createLogger({ tool: "research_discover" });
     const startMs = Date.now();
-    const response = await withToolError("Discovery failed", logger52, async () => {
-      const result = await executeDiscovery(validationResult.data, logger52);
+    const response = await withToolError("Discovery failed", logger53, async () => {
+      const result = await executeDiscovery(validationResult.data, logger53);
       return toolSuccessStructured(result);
     });
     const durationMs = Date.now() - startMs;
@@ -37999,7 +38002,7 @@ function createResearchDiscoverHandler(deps) {
   };
 }
 function registerResearchDiscoverTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "research_discover" });
+  const logger53 = deps.logger ?? createLogger({ tool: "research_discover" });
   const toolSchema = {
     topic: z65.string().min(1).max(200).describe("Research topic to search for"),
     source: z65.enum([
@@ -38022,12 +38025,12 @@ function registerResearchDiscoverTool(server, deps) {
   const secureHandler = createSecureHandler(createResearchDiscoverHandler(deps), {
     toolName: "research_discover",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("research_discover", deps.security);
   const wrappedHandler = wrapToolWithTimeout("research_discover", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   server.registerTool(
     "research_discover",
@@ -38039,7 +38042,7 @@ function registerResearchDiscoverTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered research_discover tool with secure handler and timeout protection");
+  logger53.info("Registered research_discover tool with secure handler and timeout protection");
 }
 var RESEARCH_DISCOVER_OUTPUT_SCHEMA = {
   topic: z65.string().optional(),
@@ -38293,15 +38296,15 @@ function createResearchAnalyzeHandler(deps) {
     ctx.logger.debug("Analyzing research registry", {
       focus: validationResult.data.focus
     });
-    const logger52 = deps.logger ?? createLogger({ tool: "research_analyze" });
-    return withToolError("Analysis failed", logger52, async () => {
+    const logger53 = deps.logger ?? createLogger({ tool: "research_analyze" });
+    return withToolError("Analysis failed", logger53, async () => {
       const result = await executeAnalysis(validationResult.data);
       return toolSuccessStructured(result);
     });
   };
 }
 function registerResearchAnalyzeTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "research_analyze" });
+  const logger53 = 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")
@@ -38310,12 +38313,12 @@ function registerResearchAnalyzeTool(server, deps) {
   const secureHandler = createSecureHandler(createResearchAnalyzeHandler(deps), {
     toolName: "research_analyze",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("research_analyze", deps.security);
   const wrappedHandler = wrapToolWithTimeout("research_analyze", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   const outputSchema = {
     focus: z66.string().optional(),
@@ -38333,7 +38336,7 @@ function registerResearchAnalyzeTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered research_analyze tool with secure handler and timeout protection");
+  logger53.info("Registered research_analyze tool with secure handler and timeout protection");
 }
 
 // src/mcp/tools/research-catalog-review.ts
@@ -38356,7 +38359,7 @@ function handleList() {
     data: { pending, count: pending.length }
   };
 }
-async function approveArxivRef(identifier, topic, shouldCreateIssue, logger52) {
+async function approveArxivRef(identifier, topic, shouldCreateIssue, logger53) {
   const catalog = getAutoCatalog();
   const exists = await paperExists(identifier);
   if (exists) {
@@ -38368,7 +38371,7 @@ async function approveArxivRef(identifier, topic, shouldCreateIssue, logger52) {
   if (!result.success) {
     return { action: "approve", success: false, message: `Failed: ${result.message}` };
   }
-  logger52.info("Approved paper", { paperId: result.paperId });
+  logger53.info("Approved paper", { paperId: result.paperId });
   if (shouldCreateIssue) {
     const body = formatResearchIssueBody([
       {
@@ -38392,11 +38395,11 @@ async function approveArxivRef(identifier, topic, shouldCreateIssue, logger52) {
         data: { ...result, issueUrl: issueResult.value.url }
       };
     }
-    logger52.warn("Issue creation failed after approve", { error: issueResult.error.message });
+    logger53.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, logger52) {
+async function handleApprove(input, logger53) {
   if (input.identifier === void 0 || input.identifier === "") {
     return { action: "approve", success: false, message: "identifier is required" };
   }
@@ -38410,7 +38413,7 @@ async function handleApprove(input, logger52) {
     };
   }
   if (ref.type === "arxiv") {
-    return approveArxivRef(ref.identifier, input.topic, input.createIssue, logger52);
+    return approveArxivRef(ref.identifier, input.topic, input.createIssue, logger53);
   }
   catalog.markReviewed(ref.identifier);
   return { action: "approve", success: true, message: `Reviewed: ${ref.identifier}` };
@@ -38441,12 +38444,12 @@ function handleFlush() {
     message: `Flushed ${String(count)} references from catalog`
   };
 }
-async function executeCatalogReview(input, logger52) {
+async function executeCatalogReview(input, logger53) {
   switch (input.action) {
     case "list":
       return handleList();
     case "approve":
-      return handleApprove(input, logger52);
+      return handleApprove(input, logger53);
     case "dismiss":
       return handleDismiss(input);
     case "flush":
@@ -38463,9 +38466,9 @@ function createCatalogReviewHandler(deps) {
       });
     }
     ctx.logger.debug("Catalog review", { action: validationResult.data.action });
-    const logger52 = deps.logger ?? createLogger({ tool: "research_catalog_review" });
-    return withToolError("Catalog review failed", logger52, async () => {
-      const result = await executeCatalogReview(validationResult.data, logger52);
+    const logger53 = deps.logger ?? createLogger({ tool: "research_catalog_review" });
+    return withToolError("Catalog review failed", logger53, async () => {
+      const result = await executeCatalogReview(validationResult.data, logger53);
       if (!result.success) {
         return toolStructuredError({ errorCategory: "validation", message: result.message });
       }
@@ -38474,7 +38477,7 @@ function createCatalogReviewHandler(deps) {
   };
 }
 function registerResearchCatalogReviewTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "research_catalog_review" });
+  const logger53 = 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"),
@@ -38485,12 +38488,12 @@ function registerResearchCatalogReviewTool(server, deps) {
   const secureHandler = createSecureHandler(createCatalogReviewHandler(deps), {
     toolName: "research_catalog_review",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("research_catalog_review", deps.security);
   const wrappedHandler = wrapToolWithTimeout("research_catalog_review", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   const outputSchema = {
     action: z67.string().optional(),
@@ -38508,7 +38511,7 @@ function registerResearchCatalogReviewTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered research_catalog_review tool");
+  logger53.info("Registered research_catalog_review tool");
 }
 
 // src/mcp/tools/research-synthesize.ts
@@ -38525,8 +38528,8 @@ function createResearchSynthesizeHandler(deps) {
         message: `Validation error: ${formatZodError(validationResult.error)}`
       });
     }
-    const logger52 = deps.logger ?? createLogger({ tool: "research_synthesize" });
-    return withToolError("Synthesis failed", logger52, async () => {
+    const logger53 = deps.logger ?? createLogger({ tool: "research_synthesize" });
+    return withToolError("Synthesis failed", logger53, async () => {
       const result = await synthesizeResearch(validationResult.data.topic);
       if (!result.ok) {
         return toolStructuredError({
@@ -38539,7 +38542,7 @@ function createResearchSynthesizeHandler(deps) {
   };
 }
 function registerResearchSynthesizeTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "research_synthesize" });
+  const logger53 = deps.logger ?? createLogger({ tool: "research_synthesize" });
   const toolSchema = {
     topic: z68.string().optional().describe("Optional topic filter for single-cluster synthesis")
   };
@@ -38547,12 +38550,12 @@ function registerResearchSynthesizeTool(server, deps) {
   const secureHandler = createSecureHandler(createResearchSynthesizeHandler(deps), {
     toolName: "research_synthesize",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("research_synthesize", deps.security);
   const wrappedHandler = wrapToolWithTimeout("research_synthesize", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   const outputSchema = {
     clusters: z68.array(z68.unknown()).optional(),
@@ -38570,7 +38573,7 @@ function registerResearchSynthesizeTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered research_synthesize tool");
+  logger53.info("Registered research_synthesize tool");
 }
 
 // src/mcp/tools/issue-triage-tool.ts
@@ -38630,7 +38633,7 @@ function createIssueTriageHandler(_deps) {
   };
 }
 function registerIssueTriageTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "issue_triage" });
+  const logger53 = 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)")
@@ -38640,19 +38643,19 @@ function registerIssueTriageTool(server, deps) {
     toolName: "issue_triage",
     securityTier: "external",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("issue_triage", deps.security);
   const wrappedHandler = wrapToolWithTimeout("issue_triage", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   server.registerTool(
     "issue_triage",
     { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("issue_triage") },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered issue_triage tool with secure handler and timeout protection");
+  logger53.info("Registered issue_triage tool with secure handler and timeout protection");
 }
 var triageLogger = createLogger({ tool: "issue-triage" });
 function recordTriageSuccess(category, confidence, durationMs) {
@@ -38890,7 +38893,7 @@ function createEventCollector(events, enableAuditTrail) {
     auditBridge?.(event);
   };
 }
-async function handleRunGraphWorkflow(input, logger52) {
+async function handleRunGraphWorkflow(input, logger53) {
   const startTime = getTimeProvider().now();
   const resolved = resolveGraph(input.workflow, startTime);
   if (!resolved.ok) return resolved.error;
@@ -38898,7 +38901,7 @@ async function handleRunGraphWorkflow(input, logger52) {
   const checkpointStore = input.enableCheckpointing ? createCheckpointStore() : void 0;
   const onEvent = createEventCollector(events, input.enableAuditTrail);
   const executionId = `graph-${input.workflow}-${String(Date.now())}`;
-  logger52.info("Executing graph workflow", {
+  logger53.info("Executing graph workflow", {
     workflow: input.workflow,
     executionId,
     checkpointing: input.enableCheckpointing,
@@ -38941,7 +38944,7 @@ var GRAPH_WORKFLOW_SCHEMA = {
   enableCheckpointing: z70.boolean().optional().describe("Enable checkpoint saving"),
   enableAuditTrail: z70.boolean().optional().describe("Enable audit trail logging")
 };
-function createGraphWorkflowHandler(logger52, notifier) {
+function createGraphWorkflowHandler(logger53, notifier) {
   return async (args, _ctx) => {
     const parsed = RunGraphWorkflowInputSchema.safeParse(args);
     if (!parsed.success) {
@@ -38957,7 +38960,7 @@ function createGraphWorkflowHandler(logger52, notifier) {
       event: "graph_workflow_start",
       workflow: parsed.data.workflow
     });
-    const result = await handleRunGraphWorkflow(parsed.data, logger52);
+    const result = await handleRunGraphWorkflow(parsed.data, logger53);
     const succeeded = result.status === "completed";
     notifier.info("run_graph_workflow", {
       event: succeeded ? "graph_workflow_complete" : "graph_workflow_failed",
@@ -38971,16 +38974,16 @@ function createGraphWorkflowHandler(logger52, notifier) {
   };
 }
 function registerRunGraphWorkflowTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "run_graph_workflow" });
+  const logger53 = deps.logger ?? createLogger({ tool: "run_graph_workflow" });
   const notifier = deps.notifier ?? createMcpNotifier(server);
-  const handler3 = createGraphWorkflowHandler(logger52, notifier);
+  const handler3 = createGraphWorkflowHandler(logger53, notifier);
   const secureHandler = createSecureHandler(handler3, {
     toolName: "run_graph_workflow",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("run_graph_workflow", deps.security);
-  const wrapped = wrapToolWithTimeout("run_graph_workflow", secureHandler, { timeoutMs, logger: logger52 });
+  const wrapped = wrapToolWithTimeout("run_graph_workflow", secureHandler, { timeoutMs, logger: logger53 });
   server.registerTool(
     "run_graph_workflow",
     {
@@ -38990,7 +38993,7 @@ function registerRunGraphWorkflowTool(server, deps) {
     },
     toSdkCallback(wrapped)
   );
-  logger52.info("Registered run_graph_workflow tool");
+  logger53.info("Registered run_graph_workflow tool");
 }
 function toEventSummary(event) {
   const hasNodeId = "nodeId" in event;
@@ -39542,7 +39545,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, logger52) {
+function createDryRunResponse(input, logger53) {
   const parseResult2 = parseSpec(input.spec);
   if (!parseResult2.ok) {
     return toolStructuredError({
@@ -39557,14 +39560,14 @@ function createDryRunResponse(input, logger52) {
       message: `Decompose error: ${dagResult.error.message}`
     });
   }
-  logger52.info("Dry run completed", {
+  logger53.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, logger52) {
+async function createFullResponse(input, logger53) {
   const startMs = Date.now();
   const result = await executeSpec(input.spec);
   const durationMs = Date.now() - startMs;
@@ -39577,7 +39580,7 @@ async function createFullResponse(input, logger52) {
   }
   const analysis = analyzeFailures(result.value);
   const satisfaction = result.value.validation.satisfaction;
-  logger52.info("Spec execution completed", {
+  logger53.info("Spec execution completed", {
     satisfaction,
     passed: analysis.ok ? analysis.value.passed : false
   });
@@ -39591,7 +39594,7 @@ async function createFullResponse(input, logger52) {
   return toolSuccess(JSON.stringify(output2, null, 2));
 }
 function registerExecuteSpecTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "execute_spec" });
+  const logger53 = deps.logger ?? createLogger({ tool: "execute_spec" });
   const handler3 = async (args, _ctx) => {
     const parsed = ExecuteSpecInputSchema.safeParse(args);
     if (!parsed.success) {
@@ -39601,17 +39604,17 @@ function registerExecuteSpecTool(server, deps) {
       });
     }
     if (parsed.data.dryRun) {
-      return createDryRunResponse(parsed.data, logger52);
+      return createDryRunResponse(parsed.data, logger53);
     }
-    return createFullResponse(parsed.data, logger52);
+    return createFullResponse(parsed.data, logger53);
   };
   const secureHandler = createSecureHandler(handler3, {
     toolName: "execute_spec",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("execute_spec", deps.security);
-  const wrapped = wrapToolWithTimeout("execute_spec", secureHandler, { timeoutMs, logger: logger52 });
+  const wrapped = wrapToolWithTimeout("execute_spec", secureHandler, { timeoutMs, logger: logger53 });
   const toolSchema = {
     spec: z71.string().min(1).max(5e4).describe(
       'Markdown specification to execute. Must contain "## Requirements" and "## Acceptance Criteria" sections.'
@@ -39624,7 +39627,7 @@ function registerExecuteSpecTool(server, deps) {
     { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("execute_spec") },
     toSdkCallback(wrapped)
   );
-  logger52.info("Registered execute_spec tool");
+  logger53.info("Registered execute_spec tool");
 }
 var specLogger = createLogger({ tool: "execute-spec" });
 function recordSpecSuccess(satisfaction, durationMs) {
@@ -39686,29 +39689,29 @@ var MemoryQueryInputSchema = z72.object({
 });
 var reflectionCache;
 var reflectionAdapter;
-function getReflectiveRetriever(logger52) {
+function getReflectiveRetriever(logger53) {
   const enabled = isReflectiveMemoryEnabled();
   const shadow = isReflectiveShadowMode();
   if (!enabled && !shadow) return void 0;
   if (reflectionAdapter === void 0) {
     try {
-      const registry = getGlobalRegistry({ logger: logger52 });
+      const registry = getGlobalRegistry({ logger: logger53 });
       reflectionAdapter = registry.getDefault();
     } catch {
-      logger52.warn("No adapter for reflection, using keyword retrieval");
+      logger53.warn("No adapter for reflection, using keyword retrieval");
       return void 0;
     }
   }
   reflectionCache ??= new ReflectionCache();
   return new ReflectiveRetriever({
     adapter: reflectionAdapter,
-    logger: logger52,
+    logger: logger53,
     shadowMode: shadow,
     cache: reflectionCache
   });
 }
-async function resolveReflection(query, logger52) {
-  const retriever = getReflectiveRetriever(logger52);
+async function resolveReflection(query, logger53) {
+  const retriever = getReflectiveRetriever(logger53);
   if (retriever === void 0) return { effectiveQuery: query };
   const reflection = await retriever.enhance(query);
   const reflected = reflection.reflected;
@@ -39720,14 +39723,14 @@ async function resolveReflection(query, logger52) {
     reflection
   };
 }
-async function executeMemoryQuery(input, logger52) {
+async function executeMemoryQuery(input, logger53) {
   const toolMemory = getToolMemory();
   const { effectiveQuery, expandedQuery, reflection } = await resolveReflection(
     input.query,
-    logger52
+    logger53
   );
   const results = await toolMemory.queryBySource(input.source, effectiveQuery, input.limit);
-  logger52.debug("Memory query executed", {
+  logger53.debug("Memory query executed", {
     query: input.query,
     effectiveQuery: effectiveQuery !== input.query ? effectiveQuery : void 0,
     resultCount: results.length,
@@ -39757,7 +39760,7 @@ async function memoryQueryHandler(args, ctx) {
   });
 }
 function registerMemoryQueryTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "memory_query" });
+  const logger53 = 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)"),
@@ -39767,10 +39770,10 @@ function registerMemoryQueryTool(server, deps) {
   const secureHandler = createSecureHandler(memoryQueryHandler, {
     toolName: "memory_query",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("memory_query", deps.security);
-  const wrappedHandler = wrapToolWithTimeout("memory_query", secureHandler, { timeoutMs, logger: logger52 });
+  const wrappedHandler = wrapToolWithTimeout("memory_query", secureHandler, { timeoutMs, logger: logger53 });
   const outputSchema = {
     query: z72.string(),
     expandedQuery: z72.string().optional(),
@@ -39788,7 +39791,7 @@ function registerMemoryQueryTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered memory_query tool");
+  logger53.info("Registered memory_query tool");
 }
 
 // src/mcp/tools/memory-stats.ts
@@ -39796,7 +39799,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, logger52) {
+async function collectMemoryStats(input, logger53) {
   const toolMemory = getToolMemory();
   const sessionStats = {
     learningsCount: 0,
@@ -39833,8 +39836,8 @@ async function collectMemoryStats(input, logger52) {
     mobimem: toolMemory.isMobiMemAvailable(),
     decay: toolMemory.isDecayManagerAvailable()
   };
-  const registry = await collectRegistryStats(logger52);
-  logger52.debug("Memory stats collected", { backends, registryDomains: registry.length });
+  const registry = await collectRegistryStats(logger53);
+  logger53.debug("Memory stats collected", { backends, registryDomains: registry.length });
   return {
     backends,
     session: sessionStats,
@@ -39846,7 +39849,7 @@ async function collectMemoryStats(input, logger52) {
     collectedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-async function collectRegistryStats(logger52) {
+async function collectRegistryStats(logger53) {
   const registry = getMemoryRegistry();
   const rows = [];
   for (const domain of registry.domains()) {
@@ -39857,7 +39860,7 @@ async function collectRegistryStats(logger52) {
       rows.push({ domain, count: s.count, error: null });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      logger52.debug("Registry domain stats failed", { domain, error: message });
+      logger53.debug("Registry domain stats failed", { domain, error: message });
       rows.push({ domain, count: null, error: message });
     }
   }
@@ -39877,7 +39880,7 @@ async function memoryStatsHandler(args, ctx) {
   });
 }
 function registerMemoryStatsTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "memory_stats" });
+  const logger53 = deps.logger ?? createLogger({ tool: "memory_stats" });
   const toolSchema = {
     includeDecay: z73.boolean().optional().describe("Include decay statistics (default: true)")
   };
@@ -39885,10 +39888,10 @@ function registerMemoryStatsTool(server, deps) {
   const secureHandler = createSecureHandler(memoryStatsHandler, {
     toolName: "memory_stats",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("memory_stats", deps.security);
-  const wrappedHandler = wrapToolWithTimeout("memory_stats", secureHandler, { timeoutMs, logger: logger52 });
+  const wrappedHandler = wrapToolWithTimeout("memory_stats", secureHandler, { timeoutMs, logger: logger53 });
   const outputSchema = {
     backends: z73.unknown(),
     session: z73.unknown().optional(),
@@ -39909,7 +39912,7 @@ function registerMemoryStatsTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered memory_stats tool");
+  logger53.info("Registered memory_stats tool");
 }
 
 // src/mcp/tools/memory-write.ts
@@ -40079,12 +40082,12 @@ function isDuplicateWrite(key, content) {
   recentWriteKeys.set(cacheKey, (/* @__PURE__ */ new Date()).toISOString());
   return false;
 }
-async function executeMemoryWrite(input, logger52) {
+async function executeMemoryWrite(input, logger53) {
   if (isDuplicateWrite(input.key, input.content)) {
-    logger52.debug("Skipping duplicate memory write", { key: input.key, backend: input.backend });
+    logger53.debug("Skipping duplicate memory write", { key: input.key, backend: input.backend });
     return { success: true, backend: input.backend, key: input.key, deduplicated: true };
   }
-  logger52.debug("Writing to memory", {
+  logger53.debug("Writing to memory", {
     backend: input.backend,
     key: input.key,
     contentLength: input.content.length
@@ -40122,7 +40125,7 @@ async function memoryWriteHandler(args, ctx) {
   });
 }
 function registerMemoryWriteTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "memory_write" });
+  const logger53 = 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"),
@@ -40136,11 +40139,11 @@ function registerMemoryWriteTool(server, deps) {
   const secureHandler = createSecureHandler(memoryWriteHandler, {
     toolName: "memory_write",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const guardedHandler = withPrerequisite("memory_write", secureHandler);
   const timeoutMs = getToolTimeout("memory_write", deps.security);
-  const wrappedHandler = wrapToolWithTimeout("memory_write", guardedHandler, { timeoutMs, logger: logger52 });
+  const wrappedHandler = wrapToolWithTimeout("memory_write", guardedHandler, { timeoutMs, logger: logger53 });
   const outputSchema = {
     success: z74.boolean(),
     backend: z74.string(),
@@ -40158,7 +40161,7 @@ function registerMemoryWriteTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered memory_write tool");
+  logger53.info("Registered memory_write tool");
 }
 
 // src/mcp/tools/weather-report-tool.ts
@@ -40208,7 +40211,7 @@ function weatherReportHandler(args, ctx) {
   }
 }
 function registerWeatherReportTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "weather_report" });
+  const logger53 = deps.logger ?? createLogger({ tool: "weather_report" });
   const toolSchema = {
     cli: z75.enum(["claude", "gemini", "codex", "opencode"]).optional().describe("Filter by CLI"),
     category: z75.enum([
@@ -40229,19 +40232,19 @@ function registerWeatherReportTool(server, deps) {
   const secureHandler = createSecureHandler(weatherReportHandler, {
     toolName: "weather_report",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("weather_report", deps.security);
   const wrappedHandler = wrapToolWithTimeout("weather_report", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   server.registerTool(
     "weather_report",
     { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("weather_report") },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered weather_report tool");
+  logger53.info("Registered weather_report tool");
 }
 
 // src/mcp/tools/registry-import-types.ts
@@ -40364,7 +40367,7 @@ function registryImportHandler(args, ctx) {
   }
 }
 function registerRegistryImportTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "registry_import" });
+  const logger53 = 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"),
@@ -40374,20 +40377,20 @@ function registerRegistryImportTool(server, deps) {
   const secureHandler = createSecureHandler(registryImportHandler, {
     toolName: "registry_import",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const guardedHandler = withPrerequisite("registry_import", secureHandler);
   const timeoutMs = getToolTimeout("registry_import", deps.security);
   const wrappedHandler = wrapToolWithTimeout("registry_import", guardedHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   server.registerTool(
     "registry_import",
     { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("registry_import") },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered registry_import tool");
+  logger53.info("Registered registry_import tool");
 }
 
 // src/mcp/tools/repo-analyze-types.ts
@@ -40420,7 +40423,7 @@ async function repoAnalyzeHandler(args, ctx) {
   }
 }
 function registerRepoAnalyzeTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "repo_analyze" });
+  const logger53 = 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")
@@ -40429,19 +40432,19 @@ function registerRepoAnalyzeTool(server, deps) {
   const secureHandler = createSecureHandler(repoAnalyzeHandler, {
     toolName: "repo_analyze",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("repo_analyze", deps.security);
   const wrappedHandler = wrapToolWithTimeout("repo_analyze", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   server.registerTool(
     "repo_analyze",
     { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("repo_analyze") },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered repo_analyze tool");
+  logger53.info("Registered repo_analyze tool");
 }
 
 // src/mcp/tools/repo-security-plan-types.ts
@@ -40473,7 +40476,7 @@ async function handler(args, ctx) {
   }
 }
 function registerRepoSecurityPlanTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "repo_security_plan" });
+  const logger53 = 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"])'),
@@ -40483,19 +40486,19 @@ function registerRepoSecurityPlanTool(server, deps) {
   const secureHandler = createSecureHandler(handler, {
     toolName: "repo_security_plan",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("repo_security_plan", deps.security);
   const wrappedHandler = wrapToolWithTimeout("repo_security_plan", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   server.registerTool(
     "repo_security_plan",
     { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("repo_security_plan") },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered repo_security_plan tool");
+  logger53.info("Registered repo_security_plan tool");
 }
 
 // src/mcp/tools/search-codebase-tool.ts
@@ -40611,7 +40614,7 @@ ${output2}`);
   }
 }
 function registerSearchCodebaseTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "search_codebase" });
+  const logger53 = 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"),
@@ -40622,16 +40625,16 @@ function registerSearchCodebaseTool(server, deps) {
   const secureHandler = createSecureHandler(searchCodebaseHandler, {
     toolName: "search_codebase",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("search_codebase", deps.security);
-  const wrapped = wrapToolWithTimeout("search_codebase", secureHandler, { timeoutMs, logger: logger52 });
+  const wrapped = wrapToolWithTimeout("search_codebase", secureHandler, { timeoutMs, logger: logger53 });
   server.registerTool(
     "search_codebase",
     { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("search_codebase") },
     toSdkCallback(wrapped)
   );
-  logger52.info("Registered search_codebase tool");
+  logger53.info("Registered search_codebase tool");
 }
 
 // src/mcp/tools/extract-symbols-tool.ts
@@ -40698,7 +40701,7 @@ async function extractSymbolsHandler(args, ctx) {
   }
 }
 function registerExtractSymbolsTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "extract_symbols" });
+  const logger53 = 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")
@@ -40707,19 +40710,19 @@ function registerExtractSymbolsTool(server, deps) {
   const secureHandler = createSecureHandler(extractSymbolsHandler, {
     toolName: "extract_symbols",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("extract_symbols", deps.security);
   const wrapped = wrapToolWithTimeout("extract_symbols", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   server.registerTool(
     "extract_symbols",
     { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("extract_symbols") },
     toSdkCallback(wrapped)
   );
-  logger52.info("Registered extract_symbols tool");
+  logger53.info("Registered extract_symbols tool");
 }
 
 // src/mcp/tools/query-trace-tool.ts
@@ -40832,7 +40835,7 @@ function queryTraceHandler(args, ctx) {
   });
 }
 function registerQueryTraceTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "query_trace" });
+  const logger53 = 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)"),
@@ -40842,16 +40845,16 @@ function registerQueryTraceTool(server, deps) {
   const secureHandler = createSecureHandler(queryTraceHandler, {
     toolName: "query_trace",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("query_trace", deps.security);
-  const wrappedHandler = wrapToolWithTimeout("query_trace", secureHandler, { timeoutMs, logger: logger52 });
+  const wrappedHandler = wrapToolWithTimeout("query_trace", secureHandler, { timeoutMs, logger: logger53 });
   server.registerTool(
     "query_trace",
     { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("query_trace") },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered query_trace tool");
+  logger53.info("Registered query_trace tool");
 }
 
 // src/audit/audit-types.ts
@@ -41155,7 +41158,7 @@ var FileAuditStorage = class _FileAuditStorage {
    * @param logger - Optional logger instance
    * @returns Result with FileAuditStorage or SecurityError
    */
-  static create(config, logger52) {
+  static create(config, logger53) {
     const validation = config.allowedRoot !== void 0 ? validateLogDir(config.logDir, config.allowedRoot) : validateLogDirBasic(config.logDir);
     if (!validation.ok) {
       return { ok: false, error: validation.error };
@@ -41164,7 +41167,7 @@ var FileAuditStorage = class _FileAuditStorage {
       ...config,
       logDir: validation.value
     };
-    return { ok: true, value: new _FileAuditStorage(validatedConfig, logger52, true) };
+    return { ok: true, value: new _FileAuditStorage(validatedConfig, logger53, true) };
   }
   /**
    * Constructor for FileAuditStorage.
@@ -41177,8 +41180,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, logger52, skipValidation = false) {
-    this.logger = logger52 ?? createLogger({ component: "FileAuditStorage" });
+  constructor(config, logger53, skipValidation = false) {
+    this.logger = logger53 ?? createLogger({ component: "FileAuditStorage" });
     if (!skipValidation) {
       const validation = validateLogDirBasic(config.logDir);
       if (!validation.ok) {
@@ -41407,13 +41410,13 @@ var AuditLogger = class {
   closed = false;
   inFlightFlush = null;
   droppedEventCount = 0;
-  constructor(config, storage, logger52) {
+  constructor(config, storage, logger53) {
     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 = logger52 ?? createLogger({ component: "AuditLogger" });
+    this.logger = logger53 ?? createLogger({ component: "AuditLogger" });
     this.enableHashChain = validated.data.enableHashChain;
     this.minSeverity = validated.data.minSeverity;
     this.categories = validated.data.categories;
@@ -41614,8 +41617,8 @@ var AuditLogger = class {
     this.logger.info("AuditLogger closed");
   }
 };
-function createAuditLogger(config, storage, logger52) {
-  return new AuditLogger(config, storage, logger52);
+function createAuditLogger(config, storage, logger53) {
+  return new AuditLogger(config, storage, logger53);
 }
 
 // src/pipeline/stage-types.ts
@@ -41635,8 +41638,7 @@ var PIPELINE_STATE_KEYS = {
   DELIVERABLES: "deliverables",
   PARSED_SPEC: "parsedSpec",
   SCAFFOLD_OUTPUT: "scaffoldOutput",
-  COMPLETED: "completed",
-  SHARED_MEMORY: "__sharedMemory__"
+  COMPLETED: "completed"
 };
 
 // src/pipeline/pipeline-graph.ts
@@ -41693,15 +41695,11 @@ function registerNodes(builder, template, stages) {
 }
 function createNodeHandler(stage, template) {
   return async (state) => {
-    const existingStore = state[PIPELINE_STATE_KEYS.SHARED_MEMORY];
-    const { SharedMemoryStore: SharedMemoryStore2 } = await import("./shared-memory-CM6T2MYE.js");
-    const sharedMemory = existingStore instanceof SharedMemoryStore2 ? existingStore : new SharedMemoryStore2();
     const context = {
       executionId: `${template.id}-${stage.id}`,
       task: typeof state[PIPELINE_STATE_KEYS.TASK] === "string" ? state[PIPELINE_STATE_KEYS.TASK] : "",
       templateId: template.id,
-      state,
-      sharedMemory
+      state
     };
     const output2 = await stage.execute(context);
     return { [output2.stateKey]: output2.value };
@@ -41763,10 +41761,9 @@ async function executeAndReport(task, template, graph, options, startTime) {
     dryRun: options?.dryRun === true
   });
   emitPipelineStageEvent(template.id, "pipeline", "started");
-  const sharedMemory = new SharedMemoryStore();
   const result = await executeGraph(
     graph,
-    { [PIPELINE_STATE_KEYS.TASK]: task, [PIPELINE_STATE_KEYS.SHARED_MEMORY]: sharedMemory },
+    { [PIPELINE_STATE_KEYS.TASK]: task },
     {
       maxSteps: options?.maxSteps ?? DEFAULT_MAX_STEPS2
     }
@@ -42003,7 +42000,7 @@ async function tryIssueTriage(task) {
   try {
     const issueMatch = task.match(/github\.com\/([^/]+\/[^/]+)\/issues\/(\d+)/);
     if (issueMatch === null) return null;
-    const { createIssueTriage } = await import("./issue-triage-T3SKNBH5.js");
+    const { createIssueTriage } = await import("./issue-triage-Y77JI7WF.js");
     const triage = createIssueTriage();
     const owner = issueMatch[1] ?? "";
     const num = issueMatch[2] ?? "";
@@ -42031,7 +42028,7 @@ var VALID_TEMPLATES = /* @__PURE__ */ new Set([
 ]);
 async function classifyWithLLM(task) {
   try {
-    const { executeExpert: executeExpert2 } = await import("./expert-bridge-DJM5GAWZ.js");
+    const { executeExpert: executeExpert2 } = await import("./expert-bridge-FHPWDFJX.js");
     const prompt = [
       "Classify this task into exactly one pipeline template.",
       "Templates: dev (implementation/bug fix/refactor), research (investigate/evaluate/compare),",
@@ -42813,7 +42810,7 @@ var memoryInitPromise = null;
 async function initPipelineMemory() {
   if (cachedMemory !== null) return cachedMemory;
   try {
-    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-MY6YS2VX.js");
+    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-WARRGYY7.js");
     const { getLearningDir } = await import("./learning-persistence-NX2KHL5T.js");
     const mem = createSessionMemory2(getLearningDir());
     mem.startSession(`pipeline-${String(getTimeProvider().now())}`);
@@ -42870,7 +42867,7 @@ function recordRoutingExperience(category, success, durationMs) {
     callRecord(routingMemoryCache);
     return;
   }
-  routingMemoryInitPromise ??= import("./routing-memory-AAH7NIHD.js").then(({ createRoutingMemory }) => {
+  routingMemoryInitPromise ??= import("./routing-memory-QRIJPRVD.js").then(({ createRoutingMemory }) => {
     routingMemoryCache ??= createRoutingMemory();
     return routingMemoryCache;
   }).catch((error) => {
@@ -42904,7 +42901,7 @@ ${text}` : "";
 }
 async function getWeatherContext() {
   try {
-    const { generateWeatherReport: generateWeatherReport2 } = await import("./weather-report-O3Z3BBAX.js");
+    const { generateWeatherReport: generateWeatherReport2 } = await import("./weather-report-RACZWJQL.js");
     const report = generateWeatherReport2({ includeAdaptive: true });
     const mappings = "recommendedMappings" in report ? report.recommendedMappings : [];
     if (!Array.isArray(mappings) || mappings.length === 0) return "";
@@ -42922,7 +42919,7 @@ ${lines}
 }
 async function getMemoryContext(task) {
   try {
-    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-MY6YS2VX.js");
+    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-WARRGYY7.js");
     const { getLearningDir } = await import("./learning-persistence-NX2KHL5T.js");
     const memory = createSessionMemory2(getLearningDir(), { maxLearningsInContext: 10 });
     const learnings = memory.searchLearnings(task.slice(0, 200));
@@ -43028,7 +43025,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-KKAIFULI.js");
+        const { executeVoting } = await import("./consensus-vote-KZ6UURUI.js");
         const votingResult = await executeVoting(
           {
             proposal: plan.slice(0, 4e3),
@@ -43547,7 +43544,7 @@ async function runPlanningPhase(task, stages, sid, prior) {
     )
   );
   if (sid !== void 0) saveStageCheckpoint(sid, "research", { type: "research", text: research });
-  const planResult = await runPlanOrResume(prior, task, research, stages);
+  const planResult = await runPlanOrResume(prior, task, research, stages, sid);
   if (sid !== void 0) {
     saveStageCheckpoint(sid, "plan", {
       type: "plan",
@@ -43607,9 +43604,9 @@ async function runOrResume(prior, stage, run) {
   }
   return run();
 }
-async function runPlanOrResume(prior, task, research, stages) {
+async function runPlanOrResume(prior, task, research, stages, sessionId) {
   if (prior?.plan !== void 0) {
-    logger41.info("Resuming from checkpoint", { stage: "plan" });
+    logger41.info("Resuming from checkpoint", { stage: "plan", sessionId });
     return {
       plan: prior.plan,
       iterations: prior.voteIterations ?? 0,
@@ -43618,7 +43615,7 @@ async function runPlanOrResume(prior, task, research, stages) {
       caveats: prior.voteCaveats ?? []
     };
   }
-  return planVoteLoop(task, research, stages);
+  return planVoteLoop(task, research, stages, sessionId);
 }
 async function runOrResumeDecompose(prior, plan, stages, meta) {
   if (prior?.tasks !== void 0) {
@@ -43645,7 +43642,7 @@ function extractConditionalMeta(vote) {
   }
   return { conditional: false, conditions: [], caveats: [] };
 }
-async function planVoteLoop(task, research, stages) {
+async function planVoteLoop(task, research, stages, sessionId) {
   let feedback;
   let plan = "";
   for (let i = 1; i <= MAX_VOTE_ITERATIONS; i++) {
@@ -43665,13 +43662,22 @@ async function planVoteLoop(task, research, stages) {
     );
     if (isApproved(vote)) {
       const meta = extractConditionalMeta(vote);
-      logger41.info("Plan approved", { iteration: i, approval: vote.approvalPercentage, ...meta });
+      logger41.info("Plan approved", {
+        iteration: i,
+        approval: vote.approvalPercentage,
+        sessionId,
+        ...meta
+      });
       return { plan, iterations: i, ...meta };
     }
     feedback = getVoteFeedback(vote);
-    logger41.warn("Plan rejected, iterating", { iteration: i, feedback: feedback.slice(0, 200) });
+    logger41.warn("Plan rejected, iterating", {
+      iteration: i,
+      feedback: feedback.slice(0, 200),
+      sessionId
+    });
   }
-  logger41.warn("Max vote iterations reached, proceeding with last plan");
+  logger41.warn("Max vote iterations reached, proceeding with last plan", { sessionId });
   return { plan, iterations: MAX_VOTE_ITERATIONS, conditional: false, conditions: [], caveats: [] };
 }
 async function implementSingleTask(task, stages) {
@@ -43793,7 +43799,6 @@ function createResearchStageWrapper(stages) {
 ${codeContext}`;
         }
         const result = await stages.research(enrichedTask);
-        ctx.sharedMemory.write("research", "discovery", result);
         return output(PIPELINE_STATE_KEYS.RESEARCH, result, getTimeProvider().now() - start, true);
       } catch (e) {
         return failOutput(PIPELINE_STATE_KEYS.RESEARCH, String(e), getTimeProvider().now() - start);
@@ -43816,7 +43821,6 @@ function createPlanStageWrapper(stages) {
 ## Prior Art (Research Registry)
 ${priorArt}` : research;
         const result = await stages.plan(ctx.task, enrichedResearch, feedback);
-        ctx.sharedMemory.write("plan", "decision", result);
         return output(PIPELINE_STATE_KEYS.PLAN, result, getTimeProvider().now() - start, true);
       } catch (e) {
         return failOutput(PIPELINE_STATE_KEYS.PLAN, String(e), getTimeProvider().now() - start);
@@ -43871,12 +43875,7 @@ function createImplementStageWrapper(stages) {
       const start = getTimeProvider().now();
       const tasks = Array.isArray(ctx.state[PIPELINE_STATE_KEYS.TASKS]) ? ctx.state[PIPELINE_STATE_KEYS.TASKS] : [];
       try {
-        const symbolContext = await extractSymbolsForTask(ctx.task);
-        if (symbolContext !== null && symbolContext !== "") {
-          ctx.sharedMemory.write("implement", "context", symbolContext);
-        }
         const results = await Promise.all(tasks.map((t) => stages.implement(t)));
-        classifyImplementationTrust(results, ctx);
         return output(PIPELINE_STATE_KEYS.IMPLEMENTATIONS, results, getTimeProvider().now() - start, true);
       } catch (e) {
         return failOutput(PIPELINE_STATE_KEYS.IMPLEMENTATIONS, String(e), getTimeProvider().now() - start);
@@ -43938,7 +43937,7 @@ function createScaffoldStageWrapper() {
 }
 async function searchCodebaseForTask(task) {
   try {
-    const { CodebaseIndex: CodebaseIndex2 } = await import("./codebase-search-PIBRTGBE.js");
+    const { CodebaseIndex: CodebaseIndex2 } = await import("./codebase-search-ZFJUVMVR.js");
     const index = new CodebaseIndex2(process.cwd());
     const terms = task.toLowerCase().split(/\s+/).filter((w) => w.length > 4).slice(0, 3);
     if (terms.length === 0) return null;
@@ -43951,32 +43950,9 @@ async function searchCodebaseForTask(task) {
     return null;
   }
 }
-async function extractSymbolsForTask(task) {
-  try {
-    const fileRefs = task.match(/(?:src|lib|packages)\/[^\s,)]+\.ts/g);
-    if (fileRefs === null || fileRefs.length === 0) return null;
-    const { extractSymbols: extractSymbols2 } = await import("./symbol-extractor-WYXPJH65.js");
-    const path14 = await import("path");
-    const summaries = [];
-    for (const ref of fileRefs.slice(0, 3)) {
-      try {
-        const resolved = path14.resolve(ref);
-        const result = await extractSymbols2(resolved);
-        const exported = result.symbols.filter((s) => s.exported);
-        if (exported.length > 0) {
-          summaries.push(`${ref}: ${exported.map((s) => `${s.kind} ${s.name}`).join(", ")}`);
-        }
-      } catch {
-      }
-    }
-    return summaries.length > 0 ? summaries.join("\n") : null;
-  } catch {
-    return null;
-  }
-}
 async function queryResearchRegistry(task) {
   try {
-    const { synthesizeResearch: synthesizeResearch2 } = await import("./research-helpers-synthesize-Y3O76PY4.js");
+    const { synthesizeResearch: synthesizeResearch2 } = await import("./research-helpers-synthesize-PVP6JRZV.js");
     const topic = task.split(/[.!?\n]/).filter((s) => s.trim().length > 10)[0]?.trim();
     if (topic === void 0) return null;
     const result = await synthesizeResearch2(topic.slice(0, 50));
@@ -43988,19 +43964,6 @@ async function queryResearchRegistry(task) {
     return null;
   }
 }
-function classifyImplementationTrust(results, ctx) {
-  try {
-    const implCount = results.length;
-    const trustLevel = implCount > 0 ? "semi-trusted" : "unknown";
-    ctx.sharedMemory.write("implement", "risk", {
-      trustLevel,
-      source: "pipeline-agent",
-      requiresReview: true,
-      count: implCount
-    });
-  } catch {
-  }
-}
 function createDevStageRegistry(stages) {
   return /* @__PURE__ */ new Map([
     ["research", createResearchStageWrapper(stages)],
@@ -44041,10 +44004,9 @@ function createAnalyzeStageWrapper() {
             true
           );
         }
-        const { analyzeGitHubRepo: analyzeGitHubRepo2 } = await import("./repo-analyze-D2OY2QSR.js");
+        const { analyzeGitHubRepo: analyzeGitHubRepo2 } = await import("./repo-analyze-JZEMBE6R.js");
         const analysis = await analyzeGitHubRepo2({ repo: slug, depth: "deep" });
         const summary = `Language: ${String(analysis.language)}, Framework: ${String(analysis.framework)}, CI: ${String(analysis.ciProvider)}, Security: ${analysis.securityTooling.join(", ") || "none"}`;
-        ctx.sharedMemory.write("analyze", "discovery", { slug, analysis: summary });
         return output(PIPELINE_STATE_KEYS.RESEARCH, summary, getTimeProvider().now() - start, true);
       } catch (e) {
         return failOutput(PIPELINE_STATE_KEYS.RESEARCH, String(e), getTimeProvider().now() - start);
@@ -44061,10 +44023,9 @@ function createScanStageWrapper() {
       try {
         const slug = ctx.task.match(/([a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+)/)?.[1];
         if (slug !== void 0) {
-          const { generateSecurityPlan: generateSecurityPlan2 } = await import("./repo-security-plan-V257RYTW.js");
+          const { generateSecurityPlan: generateSecurityPlan2 } = await import("./repo-security-plan-RHSLO7H6.js");
           const plan = await generateSecurityPlan2({ repo: slug, maxScanners: 10 });
           const recs = plan.recommendations.slice(0, 5).map((r) => `${r.priority}: ${r.displayName} (${r.category})`).join("; ");
-          ctx.sharedMemory.write("scan", "decision", { recommendations: recs });
           return output(PIPELINE_STATE_KEYS.FINDINGS, recs, getTimeProvider().now() - start, true);
         }
         return output(PIPELINE_STATE_KEYS.FINDINGS, "No repository to scan", getTimeProvider().now() - start, true);
@@ -44345,15 +44306,15 @@ async function prReviewHandler(args, ctx) {
   }
 }
 function registerPrReviewTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "pr_review" });
+  const logger53 = 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: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("pr_review", deps.security);
-  const wrappedHandler = wrapToolWithTimeout("pr_review", secureHandler, { timeoutMs, logger: logger52 });
+  const wrappedHandler = wrapToolWithTimeout("pr_review", secureHandler, { timeoutMs, logger: logger53 });
   server.registerTool(
     "pr_review",
     {
@@ -44363,7 +44324,7 @@ function registerPrReviewTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered pr_review tool");
+  logger53.info("Registered pr_review tool");
 }
 
 // src/mcp/tools/survey-oss-landscape.ts
@@ -44424,7 +44385,7 @@ function parseCandidates(data) {
   });
   return { totalFound: data.total_count ?? candidates.length, candidates };
 }
-async function fetchGithubCandidates(input, logger52) {
+async function fetchGithubCandidates(input, logger53) {
   const query = encodeURIComponent(buildGithubQuery(input));
   const perPage = String(input.maxResults);
   const url = `${GITHUB_SEARCH_BASE}?q=${query}&sort=stars&order=desc&per_page=${perPage}`;
@@ -44436,7 +44397,7 @@ async function fetchGithubCandidates(input, logger52) {
   if (tokenResult.ok) {
     headers["Authorization"] = `Bearer ${tokenResult.value.value}`;
   } else {
-    logger52.debug("No GitHub token; using unauthenticated rate limit (60/hr)");
+    logger53.debug("No GitHub token; using unauthenticated rate limit (60/hr)");
   }
   const fetchResult = await fetchSource({ url, source: "github", headers });
   if (!fetchResult.ok) return fetchResult;
@@ -44467,12 +44428,12 @@ async function fetchGithubCandidates(input, logger52) {
   }
   return { ok: true, value: parseCandidates(parsed.data) };
 }
-async function executeSurvey(input, logger52) {
+async function executeSurvey(input, logger53) {
   const sourcesQueried = ["github"];
   const sourcesFailed = [];
-  const githubResult = await fetchGithubCandidates(input, logger52);
+  const githubResult = await fetchGithubCandidates(input, logger53);
   if (!githubResult.ok) {
-    logger52.warn("GitHub source failed", {
+    logger53.warn("GitHub source failed", {
       code: githubResult.error.code,
       message: githubResult.error.message
     });
@@ -44502,13 +44463,13 @@ function createSurveyHandler(deps) {
         message: `Validation error: ${formatZodError(validation.error)}`
       });
     }
-    const logger52 = deps.logger ?? createLogger({ tool: "survey_oss_landscape" });
+    const logger53 = 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", logger52, async () => {
-      const result = await executeSurvey(validation.data, logger52);
+    return withToolError("Survey failed", logger53, async () => {
+      const result = await executeSurvey(validation.data, logger53);
       return toolSuccessStructured(result);
     });
   };
@@ -44522,16 +44483,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 logger52 = deps.logger ?? createLogger({ tool: "survey_oss_landscape" });
+  const logger53 = deps.logger ?? createLogger({ tool: "survey_oss_landscape" });
   const secureHandler = createSecureHandler(createSurveyHandler(deps), {
     toolName: "survey_oss_landscape",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("survey_oss_landscape", deps.security);
   const wrappedHandler = wrapToolWithTimeout("survey_oss_landscape", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   server.registerTool(
     "survey_oss_landscape",
@@ -44543,7 +44504,7 @@ function registerSurveyOssLandscapeTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered survey_oss_landscape tool");
+  logger53.info("Registered survey_oss_landscape tool");
 }
 
 // src/mcp/tools/vendor-publishing-audit.ts
@@ -44644,9 +44605,9 @@ function createVendorPublishingAuditHandler(deps) {
         message: `Validation error: ${formatZodError(validation.error)}`
       });
     }
-    const logger52 = deps.logger ?? createLogger({ tool: "vendor_publishing_audit" });
+    const logger53 = deps.logger ?? createLogger({ tool: "vendor_publishing_audit" });
     ctx.logger.debug("Vendor publishing audit", { vendor: validation.data.vendor });
-    return withToolError("Vendor publishing audit failed", logger52, () => {
+    return withToolError("Vendor publishing audit failed", logger53, () => {
       const result = lookupVendor(validation.data.vendor);
       return Promise.resolve(toolSuccessStructured(result));
     });
@@ -44670,16 +44631,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 logger52 = deps.logger ?? createLogger({ tool: "vendor_publishing_audit" });
+  const logger53 = deps.logger ?? createLogger({ tool: "vendor_publishing_audit" });
   const secureHandler = createSecureHandler(createVendorPublishingAuditHandler(deps), {
     toolName: "vendor_publishing_audit",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("vendor_publishing_audit", deps.security);
   const wrappedHandler = wrapToolWithTimeout("vendor_publishing_audit", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   server.registerTool(
     "vendor_publishing_audit",
@@ -44691,7 +44652,7 @@ function registerVendorPublishingAuditTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered vendor_publishing_audit tool");
+  logger53.info("Registered vendor_publishing_audit tool");
 }
 
 // src/mcp/tools/compare-data-feeds.ts
@@ -44877,12 +44838,12 @@ function createCompareDataFeedsHandler(deps) {
         message: `Validation error: ${formatZodError(validation.error)}`
       });
     }
-    const logger52 = deps.logger ?? createLogger({ tool: "compare_data_feeds" });
+    const logger53 = 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", logger52, () => {
+    return withToolError("Compare data feeds failed", logger53, () => {
       const result = executeCompare(validation.data);
       return Promise.resolve(toolSuccessStructured(result));
     });
@@ -44910,16 +44871,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 logger52 = deps.logger ?? createLogger({ tool: "compare_data_feeds" });
+  const logger53 = deps.logger ?? createLogger({ tool: "compare_data_feeds" });
   const secureHandler = createSecureHandler(createCompareDataFeedsHandler(deps), {
     toolName: "compare_data_feeds",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("compare_data_feeds", deps.security);
   const wrappedHandler = wrapToolWithTimeout("compare_data_feeds", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   server.registerTool(
     "compare_data_feeds",
@@ -44931,7 +44892,7 @@ function registerCompareDataFeedsTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered compare_data_feeds tool");
+  logger53.info("Registered compare_data_feeds tool");
 }
 
 // src/mcp/tools/improvement-review.ts
@@ -45009,8 +44970,8 @@ function clamp2(score, max) {
 var FitnessScoreCalculator = class {
   logger;
   checks = [];
-  constructor(logger52) {
-    this.logger = logger52 ?? createLogger({ component: "FitnessScoreCalculator" });
+  constructor(logger53) {
+    this.logger = logger53 ?? createLogger({ component: "FitnessScoreCalculator" });
     this.registerDefaultChecks();
   }
   /** Register default fitness checks. */
@@ -45504,8 +45465,8 @@ var FitnessScoreCalculator = class {
     return base;
   }
 };
-function createFitnessScoreCalculator(logger52) {
-  return new FitnessScoreCalculator(logger52);
+function createFitnessScoreCalculator(logger53) {
+  return new FitnessScoreCalculator(logger53);
 }
 function calculateFitnessScore(version) {
   const calculator = createFitnessScoreCalculator();
@@ -45753,20 +45714,20 @@ async function fileSignalsAsIssues(signals, ctx) {
   return { issuesFiled, issuesSkipped };
 }
 async function runImprovementReview(input, deps = {}) {
-  const logger52 = deps.logger ?? createLogger({ component: "improvement_review" });
+  const logger53 = 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: logger52 });
+  const audit = safeFitnessAudit(now, { logger: logger53 });
   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: logger52 }) : { issuesFiled: [], issuesSkipped: [] };
+  const { issuesFiled, issuesSkipped } = fileIssues ? await fileSignalsAsIssues(signals, { logger: logger53 }) : { issuesFiled: [], issuesSkipped: [] };
   return {
     window: windowLabel,
     totalOutcomes: windowed.length,
@@ -45796,17 +45757,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 logger52 = deps.logger ?? createLogger({ tool: "improvement_review" });
+  const logger53 = deps.logger ?? createLogger({ tool: "improvement_review" });
   const secureHandler = createSecureHandler(reviewHandler, {
     toolName: "improvement_review",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const guardedHandler = withPrerequisite("improvement_review", secureHandler);
   const timeoutMs = getToolTimeout("improvement_review", deps.security);
   const wrappedHandler = wrapToolWithTimeout("improvement_review", guardedHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   server.registerTool(
     "improvement_review",
@@ -45817,7 +45778,7 @@ function registerImprovementReviewTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered improvement_review tool");
+  logger53.info("Registered improvement_review tool");
 }
 
 // src/mcp/tools/query-task-state-tool.ts
@@ -45856,7 +45817,7 @@ function queryTaskStateHandler(args, ctx) {
   return Promise.resolve(toolSuccess(JSON.stringify(response, null, 2)));
 }
 function registerQueryTaskStateTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "query_task_state" });
+  const logger53 = 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")
   };
@@ -45864,19 +45825,19 @@ function registerQueryTaskStateTool(server, deps) {
   const secureHandler = createSecureHandler(queryTaskStateHandler, {
     toolName: "query_task_state",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("query_task_state", deps.security);
   const wrappedHandler = wrapToolWithTimeout("query_task_state", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   server.registerTool(
     "query_task_state",
     { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("query_task_state") },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered query_task_state tool");
+  logger53.info("Registered query_task_state tool");
 }
 
 // src/mcp/tools/verify-audit-chain-tool.ts
@@ -45888,7 +45849,7 @@ var VerifyAuditChainInputSchema = z97.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, logger52) {
+async function loadAuditEvents(dir, logger53) {
   const entries = await fs12.readdir(dir);
   const auditFiles = entries.filter((name) => name.startsWith("audit-") && name.endsWith(".jsonl")).sort();
   const events = [];
@@ -45899,7 +45860,7 @@ async function loadAuditEvents(dir, logger52) {
       content = await fs12.readFile(fullPath, "utf-8");
     } catch (cause) {
       const msg = cause instanceof Error ? cause.message : String(cause);
-      logger52.warn("Skipping unreadable audit log file", { filename, error: msg });
+      logger53.warn("Skipping unreadable audit log file", { filename, error: msg });
       continue;
     }
     for (const line of content.split("\n")) {
@@ -45910,14 +45871,14 @@ async function loadAuditEvents(dir, logger52) {
         if (validated.success) {
           events.push(validated.data);
         } else {
-          logger52.warn("Skipping malformed audit event", {
+          logger53.warn("Skipping malformed audit event", {
             filename,
             error: validated.error.message
           });
         }
       } catch (cause) {
         const msg = cause instanceof Error ? cause.message : String(cause);
-        logger52.warn("Skipping unparseable audit event", { filename, error: msg });
+        logger53.warn("Skipping unparseable audit event", { filename, error: msg });
       }
     }
   }
@@ -45959,7 +45920,7 @@ async function handler2(args, ctx) {
   return toolSuccess(JSON.stringify(response, null, 2));
 }
 function registerVerifyAuditChainTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "verify_audit_chain" });
+  const logger53 = deps.logger ?? createLogger({ tool: "verify_audit_chain" });
   const toolSchema = {
     logDir: z97.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."
@@ -45969,19 +45930,19 @@ function registerVerifyAuditChainTool(server, deps) {
   const secureHandler = createSecureHandler(handler2, {
     toolName: "verify_audit_chain",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("verify_audit_chain", deps.security);
   const wrappedHandler = wrapToolWithTimeout("verify_audit_chain", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   server.registerTool(
     "verify_audit_chain",
     { description: description2, inputSchema: toolSchema, annotations: getToolAnnotations("verify_audit_chain") },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered verify_audit_chain tool");
+  logger53.info("Registered verify_audit_chain tool");
 }
 
 // src/mcp/tools/pipeline-tool.ts
@@ -46060,7 +46021,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, logger52) {
+async function runPipelineHandler(args, logger53) {
   const parsed = PipelineInputSchema.safeParse(args);
   if (!parsed.success) {
     return toolStructuredError({
@@ -46070,7 +46031,7 @@ async function runPipelineHandler(args, logger52) {
   }
   const input = parsed.data;
   if (input.simulateVotes) {
-    warnIfSimulatedOutsideTests("run_pipeline", logger52);
+    warnIfSimulatedOutsideTests("run_pipeline", logger53);
   }
   try {
     const task = await resolveTask(input.task, input.specFile);
@@ -46094,14 +46055,14 @@ async function runPipelineHandler(args, logger52) {
   }
 }
 function registerPipelineTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "run_pipeline" });
-  const secureHandler = createSecureHandler((args) => runPipelineHandler(args, logger52), {
+  const logger53 = deps.logger ?? createLogger({ tool: "run_pipeline" });
+  const secureHandler = createSecureHandler((args) => runPipelineHandler(args, logger53), {
     toolName: "run_pipeline",
     rateLimiter: deps.rateLimiter,
-    logger: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("run_pipeline", deps.security);
-  const wrapped = wrapToolWithTimeout("run_pipeline", secureHandler, { timeoutMs, logger: logger52 });
+  const wrapped = wrapToolWithTimeout("run_pipeline", secureHandler, { timeoutMs, logger: logger53 });
   server.registerTool(
     "run_pipeline",
     {
@@ -46111,7 +46072,7 @@ function registerPipelineTool(server, deps) {
     },
     toSdkCallback(wrapped)
   );
-  logger52.info("Registered run_pipeline tool");
+  logger53.info("Registered run_pipeline tool");
 }
 
 // src/mcp/tools/supply-chain-tradeoff-panel.ts
@@ -46366,17 +46327,17 @@ async function tradeoffPanelHandler(args, ctx) {
   }
 }
 function registerSupplyChainTradeoffPanelTool(server, deps) {
-  const logger52 = deps.logger ?? createLogger({ tool: "supply_chain_tradeoff_panel" });
+  const logger53 = 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: logger52
+    logger: logger53
   });
   const timeoutMs = getToolTimeout("supply_chain_tradeoff_panel", deps.security);
   const wrappedHandler = wrapToolWithTimeout("supply_chain_tradeoff_panel", secureHandler, {
     timeoutMs,
-    logger: logger52
+    logger: logger53
   });
   server.registerTool(
     "supply_chain_tradeoff_panel",
@@ -46387,7 +46348,7 @@ function registerSupplyChainTradeoffPanelTool(server, deps) {
     },
     toSdkCallback(wrappedHandler)
   );
-  logger52.info("Registered supply_chain_tradeoff_panel tool");
+  logger53.info("Registered supply_chain_tradeoff_panel tool");
 }
 
 // src/mcp/tools/tool-annotations.ts
@@ -47008,13 +46969,13 @@ var REGISTERED_TOOL_NAMES = [
   "improvement_review"
 ];
 function registerTools(server, options) {
-  const logger52 = options?.logger ?? createMcpLogger({ component: "tools" });
-  const rateLimiter = options?.rateLimiter ?? createDefaultRateLimiter("mcp-tools", logger52);
-  logger52.info("Tool registration infrastructure initialized");
+  const logger53 = options?.logger ?? createMcpLogger({ component: "tools" });
+  const rateLimiter = options?.rateLimiter ?? createDefaultRateLimiter("mcp-tools", logger53);
+  logger53.info("Tool registration infrastructure initialized");
   void server;
   return {
     tools: [...REGISTERED_TOOL_NAMES],
-    logger: logger52,
+    logger: logger53,
     rateLimiter
   };
 }
@@ -47027,32 +46988,32 @@ var TIER_NAMES = {
 };
 function createGateway(config = {}) {
   const enabled = config.enabled !== false;
-  const logger52 = config.logger ?? createLogger({ component: "gateway" });
+  const logger53 = config.logger ?? createLogger({ component: "gateway" });
   const overrides = config.tierOverrides;
   return {
     enabled,
     wrapTool(toolName, handler3) {
       if (!enabled) return handler3;
-      return createGatewayHandler(toolName, handler3, logger52, overrides);
+      return createGatewayHandler(toolName, handler3, logger53, overrides);
     }
   };
 }
-function createGatewayHandler(toolName, handler3, logger52, overrides) {
+function createGatewayHandler(toolName, handler3, logger53, overrides) {
   return async (args) => {
     const params = asRecord2(args);
     const tier = classifyRequestTier(toolName, params, overrides);
     const tierName = TIER_NAMES[tier];
     const startMs = getTimeProvider().now();
-    logger52.debug("Gateway dispatch", { tool: toolName, tier, tierName });
+    logger53.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) {
-        logger52.info("Gateway completed", { ...entry });
+        logger53.info("Gateway completed", { ...entry });
       } else {
-        logger52.warn("Gateway completed with error", { ...entry });
+        logger53.warn("Gateway completed with error", { ...entry });
       }
       return result;
     } catch (error) {
@@ -47064,7 +47025,7 @@ function createGatewayHandler(toolName, handler3, logger52, overrides) {
         durationMs,
         success: false
       };
-      logger52.error("Gateway handler threw", error instanceof Error ? error : void 0, {
+      logger53.error("Gateway handler threw", error instanceof Error ? error : void 0, {
         ...entry
       });
       throw error;
@@ -49940,8 +49901,78 @@ function getSandboxMode() {
   return actualMode;
 }
 
+// src/pipeline/feedback-subscriber.ts
+var logger49 = createLogger({ component: "FeedbackSubscriber" });
+var VALID_CLIS = new Set(CLI_NAMES);
+function createFeedbackSubscriber(bus, store) {
+  return bus.subscribe({ type: ["model.called", "stage.failed"] }, (event) => {
+    try {
+      handleEvent2(event, store);
+    } catch (error) {
+      const msg = getErrorMessage(error);
+      logger49.warn("Feedback subscriber error", { error: msg });
+    }
+  });
+}
+var cachedFeedbackUnsubscribe = null;
+function startFeedbackSubscriber(bus, store) {
+  if (cachedFeedbackUnsubscribe !== null) return;
+  cachedFeedbackUnsubscribe = createFeedbackSubscriber(bus, store);
+}
+function shutdownFeedbackSubscriber() {
+  if (cachedFeedbackUnsubscribe !== null) {
+    cachedFeedbackUnsubscribe();
+    cachedFeedbackUnsubscribe = null;
+  }
+}
+function handleEvent2(event, store) {
+  if (event.type === "model.called") {
+    recordModelCall(event, store);
+  } else if (event.type === "stage.failed") {
+    recordStageFailed(event, store);
+  }
+}
+function recordModelCall(event, store) {
+  const cli = normalizeCli(event.cli);
+  if (cli === void 0) return;
+  const outcome = {
+    id: `fb-${event.executionId}-${String(event.timestamp)}`,
+    cli,
+    category: "code_generation",
+    model: event.model,
+    success: true,
+    durationMs: event.durationMs,
+    timestamp: new Date(event.timestamp).toISOString(),
+    source: "delegate"
+  };
+  store.append(outcome);
+}
+function recordStageFailed(event, store) {
+  const outcome = {
+    id: `fb-fail-${event.executionId}-${String(event.timestamp)}`,
+    cli: DEFAULT_CLI,
+    // Stage failures don't carry CLI info; default to canonical fallback
+    category: "code_generation",
+    model: "unknown",
+    success: false,
+    durationMs: 0,
+    timestamp: new Date(event.timestamp).toISOString(),
+    source: "delegate",
+    failureCategory: categorizeOutcomeErrorMessage(event.error),
+    errorMessage: event.error.slice(0, 500)
+  };
+  store.append(outcome);
+}
+function normalizeCli(cli) {
+  if (VALID_CLIS.has(cli)) {
+    return cli;
+  }
+  logger49.warn("Unknown CLI in event", { cli });
+  return void 0;
+}
+
 // src/pipeline/event-bus-bridge.ts
-var logger49 = createLogger({ component: "EventBusBridge" });
+var logger50 = createLogger({ component: "EventBusBridge" });
 function toV1Topic(prefix, event) {
   return `${prefix}.${event.type}`;
 }
@@ -49973,10 +50004,10 @@ function createEventBusBridge(options) {
       forwardCount++;
     } catch (error) {
       const msg = getErrorMessage(error);
-      logger49.warn("Failed to forward pipeline event", { type: event.type, error: msg });
+      logger50.warn("Failed to forward pipeline event", { type: event.type, error: msg });
     }
   });
-  logger49.info("EventBus bridge initialized", { prefix });
+  logger50.info("EventBus bridge initialized", { prefix });
   return {
     forwarded: () => forwardCount,
     dispose: unsub
@@ -49984,7 +50015,7 @@ function createEventBusBridge(options) {
 }
 
 // src/adapters/stdin-lifecycle.ts
-var logger50 = createLogger({ component: "StdinLifecycleMonitor" });
+var logger51 = createLogger({ component: "StdinLifecycleMonitor" });
 var DEFAULT_PPID_POLL_MS = 3e4;
 var StdinLifecycleMonitor = class {
   callbacks = /* @__PURE__ */ new Set();
@@ -50034,7 +50065,7 @@ var StdinLifecycleMonitor = class {
       clearInterval(this.ppidTimer);
       this.ppidTimer = void 0;
     }
-    logger50.warn("Parent process gone \u2014 shutting down MCP server", { reason });
+    logger51.warn("Parent process gone \u2014 shutting down MCP server", { reason });
     await this.fireCallbacks();
   }
   async fireCallbacks() {
@@ -50042,7 +50073,7 @@ var StdinLifecycleMonitor = class {
       try {
         await cb();
       } catch (error) {
-        logger50.warn("Stdin shutdown callback failed", { error: String(error) });
+        logger51.warn("Stdin shutdown callback failed", { error: String(error) });
       }
     }
   }
@@ -50056,7 +50087,7 @@ function getStdinLifecycleMonitor() {
 // src/pipeline/task-tracker.ts
 import * as fs14 from "fs";
 import * as path13 from "path";
-var logger51 = createLogger({ component: "task-tracker" });
+var logger52 = createLogger({ component: "task-tracker" });
 async function exec(cmd, args, timeout = 15e3) {
   const { execFile: execFile5 } = await import("child_process");
   const { promisify: promisify5 } = await import("util");
@@ -50071,7 +50102,7 @@ var GitHubTaskTracker = class {
   cachedProvider = null;
   async getProvider() {
     if (this.cachedProvider !== null) return this.cachedProvider;
-    const { createScmProvider } = await import("./factory-DOWBGVAL.js");
+    const { createScmProvider } = await import("./factory-W6KROBFN.js");
     const result = await createScmProvider({ repo: this.config.repo ?? "" });
     if (!result.ok) throw new Error(`SCM provider error: ${result.error.message}`);
     this.cachedProvider = result.value;
@@ -50082,7 +50113,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);
-    logger51.info("Created GitHub issue via SCM provider", { id });
+    logger52.info("Created GitHub issue via SCM provider", { id });
     return { id, title, status: "open", url: result.value.url };
   }
   async updateStatus(taskId, status) {
@@ -50110,7 +50141,7 @@ var GitLabTaskTracker = class {
     );
     const match = /\/(\d+)$/.exec(url);
     const id = match?.[1] ?? url;
-    logger51.info("Created GitLab issue", { id, url });
+    logger52.info("Created GitLab issue", { id, url });
     return { id, title, status: "open", url };
   }
   async updateStatus(taskId, status) {
@@ -50745,6 +50776,7 @@ export {
   registerSupplyChainTradeoffPanelTool,
   createAnnotationsProxy,
   createToolObservabilityProxy,
+  REGISTERED_TOOL_NAMES,
   registerTools,
   createGatewayServerProxy,
   analyzeTools,
@@ -50773,8 +50805,11 @@ export {
   createSandboxExecutor,
   initializeSandbox,
   getSandboxMode,
+  createFeedbackSubscriber,
+  startFeedbackSubscriber,
+  shutdownFeedbackSubscriber,
   createEventBusBridge,
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-4XNVJS5A.js.map
+//# sourceMappingURL=chunk-PMLVZXAE.js.map