nexus-agents 2.94.0 → 2.96.0

package/dist/{chunk-TNBWHOPY.js → chunk-Z7PILY4E.js}

@@ -4,1820 +4,90 @@ import {
   createStream,
   requireApiKey,
   validateApiKeyPresence
-} from "./chunk-L7I55FAN.js";
+} from "./chunk-AW3HJHJT.js";
 import {
   CUSTOM_API_BASE_URL_ENV,
   PROVIDER_ENV_KEYS,
   validateCustomApiBaseUrl
-} from "./chunk-YDXGYKZJ.js";
+} from "./chunk-SSHL5TAX.js";
 import {
-  getToolMemory
-} from "./chunk-63OGXDHS.js";
-import {
-  getDefaultAvailableModelsCache
-} from "./chunk-KSJPDQSG.js";
-import {
-  CUSTOM_API_DEFAULT_MODEL
-} from "./chunk-43UDRX3N.js";
-import {
-  createCliAdapter,
-  createCliDetectionCache,
-  delay,
-  getAvailableClis,
-  isCliAvailable,
-  sanitizeOutput,
-  withTimeout
-} from "./chunk-4QESFYGV.js";
-import {
-  AgentError,
-  CACHE_TIMEOUTS,
-  CLI_NAMES,
-  CircularBuffer,
-  DEFAULT_CLI,
-  ErrorCode,
-  MCP_TIMEOUTS,
-  ModelCapability,
-  ModelError,
-  OutcomeStore,
-  SecurityError,
-  TASK_SPECIALIZATION_MATRIX,
-  TIMEOUT_GUARD,
-  TaskOutcomeSchema,
-  VOTE_TIMEOUTS,
-  ValidationError,
-  categorizeOutcomeErrorMessage,
-  clamp01,
-  createLogger,
-  createMetricsMiddleware,
-  detectTaskCategory,
-  err,
-  estimateTokens,
-  formatPercentage,
-  formatZodError,
-  getCliModelName,
-  getDefaultModelForCli,
-  getDefaultRegistry,
-  getErrorMessage,
-  getInTreeCapabilitiesMatrix,
-  getMcpSafeDeadlineMs,
-  getOutcomeStore,
-  getPipelineEventBus,
-  getRandomProvider,
-  getTimeProvider,
-  getTokenEstimator,
-  isRateLimitLikeError,
-  ok,
-  recordRateLimitEvent,
-  registerPersistentOutcomeStoreFactory,
-  resolveCliAlias,
-  resolveVoteTimeout,
-  toRateLimitError
-} from "./chunk-OT6V5ROA.js";
-import {
-  ensureLearningDir,
-  getNexusDataDir,
-  getOutcomesFile,
-  nexusDataPath,
-  nexusDataPathEnsure
-} from "./chunk-CH7QIDHQ.js";
-
-// src/mcp/tools/consensus-vote.ts
-import { z as z12 } 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) {
-    try {
-      server.sendLoggingMessage({ level, logger: logger11, data }).catch((error) => {
-        internalLogger.debug("Failed to send MCP notification", {
-          level,
-          logger: logger11,
-          error: getErrorMessage(error)
-        });
-      });
-    } catch (error) {
-      internalLogger.debug("Failed to send MCP notification", {
-        level,
-        logger: logger11,
-        error: getErrorMessage(error)
-      });
-    }
-  }
-  return {
-    info: (logger11, data) => {
-      send("info", logger11, data);
-    },
-    debug: (logger11, data) => {
-      send("debug", logger11, data);
-    },
-    warn: (logger11, data) => {
-      send("warning", logger11, data);
-    }
-  };
-}
-var NOOP_NOTIFIER = {
-  info: () => void 0,
-  debug: () => void 0,
-  warn: () => void 0
-};
-var progressContextStorage = new AsyncLocalStorage();
-var abortSignalStorage = new AsyncLocalStorage();
-async function withProgressHeartbeat(toolName, notifier, operation, intervalMs = 15e3) {
-  const startTime = Date.now();
-  let beatCount = 0;
-  const progressCtx = progressContextStorage.getStore();
-  const timer = setInterval(() => {
-    beatCount++;
-    const elapsed = Math.round((Date.now() - startTime) / 1e3);
-    if (progressCtx !== void 0) {
-      progressCtx.sendNotification(beatCount);
-    }
-    notifier.debug(toolName, {
-      event: "heartbeat",
-      elapsedSeconds: elapsed,
-      beatCount,
-      hasProgressToken: progressCtx !== void 0
-    });
-  }, intervalMs);
-  try {
-    return await operation();
-  } finally {
-    clearInterval(timer);
-  }
-}
-
-// src/mcp/middleware/tool-wrapper.ts
-import { randomUUID } from "crypto";
-import { appendFileSync, existsSync, mkdirSync } from "fs";
-import { dirname, join } from "path";
-
-// src/mcp/middleware/rate-limiter.ts
-var DEFAULT_REFILL_INTERVAL_MS = CACHE_TIMEOUTS.rateLimitRefillMs;
-var RateLimiter = class {
-  tokens;
-  capacity;
-  refillRate;
-  refillIntervalMs;
-  lastRefillTime;
-  logger;
-  name;
-  constructor(config) {
-    this.capacity = config.capacity;
-    this.refillRate = config.refillRate;
-    this.refillIntervalMs = config.refillIntervalMs ?? DEFAULT_REFILL_INTERVAL_MS;
-    this.tokens = this.capacity;
-    this.lastRefillTime = getTimeProvider().now();
-    this.name = config.name ?? "rate-limiter";
-    this.logger = config.logger ?? createLogger({ component: this.name });
-    this.logger.debug("Rate limiter initialized", {
-      capacity: this.capacity,
-      refillRate: this.refillRate,
-      refillIntervalMs: this.refillIntervalMs
-    });
-  }
-  /**
-   * Refills tokens based on elapsed time.
-   * Called automatically before each acquire attempt.
-   */
-  refill() {
-    const now = getTimeProvider().now();
-    const elapsed = now - this.lastRefillTime;
-    const intervals = Math.floor(elapsed / this.refillIntervalMs);
-    if (intervals > 0) {
-      const tokensToAdd = intervals * this.refillRate;
-      this.tokens = Math.min(this.capacity, this.tokens + tokensToAdd);
-      this.lastRefillTime = now - elapsed % this.refillIntervalMs;
-      if (tokensToAdd > 0) {
-        this.logger.debug("Tokens refilled", {
-          added: tokensToAdd,
-          current: this.tokens
-        });
-      }
-    }
-  }
-  /**
-   * Attempts to acquire a token.
-   *
-   * @param count - Number of tokens to acquire (default: 1)
-   * @returns True if tokens were acquired, false if rate limited
-   */
-  tryAcquire(count = 1) {
-    this.refill();
-    if (this.tokens >= count) {
-      this.tokens -= count;
-      this.logger.debug("Token acquired", {
-        requested: count,
-        remaining: this.tokens
-      });
-      return true;
-    }
-    this.logger.warn("Rate limit exceeded", {
-      requested: count,
-      available: this.tokens
-    });
-    return false;
-  }
-  /**
-   * Gets the current state of the rate limiter.
-   *
-   * @returns The current rate limiter state
-   */
-  getState() {
-    this.refill();
-    const nextTokenMs = this.tokens > 0 ? 0 : this.refillIntervalMs - (getTimeProvider().now() - this.lastRefillTime);
-    return {
-      tokens: this.tokens,
-      capacity: this.capacity,
-      nextTokenMs: Math.max(0, nextTokenMs)
-    };
-  }
-  /**
-   * Resets the rate limiter to full capacity.
-   * Useful for testing or after configuration changes.
-   */
-  reset() {
-    this.tokens = this.capacity;
-    this.lastRefillTime = getTimeProvider().now();
-    this.logger.debug("Rate limiter reset", { tokens: this.tokens });
-  }
-};
-function createDefaultRateLimiter(name, logger11) {
-  const config = {
-    capacity: 100,
-    refillRate: 10,
-    refillIntervalMs: 1e3
-  };
-  if (name !== void 0) {
-    config.name = name;
-  }
-  if (logger11 !== void 0) {
-    config.logger = logger11;
-  }
-  return new RateLimiter(config);
-}
-
-// src/mcp/middleware/validation.ts
-function validateToolInput(schema, args) {
-  const parsed = schema.safeParse(args);
-  if (parsed.success) {
-    return ok(parsed.data);
-  }
-  const message = formatZodError(parsed.error);
-  const validationError = new ValidationError(`Invalid tool input: ${message}`, {
-    context: {
-      issues: parsed.error.issues,
-      receivedType: typeof args
-    }
-  });
-  return err(validationError);
-}
-function createValidator(schema) {
-  return (args) => validateToolInput(schema, args);
-}
-
-// src/mcp/middleware/policy-types.ts
-import { z } from "zod";
-var PolicyError = class extends SecurityError {
-  decision;
-  constructor(message, decision) {
-    super(message, {
-      context: {
-        allowed: decision.allowed,
-        reason: decision.reason,
-        ruleName: decision.ruleName,
-        requiredArtifact: decision.requiredArtifact
-      }
-    });
-    this.name = "PolicyError";
-    this.decision = decision;
-  }
-};
-var PolicyConfigSchema = z.object({
-  defaultMode: z.enum(["read-only", "read-write"]).default("read-only"),
-  policyMode: z.enum(["enforce", "warn"]).default("enforce"),
-  allowedPaths: z.array(z.string()).default(["./"])
-});
-
-// src/mcp/middleware/policy-helpers.ts
-function isPathSafe(targetPath, allowedPaths) {
-  const normalizedTarget = normalizePath(targetPath);
-  for (const allowed of allowedPaths) {
-    const normalizedAllowed = normalizePath(allowed);
-    if (normalizedTarget.startsWith(normalizedAllowed)) {
-      return true;
-    }
-  }
-  return false;
-}
-function normalizePath(p) {
-  let normalized = p.replace(/\/{1,100}$/, "");
-  if (normalized === ".") {
-    normalized = "";
-  } else if (normalized.startsWith("./")) {
-    normalized = normalized.slice(2);
-  }
-  if (!normalized.startsWith("/")) {
-    normalized = "/" + normalized;
-  }
-  return normalized;
-}
-function extractPathFromArgs(args) {
-  if (args === null || typeof args !== "object") {
-    return void 0;
-  }
-  const argsObj = args;
-  const pathFields = ["path", "filePath", "file_path", "directory", "dir", "target"];
-  for (const field of pathFields) {
-    const value = argsObj[field];
-    if (typeof value === "string") {
-      return value;
-    }
-  }
-  return void 0;
-}
-
-// src/mcp/middleware/policy-rules.ts
-var MUTATION_TOOLS = /* @__PURE__ */ new Set([
-  "write_file",
-  "edit_file",
-  "delete_file",
-  "create_directory",
-  "remove_directory",
-  "execute_command",
-  "run_shell",
-  "bash",
-  "create_expert",
-  "run_workflow"
-]);
-var READ_ONLY_TOOLS = /* @__PURE__ */ new Set([
-  "read_file",
-  "list_directory",
-  "search_files",
-  "get_status",
-  "orchestrate",
-  "delegate_to_model"
-]);
-function isMutationTool(toolName) {
-  if (MUTATION_TOOLS.has(toolName)) {
-    return true;
-  }
-  if (READ_ONLY_TOOLS.has(toolName)) {
-    return false;
-  }
-  return true;
-}
-var denyMutationsWithoutModeRule = {
-  name: "deny-mutations-without-mode",
-  description: "Blocks write operations unless mode is read-write",
-  check(ctx) {
-    if (ctx.mode === "read-write") {
-      return { allowed: true, reason: "Read-write mode enabled" };
-    }
-    if (isMutationTool(ctx.toolName)) {
-      return {
-        allowed: false,
-        reason: `Tool '${ctx.toolName}' is a mutation operation but mode is '${ctx.mode}'. Set mode to 'read-write' to enable.`
-      };
-    }
-    return { allowed: true, reason: "Read-only operation allowed" };
-  }
-};
-var safePathsRule = {
-  name: "safe-paths",
-  description: "Validates paths against allowed root directories",
-  check(ctx) {
-    const targetPath = extractPathFromArgs(ctx.args);
-    if (targetPath === void 0) {
-      return { allowed: true, reason: "No path argument found" };
-    }
-    if (targetPath.includes("..")) {
-      return {
-        allowed: false,
-        reason: `Path contains '..' which may indicate path traversal: ${targetPath}`
-      };
-    }
-    const allowedPaths = ctx.allowedPaths ?? ["./"];
-    if (!isPathSafe(targetPath, allowedPaths)) {
-      return {
-        allowed: false,
-        reason: `Path '${targetPath}' is outside allowed directories: ${allowedPaths.join(", ")}`
-      };
-    }
-    return { allowed: true, reason: "Path is within allowed directories" };
-  }
-};
-
-// src/mcp/middleware/policy.ts
-var PolicyFirewall = class {
-  rules = [];
-  mode;
-  logger;
-  constructor(config) {
-    this.mode = config?.mode ?? "enforce";
-    this.logger = config?.logger ?? createLogger({ component: "policy-firewall" });
-    if (config?.rules) {
-      for (const rule of config.rules) {
-        this.rules.push(rule);
-      }
-    }
-    this.logger.debug("Policy firewall initialized", {
-      mode: this.mode,
-      ruleCount: this.rules.length
-    });
-  }
-  /**
-   * Evaluates all policy rules against the given context.
-   *
-   * Rules are evaluated in order. The first rule that denies stops
-   * evaluation and returns the denial decision.
-   *
-   * @param ctx - The policy context to evaluate
-   * @returns The policy decision
-   */
-  evaluate(ctx) {
-    this.logger.debug("Evaluating policy", {
-      toolName: ctx.toolName,
-      mode: ctx.mode,
-      ruleCount: this.rules.length
-    });
-    if (this.rules.length === 0) {
-      return this.allowWithReason(ctx, "No policy rules configured");
-    }
-    for (const rule of this.rules) {
-      const decision = rule.check(ctx);
-      if (!decision.allowed) {
-        return this.handleDenial(ctx, rule, decision);
-      }
-    }
-    return this.allowWithReason(ctx, "All policy rules passed");
-  }
-  /**
-   * Creates an allow decision with the given reason and logs it.
-   */
-  allowWithReason(ctx, reason) {
-    const decision = { allowed: true, reason };
-    this.logDecision(ctx, decision);
-    return decision;
-  }
-  /**
-   * Handles a rule denial, respecting warn mode if configured.
-   */
-  handleDenial(ctx, rule, decision) {
-    const denialDecision = {
-      ...decision,
-      ruleName: rule.name
-    };
-    this.logDecision(ctx, denialDecision);
-    if (this.mode === "warn") {
-      this.logger.warn("Policy denial overridden by warn mode", {
-        toolName: ctx.toolName,
-        ruleName: rule.name,
-        reason: decision.reason
-      });
-      return {
-        allowed: true,
-        reason: `[WARN MODE] Would be denied: ${decision.reason}`,
-        ruleName: rule.name
-      };
-    }
-    return denialDecision;
-  }
-  /**
-   * Adds a policy rule to the firewall.
-   *
-   * @param rule - The rule to add
-   */
-  addRule(rule) {
-    const existingIndex = this.rules.findIndex((r) => r.name === rule.name);
-    if (existingIndex >= 0) {
-      this.logger.warn("Replacing existing policy rule", { ruleName: rule.name });
-      this.rules[existingIndex] = rule;
-    } else {
-      this.rules.push(rule);
-      this.logger.debug("Policy rule added", { ruleName: rule.name });
-    }
-  }
-  /**
-   * Removes a policy rule by name.
-   *
-   * @param name - The name of the rule to remove
-   * @returns True if the rule was found and removed
-   */
-  removeRule(name) {
-    const index = this.rules.findIndex((r) => r.name === name);
-    if (index >= 0) {
-      this.rules.splice(index, 1);
-      this.logger.debug("Policy rule removed", { ruleName: name });
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Gets all registered policy rules.
-   *
-   * @returns A readonly array of policy rules
-   */
-  getRules() {
-    return [...this.rules];
-  }
-  /**
-   * Sets the policy enforcement mode.
-   *
-   * @param mode - The new enforcement mode
-   */
-  setMode(mode) {
-    const previousMode = this.mode;
-    this.mode = mode;
-    this.logger.info("Policy mode changed", { from: previousMode, to: mode });
-  }
-  /**
-   * Gets the current policy enforcement mode.
-   *
-   * @returns The current mode
-   */
-  getMode() {
-    return this.mode;
-  }
-  /**
-   * Logs a policy decision for audit purposes.
-   */
-  logDecision(ctx, decision) {
-    const logData = {
-      toolName: ctx.toolName,
-      mode: ctx.mode,
-      workflowId: ctx.workflowId,
-      allowed: decision.allowed,
-      reason: decision.reason,
-      ruleName: decision.ruleName
-    };
-    if (decision.allowed) {
-      this.logger.debug("Policy decision: ALLOWED", logData);
-    } else {
-      this.logger.warn("Policy decision: DENIED", logData);
-    }
-  }
-};
-function createDefaultPolicyFirewall(config) {
-  const firewall = new PolicyFirewall(config);
-  firewall.addRule(denyMutationsWithoutModeRule);
-  firewall.addRule(safePathsRule);
-  return firewall;
-}
-function evaluatePolicy(firewall, ctx) {
-  const decision = firewall.evaluate(ctx);
-  if (decision.allowed) {
-    return ok(void 0);
-  }
-  return err(new PolicyError(`Policy denied: ${decision.reason}`, decision));
-}
-function createPolicyContext(toolName, args, options) {
-  const base = {
-    toolName,
-    args,
-    mode: options?.mode ?? "read-only"
-  };
-  const result = { ...base };
-  if (options?.artifacts !== void 0) {
-    result["artifacts"] = options.artifacts;
-  }
-  if (options?.workflowId !== void 0) {
-    result["workflowId"] = options.workflowId;
-  }
-  if (options?.allowedPaths !== void 0) {
-    result["allowedPaths"] = options.allowedPaths;
-  }
-  return result;
-}
-
-// src/mcp/middleware/timeout-guard.ts
-var DEFAULT_TIMEOUT_MS = TIMEOUT_GUARD.defaultMs;
-var MAX_TIMEOUT_MS = TIMEOUT_GUARD.maxMs;
-var NEAR_TIMEOUT_THRESHOLD = TIMEOUT_GUARD.nearTimeoutThreshold;
-function createTimeoutError(operationName, timeoutMs) {
-  return {
-    code: "OPERATION_TIMEOUT",
-    message: `Operation '${operationName}' timed out after ${String(timeoutMs)}ms`,
-    operation: operationName,
-    timeoutMs
-  };
-}
-function createGuardError(error, operationName) {
-  const guardError = {
-    code: "GUARD_ERROR",
-    message: getErrorMessage(error),
-    operation: operationName
-  };
-  if (error instanceof Error) {
-    return { ...guardError, cause: error };
-  }
-  return guardError;
-}
-var TimeoutGuard = class {
-  defaultTimeoutMs;
-  maxTimeoutMs;
-  enableLogging;
-  logger;
-  constructor(config) {
-    this.defaultTimeoutMs = config?.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
-    this.maxTimeoutMs = config?.maxTimeoutMs ?? MAX_TIMEOUT_MS;
-    this.enableLogging = config?.enableLogging ?? true;
-    this.logger = config?.logger ?? createLogger({ component: "timeout-guard" });
-  }
-  /** Resolves effective timeout and operation name from options. */
-  resolveOptions(options) {
-    return {
-      timeoutMs: Math.min(options?.timeoutMs ?? this.defaultTimeoutMs, this.maxTimeoutMs),
-      operationName: options?.operationName ?? "unknown"
-    };
-  }
-  /**
-   * Executes an async operation with timeout protection.
-   */
-  async execute(operation, options) {
-    const { timeoutMs, operationName } = this.resolveOptions(options);
-    const validationError = this.validateTimeout(timeoutMs, operationName);
-    if (validationError !== null) {
-      return err(validationError);
-    }
-    return this.runGuarded(operation, timeoutMs, operationName, options);
-  }
-  /** Runs the operation with timeout and optional abort signal. */
-  async runGuarded(operation, timeoutMs, operationName, options) {
-    this.logStart(operationName, timeoutMs);
-    const startTime = getTimeProvider().now();
-    const state = { timeoutId: void 0, timedOut: false };
-    try {
-      const result = await this.runWithTimeout(
-        operation,
-        timeoutMs,
-        state,
-        options?.onTimeout,
-        options?.signal
-      );
-      return this.handleSuccess(result, startTime, timeoutMs, operationName);
-    } catch {
-      const cancelled = options?.signal?.aborted === true && !state.timedOut;
-      return err(
-        this.handleFailure(state.timedOut, operationName, timeoutMs, startTime, cancelled)
-      );
-    } finally {
-      if (state.timeoutId !== void 0) {
-        clearTimeout(state.timeoutId);
-      }
-    }
-  }
-  validateTimeout(timeoutMs, operationName) {
-    if (timeoutMs <= 0) {
-      return {
-        code: "INVALID_TIMEOUT",
-        message: `Invalid timeout: ${String(timeoutMs)}ms`,
-        operation: operationName
-      };
-    }
-    return null;
-  }
-  logStart(operationName, timeoutMs) {
-    if (this.enableLogging) {
-      this.logger.debug("Starting guarded operation", { operation: operationName, timeoutMs });
-    }
-  }
-  async runWithTimeout(operation, timeoutMs, state, onTimeout, signal) {
-    const timeoutPromise = new Promise((_resolve, reject) => {
-      state.timeoutId = setTimeout(() => {
-        state.timedOut = true;
-        onTimeout?.();
-        reject(new Error(`Operation timed out after ${String(timeoutMs)}ms`));
-      }, timeoutMs);
-    });
-    const promises = [operation(), timeoutPromise];
-    if (signal !== void 0 && !signal.aborted) {
-      const abortPromise = new Promise((_resolve, reject) => {
-        signal.addEventListener(
-          "abort",
-          () => {
-            reject(new Error("Operation cancelled by client"));
-          },
-          { once: true }
-        );
-      });
-      promises.push(abortPromise);
-    }
-    return Promise.race(promises);
-  }
-  handleSuccess(result, startTime, timeoutMs, operationName) {
-    const durationMs = getTimeProvider().now() - startTime;
-    const nearTimeout = durationMs > timeoutMs * NEAR_TIMEOUT_THRESHOLD;
-    if (nearTimeout && this.enableLogging) {
-      this.logger.warn("Operation completed near timeout threshold", {
-        operation: operationName,
-        durationMs,
-        timeoutMs,
-        thresholdPercent: Math.round(durationMs / timeoutMs * 100)
-      });
-    }
-    if (this.enableLogging) {
-      this.logger.debug("Guarded operation completed", { operation: operationName, durationMs });
-    }
-    return ok({ value: result, durationMs, nearTimeout });
-  }
-  handleFailure(timedOut, operationName, timeoutMs, startTime, cancelled = false) {
-    const durationMs = getTimeProvider().now() - startTime;
-    if (cancelled) {
-      this.logger.info("Operation cancelled by client", {
-        operation: operationName,
-        durationMs
-      });
-      return {
-        code: "OPERATION_CANCELLED",
-        message: `Operation '${operationName}' cancelled by client`,
-        operation: operationName
-      };
-    }
-    if (timedOut) {
-      this.logger.error("Operation timed out", void 0, {
-        operation: operationName,
-        timeoutMs,
-        durationMs
-      });
-      return createTimeoutError(operationName, timeoutMs);
-    }
-    return createGuardError(new Error("Unknown error"), operationName);
-  }
-  /**
-   * Creates a guarded version of an async function.
-   */
-  guard(fn, options) {
-    return async (...args) => {
-      return this.execute(() => fn(...args), options);
-    };
-  }
-};
-
-// src/mcp/middleware/request-context.ts
-import { randomBytes } from "crypto";
-function generateRequestId() {
-  const bytes = randomBytes(8);
-  return `req_${bytes.toString("hex")}`;
-}
-function formatTimestamp() {
-  const now = new Date(getTimeProvider().now());
-  const formatter = new Intl.DateTimeFormat("en-US", {
-    timeZone: "America/New_York",
-    timeZoneName: "shortOffset"
-  });
-  const parts = formatter.formatToParts(now);
-  const offset = parts.find((p) => p.type === "timeZoneName")?.value ?? "-05:00";
-  const base = now.toLocaleString("sv-SE", {
-    timeZone: "America/New_York",
-    hour12: false
-  });
-  return base.replace(" ", "T") + offset.replace("GMT", "");
-}
-function deriveTrustTier(caller) {
-  const knownClients = ["claude-cli", "gemini-cli", "codex-cli"];
-  if (caller.transport === "stdio") return "1";
-  if (caller.authenticated === true) {
-    if (caller.clientId !== void 0 && knownClients.includes(caller.clientId)) {
-      return "1";
-    }
-    return "2";
-  }
-  return "3";
-}
-function createRequestContext(options) {
-  const caller = options.caller ?? {};
-  const context = {
-    requestId: generateRequestId(),
-    timestamp: formatTimestamp(),
-    toolName: options.toolName,
-    caller,
-    trustTier: options.trustTier ?? deriveTrustTier(caller),
-    ...options.traceId !== void 0 && { traceId: options.traceId },
-    ...options.parentSpanId !== void 0 && { parentSpanId: options.parentSpanId }
-  };
-  return Object.freeze(context);
-}
-function contextForLogging(ctx) {
-  return {
-    requestId: ctx.requestId,
-    toolName: ctx.toolName,
-    trustTier: ctx.trustTier,
-    ...ctx.caller.clientId !== void 0 && { clientId: ctx.caller.clientId },
-    ...ctx.traceId !== void 0 && { traceId: ctx.traceId }
-  };
-}
-
-// src/security/access-constraint-deriver/denylist.ts
-var UNBYPASSABLE_PATH_PATTERNS = [
-  // Environment files
-  ".env",
-  ".env.*",
-  "**/.env",
-  "**/.env.*",
-  // SSH credentials
-  "~/.ssh/**",
-  "**/ssh/id_*",
-  "**/*_rsa",
-  "**/*_ed25519",
-  "**/*.pem",
-  // Cloud credentials
-  "~/.aws/**",
-  "~/.azure/**",
-  "~/.gcp/**",
-  "~/.config/gcloud/**",
-  "~/.kube/config",
-  // Unix secret files
-  "/etc/shadow",
-  "/etc/sudoers",
-  "/etc/sudoers.d/**",
-  // Common secret file patterns
-  "**/secrets.*",
-  "**/credentials.*",
-  "**/private_key.*",
-  "**/id_rsa*"
-];
-var UNBYPASSABLE_TOOL_NAMES = [
-  // Destructive git operations
-  "git_push_force",
-  "git_reset_hard",
-  "git_branch_delete_force",
-  "git_clean_force",
-  // Destructive filesystem
-  "rm_recursive_force",
-  "chmod_recursive",
-  // Identity / auth mutations
-  "ssh_add_key",
-  "gpg_add_key",
-  "npm_publish_force",
-  // Remote destruction
-  "github_repo_delete",
-  "github_org_transfer",
-  "aws_account_close"
-];
-function compileGlobToRegex(pattern) {
-  const pat = pattern.toLowerCase();
-  const escaped = pat.replace(/[\\.+^$()|[\]{}]/g, "\\$&").replace(/\*\*/g, "__DOUBLESTAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLESTAR__/g, ".*");
-  const anchored = escaped.startsWith("~/") ? `(^|/)${escaped.slice(2)}$` : escaped.startsWith("/") ? `^${escaped}$` : `(^|/)${escaped}$`;
-  return new RegExp(anchored);
-}
-var COMPILED_PATH_PATTERNS = UNBYPASSABLE_PATH_PATTERNS.map((pattern) => ({
-  pattern,
-  regex: compileGlobToRegex(pattern)
-}));
-function isPathDenied(path) {
-  const normalized = path.toLowerCase();
-  return COMPILED_PATH_PATTERNS.some((c) => c.regex.test(normalized));
-}
-function isToolDenied(toolName) {
-  return UNBYPASSABLE_TOOL_NAMES.includes(toolName);
-}
-
-// src/security/access-constraint-deriver/tool-risk.ts
-var READ_ONLY_TOOLS2 = /* @__PURE__ */ new Set([
-  // Discovery / listing
-  "list_experts",
-  "list_workflows",
-  // Research reads
-  "research_query",
-  "research_analyze",
-  "research_catalog_review",
-  "research_synthesize",
-  // Memory reads
-  "memory_query",
-  "memory_stats",
-  // Observability
-  "weather_report",
-  "query_trace",
-  "query_task_state",
-  // Async-mode result polling (#3042 / epic #2631)
-  "get_job_result",
-  // Async-mode job discovery (#3046 / epic #2631 Stage 5)
-  "list_jobs",
-  // Codebase intelligence (read-only over local files)
-  "search_codebase",
-  "extract_symbols",
-  // Repo analysis (read-only)
-  "repo_analyze",
-  "repo_security_plan",
-  // Routing recommendation (no side effects — returns recommendation)
-  "delegate_to_model",
-  // Registry import (returns a draft template — does not write)
-  "registry_import"
-]);
-function isRiskyTool(toolName) {
-  return !READ_ONLY_TOOLS2.has(toolName);
-}
-
-// src/security/access-constraint-deriver/enforcer.ts
-function checkAccess(toolName, policy, args) {
-  if (isToolDenied(toolName)) {
-    return {
-      decision: "deny",
-      reason: `tool "${toolName}" is on the unbypassable deny-tool list`,
-      matchedRule: "unbypassable:tool"
-    };
-  }
-  if (typeof args?.path === "string" && args.path.length > 0 && isPathDenied(args.path)) {
-    return {
-      decision: "deny",
-      reason: `path "${args.path}" is on the unbypassable deny-path list`,
-      matchedRule: "unbypassable:path"
-    };
-  }
-  if (policy.allowedTools === "*") return { decision: "allow" };
-  if (policy.allowedTools.includes(toolName)) return { decision: "allow" };
-  return decideOnViolation(toolName, policy.mode);
-}
-function decideOnViolation(toolName, mode) {
-  if (mode === "audit") {
-    return {
-      decision: "log-and-allow",
-      warning: `tool "${toolName}" not in derived policy (audit mode)`
-    };
-  }
-  if (mode === "confirm_risky") {
-    if (!isRiskyTool(toolName)) {
-      return {
-        decision: "log-and-allow",
-        warning: `tool "${toolName}" not in derived policy (confirm_risky mode, read-only \u2014 would have required human approval, allowed because read-only)`
-      };
-    }
-    return {
-      decision: "deny",
-      reason: `tool "${toolName}" not in derived policy (confirm_risky mode, risky \u2014 would have required human approval; denied for now, add to allowedTools or run in audit mode to allow)`,
-      matchedRule: "allowedTools:confirm_risky"
-    };
-  }
-  return {
-    decision: "deny",
-    reason: `tool "${toolName}" not in derived policy`,
-    matchedRule: "allowedTools"
-  };
-}
-
-// src/security/access-constraint-deriver/mcp-guard.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-var accessPolicyStorage = new AsyncLocalStorage2();
-function withAccessPolicy(policy, fn) {
-  return accessPolicyStorage.run(policy, fn);
-}
-function getActivePolicy() {
-  return accessPolicyStorage.getStore();
-}
-function denyToToolResult(decision, requestId) {
-  return {
-    isError: true,
-    content: [
-      {
-        type: "text",
-        text: `access denied: ${decision.reason} (rule: ${decision.matchedRule}, request: ${requestId})`
-      }
-    ]
-  };
-}
-
-// src/security/access-constraint-deriver/chain-adapter.ts
-function toGuardArgs(args) {
-  if (typeof args !== "object" || args === null) return void 0;
-  const path = args["path"];
-  return typeof path === "string" && path.length > 0 ? { path } : void 0;
-}
-function createAccessPolicyChainMiddleware(toolName) {
-  return async (args, ctx, next) => {
-    const policy = getActivePolicy();
-    if (policy === void 0 || policy.mode === "off") {
-      return next(args, ctx);
-    }
-    const decision = checkAccess(toolName, policy, toGuardArgs(args));
-    if (decision.decision === "allow") {
-      return next(args, ctx);
-    }
-    if (decision.decision === "log-and-allow") {
-      ctx.logger.warn("access-policy: audit violation", {
-        tool: toolName,
-        warning: decision.warning,
-        policySource: policy.source,
-        requestId: ctx.requestContext.requestId
-      });
-      return next(args, ctx);
-    }
-    ctx.logger.info("access-policy: tool call denied", {
-      tool: toolName,
-      reason: decision.reason,
-      matchedRule: decision.matchedRule,
-      policySource: policy.source,
-      mode: policy.mode,
-      requestId: ctx.requestContext.requestId
-    });
-    return denyToToolResult(decision, ctx.requestContext.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: 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);
-    if (!result.ok) {
-      ctx.logger.warn("Validation failed", {
-        error: result.error.message
-      });
-      return errorResult(
-        "validation",
-        `Validation error: ${result.error.message}`,
-        ctx.requestContext.requestId
-      );
-    }
-    ctx.validatedArgs = result.value;
-    return next(result.value, ctx);
-  };
-}
-function createPolicyMiddleware(firewall, toolName, mode, allowedPaths) {
-  return async (args, ctx, next) => {
-    const policyCtx = createPolicyContext(toolName, args, {
-      mode,
-      ...allowedPaths !== void 0 && { allowedPaths }
-    });
-    const decision = firewall.evaluate(policyCtx);
-    if (!decision.allowed) {
-      ctx.logger.warn("Policy denied", {
-        reason: decision.reason,
-        ruleName: decision.ruleName
-      });
-      return errorResult(
-        "permission",
-        `Policy denied: ${decision.reason}`,
-        ctx.requestContext.requestId
-      );
-    }
-    ctx.logger.debug("Policy check passed", { reason: decision.reason });
-    return next(args, ctx);
-  };
-}
-function createRateLimitMiddleware(limiter) {
-  return async (args, ctx, next) => {
-    const acquired = limiter.tryAcquire();
-    if (!acquired) {
-      const state = limiter.getState();
-      ctx.logger.warn("Rate limit exceeded", {
-        nextTokenMs: state.nextTokenMs
-      });
-      return errorResult(
-        "transient",
-        `Rate limit exceeded. Try again in ${String(state.nextTokenMs)}ms`,
-        ctx.requestContext.requestId
-      );
-    }
-    return next(args, ctx);
-  };
-}
-function createTimeoutMiddleware(guard, toolName) {
-  return async (args, ctx, next) => {
-    const signal = abortSignalStorage.getStore();
-    const result = await guard.execute(() => next(args, ctx), {
-      operationName: toolName,
-      ...signal !== void 0 ? { signal } : {}
-    });
-    if (!result.ok) {
-      ctx.logger.error("Operation timed out", void 0, {
-        code: result.error.code,
-        timeoutMs: result.error.timeoutMs
-      });
-      return errorResult("transient", result.error.message, ctx.requestContext.requestId);
-    }
-    if (result.value.nearTimeout) {
-      ctx.logger.warn("Operation completed near timeout threshold", {
-        durationMs: result.value.durationMs
-      });
-    }
-    return result.value.value;
-  };
-}
-function createAuditMiddleware() {
-  return async (args, ctx, next) => {
-    const startTime = getTimeProvider().now();
-    ctx.logger.info("Tool invocation started");
-    try {
-      const result = await next(args, ctx);
-      const durationMs = getTimeProvider().now() - startTime;
-      if (result.isError === true) {
-        ctx.logger.warn("Tool execution completed with error", { durationMs });
-      } else {
-        ctx.logger.info("Tool execution completed", { durationMs });
-      }
-      return result;
-    } catch (error) {
-      const durationMs = getTimeProvider().now() - startTime;
-      const message = error instanceof Error ? error.message : "Unknown error";
-      ctx.logger.error("Tool execution failed", error instanceof Error ? error : void 0, {
-        durationMs
-      });
-      return errorResult("internal", `Internal error: ${message}`, ctx.requestContext.requestId);
-    }
-  };
-}
-function composeMiddleware(middlewares) {
-  return (args, ctx, finalHandler) => {
-    const dispatch = (index, currentArgs) => {
-      if (index >= middlewares.length) {
-        return finalHandler(currentArgs, ctx);
-      }
-      const middleware = middlewares[index];
-      if (middleware === void 0) {
-        return finalHandler(currentArgs, ctx);
-      }
-      return middleware(currentArgs, ctx, (nextArgs) => dispatch(index + 1, nextArgs));
-    };
-    return dispatch(0, args);
-  };
-}
-function addAuditMiddleware(middlewares, skip) {
-  if (skip.audit !== true) {
-    middlewares.push(createAuditMiddleware());
-  }
-}
-function addRateLimitMiddleware(middlewares, config, skip) {
-  if (skip.rateLimit !== true && config.rateLimiter !== void 0) {
-    const limiter = config.rateLimiter instanceof RateLimiter ? config.rateLimiter : new RateLimiter(config.rateLimiter);
-    middlewares.push(createRateLimitMiddleware(limiter));
-  }
-}
-function addValidationMiddleware(middlewares, config, skip) {
-  if (skip.validation !== true && config.schema !== void 0) {
-    middlewares.push(createValidationMiddleware(config.schema));
-  }
-}
-function addPolicyMiddleware(middlewares, config, skip) {
-  if (skip.policy !== true && config.policyFirewall !== void 0) {
-    const mode = config.executionMode ?? "read-only";
-    middlewares.push(
-      createPolicyMiddleware(config.policyFirewall, config.toolName, mode, config.allowedPaths)
-    );
-  }
-}
-function addTimeoutMiddleware(middlewares, config, skip) {
-  if (skip.timeout !== true && config.timeout !== void 0) {
-    const guard = new TimeoutGuard(config.timeout);
-    middlewares.push(createTimeoutMiddleware(guard, config.toolName));
-  }
-}
-function addAccessPolicyMiddleware(middlewares, config, skip) {
-  if (skip.accessPolicy !== true) {
-    middlewares.push(createAccessPolicyChainMiddleware(config.toolName));
-  }
-}
-function buildMiddlewareStack(config) {
-  const skip = config.skip ?? {};
-  const middlewares = [];
-  middlewares.push(createMetricsMiddleware());
-  addAuditMiddleware(middlewares, skip);
-  addRateLimitMiddleware(middlewares, config, skip);
-  addValidationMiddleware(middlewares, config, skip);
-  addPolicyMiddleware(middlewares, config, skip);
-  addAccessPolicyMiddleware(middlewares, config, skip);
-  addTimeoutMiddleware(middlewares, config, skip);
-  return middlewares;
-}
-function createMiddlewareChain(config) {
-  const logger11 = config.logger ?? createLogger({ tool: config.toolName });
-  const middlewares = buildMiddlewareStack(config);
-  const composed = composeMiddleware(middlewares);
-  return (handler) => {
-    return async (args) => {
-      const requestContext = createRequestContext({ toolName: config.toolName });
-      const requestLogger = logger11.child(contextForLogging(requestContext));
-      const ctx = { requestContext, logger: requestLogger };
-      return composed(args, ctx, (finalArgs, finalCtx) => handler(finalArgs, finalCtx));
-    };
-  };
-}
-function withMiddleware(toolName, handler, options) {
-  const config = {
-    toolName,
-    ...options
-  };
-  const chain = createMiddlewareChain(config);
-  const wrappedHandler = (args, ctx) => {
-    if (handler.length >= 2) {
-      return handler(args, ctx);
-    }
-    return handler(args);
-  };
-  return chain(wrappedHandler);
-}
-
-// src/mcp/middleware/tool-wrapper.ts
-var DEFAULT_TIMEOUT_CONFIG = {
-  defaultTimeoutMs: MCP_TIMEOUTS.defaultMs,
-  maxTimeoutMs: MCP_TIMEOUTS.maxMs,
-  enableLogging: true,
-  uriValidation: true
-};
-var DEFAULT_TOOL_TIMEOUTS = {
-  ...MCP_TIMEOUTS.perTool
-};
-function getToolTimeout(toolName, security, explicitMs) {
-  if (explicitMs !== void 0) {
-    return explicitMs;
-  }
-  const perToolConfig = security?.timeout?.perToolTimeout;
-  const perToolMs = perToolConfig?.[toolName];
-  if (perToolMs !== void 0) {
-    return perToolMs;
-  }
-  const builtInDefault = DEFAULT_TOOL_TIMEOUTS[toolName];
-  if (builtInDefault !== void 0) {
-    return builtInDefault;
-  }
-  return security?.timeout?.defaultTimeoutMs ?? DEFAULT_TIMEOUT_CONFIG.defaultTimeoutMs;
-}
-function getTimeoutConfig(security, overrideMs) {
-  const timeoutConfig = security?.timeout ?? DEFAULT_TIMEOUT_CONFIG;
-  return {
-    defaultTimeoutMs: overrideMs ?? timeoutConfig.defaultTimeoutMs,
-    maxTimeoutMs: timeoutConfig.maxTimeoutMs,
-    enableLogging: timeoutConfig.enableLogging
-  };
-}
-function wrapToolWithTimeout(toolName, handler, options) {
-  return withMiddleware(toolName, handler, {
-    timeout: getTimeoutConfig(void 0, options?.timeoutMs),
-    logger: options?.logger
-  });
-}
-var wrapperLogger = createLogger({ component: "tool-wrapper" });
-function extractProgressContext(extra) {
-  const sdk = extra;
-  const token = sdk?._meta?.progressToken;
-  const sendFn = sdk?.sendNotification;
-  if (token === void 0 || sendFn === void 0) return void 0;
-  return {
-    progressToken: token,
-    sendNotification: (progress, total) => {
-      const params = {
-        progressToken: token,
-        progress
-      };
-      if (total !== void 0) params["total"] = total;
-      sendFn({ method: "notifications/progress", params }).catch((err2) => {
-        wrapperLogger.debug("Failed to send progress notification", {
-          error: getErrorMessage(err2)
-        });
-      });
-    }
-  };
-}
-function runWithContexts(handler, args, progressCtx, signal) {
-  const run = () => handler(args);
-  if (signal !== void 0 && progressCtx !== void 0) {
-    return abortSignalStorage.run(signal, () => progressContextStorage.run(progressCtx, run));
-  }
-  if (signal !== void 0) {
-    return abortSignalStorage.run(signal, run);
-  }
-  if (progressCtx !== void 0) {
-    return progressContextStorage.run(progressCtx, run);
-  }
-  return run();
-}
-function toSdkCallback(handler) {
-  return (args, extra) => {
-    const progressCtx = extractProgressContext(extra);
-    const signal = extra?.signal;
-    return runWithContexts(handler, args, progressCtx, signal);
-  };
-}
-var MCP_SDK_DEFAULT_REQUEST_TIMEOUT_MS = 6e4;
-var TIMEOUT_MISMATCH_TELEMETRY_REL_PATH = "mcp-telemetry/timeout-mismatch-events.jsonl";
-var ensuredDirs = /* @__PURE__ */ new Set();
-function appendTimeoutMismatchEvent(event) {
-  try {
-    const path = join(getNexusDataDir(), TIMEOUT_MISMATCH_TELEMETRY_REL_PATH);
-    const dir = dirname(path);
-    if (!ensuredDirs.has(dir)) {
-      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-      ensuredDirs.add(dir);
-    }
-    appendFileSync(path, JSON.stringify(event) + "\n", "utf-8");
-  } catch (err2) {
-    wrapperLogger.debug("Best-effort timeout-mismatch event recording failed", {
-      error: getErrorMessage(err2)
-    });
-  }
-}
-function extractErrorCategoryFromResult(result) {
-  const envelope = result._meta?.["nexus-agents/error"];
-  if (envelope !== null && typeof envelope === "object" && "errorCategory" in envelope) {
-    const cat = envelope.errorCategory;
-    if (typeof cat === "string") return cat;
-  }
-  return void 0;
-}
-function extractErrorMessageFromResult(result) {
-  const first = result.content[0];
-  if (first?.type === "text" && typeof first.text === "string") {
-    return first.text.slice(0, 500);
-  }
-  return void 0;
-}
-function buildMismatchEvent(ctx, eventId, t0, outcome) {
-  const t1 = Date.now();
-  return {
-    eventId,
-    toolName: ctx.toolName,
-    configuredTimeoutMs: ctx.configuredTimeoutMs,
-    mcpSdkDefaultMs: MCP_SDK_DEFAULT_REQUEST_TIMEOUT_MS,
-    startedAt: new Date(t0).toISOString(),
-    endedAt: new Date(t1).toISOString(),
-    durationMs: t1 - t0,
-    outcome: outcome.outcome,
-    ...outcome.errorCategory !== void 0 ? { errorCategory: outcome.errorCategory } : {},
-    ...outcome.errorMessage !== void 0 ? { errorMessage: outcome.errorMessage } : {}
-  };
-}
-function classifyResult(result) {
-  if (result.isError !== true) return { outcome: "success" };
-  const errorCategory = extractErrorCategoryFromResult(result);
-  const errorMessage = extractErrorMessageFromResult(result);
-  return {
-    outcome: "error",
-    ...errorCategory !== void 0 ? { errorCategory } : {},
-    ...errorMessage !== void 0 ? { errorMessage } : {}
-  };
-}
-async function runMismatchedCall(ctx) {
-  const eventId = randomUUID();
-  const t0 = Date.now();
-  ctx.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: ctx.toolName,
-      eventId,
-      configuredTimeoutMs: ctx.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."
-    }
-  );
-  try {
-    const result = await runWithContexts(ctx.handler, ctx.args, ctx.progressCtx, ctx.signal);
-    appendTimeoutMismatchEvent(buildMismatchEvent(ctx, eventId, t0, classifyResult(result)));
-    return result;
-  } catch (err2) {
-    appendTimeoutMismatchEvent(
-      buildMismatchEvent(ctx, eventId, t0, {
-        outcome: "error",
-        errorMessage: getErrorMessage(err2).slice(0, 500)
-      })
-    );
-    throw err2;
-  }
-}
-function toSdkCallbackWithBudgetCheck(handler, toolName, configuredTimeoutMs, logger11) {
-  const log = logger11 ?? wrapperLogger;
-  return (args, extra) => {
-    const progressCtx = extractProgressContext(extra);
-    const signal = extra?.signal;
-    const isMismatch = configuredTimeoutMs > MCP_SDK_DEFAULT_REQUEST_TIMEOUT_MS && progressCtx === void 0;
-    if (!isMismatch) return runWithContexts(handler, args, progressCtx, signal);
-    return runMismatchedCall({
-      log,
-      handler,
-      args,
-      progressCtx,
-      signal,
-      toolName,
-      configuredTimeoutMs
-    });
-  };
-}
-
-// src/audit/secure-handler-audit.ts
-function actorFromContext(ctx, fallback) {
-  const caller = ctx.caller;
-  const clientId = caller.clientId;
-  if (clientId !== void 0 && clientId.length > 0) {
-    return {
-      type: clientId.includes("api") ? "external" : clientId.includes("cli") ? "agent" : "user",
-      id: clientId,
-      name: caller.userAgent
-    };
-  }
-  return fallback ?? { type: "system", id: "unknown", name: "Unknown Caller" };
-}
-function resultToOutcome(isError, isPolicyDenied) {
-  if (isPolicyDenied) return "denied";
-  if (isError === true) return "failure";
-  return "success";
-}
-function logToolInvocationAudit(opts) {
-  opts.auditLogger.logToolInvocation({
-    toolName: opts.toolName,
-    outcome: opts.outcome,
-    actor: opts.actor,
-    requestId: opts.requestId,
-    durationMs: opts.durationMs,
-    errorMessage: opts.errorMessage
-  });
-}
-function logPolicyAudit(opts) {
-  opts.auditLogger.logPolicyDecision({
-    policyName: opts.policyName,
-    decision: opts.decision,
-    reason: opts.reason,
-    toolName: opts.toolName,
-    actor: opts.actor,
-    requestId: opts.requestId
-  });
-}
-function logRateLimitAudit(opts) {
-  opts.auditLogger.logRateLimitViolation({
-    toolName: opts.toolName,
-    actor: opts.actor,
-    currentRate: opts.currentRate,
-    limitRate: opts.limitRate,
-    requestId: opts.requestId
-  });
-}
-
-// src/mcp/middleware/tool-input-sanitizer.ts
-var XML_INJECTION_PATTERN = /<\/?(system|human|assistant|instructions|user|prompt|context|tool_use|tool_result)\b[^>]*>/gi;
-var INJECTION_DETECTORS = [
-  { name: "system_prompt_override", pattern: /ignore (?:all )?previous (?:instructions|rules)/i },
-  { name: "role_impersonation", pattern: /i(?:'m| am) the (?:repo |project )?(?:owner|admin)/i },
-  { name: "hidden_instruction", pattern: /<!--[\s\S]*?(?:execute|delete|merge|apply)[\s\S]*?-->/i }
-];
-function sanitizeString(value) {
-  XML_INJECTION_PATTERN.lastIndex = 0;
-  const cleaned = value.replace(XML_INJECTION_PATTERN, "");
-  return { cleaned, modified: cleaned !== value };
-}
-function detectPatterns(value) {
-  const detected = [];
-  for (const { name, pattern } of INJECTION_DETECTORS) {
-    pattern.lastIndex = 0;
-    if (pattern.test(value)) {
-      detected.push(name);
-    }
-  }
-  return detected;
-}
-function sanitizeValue(value, stats) {
-  if (typeof value === "string") {
-    const patterns = detectPatterns(value);
-    if (patterns.length > 0) {
-      stats.patterns.push(...patterns);
-    }
-    const { cleaned, modified } = sanitizeString(value);
-    if (modified) stats.count++;
-    return cleaned;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => sanitizeValue(item, stats));
-  }
-  if (value !== null && typeof value === "object") {
-    const result = {};
-    for (const [key, val] of Object.entries(value)) {
-      result[key] = sanitizeValue(val, stats);
-    }
-    return result;
-  }
-  return value;
-}
-function sanitizeToolInput(args) {
-  if (args === void 0 || args === null) {
-    return { sanitized: args, wasModified: false, modifiedCount: 0, detectedPatterns: [] };
-  }
-  const stats = { count: 0, patterns: [] };
-  const sanitized = sanitizeValue(args, stats);
-  const uniquePatterns = [...new Set(stats.patterns)];
-  return {
-    sanitized,
-    wasModified: stats.count > 0,
-    modifiedCount: stats.count,
-    detectedPatterns: uniquePatterns
-  };
-}
-function logSanitizationResult(result, logger11, toolName) {
-  if (result.wasModified) {
-    logger11.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", {
-      tool: toolName,
-      patterns: result.detectedPatterns
-    });
-  }
-}
+  NOOP_NOTIFIER,
+  createMcpNotifier,
+  createSecureHandler,
+  getToolAnnotations,
+  getToolTimeout,
+  toSdkCallbackWithBudgetCheck,
+  toolStructuredError,
+  toolSuccess,
+  withProgressHeartbeat,
+  wrapToolWithTimeout
+} from "./chunk-3ZROPKLV.js";
+import {
+  getToolMemory
+} from "./chunk-ANH2A44T.js";
+import {
+  getDefaultAvailableModelsCache
+} from "./chunk-ZBQXPP7M.js";
+import {
+  CUSTOM_API_DEFAULT_MODEL
+} from "./chunk-MMW4KIBH.js";
+import {
+  createCliAdapter,
+  createCliDetectionCache,
+  delay,
+  getAvailableClis,
+  isCliAvailable,
+  sanitizeOutput,
+  withTimeout
+} from "./chunk-XMYJWMWN.js";
+import {
+  AgentError,
+  CLI_NAMES,
+  CircularBuffer,
+  DEFAULT_CLI,
+  ErrorCode,
+  ModelCapability,
+  ModelError,
+  OutcomeStore,
+  TASK_SPECIALIZATION_MATRIX,
+  TaskOutcomeSchema,
+  VOTE_TIMEOUTS,
+  categorizeOutcomeErrorMessage,
+  clamp01,
+  createLogger,
+  detectTaskCategory,
+  err,
+  estimateTokens,
+  formatPercentage,
+  formatZodError,
+  getCliModelName,
+  getDefaultModelForCli,
+  getDefaultRegistry,
+  getErrorMessage,
+  getInTreeCapabilitiesMatrix,
+  getMcpSafeDeadlineMs,
+  getOutcomeStore,
+  getPipelineEventBus,
+  getRandomProvider,
+  getTimeProvider,
+  getTokenEstimator,
+  isRateLimitLikeError,
+  ok,
+  recordRateLimitEvent,
+  registerPersistentOutcomeStoreFactory,
+  resolveCliAlias,
+  resolveVoteTimeout,
+  toRateLimitError
+} from "./chunk-2KHD2ANY.js";
+import {
+  ensureLearningDir,
+  getOutcomesFile,
+  nexusDataPath,
+  nexusDataPathEnsure
+} from "./chunk-CH7QIDHQ.js";
 
-// src/mcp/middleware/secure-handler.ts
-function rateLimitError(nextTokenMs) {
-  return toolStructuredError({
-    errorCategory: "transient",
-    message: `Rate limit exceeded. Try again in ${String(nextTokenMs)}ms.`
-  });
-}
-function policyDeniedError(reason, requestId) {
-  return toolStructuredError({
-    errorCategory: "permission",
-    message: `Policy denied: ${reason} (request: ${requestId})`
-  });
-}
-function internalError(message, requestId) {
-  return toolStructuredError({
-    errorCategory: "internal",
-    message: `Internal error: ${message} (request: ${requestId})`
-  });
-}
-var MAX_INPUT_SIZE_BYTES = 10 * 1024 * 1024;
-var SECRET_PATTERNS = [
-  // API keys with common prefixes
-  /\b(sk-[a-zA-Z0-9]{20,})\b/g,
-  /\b(pk-[a-zA-Z0-9]{20,})\b/g,
-  // AWS-style keys
-  /\b(AKIA[A-Z0-9]{16})\b/g,
-  // Bearer tokens in output
-  /Bearer\s+[a-zA-Z0-9_\-.~+/]+=*/g,
-  // Generic long hex secrets (40+ chars)
-  /\b[0-9a-f]{40,}\b/gi,
-  // password= or token= in output
-  /(?:password|token|secret|apikey|api_key)\s*[=:]\s*\S{8,}/gi
-];
-function sanitizeOutput2(text, logger11) {
-  let sanitized = text;
-  for (const pattern of SECRET_PATTERNS) {
-    const before = sanitized;
-    sanitized = sanitized.replace(pattern, "[REDACTED]");
-    if (sanitized !== before) {
-      logger11.warn("Potential secret detected in tool output, redacting", {
-        pattern: pattern.source.slice(0, 30)
-      });
-    }
-  }
-  return sanitized;
-}
-function sanitizeToolResult(result, logger11) {
-  for (const item of result.content) {
-    item.text = sanitizeOutput2(item.text, logger11);
-  }
-}
-function checkInputSize(args, logger11, 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 });
-    return internalError("Input too large", requestId);
-  }
-  return null;
-}
-function checkRateLimit(rateLimiter, logger11) {
-  const acquired = rateLimiter.tryAcquire();
-  if (!acquired) {
-    const state = rateLimiter.getState();
-    logger11.warn("Rate limit exceeded");
-    return rateLimitError(state.nextTokenMs);
-  }
-  return null;
-}
-function checkPolicy(opts) {
-  const ctxOpts = {
-    mode: opts.mode,
-    ...opts.allowedPaths && { allowedPaths: opts.allowedPaths }
-  };
-  const decision = opts.firewall.evaluate(createPolicyContext(opts.toolName, opts.args, ctxOpts));
-  if (!decision.allowed) {
-    opts.logger.warn("Policy denied tool execution", {
-      reason: decision.reason,
-      ruleName: decision.ruleName
-    });
-    return policyDeniedError(decision.reason, opts.requestId);
-  }
-  opts.logger.debug("Policy check passed", { reason: decision.reason });
-  return null;
-}
-async function executeHandler(handler, args, ctx, logger11) {
-  const startTime = getTimeProvider().now();
-  const result = handler.length >= 2 ? await handler(args, ctx) : await handler(args);
-  const durationMs = getTimeProvider().now() - startTime;
-  if (result.isError === true) {
-    logger11.warn("Tool execution completed with error", { durationMs });
-  } else {
-    logger11.info("Tool execution completed", { durationMs });
-  }
-  return result;
-}
-function emitToolAudit(auditLogger, toolName, ctx, result, durationMs) {
-  const actor = actorFromContext(ctx);
-  const outcome = resultToOutcome(result.isError, false);
-  auditLogger.logToolInvocation({
-    toolName,
-    outcome,
-    actor,
-    requestId: ctx.requestId,
-    durationMs
-  });
-}
-function emitToolAuditException(auditLogger, toolName, ctx, durationMs) {
-  const actor = actorFromContext(ctx);
-  auditLogger.logToolInvocation({
-    toolName,
-    outcome: "error",
-    actor,
-    requestId: ctx.requestId,
-    durationMs
-  });
-}
-function emitPolicyAudit(auditLogger, toolName, ctx, reason) {
-  const actor = actorFromContext(ctx);
-  auditLogger.logPolicyDecision({
-    policyName: "default",
-    decision: "deny",
-    reason,
-    toolName,
-    actor,
-    requestId: ctx.requestId
-  });
-}
-function emitRateLimitAudit(auditLogger, toolName, ctx) {
-  const actor = actorFromContext(ctx);
-  auditLogger.logRateLimitViolation({
-    toolName,
-    actor,
-    currentRate: 0,
-    limitRate: 0,
-    requestId: ctx.requestId
-  });
-}
-function checkSecurityTier(config, sanitizeResult, logger11) {
-  const tier = config.securityTier ?? "standard";
-  if (tier === "standard" || sanitizeResult.detectedPatterns.length === 0) {
-    return null;
-  }
-  logger11.warn("Input rejected by security tier validation", {
-    tier,
-    patterns: sanitizeResult.detectedPatterns
-  });
-  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);
-  if (sizeResult) return { error: sizeResult, sanitizedArgs: args };
-  const sanitizeResult = sanitizeToolInput(args);
-  logSanitizationResult(sanitizeResult, logger11, config.toolName);
-  const sanitizedArgs = sanitizeResult.wasModified ? sanitizeResult.sanitized : args;
-  const tierError = checkSecurityTier(config, sanitizeResult, logger11);
-  if (tierError !== null) return { error: tierError, sanitizedArgs };
-  if (config.rateLimiter) {
-    const rlResult = checkRateLimit(config.rateLimiter, logger11);
-    if (rlResult) {
-      if (config.auditLogger)
-        emitRateLimitAudit(config.auditLogger, config.toolName, requestContext);
-      return { error: rlResult, sanitizedArgs };
-    }
-  }
-  if (config.policyFirewall) {
-    const pResult = checkPolicy({
-      firewall: config.policyFirewall,
-      toolName: config.toolName,
-      args: sanitizedArgs,
-      mode,
-      allowedPaths: config.allowedPaths,
-      logger: logger11,
-      requestId: requestContext.requestId
-    });
-    if (pResult) {
-      if (config.auditLogger)
-        emitPolicyAudit(config.auditLogger, config.toolName, requestContext, "policy denied");
-      return { error: pResult, sanitizedArgs };
-    }
-  }
-  return { error: null, sanitizedArgs };
-}
-function createSecureHandler(handler, config) {
-  const logger11 = config.logger ?? createLogger({ tool: config.toolName });
-  const mode = config.executionMode ?? "read-only";
-  return async (args) => {
-    const ctxOpts = {
-      toolName: config.toolName,
-      ...config.callerInfo && { caller: config.callerInfo }
-    };
-    const requestContext = createRequestContext(ctxOpts);
-    const requestLogger = logger11.child(contextForLogging(requestContext));
-    requestLogger.info("Tool invocation started");
-    const { error: preCheckError, sanitizedArgs } = runPreChecks(
-      config,
-      args,
-      mode,
-      requestContext,
-      requestLogger
-    );
-    if (preCheckError) return preCheckError;
-    return executeAndAudit(handler, sanitizedArgs, requestContext, requestLogger, config);
-  };
-}
-async function executeAndAudit(handler, sanitizedArgs, requestContext, requestLogger, config) {
-  const execStartTime = getTimeProvider().now();
-  try {
-    const result = await executeHandler(
-      handler,
-      sanitizedArgs,
-      { requestContext, logger: requestLogger },
-      requestLogger
-    );
-    sanitizeToolResult(result, requestLogger);
-    if (config.auditLogger) {
-      emitToolAudit(
-        config.auditLogger,
-        config.toolName,
-        requestContext,
-        result,
-        getTimeProvider().now() - execStartTime
-      );
-    }
-    return result;
-  } catch (error) {
-    const rawMessage = error instanceof Error ? error.message : "Unknown error";
-    requestLogger.error("Tool execution failed", error instanceof Error ? error : void 0);
-    if (config.auditLogger) {
-      emitToolAuditException(
-        config.auditLogger,
-        config.toolName,
-        requestContext,
-        getTimeProvider().now() - execStartTime
-      );
-    }
-    const sanitized = sanitizeOutput2(rawMessage, requestLogger);
-    return internalError(sanitized, requestContext.requestId);
-  }
-}
+// src/mcp/tools/consensus-vote.ts
+import { z as z10 } from "zod";
 
 // src/cli/vote-types.ts
 var VOTER_ROLES = {
@@ -2824,7 +1094,7 @@ async function createAutoAdapter(config = {}) {
 }
 
 // src/agents/collaboration/event-bus-helpers.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID } from "crypto";
 var DEFAULT_MAX_HISTORY_SIZE = 1e3;
 var MAX_SUBSCRIPTIONS = 500;
 var MAX_TOPIC_PATTERN_LENGTH = 200;
@@ -2845,10 +1115,10 @@ function topicMatchesPattern(topic, regex) {
   return regex.test(topic);
 }
 function generateEventId() {
-  return `evt-${String(getTimeProvider().now())}-${randomUUID2().slice(0, 8)}`;
+  return `evt-${String(getTimeProvider().now())}-${randomUUID().slice(0, 8)}`;
 }
 function generateSubscriptionId() {
-  return `sub-${String(getTimeProvider().now())}-${randomUUID2().slice(0, 8)}`;
+  return `sub-${String(getTimeProvider().now())}-${randomUUID().slice(0, 8)}`;
 }
 function applyHistoryFilters(history, filter) {
   let result = history;
@@ -4000,7 +2270,7 @@ var SIMULATED_VOTE_REASONING = {
 };
 
 // src/cli/voter-response.ts
-import { z as z3 } from "zod";
+import { z } from "zod";
 var SyntheticVoteError = class extends Error {
   constructor(reason, rawOutput) {
     super(
@@ -4010,26 +2280,26 @@ var SyntheticVoteError = class extends Error {
     this.name = "SyntheticVoteError";
   }
 };
-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")
+var RawFindingSchema = z.object({
+  summary: z.string().min(1).max(500).describe("One-line summary of the issue"),
+  location: z.string().min(1).max(200).describe("path/file.ext:line"),
+  severity: z.enum(["critical", "high", "medium", "low"]).default("medium"),
+  gate: z.object({
+    reread_cited_line: z.enum(["passed", "failed", "skipped"]).default("skipped"),
+    traced_call_path: z.enum(["passed", "failed", "skipped"]).default("skipped"),
+    named_assertion: z.string().default("").describe("Concrete failing assertion \u2014 substantive, not a rubber-stamp word"),
+    ruled_out_language_non_issue: z.enum(["passed", "failed", "skipped"]).default("skipped")
   }),
-  claim: z3.string().min(1).max(2e3).describe("What is wrong and why it justifies blocking")
+  claim: z.string().min(1).max(2e3).describe("What is wrong and why it justifies blocking")
 });
-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"),
+var VoteResponseSchema = z.object({
+  decision: z.enum(["approve", "reject", "abstain"]).describe("Your vote decision"),
+  reasoning: z.string().min(10).max(4e3).describe("Explanation for your vote (10-4000 chars)"),
+  confidence: z.number().min(0).max(1).describe("Confidence level 0-1"),
+  conditions: z.array(z.string()).optional().describe("Optional conditions for approval"),
   /** Structured rejection categories for reject→refine→re-vote loops (Issue #1213). */
-  rejectionCategories: z3.array(
-    z3.enum([
+  rejectionCategories: z.array(
+    z.enum([
       "YAGNI",
       "DRY_VIOLATION",
       "OVER_ENGINEERING",
@@ -4041,7 +2311,7 @@ var VoteResponseSchema = z3.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: z3.array(RawFindingSchema).optional().describe("Structured findings (PR review only)")
+  findings: z.array(RawFindingSchema).optional().describe("Structured findings (PR review only)")
 });
 var VOTE_PROMPT_EXAMPLES = `Example approve response:
 {
@@ -4572,8 +2842,8 @@ async function collectRealVotes(options) {
 }
 
 // src/consensus/types-core.ts
-import { z as z4 } from "zod";
-var ConsensusAlgorithmSchema = z4.enum([
+import { z as z2 } from "zod";
+var ConsensusAlgorithmSchema = z2.enum([
   "simple_majority",
   "supermajority",
   "unanimous",
@@ -4581,8 +2851,8 @@ var ConsensusAlgorithmSchema = z4.enum([
   "opinion_wise",
   "higher_order"
 ]);
-var VoteDecisionSchema = z4.enum(["approve", "reject", "abstain"]);
-var ProposalStatusSchema = z4.enum([
+var VoteDecisionSchema = z2.enum(["approve", "reject", "abstain"]);
+var ProposalStatusSchema = z2.enum([
   "pending",
   "voting",
   "approved",
@@ -4590,7 +2860,7 @@ var ProposalStatusSchema = z4.enum([
   "timeout",
   "closed"
 ]);
-var RejectionCategorySchema = z4.enum([
+var RejectionCategorySchema = z2.enum([
   "YAGNI",
   "DRY_VIOLATION",
   "OVER_ENGINEERING",
@@ -4600,69 +2870,69 @@ var RejectionCategorySchema = z4.enum([
   "INSUFFICIENT_EVIDENCE"
 ]);
 var REJECTION_CATEGORIES = RejectionCategorySchema.options;
-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")
+var FindingShapeSchema = z2.object({
+  summary: z2.string().min(1).max(500),
+  location: z2.string().min(1).max(200),
+  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(""),
+    ruled_out_language_non_issue: z2.enum(["passed", "failed", "skipped"]).default("skipped")
   }),
-  claim: z4.string().min(1).max(2e3)
+  claim: z2.string().min(1).max(2e3)
 });
-var VoteSchema = z4.object({
+var VoteSchema = z2.object({
   decision: VoteDecisionSchema,
-  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"),
+  reasoning: z2.string().min(1).describe("Explanation for the vote"),
+  confidence: z2.number().min(0).max(1).describe("Confidence level 0-1"),
+  conditions: z2.array(z2.string()).optional().describe("Conditions for approval"),
   /** Structured rejection categories for reject→refine→re-vote loops (Issue #1213). */
-  rejectionCategories: z4.array(RejectionCategorySchema).optional().describe("Rejection reason categories when decision is reject"),
+  rejectionCategories: z2.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: z4.array(FindingShapeSchema).optional().describe("PR-review findings (pre-verified)"),
-  timestamp: z4.iso.datetime().optional()
+  findings: z2.array(FindingShapeSchema).optional().describe("PR-review findings (pre-verified)"),
+  timestamp: z2.iso.datetime().optional()
 });
-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"),
+var ProposalSchema = z2.object({
+  id: z2.string().optional().describe("Auto-generated if not provided"),
+  title: z2.string().min(1).max(200).describe("Short proposal title"),
+  description: z2.string().min(1).describe("Detailed proposal description"),
   algorithm: ConsensusAlgorithmSchema,
-  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()
+  timeout: z2.number().int().positive().optional().describe("Timeout in milliseconds"),
+  requiredVoters: z2.array(z2.string()).optional().describe("Agent IDs that must vote"),
+  metadata: z2.record(z2.string(), z2.unknown()).optional().describe("Additional context"),
+  createdAt: z2.iso.datetime().optional()
 });
-var ConsensusResultSchema = z4.object({
-  proposalId: z4.string(),
+var ConsensusResultSchema = z2.object({
+  proposalId: z2.string(),
   proposal: ProposalSchema,
   outcome: ProposalStatusSchema,
-  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()
+  votes: z2.map(z2.string(), VoteSchema),
+  voteCounts: z2.object({
+    approve: z2.number().int().nonnegative(),
+    reject: z2.number().int().nonnegative(),
+    abstain: z2.number().int().nonnegative(),
+    total: z2.number().int().nonnegative()
   }),
-  weightedCounts: z4.object({
-    approve: z4.number().nonnegative(),
-    reject: z4.number().nonnegative(),
-    abstain: z4.number().nonnegative(),
-    totalWeight: z4.number().nonnegative()
+  weightedCounts: z2.object({
+    approve: z2.number().nonnegative(),
+    reject: z2.number().nonnegative(),
+    abstain: z2.number().nonnegative(),
+    totalWeight: z2.number().nonnegative()
   }).optional(),
-  approvalPercentage: z4.number().min(0).max(100),
-  quorumReached: z4.boolean(),
-  startedAt: z4.iso.datetime(),
-  closedAt: z4.iso.datetime(),
-  durationMs: z4.number().int().nonnegative()
+  approvalPercentage: z2.number().min(0).max(100),
+  quorumReached: z2.boolean(),
+  startedAt: z2.iso.datetime(),
+  closedAt: z2.iso.datetime(),
+  durationMs: z2.number().int().nonnegative()
 });
-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 AgentPerformanceSchema = z2.object({
+  agentId: z2.string(),
+  totalVotes: z2.number().int().nonnegative(),
+  correctVotes: z2.number().int().nonnegative(),
+  successRate: z2.number().min(0).max(1),
+  lastUpdated: z2.iso.datetime()
 });
 var DEFAULT_INCREMENTAL_QUORUM_CONFIG = {
   enabled: false,
@@ -4671,19 +2941,19 @@ var DEFAULT_INCREMENTAL_QUORUM_CONFIG = {
   confidenceThreshold: 0.6,
   ambiguityBand: 0.15
 };
-var ProposalCacheConfigSchema = z4.object({
-  enabled: z4.boolean().default(false),
-  ttlMs: z4.number().int().positive().default(36e5),
+var ProposalCacheConfigSchema = z2.object({
+  enabled: z2.boolean().default(false),
+  ttlMs: z2.number().int().positive().default(36e5),
   // 1 hour
-  maxEntries: z4.number().int().positive().default(500)
+  maxEntries: z2.number().int().positive().default(500)
 });
-var ConsensusEngineConfigSchema = z4.object({
-  defaultTimeout: z4.number().int().positive().default(3e5),
+var ConsensusEngineConfigSchema = z2.object({
+  defaultTimeout: z2.number().int().positive().default(3e5),
   // 5 minutes
-  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),
+  minVotersForQuorum: z2.number().int().positive().default(2),
+  maxActiveProposals: z2.number().int().positive().default(100),
+  enablePerformanceTracking: z2.boolean().default(true),
+  maxClosedProposals: z2.number().int().positive().default(1e3),
   // Issue #549
   proposalCache: ProposalCacheConfigSchema.optional()
   // Issue #589
@@ -4708,50 +2978,50 @@ var VOTING_THRESHOLDS = {
   higher_order: 0.5
   // Alias for opinion_wise (Issue #514)
 };
-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())
+var ConsensusMetricsSchema = z2.object({
+  totalProposals: z2.number().int().nonnegative(),
+  approvedProposals: z2.number().int().nonnegative(),
+  rejectedProposals: z2.number().int().nonnegative(),
+  timedOutProposals: z2.number().int().nonnegative(),
+  averageDurationMs: z2.number().nonnegative(),
+  averageVotesPerProposal: z2.number().nonnegative(),
+  algorithmUsage: z2.record(ConsensusAlgorithmSchema, z2.number().int().nonnegative())
 });
 
 // src/consensus/types-voting-protocol.ts
-import { z as z5 } from "zod";
-var VotingRoundPhaseSchema = z5.enum(["analysis", "deliberation", "consensus"]);
-var VotingRoundStatusSchema = z5.enum([
+import { z as z3 } from "zod";
+var VotingRoundPhaseSchema = z3.enum(["analysis", "deliberation", "consensus"]);
+var VotingRoundStatusSchema = z3.enum([
   "pending",
   "in_progress",
   "awaiting_votes",
   "completed",
   "aborted"
 ]);
-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 AgentFindingSchema = z3.object({
+  agentId: z3.string(),
+  category: z3.enum(["bug", "security", "performance", "style", "design", "documentation", "other"]),
+  severity: z3.enum(["critical", "major", "minor", "suggestion"]),
+  description: z3.string().min(1),
+  location: z3.string().optional().describe("File path and line range if applicable"),
+  suggestion: z3.string().optional().describe("Recommended fix"),
+  confidence: z3.number().min(0).max(1),
+  timestamp: z3.iso.datetime().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 FindingVoteSchema = z3.object({
+  agentId: z3.string(),
+  findingId: z3.string(),
+  agree: z3.boolean(),
+  reasoning: z3.string().optional(),
+  amendedSeverity: z3.enum(["critical", "major", "minor", "suggestion"]).optional()
 });
-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 VotingProtocolConfigSchema = z3.object({
+  committeeSize: z3.number().int().min(2).max(7).default(3),
+  maxRounds: z3.number().int().min(1).max(5).default(3),
+  roundTimeoutMs: z3.number().int().positive().default(6e4),
+  agreementThreshold: z3.number().min(0.5).max(1).default(0.67),
+  enableAntiSycophancy: z3.boolean().default(true),
+  sycophancyThreshold: z3.number().min(0).max(1).default(0.8)
 });
 var DEFAULT_VOTING_PROTOCOL_CONFIG = {
   committeeSize: 3,
@@ -4763,30 +3033,30 @@ var DEFAULT_VOTING_PROTOCOL_CONFIG = {
 };
 
 // src/consensus/types-weighted-voting.ts
-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()
+import { z as z4 } from "zod";
+var TaskOutcomeSchema2 = z4.enum(["success", "failure", "partial", "unknown"]);
+var WeightedAgentRecordSchema = z4.object({
+  agentId: z4.string().min(1),
+  totalTasks: z4.number().int().nonnegative(),
+  successfulTasks: z4.number().int().nonnegative(),
+  failedTasks: z4.number().int().nonnegative(),
+  partialTasks: z4.number().int().nonnegative(),
+  successRate: z4.number().min(0).max(1),
+  weight: z4.number().min(0).max(1),
+  trustScore: z4.number().min(0).max(1),
+  byzantineFlags: z4.number().int().nonnegative(),
+  lastActive: z4.date(),
+  createdAt: z4.date()
 });
-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 WeightedVotingConfigSchema = z4.object({
+  minWeight: z4.number().min(0).max(1).default(0.1),
+  maxByzantineFraction: z4.number().min(0).max(0.5).default(0.33),
+  weightDecayFactor: z4.number().min(0.5).max(1).default(0.9),
+  weightRecoveryFactor: z4.number().min(1).max(2).default(1.05),
+  minTrustScore: z4.number().min(0).max(1).default(0.3),
+  byzantineFlagThreshold: z4.number().int().positive().default(3),
+  initialWeight: z4.number().min(0).max(1).default(0.5),
+  quorumThreshold: z4.number().min(0.5).max(1).default(0.67)
 });
 var DEFAULT_WEIGHTED_VOTING_CONFIG = {
   minWeight: 0.1,
@@ -4800,7 +3070,7 @@ var DEFAULT_WEIGHTED_VOTING_CONFIG = {
 };
 
 // src/consensus/higher-order-types.ts
-import { z as z7 } from "zod";
+import { z as z5 } from "zod";
 function createAgentPairKey(agentA, agentB) {
   return agentA < agentB ? `${agentA}:${agentB}` : `${agentB}:${agentA}`;
 }
@@ -4811,40 +3081,40 @@ function parseAgentPairKey(key) {
   }
   return [parts[0], parts[1]];
 }
-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 CorrelationCoefficientSchema = z5.number().min(-1).max(1);
+var IndependentSubsetSchema = z5.object({
+  id: z5.string(),
+  agentIds: z5.array(z5.string()),
+  independenceScore: z5.number().min(0).max(1),
+  observationCount: z5.number().int().nonnegative()
 });
-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 VotingObservationSchema = z5.object({
+  proposalId: z5.string(),
+  agentId: z5.string(),
+  decision: z5.enum(["approve", "reject", "abstain"]),
+  confidence: z5.number().min(0).max(1),
+  alignedWithOutcome: z5.boolean(),
+  timestamp: z5.date()
 });
-var PairwiseVotingHistorySchema = z7.object({
-  pairKey: z7.string(),
-  jointObservations: z7.number().int().nonnegative(),
-  agreements: z7.number().int().nonnegative(),
-  disagreements: z7.number().int().nonnegative(),
+var PairwiseVotingHistorySchema = z5.object({
+  pairKey: z5.string(),
+  jointObservations: z5.number().int().nonnegative(),
+  agreements: z5.number().int().nonnegative(),
+  disagreements: z5.number().int().nonnegative(),
   correlation: CorrelationCoefficientSchema,
-  lastUpdated: z7.date()
+  lastUpdated: z5.date()
 });
-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),
+var HigherOrderVotingConfigSchema = z5.object({
+  minObservationsForCorrelation: z5.number().int().positive().default(10),
+  correlationThreshold: z5.number().min(0).max(1).default(0.3),
+  correlationMaxAgeMs: z5.number().int().positive().default(864e5),
   // 24 hours
-  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)
+  independenceThreshold: z5.number().min(0).max(1).default(0.2),
+  fallbackToSimpleVoting: z5.boolean().default(true),
+  observationDecayFactor: z5.number().min(0).max(1).default(0.95),
+  maxObservationsPerAgent: z5.number().int().positive().default(1e3),
+  maxProposals: z5.number().int().positive().default(5e3),
+  maxTrackedPairs: z5.number().int().positive().default(100)
 });
 var DEFAULT_HIGHER_ORDER_CONFIG = {
   minObservationsForCorrelation: 10,
@@ -4858,25 +3128,25 @@ var DEFAULT_HIGHER_ORDER_CONFIG = {
   maxProposals: 5e3,
   maxTrackedPairs: 100
 };
-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 HigherOrderVotingResultSchema = z5.object({
+  decision: z5.enum(["approve", "reject", "no_consensus"]),
+  posteriorApproval: z5.number().min(0).max(1),
+  posteriorRejection: z5.number().min(0).max(1),
+  effectiveVoteCount: z5.number().nonnegative(),
+  usedCorrelationData: z5.boolean(),
+  method: z5.enum(["ow", "isp", "simple"]),
+  improvementOverBaseline: z5.number(),
+  independentSubsets: z5.array(IndependentSubsetSchema).optional(),
+  downweightedAgents: z5.array(z5.string()),
+  reasoning: z5.string()
 });
-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()
+var CorrelationTrackerStatsSchema = z5.object({
+  totalAgents: z5.number().int().nonnegative(),
+  trackedPairs: z5.number().int().nonnegative(),
+  totalObservations: z5.number().int().nonnegative(),
+  averageCorrelation: z5.number(),
+  independentSubsetCount: z5.number().int().nonnegative(),
+  pairsWithSufficientData: z5.number().int().nonnegative()
 });
 
 // src/consensus/higher-order-helpers.ts
@@ -7564,7 +5834,7 @@ function createCorrelationTracker(config) {
 
 // src/consensus/correlation-persistence.ts
 import * as fs from "fs";
-import { z as z8 } from "zod";
+import { z as z6 } from "zod";
 var logger6 = createLogger({ component: "correlation-persistence" });
 var VOTING_SUBDIR = "voting";
 var CORRELATIONS_FILE = "correlations.json";
@@ -7572,21 +5842,21 @@ var CORRELATIONS_JSONL_FILE = "correlations.jsonl";
 var FILE_MODE = 384;
 var DIR_MODE = 448;
 var SCHEMA_VERSION = 2;
-var PersistedVoteSchema = z8.object({
-  agentId: z8.string(),
-  decision: z8.enum(["approve", "reject", "abstain"]),
-  confidence: z8.number().min(0).max(1)
+var PersistedVoteSchema = z6.object({
+  agentId: z6.string(),
+  decision: z6.enum(["approve", "reject", "abstain"]),
+  confidence: z6.number().min(0).max(1)
 });
-var PersistedProposalSchema = z8.object({
-  proposalId: z8.string(),
-  votes: z8.array(PersistedVoteSchema),
-  outcome: z8.enum(["approved", "rejected"]),
-  timestamp: z8.iso.datetime()
+var PersistedProposalSchema = z6.object({
+  proposalId: z6.string(),
+  votes: z6.array(PersistedVoteSchema),
+  outcome: z6.enum(["approved", "rejected"]),
+  timestamp: z6.iso.datetime()
 });
-var PersistedCorrelationDataSchema = z8.object({
-  version: z8.number().int().positive(),
-  proposals: z8.array(PersistedProposalSchema),
-  savedAt: z8.iso.datetime()
+var PersistedCorrelationDataSchema = z6.object({
+  version: z6.number().int().positive(),
+  proposals: z6.array(PersistedProposalSchema),
+  savedAt: z6.iso.datetime()
 });
 function getCorrelationDataPath() {
   return nexusDataPath(VOTING_SUBDIR, CORRELATIONS_FILE);
@@ -7787,9 +6057,9 @@ function createPersistedProposal(proposalId, votes, outcome) {
 }
 
 // src/mcp/tools/consensus-vote-types.ts
-import { z as z9 } from "zod";
+import { z as z7 } from "zod";
 var MAX_PROPOSAL_LENGTH = 4e3;
-var VotingStrategySchema = z9.enum([
+var VotingStrategySchema = z7.enum([
   "simple_majority",
   "supermajority",
   "unanimous",
@@ -7797,8 +6067,8 @@ var VotingStrategySchema = z9.enum([
   "higher_order",
   "opinion_wise"
 ]);
-var ErrorPolicySchema = z9.enum(["reduce_denominator", "count_as_abstain", "fail_closed"]);
-var VoteThresholdSchema = z9.enum(["majority", "supermajority", "unanimous"]);
+var ErrorPolicySchema = z7.enum(["reduce_denominator", "count_as_abstain", "fail_closed"]);
+var VoteThresholdSchema = z7.enum(["majority", "supermajority", "unanimous"]);
 var ERROR_FLOOR_FRACTION = 0.5;
 function getDefaultErrorPolicy(strategy) {
   if (strategy === "unanimous") {
@@ -7806,8 +6076,8 @@ function getDefaultErrorPolicy(strategy) {
   }
   return "reduce_denominator";
 }
-var ConsensusVoteInputSchema = z9.object({
-  proposal: z9.string().min(1).max(MAX_PROPOSAL_LENGTH).describe("Proposal text to vote on"),
+var ConsensusVoteInputSchema = z7.object({
+  proposal: z7.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."
   ),
@@ -7817,8 +6087,8 @@ var ConsensusVoteInputSchema = z9.object({
   errorPolicy: ErrorPolicySchema.optional().describe(
     "How to treat voters that errored or timed out (#2630). Default: fail_closed for unanimous only; reduce_denominator for all other strategies incl. higher_order/opinion_wise (#3138 \u2014 a single infra timeout should not void an otherwise-unanimous vote). 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(
+  quickMode: z7.boolean().optional().default(false).describe("Use 3 agents instead of the full 7-role panel for faster execution"),
+  simulateVotes: z7.boolean().optional().default(false).describe(
     "TESTS ONLY \u2014 when true, voters return random decisions. Output must not be used for real decisions. (#2319)"
   ),
   /**
@@ -7838,7 +6108,7 @@ var ConsensusVoteInputSchema = z9.object({
    * Kept optional (no `.default()`) so the inferred type doesn't force
    * `mode: 'sync'` on every existing call site / test fixture.
    */
-  mode: z9.enum(["sync", "async"]).optional().describe(
+  mode: z7.enum(["sync", "async"]).optional().describe(
     'Dispatch mode (default: sync). Use "async" for higher-order strategies with 7 voters.'
   ),
   /**
@@ -7847,7 +6117,7 @@ var ConsensusVoteInputSchema = z9.object({
    * same key with different inputs fails closed with
    * `idempotency_key_collision`. Sync mode ignores this.
    */
-  idempotencyKey: z9.string().min(1).max(256).optional().describe(
+  idempotencyKey: z7.string().min(1).max(256).optional().describe(
     "Replay-safe key for async-mode dispatch (#3042 Stage 1c). Same (key, inputs) returns existing jobId."
   )
 });
@@ -7954,7 +6224,7 @@ function applyErrorPolicy(votes, policy) {
 }
 
 // src/orchestration/outcomes/outcome-store-persistence.ts
-import { appendFileSync as appendFileSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync3 } from "fs";
+import { appendFileSync as appendFileSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
 var PersistentOutcomeStore = class extends OutcomeStore {
   filePath;
   logger;
@@ -8005,7 +6275,7 @@ var PersistentOutcomeStore = class extends OutcomeStore {
     }
   }
   hydrate() {
-    if (!existsSync3(this.filePath)) {
+    if (!existsSync2(this.filePath)) {
       this.logger.debug("No outcomes file found, starting fresh", {
         path: this.filePath
       });
@@ -8064,7 +6334,7 @@ var PersistentOutcomeStore = class extends OutcomeStore {
   }
   persistLine(outcome) {
     try {
-      appendFileSync3(this.filePath, JSON.stringify(outcome) + "\n", "utf-8");
+      appendFileSync2(this.filePath, JSON.stringify(outcome) + "\n", "utf-8");
     } catch (error) {
       const msg = getErrorMessage(error);
       this.logger.warn("Failed to persist outcome to disk", {
@@ -8190,384 +6460,39 @@ function warnIfSimulatedOutsideTests(toolName, logger11) {
   );
 }
 
-// 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
-  },
-  /** Reads job-result sidecar file for an async-mode dispatch (#3042 / #2631). */
-  get_job_result: {
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: false
-  },
-  /** Lists async-mode job summaries from the sidecar dir (#3046 / #2631 Stage 5). */
-  list_jobs: {
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: false
-  },
-  /** Cancels an in-flight async-mode job (#3042 Stage 1b / #2631). */
-  cancel_job: {
-    // Mutates the sidecar record — NOT read-only.
-    readOnlyHint: false,
-    // Reversibility: cancel writes a new state, but doesn't delete data —
-    // not destructive in the OWASP sense (no irreversible data loss).
-    destructiveHint: false,
-    // Idempotent: repeat cancels are no-ops with explicit outcome envelope.
-    idempotentHint: true,
-    openWorldHint: false
-  },
-  /** Verifies hash chain of audit log files. */
-  verify_audit_chain: {
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: false
-  },
-  /** CI infrastructure health check — composes status-page + recent-runs signals (#3076). */
-  ci_health_check: {
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    // Hits external services (githubstatus.com + GitHub API) — `openWorldHint`.
-    openWorldHint: true
-  },
-  /** 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/jobs/job-result-store.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync, writeFileSync as writeFileSync3 } from "fs";
-import { z as z10 } from "zod";
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync, writeFileSync as writeFileSync3 } from "fs";
+import { z as z8 } from "zod";
 var logger8 = createLogger({ component: "job-result-store" });
-var JobStatusSchema = z10.enum(["pending", "complete", "failed", "cancelled"]);
-var JobResultSchema = z10.object({
+var JobStatusSchema = z8.enum(["pending", "complete", "failed", "cancelled"]);
+var JobResultSchema = z8.object({
   /** Format version. Currently `1` — bump if the shape changes. */
-  v: z10.literal(1),
-  jobId: z10.string().min(1),
+  v: z8.literal(1),
+  jobId: z8.string().min(1),
   /** Tool that was invoked (e.g. `orchestrate`). */
-  toolName: z10.string().min(1),
+  toolName: z8.string().min(1),
   status: JobStatusSchema,
-  createdAt: z10.iso.datetime(),
+  createdAt: z8.iso.datetime(),
   /** Set when the job leaves `pending` — either via `complete` or `failed` or `cancelled`. */
-  completedAt: z10.iso.datetime().optional(),
+  completedAt: z8.iso.datetime().optional(),
   /**
    * Structured payload the synchronous mode would have returned. Present
    * only when `status === 'complete'`. Shape is tool-specific — readers
    * cast to the tool's known output type after status check.
    */
-  result: z10.unknown().optional(),
+  result: z8.unknown().optional(),
   /**
    * Failure message when `status === 'failed'`. Cannot be paired with
    * `result` — the discriminator is `status`.
    */
-  error: z10.string().optional()
+  error: z8.string().optional()
 });
 function jobResultPath(jobId) {
   return nexusDataPathEnsure("jobs", `result-${jobId}.json`);
 }
 function writeJobPending(jobId, toolName) {
   const path = jobResultPath(jobId);
-  if (existsSync4(path)) {
+  if (existsSync3(path)) {
     logger8.debug("Job result file already exists \u2014 leaving in place", { jobId });
     return;
   }
@@ -8622,7 +6547,7 @@ function writeJobCancelled(jobId, toolName, reason) {
 }
 function readJobResult(jobId) {
   const path = nexusDataPath("jobs", `result-${jobId}.json`);
-  if (!existsSync4(path)) return null;
+  if (!existsSync3(path)) return null;
   try {
     const raw = JSON.parse(readFileSync3(path, "utf-8"));
     const parsed = JobResultSchema.safeParse(raw);
@@ -8642,7 +6567,7 @@ function readJobResult(jobId) {
 }
 function listJobs() {
   const dir = nexusDataPath("jobs");
-  if (!existsSync4(dir)) return [];
+  if (!existsSync3(dir)) return [];
   let entries;
   try {
     entries = readdirSync(dir);
@@ -8675,22 +6600,22 @@ function listJobs() {
 }
 
 // src/mcp/jobs/job-idempotency.ts
-import { createHash, randomUUID as randomUUID3 } from "crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { z as z11 } from "zod";
+import { createHash, randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { z as z9 } from "zod";
 var logger9 = createLogger({ component: "job-idempotency" });
-var IdempotencyIndexEntrySchema = z11.object({
-  v: z11.literal(1),
+var IdempotencyIndexEntrySchema = z9.object({
+  v: z9.literal(1),
   /** MCP tool name (e.g. `orchestrate`, `run_workflow`, `consensus_vote`). */
-  tool: z11.string().min(1),
+  tool: z9.string().min(1),
   /** Caller-supplied idempotency key. */
-  key: z11.string().min(1),
+  key: z9.string().min(1),
   /** sha256 of the canonical input JSON. */
-  inputsHash: z11.string().length(64),
+  inputsHash: z9.string().length(64),
   /** Existing jobId for this (tool, key, inputs) tuple. */
-  jobId: z11.string().min(1),
+  jobId: z9.string().min(1),
   /** ISO timestamp of first dispatch. */
-  createdAt: z11.iso.datetime()
+  createdAt: z9.iso.datetime()
 });
 function sha256Hex(input) {
   return createHash("sha256").update(input).digest("hex");
@@ -8712,13 +6637,13 @@ function indexFilePathReadOnly(tool, key) {
   const filename = `key-${sha256Hex(`${tool}:${key}`)}.json`;
   return nexusDataPath("jobs", filename);
 }
-function resolveIdempotency(tool, idempotencyKey, inputs, randomFallback = randomUUID3) {
+function resolveIdempotency(tool, idempotencyKey, inputs, randomFallback = randomUUID2) {
   if (idempotencyKey === void 0 || idempotencyKey === "") {
     return { kind: "fresh", jobId: randomFallback() };
   }
   const incomingInputsHash = computeInputsHash(inputs);
   const path = indexFilePathReadOnly(tool, idempotencyKey);
-  if (existsSync5(path)) {
+  if (existsSync4(path)) {
     const entry = readIndexEntry(path);
     if (entry !== null) {
       if (entry.inputsHash === incomingInputsHash) {
@@ -8738,7 +6663,7 @@ function resolveIdempotency(tool, idempotencyKey, inputs, randomFallback = rando
 }
 function registerIdempotentJob(params) {
   const path = indexFilePath(params.tool, params.idempotencyKey);
-  if (existsSync5(path)) {
+  if (existsSync4(path)) {
     logger9.debug("Idempotency index entry already present; skipping write", {
       tool: params.tool,
       jobId: params.jobId
@@ -8862,7 +6787,7 @@ function suggestRetryAfterMs(toolName) {
 }
 
 // src/mcp/tools/consensus-vote.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 var persistentCorrelationTracker;
 function getOrCreateCorrelationTracker() {
   persistentCorrelationTracker ??= createPersistentCorrelationTracker();
@@ -9043,7 +6968,7 @@ async function processVotesWithCascade(engineVotes, opts) {
 var CONTRARIAN_ESCALATION_THRESHOLD = 0.8;
 async function runContrarianCheck(proposal, log) {
   try {
-    const { executeExpert } = await import("./expert-bridge-OXME7FES.js");
+    const { executeExpert } = await import("./expert-bridge-N4L47MHU.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.",
@@ -9237,7 +7162,7 @@ function dispatchAsyncConsensusVote(deps, args) {
     tool: "consensus_vote",
     idempotencyKey: args.idempotencyKey,
     inputs: args,
-    freshJobId: () => `job-vote-${randomUUID4()}`,
+    freshJobId: () => `job-vote-${randomUUID3()}`,
     replayEnvelope: buildConsensusVoteReplayEnvelope,
     collisionEnvelope: buildConsensusVoteCollisionEnvelope
   });
@@ -9348,27 +7273,27 @@ function createConsensusVoteHandler(deps) {
   };
 }
 var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
-  proposal: z12.string(),
+  proposal: z10.string(),
   strategy: VotingStrategySchema,
-  decision: z12.enum(["approved", "rejected", "no_quorum"]),
-  approvalPercentage: z12.number(),
-  voteCounts: z12.object({
-    approve: z12.number(),
-    reject: z12.number(),
-    abstain: z12.number(),
-    error: z12.number()
+  decision: z10.enum(["approved", "rejected", "no_quorum"]),
+  approvalPercentage: z10.number(),
+  voteCounts: z10.object({
+    approve: z10.number(),
+    reject: z10.number(),
+    abstain: z10.number(),
+    error: z10.number()
   }),
-  votes: z12.array(
-    z12.object({
-      role: z12.string().max(100),
-      decision: z12.enum(["approve", "reject", "abstain"]),
-      confidence: z12.number(),
-      reasoning: z12.string().max(4e3),
-      simulated: z12.boolean(),
-      error: z12.boolean(),
-      modelUsed: z12.string().max(100).optional(),
-      rejectionCategories: z12.array(
-        z12.enum([
+  votes: z10.array(
+    z10.object({
+      role: z10.string().max(100),
+      decision: z10.enum(["approve", "reject", "abstain"]),
+      confidence: z10.number(),
+      reasoning: z10.string().max(4e3),
+      simulated: z10.boolean(),
+      error: z10.boolean(),
+      modelUsed: z10.string().max(100).optional(),
+      rejectionCategories: z10.array(
+        z10.enum([
           "YAGNI",
           "DRY_VIOLATION",
           "OVER_ENGINEERING",
@@ -9381,34 +7306,34 @@ var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
     })
   ),
   threshold: VoteThresholdSchema.optional(),
-  durationMs: z12.number(),
-  simulateVotes: z12.boolean(),
-  higherOrderMetadata: z12.object({
-    posteriorApproval: z12.number(),
-    posteriorRejection: z12.number(),
-    effectiveVoteCount: z12.number(),
-    method: z12.enum(["ow", "isp", "simple"]),
-    usedCorrelationData: z12.boolean(),
-    improvementOverBaseline: z12.number(),
-    downweightedAgents: z12.array(z12.string().max(100)).max(10),
-    reasoning: z12.string().max(2e3)
+  durationMs: z10.number(),
+  simulateVotes: z10.boolean(),
+  higherOrderMetadata: z10.object({
+    posteriorApproval: z10.number(),
+    posteriorRejection: z10.number(),
+    effectiveVoteCount: z10.number(),
+    method: z10.enum(["ow", "isp", "simple"]),
+    usedCorrelationData: z10.boolean(),
+    improvementOverBaseline: z10.number(),
+    downweightedAgents: z10.array(z10.string().max(100)).max(10),
+    reasoning: z10.string().max(2e3)
   }).optional(),
   // #3124: explains a `rejected` decision that coexists with a high
   // approvalPercentage (an error-policy short-circuit, e.g. fail_closed).
-  policyReason: z12.string().max(200).optional()
+  policyReason: z10.string().max(200).optional()
 };
 function registerConsensusVoteTool(server, deps) {
   const logger11 = deps.logger ?? createLogger({ tool: "consensus_vote" });
   const notifier = deps.notifier ?? createMcpNotifier(server);
   const depsWithNotifier = { ...deps, notifier };
   const toolSchema = {
-    proposal: z12.string().min(1).max(MAX_PROPOSAL_LENGTH).describe("Proposal text to vote on"),
-    threshold: z12.enum(["majority", "supermajority", "unanimous"]).optional().describe("Voting threshold (legacy). Use strategy instead."),
+    proposal: z10.string().min(1).max(MAX_PROPOSAL_LENGTH).describe("Proposal text to vote on"),
+    threshold: z10.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: z12.boolean().optional().default(false).describe("Use 3 agents instead of 7"),
-    simulateVotes: z12.boolean().optional().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
+    quickMode: z10.boolean().optional().default(false).describe("Use 3 agents instead of 7"),
+    simulateVotes: z10.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), {
@@ -9451,38 +7376,6 @@ export {
   wrapResilientWithFallback,
   createUnifiedRegistry,
   getGlobalRegistry,
-  validateToolInput,
-  createValidator,
-  RateLimiter,
-  createDefaultRateLimiter,
-  PolicyError,
-  PolicyConfigSchema,
-  denyMutationsWithoutModeRule,
-  safePathsRule,
-  PolicyFirewall,
-  createDefaultPolicyFirewall,
-  evaluatePolicy,
-  createPolicyContext,
-  actorFromContext,
-  resultToOutcome,
-  logToolInvocationAudit,
-  logPolicyAudit,
-  logRateLimitAudit,
-  toolSuccess,
-  toolSuccessStructured,
-  toolStructuredError,
-  toolError,
-  createSecureHandler,
-  createMcpNotifier,
-  NOOP_NOTIFIER,
-  abortSignalStorage,
-  withProgressHeartbeat,
-  withAccessPolicy,
-  getToolTimeout,
-  wrapToolWithTimeout,
-  toSdkCallback,
-  toSdkCallbackWithBudgetCheck,
-  getToolAnnotations,
   PersistentOutcomeStore,
   JobStatusSchema,
   writeJobPending,
@@ -9566,4 +7459,4 @@ export {
   CONSENSUS_VOTE_OUTPUT_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-TNBWHOPY.js.map
+//# sourceMappingURL=chunk-Z7PILY4E.js.map