nexus-agents 2.29.0 → 2.29.2

package/dist/{chunk-S3BKWNST.js → chunk-J245RJGW.js}

@@ -1,11 +1,19 @@
+import {
+  SessionMemory
+} from "./chunk-KQIDTE52.js";
+import {
+  AdaptiveMemoryBackend,
+  HybridMemoryBackend,
+  MemoryError,
+  MemoryImportance,
+  getMemoryEntry,
+  memoryExists,
+  memoryRowToEntry
+} from "./chunk-DDQGAVQA.js";
 import {
   stringifyValue,
-  tokenize,
   tokenizeFiltered
 } from "./chunk-633WH2ML.js";
-import {
-  SessionMemory
-} from "./chunk-I6YDS23R.js";
 import {
   createCliAdapter,
   createCliDetectionCache,
@@ -13,7 +21,7 @@ import {
   getAvailableClis,
   isCliAvailable,
   withTimeout
-} from "./chunk-ZBZJHXRT.js";
+} from "./chunk-CW2Z773T.js";
 import {
   AgentError,
   CACHE_TIMEOUTS,
@@ -58,45 +66,45 @@ import {
   resolveVoteTimeout,
   toRateLimitError,
   validateTimeout
-} from "./chunk-IMWYKX4H.js";
+} from "./chunk-HSOPD265.js";
 import {
   OUTCOMES_FILE,
   ensureLearningDir
 } from "./chunk-CLYZ7FWP.js";
 
 // src/mcp/tools/consensus-vote.ts
-import { z as z22 } from "zod";
+import { z as z19 } from "zod";
 
 // src/mcp/mcp-notifier.ts
 import { AsyncLocalStorage } from "async_hooks";
 var internalLogger = createLogger({ component: "mcp-notifier" });
 function createMcpNotifier(server) {
-  function send(level, logger13, data) {
+  function send(level, logger11, data) {
     try {
-      server.sendLoggingMessage({ level, logger: logger13, data }).catch((error) => {
+      server.sendLoggingMessage({ level, logger: logger11, data }).catch((error) => {
         internalLogger.debug("Failed to send MCP notification", {
           level,
-          logger: logger13,
+          logger: logger11,
           error: getErrorMessage(error)
         });
       });
     } catch (error) {
       internalLogger.debug("Failed to send MCP notification", {
         level,
-        logger: logger13,
+        logger: logger11,
         error: getErrorMessage(error)
       });
     }
   }
   return {
-    info: (logger13, data) => {
-      send("info", logger13, data);
+    info: (logger11, data) => {
+      send("info", logger11, data);
     },
-    debug: (logger13, data) => {
-      send("debug", logger13, data);
+    debug: (logger11, data) => {
+      send("debug", logger11, data);
     },
-    warn: (logger13, data) => {
-      send("warning", logger13, data);
+    warn: (logger11, data) => {
+      send("warning", logger11, data);
     }
   };
 }
@@ -221,7 +229,7 @@ var RateLimiter = class {
     this.logger.debug("Rate limiter reset", { tokens: this.tokens });
   }
 };
-function createDefaultRateLimiter(name, logger13) {
+function createDefaultRateLimiter(name, logger11) {
   const config = {
     capacity: 100,
     refillRate: 10,
@@ -230,8 +238,8 @@ function createDefaultRateLimiter(name, logger13) {
   if (name !== void 0) {
     config.name = name;
   }
-  if (logger13 !== void 0) {
-    config.logger = logger13;
+  if (logger11 !== void 0) {
+    config.logger = logger11;
   }
   return new RateLimiter(config);
 }
@@ -669,7 +677,7 @@ var TimeoutGuard = class {
         reject(new Error(`Operation timed out after ${String(timeoutMs)}ms`));
       }, timeoutMs);
     });
-    const promises2 = [operation(), timeoutPromise];
+    const promises = [operation(), timeoutPromise];
     if (signal !== void 0 && !signal.aborted) {
       const abortPromise = new Promise((_resolve, reject) => {
         signal.addEventListener(
@@ -680,9 +688,9 @@ var TimeoutGuard = class {
           { once: true }
         );
       });
-      promises2.push(abortPromise);
+      promises.push(abortPromise);
     }
-    return Promise.race(promises2);
+    return Promise.race(promises);
   }
   handleSuccess(result, startTime, timeoutMs, operationName) {
     const durationMs = getTimeProvider().now() - startTime;
@@ -943,13 +951,13 @@ function buildMiddlewareStack(config) {
   return middlewares;
 }
 function createMiddlewareChain(config) {
-  const logger13 = config.logger ?? createLogger({ tool: config.toolName });
+  const logger11 = config.logger ?? createLogger({ tool: config.toolName });
   const middlewares = buildMiddlewareStack(config);
   const composed = composeMiddleware(middlewares);
   return (handler) => {
     return async (args) => {
       const requestContext = createRequestContext({ toolName: config.toolName });
-      const requestLogger = logger13.child(contextForLogging(requestContext));
+      const requestLogger = logger11.child(contextForLogging(requestContext));
       const ctx = { requestContext, logger: requestLogger };
       return composed(args, ctx, (finalArgs, finalCtx) => handler(finalArgs, finalCtx));
     };
@@ -1158,15 +1166,15 @@ function sanitizeToolInput(args) {
     detectedPatterns: uniquePatterns
   };
 }
-function logSanitizationResult(result, logger13, toolName) {
+function logSanitizationResult(result, logger11, toolName) {
   if (result.wasModified) {
-    logger13.warn("Tool input sanitized \u2014 XML injection tags stripped", {
+    logger11.warn("Tool input sanitized \u2014 XML injection tags stripped", {
       tool: toolName,
       modifiedFields: result.modifiedCount
     });
   }
   if (result.detectedPatterns.length > 0) {
-    logger13.warn("Injection patterns detected in tool input", {
+    logger11.warn("Injection patterns detected in tool input", {
       tool: toolName,
       patterns: result.detectedPatterns
     });
@@ -1211,11 +1219,11 @@ var SECRET_PATTERNS = [
   // password= or token= in output
   /(?:password|token|secret|apikey|api_key)\s*[=:]\s*\S{8,}/i
 ];
-function sanitizeOutput(text, logger13) {
+function sanitizeOutput(text, logger11) {
   let sanitized = text;
   for (const pattern of SECRET_PATTERNS) {
     if (pattern.test(sanitized)) {
-      logger13.warn("Potential secret detected in tool output, redacting", {
+      logger11.warn("Potential secret detected in tool output, redacting", {
         pattern: pattern.source.slice(0, 30)
       });
       sanitized = sanitized.replace(pattern, "[REDACTED]");
@@ -1223,25 +1231,25 @@ function sanitizeOutput(text, logger13) {
   }
   return sanitized;
 }
-function sanitizeToolResult(result, logger13) {
+function sanitizeToolResult(result, logger11) {
   for (const item of result.content) {
-    item.text = sanitizeOutput(item.text, logger13);
+    item.text = sanitizeOutput(item.text, logger11);
   }
 }
-function checkInputSize(args, logger13, requestId) {
+function checkInputSize(args, logger11, requestId) {
   if (args === void 0) return null;
   const inputSize = JSON.stringify(args).length;
   if (inputSize > MAX_INPUT_SIZE_BYTES) {
-    logger13.warn("Input size exceeds limit", { inputSize, limit: MAX_INPUT_SIZE_BYTES });
+    logger11.warn("Input size exceeds limit", { inputSize, limit: MAX_INPUT_SIZE_BYTES });
     return internalError("Input too large", requestId);
   }
   return null;
 }
-function checkRateLimit(rateLimiter, logger13) {
+function checkRateLimit(rateLimiter, logger11) {
   const acquired = rateLimiter.tryAcquire();
   if (!acquired) {
     const state = rateLimiter.getState();
-    logger13.warn("Rate limit exceeded");
+    logger11.warn("Rate limit exceeded");
     return rateLimitError(state.nextTokenMs);
   }
   return null;
@@ -1262,14 +1270,14 @@ function checkPolicy(opts) {
   opts.logger.debug("Policy check passed", { reason: decision.reason });
   return null;
 }
-async function executeHandler(handler, args, ctx, logger13) {
+async function executeHandler(handler, args, ctx, logger11) {
   const startTime = getTimeProvider().now();
   const result = handler.length >= 2 ? await handler(args, ctx) : await handler(args);
   const durationMs = getTimeProvider().now() - startTime;
   if (result.isError === true) {
-    logger13.warn("Tool execution completed with error", { durationMs });
+    logger11.warn("Tool execution completed with error", { durationMs });
   } else {
-    logger13.info("Tool execution completed", { durationMs });
+    logger11.info("Tool execution completed", { durationMs });
   }
   return result;
 }
@@ -1305,12 +1313,12 @@ function emitRateLimitAudit(auditLogger, toolName, ctx) {
     requestId: ctx.requestId
   });
 }
-function checkSecurityTier(config, sanitizeResult, logger13) {
+function checkSecurityTier(config, sanitizeResult, logger11) {
   const tier = config.securityTier ?? "standard";
   if (tier === "standard" || sanitizeResult.detectedPatterns.length === 0) {
     return null;
   }
-  logger13.warn("Input rejected by security tier validation", {
+  logger11.warn("Input rejected by security tier validation", {
     tier,
     patterns: sanitizeResult.detectedPatterns
   });
@@ -1324,16 +1332,16 @@ function checkSecurityTier(config, sanitizeResult, logger13) {
     ]
   };
 }
-function runPreChecks(config, args, mode, requestContext, logger13) {
-  const sizeResult = checkInputSize(args, logger13, requestContext.requestId);
+function runPreChecks(config, args, mode, requestContext, logger11) {
+  const sizeResult = checkInputSize(args, logger11, requestContext.requestId);
   if (sizeResult) return { error: sizeResult, sanitizedArgs: args };
   const sanitizeResult = sanitizeToolInput(args);
-  logSanitizationResult(sanitizeResult, logger13, config.toolName);
+  logSanitizationResult(sanitizeResult, logger11, config.toolName);
   const sanitizedArgs = sanitizeResult.wasModified ? sanitizeResult.sanitized : args;
-  const tierError = checkSecurityTier(config, sanitizeResult, logger13);
+  const tierError = checkSecurityTier(config, sanitizeResult, logger11);
   if (tierError !== null) return { error: tierError, sanitizedArgs };
   if (config.rateLimiter) {
-    const rlResult = checkRateLimit(config.rateLimiter, logger13);
+    const rlResult = checkRateLimit(config.rateLimiter, logger11);
     if (rlResult) {
       if (config.auditLogger)
         emitRateLimitAudit(config.auditLogger, config.toolName, requestContext);
@@ -1347,7 +1355,7 @@ function runPreChecks(config, args, mode, requestContext, logger13) {
       args: sanitizedArgs,
       mode,
       allowedPaths: config.allowedPaths,
-      logger: logger13,
+      logger: logger11,
       requestId: requestContext.requestId
     });
     if (pResult) {
@@ -1359,7 +1367,7 @@ function runPreChecks(config, args, mode, requestContext, logger13) {
   return { error: null, sanitizedArgs };
 }
 function createSecureHandler(handler, config) {
-  const logger13 = config.logger ?? createLogger({ tool: config.toolName });
+  const logger11 = config.logger ?? createLogger({ tool: config.toolName });
   const mode = config.executionMode ?? "read-only";
   return async (args) => {
     const ctxOpts = {
@@ -1367,7 +1375,7 @@ function createSecureHandler(handler, config) {
       ...config.callerInfo && { caller: config.callerInfo }
     };
     const requestContext = createRequestContext(ctxOpts);
-    const requestLogger = logger13.child(contextForLogging(requestContext));
+    const requestLogger = logger11.child(contextForLogging(requestContext));
     requestLogger.info("Tool invocation started");
     const { error: preCheckError, sanitizedArgs } = runPreChecks(
       config,
@@ -2685,13 +2693,13 @@ var SdkAdapter = class extends BaseAdapter {
   sdkConfig;
   /** Inflight init promise for coalescing concurrent calls (Issue #1438). */
   initPromise;
-  constructor(config, logger13) {
+  constructor(config, logger11) {
     const apiKey = resolveApiKey(config.providerId, config.apiKey);
     super({
       providerId: `sdk-${config.providerId}`,
       modelId: config.modelId,
       capabilities: [ModelCapability.COMPLETION, ModelCapability.STREAMING],
-      logger: logger13 ?? createLogger({ adapter: `sdk-${config.providerId}` }),
+      logger: logger11 ?? createLogger({ adapter: `sdk-${config.providerId}` }),
       ...apiKey !== void 0 ? { apiKey } : {},
       ...config.timeout !== void 0 ? { timeout: config.timeout } : {},
       ...config.maxRetries !== void 0 ? { maxRetries: config.maxRetries } : {}
@@ -2864,19 +2872,19 @@ var SdkAdapter = class extends BaseAdapter {
 
 // src/adapters/auto-adapter.ts
 var defaultLogger = createLogger({ component: "auto-adapter" });
-function resolveCache(config, logger13) {
+function resolveCache(config, logger11) {
   if (config.cache !== void 0) {
     return config.cache;
   }
   const enableCache = config.enableCache ?? true;
-  return enableCache ? createCliDetectionCache({ logger: logger13 }) : void 0;
+  return enableCache ? createCliDetectionCache({ logger: logger11 }) : void 0;
 }
-async function tryCliAdapter(config, logger13, cache) {
+async function tryCliAdapter(config, logger11, cache) {
   const preferredCli = config.preferredCli;
   const bridgeConfig = config.defaultCliTimeoutMs !== void 0 ? { defaultTimeoutMs: config.defaultCliTimeoutMs } : void 0;
   if (preferredCli !== void 0 && await isCliAvailable(preferredCli, cache)) {
-    logger13.info("Using preferred CLI", { cli: preferredCli });
-    const cliAdapter2 = createCliAdapter({ cli: preferredCli, logger: logger13 });
+    logger11.info("Using preferred CLI", { cli: preferredCli });
+    const cliAdapter2 = createCliAdapter({ cli: preferredCli, logger: logger11 });
     await cliAdapter2.initialize();
     return {
       adapter: createCliToModelAdapter(cliAdapter2, bridgeConfig),
@@ -2888,15 +2896,15 @@ async function tryCliAdapter(config, logger13, cache) {
   }
   const availableClis = await getAvailableClis(cache);
   if (availableClis.length === 0) {
-    logger13.info("No CLI adapters available");
+    logger11.info("No CLI adapters available");
     return null;
   }
   const selectedCli = availableClis[0];
   if (selectedCli === void 0) {
     return null;
   }
-  logger13.info("Auto-selected CLI", { cli: selectedCli, available: availableClis });
-  const cliAdapter = createCliAdapter({ cli: selectedCli, logger: logger13 });
+  logger11.info("Auto-selected CLI", { cli: selectedCli, available: availableClis });
+  const cliAdapter = createCliAdapter({ cli: selectedCli, logger: logger11 });
   await cliAdapter.initialize();
   return {
     adapter: createCliToModelAdapter(cliAdapter, bridgeConfig),
@@ -2910,13 +2918,13 @@ function resolveApiKeyFromEnv(configKey, envVar) {
   const key = configKey ?? process.env[envVar];
   return key !== void 0 && key.length > 0 ? key : void 0;
 }
-function tryApiAdapter(config, logger13) {
+function tryApiAdapter(config, logger11) {
   const claudeModelId = getCliModelName(DEFAULT_MODEL_PER_CLI["claude"]);
   const codexModelId = getCliModelName(DEFAULT_MODEL_PER_CLI["codex"]);
   const geminiModelId = getCliModelName(DEFAULT_MODEL_PER_CLI["gemini"]);
   const anthropicKey = resolveApiKeyFromEnv(config.anthropicApiKey, "ANTHROPIC_API_KEY");
   if (anthropicKey !== void 0) {
-    logger13.info("Using Anthropic API adapter", { model: claudeModelId });
+    logger11.info("Using Anthropic API adapter", { model: claudeModelId });
     return {
       adapter: createClaudeAdapter({ modelId: claudeModelId, apiKey: anthropicKey }),
       source: "api",
@@ -2926,7 +2934,7 @@ function tryApiAdapter(config, logger13) {
   }
   const openaiKey = resolveApiKeyFromEnv(config.openaiApiKey, "OPENAI_API_KEY");
   if (openaiKey !== void 0) {
-    logger13.info("Using OpenAI API adapter (AI SDK)", { model: codexModelId });
+    logger11.info("Using OpenAI API adapter (AI SDK)", { model: codexModelId });
     return {
       adapter: new SdkAdapter({ providerId: "openai", modelId: codexModelId, apiKey: openaiKey }),
       source: "api",
@@ -2936,7 +2944,7 @@ function tryApiAdapter(config, logger13) {
   }
   const googleKey = resolveApiKeyFromEnv(config.googleApiKey, "GOOGLE_AI_API_KEY");
   if (googleKey !== void 0) {
-    logger13.info("Using Google AI API adapter (AI SDK)", { model: geminiModelId });
+    logger11.info("Using Google AI API adapter (AI SDK)", { model: geminiModelId });
     return {
       adapter: new SdkAdapter({
         providerId: "google",
@@ -2948,55 +2956,55 @@ function tryApiAdapter(config, logger13) {
       reason: `Using Google AI API via AI SDK (model: ${geminiModelId})`
     };
   }
-  logger13.info("No API keys available for any provider");
+  logger11.info("No API keys available for any provider");
   return null;
 }
-async function selectCliFirst(config, logger13, cache) {
-  const cliResult = await tryCliAdapter(config, logger13, cache);
+async function selectCliFirst(config, logger11, cache) {
+  const cliResult = await tryCliAdapter(config, logger11, cache);
   if (cliResult !== null) return cliResult;
-  const apiResult = tryApiAdapter(config, logger13);
+  const apiResult = tryApiAdapter(config, logger11);
   if (apiResult !== null) return apiResult;
   throw new Error(
     "No adapters available. Install a CLI (claude/gemini/codex) or set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GOOGLE_AI_API_KEY."
   );
 }
-async function selectApiFirst(config, logger13, cache) {
-  const apiResult = tryApiAdapter(config, logger13);
+async function selectApiFirst(config, logger11, cache) {
+  const apiResult = tryApiAdapter(config, logger11);
   if (apiResult !== null) return apiResult;
-  const cliResult = await tryCliAdapter(config, logger13, cache);
+  const cliResult = await tryCliAdapter(config, logger11, cache);
   if (cliResult !== null) return cliResult;
   throw new Error(
     "No adapters available. Set ANTHROPIC_API_KEY/OPENAI_API_KEY/GOOGLE_AI_API_KEY or install a CLI (claude/gemini/codex)."
   );
 }
-async function selectCliOnly(config, logger13, cache) {
-  const cliResult = await tryCliAdapter(config, logger13, cache);
+async function selectCliOnly(config, logger11, cache) {
+  const cliResult = await tryCliAdapter(config, logger11, cache);
   if (cliResult !== null) return cliResult;
   throw new Error(
     "No CLI adapters available. Install and authenticate claude, gemini, or codex CLI."
   );
 }
-function selectApiOnly(config, logger13) {
-  const apiResult = tryApiAdapter(config, logger13);
+function selectApiOnly(config, logger11) {
+  const apiResult = tryApiAdapter(config, logger11);
   if (apiResult !== null) return apiResult;
   throw new Error(
     "No API key available. Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GOOGLE_AI_API_KEY."
   );
 }
 async function createAutoAdapter(config = {}) {
-  const logger13 = config.logger ?? defaultLogger;
+  const logger11 = config.logger ?? defaultLogger;
   const priority = config.priority ?? "cli-first";
-  const cache = resolveCache(config, logger13);
-  logger13.info("Auto-selecting adapter", { priority, cacheEnabled: cache !== void 0 });
+  const cache = resolveCache(config, logger11);
+  logger11.info("Auto-selecting adapter", { priority, cacheEnabled: cache !== void 0 });
   switch (priority) {
     case "cli-first":
-      return selectCliFirst(config, logger13, cache);
+      return selectCliFirst(config, logger11, cache);
     case "api-first":
-      return selectApiFirst(config, logger13, cache);
+      return selectApiFirst(config, logger11, cache);
     case "cli-only":
-      return selectCliOnly(config, logger13, cache);
+      return selectCliOnly(config, logger11, cache);
     case "api-only":
-      return selectApiOnly(config, logger13);
+      return selectApiOnly(config, logger11);
     default: {
       const exhaustive = priority;
       throw new Error(`Unknown priority: ${String(exhaustive)}`);
@@ -3247,13 +3255,13 @@ var EventBus = class {
       topic: enrichedEvent.topic,
       eventId: enrichedEvent.eventId
     });
-    const promises2 = [];
+    const promises = [];
     for (const record of this.subscriptions.values()) {
       if (topicMatchesPattern(enrichedEvent.topic, record.regex)) {
-        promises2.push(this.invokeListenerAsync(record, enrichedEvent));
+        promises.push(this.invokeListenerAsync(record, enrichedEvent));
       }
     }
-    await Promise.all(promises2);
+    await Promise.all(promises);
   }
   /**
    * Subscribe to events matching a topic pattern.
@@ -4191,14 +4199,14 @@ async function executeSingleVoteAttempt(role, proposal, adapter, timeoutMs) {
   }
 }
 async function executeWithRetries(opts) {
-  const { role, proposal, adapter, logger: logger13, timeoutMs, maxRetries } = opts;
+  const { role, proposal, adapter, logger: logger11, timeoutMs, maxRetries } = opts;
   let lastError = "";
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     if (attempt > 0) {
       const isRateLimit = isRateLimitError(lastError);
       const baseDelay = isRateLimit ? RATE_LIMIT_RETRY_DELAY_MS : INITIAL_RETRY_DELAY_MS;
       const delayMs = baseDelay * Math.pow(2, attempt - 1);
-      logger13.debug("Retrying vote execution", { role, attempt, delayMs, isRateLimit });
+      logger11.debug("Retrying vote execution", { role, attempt, delayMs, isRateLimit });
       await delay(delayMs);
     }
     const result = await executeSingleVoteAttempt(role, proposal, adapter, timeoutMs);
@@ -4207,7 +4215,7 @@ async function executeWithRetries(opts) {
     }
     lastError = result.error;
     const rateLimited = isRateLimitError(lastError);
-    logger13.warn("Vote attempt failed", {
+    logger11.warn("Vote attempt failed", {
       role,
       attempt: attempt + 1,
       maxRetries: maxRetries + 1,
@@ -4218,35 +4226,85 @@ async function executeWithRetries(opts) {
   return { error: lastError !== "" ? lastError : "Unknown error after all retries", ok: false };
 }
 
+// src/cli/voter-agents-deadline.ts
+var DEADLINE_MESSAGE = "overall consensus deadline exceeded";
+function raceWithDeadline(p, role, deadlineMs) {
+  let timer;
+  const timeoutP = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      resolve(createErrorVoteResult(role, DEADLINE_MESSAGE, deadlineMs));
+    }, deadlineMs);
+  });
+  return Promise.race([p, timeoutP]).finally(() => {
+    if (timer !== void 0) clearTimeout(timer);
+  });
+}
+async function launchVotesWithOverallDeadline(input) {
+  const {
+    roles,
+    proposal,
+    roleAdapters,
+    fallbackAdapter,
+    logger: logger11,
+    voteOptions,
+    interDelay,
+    overallDeadlineMs,
+    voteFn
+  } = input;
+  const startedAt = Date.now();
+  const wrapped = roles.map(async (role, i) => {
+    if (i > 0 && interDelay > 0) await delay(interDelay);
+    const adapter = roleAdapters.get(role) ?? fallbackAdapter;
+    const elapsed = Date.now() - startedAt;
+    const remaining = Math.max(1, overallDeadlineMs - elapsed);
+    return raceWithDeadline(voteFn(role, proposal, adapter, logger11, voteOptions), role, remaining);
+  });
+  const results = await Promise.all(wrapped);
+  const expired = results.filter((r) => r.source === "error" && r.error === DEADLINE_MESSAGE);
+  if (expired.length > 0) {
+    logger11.warn("Consensus overall deadline reached; returning partial results", {
+      totalRoles: roles.length,
+      expiredRoles: expired.map((r) => r.role),
+      overallDeadlineMs
+    });
+  }
+  return results;
+}
+
 // src/cli/voter-agents.ts
-var DEFAULT_INTER_AGENT_DELAY_MS = 1e3;
+function computeOverallConsensusDeadlineMs(timeoutMs, maxRetries, roleCount, interDelayMs) {
+  const perVoteBudget = timeoutMs * (maxRetries + 1);
+  const staggerBudget = Math.max(0, roleCount - 1) * interDelayMs;
+  return perVoteBudget + staggerBudget + 6e4;
+}
+var DEFAULT_INTER_AGENT_DELAY_MS = 2e3;
 var defaultLogger2 = createLogger({ component: "voter-agents" });
-async function executeAgentVote(role, proposal, adapter, logger13, options) {
+async function executeAgentVote(role, proposal, adapter, logger11, options) {
   const start = getTimeProvider().now();
   const timeoutMs = options?.timeoutMs ?? resolveVoteTimeout();
   const maxRetries = options?.maxRetries ?? VOTE_TIMEOUTS.maxRetries;
   const allowSimulation = options?.allowSimulation ?? false;
-  logger13.info("Executing vote", { role, model: adapter.modelId, provider: adapter.providerId });
+  logger11.info("Executing vote", { role, model: adapter.modelId, provider: adapter.providerId });
   const result = await executeWithRetries({
     role,
     proposal,
     adapter,
-    logger: logger13,
+    logger: logger11,
     timeoutMs,
     maxRetries
   });
   const processingTimeMs = getTimeProvider().now() - start;
   if (result.ok) {
-    logger13.info("Vote completed", { role, model: adapter.modelId, decision: result.vote.decision });
+    logger11.info("Vote completed", { role, model: adapter.modelId, decision: result.vote.decision });
     return { role, vote: result.vote, processingTimeMs, source: "llm", cli: adapter.providerId };
   }
-  logger13.error("Vote execution failed after all retries", void 0, {
+  logger11.error("Vote execution failed after all retries", void 0, {
     role,
     model: adapter.modelId,
     errorMessage: result.error
   });
   if (allowSimulation) {
-    logger13.warn("Falling back to simulation (allowSimulation=true)", { role });
+    logger11.warn("Falling back to simulation (allowSimulation=true)", { role });
     return createSimulationVoteResult(role, proposal, processingTimeMs, result.error);
   }
   return createErrorVoteResult(role, result.error, processingTimeMs);
@@ -4257,10 +4315,10 @@ var NoAdapterError = class extends Error {
     this.name = "NoAdapterError";
   }
 };
-function resolveAdapter(options, logger13) {
+function resolveAdapter(options, logger11) {
   try {
     if (options.adapter !== void 0) return { adapter: options.adapter };
-    const registry = getGlobalRegistry({ logger: logger13 });
+    const registry = getGlobalRegistry({ logger: logger11 });
     return { adapter: registry.getDefault() };
   } catch (error) {
     return { error: getErrorMessage(error) };
@@ -4271,29 +4329,29 @@ function assignUniformAdapter(roles, adapter) {
   for (const role of roles) adapters.set(role, adapter);
   return adapters;
 }
-function createCliAdapterMap(clis, logger13) {
-  const registry = getGlobalRegistry({ logger: logger13 });
+function createCliAdapterMap(clis, logger11) {
+  const registry = getGlobalRegistry({ logger: logger11 });
   const result = /* @__PURE__ */ new Map();
   for (const cli of clis) {
     result.set(cli, registry.getAdapterForCli(cli));
   }
   return result;
 }
-async function resolveDiverseAdapters(roles, logger13, fallbackAdapter) {
+async function resolveDiverseAdapters(roles, logger11, fallbackAdapter) {
   let availableClis;
   try {
     availableClis = await getAvailableClis();
   } catch (e) {
-    logger13.warn("Failed to resolve available CLIs; falling back to single adapter", {
+    logger11.warn("Failed to resolve available CLIs; falling back to single adapter", {
       error: String(e)
     });
     availableClis = [];
   }
   if (availableClis.length <= 1) {
-    logger13.info("Using single adapter for all roles", { cliCount: availableClis.length });
+    logger11.info("Using single adapter for all roles", { cliCount: availableClis.length });
     return assignUniformAdapter(roles, fallbackAdapter);
   }
-  const cliAdapters = createCliAdapterMap(availableClis, logger13);
+  const cliAdapters = createCliAdapterMap(availableClis, logger11);
   if (cliAdapters.size <= 1) return assignUniformAdapter(roles, fallbackAdapter);
   const cliList = [...cliAdapters.entries()];
   const adapters = /* @__PURE__ */ new Map();
@@ -4305,7 +4363,7 @@ async function resolveDiverseAdapters(roles, logger13, fallbackAdapter) {
     adapters.set(role, entry[1]);
     assignments[role] = entry[0];
   }
-  logger13.info("Diverse adapters assigned", {
+  logger11.info("Diverse adapters assigned", {
     cliCount: cliAdapters.size,
     clis: [...cliAdapters.keys()],
     roleAssignments: assignments
@@ -4313,38 +4371,46 @@ async function resolveDiverseAdapters(roles, logger13, fallbackAdapter) {
   return adapters;
 }
 async function launchStaggeredVotes(input) {
-  const { roles, proposal, roleAdapters, fallbackAdapter, logger: logger13, voteOptions, interDelay } = input;
-  const votePromises = [];
-  for (const [i, role] of roles.entries()) {
-    if (i > 0 && interDelay > 0) {
-      await delay(interDelay);
-    }
-    const adapter = roleAdapters.get(role) ?? fallbackAdapter;
-    votePromises.push(executeAgentVote(role, proposal, adapter, logger13, voteOptions));
-  }
-  return Promise.all(votePromises);
+  const { roles, proposal, roleAdapters, fallbackAdapter, logger: logger11, voteOptions, interDelay } = input;
+  const overallDeadlineMs = computeOverallConsensusDeadlineMs(
+    voteOptions.timeoutMs,
+    voteOptions.maxRetries,
+    roles.length,
+    interDelay
+  );
+  return launchVotesWithOverallDeadline({
+    roles,
+    proposal,
+    roleAdapters,
+    fallbackAdapter,
+    logger: logger11,
+    voteOptions,
+    interDelay,
+    overallDeadlineMs,
+    voteFn: executeAgentVote
+  });
 }
 async function collectRealVotes(options) {
-  const logger13 = options.logger ?? defaultLogger2;
+  const logger11 = options.logger ?? defaultLogger2;
   const { roles, proposal, simulate, allowSimulation } = options;
   const timeoutMs = options.timeoutMs ?? resolveVoteTimeout();
   const maxRetries = options.maxRetries ?? VOTE_TIMEOUTS.maxRetries;
   if (simulate === true) {
-    logger13.info("Using simulation mode (explicitly requested)");
+    logger11.info("Using simulation mode (explicitly requested)");
     return createSimulatedVotes(roles, proposal);
   }
-  const adapterResult = resolveAdapter(options, logger13);
+  const adapterResult = resolveAdapter(options, logger11);
   if ("error" in adapterResult) {
-    logger13.error("No adapter available for voting", void 0, { error: adapterResult.error });
+    logger11.error("No adapter available for voting", void 0, { error: adapterResult.error });
     if (allowSimulation === true) {
-      logger13.warn("Falling back to simulation (allowSimulation=true)");
+      logger11.warn("Falling back to simulation (allowSimulation=true)");
       return createSimulatedVotes(roles, proposal, "No adapter available");
     }
     throw new NoAdapterError(
       `No adapter available for voting: ${adapterResult.error}. Install a CLI (claude/gemini/codex) or set ANTHROPIC_API_KEY.`
     );
   }
-  const roleAdapters = options.adapter !== void 0 ? assignUniformAdapter(roles, adapterResult.adapter) : await resolveDiverseAdapters(roles, logger13, adapterResult.adapter);
+  const roleAdapters = options.adapter !== void 0 ? assignUniformAdapter(roles, adapterResult.adapter) : await resolveDiverseAdapters(roles, logger11, adapterResult.adapter);
   const voteOptions = { timeoutMs, maxRetries, allowSimulation: allowSimulation ?? false };
   const interDelay = options.interAgentDelayMs ?? DEFAULT_INTER_AGENT_DELAY_MS;
   return launchStaggeredVotes({
@@ -4352,7 +4418,7 @@ async function collectRealVotes(options) {
     proposal,
     roleAdapters,
     fallbackAdapter: adapterResult.adapter,
-    logger: logger13,
+    logger: logger11,
     voteOptions,
     interDelay
   });
@@ -5297,11 +5363,11 @@ var ConsensusEngine = class {
   logger;
   metrics;
   voterExpansionCallback;
-  constructor(config, logger13) {
+  constructor(config, logger11) {
     this.config = { ...DEFAULT_CONSENSUS_CONFIG, ...config };
     this.cacheConfig = { ...DEFAULT_PROPOSAL_CACHE_CONFIG, ...config?.proposalCache };
     this.quorumConfig = { ...DEFAULT_INCREMENTAL_QUORUM_CONFIG, ...config?.incrementalQuorum };
-    this.logger = logger13 ?? createLogger({ component: "ConsensusEngine" });
+    this.logger = logger11 ?? createLogger({ component: "ConsensusEngine" });
     this.strategyFactory = new VotingStrategyFactory();
     this.metrics = this.createInitialMetrics();
   }
@@ -5724,8 +5790,8 @@ var ConsensusEngine = class {
     this.logger.debug("Proposal cache cleared");
   }
 };
-function createConsensusEngine(config, logger13) {
-  return new ConsensusEngine(config, logger13);
+function createConsensusEngine(config, logger11) {
+  return new ConsensusEngine(config, logger11);
 }
 
 // src/consensus/quorum-validator.ts
@@ -5733,8 +5799,8 @@ var DEFAULT_MIN_TRUST = 0.3;
 var DEFAULT_MIN_WEIGHT = 0.1;
 var QuorumValidator = class {
   logger;
-  constructor(logger13) {
-    this.logger = logger13 ?? createLogger({ component: "QuorumValidator" });
+  constructor(logger11) {
+    this.logger = logger11 ?? createLogger({ component: "QuorumValidator" });
   }
   validateQuorum(input) {
     const { votes, config } = input;
@@ -5961,8 +6027,8 @@ var QuorumValidator = class {
     };
   }
 };
-function createQuorumValidator(logger13) {
-  return new QuorumValidator(logger13);
+function createQuorumValidator(logger11) {
+  return new QuorumValidator(logger11);
 }
 
 // src/consensus/voting-protocol-helpers.ts
@@ -7571,44 +7637,12 @@ function buildResponse(input, result) {
 }
 
 // src/mcp/tools/tool-memory.ts
-import * as fs4 from "fs";
+import * as fs3 from "fs";
 import * as os3 from "os";
-import * as path4 from "path";
-
-// src/context/memory-backend-types.ts
-import { z as z9 } from "zod";
-var MemoryImportance = {
-  LOW: "low",
-  MEDIUM: "medium",
-  HIGH: "high"
-};
-var MemoryImportanceSchema = z9.enum(["low", "medium", "high"]);
-var MemoryMetadataSchema = z9.object({
-  importance: MemoryImportanceSchema,
-  tags: z9.array(z9.string()).optional(),
-  ttl: z9.number().positive().optional()
-});
-var MemoryEntrySchema = z9.object({
-  key: z9.string().min(1),
-  value: z9.unknown(),
-  metadata: MemoryMetadataSchema,
-  createdAt: z9.date(),
-  accessedAt: z9.date()
-});
-var MemoryError = class extends NexusError {
-  constructor(message, options) {
-    super(message, { code: ErrorCode.INTERNAL_ERROR, ...options });
-    this.name = "MemoryError";
-  }
-};
-var HybridMemoryConfigSchema = z9.object({
-  dbPath: z9.string().min(1),
-  markdownDir: z9.string().min(1),
-  autoExpire: z9.boolean().optional()
-});
+import * as path3 from "path";
 
 // src/context/belief-core-types.ts
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 var BeliefConfidence = {
   /** Strong evidence, short reasoning chain */
   HIGH: "high",
@@ -7619,7 +7653,7 @@ var BeliefConfidence = {
   /** Speculative or hypothetical */
   SPECULATIVE: "speculative"
 };
-var BeliefConfidenceSchema = z10.enum(["high", "medium", "low", "speculative"]);
+var BeliefConfidenceSchema = z9.enum(["high", "medium", "low", "speculative"]);
 var BeliefSourceType = {
   /** Direct observation from environment */
   OBSERVATION: "observation",
@@ -7634,7 +7668,7 @@ var BeliefSourceType = {
   /** Default or prior belief */
   PRIOR: "prior"
 };
-var BeliefSourceTypeSchema = z10.enum([
+var BeliefSourceTypeSchema = z9.enum([
   "observation",
   "inference",
   "external",
@@ -7642,26 +7676,26 @@ var BeliefSourceTypeSchema = z10.enum([
   "hindsight",
   "prior"
 ]);
-var BeliefSchema = z10.object({
-  beliefId: z10.string().min(1),
-  subject: z10.string().min(1),
-  predicate: z10.string().min(1),
-  object: z10.string(),
+var BeliefSchema = z9.object({
+  beliefId: z9.string().min(1),
+  subject: z9.string().min(1),
+  predicate: z9.string().min(1),
+  object: z9.string(),
   confidence: BeliefConfidenceSchema,
   sourceType: BeliefSourceTypeSchema,
-  sourceRef: z10.string().optional(),
-  derivedFrom: z10.array(z10.string()).optional(),
-  version: z10.number().int().min(1),
-  createdAt: z10.date(),
-  updatedAt: z10.date(),
-  superseded: z10.boolean(),
-  supersededBy: z10.string().optional(),
-  domain: z10.string().optional(),
-  metadata: z10.record(z10.string(), z10.unknown()).optional()
+  sourceRef: z9.string().optional(),
+  derivedFrom: z9.array(z9.string()).optional(),
+  version: z9.number().int().min(1),
+  createdAt: z9.date(),
+  updatedAt: z9.date(),
+  superseded: z9.boolean(),
+  supersededBy: z9.string().optional(),
+  domain: z9.string().optional(),
+  metadata: z9.record(z9.string(), z9.unknown()).optional()
 });
 
 // src/context/belief-update-types.ts
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 var BeliefUpdateType = {
   /** Add a new belief (retain) */
   RETAIN: "retain",
@@ -7676,7 +7710,7 @@ var BeliefUpdateType = {
   /** Weaken belief based on contradicting evidence */
   WEAKEN: "weaken"
 };
-var BeliefUpdateTypeSchema = z11.enum([
+var BeliefUpdateTypeSchema = z10.enum([
   "retain",
   "revise",
   "supersede",
@@ -7684,75 +7718,75 @@ var BeliefUpdateTypeSchema = z11.enum([
   "reinforce",
   "weaken"
 ]);
-var BeliefUpdateSchema = z11.object({
-  updateId: z11.string().min(1),
-  beliefId: z11.string().min(1),
+var BeliefUpdateSchema = z10.object({
+  updateId: z10.string().min(1),
+  beliefId: z10.string().min(1),
   updateType: BeliefUpdateTypeSchema,
-  previousState: z11.record(z11.string(), z11.unknown()).optional(),
-  newState: z11.record(z11.string(), z11.unknown()),
-  reason: z11.string().min(1),
-  evidence: z11.string().optional(),
-  timestamp: z11.date(),
-  updatedBy: z11.string().optional()
+  previousState: z10.record(z10.string(), z10.unknown()).optional(),
+  newState: z10.record(z10.string(), z10.unknown()),
+  reason: z10.string().min(1),
+  evidence: z10.string().optional(),
+  timestamp: z10.date(),
+  updatedBy: z10.string().optional()
 });
-var BeliefQuerySchema = z11.object({
-  subject: z11.string().optional(),
-  predicate: z11.string().optional(),
-  domain: z11.string().optional(),
+var BeliefQuerySchema = z10.object({
+  subject: z10.string().optional(),
+  predicate: z10.string().optional(),
+  domain: z10.string().optional(),
   minConfidence: BeliefConfidenceSchema.optional(),
-  includeSuperseded: z11.boolean().optional(),
+  includeSuperseded: z10.boolean().optional(),
   sourceType: BeliefSourceTypeSchema.optional(),
-  limit: z11.number().int().positive().max(1e3).optional(),
-  orderBy: z11.enum(["createdAt", "updatedAt", "confidence"]).optional(),
-  orderDirection: z11.enum(["asc", "desc"]).optional()
+  limit: z10.number().int().positive().max(1e3).optional(),
+  orderBy: z10.enum(["createdAt", "updatedAt", "confidence"]).optional(),
+  orderDirection: z10.enum(["asc", "desc"]).optional()
 });
 
 // src/context/belief-hindsight-types.ts
-import { z as z12 } from "zod";
-var CounterfactualSchema = z12.object({
-  counterfactualId: z12.string().min(1),
-  hypothesis: z12.string().min(1),
-  affectedBeliefs: z12.array(z12.string()),
-  predictedOutcomes: z12.array(z12.string()),
-  actualOutcomes: z12.array(z12.string()).optional(),
-  validated: z12.boolean(),
-  createdAt: z12.date(),
-  taskContext: z12.string().optional()
+import { z as z11 } from "zod";
+var CounterfactualSchema = z11.object({
+  counterfactualId: z11.string().min(1),
+  hypothesis: z11.string().min(1),
+  affectedBeliefs: z11.array(z11.string()),
+  predictedOutcomes: z11.array(z11.string()),
+  actualOutcomes: z11.array(z11.string()).optional(),
+  validated: z11.boolean(),
+  createdAt: z11.date(),
+  taskContext: z11.string().optional()
 });
-var HindsightRecordSchema = z12.object({
-  hindsightId: z12.string().min(1),
-  taskId: z12.string().min(1),
-  priorBeliefs: z12.array(z12.string()),
-  expectedOutcome: z12.string(),
-  actualOutcome: z12.string(),
-  outcomeMatched: z12.boolean(),
-  correctedBeliefs: z12.array(z12.string()),
-  newBeliefs: z12.array(z12.string()),
-  lessons: z12.array(z12.string()),
-  createdAt: z12.date()
+var HindsightRecordSchema = z11.object({
+  hindsightId: z11.string().min(1),
+  taskId: z11.string().min(1),
+  priorBeliefs: z11.array(z11.string()),
+  expectedOutcome: z11.string(),
+  actualOutcome: z11.string(),
+  outcomeMatched: z11.boolean(),
+  correctedBeliefs: z11.array(z11.string()),
+  newBeliefs: z11.array(z11.string()),
+  lessons: z11.array(z11.string()),
+  createdAt: z11.date()
 });
 
 // src/context/belief-memory-interface.ts
-import { z as z13 } from "zod";
-var BeliefMemoryStatsSchema = z13.object({
-  totalBeliefs: z13.number().int().min(0),
-  activeBeliefs: z13.number().int().min(0),
-  supersededBeliefs: z13.number().int().min(0),
-  beliefsByConfidence: z13.record(BeliefConfidenceSchema, z13.number().int().min(0)),
-  beliefsBySource: z13.record(BeliefSourceTypeSchema, z13.number().int().min(0)),
-  totalUpdates: z13.number().int().min(0),
-  totalCounterfactuals: z13.number().int().min(0),
-  totalHindsightRecords: z13.number().int().min(0),
-  oldestBelief: z13.date().optional(),
-  newestBelief: z13.date().optional()
+import { z as z12 } from "zod";
+var BeliefMemoryStatsSchema = z12.object({
+  totalBeliefs: z12.number().int().min(0),
+  activeBeliefs: z12.number().int().min(0),
+  supersededBeliefs: z12.number().int().min(0),
+  beliefsByConfidence: z12.record(BeliefConfidenceSchema, z12.number().int().min(0)),
+  beliefsBySource: z12.record(BeliefSourceTypeSchema, z12.number().int().min(0)),
+  totalUpdates: z12.number().int().min(0),
+  totalCounterfactuals: z12.number().int().min(0),
+  totalHindsightRecords: z12.number().int().min(0),
+  oldestBelief: z12.date().optional(),
+  newestBelief: z12.date().optional()
 });
-var BeliefMemoryConfigSchema = z13.object({
-  maxBeliefsPerSubject: z13.number().int().positive().optional(),
-  maxTotalBeliefs: z13.number().int().positive().optional(),
-  autoPruneAge: z13.number().positive().optional(),
-  enableInference: z13.boolean().optional(),
+var BeliefMemoryConfigSchema = z12.object({
+  maxBeliefsPerSubject: z12.number().int().positive().optional(),
+  maxTotalBeliefs: z12.number().int().positive().optional(),
+  autoPruneAge: z12.number().positive().optional(),
+  enableInference: z12.boolean().optional(),
   defaultConfidence: BeliefConfidenceSchema.optional(),
-  maxInferenceDepth: z13.number().int().positive().max(10).optional()
+  maxInferenceDepth: z12.number().int().positive().max(10).optional()
 });
 var DEFAULT_BELIEF_CONFIG = {
   maxBeliefsPerSubject: 100,
@@ -8272,13 +8306,13 @@ var HindsightBeliefMemory = class {
   domainIndex = /* @__PURE__ */ new Map();
   config;
   logger;
-  constructor(config, logger13) {
+  constructor(config, logger11) {
     const validation = BeliefMemoryConfigSchema.safeParse(config ?? {});
     if (!validation.success) {
       throw new MemoryError(`Invalid BeliefMemoryConfig: ${formatZodError(validation.error)}`);
     }
     this.config = { ...DEFAULT_BELIEF_CONFIG, ...config };
-    this.logger = logger13 ?? createLogger({ component: "HindsightBeliefMemory" });
+    this.logger = logger11 ?? createLogger({ component: "HindsightBeliefMemory" });
     this.logger.info("HindsightBeliefMemory initialized", { config: this.config });
   }
   get auditStores() {
@@ -8648,448 +8682,8 @@ var HindsightBeliefMemory = class {
   }
 };
 
-// src/context/memory-backend.ts
-import { z as z14 } from "zod";
-
-// src/context/memory-markdown.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-var MemoryMarkdownHelper = class {
-  constructor(markdownDir, logger13) {
-    this.markdownDir = markdownDir;
-    this.logger = logger13;
-  }
-  /**
-   * Ensure the Markdown export directory exists.
-   */
-  ensureDir() {
-    if (!fs2.existsSync(this.markdownDir)) {
-      fs2.mkdirSync(this.markdownDir, { recursive: true });
-      this.logger.debug("Created Markdown directory", { path: this.markdownDir });
-    }
-  }
-  /**
-   * Write a memory entry to Markdown file.
-   */
-  async write(key, value, metadata, createdAt) {
-    const filename = this.keyToFilename(key);
-    const filepath = path2.join(this.markdownDir, filename);
-    const content = this.format(key, value, metadata, createdAt);
-    try {
-      await fs2.promises.writeFile(filepath, content, "utf-8");
-      this.logger.debug("Wrote Markdown file", { key, filepath });
-    } catch (error) {
-      this.logger.warn("Failed to write Markdown file", { key, filepath, error });
-    }
-  }
-  /**
-   * Delete a Markdown file for a memory.
-   */
-  delete(key) {
-    const filename = this.keyToFilename(key);
-    const filepath = path2.join(this.markdownDir, filename);
-    try {
-      if (fs2.existsSync(filepath)) {
-        fs2.unlinkSync(filepath);
-        this.logger.debug("Deleted Markdown file", { key, filepath });
-      }
-    } catch (error) {
-      this.logger.warn("Failed to delete Markdown file", { key, filepath, error });
-    }
-  }
-  /**
-   * Convert a memory key to a safe filename.
-   */
-  keyToFilename(key) {
-    const safeKey = key.replace(/[^a-zA-Z0-9-_]/g, "_").replace(/_+/g, "_").substring(0, 200);
-    return `${safeKey}.md`;
-  }
-  /**
-   * Format a memory entry as Markdown.
-   */
-  format(key, value, metadata, createdAt) {
-    const lines = [
-      `# Memory: ${key}`,
-      "",
-      "## Metadata",
-      "",
-      `- **Importance:** ${metadata.importance}`,
-      `- **Created:** ${createdAt.toISOString()}`
-    ];
-    if (metadata.tags !== void 0 && metadata.tags.length > 0) {
-      lines.push(`- **Tags:** ${metadata.tags.join(", ")}`);
-    }
-    if (metadata.ttl !== void 0) {
-      const expiresAt = new Date(createdAt.getTime() + metadata.ttl);
-      lines.push(`- **Expires:** ${expiresAt.toISOString()}`);
-    }
-    lines.push("", "## Value", "");
-    if (typeof value === "string") {
-      lines.push(value);
-    } else if (value === null) {
-      lines.push("`null`");
-    } else if (typeof value === "object") {
-      lines.push("```json", JSON.stringify(value, null, 2), "```");
-    } else {
-      const stringValue = typeof value === "number" || typeof value === "boolean" ? String(value) : JSON.stringify(value);
-      lines.push(`\`${stringValue}\``);
-    }
-    lines.push("");
-    return lines.join("\n");
-  }
-};
-
-// src/context/memory-operations.ts
-function safeParseJson(raw) {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function parseMetadataOrDefault(raw) {
-  const parsed = safeParseJson(raw);
-  if (parsed !== null && typeof parsed === "object") return parsed;
-  return { importance: "medium" };
-}
-function rowToEntry(row) {
-  return {
-    key: row.key,
-    value: safeParseJson(row.value),
-    metadata: parseMetadataOrDefault(row.metadata),
-    createdAt: new Date(row.created_at),
-    accessedAt: new Date(row.accessed_at)
-  };
-}
-function sanitizeFtsQuery(query) {
-  return query.replace(/[*:^"(){}[\]]/g, " ").replace(/\bAND\b/gi, " ").replace(/\bOR\b/gi, " ").replace(/\bNOT\b/gi, " ").replace(/\bNEAR\b/gi, " ").replace(/\s+/g, " ").trim();
-}
-function cleanupExpiredEntries(rows, database, autoExpire, logger13) {
-  const now = getTimeProvider().now();
-  const entries = [];
-  const expiredKeys = [];
-  for (const row of rows) {
-    if (autoExpire && row.expires_at !== null && row.expires_at < now) {
-      expiredKeys.push(row.key);
-      continue;
-    }
-    entries.push(rowToEntry(row));
-  }
-  if (expiredKeys.length > 0) {
-    const deleteStmt = database.prepare(
-      `DELETE FROM memories WHERE key IN (${expiredKeys.map(() => "?").join(",")})`
-    );
-    deleteStmt.run(...expiredKeys);
-    logger13.debug("Auto-expired memories", { count: expiredKeys.length });
-  }
-  return { entries, expiredCount: expiredKeys.length };
-}
-function countMemories(database) {
-  try {
-    const stmt = database.prepare("SELECT COUNT(*) as count FROM memories");
-    const row = stmt.get();
-    return ok(row?.count ?? 0);
-  } catch (error) {
-    const causeError = error instanceof Error ? error : new Error(String(error));
-    return err(new MemoryError("Failed to count memories", { cause: causeError }));
-  }
-}
-function expireAllEntries(database, logger13) {
-  try {
-    const stmt = database.prepare(
-      "DELETE FROM memories WHERE expires_at IS NOT NULL AND expires_at < ?"
-    );
-    const result = stmt.run(getTimeProvider().now());
-    logger13.info("Expired memories", { count: result.changes });
-    return ok(result.changes);
-  } catch (error) {
-    const causeError = error instanceof Error ? error : new Error(String(error));
-    return err(new MemoryError("Failed to expire memories", { cause: causeError }));
-  }
-}
-function pruneOldEntries(database, olderThan, logger13) {
-  try {
-    const stmt = database.prepare("DELETE FROM memories WHERE created_at < ?");
-    const result = stmt.run(olderThan.getTime());
-    logger13.info("Pruned old memories", {
-      olderThan: olderThan.toISOString(),
-      count: result.changes
-    });
-    return ok(result.changes);
-  } catch (error) {
-    const causeError = error instanceof Error ? error : new Error(String(error));
-    return err(
-      new MemoryError("Failed to prune memories", {
-        cause: causeError,
-        context: { olderThan: olderThan.toISOString() }
-      })
-    );
-  }
-}
-
-// src/context/memory-backend.ts
-var HybridMemoryBackend = class {
-  dbPath;
-  logger;
-  autoExpire;
-  markdown;
-  db = null;
-  initialized = false;
-  initPromise;
-  constructor(config) {
-    const validation = HybridMemoryConfigSchema.safeParse(config);
-    if (!validation.success) {
-      throw new ValidationError(
-        `Invalid HybridMemoryBackend config: ${formatZodError(validation.error)}`,
-        {
-          context: { config, validationErrors: validation.error.issues }
-        }
-      );
-    }
-    this.dbPath = config.dbPath;
-    this.logger = config.logger ?? createLogger({ component: "HybridMemoryBackend" });
-    this.autoExpire = config.autoExpire ?? true;
-    this.markdown = new MemoryMarkdownHelper(config.markdownDir, this.logger);
-  }
-  initializeWithDatabase(database) {
-    this.db = database;
-    this.createTables();
-    this.markdown.ensureDir();
-    this.initialized = true;
-    this.logger.info("HybridMemoryBackend initialized", { dbPath: this.dbPath });
-  }
-  async initialize() {
-    if (this.initialized) return ok(void 0);
-    this.initPromise ??= this.doInitialize().finally(() => {
-      this.initPromise = void 0;
-    });
-    return this.initPromise;
-  }
-  async doInitialize() {
-    try {
-      const betterSqlite3Module = await import("better-sqlite3").catch((cause) => {
-        this.logger.debug("better-sqlite3 import failed", { error: String(cause) });
-        return null;
-      });
-      if (betterSqlite3Module === null) {
-        return err(
-          new MemoryError("better-sqlite3 not installed. Install: npm install better-sqlite3", {
-            context: { dbPath: this.dbPath }
-          })
-        );
-      }
-      const Database = betterSqlite3Module.default;
-      this.db = new Database(this.dbPath);
-      this.createTables();
-      this.markdown.ensureDir();
-      this.initialized = true;
-      this.logger.info("HybridMemoryBackend initialized", { dbPath: this.dbPath });
-      return ok(void 0);
-    } catch (error) {
-      const causeError = error instanceof Error ? error : new Error(String(error));
-      this.logger.error("Failed to initialize HybridMemoryBackend", causeError);
-      return err(
-        new MemoryError("Failed to initialize memory backend", {
-          cause: causeError,
-          context: { dbPath: this.dbPath }
-        })
-      );
-    }
-  }
-  createTables() {
-    const database = this.getDatabase();
-    database.exec(`
-      CREATE TABLE IF NOT EXISTS memories (
-        key TEXT PRIMARY KEY, value TEXT NOT NULL, metadata TEXT NOT NULL,
-        created_at INTEGER NOT NULL, accessed_at INTEGER NOT NULL, expires_at INTEGER
-      )
-    `);
-    database.exec(`
-      CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
-        key, value, tags, content='memories', content_rowid='rowid'
-      )
-    `);
-    database.exec(`
-      CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
-        INSERT INTO memories_fts(rowid, key, value, tags)
-        SELECT rowid, NEW.key, NEW.value, json_extract(NEW.metadata, '$.tags') FROM memories WHERE key = NEW.key;
-      END
-    `);
-    database.exec(`
-      CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
-        INSERT INTO memories_fts(memories_fts, rowid, key, value, tags)
-        VALUES('delete', OLD.rowid, OLD.key, OLD.value, json_extract(OLD.metadata, '$.tags'));
-      END
-    `);
-    database.exec(`
-      CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
-        INSERT INTO memories_fts(memories_fts, rowid, key, value, tags)
-        VALUES('delete', OLD.rowid, OLD.key, OLD.value, json_extract(OLD.metadata, '$.tags'));
-        INSERT INTO memories_fts(rowid, key, value, tags)
-        SELECT rowid, NEW.key, NEW.value, json_extract(NEW.metadata, '$.tags') FROM memories WHERE key = NEW.key;
-      END
-    `);
-    database.exec(
-      `CREATE INDEX IF NOT EXISTS idx_memories_expires_at ON memories(expires_at) WHERE expires_at IS NOT NULL`
-    );
-    database.exec(`CREATE INDEX IF NOT EXISTS idx_memories_created_at ON memories(created_at)`);
-    this.logger.debug("Database tables created");
-  }
-  getDatabase() {
-    if (this.db === null) throw new MemoryError("Database not initialized");
-    return this.db;
-  }
-  ensureInitialized() {
-    if (!this.initialized || this.db === null) {
-      throw new MemoryError("HybridMemoryBackend not initialized. Call initialize() first.");
-    }
-  }
-  async store(key, value, metadata) {
-    try {
-      this.ensureInitialized();
-      const keyValidation = z14.string().min(1).safeParse(key);
-      if (!keyValidation.success)
-        return err(new MemoryError("Invalid key: must be non-empty string", { context: { key } }));
-      const metadataValidation = MemoryMetadataSchema.safeParse(metadata);
-      if (!metadataValidation.success)
-        return err(
-          new MemoryError("Invalid metadata", {
-            context: { metadata, errors: metadataValidation.error.issues }
-          })
-        );
-      const now = getTimeProvider().now();
-      const expiresAt = metadata.ttl !== void 0 ? now + metadata.ttl : null;
-      const database = this.getDatabase();
-      const stmt = database.prepare(
-        `INSERT OR REPLACE INTO memories (key, value, metadata, created_at, accessed_at, expires_at) VALUES (?, ?, ?, ?, ?, ?)`
-      );
-      stmt.run(key, JSON.stringify(value), JSON.stringify(metadata), now, now, expiresAt);
-      this.logger.debug("Stored memory", { key, importance: metadata.importance });
-      if (metadata.importance === MemoryImportance.HIGH)
-        await this.markdown.write(key, value, metadata, new Date(now));
-      return ok(void 0);
-    } catch (error) {
-      const causeError = error instanceof Error ? error : new Error(String(error));
-      this.logger.error("Failed to store memory", causeError, { key });
-      return err(
-        new MemoryError("Failed to store memory", { cause: causeError, context: { key } })
-      );
-    }
-  }
-  retrieve(key) {
-    try {
-      this.ensureInitialized();
-      const database = this.getDatabase();
-      const stmt = database.prepare(
-        `SELECT key, value, metadata, created_at, accessed_at, expires_at FROM memories WHERE key = ?`
-      );
-      const row = stmt.get(key);
-      if (row === void 0) return Promise.resolve(ok(null));
-      if (this.autoExpire && row.expires_at !== null && row.expires_at < getTimeProvider().now()) {
-        database.prepare("DELETE FROM memories WHERE key = ?").run(key);
-        this.logger.debug("Auto-expired memory", { key });
-        return Promise.resolve(ok(null));
-      }
-      database.prepare("UPDATE memories SET accessed_at = ? WHERE key = ?").run(getTimeProvider().now(), key);
-      return Promise.resolve(ok(JSON.parse(row.value)));
-    } catch (error) {
-      const causeError = error instanceof Error ? error : new Error(String(error));
-      this.logger.error("Failed to retrieve memory", causeError, { key });
-      return Promise.resolve(
-        err(new MemoryError("Failed to retrieve memory", { cause: causeError, context: { key } }))
-      );
-    }
-  }
-  search(query, limit) {
-    try {
-      this.ensureInitialized();
-      if (limit <= 0 || limit > 1e3)
-        return Promise.resolve(
-          err(new MemoryError("Invalid limit: must be between 1 and 1000", { context: { limit } }))
-        );
-      const sanitizedQuery = sanitizeFtsQuery(query);
-      if (sanitizedQuery.length === 0) return Promise.resolve(ok([]));
-      const database = this.getDatabase();
-      const stmt = database.prepare(`
-        SELECT m.key, m.value, m.metadata, m.created_at, m.accessed_at, m.expires_at
-        FROM memories m INNER JOIN memories_fts fts ON m.rowid = fts.rowid
-        WHERE memories_fts MATCH ? ORDER BY rank LIMIT ?
-      `);
-      const rows = stmt.all(sanitizedQuery, limit);
-      const { entries } = cleanupExpiredEntries(rows, database, this.autoExpire, this.logger);
-      return Promise.resolve(ok(entries));
-    } catch (error) {
-      const causeError = error instanceof Error ? error : new Error(String(error));
-      this.logger.error("Failed to search memories", causeError, { query });
-      return Promise.resolve(
-        err(
-          new MemoryError("Failed to search memories", {
-            cause: causeError,
-            context: { query, limit }
-          })
-        )
-      );
-    }
-  }
-  prune(olderThan) {
-    this.ensureInitialized();
-    return Promise.resolve(pruneOldEntries(this.getDatabase(), olderThan, this.logger));
-  }
-  expireAll() {
-    this.ensureInitialized();
-    return Promise.resolve(expireAllEntries(this.getDatabase(), this.logger));
-  }
-  delete(key) {
-    try {
-      this.ensureInitialized();
-      const result = this.getDatabase().prepare("DELETE FROM memories WHERE key = ?").run(key);
-      if (result.changes > 0) {
-        this.markdown.delete(key);
-        this.logger.debug("Deleted memory", { key });
-        return Promise.resolve(ok(true));
-      }
-      return Promise.resolve(ok(false));
-    } catch (error) {
-      const causeError = error instanceof Error ? error : new Error(String(error));
-      this.logger.error("Failed to delete memory", causeError, { key });
-      return Promise.resolve(
-        err(new MemoryError("Failed to delete memory", { cause: causeError, context: { key } }))
-      );
-    }
-  }
-  getAll(limit = 100) {
-    try {
-      this.ensureInitialized();
-      const database = this.getDatabase();
-      const rows = database.prepare(
-        `SELECT key, value, metadata, created_at, accessed_at, expires_at FROM memories ORDER BY accessed_at DESC LIMIT ?`
-      ).all(limit);
-      const { entries } = cleanupExpiredEntries(rows, database, this.autoExpire, this.logger);
-      return Promise.resolve(ok(entries));
-    } catch (error) {
-      const causeError = error instanceof Error ? error : new Error(String(error));
-      this.logger.error("Failed to get all memories", causeError);
-      return Promise.resolve(
-        err(new MemoryError("Failed to get all memories", { cause: causeError }))
-      );
-    }
-  }
-  count() {
-    this.ensureInitialized();
-    return Promise.resolve(countMemories(this.getDatabase()));
-  }
-  close() {
-    if (this.db !== null) {
-      this.db.close();
-      this.db = null;
-      this.initialized = false;
-      this.logger.info("HybridMemoryBackend closed");
-    }
-  }
-};
-
 // src/context/graph-memory-types.ts
-import { z as z15 } from "zod";
+import { z as z13 } from "zod";
 var RelationType = {
   /** General association between memories */
   RELATED_TO: "related_to",
@@ -9108,7 +8702,7 @@ var RelationType = {
   /** Causal relationship */
   CAUSES: "causes"
 };
-var RelationTypeSchema = z15.enum([
+var RelationTypeSchema = z13.enum([
   "related_to",
   "derived_from",
   "contradicts",
@@ -9118,28 +8712,28 @@ var RelationTypeSchema = z15.enum([
   "precedes",
   "causes"
 ]);
-var GraphEdgeSchema = z15.object({
-  from: z15.string().min(1),
-  to: z15.string().min(1),
+var GraphEdgeSchema = z13.object({
+  from: z13.string().min(1),
+  to: z13.string().min(1),
   type: RelationTypeSchema,
-  weight: z15.number().min(0).max(1),
-  createdAt: z15.date(),
-  metadata: z15.record(z15.string(), z15.unknown()).optional()
+  weight: z13.number().min(0).max(1),
+  createdAt: z13.date(),
+  metadata: z13.record(z13.string(), z13.unknown()).optional()
 });
-var TraversalOptionsSchema = z15.object({
-  maxDepth: z15.number().int().positive().optional(),
-  relationTypes: z15.array(RelationTypeSchema).optional(),
-  minWeight: z15.number().min(0).max(1).optional(),
-  limit: z15.number().int().positive().optional(),
-  includeStart: z15.boolean().optional(),
-  direction: z15.enum(["outgoing", "incoming", "both"]).optional()
+var TraversalOptionsSchema = z13.object({
+  maxDepth: z13.number().int().positive().optional(),
+  relationTypes: z13.array(RelationTypeSchema).optional(),
+  minWeight: z13.number().min(0).max(1).optional(),
+  limit: z13.number().int().positive().optional(),
+  includeStart: z13.boolean().optional(),
+  direction: z13.enum(["outgoing", "incoming", "both"]).optional()
 });
-var GraphMemoryConfigSchema = z15.object({
-  dbPath: z15.string().min(1),
-  markdownDir: z15.string().min(1),
-  defaultTraversalDepth: z15.number().int().positive().optional(),
-  maxTraversalDepth: z15.number().int().positive().optional(),
-  autoExpire: z15.boolean().optional()
+var GraphMemoryConfigSchema = z13.object({
+  dbPath: z13.string().min(1),
+  markdownDir: z13.string().min(1),
+  defaultTraversalDepth: z13.number().int().positive().optional(),
+  maxTraversalDepth: z13.number().int().positive().optional(),
+  autoExpire: z13.boolean().optional()
 });
 var DEFAULT_GRAPH_MEMORY_CONFIG = {
   defaultTraversalDepth: 2,
@@ -9147,50 +8741,6 @@ var DEFAULT_GRAPH_MEMORY_CONFIG = {
   autoExpire: true
 };
 
-// src/utils/memory-db-utils.ts
-var logger6 = createLogger({ component: "MemoryDbUtils" });
-function safeJsonParse(json, fallback, context) {
-  try {
-    return JSON.parse(json);
-  } catch {
-    logger6.warn("Corrupt JSON in memory database row", { context });
-    return fallback;
-  }
-}
-function memoryRowToEntry(row) {
-  return {
-    key: row.key,
-    value: safeJsonParse(row.value, row.value, `value for key="${row.key}"`),
-    metadata: safeJsonParse(
-      row.metadata,
-      { importance: MemoryImportance.MEDIUM },
-      `metadata for key="${row.key}"`
-    ),
-    createdAt: new Date(row.created_at),
-    accessedAt: new Date(row.accessed_at)
-  };
-}
-function memoryExists(db, key) {
-  const stmt = db.prepare(
-    "SELECT COUNT(*) as count FROM memories WHERE key = ?"
-  );
-  const result = stmt.get(key);
-  return result !== void 0 && result.count > 0;
-}
-function getMemoryEntry(db, key) {
-  const stmt = db.prepare("SELECT * FROM memories WHERE key = ?");
-  const row = stmt.get(key);
-  return row !== void 0 ? memoryRowToEntry(row) : void 0;
-}
-function getMemoryRow(db, key) {
-  const stmt = db.prepare("SELECT * FROM memories WHERE key = ?");
-  return stmt.get(key);
-}
-function getAllMemoryRows(db, limit) {
-  const stmt = db.prepare("SELECT * FROM memories ORDER BY accessed_at DESC LIMIT ?");
-  return stmt.all(limit);
-}
-
 // src/context/graph-memory-helpers.ts
 var CREATE_EDGES_TABLE_SQL = `
   CREATE TABLE IF NOT EXISTS graph_edges (
@@ -9279,11 +8829,11 @@ function getNextKeys(currentKey, edges, opts) {
   }
   return next;
 }
-function buildTraversalResult(entry, depth, path5, edge) {
+function buildTraversalResult(entry, depth, path4, edge) {
   if (edge !== void 0) {
-    return { entry, depth, path: path5, edge };
+    return { entry, depth, path: path4, edge };
   }
-  return { entry, depth, path: path5 };
+  return { entry, depth, path: path4 };
 }
 function bfsTraverse(config) {
   const { db, startKey, opts } = config;
@@ -9339,7 +8889,7 @@ function findShortestPath(db, from, to, opts) {
 }
 
 // src/context/graph-memory.ts
-var logger7 = createLogger({ component: "GraphMemoryBackend" });
+var logger6 = createLogger({ component: "GraphMemoryBackend" });
 var GraphMemoryBackend = class {
   config;
   log;
@@ -9354,7 +8904,7 @@ var GraphMemoryBackend = class {
       throw new MemoryError(`Invalid GraphMemoryBackend config: ${msg}`);
     }
     this.config = { ...DEFAULT_GRAPH_MEMORY_CONFIG, ...config };
-    this.log = logger7;
+    this.log = logger6;
     this.base = new HybridMemoryBackend({ dbPath: config.dbPath, markdownDir: config.markdownDir });
   }
   async initialize() {
@@ -9369,7 +8919,7 @@ var GraphMemoryBackend = class {
     if (!baseInit.ok) return baseInit;
     try {
       const mod = await import("better-sqlite3").catch((cause) => {
-        logger7.debug("better-sqlite3 import failed", { error: String(cause) });
+        logger6.debug("better-sqlite3 import failed", { error: String(cause) });
         return null;
       });
       if (mod === null)
@@ -9500,8 +9050,8 @@ var GraphMemoryBackend = class {
       if (!memoryExists(db, to))
         return Promise.resolve(err(new MemoryError(`To key not found: ${to}`)));
       const resolved = resolveTraversalOptions(opts);
-      const path5 = findShortestPath(db, from, to, resolved);
-      return Promise.resolve(ok(path5));
+      const path4 = findShortestPath(db, from, to, resolved);
+      return Promise.resolve(ok(path4));
     } catch (error) {
       const cause = error instanceof Error ? error : new Error(String(error));
       return Promise.resolve(err(new MemoryError("Path finding failed", { cause })));
@@ -9541,11 +9091,11 @@ var GraphMemoryBackend = class {
 };
 
 // src/context/agentic-memory-types.ts
-import { z as z17 } from "zod";
+import { z as z15 } from "zod";
 
 // src/context/agentic-memory-primitives.ts
-import { z as z16 } from "zod";
-var EntityTypeSchema = z16.enum([
+import { z as z14 } from "zod";
+var EntityTypeSchema = z14.enum([
   "person",
   "organization",
   "concept",
@@ -9553,60 +9103,60 @@ var EntityTypeSchema = z16.enum([
   "file",
   "unknown"
 ]);
-var EntityReferenceSchema = z16.object({
-  name: z16.string().min(1).max(200),
+var EntityReferenceSchema = z14.object({
+  name: z14.string().min(1).max(200),
   type: EntityTypeSchema
 });
-var EvolutionTypeSchema = z16.enum([
+var EvolutionTypeSchema = z14.enum([
   "refinement",
   "contradiction",
   "extension",
   "supersession"
 ]);
-var EvolutionResultSchema = z16.object({
+var EvolutionResultSchema = z14.object({
   type: EvolutionTypeSchema,
-  affectedKey: z16.string().min(1),
-  confidence: z16.number().min(0).max(1),
-  description: z16.string().max(500)
+  affectedKey: z14.string().min(1),
+  confidence: z14.number().min(0).max(1),
+  description: z14.string().max(500)
 });
-var LinkSuggestionSchema = z16.object({
-  from: z16.string().min(1),
-  to: z16.string().min(1),
+var LinkSuggestionSchema = z14.object({
+  from: z14.string().min(1),
+  to: z14.string().min(1),
   relationType: RelationTypeSchema,
-  reason: z16.string().max(200),
-  confidence: z16.number().min(0).max(1)
+  reason: z14.string().max(200),
+  confidence: z14.number().min(0).max(1)
 });
 
 // src/context/agentic-memory-types.ts
-var MemoryAttributesSchema = z17.object({
-  keywords: z17.array(z17.string().max(100)).max(50),
-  semanticTags: z17.array(z17.string().max(50)).max(20),
-  contextDescription: z17.string().max(500),
-  entities: z17.array(EntityReferenceSchema).max(30),
-  attributesUpdatedAt: z17.date()
+var MemoryAttributesSchema = z15.object({
+  keywords: z15.array(z15.string().max(100)).max(50),
+  semanticTags: z15.array(z15.string().max(50)).max(20),
+  contextDescription: z15.string().max(500),
+  entities: z15.array(EntityReferenceSchema).max(30),
+  attributesUpdatedAt: z15.date()
 });
-var ExtractionConfigSchema = z17.object({
-  maxKeywords: z17.number().int().positive().max(50),
-  maxSemanticTags: z17.number().int().positive().max(20),
-  maxContextLength: z17.number().int().positive().max(500),
-  maxEntities: z17.number().int().positive().max(30)
+var ExtractionConfigSchema = z15.object({
+  maxKeywords: z15.number().int().positive().max(50),
+  maxSemanticTags: z15.number().int().positive().max(20),
+  maxContextLength: z15.number().int().positive().max(500),
+  maxEntities: z15.number().int().positive().max(30)
 });
-var LinkingConfigSchema = z17.object({
-  suggestionThreshold: z17.number().min(0).max(1),
-  maxSuggestions: z17.number().int().positive().max(20),
-  allowedTypes: z17.array(RelationTypeSchema)
+var LinkingConfigSchema = z15.object({
+  suggestionThreshold: z15.number().min(0).max(1),
+  maxSuggestions: z15.number().int().positive().max(20),
+  allowedTypes: z15.array(RelationTypeSchema)
 });
-var LinkingOptionsSchema = z17.object({
-  threshold: z17.number().min(0).max(1).optional(),
-  maxLinks: z17.number().int().positive().optional(),
-  bidirectional: z17.boolean().optional()
+var LinkingOptionsSchema = z15.object({
+  threshold: z15.number().min(0).max(1).optional(),
+  maxLinks: z15.number().int().positive().optional(),
+  bidirectional: z15.boolean().optional()
 });
-var AgenticMemoryConfigSchema = z17.object({
-  dbPath: z17.string().min(1),
-  markdownDir: z17.string().min(1),
+var AgenticMemoryConfigSchema = z15.object({
+  dbPath: z15.string().min(1),
+  markdownDir: z15.string().min(1),
   extraction: ExtractionConfigSchema.partial().optional(),
   linking: LinkingConfigSchema.partial().optional(),
-  autoExpire: z17.boolean().optional()
+  autoExpire: z15.boolean().optional()
 });
 var DEFAULT_EXTRACTION_CONFIG = {
   maxKeywords: 10,
@@ -9859,7 +9409,7 @@ function mergeLinkingConfig(partial) {
 }
 
 // src/context/agentic-memory-db-helpers.ts
-var logger8 = createLogger({ component: "AgenticMemoryDbHelpers" });
+var logger7 = createLogger({ component: "AgenticMemoryDbHelpers" });
 function safeExtractAttributes(amem) {
   if (!Array.isArray(amem.keywords) || amem.attributesUpdatedAt === void 0) return null;
   const updatedAt = amem.attributesUpdatedAt;
@@ -9884,7 +9434,7 @@ function memoryRowToAgenticEntry(row, extractionConfig) {
   try {
     parsedMeta = JSON.parse(row.metadata);
   } catch {
-    logger8.warn("Corrupt metadata JSON in memory row, using fallback extraction", {
+    logger7.warn("Corrupt metadata JSON in memory row, using fallback extraction", {
       key: row.key
     });
   }
@@ -9917,7 +9467,7 @@ function getAttributesFromRow(row, extractionConfig) {
   try {
     meta = JSON.parse(row.metadata);
   } catch {
-    logger8.warn("Corrupt metadata JSON in getAttributesFromRow, using value extraction", {
+    logger7.warn("Corrupt metadata JSON in getAttributesFromRow, using value extraction", {
       key: row.key
     });
   }
@@ -9929,7 +9479,7 @@ function getAttributesFromRow(row, extractionConfig) {
   try {
     parsedValue = JSON.parse(row.value);
   } catch {
-    logger8.warn("Corrupt value JSON in getAttributesFromRow, using raw string", {
+    logger7.warn("Corrupt value JSON in getAttributesFromRow, using raw string", {
       key: row.key
     });
   }
@@ -10019,7 +9569,7 @@ function buildAgenticEntry(key, value, metadata, attributes, createdAt) {
 }
 
 // src/context/agentic-memory.ts
-var logger9 = createLogger({ component: "AgenticMemoryBackend" });
+var logger8 = createLogger({ component: "AgenticMemoryBackend" });
 var AgenticMemoryBackend = class {
   config;
   log;
@@ -10037,7 +9587,7 @@ var AgenticMemoryBackend = class {
       throw new MemoryError(`Invalid AgenticMemoryBackend config: ${msg}`);
     }
     this.config = config;
-    this.log = logger9;
+    this.log = logger8;
     this.extractionConfig = mergeExtractionConfig(config.extraction);
     this.linkingConfig = mergeLinkingConfig(config.linking);
     this.base = new HybridMemoryBackend({
@@ -10284,477 +9834,80 @@ var AgenticMemoryBackend = class {
   }
 };
 
-// src/context/adaptive-memory-types.ts
-import { z as z18 } from "zod";
-var ScoringWeightsBaseSchema = z18.object({
-  recency: z18.number().min(0).max(1),
-  importance: z18.number().min(0).max(1),
-  relevance: z18.number().min(0).max(1)
-});
-var ScoringWeightsSchema = ScoringWeightsBaseSchema.refine(
-  (w) => Math.abs(w.recency + w.importance + w.relevance - 1) < 1e-3,
-  { message: "Weights must sum to 1.0" }
-);
-var PartialScoringWeightsSchema = ScoringWeightsBaseSchema.partial();
-var ImportanceWeightsSchema = z18.object({
-  low: z18.number().min(0).max(1),
-  medium: z18.number().min(0).max(1),
-  high: z18.number().min(0).max(1)
-});
-var DecayConfigSchema = z18.object({
-  halfLifeMs: z18.number().positive(),
-  minScore: z18.number().min(0).max(1)
-});
-var PriorityScoreSchema = z18.object({
-  score: z18.number().min(0),
-  components: z18.object({
-    recency: z18.number().min(0).max(1),
-    importance: z18.number().min(0).max(1),
-    relevance: z18.number().min(0).max(1)
-  })
-});
-var ScoredMemoryEntrySchema = z18.object({
-  entry: z18.object({
-    key: z18.string(),
-    value: z18.unknown(),
-    metadata: z18.object({
-      importance: z18.enum(["low", "medium", "high"]),
-      tags: z18.array(z18.string()).optional(),
-      ttl: z18.number().optional()
-    }),
-    createdAt: z18.date(),
-    accessedAt: z18.date()
-  }),
-  priority: PriorityScoreSchema
-});
-var PriorityRetrievalOptionsSchema = z18.object({
-  query: z18.string().optional(),
-  limit: z18.number().int().positive().optional(),
-  minScore: z18.number().min(0).optional(),
-  weights: PartialScoringWeightsSchema.optional(),
-  importanceFilter: z18.array(z18.enum(["low", "medium", "high"])).optional(),
-  tagFilter: z18.array(z18.string()).optional()
-});
-var ScoringConfigSchema = z18.object({
-  weights: ScoringWeightsSchema,
-  importanceWeights: ImportanceWeightsSchema,
-  decay: DecayConfigSchema
-});
-var AdaptiveMemoryConfigSchema = z18.object({
-  dbPath: z18.string().min(1),
-  markdownDir: z18.string().min(1),
-  scoring: ScoringConfigSchema.partial().optional(),
-  autoExpire: z18.boolean().optional()
-});
-var DEFAULT_SCORING_WEIGHTS = {
-  recency: 0.4,
-  importance: 0.3,
-  relevance: 0.3
-};
-var DEFAULT_IMPORTANCE_WEIGHTS = {
-  low: 0.25,
-  medium: 0.5,
-  high: 1
-};
-var DEFAULT_DECAY_CONFIG = {
-  halfLifeMs: 24 * 60 * 60 * 1e3,
-  // 24 hours
-  minScore: 0.1
-};
-var DEFAULT_SCORING_CONFIG = {
-  weights: DEFAULT_SCORING_WEIGHTS,
-  importanceWeights: DEFAULT_IMPORTANCE_WEIGHTS,
-  decay: DEFAULT_DECAY_CONFIG
-};
-
-// src/utils/similarity-utils.ts
-function calculateTokenOverlap(queryTokens, targetTokens) {
-  if (queryTokens.length === 0) return 0;
-  if (targetTokens.length === 0) return 0;
-  const targetSet = new Set(targetTokens);
-  let matches = 0;
-  for (const token of queryTokens) {
-    if (targetSet.has(token)) matches++;
-  }
-  return matches / queryTokens.length;
-}
-function calculateSetOverlapCount(sourceSet, targetSet) {
-  let count = 0;
-  for (const item of sourceSet) {
-    if (targetSet.has(item)) count++;
-  }
-  return count;
-}
-function calculateJaccardSimilarity(set1, set2) {
-  if (set1.size === 0 && set2.size === 0) return 1;
-  if (set1.size === 0 || set2.size === 0) return 0;
-  const intersection = calculateSetOverlapCount(set1, set2);
-  const union = set1.size + set2.size - intersection;
-  return union > 0 ? intersection / union : 0;
-}
-function calculateTextJaccardSimilarity(text1, text2) {
-  const words1 = new Set(
-    text1.toLowerCase().split(/\s+/).filter((w) => w.length > 0)
-  );
-  const words2 = new Set(
-    text2.toLowerCase().split(/\s+/).filter((w) => w.length > 0)
-  );
-  return calculateJaccardSimilarity(words1, words2);
-}
-
-// src/context/adaptive-memory-helpers.ts
-function calculateRecencyScore(accessedAt, now, halfLifeMs, minScore) {
-  const elapsedMs = now.getTime() - accessedAt.getTime();
-  if (elapsedMs <= 0) return 1;
-  const lambda = Math.LN2 / halfLifeMs;
-  const decayedScore = Math.exp(-lambda * elapsedMs);
-  return Math.max(minScore, decayedScore);
-}
-function calculateImportanceScore(importance, config) {
-  switch (importance) {
-    case MemoryImportance.HIGH:
-      return config.importanceWeights.high;
-    case MemoryImportance.MEDIUM:
-      return config.importanceWeights.medium;
-    case MemoryImportance.LOW:
-      return config.importanceWeights.low;
-    default:
-      return config.importanceWeights.medium;
-  }
-}
-function calculateRelevanceScore(query, value) {
-  if (query === void 0 || query.trim() === "") return 1;
-  const queryTokens = tokenize2(query);
-  const valueTokens = tokenize2(value);
-  if (queryTokens.length === 0 || valueTokens.length === 0) return 0.5;
-  return calculateTokenOverlap(queryTokens, valueTokens);
-}
-function tokenize2(text) {
-  return tokenize(text, 1);
-}
-function calculatePriorityScore(input) {
-  const { entry, query, now, config, weightOverrides } = input;
-  const recency = calculateRecencyScore(
-    entry.accessedAt,
-    now,
-    config.decay.halfLifeMs,
-    config.decay.minScore
-  );
-  const importance = calculateImportanceScore(entry.metadata.importance, config);
-  const relevance = calculateRelevanceScore(query, stringifyValue2(entry.value));
-  const components = { recency, importance, relevance };
-  const weights = resolveWeights(config.weights, weightOverrides);
-  const score = recency * weights.recency + importance * weights.importance + relevance * weights.relevance;
-  return { score, components };
-}
-function stringifyValue2(value) {
-  return stringifyValue(value);
-}
-function resolveWeights(base, overrides) {
-  if (overrides === void 0) return base;
-  const merged = {
-    recency: overrides.recency ?? base.recency,
-    importance: overrides.importance ?? base.importance,
-    relevance: overrides.relevance ?? base.relevance
-  };
-  const sum = merged.recency + merged.importance + merged.relevance;
-  if (sum === 0) return base;
-  if (Math.abs(sum - 1) > 1e-3) {
-    return {
-      recency: merged.recency / sum,
-      importance: merged.importance / sum,
-      relevance: merged.relevance / sum
-    };
-  }
-  return merged;
-}
-function filterScoredEntries(entries, config) {
-  return entries.filter((e) => {
-    if (config.minScore !== void 0 && e.priority.score < config.minScore) {
-      return false;
-    }
-    if (config.importanceFilter !== void 0 && config.importanceFilter.length > 0) {
-      if (!config.importanceFilter.includes(e.entry.metadata.importance)) {
-        return false;
-      }
-    }
-    if (config.tagFilter !== void 0 && config.tagFilter.length > 0) {
-      const entryTags = e.entry.metadata.tags ?? [];
-      const hasMatch = config.tagFilter.some((t) => entryTags.includes(t));
-      if (!hasMatch) return false;
-    }
-    return true;
-  });
-}
-function touchMemory(db, key) {
-  const stmt = db.prepare("UPDATE memories SET accessed_at = ? WHERE key = ?");
-  const result = stmt.run(getTimeProvider().now(), key);
-  return result.changes > 0;
-}
-function scoreAndSortEntries(rows, opts, config) {
-  const now = new Date(getTimeProvider().now());
-  const scored = rows.map((row) => {
-    const entry = memoryRowToEntry(row);
-    const priority = calculatePriorityScore({
-      entry,
-      now,
-      config,
-      ...opts?.query !== void 0 && { query: opts.query },
-      ...opts?.weights !== void 0 && { weightOverrides: opts.weights }
-    });
-    return { entry, priority };
-  });
-  const filterConfig = {
-    ...opts?.minScore !== void 0 && { minScore: opts.minScore },
-    ...opts?.importanceFilter !== void 0 && { importanceFilter: opts.importanceFilter },
-    ...opts?.tagFilter !== void 0 && { tagFilter: opts.tagFilter }
-  };
-  const filtered = filterScoredEntries(scored, filterConfig);
-  filtered.sort((a, b) => b.priority.score - a.priority.score);
-  const limit = opts?.limit ?? 100;
-  return filtered.slice(0, limit);
-}
-function mergeScoringConfig(partial) {
-  if (partial === void 0) return DEFAULT_SCORING_CONFIG;
-  return {
-    weights: partial.weights ?? DEFAULT_SCORING_CONFIG.weights,
-    importanceWeights: partial.importanceWeights ?? DEFAULT_SCORING_CONFIG.importanceWeights,
-    decay: partial.decay ?? DEFAULT_SCORING_CONFIG.decay
-  };
-}
-
-// src/context/adaptive-memory.ts
-var logger10 = createLogger({ component: "AdaptiveMemoryBackend" });
-var AdaptiveMemoryBackend = class {
-  config;
-  log;
-  base;
-  scoringConfig;
-  db = null;
-  initialized = false;
-  initPromise;
-  constructor(config) {
-    const validation = AdaptiveMemoryConfigSchema.safeParse(config);
-    if (!validation.success) {
-      const msg = validation.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
-      throw new MemoryError(`Invalid AdaptiveMemoryBackend config: ${msg}`);
-    }
-    this.config = config;
-    this.log = logger10;
-    this.scoringConfig = mergeScoringConfig(config.scoring);
-    this.base = new HybridMemoryBackend({ dbPath: config.dbPath, markdownDir: config.markdownDir });
-  }
-  async initialize() {
-    if (this.initialized) return ok(void 0);
-    this.initPromise ??= this.doInitialize().finally(() => {
-      this.initPromise = void 0;
-    });
-    return this.initPromise;
-  }
-  async doInitialize() {
-    const baseInit = await this.base.initialize();
-    if (!baseInit.ok) return baseInit;
-    try {
-      const mod = await import("better-sqlite3").catch((cause) => {
-        this.log.debug("better-sqlite3 import failed", { error: String(cause) });
-        return null;
-      });
-      if (mod === null)
-        return err(
-          new MemoryError("better-sqlite3 not installed. Install: npm install better-sqlite3")
-        );
-      const Database = mod.default;
-      this.db = new Database(this.config.dbPath);
-      this.initialized = true;
-      this.log.info("AdaptiveMemoryBackend initialized");
-      return ok(void 0);
-    } catch (error) {
-      const cause = error instanceof Error ? error : new Error(String(error));
-      return err(new MemoryError("Failed to initialize adaptive backend", { cause }));
-    }
-  }
-  initializeWithDatabase(database) {
-    this.base.initializeWithDatabase(database);
-    this.db = database;
-    this.initialized = true;
-    this.log.info("AdaptiveMemoryBackend initialized with database");
-  }
-  getDb() {
-    if (this.db === null) throw new MemoryError("Database not initialized");
-    return this.db;
-  }
-  ensureInit() {
-    if (!this.initialized) throw new MemoryError("AdaptiveMemoryBackend not initialized");
-  }
-  // =========================================================================
-  // IMemoryBackend Methods (delegated to base)
-  // =========================================================================
-  store(key, value, metadata) {
-    return this.base.store(key, value, metadata);
-  }
-  retrieve(key) {
-    return this.base.retrieve(key);
-  }
-  search(query, limit) {
-    return this.base.search(query, limit);
-  }
-  prune(olderThan) {
-    return this.base.prune(olderThan);
-  }
-  // =========================================================================
-  // IAdaptiveMemory Methods
-  // =========================================================================
-  retrieveByPriority(opts) {
-    try {
-      this.ensureInit();
-      const db = this.getDb();
-      const maxFetch = (opts?.limit ?? 100) * 2;
-      const rows = getAllMemoryRows(db, maxFetch);
-      const scored = scoreAndSortEntries(rows, opts, this.scoringConfig);
-      this.log.debug("Retrieved by priority", { count: scored.length, query: opts?.query });
-      return Promise.resolve(ok(scored));
-    } catch (error) {
-      const cause = error instanceof Error ? error : new Error(String(error));
-      return Promise.resolve(err(new MemoryError("Failed to retrieve by priority", { cause })));
-    }
-  }
-  getPriorityScore(key, query) {
-    try {
-      this.ensureInit();
-      const db = this.getDb();
-      if (!memoryExists(db, key)) {
-        return Promise.resolve(err(new MemoryError(`Key not found: ${key}`)));
-      }
-      const row = getMemoryRow(db, key);
-      if (row === void 0) {
-        return Promise.resolve(err(new MemoryError(`Key not found: ${key}`)));
-      }
-      const entry = memoryRowToEntry(row);
-      const priority = calculatePriorityScore({
-        entry,
-        now: new Date(getTimeProvider().now()),
-        config: this.scoringConfig,
-        ...query !== void 0 && { query }
-      });
-      return Promise.resolve(ok(priority));
-    } catch (error) {
-      const cause = error instanceof Error ? error : new Error(String(error));
-      return Promise.resolve(err(new MemoryError("Failed to get priority score", { cause })));
-    }
-  }
-  touch(key) {
-    try {
-      this.ensureInit();
-      const db = this.getDb();
-      if (!memoryExists(db, key)) {
-        return Promise.resolve(err(new MemoryError(`Key not found: ${key}`)));
-      }
-      const updated = touchMemory(db, key);
-      if (!updated) {
-        return Promise.resolve(err(new MemoryError(`Failed to touch: ${key}`)));
-      }
-      this.log.debug("Touched memory", { key });
-      return Promise.resolve(ok(void 0));
-    } catch (error) {
-      const cause = error instanceof Error ? error : new Error(String(error));
-      return Promise.resolve(err(new MemoryError("Failed to touch memory", { cause })));
-    }
-  }
-  getScoringConfig() {
-    return this.scoringConfig;
-  }
-  updateScoringConfig(config) {
-    this.scoringConfig = mergeScoringConfig({ ...this.scoringConfig, ...config });
-    this.log.info("Updated scoring config", { config: this.scoringConfig });
-  }
-  // =========================================================================
-  // Lifecycle
-  // =========================================================================
-  close() {
-    this.base.close();
-    if (this.db !== null) {
-      this.db.close();
-      this.db = null;
-    }
-    this.initialized = false;
-    this.log.info("AdaptiveMemoryBackend closed");
-  }
-};
-
 // src/context/belief-memory-persistence.ts
-import * as fs3 from "fs";
+import * as fs2 from "fs";
 import * as os2 from "os";
-import * as path3 from "path";
+import * as path2 from "path";
 
 // src/context/belief-persistence-types.ts
-import { z as z19 } from "zod";
-var BeliefSnapshotSchema = z19.object({
-  version: z19.number().int().min(1),
-  exportedAt: z19.string(),
-  beliefs: z19.array(
-    z19.object({
-      beliefId: z19.string(),
-      subject: z19.string(),
-      predicate: z19.string(),
-      object: z19.string(),
+import { z as z16 } from "zod";
+var BeliefSnapshotSchema = z16.object({
+  version: z16.number().int().min(1),
+  exportedAt: z16.string(),
+  beliefs: z16.array(
+    z16.object({
+      beliefId: z16.string(),
+      subject: z16.string(),
+      predicate: z16.string(),
+      object: z16.string(),
       confidence: BeliefConfidenceSchema,
       sourceType: BeliefSourceTypeSchema,
-      sourceRef: z19.string().optional(),
-      derivedFrom: z19.array(z19.string()).optional(),
-      version: z19.number(),
-      createdAt: z19.string(),
-      updatedAt: z19.string(),
-      superseded: z19.boolean(),
-      supersededBy: z19.string().optional(),
-      domain: z19.string().optional(),
-      metadata: z19.record(z19.string(), z19.unknown()).optional()
+      sourceRef: z16.string().optional(),
+      derivedFrom: z16.array(z16.string()).optional(),
+      version: z16.number(),
+      createdAt: z16.string(),
+      updatedAt: z16.string(),
+      superseded: z16.boolean(),
+      supersededBy: z16.string().optional(),
+      domain: z16.string().optional(),
+      metadata: z16.record(z16.string(), z16.unknown()).optional()
     })
   ),
-  updates: z19.array(
-    z19.object({
-      beliefId: z19.string(),
-      records: z19.array(
-        z19.object({
-          updateId: z19.string(),
-          beliefId: z19.string(),
+  updates: z16.array(
+    z16.object({
+      beliefId: z16.string(),
+      records: z16.array(
+        z16.object({
+          updateId: z16.string(),
+          beliefId: z16.string(),
           updateType: BeliefUpdateTypeSchema,
-          previousState: z19.record(z19.string(), z19.unknown()).optional(),
-          newState: z19.record(z19.string(), z19.unknown()),
-          reason: z19.string().max(1e4),
-          evidence: z19.string().max(1e4).optional(),
-          timestamp: z19.string(),
-          updatedBy: z19.string().optional()
+          previousState: z16.record(z16.string(), z16.unknown()).optional(),
+          newState: z16.record(z16.string(), z16.unknown()),
+          reason: z16.string().max(1e4),
+          evidence: z16.string().max(1e4).optional(),
+          timestamp: z16.string(),
+          updatedBy: z16.string().optional()
         })
       )
     })
   ),
-  counterfactuals: z19.array(
-    z19.object({
-      counterfactualId: z19.string(),
-      hypothesis: z19.string().max(1e4),
-      affectedBeliefs: z19.array(z19.string()),
-      predictedOutcomes: z19.array(z19.string()),
-      actualOutcomes: z19.array(z19.string()).optional(),
-      validated: z19.boolean(),
-      createdAt: z19.string(),
-      taskContext: z19.string().optional()
+  counterfactuals: z16.array(
+    z16.object({
+      counterfactualId: z16.string(),
+      hypothesis: z16.string().max(1e4),
+      affectedBeliefs: z16.array(z16.string()),
+      predictedOutcomes: z16.array(z16.string()),
+      actualOutcomes: z16.array(z16.string()).optional(),
+      validated: z16.boolean(),
+      createdAt: z16.string(),
+      taskContext: z16.string().optional()
     })
   ),
-  hindsightRecords: z19.array(
-    z19.object({
-      taskId: z19.string(),
-      records: z19.array(
-        z19.object({
-          hindsightId: z19.string(),
-          taskId: z19.string(),
-          priorBeliefs: z19.array(z19.string()),
-          expectedOutcome: z19.string().max(1e4),
-          actualOutcome: z19.string().max(1e4),
-          outcomeMatched: z19.boolean(),
-          correctedBeliefs: z19.array(z19.string()),
-          newBeliefs: z19.array(z19.string()),
-          lessons: z19.array(z19.string()),
-          createdAt: z19.string()
+  hindsightRecords: z16.array(
+    z16.object({
+      taskId: z16.string(),
+      records: z16.array(
+        z16.object({
+          hindsightId: z16.string(),
+          taskId: z16.string(),
+          priorBeliefs: z16.array(z16.string()),
+          expectedOutcome: z16.string().max(1e4),
+          actualOutcome: z16.string().max(1e4),
+          outcomeMatched: z16.boolean(),
+          correctedBeliefs: z16.array(z16.string()),
+          newBeliefs: z16.array(z16.string()),
+          lessons: z16.array(z16.string()),
+          createdAt: z16.string()
         })
       )
     })
@@ -10762,7 +9915,7 @@ var BeliefSnapshotSchema = z19.object({
 });
 
 // src/context/belief-memory-persistence.ts
-var BELIEFS_DIR = path3.join(os2.homedir(), ".nexus-agents", "memory", "beliefs");
+var BELIEFS_DIR = path2.join(os2.homedir(), ".nexus-agents", "memory", "beliefs");
 var MAX_SNAPSHOT_FILES = 10;
 var SNAPSHOT_VERSION = 1;
 function optProp(key, value) {
@@ -10940,75 +10093,75 @@ function hydrateSnapshot(snapshot) {
   };
 }
 function ensureBeliefsDir() {
-  if (!fs3.existsSync(BELIEFS_DIR)) fs3.mkdirSync(BELIEFS_DIR, { recursive: true });
+  if (!fs2.existsSync(BELIEFS_DIR)) fs2.mkdirSync(BELIEFS_DIR, { recursive: true });
 }
 function getSnapshotFiles() {
   try {
-    return fs3.readdirSync(BELIEFS_DIR).filter((f) => f.startsWith("beliefs-") && f.endsWith(".json")).sort().reverse();
+    return fs2.readdirSync(BELIEFS_DIR).filter((f) => f.startsWith("beliefs-") && f.endsWith(".json")).sort().reverse();
   } catch {
     return [];
   }
 }
-function enforceRetention(logger13) {
+function enforceRetention(logger11) {
   try {
     const files = getSnapshotFiles();
     if (files.length <= MAX_SNAPSHOT_FILES) return;
     const toDelete = files.slice(MAX_SNAPSHOT_FILES);
-    for (const file of toDelete) fs3.unlinkSync(path3.join(BELIEFS_DIR, file));
-    logger13.debug("Belief snapshot retention enforced", {
+    for (const file of toDelete) fs2.unlinkSync(path2.join(BELIEFS_DIR, file));
+    logger11.debug("Belief snapshot retention enforced", {
       kept: MAX_SNAPSHOT_FILES,
       deleted: toDelete.length
     });
   } catch (error) {
-    logger13.debug("Belief snapshot retention cleanup failed", {
+    logger11.debug("Belief snapshot retention cleanup failed", {
       error: getErrorMessage(error)
     });
   }
 }
-function saveBeliefSnapshot(data, logger13) {
+function saveBeliefSnapshot(data, logger11) {
   try {
     ensureBeliefsDir();
     const snapshot = createSnapshot(data);
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const filename = `beliefs-${timestamp}.json`;
-    const filepath = path3.join(BELIEFS_DIR, filename);
-    fs3.writeFileSync(filepath, JSON.stringify(snapshot, null, 2), "utf-8");
-    logger13.info("Belief memory snapshot saved", { filename, beliefs: snapshot.beliefs.length });
-    enforceRetention(logger13);
+    const filepath = path2.join(BELIEFS_DIR, filename);
+    fs2.writeFileSync(filepath, JSON.stringify(snapshot, null, 2), "utf-8");
+    logger11.info("Belief memory snapshot saved", { filename, beliefs: snapshot.beliefs.length });
+    enforceRetention(logger11);
     return ok(filepath);
   } catch (error) {
     const message = getErrorMessage(error);
     return err(new Error(`Failed to save belief snapshot: ${message}`));
   }
 }
-function loadBeliefSnapshot(logger13) {
+function loadBeliefSnapshot(logger11) {
   try {
     ensureBeliefsDir();
     const files = getSnapshotFiles();
     if (files.length === 0) {
-      logger13.debug("No belief snapshots found");
+      logger11.debug("No belief snapshots found");
       return ok(null);
     }
     for (const file of files.slice(0, 3)) {
       try {
-        const filepath = path3.join(BELIEFS_DIR, file);
-        const raw = JSON.parse(fs3.readFileSync(filepath, "utf-8"));
+        const filepath = path2.join(BELIEFS_DIR, file);
+        const raw = JSON.parse(fs2.readFileSync(filepath, "utf-8"));
         const validation = BeliefSnapshotSchema.safeParse(raw);
         if (!validation.success) {
-          logger13.warn("Invalid belief snapshot file", { file, errors: validation.error.issues });
+          logger11.warn("Invalid belief snapshot file", { file, errors: validation.error.issues });
           continue;
         }
         const hydrated = hydrateSnapshot(validation.data);
-        logger13.info("Belief memory snapshot loaded", { file, beliefs: hydrated.beliefs.size });
+        logger11.info("Belief memory snapshot loaded", { file, beliefs: hydrated.beliefs.size });
         return ok(hydrated);
       } catch (error) {
-        logger13.warn("Failed to load belief snapshot file", {
+        logger11.warn("Failed to load belief snapshot file", {
           file,
           error: getErrorMessage(error)
         });
       }
     }
-    logger13.warn("All recent belief snapshots are invalid");
+    logger11.warn("All recent belief snapshots are invalid");
     return ok(null);
   } catch (error) {
     const message = getErrorMessage(error);
@@ -11017,81 +10170,81 @@ function loadBeliefSnapshot(logger13) {
 }
 
 // src/context/memory-types.ts
-import { z as z21 } from "zod";
+import { z as z18 } from "zod";
 
 // src/context/memory-module-types.ts
-import { z as z20 } from "zod";
-var CoreMemoryDataSchema = z20.object({
-  agentId: z20.string().min(1),
-  role: z20.string(),
-  name: z20.string().min(1),
-  constraints: z20.array(z20.string()),
-  capabilities: z20.array(z20.string()),
-  systemPrompt: z20.string().max(5e4).optional(),
-  temperament: z20.enum(["cautious", "balanced", "exploratory"]).optional()
+import { z as z17 } from "zod";
+var CoreMemoryDataSchema = z17.object({
+  agentId: z17.string().min(1),
+  role: z17.string(),
+  name: z17.string().min(1),
+  constraints: z17.array(z17.string()),
+  capabilities: z17.array(z17.string()),
+  systemPrompt: z17.string().max(5e4).optional(),
+  temperament: z17.enum(["cautious", "balanced", "exploratory"]).optional()
 });
-var EpisodeDataSchema = z20.object({
-  episodeId: z20.string().min(1),
-  taskId: z20.string().min(1),
-  agentId: z20.string().min(1),
-  action: z20.string().min(1),
-  outcome: z20.enum(["success", "failure", "partial"]),
-  context: z20.record(z20.string(), z20.unknown()),
-  learnings: z20.array(z20.string()).optional(),
-  timestamp: z20.date(),
-  durationMs: z20.number().positive().optional()
+var EpisodeDataSchema = z17.object({
+  episodeId: z17.string().min(1),
+  taskId: z17.string().min(1),
+  agentId: z17.string().min(1),
+  action: z17.string().min(1),
+  outcome: z17.enum(["success", "failure", "partial"]),
+  context: z17.record(z17.string(), z17.unknown()),
+  learnings: z17.array(z17.string()).optional(),
+  timestamp: z17.date(),
+  durationMs: z17.number().positive().optional()
 });
-var SemanticFactSchema = z20.object({
-  factId: z20.string().min(1),
-  domain: z20.string().min(1),
-  subject: z20.string().min(1),
-  predicate: z20.string().min(1),
-  object: z20.string(),
-  confidence: z20.number().min(0).max(1),
-  source: z20.string().optional(),
-  validUntil: z20.date().optional()
+var SemanticFactSchema = z17.object({
+  factId: z17.string().min(1),
+  domain: z17.string().min(1),
+  subject: z17.string().min(1),
+  predicate: z17.string().min(1),
+  object: z17.string(),
+  confidence: z17.number().min(0).max(1),
+  source: z17.string().optional(),
+  validUntil: z17.date().optional()
 });
-var ProcedureStepSchema = z20.object({
-  stepId: z20.string().min(1),
-  action: z20.string().min(1),
-  parameters: z20.record(z20.string(), z20.unknown()).optional(),
-  preconditions: z20.array(z20.string()).optional(),
-  postconditions: z20.array(z20.string()).optional()
+var ProcedureStepSchema = z17.object({
+  stepId: z17.string().min(1),
+  action: z17.string().min(1),
+  parameters: z17.record(z17.string(), z17.unknown()).optional(),
+  preconditions: z17.array(z17.string()).optional(),
+  postconditions: z17.array(z17.string()).optional()
 });
-var ProcedureSchema = z20.object({
-  procedureId: z20.string().min(1),
-  name: z20.string().min(1),
-  description: z20.string().max(1e4),
-  steps: z20.array(ProcedureStepSchema).max(100),
-  triggerConditions: z20.array(z20.string()),
-  successRate: z20.number().min(0).max(1),
-  executionCount: z20.number().int().min(0),
-  averageDurationMs: z20.number().positive().optional(),
-  tags: z20.array(z20.string()).optional()
+var ProcedureSchema = z17.object({
+  procedureId: z17.string().min(1),
+  name: z17.string().min(1),
+  description: z17.string().max(1e4),
+  steps: z17.array(ProcedureStepSchema).max(100),
+  triggerConditions: z17.array(z17.string()),
+  successRate: z17.number().min(0).max(1),
+  executionCount: z17.number().int().min(0),
+  averageDurationMs: z17.number().positive().optional(),
+  tags: z17.array(z17.string()).optional()
 });
-var ResourceReferenceSchema = z20.object({
-  resourceId: z20.string().min(1),
-  type: z20.enum(["file", "url", "api", "database", "other"]),
-  location: z20.string().min(1),
-  name: z20.string().min(1),
-  mimeType: z20.string().optional(),
-  size: z20.number().int().positive().optional(),
-  hash: z20.string().optional(),
-  lastAccessed: z20.date(),
-  lastModified: z20.date().optional(),
-  metadata: z20.record(z20.string(), z20.unknown()).optional()
+var ResourceReferenceSchema = z17.object({
+  resourceId: z17.string().min(1),
+  type: z17.enum(["file", "url", "api", "database", "other"]),
+  location: z17.string().min(1),
+  name: z17.string().min(1),
+  mimeType: z17.string().optional(),
+  size: z17.number().int().positive().optional(),
+  hash: z17.string().optional(),
+  lastAccessed: z17.date(),
+  lastModified: z17.date().optional(),
+  metadata: z17.record(z17.string(), z17.unknown()).optional()
 });
-var VaultEntrySchema = z20.object({
-  vaultId: z20.string().min(1),
-  category: z20.enum(["insight", "decision", "pattern", "config", "archive"]),
-  title: z20.string().min(1),
-  content: z20.unknown(),
-  importance: z20.enum(["critical", "high", "normal"]),
-  createdAt: z20.date(),
-  updatedAt: z20.date(),
-  expiresAt: z20.date().optional(),
-  tags: z20.array(z20.string()).optional(),
-  relatedIds: z20.array(z20.string()).optional()
+var VaultEntrySchema = z17.object({
+  vaultId: z17.string().min(1),
+  category: z17.enum(["insight", "decision", "pattern", "config", "archive"]),
+  title: z17.string().min(1),
+  content: z17.unknown(),
+  importance: z17.enum(["critical", "high", "normal"]),
+  createdAt: z17.date(),
+  updatedAt: z17.date(),
+  expiresAt: z17.date().optional(),
+  tags: z17.array(z17.string()).optional(),
+  relatedIds: z17.array(z17.string()).optional()
 });
 
 // src/context/memory-types.ts
@@ -11105,7 +10258,7 @@ var MemoryType = {
   /** Hindsight Belief Memory for reasoning agents (arXiv:2512.12818) */
   BELIEF: "belief"
 };
-var MemoryTypeSchema = z21.enum([
+var MemoryTypeSchema = z18.enum([
   "core",
   "episodic",
   "semantic",
@@ -11155,6 +10308,7 @@ var DEFAULT_RELEVANCE_CONFIG = {
       MemoryType.VAULT
     ],
     qa_expert: [MemoryType.SEMANTIC, MemoryType.EPISODIC, MemoryType.PROCEDURAL, MemoryType.BELIEF],
+    data_visualization_expert: [MemoryType.SEMANTIC, MemoryType.RESOURCE, MemoryType.EPISODIC],
     custom: [MemoryType.SEMANTIC, MemoryType.PROCEDURAL, MemoryType.RESOURCE],
     // TRINITY roles (arXiv:2512.04695) - thinker and verifier benefit from belief memory
     thinker: [MemoryType.SEMANTIC, MemoryType.CORE, MemoryType.VAULT, MemoryType.BELIEF],
@@ -11405,7 +10559,7 @@ var KnowledgeVaultImpl = class {
 };
 
 // src/context/typed-memory.ts
-var logger11 = createLogger({ component: "typed-memory" });
+var logger9 = createLogger({ component: "typed-memory" });
 var TypedMemory = class {
   core;
   episodic;
@@ -11426,7 +10580,7 @@ var TypedMemory = class {
     this.resource = new ResourceMemoryImpl(backend);
     this.vault = new KnowledgeVaultImpl(backend);
     this.belief = new HindsightBeliefMemory();
-    logger11.info("TypedMemory initialized");
+    logger9.info("TypedMemory initialized");
   }
   async queryByType(type, query, limit = 20) {
     const result = await this.backend.search(`${type} ${query}`, limit);
@@ -11468,7 +10622,7 @@ var TypedMemory = class {
   async pruneExpired() {
     const result = await this.backend.prune(new Date(getTimeProvider().now()));
     if (!result.ok) return result;
-    logger11.info("Pruned expired entries", { count: result.value });
+    logger9.info("Pruned expired entries", { count: result.value });
     return ok({
       prunedCount: result.value,
       prunedByType: {
@@ -11511,11 +10665,11 @@ var MemoryPromoter = class {
   agentic;
   config;
   log;
-  constructor(beliefs, agentic, config = {}, logger13) {
+  constructor(beliefs, agentic, config = {}, logger11) {
     this.beliefs = beliefs;
     this.agentic = agentic;
     this.config = { ...DEFAULT_PROMOTION_CONFIG, ...config };
-    this.log = logger13 ?? createLogger({ component: "MemoryPromoter" });
+    this.log = logger11 ?? createLogger({ component: "MemoryPromoter" });
   }
   /**
    * Promote high-confidence session learnings to structured beliefs.
@@ -11652,7 +10806,7 @@ var MemoryPromoter = class {
 };
 
 // src/mcp/tools/memory-decay.ts
-var DEFAULT_DECAY_CONFIG2 = {
+var DEFAULT_DECAY_CONFIG = {
   enabled: true,
   decayIntervalMs: 60 * 60 * 1e3,
   // 1 hour
@@ -11668,8 +10822,8 @@ var DEFAULT_DECAY_CONFIG2 = {
 var CrossReferenceTracker = class {
   references = /* @__PURE__ */ new Map();
   log;
-  constructor(logger13) {
-    this.log = logger13 ?? createLogger({ component: "CrossReferenceTracker" });
+  constructor(logger11) {
+    this.log = logger11 ?? createLogger({ component: "CrossReferenceTracker" });
   }
   /**
    * Register a cross-reference between two memories.
@@ -11754,9 +10908,9 @@ var MemoryDecayManager = class {
   agentic = null;
   adaptive = null;
   mobimem = null;
-  constructor(config = {}, logger13) {
-    this.config = { ...DEFAULT_DECAY_CONFIG2, ...config };
-    this.log = logger13 ?? createLogger({ component: "MemoryDecayManager" });
+  constructor(config = {}, logger11) {
+    this.config = { ...DEFAULT_DECAY_CONFIG, ...config };
+    this.log = logger11 ?? createLogger({ component: "MemoryDecayManager" });
     this.tracker = new CrossReferenceTracker(this.log);
   }
   /**
@@ -12111,16 +11265,16 @@ async function queryAdaptiveMemory(adaptive, query, keywords, limit, log) {
 }
 
 // src/mcp/tools/tool-memory.ts
-var MEMORY_BASE = path4.join(os3.homedir(), ".nexus-agents", "memory");
-var DEFAULT_MEMORY_DIR = path4.join(MEMORY_BASE, "sessions");
-var AGENTIC_DB_PATH = path4.join(MEMORY_BASE, "agentic.db");
-var ADAPTIVE_DB_PATH = path4.join(MEMORY_BASE, "adaptive.db");
-var TYPED_DB_PATH = path4.join(MEMORY_BASE, "typed.db");
-var MOBIMEM_DB_PATH = path4.join(MEMORY_BASE, "mobimem.db");
-var MARKDOWN_DIR = path4.join(MEMORY_BASE, "markdown");
+var MEMORY_BASE = path3.join(os3.homedir(), ".nexus-agents", "memory");
+var DEFAULT_MEMORY_DIR = path3.join(MEMORY_BASE, "sessions");
+var AGENTIC_DB_PATH = path3.join(MEMORY_BASE, "agentic.db");
+var ADAPTIVE_DB_PATH = path3.join(MEMORY_BASE, "adaptive.db");
+var TYPED_DB_PATH = path3.join(MEMORY_BASE, "typed.db");
+var MOBIMEM_DB_PATH = path3.join(MEMORY_BASE, "mobimem.db");
+var MARKDOWN_DIR = path3.join(MEMORY_BASE, "markdown");
 var sharedInstance = null;
-function getToolMemory(logger13) {
-  sharedInstance ??= new ToolMemoryManager(logger13);
+function getToolMemory(logger11) {
+  sharedInstance ??= new ToolMemoryManager(logger11);
   return sharedInstance;
 }
 function shutdownToolMemory() {
@@ -12141,8 +11295,8 @@ var ToolMemoryManager = class {
   mobimem = null;
   decayManager = null;
   initPromise = null;
-  constructor(logger13) {
-    this.log = logger13 ?? createLogger({ component: "ToolMemory" });
+  constructor(logger11) {
+    this.log = logger11 ?? createLogger({ component: "ToolMemory" });
     this.memory = new SessionMemory({
       memoryDir: DEFAULT_MEMORY_DIR,
       logger: this.log
@@ -12166,7 +11320,7 @@ var ToolMemoryManager = class {
   }
   /** Try to activate SQLite backends (best-effort, non-blocking). */
   async initSqliteBackends() {
-    fs4.mkdirSync(MARKDOWN_DIR, { recursive: true });
+    fs3.mkdirSync(MARKDOWN_DIR, { recursive: true });
     await this.initAgenticMemory();
     await this.initAdaptiveMemory();
     await this.initTypedMemory();
@@ -12824,14 +11978,14 @@ var ToolMemoryManager = class {
 };
 
 // src/orchestration/outcomes/outcome-store-persistence.ts
-import { appendFileSync, readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync4 } from "fs";
+import { appendFileSync, readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3 } from "fs";
 var PersistentOutcomeStore = class extends OutcomeStore {
   filePath;
   logger;
-  constructor(config, logger13) {
+  constructor(config, logger11) {
     super(config);
     this.filePath = config?.filePath ?? OUTCOMES_FILE;
-    this.logger = logger13 ?? createLogger({ component: "PersistentOutcomeStore" });
+    this.logger = logger11 ?? createLogger({ component: "PersistentOutcomeStore" });
     const dataDir = config?.dataDir;
     ensureLearningDir(dataDir);
     this.hydrate();
@@ -12875,7 +12029,7 @@ var PersistentOutcomeStore = class extends OutcomeStore {
     }
   }
   hydrate() {
-    if (!existsSync4(this.filePath)) {
+    if (!existsSync3(this.filePath)) {
       this.logger.debug("No outcomes file found, starting fresh", {
         path: this.filePath
       });
@@ -12972,7 +12126,7 @@ function emitTrendDetected(bus, detail) {
 }
 
 // src/mcp/tools/consensus-vote-recording.ts
-var logger12 = createLogger({ tool: "consensus-vote" });
+var logger10 = createLogger({ tool: "consensus-vote" });
 function recordVoteSuccess(proposal, strategy, outcome, duration, votes) {
   try {
     const memory = getToolMemory();
@@ -12988,10 +12142,10 @@ function recordVoteSuccess(proposal, strategy, outcome, duration, votes) {
       source: "consensus-vote"
     });
     void memory.runPromotionPipeline().catch((error) => {
-      logger12.warn("Promotion pipeline failed", { error });
+      logger10.warn("Promotion pipeline failed", { error });
     });
   } catch (error) {
-    logger12.warn("Failed to record vote success to memory", { error: getErrorMessage(error) });
+    logger10.warn("Failed to record vote success to memory", { error: getErrorMessage(error) });
   }
   if (votes !== void 0) {
     recordVoteOutcomes(votes);
@@ -13006,7 +12160,7 @@ function recordVoteError(proposal, errorMessage) {
       filePattern: "mcp/tools/consensus-vote"
     });
   } catch (error) {
-    logger12.warn("Failed to record vote error", { error: getErrorMessage(error) });
+    logger10.warn("Failed to record vote error", { error: getErrorMessage(error) });
   }
 }
 function recordVoteOutcomes(votes) {
@@ -13033,7 +12187,7 @@ function recordVoteOutcomes(votes) {
       });
     }
   } catch (error) {
-    logger12.debug("Best-effort vote outcome recording failed", { error: getErrorMessage(error) });
+    logger10.debug("Best-effort vote outcome recording failed", { error: getErrorMessage(error) });
   }
 }
 
@@ -13083,6 +12237,32 @@ function createEmptyConsensusResult(proposal, algorithm) {
     durationMs: 0
   };
 }
+var CASCADE_THRESHOLDS = {
+  majority: 0.5,
+  supermajority: 0.67,
+  unanimous: 1
+};
+function detectEarlyCascade(algorithm, approvals, rejections, total) {
+  const threshold = CASCADE_THRESHOLDS[algorithm] ?? 0.5;
+  if (total === 0) return { decided: false, reason: "" };
+  if (algorithm === "unanimous" && rejections > 0) {
+    return { decided: true, reason: `Unanimous rejected: ${String(rejections)} rejection(s)` };
+  }
+  if (approvals / total > threshold) {
+    return {
+      decided: true,
+      reason: `Approval locked: ${String(approvals)}/${String(total)} > ${String(threshold)}`
+    };
+  }
+  const remaining = total - approvals - rejections;
+  if ((approvals + remaining) / total < threshold) {
+    return {
+      decided: true,
+      reason: `Rejection locked: max possible ${String(approvals + remaining)}/${String(total)} < ${String(threshold)}`
+    };
+  }
+  return { decided: false, reason: "" };
+}
 async function processVotesThroughEngine(votes, proposal, algorithm) {
   const validVotes = votes.filter((v) => v.source !== "error");
   if (validVotes.length === 0) return createEmptyConsensusResult(proposal, algorithm);
@@ -13106,22 +12286,22 @@ async function processVotesThroughEngine(votes, proposal, algorithm) {
     });
   return resultRes.value;
 }
-function runHigherOrderVoting(strategy, voteMap, logger13) {
+function runHigherOrderVoting(strategy, voteMap, logger11) {
   if (strategy !== "higher_order") return void 0;
   const hovStrategy = new HigherOrderVotingStrategy();
   const tracker = getOrCreateCorrelationTracker();
   const result = hovStrategy.aggregate(voteMap, tracker);
-  logger13.info("Higher-Order Voting complete", {
+  logger11.info("Higher-Order Voting complete", {
     method: result.method,
     decision: result.decision,
     posteriorApproval: result.posteriorApproval.toFixed(3)
   });
   return result;
 }
-function recordVotesToTracker(votes, voteMap, outcome, logger13) {
+function recordVotesToTracker(votes, voteMap, outcome, logger11) {
   const allVotesReal = votes.every((v) => v.source === "llm");
   if (!allVotesReal) {
-    logger13.warn("Skipping correlation recording due to non-LLM votes", {
+    logger11.warn("Skipping correlation recording due to non-LLM votes", {
       count: votes.filter((v) => v.source !== "llm").length
     });
     return;
@@ -13129,39 +12309,106 @@ function recordVotesToTracker(votes, voteMap, outcome, logger13) {
   const tracker = getOrCreateCorrelationTracker();
   const id = `consensus-${String(getTimeProvider().now())}-${getRandomProvider().random().toString(36).slice(2, 9)}`;
   tracker.recordProposalVotes(id, voteMap, outcome);
-  logger13.debug("Recorded votes to tracker", { proposalId: id, outcome });
+  logger11.debug("Recorded votes to tracker", { proposalId: id, outcome });
   try {
     const persisted = createPersistedProposal(id, voteMap, outcome);
     const saveResult = saveCorrelationData([persisted]);
     if (!saveResult.ok) {
-      logger13.warn("Failed to persist correlation data", { error: saveResult.error.message });
+      logger11.warn("Failed to persist correlation data", { error: saveResult.error.message });
     }
   } catch (error) {
     const message = getErrorMessage(error);
-    logger13.warn("Error persisting correlation data", { error: message });
+    logger11.warn("Error persisting correlation data", { error: message });
+  }
+}
+async function processVotesWithCascade(votes, opts) {
+  const validVotes = votes.filter((v) => v.source !== "error");
+  const approvals = validVotes.filter((v) => v.vote.decision === "approve").length;
+  const rejections = validVotes.filter((v) => v.vote.decision === "reject").length;
+  const cascadeInfo = detectEarlyCascade(opts.algorithm, approvals, rejections, opts.totalRoles);
+  if (cascadeInfo.decided) {
+    opts.log.info("Vote cascade: outcome decided early", {
+      approvals,
+      rejections,
+      total: opts.totalRoles,
+      reason: cascadeInfo.reason
+    });
+  }
+  const engineResult = await processVotesThroughEngine(votes, opts.proposal, opts.algorithm);
+  const voteMap = /* @__PURE__ */ new Map();
+  for (const { role, vote, source } of votes) {
+    if (source !== "error") voteMap.set(role, vote);
+  }
+  const higherOrderResult = cascadeInfo.decided ? void 0 : runHigherOrderVoting(opts.strategy, voteMap, opts.log);
+  const outcome = engineResult.outcome === "approved" ? "approved" : "rejected";
+  return { engineResult, voteMap, higherOrderResult, outcome, cascaded: cascadeInfo.decided };
+}
+var CONTRARIAN_ESCALATION_THRESHOLD = 0.8;
+async function runContrarianCheck(proposal, log) {
+  try {
+    const { executeExpert } = await import("./expert-bridge-J36C7VES.js");
+    const prompt = [
+      "You are a contrarian analyst. Your job is to find reasons this proposal should be REJECTED.",
+      "Look for: YAGNI (not needed), MISALIGNED (wrong tech/architecture), SECURITY_RISK, SCOPE_CREEP.",
+      "",
+      `Proposal: ${proposal.slice(0, 2e3)}`,
+      "",
+      "If you find a strong reason to reject, respond with JSON:",
+      '{"decision":"reject","confidence":0.0-1.0,"reasoning":"your concern"}',
+      "If the proposal is sound, respond with:",
+      '{"decision":"approve","confidence":0.0-1.0,"reasoning":"why it is acceptable"}'
+    ].join("\n");
+    const result = await executeExpert("architecture", prompt);
+    if (!result.success) return { shouldEscalate: false, reason: "", confidence: 0 };
+    const jsonMatch = result.text.match(/\{[\s\S]*\}/);
+    if (jsonMatch === null) return { shouldEscalate: false, reason: "", confidence: 0 };
+    const parsed = JSON.parse(jsonMatch[0]);
+    const isRejection = parsed.decision === "reject";
+    const confidence = typeof parsed.confidence === "number" ? parsed.confidence : 0;
+    const reasoning = typeof parsed.reasoning === "string" ? parsed.reasoning : "";
+    if (isRejection && confidence >= CONTRARIAN_ESCALATION_THRESHOLD) {
+      log.info("Contrarian rejected with high confidence", {
+        confidence,
+        reasoning: reasoning.slice(0, 200)
+      });
+      return { shouldEscalate: true, reason: reasoning, confidence };
+    }
+    return { shouldEscalate: false, reason: "", confidence };
+  } catch {
+    return { shouldEscalate: false, reason: "", confidence: 0 };
   }
 }
-async function executeVoting(input, logger13) {
+async function executeVoting(input, logger11) {
   const strategy = resolveStrategy(input);
   const algorithm = strategyToAlgorithm(strategy);
   const roles = getVoterRoles(input.quickMode);
   const startTime = getTimeProvider().now();
-  logger13.info("Starting consensus vote", { strategy, algorithm, roleCount: roles.length });
+  logger11.info("Starting consensus vote", { strategy, algorithm, roleCount: roles.length });
   const votes = await collectRealVotes({
     roles,
     proposal: input.proposal,
     simulate: input.simulateVotes
   });
-  const engineResult = await processVotesThroughEngine(votes, input.proposal, algorithm);
-  const voteMap = /* @__PURE__ */ new Map();
-  for (const { role, vote, source } of votes) {
-    if (source !== "error") voteMap.set(role, vote);
+  const { engineResult, voteMap, higherOrderResult, outcome, cascaded } = await processVotesWithCascade(votes, {
+    totalRoles: roles.length,
+    proposal: input.proposal,
+    algorithm,
+    strategy,
+    log: logger11
+  });
+  recordVotesToTracker(votes, voteMap, outcome, logger11);
+  if (input.quickMode && outcome === "approved" && !input.simulateVotes) {
+    const escalation = await runContrarianCheck(input.proposal, logger11);
+    if (escalation.shouldEscalate) {
+      logger11.warn("Contrarian escalation: re-running with full vote", {
+        reason: escalation.reason,
+        confidence: escalation.confidence
+      });
+      return executeVoting({ ...input, quickMode: false }, logger11);
+    }
   }
-  const higherOrderResult = runHigherOrderVoting(strategy, voteMap, logger13);
-  const outcome = engineResult.outcome === "approved" ? "approved" : "rejected";
-  recordVotesToTracker(votes, voteMap, outcome, logger13);
   const totalTimeMs = getTimeProvider().now() - startTime;
-  logger13.info("Consensus vote completed", { strategy, outcome, durationMs: totalTimeMs });
+  logger11.info("Consensus vote completed", { strategy, outcome, durationMs: totalTimeMs, cascaded });
   const result = {
     proposal: input.proposal,
     threshold: algorithm,
@@ -13175,14 +12422,14 @@ async function executeVoting(input, logger13) {
   return result;
 }
 async function handleConsensusVote(deps, args) {
-  const logger13 = deps.logger ?? createLogger({ tool: "consensus_vote" });
+  const logger11 = deps.logger ?? createLogger({ tool: "consensus_vote" });
   try {
-    const result = await executeVoting(args, logger13);
+    const result = await executeVoting(args, logger11);
     const strategy = args.strategy ?? "simple_majority";
     const errorVotes = result.votes.filter((v) => v.source === "error");
     if (errorVotes.length === result.votes.length && result.votes.length > 0) {
       const failures = errorVotes.map((v) => `${v.role}: ${v.error ?? "unknown error"}`).join("; ");
-      logger13.warn("All voters failed", { failureCount: errorVotes.length, failures });
+      logger11.warn("All voters failed", { failureCount: errorVotes.length, failures });
       recordVoteError(args.proposal, `All ${String(errorVotes.length)} voters failed: ${failures}`);
       return {
         ok: false,
@@ -13200,7 +12447,7 @@ async function handleConsensusVote(deps, args) {
   } catch (error) {
     const message = getErrorMessage(error);
     const cause = error instanceof Error ? error : new Error(message);
-    logger13.error("Consensus vote failed", cause);
+    logger11.error("Consensus vote failed", cause);
     recordVoteError(args.proposal, message);
     return { ok: false, error: `Voting failed: ${message}` };
   }
@@ -13251,27 +12498,27 @@ function createConsensusVoteHandler(deps) {
   };
 }
 var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
-  proposal: z22.string(),
+  proposal: z19.string(),
   strategy: VotingStrategySchema,
-  decision: z22.enum(["approved", "rejected", "no_quorum"]),
-  approvalPercentage: z22.number(),
-  voteCounts: z22.object({
-    approve: z22.number(),
-    reject: z22.number(),
-    abstain: z22.number(),
-    error: z22.number()
+  decision: z19.enum(["approved", "rejected", "no_quorum"]),
+  approvalPercentage: z19.number(),
+  voteCounts: z19.object({
+    approve: z19.number(),
+    reject: z19.number(),
+    abstain: z19.number(),
+    error: z19.number()
   }),
-  votes: z22.array(
-    z22.object({
-      role: z22.string().max(100),
-      decision: z22.enum(["approve", "reject", "abstain"]),
-      confidence: z22.number(),
-      reasoning: z22.string().max(4e3),
-      simulated: z22.boolean(),
-      error: z22.boolean(),
-      modelUsed: z22.string().max(100).optional(),
-      rejectionCategories: z22.array(
-        z22.enum([
+  votes: z19.array(
+    z19.object({
+      role: z19.string().max(100),
+      decision: z19.enum(["approve", "reject", "abstain"]),
+      confidence: z19.number(),
+      reasoning: z19.string().max(4e3),
+      simulated: z19.boolean(),
+      error: z19.boolean(),
+      modelUsed: z19.string().max(100).optional(),
+      rejectionCategories: z19.array(
+        z19.enum([
           "YAGNI",
           "DRY_VIOLATION",
           "OVER_ENGINEERING",
@@ -13283,50 +12530,50 @@ var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
       ).optional()
     })
   ),
-  threshold: z22.enum(["majority", "supermajority", "unanimous"]).optional(),
-  durationMs: z22.number(),
-  simulateVotes: z22.boolean(),
-  higherOrderMetadata: z22.object({
-    posteriorApproval: z22.number(),
-    posteriorRejection: z22.number(),
-    effectiveVoteCount: z22.number(),
-    method: z22.enum(["ow", "isp", "simple"]),
-    usedCorrelationData: z22.boolean(),
-    improvementOverBaseline: z22.number(),
-    downweightedAgents: z22.array(z22.string().max(100)).max(10),
-    reasoning: z22.string().max(2e3)
+  threshold: z19.enum(["majority", "supermajority", "unanimous"]).optional(),
+  durationMs: z19.number(),
+  simulateVotes: z19.boolean(),
+  higherOrderMetadata: z19.object({
+    posteriorApproval: z19.number(),
+    posteriorRejection: z19.number(),
+    effectiveVoteCount: z19.number(),
+    method: z19.enum(["ow", "isp", "simple"]),
+    usedCorrelationData: z19.boolean(),
+    improvementOverBaseline: z19.number(),
+    downweightedAgents: z19.array(z19.string().max(100)).max(10),
+    reasoning: z19.string().max(2e3)
   }).optional()
 };
 function registerConsensusVoteTool(server, deps) {
-  const logger13 = deps.logger ?? createLogger({ tool: "consensus_vote" });
+  const logger11 = deps.logger ?? createLogger({ tool: "consensus_vote" });
   const notifier = deps.notifier ?? createMcpNotifier(server);
   const depsWithNotifier = { ...deps, notifier };
   const toolSchema = {
-    proposal: z22.string().min(1).max(MAX_PROPOSAL_LENGTH).describe("Proposal text to vote on"),
-    threshold: z22.enum(["majority", "supermajority", "unanimous"]).optional().describe("Voting threshold (legacy). Use strategy instead."),
+    proposal: z19.string().min(1).max(MAX_PROPOSAL_LENGTH).describe("Proposal text to vote on"),
+    threshold: z19.enum(["majority", "supermajority", "unanimous"]).optional().describe("Voting threshold (legacy). Use strategy instead."),
     strategy: VotingStrategySchema.optional().describe(
       "Voting strategy: simple_majority (default), supermajority, unanimous, proof_of_learning, or higher_order"
     ),
-    quickMode: z22.boolean().optional().default(false).describe("Use 3 agents instead of 6"),
-    simulateVotes: z22.boolean().optional().default(false).describe("Use simulated votes")
+    quickMode: z19.boolean().optional().default(false).describe("Use 3 agents instead of 6"),
+    simulateVotes: z19.boolean().optional().default(false).describe("Use simulated votes")
   };
   const description = "Execute multi-model consensus voting on a proposal. Uses 6 specialized agent roles (architect, security, devex, ai_ml, pm, catfish) to vote on proposals with configurable strategies. Supports higher_order strategy for Bayesian-optimal aggregation with correlation awareness (Issue #514).";
   const secureHandler = createSecureHandler(createConsensusVoteHandler(depsWithNotifier), {
     toolName: "consensus_vote",
     rateLimiter: deps.rateLimiter,
-    logger: logger13
+    logger: logger11
   });
   const timeoutMs = getToolTimeout("consensus_vote", deps.security);
   const wrappedHandler = wrapToolWithTimeout("consensus_vote", secureHandler, {
     timeoutMs,
-    logger: logger13
+    logger: logger11
   });
   server.registerTool(
     "consensus_vote",
     { description, inputSchema: toolSchema, outputSchema: CONSENSUS_VOTE_OUTPUT_SCHEMA },
     toSdkCallback(wrappedHandler)
   );
-  logger13.info("Registered consensus_vote tool with secure handler and timeout protection");
+  logger11.info("Registered consensus_vote tool with secure handler and timeout protection");
 }
 
 export {
@@ -13367,11 +12614,8 @@ export {
   createUnifiedRegistry,
   getGlobalRegistry,
   DEFAULT_RELEVANCE_CONFIG,
-  MemoryImportance,
-  MemoryError,
   generateHyphenId,
   generateUUID,
-  calculateTextJaccardSimilarity,
   validateToolInput,
   createValidator,
   RateLimiter,
@@ -13472,4 +12716,4 @@ export {
   CONSENSUS_VOTE_OUTPUT_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-S3BKWNST.js.map
+//# sourceMappingURL=chunk-J245RJGW.js.map