nexus-agents 2.72.1 → 2.74.0

package/dist/{chunk-53K3KEKT.js → chunk-T5VPZZYX.js}

@@ -4,15 +4,18 @@ import {
   createStream,
   requireApiKey,
   validateApiKeyPresence
-} from "./chunk-5MHIWRKB.js";
+} from "./chunk-NQR7QAZX.js";
 import {
   CUSTOM_API_BASE_URL_ENV,
   PROVIDER_ENV_KEYS,
   validateCustomApiBaseUrl
-} from "./chunk-5WQ3SRSE.js";
+} from "./chunk-PAFH336F.js";
+import {
+  getDefaultAvailableModelsCache
+} from "./chunk-QON7LR7J.js";
 import {
   CUSTOM_API_DEFAULT_MODEL
-} from "./chunk-2MD5MWCK.js";
+} from "./chunk-GS3GW7C7.js";
 import {
   createCliAdapter,
   createCliDetectionCache,
@@ -20,10 +23,10 @@ import {
   getAvailableClis,
   isCliAvailable,
   withTimeout
-} from "./chunk-ES6GFP35.js";
+} from "./chunk-NC2LECY6.js";
 import {
   SessionMemory
-} from "./chunk-2KB63QGE.js";
+} from "./chunk-EQHYXT56.js";
 import {
   AdaptiveMemoryBackend,
   HybridMemoryBackend,
@@ -32,7 +35,7 @@ import {
   getMemoryEntry,
   memoryExists,
   memoryRowToEntry
-} from "./chunk-QECRZ3YA.js";
+} from "./chunk-3ESCBV47.js";
 import {
   stringifyValue,
   tokenizeFiltered
@@ -42,8 +45,6 @@ import {
   CACHE_TIMEOUTS,
   CLI_NAMES,
   DEFAULT_CLI,
-  DEFAULT_MODEL_CAPABILITIES,
-  DEFAULT_MODEL_PER_CLI,
   ErrorCode,
   MCP_TIMEOUTS,
   MobiMem,
@@ -66,7 +67,10 @@ import {
   formatPercentage,
   formatZodError,
   getCliModelName,
+  getDefaultModelForCli,
+  getDefaultRegistry,
   getErrorMessage,
+  getInTreeCapabilitiesMatrix,
   getMcpSafeDeadlineMs,
   getOutcomeStore,
   getRandomProvider,
@@ -78,9 +82,8 @@ import {
   registerPersistentOutcomeStoreFactory,
   resolveCliAlias,
   resolveVoteTimeout,
-  toRateLimitError,
-  validateTimeout
-} from "./chunk-O4KUCF5S.js";
+  toRateLimitError
+} from "./chunk-Q3RFPJYK.js";
 import {
   ensureLearningDir,
   getOutcomesFile
@@ -90,38 +93,38 @@ import {
 } from "./chunk-GOT7OAL5.js";
 
 // src/mcp/tools/consensus-vote.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // src/mcp/mcp-notifier.ts
 import { AsyncLocalStorage } from "async_hooks";
 var internalLogger = createLogger({ component: "mcp-notifier" });
 function createMcpNotifier(server) {
-  function send(level, logger11, data) {
+  function send(level, logger12, data) {
     try {
-      server.sendLoggingMessage({ level, logger: logger11, data }).catch((error) => {
+      server.sendLoggingMessage({ level, logger: logger12, data }).catch((error) => {
         internalLogger.debug("Failed to send MCP notification", {
           level,
-          logger: logger11,
+          logger: logger12,
           error: getErrorMessage(error)
         });
       });
     } catch (error) {
       internalLogger.debug("Failed to send MCP notification", {
         level,
-        logger: logger11,
+        logger: logger12,
         error: getErrorMessage(error)
       });
     }
   }
   return {
-    info: (logger11, data) => {
-      send("info", logger11, data);
+    info: (logger12, data) => {
+      send("info", logger12, data);
     },
-    debug: (logger11, data) => {
-      send("debug", logger11, data);
+    debug: (logger12, data) => {
+      send("debug", logger12, data);
     },
-    warn: (logger11, data) => {
-      send("warning", logger11, data);
+    warn: (logger12, data) => {
+      send("warning", logger12, data);
     }
   };
 }
@@ -246,7 +249,7 @@ var RateLimiter = class {
     this.logger.debug("Rate limiter reset", { tokens: this.tokens });
   }
 };
-function createDefaultRateLimiter(name, logger11) {
+function createDefaultRateLimiter(name, logger12) {
   const config = {
     capacity: 100,
     refillRate: 10,
@@ -255,8 +258,8 @@ function createDefaultRateLimiter(name, logger11) {
   if (name !== void 0) {
     config.name = name;
   }
-  if (logger11 !== void 0) {
-    config.logger = logger11;
+  if (logger12 !== void 0) {
+    config.logger = logger12;
   }
   return new RateLimiter(config);
 }
@@ -1014,13 +1017,69 @@ function createAccessPolicyChainMiddleware(toolName) {
   };
 }
 
-// src/mcp/middleware/middleware-chain.ts
-function errorResult(message, requestId) {
+// src/mcp/error-envelope.ts
+import { z as z2 } from "zod";
+var ErrorCategorySchema = z2.enum([
+  "transient",
+  "validation",
+  "permission",
+  "business",
+  "internal"
+]);
+var ToolErrorEnvelopeSchema = z2.object({
+  errorCategory: ErrorCategorySchema,
+  /** Whether retrying the same call could succeed without caller changes. */
+  isRetryable: z2.boolean(),
+  /** Human-readable summary. Bounded to keep stack traces out of results. */
+  message: z2.string().min(1).max(2e3),
+  /**
+   * Optional structured context. MUST NOT carry secrets, credentials,
+   * absolute filesystem paths, or raw Error/response objects — those are
+   * an information-disclosure risk (this field is not output-sanitized).
+   */
+  detail: z2.record(z2.string(), z2.unknown()).optional()
+});
+var ERROR_ENVELOPE_META_KEY = "nexus-agents/error";
+function defaultRetryable(category) {
+  return category === "transient";
+}
+
+// src/mcp/tools/tool-result.ts
+function toolSuccess(text) {
+  return {
+    content: [{ type: "text", text }]
+  };
+}
+function toolSuccessStructured(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    structuredContent: data
+  };
+}
+function toolStructuredError(input) {
+  const envelope = {
+    errorCategory: input.errorCategory,
+    isRetryable: input.isRetryable ?? defaultRetryable(input.errorCategory),
+    message: input.message,
+    ...input.detail !== void 0 ? { detail: input.detail } : {}
+  };
   return {
     isError: true,
-    content: [{ type: "text", text: `${message} (request: ${requestId})` }]
+    content: [{ type: "text", text: envelope.message }],
+    _meta: { [ERROR_ENVELOPE_META_KEY]: envelope }
   };
 }
+function toolError(message) {
+  return toolStructuredError({ errorCategory: "internal", message });
+}
+
+// src/mcp/middleware/middleware-chain.ts
+function errorResult(category, message, requestId) {
+  return toolStructuredError({
+    errorCategory: category,
+    message: `${message} (request: ${requestId})`
+  });
+}
 function createValidationMiddleware(schema) {
   return async (args, ctx, next) => {
     const result = validateToolInput(schema, args);
@@ -1028,7 +1087,11 @@ function createValidationMiddleware(schema) {
       ctx.logger.warn("Validation failed", {
         error: result.error.message
       });
-      return errorResult(`Validation error: ${result.error.message}`, ctx.requestContext.requestId);
+      return errorResult(
+        "validation",
+        `Validation error: ${result.error.message}`,
+        ctx.requestContext.requestId
+      );
     }
     ctx.validatedArgs = result.value;
     return next(result.value, ctx);
@@ -1046,7 +1109,11 @@ function createPolicyMiddleware(firewall, toolName, mode, allowedPaths) {
         reason: decision.reason,
         ruleName: decision.ruleName
       });
-      return errorResult(`Policy denied: ${decision.reason}`, ctx.requestContext.requestId);
+      return errorResult(
+        "permission",
+        `Policy denied: ${decision.reason}`,
+        ctx.requestContext.requestId
+      );
     }
     ctx.logger.debug("Policy check passed", { reason: decision.reason });
     return next(args, ctx);
@@ -1061,6 +1128,7 @@ function createRateLimitMiddleware(limiter) {
         nextTokenMs: state.nextTokenMs
       });
       return errorResult(
+        "transient",
         `Rate limit exceeded. Try again in ${String(state.nextTokenMs)}ms`,
         ctx.requestContext.requestId
       );
@@ -1080,7 +1148,7 @@ function createTimeoutMiddleware(guard, toolName) {
         code: result.error.code,
         timeoutMs: result.error.timeoutMs
       });
-      return errorResult(result.error.message, ctx.requestContext.requestId);
+      return errorResult("transient", result.error.message, ctx.requestContext.requestId);
     }
     if (result.value.nearTimeout) {
       ctx.logger.warn("Operation completed near timeout threshold", {
@@ -1109,7 +1177,7 @@ function createAuditMiddleware() {
       ctx.logger.error("Tool execution failed", error instanceof Error ? error : void 0, {
         durationMs
       });
-      return errorResult(`Internal error: ${message}`, ctx.requestContext.requestId);
+      return errorResult("internal", `Internal error: ${message}`, ctx.requestContext.requestId);
     }
   };
 }
@@ -1176,13 +1244,13 @@ function buildMiddlewareStack(config) {
   return middlewares;
 }
 function createMiddlewareChain(config) {
-  const logger11 = config.logger ?? createLogger({ tool: config.toolName });
+  const logger12 = 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 = logger11.child(contextForLogging(requestContext));
+      const requestLogger = logger12.child(contextForLogging(requestContext));
       const ctx = { requestContext, logger: requestLogger };
       return composed(args, ctx, (finalArgs, finalCtx) => handler(finalArgs, finalCtx));
     };
@@ -1284,6 +1352,26 @@ function toSdkCallback(handler) {
     return runWithContexts(handler, args, progressCtx, signal);
   };
 }
+var MCP_SDK_DEFAULT_REQUEST_TIMEOUT_MS = 6e4;
+function toSdkCallbackWithBudgetCheck(handler, toolName, configuredTimeoutMs, logger12) {
+  const log = logger12 ?? wrapperLogger;
+  return (args, extra) => {
+    const progressCtx = extractProgressContext(extra);
+    const signal = extra?.signal;
+    if (configuredTimeoutMs > MCP_SDK_DEFAULT_REQUEST_TIMEOUT_MS && progressCtx === void 0) {
+      log.warn(
+        "MCP tool budget exceeds client default and no progressToken received \u2014 request likely to be killed by client before server-side deadline",
+        {
+          tool: toolName,
+          configuredTimeoutMs,
+          mcpSdkDefaultMs: MCP_SDK_DEFAULT_REQUEST_TIMEOUT_MS,
+          remediation: "Client should pass `onprogress` and `resetTimeoutOnProgress: true` when calling, or extend `options.timeout`. See docs/architecture/MCP_PROTOCOL.md."
+        }
+      );
+    }
+    return runWithContexts(handler, args, progressCtx, signal);
+  };
+}
 
 // src/audit/secure-handler-audit.ts
 function actorFromContext(ctx, fallback) {
@@ -1391,15 +1479,15 @@ function sanitizeToolInput(args) {
     detectedPatterns: uniquePatterns
   };
 }
-function logSanitizationResult(result, logger11, toolName) {
+function logSanitizationResult(result, logger12, toolName) {
   if (result.wasModified) {
-    logger11.warn("Tool input sanitized \u2014 XML injection tags stripped", {
+    logger12.warn("Tool input sanitized \u2014 XML injection tags stripped", {
       tool: toolName,
       modifiedFields: result.modifiedCount
     });
   }
   if (result.detectedPatterns.length > 0) {
-    logger11.warn("Injection patterns detected in tool input", {
+    logger12.warn("Injection patterns detected in tool input", {
       tool: toolName,
       patterns: result.detectedPatterns
     });
@@ -1408,27 +1496,22 @@ function logSanitizationResult(result, logger11, toolName) {
 
 // src/mcp/middleware/secure-handler.ts
 function rateLimitError(nextTokenMs) {
-  return {
-    isError: true,
-    content: [
-      {
-        type: "text",
-        text: `Rate limit exceeded. Try again in ${String(nextTokenMs)}ms.`
-      }
-    ]
-  };
+  return toolStructuredError({
+    errorCategory: "transient",
+    message: `Rate limit exceeded. Try again in ${String(nextTokenMs)}ms.`
+  });
 }
 function policyDeniedError(reason, requestId) {
-  return {
-    isError: true,
-    content: [{ type: "text", text: `Policy denied: ${reason} (request: ${requestId})` }]
-  };
+  return toolStructuredError({
+    errorCategory: "permission",
+    message: `Policy denied: ${reason} (request: ${requestId})`
+  });
 }
 function internalError(message, requestId) {
-  return {
-    isError: true,
-    content: [{ type: "text", text: `Internal error: ${message} (request: ${requestId})` }]
-  };
+  return toolStructuredError({
+    errorCategory: "internal",
+    message: `Internal error: ${message} (request: ${requestId})`
+  });
 }
 var MAX_INPUT_SIZE_BYTES = 10 * 1024 * 1024;
 var SECRET_PATTERNS = [
@@ -1444,11 +1527,11 @@ var SECRET_PATTERNS = [
   // password= or token= in output
   /(?:password|token|secret|apikey|api_key)\s*[=:]\s*\S{8,}/i
 ];
-function sanitizeOutput(text, logger11) {
+function sanitizeOutput(text, logger12) {
   let sanitized = text;
   for (const pattern of SECRET_PATTERNS) {
     if (pattern.test(sanitized)) {
-      logger11.warn("Potential secret detected in tool output, redacting", {
+      logger12.warn("Potential secret detected in tool output, redacting", {
         pattern: pattern.source.slice(0, 30)
       });
       sanitized = sanitized.replace(pattern, "[REDACTED]");
@@ -1456,25 +1539,25 @@ function sanitizeOutput(text, logger11) {
   }
   return sanitized;
 }
-function sanitizeToolResult(result, logger11) {
+function sanitizeToolResult(result, logger12) {
   for (const item of result.content) {
-    item.text = sanitizeOutput(item.text, logger11);
+    item.text = sanitizeOutput(item.text, logger12);
   }
 }
-function checkInputSize(args, logger11, requestId) {
+function checkInputSize(args, logger12, requestId) {
   if (args === void 0) return null;
   const inputSize = JSON.stringify(args).length;
   if (inputSize > MAX_INPUT_SIZE_BYTES) {
-    logger11.warn("Input size exceeds limit", { inputSize, limit: MAX_INPUT_SIZE_BYTES });
+    logger12.warn("Input size exceeds limit", { inputSize, limit: MAX_INPUT_SIZE_BYTES });
     return internalError("Input too large", requestId);
   }
   return null;
 }
-function checkRateLimit(rateLimiter, logger11) {
+function checkRateLimit(rateLimiter, logger12) {
   const acquired = rateLimiter.tryAcquire();
   if (!acquired) {
     const state = rateLimiter.getState();
-    logger11.warn("Rate limit exceeded");
+    logger12.warn("Rate limit exceeded");
     return rateLimitError(state.nextTokenMs);
   }
   return null;
@@ -1495,14 +1578,14 @@ function checkPolicy(opts) {
   opts.logger.debug("Policy check passed", { reason: decision.reason });
   return null;
 }
-async function executeHandler(handler, args, ctx, logger11) {
+async function executeHandler(handler, args, ctx, logger12) {
   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) {
-    logger11.warn("Tool execution completed with error", { durationMs });
+    logger12.warn("Tool execution completed with error", { durationMs });
   } else {
-    logger11.info("Tool execution completed", { durationMs });
+    logger12.info("Tool execution completed", { durationMs });
   }
   return result;
 }
@@ -1548,35 +1631,30 @@ function emitRateLimitAudit(auditLogger, toolName, ctx) {
     requestId: ctx.requestId
   });
 }
-function checkSecurityTier(config, sanitizeResult, logger11) {
+function checkSecurityTier(config, sanitizeResult, logger12) {
   const tier = config.securityTier ?? "standard";
   if (tier === "standard" || sanitizeResult.detectedPatterns.length === 0) {
     return null;
   }
-  logger11.warn("Input rejected by security tier validation", {
+  logger12.warn("Input rejected by security tier validation", {
     tier,
     patterns: sanitizeResult.detectedPatterns
   });
-  return {
-    isError: true,
-    content: [
-      {
-        type: "text",
-        text: `Input validation failed: detected patterns [${sanitizeResult.detectedPatterns.join(", ")}]. Remove prompt injection patterns and retry.`
-      }
-    ]
-  };
+  return toolStructuredError({
+    errorCategory: "permission",
+    message: `Input validation failed: detected patterns [${sanitizeResult.detectedPatterns.join(", ")}]. Remove prompt injection patterns and retry.`
+  });
 }
-function runPreChecks(config, args, mode, requestContext, logger11) {
-  const sizeResult = checkInputSize(args, logger11, requestContext.requestId);
+function runPreChecks(config, args, mode, requestContext, logger12) {
+  const sizeResult = checkInputSize(args, logger12, requestContext.requestId);
   if (sizeResult) return { error: sizeResult, sanitizedArgs: args };
   const sanitizeResult = sanitizeToolInput(args);
-  logSanitizationResult(sanitizeResult, logger11, config.toolName);
+  logSanitizationResult(sanitizeResult, logger12, config.toolName);
   const sanitizedArgs = sanitizeResult.wasModified ? sanitizeResult.sanitized : args;
-  const tierError = checkSecurityTier(config, sanitizeResult, logger11);
+  const tierError = checkSecurityTier(config, sanitizeResult, logger12);
   if (tierError !== null) return { error: tierError, sanitizedArgs };
   if (config.rateLimiter) {
-    const rlResult = checkRateLimit(config.rateLimiter, logger11);
+    const rlResult = checkRateLimit(config.rateLimiter, logger12);
     if (rlResult) {
       if (config.auditLogger)
         emitRateLimitAudit(config.auditLogger, config.toolName, requestContext);
@@ -1590,7 +1668,7 @@ function runPreChecks(config, args, mode, requestContext, logger11) {
       args: sanitizedArgs,
       mode,
       allowedPaths: config.allowedPaths,
-      logger: logger11,
+      logger: logger12,
       requestId: requestContext.requestId
     });
     if (pResult) {
@@ -1602,7 +1680,7 @@ function runPreChecks(config, args, mode, requestContext, logger11) {
   return { error: null, sanitizedArgs };
 }
 function createSecureHandler(handler, config) {
-  const logger11 = config.logger ?? createLogger({ tool: config.toolName });
+  const logger12 = config.logger ?? createLogger({ tool: config.toolName });
   const mode = config.executionMode ?? "read-only";
   return async (args) => {
     const ctxOpts = {
@@ -1610,7 +1688,7 @@ function createSecureHandler(handler, config) {
       ...config.callerInfo && { caller: config.callerInfo }
     };
     const requestContext = createRequestContext(ctxOpts);
-    const requestLogger = logger11.child(contextForLogging(requestContext));
+    const requestLogger = logger12.child(contextForLogging(requestContext));
     requestLogger.info("Tool invocation started");
     const { error: preCheckError, sanitizedArgs } = runPreChecks(
       config,
@@ -1658,31 +1736,7 @@ async function executeAndAudit(handler, sanitizedArgs, requestContext, requestLo
   }
 }
 
-// src/mcp/tools/tool-result.ts
-function toolSuccess(text) {
-  return {
-    content: [{ type: "text", text }]
-  };
-}
-function toolSuccessStructured(data) {
-  return {
-    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
-    structuredContent: data
-  };
-}
-function toolError(message) {
-  return {
-    isError: true,
-    content: [{ type: "text", text: message }]
-  };
-}
-
 // src/cli/vote-types.ts
-var THRESHOLD_MAP = {
-  majority: "simple_majority",
-  supermajority: "supermajority",
-  unanimous: "unanimous"
-};
 var VOTER_ROLES = {
   architect: "Software Architect - evaluates technical design, scalability, and maintainability",
   security: "Security Engineer - evaluates security implications, vulnerabilities, and attack vectors",
@@ -2219,7 +2273,48 @@ var ClaudeAdapter = class extends BaseAdapter {
         return null;
     }
   }
+  /**
+   * (#2540) List models the Anthropic API currently exposes.
+   * Wraps `client.models.list()`. Cached for 5 min, in-flight promise
+   * shared across concurrent callers, throws on non-2xx so the
+   * harness-side identity resolver knows to fall back.
+   */
+  async listModels() {
+    const now = Date.now();
+    if (this.modelsCache !== null && now - this.modelsCache.fetchedAt < CLAUDE_LIST_MODELS_TTL_MS) {
+      return this.modelsCache.value;
+    }
+    if (this.modelsInFlight !== null) return this.modelsInFlight;
+    const inFlight = this.fetchModels();
+    this.modelsInFlight = inFlight;
+    try {
+      const value = await inFlight;
+      this.modelsCache = { value, fetchedAt: Date.now() };
+      return value;
+    } finally {
+      this.modelsInFlight = null;
+    }
+  }
+  modelsCache = null;
+  modelsInFlight = null;
+  async fetchModels() {
+    const list = await this.client.models.list();
+    const out = [];
+    for (const m of list.data) {
+      const entry = { id: m.id };
+      if (typeof m.created_at === "string") {
+        const ts = Date.parse(m.created_at);
+        if (!Number.isNaN(ts)) {
+          out.push({ ...entry, ownedBy: "anthropic", createdAt: Math.floor(ts / 1e3) });
+          continue;
+        }
+      }
+      out.push({ ...entry, ownedBy: "anthropic" });
+    }
+    return out;
+  }
 };
+var CLAUDE_LIST_MODELS_TTL_MS = 5 * 60 * 1e3;
 function createClaudeAdapter(config) {
   return new ClaudeAdapter(config);
 }
@@ -2293,13 +2388,13 @@ var SdkAdapter = class extends BaseAdapter {
   customBaseUrl;
   /** Inflight init promise for coalescing concurrent calls (Issue #1438). */
   initPromise;
-  constructor(config, logger11) {
+  constructor(config, logger12) {
     const apiKey = resolveApiKey(config.providerId, config.apiKey);
     super({
       providerId: `sdk-${config.providerId}`,
       modelId: config.modelId,
       capabilities: [ModelCapability.COMPLETION, ModelCapability.STREAMING],
-      logger: logger11 ?? createLogger({ adapter: `sdk-${config.providerId}` }),
+      logger: logger12 ?? createLogger({ adapter: `sdk-${config.providerId}` }),
       ...apiKey !== void 0 ? { apiKey } : {},
       ...config.timeout !== void 0 ? { timeout: config.timeout } : {},
       ...config.maxRetries !== void 0 ? { maxRetries: config.maxRetries } : {}
@@ -2478,19 +2573,19 @@ var SdkAdapter = class extends BaseAdapter {
 
 // src/adapters/auto-adapter.ts
 var defaultLogger = createLogger({ component: "auto-adapter" });
-function resolveCache(config, logger11) {
+function resolveCache(config, logger12) {
   if (config.cache !== void 0) {
     return config.cache;
   }
   const enableCache = config.enableCache ?? true;
-  return enableCache ? createCliDetectionCache({ logger: logger11 }) : void 0;
+  return enableCache ? createCliDetectionCache({ logger: logger12 }) : void 0;
 }
-async function tryCliAdapter(config, logger11, cache) {
+async function tryCliAdapter(config, logger12, cache) {
   const preferredCli = config.preferredCli;
   const bridgeConfig = config.defaultCliTimeoutMs !== void 0 ? { defaultTimeoutMs: config.defaultCliTimeoutMs } : void 0;
   if (preferredCli !== void 0 && await isCliAvailable(preferredCli, cache)) {
-    logger11.info("Using preferred CLI", { cli: preferredCli });
-    const cliAdapter2 = createCliAdapter({ cli: preferredCli, logger: logger11 });
+    logger12.info("Using preferred CLI", { cli: preferredCli });
+    const cliAdapter2 = createCliAdapter({ cli: preferredCli, logger: logger12 });
     await cliAdapter2.initialize();
     return {
       adapter: createCliToModelAdapter(cliAdapter2, bridgeConfig),
@@ -2502,15 +2597,15 @@ async function tryCliAdapter(config, logger11, cache) {
   }
   const availableClis = await getAvailableClis(cache);
   if (availableClis.length === 0) {
-    logger11.info("No CLI adapters available");
+    logger12.info("No CLI adapters available");
     return null;
   }
   const selectedCli = availableClis[0];
   if (selectedCli === void 0) {
     return null;
   }
-  logger11.info("Auto-selected CLI", { cli: selectedCli, available: availableClis });
-  const cliAdapter = createCliAdapter({ cli: selectedCli, logger: logger11 });
+  logger12.info("Auto-selected CLI", { cli: selectedCli, available: availableClis });
+  const cliAdapter = createCliAdapter({ cli: selectedCli, logger: logger12 });
   await cliAdapter.initialize();
   return {
     adapter: createCliToModelAdapter(cliAdapter, bridgeConfig),
@@ -2524,13 +2619,13 @@ function resolveApiKeyFromEnv(configKey, envVar) {
   const key = configKey ?? process.env[envVar];
   return key !== void 0 && key.length > 0 ? key : void 0;
 }
-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"]);
+function tryApiAdapter(config, logger12) {
+  const claudeModelId = getCliModelName(getDefaultModelForCli("claude"));
+  const codexModelId = getCliModelName(getDefaultModelForCli("codex"));
+  const geminiModelId = getCliModelName(getDefaultModelForCli("gemini"));
   const anthropicKey = resolveApiKeyFromEnv(config.anthropicApiKey, "ANTHROPIC_API_KEY");
   if (anthropicKey !== void 0) {
-    logger11.info("Using Anthropic API adapter", { model: claudeModelId });
+    logger12.info("Using Anthropic API adapter", { model: claudeModelId });
     return {
       adapter: createClaudeAdapter({ modelId: claudeModelId, apiKey: anthropicKey }),
       source: "api",
@@ -2540,7 +2635,7 @@ function tryApiAdapter(config, logger11) {
   }
   const openaiKey = resolveApiKeyFromEnv(config.openaiApiKey, "OPENAI_API_KEY");
   if (openaiKey !== void 0) {
-    logger11.info("Using OpenAI API adapter (AI SDK)", { model: codexModelId });
+    logger12.info("Using OpenAI API adapter (AI SDK)", { model: codexModelId });
     return {
       adapter: new SdkAdapter({ providerId: "openai", modelId: codexModelId, apiKey: openaiKey }),
       source: "api",
@@ -2550,7 +2645,7 @@ function tryApiAdapter(config, logger11) {
   }
   const googleKey = resolveApiKeyFromEnv(config.googleApiKey, "GOOGLE_AI_API_KEY");
   if (googleKey !== void 0) {
-    logger11.info("Using Google AI API adapter (AI SDK)", { model: geminiModelId });
+    logger12.info("Using Google AI API adapter (AI SDK)", { model: geminiModelId });
     return {
       adapter: new SdkAdapter({
         providerId: "google",
@@ -2562,19 +2657,19 @@ function tryApiAdapter(config, logger11) {
       reason: `Using Google AI API via AI SDK (model: ${geminiModelId})`
     };
   }
-  const custom = tryCustomOpenAiAdapter(logger11);
+  const custom = tryCustomOpenAiAdapter(logger12);
   if (custom !== null) return custom;
-  logger11.info("No API keys available for any provider");
+  logger12.info("No API keys available for any provider");
   return null;
 }
-function tryCustomOpenAiAdapter(logger11) {
+function tryCustomOpenAiAdapter(logger12) {
   const customKey = resolveApiKeyFromEnv(void 0, "NEXUS_CUSTOM_API_KEY");
   const customBaseUrl = process.env["NEXUS_CUSTOM_API_BASE_URL"];
   if (customKey === void 0 || customBaseUrl === void 0 || customBaseUrl === "") {
     return null;
   }
   const customModelId = process.env["NEXUS_CUSTOM_MODEL"] ?? CUSTOM_API_DEFAULT_MODEL;
-  logger11.info("Using custom-openai SDK adapter", {
+  logger12.info("Using custom-openai SDK adapter", {
     model: customModelId,
     baseUrl: customBaseUrl
   });
@@ -2590,52 +2685,52 @@ function tryCustomOpenAiAdapter(logger11) {
     reason: `Using custom OpenAI-compatible gateway at ${customBaseUrl} (model: ${customModelId})`
   };
 }
-async function selectCliFirst(config, logger11, cache) {
-  const cliResult = await tryCliAdapter(config, logger11, cache);
+async function selectCliFirst(config, logger12, cache) {
+  const cliResult = await tryCliAdapter(config, logger12, cache);
   if (cliResult !== null) return cliResult;
-  const apiResult = tryApiAdapter(config, logger11);
+  const apiResult = tryApiAdapter(config, logger12);
   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, logger11, cache) {
-  const apiResult = tryApiAdapter(config, logger11);
+async function selectApiFirst(config, logger12, cache) {
+  const apiResult = tryApiAdapter(config, logger12);
   if (apiResult !== null) return apiResult;
-  const cliResult = await tryCliAdapter(config, logger11, cache);
+  const cliResult = await tryCliAdapter(config, logger12, 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, logger11, cache) {
-  const cliResult = await tryCliAdapter(config, logger11, cache);
+async function selectCliOnly(config, logger12, cache) {
+  const cliResult = await tryCliAdapter(config, logger12, cache);
   if (cliResult !== null) return cliResult;
   throw new Error(
     "No CLI adapters available. Install and authenticate claude, gemini, or codex CLI."
   );
 }
-function selectApiOnly(config, logger11) {
-  const apiResult = tryApiAdapter(config, logger11);
+function selectApiOnly(config, logger12) {
+  const apiResult = tryApiAdapter(config, logger12);
   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 logger11 = config.logger ?? defaultLogger;
+  const logger12 = config.logger ?? defaultLogger;
   const priority = config.priority ?? "cli-first";
-  const cache = resolveCache(config, logger11);
-  logger11.info("Auto-selecting adapter", { priority, cacheEnabled: cache !== void 0 });
+  const cache = resolveCache(config, logger12);
+  logger12.info("Auto-selecting adapter", { priority, cacheEnabled: cache !== void 0 });
   switch (priority) {
     case "cli-first":
-      return selectCliFirst(config, logger11, cache);
+      return selectCliFirst(config, logger12, cache);
     case "api-first":
-      return selectApiFirst(config, logger11, cache);
+      return selectApiFirst(config, logger12, cache);
     case "cli-only":
-      return selectCliOnly(config, logger11, cache);
+      return selectCliOnly(config, logger12, cache);
     case "api-only":
-      return selectApiOnly(config, logger11);
+      return selectApiOnly(config, logger12);
     default: {
       const exhaustive = priority;
       throw new Error(`Unknown priority: ${String(exhaustive)}`);
@@ -3317,10 +3412,172 @@ function mapSelectionSource(selection) {
   return "api";
 }
 
+// src/adapters/model-not-found-fallback.ts
+var logger = createLogger({ component: "model-not-found-fallback" });
+function withModelNotFoundFallback(inner, options = {}) {
+  const registry = options.registry ?? getDefaultRegistry();
+  const cache = options.cache ?? getDefaultAvailableModelsCache();
+  const resolvedOptions = {
+    cache,
+    registry,
+    adapterFactory: options.adapterFactory,
+    onRetirement: options.onRetirement
+  };
+  const wrapped = {
+    providerId: inner.providerId,
+    modelId: inner.modelId,
+    capabilities: inner.capabilities,
+    countTokens: (text) => inner.countTokens(text),
+    validateConfig: () => inner.validateConfig(),
+    stream: (request) => streamWithFallback(inner, request, resolvedOptions),
+    complete: (request) => completeWithFallback(inner, request, resolvedOptions)
+  };
+  if (typeof inner.listModels === "function") {
+    const list = inner.listModels.bind(inner);
+    wrapped.listModels = () => list();
+  }
+  return wrapped;
+}
+async function completeWithFallback(inner, request, options) {
+  const first = await inner.complete(request);
+  if (first.ok) return first;
+  if (first.error.code !== ErrorCode.MODEL_NOT_FOUND) return first;
+  const fallback = await pickFallback(inner.modelId, options.cache, options.registry);
+  if (fallback === null) {
+    logger.warn("Model not found and no fallback available", {
+      modelId: inner.modelId,
+      providerId: inner.providerId,
+      errorMessage: first.error.message
+    });
+    return first;
+  }
+  logger.info("Model retirement detected; retrying with fallback", {
+    retiredModelId: inner.modelId,
+    fallbackModelId: fallback,
+    providerId: inner.providerId
+  });
+  notifyRetirement(options.onRetirement, {
+    retiredModelId: inner.modelId,
+    fallbackModelId: fallback,
+    providerId: inner.providerId,
+    errorMessage: first.error.message
+  });
+  if (options.adapterFactory === void 0) {
+    return err(
+      new ModelError(`${first.error.message} \u2014 suggested fallback: ${fallback}`, {
+        code: ErrorCode.MODEL_NOT_FOUND,
+        cause: first.error
+      })
+    );
+  }
+  const fallbackAdapter = options.adapterFactory(fallback);
+  const retried = await fallbackAdapter.complete(request);
+  if (retried.ok) return retried;
+  return err(
+    new ModelError(`Fallback ${fallback} also failed: ${retried.error.message}`, {
+      code: retried.error.code,
+      cause: retried.error
+    })
+  );
+}
+async function* streamWithFallback(inner, request, options) {
+  try {
+    for await (const chunk of inner.stream(request)) {
+      yield chunk;
+    }
+    return;
+  } catch (e) {
+    if (!isModelNotFoundError(e)) throw e;
+    const fallbackAdapter = await resolveStreamFallback(inner, e, options);
+    for await (const chunk of fallbackAdapter.stream(request)) {
+      yield chunk;
+    }
+  }
+}
+async function resolveStreamFallback(inner, cause, options) {
+  const fallback = await pickFallback(inner.modelId, options.cache, options.registry);
+  if (fallback === null) {
+    logger.warn("Stream model not found and no fallback available", {
+      modelId: inner.modelId,
+      providerId: inner.providerId,
+      errorMessage: cause instanceof Error ? cause.message : String(cause)
+    });
+    throw cause;
+  }
+  logger.info("Stream retirement detected; restarting with fallback (restart-from-zero)", {
+    retiredModelId: inner.modelId,
+    fallbackModelId: fallback,
+    providerId: inner.providerId
+  });
+  notifyRetirement(options.onRetirement, {
+    retiredModelId: inner.modelId,
+    fallbackModelId: fallback,
+    providerId: inner.providerId,
+    errorMessage: cause instanceof Error ? cause.message : String(cause)
+  });
+  if (options.adapterFactory === void 0) {
+    const message = `${cause instanceof Error ? cause.message : String(cause)} \u2014 suggested fallback: ${fallback}`;
+    const causeErr = cause instanceof Error ? cause : void 0;
+    throw new ModelError(
+      message,
+      causeErr !== void 0 ? { code: ErrorCode.MODEL_NOT_FOUND, cause: causeErr } : { code: ErrorCode.MODEL_NOT_FOUND }
+    );
+  }
+  return options.adapterFactory(fallback);
+}
+function isModelNotFoundError(e) {
+  if (e instanceof ModelError) {
+    return e.code === ErrorCode.MODEL_NOT_FOUND;
+  }
+  if (typeof e === "object" && e !== null && "code" in e) {
+    return e.code === ErrorCode.MODEL_NOT_FOUND;
+  }
+  return false;
+}
+function notifyRetirement(cb, info) {
+  if (cb === void 0) return;
+  try {
+    cb(info);
+  } catch (e) {
+    logger.debug("onRetirement callback threw", {
+      error: e instanceof Error ? e.message : String(e)
+    });
+  }
+}
+async function pickFallback(retiredModelId, cache, registry) {
+  const refreshed = await cache.refresh();
+  if (refreshed.length === 0) return null;
+  const target = registry.getEntry(retiredModelId);
+  const sameFamily = refreshed.find((m) => {
+    if (m.id === retiredModelId) return false;
+    const candidate = registry.getEntry(m.id);
+    return candidate.family === target.family && candidate.vendor === target.vendor;
+  });
+  if (sameFamily !== void 0) return sameFamily.id;
+  const sameVendor = refreshed.find((m) => {
+    if (m.id === retiredModelId) return false;
+    const candidate = registry.getEntry(m.id);
+    return candidate.vendor === target.vendor;
+  });
+  return sameVendor?.id ?? null;
+}
+function wrapResilientWithFallback(inner, options = {}) {
+  const wrapped = withModelNotFoundFallback(inner, options);
+  return Object.assign(wrapped, {
+    getHealth: inner.getHealth.bind(inner),
+    refresh: inner.refresh.bind(inner),
+    setPreferredCli: inner.setPreferredCli.bind(inner),
+    onFailover: inner.onFailover.bind(inner),
+    dispose: inner.dispose.bind(inner)
+  });
+}
+
 // src/adapters/unified-registry.ts
 var UnifiedAdapterRegistry = class {
   logger;
   defaultCliTimeoutMs;
+  enableMissingModelFallback;
+  missingModelFallbackOptions;
   /** Pre-computed task → CLI routing (immutable after construction). */
   taskRouting;
   /** Per-CLI adapter cache — max 3 entries (claude/gemini/codex). */
@@ -3330,12 +3587,26 @@ var UnifiedAdapterRegistry = class {
   constructor(config) {
     this.logger = config?.logger ?? createLogger({ component: "unified-registry" });
     this.defaultCliTimeoutMs = config?.defaultCliTimeoutMs;
+    this.enableMissingModelFallback = config?.enableMissingModelFallback ?? false;
+    this.missingModelFallbackOptions = config?.missingModelFallbackOptions;
     this.taskRouting = this.buildTaskRouting();
     this.logger.info("UnifiedAdapterRegistry initialized", {
       categories: this.taskRouting.size,
-      models: DEFAULT_MODEL_CAPABILITIES.models.length
+      models: getInTreeCapabilitiesMatrix().models.length,
+      missingModelFallback: this.enableMissingModelFallback
     });
   }
+  /**
+   * Apply the MODEL_NOT_FOUND fallback decorator if enabled, otherwise
+   * return the adapter unchanged. The recursion guard from the original
+   * issue is unnecessary here: the decorator's retry path uses the
+   * caller-supplied `adapterFactory`; without one, it surfaces an
+   * enriched error and never re-enters the resilient layer.
+   */
+  maybeWrap(adapter) {
+    if (!this.enableMissingModelFallback) return adapter;
+    return wrapResilientWithFallback(adapter, this.missingModelFallbackOptions);
+  }
   // --------------------------------------------------------------------------
   // Public API
   // --------------------------------------------------------------------------
@@ -3377,15 +3648,19 @@ var UnifiedAdapterRegistry = class {
   getAdapterForCli(cli) {
     const cached = this.cliAdapters.get(cli);
     if (cached !== void 0) return cached;
-    const adapter = createResilientAdapter({
+    const raw = createResilientAdapter({
       logger: this.logger,
       preferredCli: cli,
       ...this.defaultCliTimeoutMs !== void 0 && {
         defaultCliTimeoutMs: this.defaultCliTimeoutMs
       }
     });
+    const adapter = this.maybeWrap(raw);
     this.cliAdapters.set(cli, adapter);
-    this.logger.info("Created CLI-specific adapter", { cli });
+    this.logger.info("Created CLI-specific adapter", {
+      cli,
+      missingModelFallback: this.enableMissingModelFallback
+    });
     return adapter;
   }
   /**
@@ -3394,10 +3669,11 @@ var UnifiedAdapterRegistry = class {
    * Falls back to default adapter if model not recognized.
    */
   getAdapterForModel(modelPreference) {
-    const exact = DEFAULT_MODEL_CAPABILITIES.models.find(
+    const allModels = getInTreeCapabilitiesMatrix().models;
+    const exact = allModels.find(
       (m) => m.id === modelPreference || m.cliAlias === modelPreference || m.cliModelName === modelPreference
     );
-    const prefix = exact ?? [...DEFAULT_MODEL_CAPABILITIES.models].filter((m) => modelPreference.startsWith(m.id)).sort((a, b) => b.id.length - a.id.length)[0];
+    const prefix = exact ?? [...allModels].filter((m) => modelPreference.startsWith(m.id)).sort((a, b) => b.id.length - a.id.length)[0];
     const model = prefix;
     if (model !== void 0) {
       this.logger.debug("Model resolved to CLI", {
@@ -3425,12 +3701,13 @@ var UnifiedAdapterRegistry = class {
    */
   getDefault() {
     if (this.defaultAdapter !== void 0) return this.defaultAdapter;
-    this.defaultAdapter = createResilientAdapter({
+    const raw = createResilientAdapter({
       logger: this.logger,
       ...this.defaultCliTimeoutMs !== void 0 && {
         defaultCliTimeoutMs: this.defaultCliTimeoutMs
       }
     });
+    this.defaultAdapter = this.maybeWrap(raw);
     return this.defaultAdapter;
   }
   /**
@@ -3440,7 +3717,7 @@ var UnifiedAdapterRegistry = class {
     return {
       taskRouting: [...this.taskRouting.values()],
       cachedAdapters: [...this.cliAdapters.keys()],
-      availableModels: DEFAULT_MODEL_CAPABILITIES.models.length
+      availableModels: getInTreeCapabilitiesMatrix().models.length
     };
   }
   /**
@@ -3491,8 +3768,8 @@ var ROLE_TO_CATEGORY = {
   infrastructure_expert: "devops"
 };
 function resolveDefaultModel(cli) {
-  if (cli in DEFAULT_MODEL_PER_CLI) {
-    return DEFAULT_MODEL_PER_CLI[cli];
+  if (CLI_NAMES.includes(cli)) {
+    return getDefaultModelForCli(cli);
   }
   return cli;
 }
@@ -3725,7 +4002,7 @@ var SIMULATED_VOTE_REASONING = {
 };
 
 // src/cli/voter-response.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var SyntheticVoteError = class extends Error {
   constructor(reason, rawOutput) {
     super(
@@ -3735,26 +4012,26 @@ var SyntheticVoteError = class extends Error {
     this.name = "SyntheticVoteError";
   }
 };
-var RawFindingSchema = z2.object({
-  summary: z2.string().min(1).max(500).describe("One-line summary of the issue"),
-  location: z2.string().min(1).max(200).describe("path/file.ext:line"),
-  severity: z2.enum(["critical", "high", "medium", "low"]).default("medium"),
-  gate: z2.object({
-    reread_cited_line: z2.enum(["passed", "failed", "skipped"]).default("skipped"),
-    traced_call_path: z2.enum(["passed", "failed", "skipped"]).default("skipped"),
-    named_assertion: z2.string().default("").describe("Concrete failing assertion \u2014 substantive, not a rubber-stamp word"),
-    ruled_out_language_non_issue: z2.enum(["passed", "failed", "skipped"]).default("skipped")
+var RawFindingSchema = z3.object({
+  summary: z3.string().min(1).max(500).describe("One-line summary of the issue"),
+  location: z3.string().min(1).max(200).describe("path/file.ext:line"),
+  severity: z3.enum(["critical", "high", "medium", "low"]).default("medium"),
+  gate: z3.object({
+    reread_cited_line: z3.enum(["passed", "failed", "skipped"]).default("skipped"),
+    traced_call_path: z3.enum(["passed", "failed", "skipped"]).default("skipped"),
+    named_assertion: z3.string().default("").describe("Concrete failing assertion \u2014 substantive, not a rubber-stamp word"),
+    ruled_out_language_non_issue: z3.enum(["passed", "failed", "skipped"]).default("skipped")
   }),
-  claim: z2.string().min(1).max(2e3).describe("What is wrong and why it justifies blocking")
+  claim: z3.string().min(1).max(2e3).describe("What is wrong and why it justifies blocking")
 });
-var VoteResponseSchema = z2.object({
-  decision: z2.enum(["approve", "reject", "abstain"]).describe("Your vote decision"),
-  reasoning: z2.string().min(10).max(4e3).describe("Explanation for your vote (10-4000 chars)"),
-  confidence: z2.number().min(0).max(1).describe("Confidence level 0-1"),
-  conditions: z2.array(z2.string()).optional().describe("Optional conditions for approval"),
+var VoteResponseSchema = z3.object({
+  decision: z3.enum(["approve", "reject", "abstain"]).describe("Your vote decision"),
+  reasoning: z3.string().min(10).max(4e3).describe("Explanation for your vote (10-4000 chars)"),
+  confidence: z3.number().min(0).max(1).describe("Confidence level 0-1"),
+  conditions: z3.array(z3.string()).optional().describe("Optional conditions for approval"),
   /** Structured rejection categories for reject→refine→re-vote loops (Issue #1213). */
-  rejectionCategories: z2.array(
-    z2.enum([
+  rejectionCategories: z3.array(
+    z3.enum([
       "YAGNI",
       "DRY_VIOLATION",
       "OVER_ENGINEERING",
@@ -3766,7 +4043,7 @@ var VoteResponseSchema = z2.object({
   ).optional().describe("Rejection reason categories when decision is reject"),
   /** Top-level structured findings for PR-review mode (#2245 v4 follow-up).
    * Replaces the YAML-in-reasoning encoding that proved lossy. */
-  findings: z2.array(RawFindingSchema).optional().describe("Structured findings (PR review only)")
+  findings: z3.array(RawFindingSchema).optional().describe("Structured findings (PR review only)")
 });
 var VOTE_PROMPT_EXAMPLES = `Example approve response:
 {
@@ -3904,7 +4181,6 @@ var RATE_LIMIT_RETRY_DELAY_MS = 5e3;
 function isRateLimitError(message) {
   return isRateLimitLikeError(new Error(message));
 }
-var validateTimeout2 = validateTimeout;
 function createErrorVoteResult(role, errorMsg, processingTimeMs) {
   return {
     role,
@@ -4031,21 +4307,21 @@ async function executeSingleVoteAttempt(role, proposal, adapter, timeoutMs) {
   }
 }
 async function executeWithRetries(opts) {
-  const { role, proposal, adapter, logger: logger11, timeoutMs, maxRetries } = opts;
+  const { role, proposal, adapter, logger: logger12, 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);
-      logger11.debug("Retrying vote execution", { role, attempt, delayMs, isRateLimit });
+      logger12.debug("Retrying vote execution", { role, attempt, delayMs, isRateLimit });
       await delay(delayMs);
     }
     const attemptStart = Date.now();
     const result = await executeSingleVoteAttempt(role, proposal, adapter, timeoutMs);
     const attemptMs = Date.now() - attemptStart;
     if (result.ok) {
-      logger11.info("Vote attempt timing", {
+      logger12.info("Vote attempt timing", {
         role,
         attempt: attempt + 1,
         attemptMs,
@@ -4055,14 +4331,14 @@ async function executeWithRetries(opts) {
     }
     lastError = result.error;
     const rateLimited = isRateLimitError(lastError);
-    logger11.info("Vote attempt timing", {
+    logger12.info("Vote attempt timing", {
       role,
       attempt: attempt + 1,
       attemptMs,
       succeeded: false,
       rateLimited
     });
-    logger11.warn("Vote attempt failed", {
+    logger12.warn("Vote attempt failed", {
       role,
       attempt: attempt + 1,
       maxRetries: maxRetries + 1,
@@ -4092,7 +4368,7 @@ async function launchVotesWithOverallDeadline(input) {
     proposal,
     roleAdapters,
     fallbackAdapter,
-    logger: logger11,
+    logger: logger12,
     voteOptions,
     interDelay,
     overallDeadlineMs,
@@ -4104,12 +4380,12 @@ async function launchVotesWithOverallDeadline(input) {
     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);
+    return raceWithDeadline(voteFn(role, proposal, adapter, logger12, 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", {
+    logger12.warn("Consensus overall deadline reached; returning partial results", {
       totalRoles: roles.length,
       expiredRoles: expired.map((r) => r.role),
       overallDeadlineMs
@@ -4122,36 +4398,36 @@ async function launchVotesWithOverallDeadline(input) {
 function computeOverallConsensusDeadlineMs(timeoutMs, maxRetries, roleCount, interDelayMs) {
   const perVoteBudget = timeoutMs * (maxRetries + 1);
   const staggerBudget = Math.max(0, roleCount - 1) * interDelayMs;
-  return perVoteBudget + staggerBudget + 6e4;
+  return perVoteBudget + staggerBudget + VOTE_TIMEOUTS.overallDeadlineBufferMs;
 }
 var DEFAULT_INTER_AGENT_DELAY_MS = 2e3;
 var defaultLogger2 = createLogger({ component: "voter-agents" });
-async function executeAgentVote(role, proposal, adapter, logger11, options) {
+async function executeAgentVote(role, proposal, adapter, logger12, options) {
   const start = getTimeProvider().now();
   const timeoutMs = options?.timeoutMs ?? resolveVoteTimeout();
   const maxRetries = options?.maxRetries ?? VOTE_TIMEOUTS.maxRetries;
   const allowSimulation = options?.allowSimulation ?? false;
-  logger11.info("Executing vote", { role, model: adapter.modelId, provider: adapter.providerId });
+  logger12.info("Executing vote", { role, model: adapter.modelId, provider: adapter.providerId });
   const result = await executeWithRetries({
     role,
     proposal,
     adapter,
-    logger: logger11,
+    logger: logger12,
     timeoutMs,
     maxRetries
   });
   const processingTimeMs = getTimeProvider().now() - start;
   if (result.ok) {
-    logger11.info("Vote completed", { role, model: adapter.modelId, decision: result.vote.decision });
+    logger12.info("Vote completed", { role, model: adapter.modelId, decision: result.vote.decision });
     return { role, vote: result.vote, processingTimeMs, source: "llm", cli: adapter.providerId };
   }
-  logger11.error("Vote execution failed after all retries", void 0, {
+  logger12.error("Vote execution failed after all retries", void 0, {
     role,
     model: adapter.modelId,
     errorMessage: result.error
   });
   if (allowSimulation) {
-    logger11.warn("Falling back to simulation (allowSimulation=true)", { role });
+    logger12.warn("Falling back to simulation (allowSimulation=true)", { role });
     return createSimulationVoteResult(role, proposal, processingTimeMs, result.error);
   }
   return createErrorVoteResult(role, result.error, processingTimeMs);
@@ -4162,10 +4438,10 @@ var NoAdapterError = class extends Error {
     this.name = "NoAdapterError";
   }
 };
-function resolveAdapter(options, logger11) {
+function resolveAdapter(options, logger12) {
   try {
     if (options.adapter !== void 0) return { adapter: options.adapter };
-    const registry = getGlobalRegistry({ logger: logger11 });
+    const registry = getGlobalRegistry({ logger: logger12 });
     return { adapter: registry.getDefault() };
   } catch (error) {
     return { error: getErrorMessage(error) };
@@ -4176,29 +4452,29 @@ function assignUniformAdapter(roles, adapter) {
   for (const role of roles) adapters.set(role, adapter);
   return adapters;
 }
-function createCliAdapterMap(clis, logger11) {
-  const registry = getGlobalRegistry({ logger: logger11 });
+function createCliAdapterMap(clis, logger12) {
+  const registry = getGlobalRegistry({ logger: logger12 });
   const result = /* @__PURE__ */ new Map();
   for (const cli of clis) {
     result.set(cli, registry.getAdapterForCli(cli));
   }
   return result;
 }
-async function resolveDiverseAdapters(roles, logger11, fallbackAdapter) {
+async function resolveDiverseAdapters(roles, logger12, fallbackAdapter) {
   let availableClis;
   try {
     availableClis = await getAvailableClis();
   } catch (e) {
-    logger11.warn("Failed to resolve available CLIs; falling back to single adapter", {
+    logger12.warn("Failed to resolve available CLIs; falling back to single adapter", {
       error: String(e)
     });
     availableClis = [];
   }
   if (availableClis.length <= 1) {
-    logger11.info("Using single adapter for all roles", { cliCount: availableClis.length });
+    logger12.info("Using single adapter for all roles", { cliCount: availableClis.length });
     return assignUniformAdapter(roles, fallbackAdapter);
   }
-  const cliAdapters = createCliAdapterMap(availableClis, logger11);
+  const cliAdapters = createCliAdapterMap(availableClis, logger12);
   if (cliAdapters.size <= 1) return assignUniformAdapter(roles, fallbackAdapter);
   const cliList = [...cliAdapters.entries()];
   const adapters = /* @__PURE__ */ new Map();
@@ -4210,7 +4486,7 @@ async function resolveDiverseAdapters(roles, logger11, fallbackAdapter) {
     adapters.set(role, entry[1]);
     assignments[role] = entry[0];
   }
-  logger11.info("Diverse adapters assigned", {
+  logger12.info("Diverse adapters assigned", {
     cliCount: cliAdapters.size,
     clis: [...cliAdapters.keys()],
     roleAssignments: assignments
@@ -4218,7 +4494,7 @@ async function resolveDiverseAdapters(roles, logger11, fallbackAdapter) {
   return adapters;
 }
 async function launchStaggeredVotes(input) {
-  const { roles, proposal, roleAdapters, fallbackAdapter, logger: logger11, voteOptions, interDelay } = input;
+  const { roles, proposal, roleAdapters, fallbackAdapter, logger: logger12, voteOptions, interDelay } = input;
   const computedDeadlineMs = computeOverallConsensusDeadlineMs(
     voteOptions.timeoutMs,
     voteOptions.maxRetries,
@@ -4227,7 +4503,7 @@ async function launchStaggeredVotes(input) {
   );
   const overallDeadlineMs = getMcpSafeDeadlineMs(computedDeadlineMs, "consensus_vote");
   if (overallDeadlineMs < computedDeadlineMs) {
-    logger11.debug("Consensus deadline clamped to MCP wrapper timeout", {
+    logger12.debug("Consensus deadline clamped to MCP wrapper timeout", {
       computedDeadlineMs,
       overallDeadlineMs
     });
@@ -4237,7 +4513,7 @@ async function launchStaggeredVotes(input) {
     proposal,
     roleAdapters,
     fallbackAdapter,
-    logger: logger11,
+    logger: logger12,
     voteOptions,
     interDelay,
     overallDeadlineMs,
@@ -4245,26 +4521,26 @@ async function launchStaggeredVotes(input) {
   });
 }
 async function collectRealVotes(options) {
-  const logger11 = options.logger ?? defaultLogger2;
+  const logger12 = options.logger ?? defaultLogger2;
   const { roles, proposal, simulate, allowSimulation } = options;
   const timeoutMs = options.timeoutMs ?? resolveVoteTimeout();
   const maxRetries = options.maxRetries ?? VOTE_TIMEOUTS.maxRetries;
   if (simulate === true) {
-    logger11.info("Using simulation mode (explicitly requested)");
+    logger12.info("Using simulation mode (explicitly requested)");
     return createSimulatedVotes(roles, proposal);
   }
-  const adapterResult = resolveAdapter(options, logger11);
+  const adapterResult = resolveAdapter(options, logger12);
   if ("error" in adapterResult) {
-    logger11.error("No adapter available for voting", void 0, { error: adapterResult.error });
+    logger12.error("No adapter available for voting", void 0, { error: adapterResult.error });
     if (allowSimulation === true) {
-      logger11.warn("Falling back to simulation (allowSimulation=true)");
+      logger12.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, logger11, adapterResult.adapter);
+  const roleAdapters = options.adapter !== void 0 ? assignUniformAdapter(roles, adapterResult.adapter) : await resolveDiverseAdapters(roles, logger12, adapterResult.adapter);
   const voteOptions = { timeoutMs, maxRetries, allowSimulation: allowSimulation ?? false };
   const interDelay = options.interAgentDelayMs ?? DEFAULT_INTER_AGENT_DELAY_MS;
   return launchStaggeredVotes({
@@ -4272,15 +4548,15 @@ async function collectRealVotes(options) {
     proposal,
     roleAdapters,
     fallbackAdapter: adapterResult.adapter,
-    logger: logger11,
+    logger: logger12,
     voteOptions,
     interDelay
   });
 }
 
 // src/consensus/types-core.ts
-import { z as z3 } from "zod";
-var ConsensusAlgorithmSchema = z3.enum([
+import { z as z4 } from "zod";
+var ConsensusAlgorithmSchema = z4.enum([
   "simple_majority",
   "supermajority",
   "unanimous",
@@ -4288,8 +4564,8 @@ var ConsensusAlgorithmSchema = z3.enum([
   "opinion_wise",
   "higher_order"
 ]);
-var VoteDecisionSchema = z3.enum(["approve", "reject", "abstain"]);
-var ProposalStatusSchema = z3.enum([
+var VoteDecisionSchema = z4.enum(["approve", "reject", "abstain"]);
+var ProposalStatusSchema = z4.enum([
   "pending",
   "voting",
   "approved",
@@ -4297,7 +4573,7 @@ var ProposalStatusSchema = z3.enum([
   "timeout",
   "closed"
 ]);
-var RejectionCategorySchema = z3.enum([
+var RejectionCategorySchema = z4.enum([
   "YAGNI",
   "DRY_VIOLATION",
   "OVER_ENGINEERING",
@@ -4307,69 +4583,69 @@ var RejectionCategorySchema = z3.enum([
   "INSUFFICIENT_EVIDENCE"
 ]);
 var REJECTION_CATEGORIES = RejectionCategorySchema.options;
-var FindingShapeSchema = z3.object({
-  summary: z3.string().min(1).max(500),
-  location: z3.string().min(1).max(200),
-  severity: z3.enum(["critical", "high", "medium", "low"]).default("medium"),
-  gate: z3.object({
-    reread_cited_line: z3.enum(["passed", "failed", "skipped"]).default("skipped"),
-    traced_call_path: z3.enum(["passed", "failed", "skipped"]).default("skipped"),
-    named_assertion: z3.string().default(""),
-    ruled_out_language_non_issue: z3.enum(["passed", "failed", "skipped"]).default("skipped")
+var FindingShapeSchema = z4.object({
+  summary: z4.string().min(1).max(500),
+  location: z4.string().min(1).max(200),
+  severity: z4.enum(["critical", "high", "medium", "low"]).default("medium"),
+  gate: z4.object({
+    reread_cited_line: z4.enum(["passed", "failed", "skipped"]).default("skipped"),
+    traced_call_path: z4.enum(["passed", "failed", "skipped"]).default("skipped"),
+    named_assertion: z4.string().default(""),
+    ruled_out_language_non_issue: z4.enum(["passed", "failed", "skipped"]).default("skipped")
   }),
-  claim: z3.string().min(1).max(2e3)
+  claim: z4.string().min(1).max(2e3)
 });
-var VoteSchema = z3.object({
+var VoteSchema = z4.object({
   decision: VoteDecisionSchema,
-  reasoning: z3.string().min(1).describe("Explanation for the vote"),
-  confidence: z3.number().min(0).max(1).describe("Confidence level 0-1"),
-  conditions: z3.array(z3.string()).optional().describe("Conditions for approval"),
+  reasoning: z4.string().min(1).describe("Explanation for the vote"),
+  confidence: z4.number().min(0).max(1).describe("Confidence level 0-1"),
+  conditions: z4.array(z4.string()).optional().describe("Conditions for approval"),
   /** Structured rejection categories for reject→refine→re-vote loops (Issue #1213). */
-  rejectionCategories: z3.array(RejectionCategorySchema).optional().describe("Rejection reason categories when decision is reject"),
+  rejectionCategories: z4.array(RejectionCategorySchema).optional().describe("Rejection reason categories when decision is reject"),
   /** Pre-verified PR-review findings (#2245 v4 follow-up). Optional;
    * populated only when the voter emits the structured top-level array. */
-  findings: z3.array(FindingShapeSchema).optional().describe("PR-review findings (pre-verified)"),
-  timestamp: z3.iso.datetime().optional()
+  findings: z4.array(FindingShapeSchema).optional().describe("PR-review findings (pre-verified)"),
+  timestamp: z4.iso.datetime().optional()
 });
-var ProposalSchema = z3.object({
-  id: z3.string().optional().describe("Auto-generated if not provided"),
-  title: z3.string().min(1).max(200).describe("Short proposal title"),
-  description: z3.string().min(1).describe("Detailed proposal description"),
+var ProposalSchema = z4.object({
+  id: z4.string().optional().describe("Auto-generated if not provided"),
+  title: z4.string().min(1).max(200).describe("Short proposal title"),
+  description: z4.string().min(1).describe("Detailed proposal description"),
   algorithm: ConsensusAlgorithmSchema,
-  timeout: z3.number().int().positive().optional().describe("Timeout in milliseconds"),
-  requiredVoters: z3.array(z3.string()).optional().describe("Agent IDs that must vote"),
-  metadata: z3.record(z3.string(), z3.unknown()).optional().describe("Additional context"),
-  createdAt: z3.iso.datetime().optional()
+  timeout: z4.number().int().positive().optional().describe("Timeout in milliseconds"),
+  requiredVoters: z4.array(z4.string()).optional().describe("Agent IDs that must vote"),
+  metadata: z4.record(z4.string(), z4.unknown()).optional().describe("Additional context"),
+  createdAt: z4.iso.datetime().optional()
 });
-var ConsensusResultSchema = z3.object({
-  proposalId: z3.string(),
+var ConsensusResultSchema = z4.object({
+  proposalId: z4.string(),
   proposal: ProposalSchema,
   outcome: ProposalStatusSchema,
-  votes: z3.map(z3.string(), VoteSchema),
-  voteCounts: z3.object({
-    approve: z3.number().int().nonnegative(),
-    reject: z3.number().int().nonnegative(),
-    abstain: z3.number().int().nonnegative(),
-    total: z3.number().int().nonnegative()
+  votes: z4.map(z4.string(), VoteSchema),
+  voteCounts: z4.object({
+    approve: z4.number().int().nonnegative(),
+    reject: z4.number().int().nonnegative(),
+    abstain: z4.number().int().nonnegative(),
+    total: z4.number().int().nonnegative()
   }),
-  weightedCounts: z3.object({
-    approve: z3.number().nonnegative(),
-    reject: z3.number().nonnegative(),
-    abstain: z3.number().nonnegative(),
-    totalWeight: z3.number().nonnegative()
+  weightedCounts: z4.object({
+    approve: z4.number().nonnegative(),
+    reject: z4.number().nonnegative(),
+    abstain: z4.number().nonnegative(),
+    totalWeight: z4.number().nonnegative()
   }).optional(),
-  approvalPercentage: z3.number().min(0).max(100),
-  quorumReached: z3.boolean(),
-  startedAt: z3.iso.datetime(),
-  closedAt: z3.iso.datetime(),
-  durationMs: z3.number().int().nonnegative()
+  approvalPercentage: z4.number().min(0).max(100),
+  quorumReached: z4.boolean(),
+  startedAt: z4.iso.datetime(),
+  closedAt: z4.iso.datetime(),
+  durationMs: z4.number().int().nonnegative()
 });
-var AgentPerformanceSchema = z3.object({
-  agentId: z3.string(),
-  totalVotes: z3.number().int().nonnegative(),
-  correctVotes: z3.number().int().nonnegative(),
-  successRate: z3.number().min(0).max(1),
-  lastUpdated: z3.iso.datetime()
+var AgentPerformanceSchema = z4.object({
+  agentId: z4.string(),
+  totalVotes: z4.number().int().nonnegative(),
+  correctVotes: z4.number().int().nonnegative(),
+  successRate: z4.number().min(0).max(1),
+  lastUpdated: z4.iso.datetime()
 });
 var DEFAULT_INCREMENTAL_QUORUM_CONFIG = {
   enabled: false,
@@ -4378,19 +4654,19 @@ var DEFAULT_INCREMENTAL_QUORUM_CONFIG = {
   confidenceThreshold: 0.6,
   ambiguityBand: 0.15
 };
-var ProposalCacheConfigSchema = z3.object({
-  enabled: z3.boolean().default(false),
-  ttlMs: z3.number().int().positive().default(36e5),
+var ProposalCacheConfigSchema = z4.object({
+  enabled: z4.boolean().default(false),
+  ttlMs: z4.number().int().positive().default(36e5),
   // 1 hour
-  maxEntries: z3.number().int().positive().default(500)
+  maxEntries: z4.number().int().positive().default(500)
 });
-var ConsensusEngineConfigSchema = z3.object({
-  defaultTimeout: z3.number().int().positive().default(3e5),
+var ConsensusEngineConfigSchema = z4.object({
+  defaultTimeout: z4.number().int().positive().default(3e5),
   // 5 minutes
-  minVotersForQuorum: z3.number().int().positive().default(2),
-  maxActiveProposals: z3.number().int().positive().default(100),
-  enablePerformanceTracking: z3.boolean().default(true),
-  maxClosedProposals: z3.number().int().positive().default(1e3),
+  minVotersForQuorum: z4.number().int().positive().default(2),
+  maxActiveProposals: z4.number().int().positive().default(100),
+  enablePerformanceTracking: z4.boolean().default(true),
+  maxClosedProposals: z4.number().int().positive().default(1e3),
   // Issue #549
   proposalCache: ProposalCacheConfigSchema.optional()
   // Issue #589
@@ -4415,50 +4691,50 @@ var VOTING_THRESHOLDS = {
   higher_order: 0.5
   // Alias for opinion_wise (Issue #514)
 };
-var ConsensusMetricsSchema = z3.object({
-  totalProposals: z3.number().int().nonnegative(),
-  approvedProposals: z3.number().int().nonnegative(),
-  rejectedProposals: z3.number().int().nonnegative(),
-  timedOutProposals: z3.number().int().nonnegative(),
-  averageDurationMs: z3.number().nonnegative(),
-  averageVotesPerProposal: z3.number().nonnegative(),
-  algorithmUsage: z3.record(ConsensusAlgorithmSchema, z3.number().int().nonnegative())
+var ConsensusMetricsSchema = z4.object({
+  totalProposals: z4.number().int().nonnegative(),
+  approvedProposals: z4.number().int().nonnegative(),
+  rejectedProposals: z4.number().int().nonnegative(),
+  timedOutProposals: z4.number().int().nonnegative(),
+  averageDurationMs: z4.number().nonnegative(),
+  averageVotesPerProposal: z4.number().nonnegative(),
+  algorithmUsage: z4.record(ConsensusAlgorithmSchema, z4.number().int().nonnegative())
 });
 
 // src/consensus/types-voting-protocol.ts
-import { z as z4 } from "zod";
-var VotingRoundPhaseSchema = z4.enum(["analysis", "deliberation", "consensus"]);
-var VotingRoundStatusSchema = z4.enum([
+import { z as z5 } from "zod";
+var VotingRoundPhaseSchema = z5.enum(["analysis", "deliberation", "consensus"]);
+var VotingRoundStatusSchema = z5.enum([
   "pending",
   "in_progress",
   "awaiting_votes",
   "completed",
   "aborted"
 ]);
-var AgentFindingSchema = z4.object({
-  agentId: z4.string(),
-  category: z4.enum(["bug", "security", "performance", "style", "design", "documentation", "other"]),
-  severity: z4.enum(["critical", "major", "minor", "suggestion"]),
-  description: z4.string().min(1),
-  location: z4.string().optional().describe("File path and line range if applicable"),
-  suggestion: z4.string().optional().describe("Recommended fix"),
-  confidence: z4.number().min(0).max(1),
-  timestamp: z4.iso.datetime().optional()
+var AgentFindingSchema = z5.object({
+  agentId: z5.string(),
+  category: z5.enum(["bug", "security", "performance", "style", "design", "documentation", "other"]),
+  severity: z5.enum(["critical", "major", "minor", "suggestion"]),
+  description: z5.string().min(1),
+  location: z5.string().optional().describe("File path and line range if applicable"),
+  suggestion: z5.string().optional().describe("Recommended fix"),
+  confidence: z5.number().min(0).max(1),
+  timestamp: z5.iso.datetime().optional()
 });
-var FindingVoteSchema = z4.object({
-  agentId: z4.string(),
-  findingId: z4.string(),
-  agree: z4.boolean(),
-  reasoning: z4.string().optional(),
-  amendedSeverity: z4.enum(["critical", "major", "minor", "suggestion"]).optional()
+var FindingVoteSchema = z5.object({
+  agentId: z5.string(),
+  findingId: z5.string(),
+  agree: z5.boolean(),
+  reasoning: z5.string().optional(),
+  amendedSeverity: z5.enum(["critical", "major", "minor", "suggestion"]).optional()
 });
-var VotingProtocolConfigSchema = z4.object({
-  committeeSize: z4.number().int().min(2).max(7).default(3),
-  maxRounds: z4.number().int().min(1).max(5).default(3),
-  roundTimeoutMs: z4.number().int().positive().default(6e4),
-  agreementThreshold: z4.number().min(0.5).max(1).default(0.67),
-  enableAntiSycophancy: z4.boolean().default(true),
-  sycophancyThreshold: z4.number().min(0).max(1).default(0.8)
+var VotingProtocolConfigSchema = z5.object({
+  committeeSize: z5.number().int().min(2).max(7).default(3),
+  maxRounds: z5.number().int().min(1).max(5).default(3),
+  roundTimeoutMs: z5.number().int().positive().default(6e4),
+  agreementThreshold: z5.number().min(0.5).max(1).default(0.67),
+  enableAntiSycophancy: z5.boolean().default(true),
+  sycophancyThreshold: z5.number().min(0).max(1).default(0.8)
 });
 var DEFAULT_VOTING_PROTOCOL_CONFIG = {
   committeeSize: 3,
@@ -4470,30 +4746,30 @@ var DEFAULT_VOTING_PROTOCOL_CONFIG = {
 };
 
 // src/consensus/types-weighted-voting.ts
-import { z as z5 } from "zod";
-var TaskOutcomeSchema2 = z5.enum(["success", "failure", "partial", "unknown"]);
-var WeightedAgentRecordSchema = z5.object({
-  agentId: z5.string().min(1),
-  totalTasks: z5.number().int().nonnegative(),
-  successfulTasks: z5.number().int().nonnegative(),
-  failedTasks: z5.number().int().nonnegative(),
-  partialTasks: z5.number().int().nonnegative(),
-  successRate: z5.number().min(0).max(1),
-  weight: z5.number().min(0).max(1),
-  trustScore: z5.number().min(0).max(1),
-  byzantineFlags: z5.number().int().nonnegative(),
-  lastActive: z5.date(),
-  createdAt: z5.date()
+import { z as z6 } from "zod";
+var TaskOutcomeSchema2 = z6.enum(["success", "failure", "partial", "unknown"]);
+var WeightedAgentRecordSchema = z6.object({
+  agentId: z6.string().min(1),
+  totalTasks: z6.number().int().nonnegative(),
+  successfulTasks: z6.number().int().nonnegative(),
+  failedTasks: z6.number().int().nonnegative(),
+  partialTasks: z6.number().int().nonnegative(),
+  successRate: z6.number().min(0).max(1),
+  weight: z6.number().min(0).max(1),
+  trustScore: z6.number().min(0).max(1),
+  byzantineFlags: z6.number().int().nonnegative(),
+  lastActive: z6.date(),
+  createdAt: z6.date()
 });
-var WeightedVotingConfigSchema = z5.object({
-  minWeight: z5.number().min(0).max(1).default(0.1),
-  maxByzantineFraction: z5.number().min(0).max(0.5).default(0.33),
-  weightDecayFactor: z5.number().min(0.5).max(1).default(0.9),
-  weightRecoveryFactor: z5.number().min(1).max(2).default(1.05),
-  minTrustScore: z5.number().min(0).max(1).default(0.3),
-  byzantineFlagThreshold: z5.number().int().positive().default(3),
-  initialWeight: z5.number().min(0).max(1).default(0.5),
-  quorumThreshold: z5.number().min(0.5).max(1).default(0.67)
+var WeightedVotingConfigSchema = z6.object({
+  minWeight: z6.number().min(0).max(1).default(0.1),
+  maxByzantineFraction: z6.number().min(0).max(0.5).default(0.33),
+  weightDecayFactor: z6.number().min(0.5).max(1).default(0.9),
+  weightRecoveryFactor: z6.number().min(1).max(2).default(1.05),
+  minTrustScore: z6.number().min(0).max(1).default(0.3),
+  byzantineFlagThreshold: z6.number().int().positive().default(3),
+  initialWeight: z6.number().min(0).max(1).default(0.5),
+  quorumThreshold: z6.number().min(0.5).max(1).default(0.67)
 });
 var DEFAULT_WEIGHTED_VOTING_CONFIG = {
   minWeight: 0.1,
@@ -4507,7 +4783,7 @@ var DEFAULT_WEIGHTED_VOTING_CONFIG = {
 };
 
 // src/consensus/higher-order-types.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 function createAgentPairKey(agentA, agentB) {
   return agentA < agentB ? `${agentA}:${agentB}` : `${agentB}:${agentA}`;
 }
@@ -4518,40 +4794,40 @@ function parseAgentPairKey(key) {
   }
   return [parts[0], parts[1]];
 }
-var CorrelationCoefficientSchema = z6.number().min(-1).max(1);
-var IndependentSubsetSchema = z6.object({
-  id: z6.string(),
-  agentIds: z6.array(z6.string()),
-  independenceScore: z6.number().min(0).max(1),
-  observationCount: z6.number().int().nonnegative()
+var CorrelationCoefficientSchema = z7.number().min(-1).max(1);
+var IndependentSubsetSchema = z7.object({
+  id: z7.string(),
+  agentIds: z7.array(z7.string()),
+  independenceScore: z7.number().min(0).max(1),
+  observationCount: z7.number().int().nonnegative()
 });
-var VotingObservationSchema = z6.object({
-  proposalId: z6.string(),
-  agentId: z6.string(),
-  decision: z6.enum(["approve", "reject", "abstain"]),
-  confidence: z6.number().min(0).max(1),
-  alignedWithOutcome: z6.boolean(),
-  timestamp: z6.date()
+var VotingObservationSchema = z7.object({
+  proposalId: z7.string(),
+  agentId: z7.string(),
+  decision: z7.enum(["approve", "reject", "abstain"]),
+  confidence: z7.number().min(0).max(1),
+  alignedWithOutcome: z7.boolean(),
+  timestamp: z7.date()
 });
-var PairwiseVotingHistorySchema = z6.object({
-  pairKey: z6.string(),
-  jointObservations: z6.number().int().nonnegative(),
-  agreements: z6.number().int().nonnegative(),
-  disagreements: z6.number().int().nonnegative(),
+var PairwiseVotingHistorySchema = z7.object({
+  pairKey: z7.string(),
+  jointObservations: z7.number().int().nonnegative(),
+  agreements: z7.number().int().nonnegative(),
+  disagreements: z7.number().int().nonnegative(),
   correlation: CorrelationCoefficientSchema,
-  lastUpdated: z6.date()
+  lastUpdated: z7.date()
 });
-var HigherOrderVotingConfigSchema = z6.object({
-  minObservationsForCorrelation: z6.number().int().positive().default(10),
-  correlationThreshold: z6.number().min(0).max(1).default(0.3),
-  correlationMaxAgeMs: z6.number().int().positive().default(864e5),
+var HigherOrderVotingConfigSchema = z7.object({
+  minObservationsForCorrelation: z7.number().int().positive().default(10),
+  correlationThreshold: z7.number().min(0).max(1).default(0.3),
+  correlationMaxAgeMs: z7.number().int().positive().default(864e5),
   // 24 hours
-  independenceThreshold: z6.number().min(0).max(1).default(0.2),
-  fallbackToSimpleVoting: z6.boolean().default(true),
-  observationDecayFactor: z6.number().min(0).max(1).default(0.95),
-  maxObservationsPerAgent: z6.number().int().positive().default(1e3),
-  maxProposals: z6.number().int().positive().default(5e3),
-  maxTrackedPairs: z6.number().int().positive().default(100)
+  independenceThreshold: z7.number().min(0).max(1).default(0.2),
+  fallbackToSimpleVoting: z7.boolean().default(true),
+  observationDecayFactor: z7.number().min(0).max(1).default(0.95),
+  maxObservationsPerAgent: z7.number().int().positive().default(1e3),
+  maxProposals: z7.number().int().positive().default(5e3),
+  maxTrackedPairs: z7.number().int().positive().default(100)
 });
 var DEFAULT_HIGHER_ORDER_CONFIG = {
   minObservationsForCorrelation: 10,
@@ -4565,25 +4841,25 @@ var DEFAULT_HIGHER_ORDER_CONFIG = {
   maxProposals: 5e3,
   maxTrackedPairs: 100
 };
-var HigherOrderVotingResultSchema = z6.object({
-  decision: z6.enum(["approve", "reject", "no_consensus"]),
-  posteriorApproval: z6.number().min(0).max(1),
-  posteriorRejection: z6.number().min(0).max(1),
-  effectiveVoteCount: z6.number().nonnegative(),
-  usedCorrelationData: z6.boolean(),
-  method: z6.enum(["ow", "isp", "simple"]),
-  improvementOverBaseline: z6.number(),
-  independentSubsets: z6.array(IndependentSubsetSchema).optional(),
-  downweightedAgents: z6.array(z6.string()),
-  reasoning: z6.string()
+var HigherOrderVotingResultSchema = z7.object({
+  decision: z7.enum(["approve", "reject", "no_consensus"]),
+  posteriorApproval: z7.number().min(0).max(1),
+  posteriorRejection: z7.number().min(0).max(1),
+  effectiveVoteCount: z7.number().nonnegative(),
+  usedCorrelationData: z7.boolean(),
+  method: z7.enum(["ow", "isp", "simple"]),
+  improvementOverBaseline: z7.number(),
+  independentSubsets: z7.array(IndependentSubsetSchema).optional(),
+  downweightedAgents: z7.array(z7.string()),
+  reasoning: z7.string()
 });
-var CorrelationTrackerStatsSchema = z6.object({
-  totalAgents: z6.number().int().nonnegative(),
-  trackedPairs: z6.number().int().nonnegative(),
-  totalObservations: z6.number().int().nonnegative(),
-  averageCorrelation: z6.number(),
-  independentSubsetCount: z6.number().int().nonnegative(),
-  pairsWithSufficientData: z6.number().int().nonnegative()
+var CorrelationTrackerStatsSchema = z7.object({
+  totalAgents: z7.number().int().nonnegative(),
+  trackedPairs: z7.number().int().nonnegative(),
+  totalObservations: z7.number().int().nonnegative(),
+  averageCorrelation: z7.number(),
+  independentSubsetCount: z7.number().int().nonnegative(),
+  pairsWithSufficientData: z7.number().int().nonnegative()
 });
 
 // src/consensus/higher-order-helpers.ts
@@ -4758,13 +5034,13 @@ function buildReasoning(decision, effectiveVotes, downweightedAgents, method) {
 }
 
 // src/consensus/higher-order-voting.ts
-var logger = createLogger({ component: "higher-order-voting" });
+var logger2 = createLogger({ component: "higher-order-voting" });
 var OWVoting = class {
   algorithm = "simple_majority";
   config;
   constructor(options = {}) {
     this.config = { ...DEFAULT_HIGHER_ORDER_CONFIG, ...options.config };
-    logger.info("OWVoting initialized", { config: this.config });
+    logger2.info("OWVoting initialized", { config: this.config });
   }
   /** IVotingStrategy implementation for integration with ConsensusEngine. */
   calculateOutcome(votes, _weights) {
@@ -4775,7 +5051,7 @@ var OWVoting = class {
     const agentIds = Array.from(votes.keys());
     const hasSufficientData = hasSufficientCorrelationData(agentIds, correlationMatrix);
     if (!hasSufficientData && this.config.fallbackToSimpleVoting) {
-      logger.info("Insufficient correlation data, falling back to simple voting", {
+      logger2.info("Insufficient correlation data, falling back to simple voting", {
         agentCount: agentIds.length,
         reason: "insufficient_correlation_data"
       });
@@ -4806,7 +5082,7 @@ var OWVoting = class {
       downweightedAgents,
       reasoning: buildReasoning(decision, effectiveVoteCount, downweightedAgents, "ow")
     };
-    logger.info("OW aggregation complete", {
+    logger2.info("OW aggregation complete", {
       decision,
       posteriorApproval: posteriorApproval.toFixed(3),
       effectiveVotes: effectiveVoteCount.toFixed(2),
@@ -4819,7 +5095,7 @@ var OWVoting = class {
   }
   computeISP(votes, independentSubsets) {
     if (independentSubsets.length === 0) {
-      logger.info("No independent subsets, falling back to simple voting", {
+      logger2.info("No independent subsets, falling back to simple voting", {
         reason: "no_independent_subsets"
       });
       return this.aggregateSimpleInternal(votes);
@@ -4847,7 +5123,7 @@ var OWVoting = class {
       downweightedAgents,
       reasoning: buildReasoning(decision, effectiveVoteCount, downweightedAgents, "isp")
     };
-    logger.info("ISP aggregation complete", {
+    logger2.info("ISP aggregation complete", {
       decision,
       subsetCount: independentSubsets.length,
       posteriorApproval: posteriorApproval.toFixed(3)
@@ -4858,7 +5134,7 @@ var OWVoting = class {
     const agentIds = Array.from(votes.keys());
     if (!tracker.hasSufficientData(agentIds)) {
       if (this.config.fallbackToSimpleVoting) {
-        logger.info("Insufficient data for correlation analysis, using simple voting", {
+        logger2.info("Insufficient data for correlation analysis, using simple voting", {
           agentCount: agentIds.length,
           reason: "insufficient_tracker_data"
         });
@@ -4873,7 +5149,7 @@ var OWVoting = class {
       const owConfidence = Math.abs(owResult.posteriorApproval - 0.5) * 2;
       const ispConfidence = Math.abs(ispResult.posteriorApproval - 0.5) * 2;
       if (ispConfidence > owConfidence) {
-        logger.debug("Using ISP result over OW due to higher confidence");
+        logger2.debug("Using ISP result over OW due to higher confidence");
         return ispResult;
       }
     }
@@ -5232,11 +5508,11 @@ var ConsensusEngine = class {
   logger;
   metrics;
   voterExpansionCallback;
-  constructor(config, logger11) {
+  constructor(config, logger12) {
     this.config = { ...DEFAULT_CONSENSUS_CONFIG, ...config };
     this.cacheConfig = { ...DEFAULT_PROPOSAL_CACHE_CONFIG, ...config?.proposalCache };
     this.quorumConfig = { ...DEFAULT_INCREMENTAL_QUORUM_CONFIG, ...config?.incrementalQuorum };
-    this.logger = logger11 ?? createLogger({ component: "ConsensusEngine" });
+    this.logger = logger12 ?? createLogger({ component: "ConsensusEngine" });
     this.strategyFactory = new VotingStrategyFactory();
     this.metrics = this.createInitialMetrics();
   }
@@ -5669,8 +5945,8 @@ var ConsensusEngine = class {
     this.logger.debug("Proposal cache cleared");
   }
 };
-function createConsensusEngine(config, logger11) {
-  return new ConsensusEngine(config, logger11);
+function createConsensusEngine(config, logger12) {
+  return new ConsensusEngine(config, logger12);
 }
 
 // src/consensus/quorum-validator.ts
@@ -5678,8 +5954,8 @@ var DEFAULT_MIN_TRUST = 0.3;
 var DEFAULT_MIN_WEIGHT = 0.1;
 var QuorumValidator = class {
   logger;
-  constructor(logger11) {
-    this.logger = logger11 ?? createLogger({ component: "QuorumValidator" });
+  constructor(logger12) {
+    this.logger = logger12 ?? createLogger({ component: "QuorumValidator" });
   }
   validateQuorum(input) {
     const { votes, config } = input;
@@ -5906,8 +6182,8 @@ var QuorumValidator = class {
     };
   }
 };
-function createQuorumValidator(logger11) {
-  return new QuorumValidator(logger11);
+function createQuorumValidator(logger12) {
+  return new QuorumValidator(logger12);
 }
 
 // src/consensus/voting-protocol-helpers.ts
@@ -6156,12 +6432,12 @@ function detectSycophancyPatterns(session) {
 }
 
 // src/consensus/voting-protocol.ts
-var logger2 = createLogger({ component: "voting-protocol" });
+var logger3 = createLogger({ component: "voting-protocol" });
 var VotingProtocol = class {
   sessions = /* @__PURE__ */ new Map();
   logger;
   constructor(customLogger) {
-    this.logger = customLogger ?? logger2;
+    this.logger = customLogger ?? logger3;
   }
   /**
    * Create a new voting session with a committee.
@@ -6614,7 +6890,7 @@ function applyOutcomeWeight(currentWeight, outcome, decayFactor, recoveryFactor)
 }
 
 // src/consensus/weighted-voting.ts
-var logger3 = createLogger({ component: "weighted-voting" });
+var logger4 = createLogger({ component: "weighted-voting" });
 var WeightedVoting = class {
   records = /* @__PURE__ */ new Map();
   config;
@@ -6624,7 +6900,7 @@ var WeightedVoting = class {
     this.config = { ...DEFAULT_WEIGHTED_VOTING_CONFIG, ...options.config };
     this.eventBus = options.eventBus ?? void 0;
     this.emitEvents = options.emitEvents ?? options.eventBus !== void 0;
-    logger3.info("WeightedVoting initialized", {
+    logger4.info("WeightedVoting initialized", {
       config: this.config,
       eventsEnabled: this.emitEvents
     });
@@ -6655,7 +6931,7 @@ var WeightedVoting = class {
     );
     updateDerivedMetrics(record);
     this.emitWeightChange(agentId, previousWeight, record.weight, "performance_update");
-    logger3.debug("Performance updated", {
+    logger4.debug("Performance updated", {
       agentId,
       outcome,
       newWeight: record.weight,
@@ -6688,12 +6964,12 @@ var WeightedVoting = class {
   }
   registerAgent(agentId) {
     if (this.records.has(agentId)) {
-      logger3.debug("Agent already registered", { agentId });
+      logger4.debug("Agent already registered", { agentId });
       return;
     }
     const record = createAgentRecord(agentId, this.config.initialWeight);
     this.records.set(agentId, record);
-    logger3.info("Agent registered", { agentId, initialWeight: this.config.initialWeight });
+    logger4.info("Agent registered", { agentId, initialWeight: this.config.initialWeight });
   }
   getAgentRecord(agentId) {
     const record = this.records.get(agentId);
@@ -6703,7 +6979,7 @@ var WeightedVoting = class {
   flagByzantine(agentId, reason) {
     const record = this.records.get(agentId);
     if (record === void 0) {
-      logger3.warn("Cannot flag unregistered agent", { agentId });
+      logger4.warn("Cannot flag unregistered agent", { agentId });
       return;
     }
     const previousWeight = record.weight;
@@ -6714,7 +6990,7 @@ var WeightedVoting = class {
     const canStillVote = this.canVote(agentId);
     this.emitAgentFlaggedEvent(agentId, reason, previousWeight, canStillVote);
     this.emitWeightChange(agentId, previousWeight, record.weight, "flag_penalty");
-    logger3.warn("Agent flagged for Byzantine behavior", {
+    logger4.warn("Agent flagged for Byzantine behavior", {
       agentId,
       reason,
       totalFlags: record.byzantineFlags,
@@ -6746,7 +7022,7 @@ var WeightedVoting = class {
       updateDerivedMetrics(record);
       this.emitWeightChange(record.agentId, previousWeight, record.weight, "recalibration");
     }
-    logger3.info("Weights recalibrated", {
+    logger4.info("Weights recalibrated", {
       agentCount: this.records.size,
       globalSuccessRate: globalSuccessRate.toFixed(3)
     });
@@ -6760,7 +7036,7 @@ var WeightedVoting = class {
     const breakdown = /* @__PURE__ */ new Map();
     for (const [agentId, vote] of votes) {
       if (!this.canVote(agentId)) {
-        logger3.warn("Agent cannot vote", { agentId, reason: "insufficient weight or trust" });
+        logger4.warn("Agent cannot vote", { agentId, reason: "insufficient weight or trust" });
         continue;
       }
       const weight = this.calculateWeight(agentId);
@@ -6774,7 +7050,7 @@ var WeightedVoting = class {
     return { approval, rejection, total, agents, breakdown };
   }
   logConsensusResult(result) {
-    logger3.info("Weighted consensus calculated", {
+    logger4.info("Weighted consensus calculated", {
       decision: result.decision,
       approval: result.weightedApproval.toFixed(3),
       rejection: result.weightedRejection.toFixed(3),
@@ -6798,7 +7074,7 @@ var WeightedVoting = class {
     record.trustScore = 0;
     record.weight = 0;
     this.emitWeightChange(record.agentId, weightBefore, 0, "flag_penalty");
-    logger3.warn("Agent excluded from voting due to Byzantine behavior", {
+    logger4.warn("Agent excluded from voting due to Byzantine behavior", {
       agentId: record.agentId,
       flags: record.byzantineFlags
     });
@@ -6967,7 +7243,7 @@ function partitionIntoIndependentGroups(agents, correlationMatrix, pairwiseHisto
 }
 
 // src/consensus/correlation-tracker.ts
-var logger4 = createLogger({ component: "correlation-tracker" });
+var logger5 = createLogger({ component: "correlation-tracker" });
 var CorrelationTracker = class {
   config;
   observations = /* @__PURE__ */ new Map();
@@ -6978,7 +7254,7 @@ var CorrelationTracker = class {
   cachedSubsets = null;
   constructor(config) {
     this.config = { ...DEFAULT_HIGHER_ORDER_CONFIG, ...config };
-    logger4.info("CorrelationTracker initialized", {
+    logger5.info("CorrelationTracker initialized", {
       maxObservationsPerAgent: this.config.maxObservationsPerAgent,
       maxProposals: this.config.maxProposals
     });
@@ -7015,7 +7291,7 @@ var CorrelationTracker = class {
     this.proposalOrder.push(proposalId);
     this.updatePairwiseCorrelations(proposalId, proposalObservations);
     this.invalidateCache();
-    logger4.debug("Recorded proposal votes", {
+    logger5.debug("Recorded proposal votes", {
       proposalId,
       agentCount: votes.size,
       outcome,
@@ -7053,7 +7329,7 @@ var CorrelationTracker = class {
       this.config
     );
     this.cachedSubsets = subsets;
-    logger4.debug("Identified independent subsets", {
+    logger5.debug("Identified independent subsets", {
       agentCount: agents.length,
       subsetCount: subsets.length
     });
@@ -7109,7 +7385,7 @@ var CorrelationTracker = class {
     this.agentProposals.clear();
     this.proposalOrder.length = 0;
     this.cachedSubsets = null;
-    logger4.info("CorrelationTracker cleared");
+    logger5.info("CorrelationTracker cleared");
   }
   // ============================================================================
   // Private helpers
@@ -7130,7 +7406,7 @@ var CorrelationTracker = class {
           }
         }
       }
-      logger4.debug("Evicted oldest proposal", {
+      logger5.debug("Evicted oldest proposal", {
         evictedProposalId,
         reason: "maxProposals",
         remainingProposals: this.proposalOrder.length
@@ -7154,7 +7430,7 @@ var CorrelationTracker = class {
     }
     if (oldestKey !== void 0) {
       this.pairwiseHistory.delete(oldestKey);
-      logger4.debug("Evicted oldest pairwise history entry", {
+      logger5.debug("Evicted oldest pairwise history entry", {
         evictedKey: oldestKey,
         reason: "maxTrackedPairs",
         remainingPairs: this.pairwiseHistory.size
@@ -7170,7 +7446,7 @@ var CorrelationTracker = class {
     while (agentObs.length >= this.config.maxObservationsPerAgent) {
       const evicted = agentObs.shift();
       if (evicted !== void 0) {
-        logger4.debug("Evicted oldest observation for agent", {
+        logger5.debug("Evicted oldest observation for agent", {
           agentId,
           evictedProposalId: evicted.proposalId,
           reason: "maxObservationsPerAgent"
@@ -7233,28 +7509,28 @@ function createCorrelationTracker(config) {
 
 // src/consensus/correlation-persistence.ts
 import * as fs from "fs";
-import { z as z7 } from "zod";
-var logger5 = createLogger({ component: "correlation-persistence" });
+import { z as z8 } from "zod";
+var logger6 = createLogger({ component: "correlation-persistence" });
 var VOTING_SUBDIR = "voting";
 var CORRELATIONS_FILE = "correlations.json";
 var FILE_MODE = 384;
 var DIR_MODE = 448;
 var SCHEMA_VERSION = 1;
-var PersistedVoteSchema = z7.object({
-  agentId: z7.string(),
-  decision: z7.enum(["approve", "reject", "abstain"]),
-  confidence: z7.number().min(0).max(1)
+var PersistedVoteSchema = z8.object({
+  agentId: z8.string(),
+  decision: z8.enum(["approve", "reject", "abstain"]),
+  confidence: z8.number().min(0).max(1)
 });
-var PersistedProposalSchema = z7.object({
-  proposalId: z7.string(),
-  votes: z7.array(PersistedVoteSchema),
-  outcome: z7.enum(["approved", "rejected"]),
-  timestamp: z7.iso.datetime()
+var PersistedProposalSchema = z8.object({
+  proposalId: z8.string(),
+  votes: z8.array(PersistedVoteSchema),
+  outcome: z8.enum(["approved", "rejected"]),
+  timestamp: z8.iso.datetime()
 });
-var PersistedCorrelationDataSchema = z7.object({
-  version: z7.number().int().positive(),
-  proposals: z7.array(PersistedProposalSchema),
-  savedAt: z7.iso.datetime()
+var PersistedCorrelationDataSchema = z8.object({
+  version: z8.number().int().positive(),
+  proposals: z8.array(PersistedProposalSchema),
+  savedAt: z8.iso.datetime()
 });
 function getCorrelationDataPath() {
   return nexusDataPath(VOTING_SUBDIR, CORRELATIONS_FILE);
@@ -7304,7 +7580,7 @@ function saveCorrelationData(proposals, config = DEFAULT_HIGHER_ORDER_CONFIG) {
   try {
     fs.writeFileSync(tempPath, json, { encoding: "utf-8", mode: FILE_MODE });
     fs.renameSync(tempPath, filePath);
-    logger5.info("Correlation data saved", {
+    logger6.info("Correlation data saved", {
       path: filePath,
       proposalCount: merged.length
     });
@@ -7314,7 +7590,7 @@ function saveCorrelationData(proposals, config = DEFAULT_HIGHER_ORDER_CONFIG) {
       fs.unlinkSync(tempPath);
     } catch (cleanupErr) {
       const msg = cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr);
-      logger5.debug("Failed to clean up temp file during correlation save", {
+      logger6.debug("Failed to clean up temp file during correlation save", {
         path: tempPath,
         error: msg
       });
@@ -7338,7 +7614,7 @@ function readAndParseFile(filePath) {
     return ok(JSON.parse(rawContent));
   } catch (cause) {
     const error = cause instanceof Error ? cause : new Error(String(cause));
-    logger5.warn("Corrupt correlation data file, will start fresh", {
+    logger6.warn("Corrupt correlation data file, will start fresh", {
       path: filePath,
       error: error.message
     });
@@ -7348,14 +7624,14 @@ function readAndParseFile(filePath) {
 function validateCorrelationData(parsed, filePath) {
   const validation = PersistedCorrelationDataSchema.safeParse(parsed);
   if (!validation.success) {
-    logger5.warn("Invalid correlation data schema, will start fresh", {
+    logger6.warn("Invalid correlation data schema, will start fresh", {
       path: filePath,
       errors: validation.error.issues.map((issue) => issue.message)
     });
     return err(new Error(`Invalid correlation data schema: ${validation.error.message}`));
   }
   if (validation.data.version > SCHEMA_VERSION) {
-    logger5.warn("Correlation data from newer version, will start fresh", {
+    logger6.warn("Correlation data from newer version, will start fresh", {
       fileVersion: validation.data.version,
       currentVersion: SCHEMA_VERSION
     });
@@ -7373,7 +7649,7 @@ function loadCorrelationData() {
   if (!parseResult.ok) return parseResult;
   const validateResult = validateCorrelationData(parseResult.value, filePath);
   if (!validateResult.ok) return validateResult;
-  logger5.info("Correlation data loaded", {
+  logger6.info("Correlation data loaded", {
     path: filePath,
     proposalCount: validateResult.value.proposals.length,
     savedAt: validateResult.value.savedAt
@@ -7400,13 +7676,13 @@ function createPersistentCorrelationTracker(config) {
   const tracker = createCorrelationTracker(config);
   const loadResult = loadCorrelationData();
   if (!loadResult.ok) {
-    logger5.info("Starting with fresh correlation tracker", {
+    logger6.info("Starting with fresh correlation tracker", {
       reason: loadResult.error.message
     });
     return tracker;
   }
   const replayedCount = replayProposals(tracker, loadResult.value.proposals);
-  logger5.info("Correlation tracker restored from persistence", {
+  logger6.info("Correlation tracker restored from persistence", {
     replayedProposals: replayedCount,
     stats: tracker.getStats()
   });
@@ -7430,9 +7706,9 @@ function createPersistedProposal(proposalId, votes, outcome) {
 }
 
 // src/mcp/tools/consensus-vote-types.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var MAX_PROPOSAL_LENGTH = 4e3;
-var VotingStrategySchema = z8.enum([
+var VotingStrategySchema = z9.enum([
   "simple_majority",
   "supermajority",
   "unanimous",
@@ -7440,16 +7716,26 @@ var VotingStrategySchema = z8.enum([
   "higher_order",
   "opinion_wise"
 ]);
-var ConsensusVoteInputSchema = z8.object({
-  proposal: z8.string().min(1).max(MAX_PROPOSAL_LENGTH).describe("Proposal text to vote on"),
-  threshold: z8.enum(["majority", "supermajority", "unanimous"]).optional().describe(
+var ErrorPolicySchema = z9.enum(["reduce_denominator", "count_as_abstain", "fail_closed"]);
+var VoteThresholdSchema = z9.enum(["majority", "supermajority", "unanimous"]);
+var ERROR_FLOOR_FRACTION = 0.5;
+function getDefaultErrorPolicy(strategy) {
+  if (strategy === "unanimous" || strategy === "higher_order") return "fail_closed";
+  return "reduce_denominator";
+}
+var ConsensusVoteInputSchema = z9.object({
+  proposal: z9.string().min(1).max(MAX_PROPOSAL_LENGTH).describe("Proposal text to vote on"),
+  threshold: VoteThresholdSchema.optional().describe(
     "Voting threshold (legacy): majority, supermajority, unanimous. Use strategy instead."
   ),
   strategy: VotingStrategySchema.optional().describe(
     "Voting strategy: simple_majority (default), supermajority, unanimous, proof_of_learning, or higher_order (Bayesian-optimal)"
   ),
-  quickMode: z8.boolean().optional().default(false).describe("Use 3 agents instead of 5 for faster execution"),
-  simulateVotes: z8.boolean().optional().default(false).describe(
+  errorPolicy: ErrorPolicySchema.optional().describe(
+    "How to treat voters that errored or timed out (#2630). Default: fail_closed for unanimous/higher_order, reduce_denominator otherwise. Regardless of policy, errors > 50% always fails."
+  ),
+  quickMode: z9.boolean().optional().default(false).describe("Use 3 agents instead of 5 for faster execution"),
+  simulateVotes: z9.boolean().optional().default(false).describe(
     "TESTS ONLY \u2014 when true, voters return random decisions. Output must not be used for real decisions. (#2319)"
   )
 });
@@ -7515,12 +7801,49 @@ function buildResponse(input, result) {
   return response;
 }
 
+// src/mcp/tools/consensus-vote-error-policy.ts
+function isHardFloorTripped(errorCount, totalCount) {
+  if (totalCount === 0) return false;
+  return errorCount / totalCount > ERROR_FLOOR_FRACTION;
+}
+function applyErrorPolicy(votes, policy) {
+  const errorVotes = votes.filter((v) => v.source === "error");
+  const errorCount = errorVotes.length;
+  const totalCount = votes.length;
+  if (isHardFloorTripped(errorCount, totalCount)) {
+    return {
+      shortCircuit: true,
+      reason: `Errors exceeded ${String(Math.round(ERROR_FLOOR_FRACTION * 100))}% of voters (${String(errorCount)}/${String(totalCount)})`,
+      engineVotes: []
+    };
+  }
+  if (policy === "fail_closed" && errorCount > 0) {
+    return {
+      shortCircuit: true,
+      reason: `fail_closed: ${String(errorCount)} voter(s) errored`,
+      engineVotes: []
+    };
+  }
+  if (policy === "count_as_abstain") {
+    return {
+      shortCircuit: false,
+      engineVotes: votes.map(
+        (v) => v.source === "error" ? { ...v, vote: { ...v.vote, decision: "abstain" } } : v
+      )
+    };
+  }
+  return {
+    shortCircuit: false,
+    engineVotes: votes.filter((v) => v.source !== "error")
+  };
+}
+
 // src/mcp/tools/tool-memory.ts
 import * as fs3 from "fs";
 import * as path2 from "path";
 
 // src/context/belief-core-types.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var BeliefConfidence = {
   /** Strong evidence, short reasoning chain */
   HIGH: "high",
@@ -7531,7 +7854,7 @@ var BeliefConfidence = {
   /** Speculative or hypothetical */
   SPECULATIVE: "speculative"
 };
-var BeliefConfidenceSchema = z9.enum(["high", "medium", "low", "speculative"]);
+var BeliefConfidenceSchema = z10.enum(["high", "medium", "low", "speculative"]);
 var BeliefSourceType = {
   /** Direct observation from environment */
   OBSERVATION: "observation",
@@ -7546,7 +7869,7 @@ var BeliefSourceType = {
   /** Default or prior belief */
   PRIOR: "prior"
 };
-var BeliefSourceTypeSchema = z9.enum([
+var BeliefSourceTypeSchema = z10.enum([
   "observation",
   "inference",
   "external",
@@ -7554,26 +7877,26 @@ var BeliefSourceTypeSchema = z9.enum([
   "hindsight",
   "prior"
 ]);
-var BeliefSchema = z9.object({
-  beliefId: z9.string().min(1),
-  subject: z9.string().min(1),
-  predicate: z9.string().min(1),
-  object: z9.string(),
+var BeliefSchema = z10.object({
+  beliefId: z10.string().min(1),
+  subject: z10.string().min(1),
+  predicate: z10.string().min(1),
+  object: z10.string(),
   confidence: BeliefConfidenceSchema,
   sourceType: BeliefSourceTypeSchema,
-  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()
+  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()
 });
 
 // src/context/belief-update-types.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var BeliefUpdateType = {
   /** Add a new belief (retain) */
   RETAIN: "retain",
@@ -7588,7 +7911,7 @@ var BeliefUpdateType = {
   /** Weaken belief based on contradicting evidence */
   WEAKEN: "weaken"
 };
-var BeliefUpdateTypeSchema = z10.enum([
+var BeliefUpdateTypeSchema = z11.enum([
   "retain",
   "revise",
   "supersede",
@@ -7596,75 +7919,75 @@ var BeliefUpdateTypeSchema = z10.enum([
   "reinforce",
   "weaken"
 ]);
-var BeliefUpdateSchema = z10.object({
-  updateId: z10.string().min(1),
-  beliefId: z10.string().min(1),
+var BeliefUpdateSchema = z11.object({
+  updateId: z11.string().min(1),
+  beliefId: z11.string().min(1),
   updateType: BeliefUpdateTypeSchema,
-  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()
+  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()
 });
-var BeliefQuerySchema = z10.object({
-  subject: z10.string().optional(),
-  predicate: z10.string().optional(),
-  domain: z10.string().optional(),
+var BeliefQuerySchema = z11.object({
+  subject: z11.string().optional(),
+  predicate: z11.string().optional(),
+  domain: z11.string().optional(),
   minConfidence: BeliefConfidenceSchema.optional(),
-  includeSuperseded: z10.boolean().optional(),
+  includeSuperseded: z11.boolean().optional(),
   sourceType: BeliefSourceTypeSchema.optional(),
-  limit: z10.number().int().positive().max(1e3).optional(),
-  orderBy: z10.enum(["createdAt", "updatedAt", "confidence"]).optional(),
-  orderDirection: z10.enum(["asc", "desc"]).optional()
+  limit: z11.number().int().positive().max(1e3).optional(),
+  orderBy: z11.enum(["createdAt", "updatedAt", "confidence"]).optional(),
+  orderDirection: z11.enum(["asc", "desc"]).optional()
 });
 
 // src/context/belief-hindsight-types.ts
-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()
+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()
 });
-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()
+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()
 });
 
 // src/context/belief-memory-interface.ts
-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()
+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()
 });
-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(),
+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(),
   defaultConfidence: BeliefConfidenceSchema.optional(),
-  maxInferenceDepth: z12.number().int().positive().max(10).optional()
+  maxInferenceDepth: z13.number().int().positive().max(10).optional()
 });
 var DEFAULT_BELIEF_CONFIG = {
   maxBeliefsPerSubject: 100,
@@ -8184,13 +8507,13 @@ var HindsightBeliefMemory = class {
   domainIndex = /* @__PURE__ */ new Map();
   config;
   logger;
-  constructor(config, logger11) {
+  constructor(config, logger12) {
     const validation = BeliefMemoryConfigSchema.safeParse(config ?? {});
     if (!validation.success) {
       throw new MemoryError(`Invalid BeliefMemoryConfig: ${formatZodError(validation.error)}`);
     }
     this.config = { ...DEFAULT_BELIEF_CONFIG, ...config };
-    this.logger = logger11 ?? createLogger({ component: "HindsightBeliefMemory" });
+    this.logger = logger12 ?? createLogger({ component: "HindsightBeliefMemory" });
     this.logger.info("HindsightBeliefMemory initialized", { config: this.config });
   }
   get auditStores() {
@@ -8561,7 +8884,7 @@ var HindsightBeliefMemory = class {
 };
 
 // src/context/graph-memory-types.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var RelationType = {
   /** General association between memories */
   RELATED_TO: "related_to",
@@ -8580,7 +8903,7 @@ var RelationType = {
   /** Causal relationship */
   CAUSES: "causes"
 };
-var RelationTypeSchema = z13.enum([
+var RelationTypeSchema = z14.enum([
   "related_to",
   "derived_from",
   "contradicts",
@@ -8590,28 +8913,28 @@ var RelationTypeSchema = z13.enum([
   "precedes",
   "causes"
 ]);
-var GraphEdgeSchema = z13.object({
-  from: z13.string().min(1),
-  to: z13.string().min(1),
+var GraphEdgeSchema = z14.object({
+  from: z14.string().min(1),
+  to: z14.string().min(1),
   type: RelationTypeSchema,
-  weight: z13.number().min(0).max(1),
-  createdAt: z13.date(),
-  metadata: z13.record(z13.string(), z13.unknown()).optional()
+  weight: z14.number().min(0).max(1),
+  createdAt: z14.date(),
+  metadata: z14.record(z14.string(), z14.unknown()).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 TraversalOptionsSchema = z14.object({
+  maxDepth: z14.number().int().positive().optional(),
+  relationTypes: z14.array(RelationTypeSchema).optional(),
+  minWeight: z14.number().min(0).max(1).optional(),
+  limit: z14.number().int().positive().optional(),
+  includeStart: z14.boolean().optional(),
+  direction: z14.enum(["outgoing", "incoming", "both"]).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 GraphMemoryConfigSchema = z14.object({
+  dbPath: z14.string().min(1),
+  markdownDir: z14.string().min(1),
+  defaultTraversalDepth: z14.number().int().positive().optional(),
+  maxTraversalDepth: z14.number().int().positive().optional(),
+  autoExpire: z14.boolean().optional()
 });
 var DEFAULT_GRAPH_MEMORY_CONFIG = {
   defaultTraversalDepth: 2,
@@ -8767,7 +9090,7 @@ function findShortestPath(db, from, to, opts) {
 }
 
 // src/context/graph-memory.ts
-var logger6 = createLogger({ component: "GraphMemoryBackend" });
+var logger7 = createLogger({ component: "GraphMemoryBackend" });
 var GraphMemoryBackend = class {
   config;
   log;
@@ -8782,7 +9105,7 @@ var GraphMemoryBackend = class {
       throw new MemoryError(`Invalid GraphMemoryBackend config: ${msg}`);
     }
     this.config = { ...DEFAULT_GRAPH_MEMORY_CONFIG, ...config };
-    this.log = logger6;
+    this.log = logger7;
     this.base = new HybridMemoryBackend({ dbPath: config.dbPath, markdownDir: config.markdownDir });
   }
   async initialize() {
@@ -8797,7 +9120,7 @@ var GraphMemoryBackend = class {
     if (!baseInit.ok) return baseInit;
     try {
       const mod = await import("better-sqlite3").catch((cause) => {
-        logger6.debug("better-sqlite3 import failed", { error: String(cause) });
+        logger7.debug("better-sqlite3 import failed", { error: String(cause) });
         return null;
       });
       if (mod === null)
@@ -8969,11 +9292,11 @@ var GraphMemoryBackend = class {
 };
 
 // src/context/agentic-memory-types.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // src/context/agentic-memory-primitives.ts
-import { z as z14 } from "zod";
-var EntityTypeSchema = z14.enum([
+import { z as z15 } from "zod";
+var EntityTypeSchema = z15.enum([
   "person",
   "organization",
   "concept",
@@ -8981,60 +9304,60 @@ var EntityTypeSchema = z14.enum([
   "file",
   "unknown"
 ]);
-var EntityReferenceSchema = z14.object({
-  name: z14.string().min(1).max(200),
+var EntityReferenceSchema = z15.object({
+  name: z15.string().min(1).max(200),
   type: EntityTypeSchema
 });
-var EvolutionTypeSchema = z14.enum([
+var EvolutionTypeSchema = z15.enum([
   "refinement",
   "contradiction",
   "extension",
   "supersession"
 ]);
-var EvolutionResultSchema = z14.object({
+var EvolutionResultSchema = z15.object({
   type: EvolutionTypeSchema,
-  affectedKey: z14.string().min(1),
-  confidence: z14.number().min(0).max(1),
-  description: z14.string().max(500)
+  affectedKey: z15.string().min(1),
+  confidence: z15.number().min(0).max(1),
+  description: z15.string().max(500)
 });
-var LinkSuggestionSchema = z14.object({
-  from: z14.string().min(1),
-  to: z14.string().min(1),
+var LinkSuggestionSchema = z15.object({
+  from: z15.string().min(1),
+  to: z15.string().min(1),
   relationType: RelationTypeSchema,
-  reason: z14.string().max(200),
-  confidence: z14.number().min(0).max(1)
+  reason: z15.string().max(200),
+  confidence: z15.number().min(0).max(1)
 });
 
 // src/context/agentic-memory-types.ts
-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 MemoryAttributesSchema = z16.object({
+  keywords: z16.array(z16.string().max(100)).max(50),
+  semanticTags: z16.array(z16.string().max(50)).max(20),
+  contextDescription: z16.string().max(500),
+  entities: z16.array(EntityReferenceSchema).max(30),
+  attributesUpdatedAt: z16.date()
 });
-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 ExtractionConfigSchema = z16.object({
+  maxKeywords: z16.number().int().positive().max(50),
+  maxSemanticTags: z16.number().int().positive().max(20),
+  maxContextLength: z16.number().int().positive().max(500),
+  maxEntities: z16.number().int().positive().max(30)
 });
-var LinkingConfigSchema = z15.object({
-  suggestionThreshold: z15.number().min(0).max(1),
-  maxSuggestions: z15.number().int().positive().max(20),
-  allowedTypes: z15.array(RelationTypeSchema)
+var LinkingConfigSchema = z16.object({
+  suggestionThreshold: z16.number().min(0).max(1),
+  maxSuggestions: z16.number().int().positive().max(20),
+  allowedTypes: z16.array(RelationTypeSchema)
 });
-var LinkingOptionsSchema = z15.object({
-  threshold: z15.number().min(0).max(1).optional(),
-  maxLinks: z15.number().int().positive().optional(),
-  bidirectional: z15.boolean().optional()
+var LinkingOptionsSchema = z16.object({
+  threshold: z16.number().min(0).max(1).optional(),
+  maxLinks: z16.number().int().positive().optional(),
+  bidirectional: z16.boolean().optional()
 });
-var AgenticMemoryConfigSchema = z15.object({
-  dbPath: z15.string().min(1),
-  markdownDir: z15.string().min(1),
+var AgenticMemoryConfigSchema = z16.object({
+  dbPath: z16.string().min(1),
+  markdownDir: z16.string().min(1),
   extraction: ExtractionConfigSchema.partial().optional(),
   linking: LinkingConfigSchema.partial().optional(),
-  autoExpire: z15.boolean().optional()
+  autoExpire: z16.boolean().optional()
 });
 var DEFAULT_EXTRACTION_CONFIG = {
   maxKeywords: 10,
@@ -9287,7 +9610,7 @@ function mergeLinkingConfig(partial) {
 }
 
 // src/context/agentic-memory-db-helpers.ts
-var logger7 = createLogger({ component: "AgenticMemoryDbHelpers" });
+var logger8 = createLogger({ component: "AgenticMemoryDbHelpers" });
 function safeExtractAttributes(amem) {
   if (!Array.isArray(amem.keywords) || amem.attributesUpdatedAt === void 0) return null;
   const updatedAt = amem.attributesUpdatedAt;
@@ -9312,7 +9635,7 @@ function memoryRowToAgenticEntry(row, extractionConfig) {
   try {
     parsedMeta = JSON.parse(row.metadata);
   } catch {
-    logger7.warn("Corrupt metadata JSON in memory row, using fallback extraction", {
+    logger8.warn("Corrupt metadata JSON in memory row, using fallback extraction", {
       key: row.key
     });
   }
@@ -9345,7 +9668,7 @@ function getAttributesFromRow(row, extractionConfig) {
   try {
     meta = JSON.parse(row.metadata);
   } catch {
-    logger7.warn("Corrupt metadata JSON in getAttributesFromRow, using value extraction", {
+    logger8.warn("Corrupt metadata JSON in getAttributesFromRow, using value extraction", {
       key: row.key
     });
   }
@@ -9357,7 +9680,7 @@ function getAttributesFromRow(row, extractionConfig) {
   try {
     parsedValue = JSON.parse(row.value);
   } catch {
-    logger7.warn("Corrupt value JSON in getAttributesFromRow, using raw string", {
+    logger8.warn("Corrupt value JSON in getAttributesFromRow, using raw string", {
       key: row.key
     });
   }
@@ -9447,7 +9770,7 @@ function buildAgenticEntry(key, value, metadata, attributes, createdAt) {
 }
 
 // src/context/agentic-memory.ts
-var logger8 = createLogger({ component: "AgenticMemoryBackend" });
+var logger9 = createLogger({ component: "AgenticMemoryBackend" });
 var AgenticMemoryBackend = class {
   config;
   log;
@@ -9465,7 +9788,7 @@ var AgenticMemoryBackend = class {
       throw new MemoryError(`Invalid AgenticMemoryBackend config: ${msg}`);
     }
     this.config = config;
-    this.log = logger8;
+    this.log = logger9;
     this.extractionConfig = mergeExtractionConfig(config.extraction);
     this.linkingConfig = mergeLinkingConfig(config.linking);
     this.base = new HybridMemoryBackend({
@@ -9717,74 +10040,74 @@ import * as fs2 from "fs";
 import * as path from "path";
 
 // src/context/belief-persistence-types.ts
-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(),
+import { z as z17 } from "zod";
+var BeliefSnapshotSchema = z17.object({
+  version: z17.number().int().min(1),
+  exportedAt: z17.string(),
+  beliefs: z17.array(
+    z17.object({
+      beliefId: z17.string(),
+      subject: z17.string(),
+      predicate: z17.string(),
+      object: z17.string(),
       confidence: BeliefConfidenceSchema,
       sourceType: BeliefSourceTypeSchema,
-      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()
+      sourceRef: z17.string().optional(),
+      derivedFrom: z17.array(z17.string()).optional(),
+      version: z17.number(),
+      createdAt: z17.string(),
+      updatedAt: z17.string(),
+      superseded: z17.boolean(),
+      supersededBy: z17.string().optional(),
+      domain: z17.string().optional(),
+      metadata: z17.record(z17.string(), z17.unknown()).optional()
     })
   ),
-  updates: z16.array(
-    z16.object({
-      beliefId: z16.string(),
-      records: z16.array(
-        z16.object({
-          updateId: z16.string(),
-          beliefId: z16.string(),
+  updates: z17.array(
+    z17.object({
+      beliefId: z17.string(),
+      records: z17.array(
+        z17.object({
+          updateId: z17.string(),
+          beliefId: z17.string(),
           updateType: BeliefUpdateTypeSchema,
-          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()
+          previousState: z17.record(z17.string(), z17.unknown()).optional(),
+          newState: z17.record(z17.string(), z17.unknown()),
+          reason: z17.string().max(1e4),
+          evidence: z17.string().max(1e4).optional(),
+          timestamp: z17.string(),
+          updatedBy: z17.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()
+  counterfactuals: z17.array(
+    z17.object({
+      counterfactualId: z17.string(),
+      hypothesis: z17.string().max(1e4),
+      affectedBeliefs: z17.array(z17.string()),
+      predictedOutcomes: z17.array(z17.string()),
+      actualOutcomes: z17.array(z17.string()).optional(),
+      validated: z17.boolean(),
+      createdAt: z17.string(),
+      taskContext: z17.string().optional()
     })
   ),
-  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()
+  hindsightRecords: z17.array(
+    z17.object({
+      taskId: z17.string(),
+      records: z17.array(
+        z17.object({
+          hindsightId: z17.string(),
+          taskId: z17.string(),
+          priorBeliefs: z17.array(z17.string()),
+          expectedOutcome: z17.string().max(1e4),
+          actualOutcome: z17.string().max(1e4),
+          outcomeMatched: z17.boolean(),
+          correctedBeliefs: z17.array(z17.string()),
+          newBeliefs: z17.array(z17.string()),
+          lessons: z17.array(z17.string()),
+          createdAt: z17.string()
         })
       )
     })
@@ -9981,23 +10304,23 @@ function getSnapshotFiles() {
     return [];
   }
 }
-function enforceRetention(logger11) {
+function enforceRetention(logger12) {
   try {
     const files = getSnapshotFiles();
     if (files.length <= MAX_SNAPSHOT_FILES) return;
     const toDelete = files.slice(MAX_SNAPSHOT_FILES);
     for (const file of toDelete) fs2.unlinkSync(path.join(getBeliefsDir(), file));
-    logger11.debug("Belief snapshot retention enforced", {
+    logger12.debug("Belief snapshot retention enforced", {
       kept: MAX_SNAPSHOT_FILES,
       deleted: toDelete.length
     });
   } catch (error) {
-    logger11.debug("Belief snapshot retention cleanup failed", {
+    logger12.debug("Belief snapshot retention cleanup failed", {
       error: getErrorMessage(error)
     });
   }
 }
-function saveBeliefSnapshot(data, logger11) {
+function saveBeliefSnapshot(data, logger12) {
   try {
     ensureBeliefsDir();
     const snapshot = createSnapshot(data);
@@ -10005,20 +10328,20 @@ function saveBeliefSnapshot(data, logger11) {
     const filename = `beliefs-${timestamp}.json`;
     const filepath = path.join(getBeliefsDir(), filename);
     fs2.writeFileSync(filepath, JSON.stringify(snapshot, null, 2), "utf-8");
-    logger11.info("Belief memory snapshot saved", { filename, beliefs: snapshot.beliefs.length });
-    enforceRetention(logger11);
+    logger12.info("Belief memory snapshot saved", { filename, beliefs: snapshot.beliefs.length });
+    enforceRetention(logger12);
     return ok(filepath);
   } catch (error) {
     const message = getErrorMessage(error);
     return err(new Error(`Failed to save belief snapshot: ${message}`));
   }
 }
-function loadBeliefSnapshot(logger11) {
+function loadBeliefSnapshot(logger12) {
   try {
     ensureBeliefsDir();
     const files = getSnapshotFiles();
     if (files.length === 0) {
-      logger11.debug("No belief snapshots found");
+      logger12.debug("No belief snapshots found");
       return ok(null);
     }
     for (const file of files.slice(0, 3)) {
@@ -10027,20 +10350,20 @@ function loadBeliefSnapshot(logger11) {
         const raw = JSON.parse(fs2.readFileSync(filepath, "utf-8"));
         const validation = BeliefSnapshotSchema.safeParse(raw);
         if (!validation.success) {
-          logger11.warn("Invalid belief snapshot file", { file, errors: validation.error.issues });
+          logger12.warn("Invalid belief snapshot file", { file, errors: validation.error.issues });
           continue;
         }
         const hydrated = hydrateSnapshot(validation.data);
-        logger11.info("Belief memory snapshot loaded", { file, beliefs: hydrated.beliefs.size });
+        logger12.info("Belief memory snapshot loaded", { file, beliefs: hydrated.beliefs.size });
         return ok(hydrated);
       } catch (error) {
-        logger11.warn("Failed to load belief snapshot file", {
+        logger12.warn("Failed to load belief snapshot file", {
           file,
           error: getErrorMessage(error)
         });
       }
     }
-    logger11.warn("All recent belief snapshots are invalid");
+    logger12.warn("All recent belief snapshots are invalid");
     return ok(null);
   } catch (error) {
     const message = getErrorMessage(error);
@@ -10049,81 +10372,81 @@ function loadBeliefSnapshot(logger11) {
 }
 
 // src/context/memory-types.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/context/memory-module-types.ts
-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()
+import { z as z18 } from "zod";
+var CoreMemoryDataSchema = z18.object({
+  agentId: z18.string().min(1),
+  role: z18.string(),
+  name: z18.string().min(1),
+  constraints: z18.array(z18.string()),
+  capabilities: z18.array(z18.string()),
+  systemPrompt: z18.string().max(5e4).optional(),
+  temperament: z18.enum(["cautious", "balanced", "exploratory"]).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 EpisodeDataSchema = z18.object({
+  episodeId: z18.string().min(1),
+  taskId: z18.string().min(1),
+  agentId: z18.string().min(1),
+  action: z18.string().min(1),
+  outcome: z18.enum(["success", "failure", "partial"]),
+  context: z18.record(z18.string(), z18.unknown()),
+  learnings: z18.array(z18.string()).optional(),
+  timestamp: z18.date(),
+  durationMs: z18.number().positive().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 SemanticFactSchema = z18.object({
+  factId: z18.string().min(1),
+  domain: z18.string().min(1),
+  subject: z18.string().min(1),
+  predicate: z18.string().min(1),
+  object: z18.string(),
+  confidence: z18.number().min(0).max(1),
+  source: z18.string().optional(),
+  validUntil: z18.date().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 ProcedureStepSchema = z18.object({
+  stepId: z18.string().min(1),
+  action: z18.string().min(1),
+  parameters: z18.record(z18.string(), z18.unknown()).optional(),
+  preconditions: z18.array(z18.string()).optional(),
+  postconditions: z18.array(z18.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 ProcedureSchema = z18.object({
+  procedureId: z18.string().min(1),
+  name: z18.string().min(1),
+  description: z18.string().max(1e4),
+  steps: z18.array(ProcedureStepSchema).max(100),
+  triggerConditions: z18.array(z18.string()),
+  successRate: z18.number().min(0).max(1),
+  executionCount: z18.number().int().min(0),
+  averageDurationMs: z18.number().positive().optional(),
+  tags: z18.array(z18.string()).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 ResourceReferenceSchema = z18.object({
+  resourceId: z18.string().min(1),
+  type: z18.enum(["file", "url", "api", "database", "other"]),
+  location: z18.string().min(1),
+  name: z18.string().min(1),
+  mimeType: z18.string().optional(),
+  size: z18.number().int().positive().optional(),
+  hash: z18.string().optional(),
+  lastAccessed: z18.date(),
+  lastModified: z18.date().optional(),
+  metadata: z18.record(z18.string(), z18.unknown()).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()
+var VaultEntrySchema = z18.object({
+  vaultId: z18.string().min(1),
+  category: z18.enum(["insight", "decision", "pattern", "config", "archive"]),
+  title: z18.string().min(1),
+  content: z18.unknown(),
+  importance: z18.enum(["critical", "high", "normal"]),
+  createdAt: z18.date(),
+  updatedAt: z18.date(),
+  expiresAt: z18.date().optional(),
+  tags: z18.array(z18.string()).optional(),
+  relatedIds: z18.array(z18.string()).optional()
 });
 
 // src/context/memory-types.ts
@@ -10137,7 +10460,7 @@ var MemoryType = {
   /** Hindsight Belief Memory for reasoning agents (arXiv:2512.12818) */
   BELIEF: "belief"
 };
-var MemoryTypeSchema = z18.enum([
+var MemoryTypeSchema = z19.enum([
   "core",
   "episodic",
   "semantic",
@@ -10436,7 +10759,7 @@ var KnowledgeVaultImpl = class {
 };
 
 // src/context/typed-memory.ts
-var logger9 = createLogger({ component: "typed-memory" });
+var logger10 = createLogger({ component: "typed-memory" });
 var TypedMemory = class {
   core;
   episodic;
@@ -10457,7 +10780,7 @@ var TypedMemory = class {
     this.resource = new ResourceMemoryImpl(backend);
     this.vault = new KnowledgeVaultImpl(backend);
     this.belief = new HindsightBeliefMemory();
-    logger9.info("TypedMemory initialized");
+    logger10.info("TypedMemory initialized");
   }
   async queryByType(type, query, limit = 20) {
     const result = await this.backend.search(`${type} ${query}`, limit);
@@ -10499,7 +10822,7 @@ var TypedMemory = class {
   async pruneExpired() {
     const result = await this.backend.prune(new Date(getTimeProvider().now()));
     if (!result.ok) return result;
-    logger9.info("Pruned expired entries", { count: result.value });
+    logger10.info("Pruned expired entries", { count: result.value });
     return ok({
       prunedCount: result.value,
       prunedByType: {
@@ -10542,11 +10865,11 @@ var MemoryPromoter = class {
   agentic;
   config;
   log;
-  constructor(beliefs, agentic, config = {}, logger11) {
+  constructor(beliefs, agentic, config = {}, logger12) {
     this.beliefs = beliefs;
     this.agentic = agentic;
     this.config = { ...DEFAULT_PROMOTION_CONFIG, ...config };
-    this.log = logger11 ?? createLogger({ component: "MemoryPromoter" });
+    this.log = logger12 ?? createLogger({ component: "MemoryPromoter" });
   }
   /**
    * Promote high-confidence session learnings to structured beliefs.
@@ -10699,8 +11022,8 @@ var DEFAULT_DECAY_CONFIG = {
 var CrossReferenceTracker = class {
   references = /* @__PURE__ */ new Map();
   log;
-  constructor(logger11) {
-    this.log = logger11 ?? createLogger({ component: "CrossReferenceTracker" });
+  constructor(logger12) {
+    this.log = logger12 ?? createLogger({ component: "CrossReferenceTracker" });
   }
   /**
    * Register a cross-reference between two memories.
@@ -10785,9 +11108,9 @@ var MemoryDecayManager = class {
   agentic = null;
   adaptive = null;
   mobimem = null;
-  constructor(config = {}, logger11) {
+  constructor(config = {}, logger12) {
     this.config = { ...DEFAULT_DECAY_CONFIG, ...config };
-    this.log = logger11 ?? createLogger({ component: "MemoryDecayManager" });
+    this.log = logger12 ?? createLogger({ component: "MemoryDecayManager" });
     this.tracker = new CrossReferenceTracker(this.log);
   }
   /**
@@ -11150,8 +11473,8 @@ var TYPED_DB_PATH = path2.join(MEMORY_BASE, "typed.db");
 var MOBIMEM_DB_PATH = path2.join(MEMORY_BASE, "mobimem.db");
 var MARKDOWN_DIR = path2.join(MEMORY_BASE, "markdown");
 var sharedInstance = null;
-function getToolMemory(logger11) {
-  sharedInstance ??= new ToolMemoryManager(logger11);
+function getToolMemory(logger12) {
+  sharedInstance ??= new ToolMemoryManager(logger12);
   return sharedInstance;
 }
 function shutdownToolMemory() {
@@ -11172,8 +11495,8 @@ var ToolMemoryManager = class {
   mobimem = null;
   decayManager = null;
   initPromise = null;
-  constructor(logger11) {
-    this.log = logger11 ?? createLogger({ component: "ToolMemory" });
+  constructor(logger12) {
+    this.log = logger12 ?? createLogger({ component: "ToolMemory" });
     this.memory = new SessionMemory({
       memoryDir: DEFAULT_MEMORY_DIR,
       logger: this.log
@@ -11859,10 +12182,10 @@ import { appendFileSync, readFileSync as readFileSync3, writeFileSync as writeFi
 var PersistentOutcomeStore = class extends OutcomeStore {
   filePath;
   logger;
-  constructor(config, logger11) {
+  constructor(config, logger12) {
     super(config);
     this.filePath = config?.filePath ?? getOutcomesFile();
-    this.logger = logger11 ?? createLogger({ component: "PersistentOutcomeStore" });
+    this.logger = logger12 ?? createLogger({ component: "PersistentOutcomeStore" });
     const dataDir = config?.dataDir;
     ensureLearningDir(dataDir);
     this.hydrate();
@@ -12003,11 +12326,11 @@ function emitTrendDetected(bus, detail) {
 }
 
 // src/mcp/tools/consensus-vote-recording.ts
-var logger10 = createLogger({ tool: "consensus-vote" });
+var logger11 = createLogger({ tool: "consensus-vote" });
 function recordVoteSuccess(proposal, strategy, outcome, duration, votes) {
   const allSimulated = votes !== void 0 && votes.length > 0 && votes.every((v) => v.source === "simulation");
   if (allSimulated) {
-    logger10.debug("Skipping memory + outcome recording \u2014 all votes simulated");
+    logger11.debug("Skipping memory + outcome recording \u2014 all votes simulated");
     return;
   }
   try {
@@ -12024,10 +12347,10 @@ function recordVoteSuccess(proposal, strategy, outcome, duration, votes) {
       source: "consensus-vote"
     });
     void memory.runPromotionPipeline().catch((error) => {
-      logger10.warn("Promotion pipeline failed", { error });
+      logger11.warn("Promotion pipeline failed", { error });
     });
   } catch (error) {
-    logger10.warn("Failed to record vote success to memory", { error: getErrorMessage(error) });
+    logger11.warn("Failed to record vote success to memory", { error: getErrorMessage(error) });
   }
   if (votes !== void 0) {
     recordVoteOutcomes(votes);
@@ -12042,7 +12365,7 @@ function recordVoteError(proposal, errorMessage) {
       filePattern: "mcp/tools/consensus-vote"
     });
   } catch (error) {
-    logger10.warn("Failed to record vote error", { error: getErrorMessage(error) });
+    logger11.warn("Failed to record vote error", { error: getErrorMessage(error) });
   }
 }
 function recordVoteOutcomes(votes) {
@@ -12069,7 +12392,7 @@ function recordVoteOutcomes(votes) {
       });
     }
   } catch (error) {
-    logger10.debug("Best-effort vote outcome recording failed", { error: getErrorMessage(error) });
+    logger11.debug("Best-effort vote outcome recording failed", { error: getErrorMessage(error) });
   }
 }
 
@@ -12078,15 +12401,327 @@ var WARNED = /* @__PURE__ */ new Set();
 function isTestRunner() {
   return process.env.VITEST === "true" || process.env.NODE_ENV === "test";
 }
-function warnIfSimulatedOutsideTests(toolName, logger11) {
+function warnIfSimulatedOutsideTests(toolName, logger12) {
   if (isTestRunner()) return;
   if (WARNED.has(toolName)) return;
   WARNED.add(toolName);
-  logger11.warn(
+  logger12.warn(
     `[${toolName}] simulateVotes=true: output is RANDOM and reserved for tests/demos. Do not treat the result as a real decision.`
   );
 }
 
+// src/mcp/tool-annotations.ts
+var TOOL_ANNOTATIONS = {
+  // ============================================================================
+  // Orchestration & expert lifecycle
+  // ============================================================================
+  /** Orchestrator coordinates expert agents; spawns workers that may mutate state. */
+  orchestrate: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  /** Creates an expert and adds it to the in-memory expert registry. */
+  create_expert: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false
+  },
+  /** Executes a previously created expert; invokes external CLIs. */
+  execute_expert: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  // ============================================================================
+  // Workflow / pipeline execution
+  // ============================================================================
+  /** Runs a workflow template; steps may write to the registry or filesystem. */
+  run_workflow: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  /** Runs a graph-based workflow with checkpointing. */
+  run_graph_workflow: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  /** Runs a pipeline plugin by name. */
+  run_pipeline: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  /** Full dev pipeline: research → plan → vote → implement → QA. */
+  run_dev_pipeline: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  /** Executes an AI-software-factory spec pipeline. */
+  execute_spec: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  // ============================================================================
+  // Voting / decision
+  // ============================================================================
+  /** Records vote outcomes to the audit log; doesn't write to repo state. */
+  consensus_vote: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  /** Per-axis tradeoff vote; records outcome to the store. */
+  supply_chain_tradeoff_panel: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  /** Multi-voter PR review; may write review comments. */
+  pr_review: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  // ============================================================================
+  // Routing & introspection (read-only)
+  // ============================================================================
+  /** Returns a routing recommendation; doesn't execute. */
+  delegate_to_model: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  /** Lists registered expert types. */
+  list_experts: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  /** Lists registered workflow templates. */
+  list_workflows: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  // ============================================================================
+  // Research registry — reads
+  // ============================================================================
+  /** Queries the research registry. */
+  research_query: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  /** Analyzes registry for gaps, trends, coverage. */
+  research_analyze: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  /** Synthesizes registry into topic clusters. */
+  research_synthesize: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  /** Discovers research items via external APIs; doesn't mutate registry. */
+  research_discover: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  // ============================================================================
+  // Research registry — mutations
+  // ============================================================================
+  /** Adds an arXiv paper to the registry. Dedup-checked but first call has effects. */
+  research_add: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  /** Adds a non-paper source to the registry. */
+  research_add_source: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  /** Reviews auto-cataloged research references; may approve/dismiss. */
+  research_catalog_review: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false
+  },
+  // ============================================================================
+  // Transient lookups (no registry persistence)
+  // ============================================================================
+  /** Transient OSS search via GitHub API; no persistence. */
+  survey_oss_landscape: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  /** Static lookup against curated vendor seed data. */
+  vendor_publishing_audit: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  /** Diffs two YAML/JSON files; local-only. */
+  compare_data_feeds: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  // ============================================================================
+  // Memory
+  // ============================================================================
+  /** Reads from memory backends. */
+  memory_query: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  /** Returns memory statistics. */
+  memory_stats: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  /** Writes to a memory backend. */
+  memory_write: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false
+  },
+  // ============================================================================
+  // Observability
+  // ============================================================================
+  /** Multi-CLI performance weather report; reads outcome store. */
+  weather_report: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  /** Queries execution traces from disk. */
+  query_trace: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  /** Queries structured task-state log. */
+  query_task_state: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  /** Verifies hash chain of audit log files. */
+  verify_audit_chain: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  /** Threshold-gated observability loop; may file GitHub issues when fileIssues=true. */
+  improvement_review: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  // ============================================================================
+  // Repository analysis
+  // ============================================================================
+  /** Analyzes a GitHub repository structure; doesn't write. */
+  repo_analyze: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  /** Generates a security-scanning pipeline plan; returns plan, doesn't write it. */
+  repo_security_plan: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  /** Extracts code symbols from source files. */
+  extract_symbols: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  /** Searches codebase for patterns or symbols. */
+  search_codebase: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  // ============================================================================
+  // Issue triage & registry imports
+  // ============================================================================
+  /** Triages a GitHub issue; may write labels/comments when authorized. */
+  issue_triage: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  /** Generates a draft model-registry entry; doesn't write. */
+  registry_import: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  }
+};
+function getToolAnnotations(name) {
+  const a = TOOL_ANNOTATIONS[name];
+  if (a === void 0) {
+    throw new Error(
+      `getToolAnnotations: no entry for tool "${name}". Add it to TOOL_ANNOTATIONS in src/mcp/tool-annotations.ts (#2648).`
+    );
+  }
+  return a;
+}
+
 // src/mcp/tools/consensus-vote.ts
 var persistentCorrelationTracker;
 function getOrCreateCorrelationTracker() {
@@ -12133,6 +12768,21 @@ function createEmptyConsensusResult(proposal, algorithm) {
     durationMs: 0
   };
 }
+function createPolicyFailedResult(proposal, algorithm, reason) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    proposalId: "error-policy-short-circuit",
+    proposal: { title: `MCP Consensus Vote \u2014 ${reason}`, description: proposal, algorithm },
+    outcome: "rejected",
+    votes: /* @__PURE__ */ new Map(),
+    voteCounts: { approve: 0, reject: 0, abstain: 0, total: 0 },
+    approvalPercentage: 0,
+    quorumReached: false,
+    startedAt: now,
+    closedAt: now,
+    durationMs: 0
+  };
+}
 var CASCADE_THRESHOLDS = {
   majority: 0.5,
   supermajority: 0.67,
@@ -12159,9 +12809,8 @@ function detectEarlyCascade(algorithm, approvals, rejections, total) {
   }
   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);
+async function processVotesThroughEngine(engineVotes, proposal, algorithm) {
+  if (engineVotes.length === 0) return createEmptyConsensusResult(proposal, algorithm);
   const engine = createConsensusEngine();
   const engineProposal = {
     title: "MCP Consensus Vote",
@@ -12174,7 +12823,7 @@ async function processVotesThroughEngine(votes, proposal, algorithm) {
       cause: proposalResult.error
     });
   const proposalId = proposalResult.value;
-  for (const { role, vote } of validVotes) await engine.vote(proposalId, role, vote);
+  for (const { role, vote } of engineVotes) await engine.vote(proposalId, role, vote);
   const resultRes = await engine.close(proposalId);
   if (!resultRes.ok)
     throw new Error(`Failed to close proposal: ${resultRes.error.message}`, {
@@ -12182,22 +12831,22 @@ async function processVotesThroughEngine(votes, proposal, algorithm) {
     });
   return resultRes.value;
 }
-function runHigherOrderVoting(strategy, voteMap, logger11) {
+function runHigherOrderVoting(strategy, voteMap, logger12) {
   if (strategy !== "higher_order") return void 0;
   const hovStrategy = new HigherOrderVotingStrategy();
   const tracker = getOrCreateCorrelationTracker();
   const result = hovStrategy.aggregate(voteMap, tracker);
-  logger11.info("Higher-Order Voting complete", {
+  logger12.info("Higher-Order Voting complete", {
     method: result.method,
     decision: result.decision,
     posteriorApproval: result.posteriorApproval.toFixed(3)
   });
   return result;
 }
-function recordVotesToTracker(votes, voteMap, outcome, logger11) {
+function recordVotesToTracker(votes, voteMap, outcome, logger12) {
   const allVotesReal = votes.every((v) => v.source === "llm");
   if (!allVotesReal) {
-    logger11.warn("Skipping correlation recording due to non-LLM votes", {
+    logger12.warn("Skipping correlation recording due to non-LLM votes", {
       count: votes.filter((v) => v.source !== "llm").length
     });
     return;
@@ -12205,22 +12854,21 @@ function recordVotesToTracker(votes, voteMap, outcome, logger11) {
   const tracker = getOrCreateCorrelationTracker();
   const id = `consensus-${String(getTimeProvider().now())}-${getRandomProvider().random().toString(36).slice(2, 9)}`;
   tracker.recordProposalVotes(id, voteMap, outcome);
-  logger11.debug("Recorded votes to tracker", { proposalId: id, outcome });
+  logger12.debug("Recorded votes to tracker", { proposalId: id, outcome });
   try {
     const persisted = createPersistedProposal(id, voteMap, outcome);
     const saveResult = saveCorrelationData([persisted]);
     if (!saveResult.ok) {
-      logger11.warn("Failed to persist correlation data", { error: saveResult.error.message });
+      logger12.warn("Failed to persist correlation data", { error: saveResult.error.message });
     }
   } catch (error) {
     const message = getErrorMessage(error);
-    logger11.warn("Error persisting correlation data", { error: message });
+    logger12.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;
+async function processVotesWithCascade(engineVotes, opts) {
+  const approvals = engineVotes.filter((v) => v.vote.decision === "approve").length;
+  const rejections = engineVotes.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", {
@@ -12230,11 +12878,9 @@ async function processVotesWithCascade(votes, opts) {
       reason: cascadeInfo.reason
     });
   }
-  const engineResult = await processVotesThroughEngine(votes, opts.proposal, opts.algorithm);
+  const engineResult = await processVotesThroughEngine(engineVotes, opts.proposal, opts.algorithm);
   const voteMap = /* @__PURE__ */ new Map();
-  for (const { role, vote, source } of votes) {
-    if (source !== "error") voteMap.set(role, vote);
-  }
+  for (const { role, vote } of engineVotes) 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 };
@@ -12242,7 +12888,7 @@ async function processVotesWithCascade(votes, opts) {
 var CONTRARIAN_ESCALATION_THRESHOLD = 0.8;
 async function runContrarianCheck(proposal, log) {
   try {
-    const { executeExpert } = await import("./expert-bridge-DMDHHDEU.js");
+    const { executeExpert } = await import("./expert-bridge-3AWQHR65.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.",
@@ -12274,59 +12920,116 @@ async function runContrarianCheck(proposal, log) {
     return { shouldEscalate: false, reason: "", confidence: 0 };
   }
 }
-async function executeVoting(input, logger11) {
+function buildPolicyShortCircuitResult(args) {
+  args.logger.warn("Consensus vote short-circuited by error policy", {
+    errorPolicy: args.errorPolicy,
+    reason: args.reason
+  });
+  const totalTimeMs = getTimeProvider().now() - args.startTime;
+  return {
+    proposal: args.input.proposal,
+    threshold: args.algorithm,
+    result: createPolicyFailedResult(args.input.proposal, args.algorithm, args.reason),
+    votes: args.votes,
+    totalTimeMs,
+    simulateVotes: args.input.simulateVotes,
+    strategy: args.strategy
+  };
+}
+async function maybeEscalateContrarian(input, outcome, logger12, opts) {
+  if (!input.quickMode || outcome !== "approved" || input.simulateVotes) return void 0;
+  const escalation = await runContrarianCheck(input.proposal, logger12);
+  if (!escalation.shouldEscalate) return void 0;
+  logger12.warn("Contrarian escalation: re-running with full vote", {
+    reason: escalation.reason,
+    confidence: escalation.confidence
+  });
+  return executeVoting({ ...input, quickMode: false }, logger12, opts);
+}
+async function executeVoting(input, logger12, opts) {
   const strategy = resolveStrategy(input);
   const algorithm = strategyToAlgorithm(strategy);
   const roles = getVoterRoles(input.quickMode);
   const startTime = getTimeProvider().now();
-  logger11.info("Starting consensus vote", { strategy, algorithm, roleCount: roles.length });
+  const errorPolicy = input.errorPolicy ?? getDefaultErrorPolicy(strategy);
+  logger12.info("Starting consensus vote", {
+    strategy,
+    algorithm,
+    roleCount: roles.length,
+    errorPolicy
+  });
   const votes = await collectRealVotes({
     roles,
     proposal: input.proposal,
-    simulate: input.simulateVotes
+    simulate: input.simulateVotes,
+    ...opts?.voteTimeoutMs !== void 0 && { timeoutMs: opts.voteTimeoutMs }
   });
-  const { engineResult, voteMap, higherOrderResult, outcome, cascaded } = await processVotesWithCascade(votes, {
+  const policyDecision = applyErrorPolicy(votes, errorPolicy);
+  if (policyDecision.shortCircuit) {
+    return buildPolicyShortCircuitResult({
+      input,
+      strategy,
+      algorithm,
+      votes,
+      errorPolicy,
+      reason: policyDecision.reason ?? "error policy short-circuit",
+      startTime,
+      logger: logger12
+    });
+  }
+  const { engineResult, voteMap, higherOrderResult, outcome, cascaded } = await processVotesWithCascade(policyDecision.engineVotes, {
     totalRoles: roles.length,
     proposal: input.proposal,
     algorithm,
     strategy,
-    log: logger11
+    log: logger12
   });
-  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 totalTimeMs = getTimeProvider().now() - startTime;
-  logger11.info("Consensus vote completed", { strategy, outcome, durationMs: totalTimeMs, cascaded });
-  const result = {
-    proposal: input.proposal,
-    threshold: algorithm,
-    result: engineResult,
+  recordVotesToTracker(votes, voteMap, outcome, logger12);
+  const escalated = await maybeEscalateContrarian(input, outcome, logger12, opts);
+  if (escalated !== void 0) return escalated;
+  return finalizeVotingResult({
+    input,
+    strategy,
+    algorithm,
+    engineResult,
+    higherOrderResult,
     votes,
+    outcome,
+    cascaded,
+    startTime,
+    logger: logger12
+  });
+}
+function finalizeVotingResult(args) {
+  const totalTimeMs = getTimeProvider().now() - args.startTime;
+  args.logger.info("Consensus vote completed", {
+    strategy: args.strategy,
+    outcome: args.outcome,
+    durationMs: totalTimeMs,
+    cascaded: args.cascaded
+  });
+  const result = {
+    proposal: args.input.proposal,
+    threshold: args.algorithm,
+    result: args.engineResult,
+    votes: args.votes,
     totalTimeMs,
-    simulateVotes: input.simulateVotes,
-    strategy
+    simulateVotes: args.input.simulateVotes,
+    strategy: args.strategy
   };
-  if (higherOrderResult !== void 0) result.higherOrderResult = higherOrderResult;
+  if (args.higherOrderResult !== void 0) result.higherOrderResult = args.higherOrderResult;
   return result;
 }
 async function handleConsensusVote(deps, args) {
-  const logger11 = deps.logger ?? createLogger({ tool: "consensus_vote" });
-  if (args.simulateVotes) warnIfSimulatedOutsideTests("consensus_vote", logger11);
+  const logger12 = deps.logger ?? createLogger({ tool: "consensus_vote" });
+  if (args.simulateVotes) warnIfSimulatedOutsideTests("consensus_vote", logger12);
   try {
-    const result = await executeVoting(args, logger11);
+    const result = await executeVoting(args, logger12);
     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("; ");
-      logger11.warn("All voters failed", { failureCount: errorVotes.length, failures });
+      logger12.warn("All voters failed", { failureCount: errorVotes.length, failures });
       recordVoteError(args.proposal, `All ${String(errorVotes.length)} voters failed: ${failures}`);
       return {
         ok: false,
@@ -12344,7 +13047,7 @@ async function handleConsensusVote(deps, args) {
   } catch (error) {
     const message = getErrorMessage(error);
     const cause = error instanceof Error ? error : new Error(message);
-    logger11.error("Consensus vote failed", cause);
+    logger12.error("Consensus vote failed", cause);
     recordVoteError(args.proposal, message);
     return { ok: false, error: `Voting failed: ${message}` };
   }
@@ -12354,7 +13057,10 @@ function createConsensusVoteHandler(deps) {
   return async (args, ctx) => {
     const validationResult = ConsensusVoteInputSchema.safeParse(args);
     if (!validationResult.success) {
-      return toolError(`Validation error: ${formatZodError(validationResult.error)}`);
+      return toolStructuredError({
+        errorCategory: "validation",
+        message: `Validation error: ${formatZodError(validationResult.error)}`
+      });
     }
     const strategy = validationResult.data.strategy ?? "simple_majority";
     ctx.logger.debug("Starting consensus vote", {
@@ -12372,7 +13078,7 @@ function createConsensusVoteHandler(deps) {
       () => handleConsensusVote(deps, validationResult.data)
     );
     if (!result.ok) {
-      return toolError(result.error);
+      return toolStructuredError({ errorCategory: "internal", message: result.error });
     }
     for (const vote of result.value.votes) {
       notifier.debug("consensus_vote", {
@@ -12395,27 +13101,27 @@ function createConsensusVoteHandler(deps) {
   };
 }
 var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
-  proposal: z19.string(),
+  proposal: z20.string(),
   strategy: VotingStrategySchema,
-  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()
+  decision: z20.enum(["approved", "rejected", "no_quorum"]),
+  approvalPercentage: z20.number(),
+  voteCounts: z20.object({
+    approve: z20.number(),
+    reject: z20.number(),
+    abstain: z20.number(),
+    error: z20.number()
   }),
-  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([
+  votes: z20.array(
+    z20.object({
+      role: z20.string().max(100),
+      decision: z20.enum(["approve", "reject", "abstain"]),
+      confidence: z20.number(),
+      reasoning: z20.string().max(4e3),
+      simulated: z20.boolean(),
+      error: z20.boolean(),
+      modelUsed: z20.string().max(100).optional(),
+      rejectionCategories: z20.array(
+        z20.enum([
           "YAGNI",
           "DRY_VIOLATION",
           "OVER_ENGINEERING",
@@ -12427,50 +13133,55 @@ var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
       ).optional()
     })
   ),
-  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)
+  threshold: VoteThresholdSchema.optional(),
+  durationMs: z20.number(),
+  simulateVotes: z20.boolean(),
+  higherOrderMetadata: z20.object({
+    posteriorApproval: z20.number(),
+    posteriorRejection: z20.number(),
+    effectiveVoteCount: z20.number(),
+    method: z20.enum(["ow", "isp", "simple"]),
+    usedCorrelationData: z20.boolean(),
+    improvementOverBaseline: z20.number(),
+    downweightedAgents: z20.array(z20.string().max(100)).max(10),
+    reasoning: z20.string().max(2e3)
   }).optional()
 };
 function registerConsensusVoteTool(server, deps) {
-  const logger11 = deps.logger ?? createLogger({ tool: "consensus_vote" });
+  const logger12 = deps.logger ?? createLogger({ tool: "consensus_vote" });
   const notifier = deps.notifier ?? createMcpNotifier(server);
   const depsWithNotifier = { ...deps, notifier };
   const toolSchema = {
-    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."),
+    proposal: z20.string().min(1).max(MAX_PROPOSAL_LENGTH).describe("Proposal text to vote on"),
+    threshold: z20.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: z19.boolean().optional().default(false).describe("Use 3 agents instead of 7"),
-    simulateVotes: z19.boolean().optional().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
+    quickMode: z20.boolean().optional().default(false).describe("Use 3 agents instead of 7"),
+    simulateVotes: z20.boolean().optional().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
   };
   const description = "Execute multi-model consensus voting on a proposal. Uses 7 specialized agent roles (architect, security, devex, ai_ml, pm, catfish, scope_steward) 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: logger11
+    logger: logger12
   });
   const timeoutMs = getToolTimeout("consensus_vote", deps.security);
   const wrappedHandler = wrapToolWithTimeout("consensus_vote", secureHandler, {
     timeoutMs,
-    logger: logger11
+    logger: logger12
   });
   server.registerTool(
     "consensus_vote",
-    { description, inputSchema: toolSchema, outputSchema: CONSENSUS_VOTE_OUTPUT_SCHEMA },
-    toSdkCallback(wrappedHandler)
+    {
+      description,
+      inputSchema: toolSchema,
+      outputSchema: CONSENSUS_VOTE_OUTPUT_SCHEMA,
+      annotations: getToolAnnotations("consensus_vote")
+    },
+    toSdkCallbackWithBudgetCheck(wrappedHandler, "consensus_vote", timeoutMs, logger12)
   );
-  logger11.info("Registered consensus_vote tool with secure handler and timeout protection");
+  logger12.info("Registered consensus_vote tool with secure handler and timeout protection");
 }
 
 export {
@@ -12486,6 +13197,8 @@ export {
   getGlobalEventBus,
   createEvent,
   EventTopics,
+  withModelNotFoundFallback,
+  wrapResilientWithFallback,
   createUnifiedRegistry,
   getGlobalRegistry,
   DEFAULT_RELEVANCE_CONFIG,
@@ -12508,6 +13221,10 @@ export {
   logToolInvocationAudit,
   logPolicyAudit,
   logRateLimitAudit,
+  toolSuccess,
+  toolSuccessStructured,
+  toolStructuredError,
+  toolError,
   createSecureHandler,
   createMcpNotifier,
   NOOP_NOTIFIER,
@@ -12517,9 +13234,8 @@ export {
   getToolTimeout,
   wrapToolWithTimeout,
   toSdkCallback,
-  toolSuccess,
-  toolSuccessStructured,
-  toolError,
+  toSdkCallbackWithBudgetCheck,
+  getToolAnnotations,
   getToolMemory,
   shutdownToolMemory,
   PersistentOutcomeStore,
@@ -12527,8 +13243,6 @@ export {
   emitTrendDetected,
   DEFAULT_VOTE_TIMEOUT_MS,
   isRateLimitError,
-  validateTimeout2 as validateTimeout,
-  THRESHOLD_MAP,
   VOTER_ROLES,
   NoAdapterError,
   collectRealVotes,
@@ -12587,6 +13301,8 @@ export {
   CorrelationTracker,
   createCorrelationTracker,
   VotingStrategySchema,
+  ErrorPolicySchema,
+  VoteThresholdSchema,
   ConsensusVoteInputSchema,
   warnIfSimulatedOutsideTests,
   resetCorrelationTracker,
@@ -12594,4 +13310,4 @@ export {
   CONSENSUS_VOTE_OUTPUT_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-53K3KEKT.js.map
+//# sourceMappingURL=chunk-T5VPZZYX.js.map