nexus-agents 8.63.1 → 8.63.2

package/dist/{chunk-SYMY2WZI.js → chunk-TZKXFJSF.js}

@@ -21,7 +21,7 @@ import {
 import {
   DEFAULT_TASK_TTL_MS,
   clampTaskTtl
-} from "./chunk-KM2Q6MWR.js";
+} from "./chunk-Y466OQB2.js";
 import {
   executeExpert
 } from "./chunk-3X7U2LTF.js";
@@ -71,7 +71,7 @@ import {
   updateStage,
   withWarnings,
   writeJobCancelled
-} from "./chunk-YHJO37S5.js";
+} from "./chunk-BPUYQPXF.js";
 import {
   allOf,
   anyOf
@@ -93,7 +93,7 @@ import {
 } from "./chunk-PEZRHADK.js";
 import {
   withPrerequisite
-} from "./chunk-4MYYKOYW.js";
+} from "./chunk-DZPAS2KT.js";
 import {
   NOOP_NOTIFIER,
   RateLimiter,
@@ -116,7 +116,7 @@ import {
   toolSuccessStructured,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-J3WA3SHX.js";
+} from "./chunk-6RTJNYWK.js";
 import {
   EventTopics,
   UNRESOLVED_MODEL_ID,
@@ -27323,10 +27323,10 @@ function calculateDifferenceCI(p1, p2, total1, total2, confidence) {
   const difference = p1 - p2;
   const measured = total1 > 0 && total2 > 0;
   const seDiff = Math.sqrt(p1 * (1 - p1) / (total1 || 1) + p2 * (1 - p2) / (total2 || 1));
-  const z127 = getZScore(confidence);
+  const z128 = getZScore(confidence);
   return {
-    lower: difference - z127 * seDiff,
-    upper: difference + z127 * seDiff,
+    lower: difference - z128 * seDiff,
+    upper: difference + z128 * seDiff,
     estimate: difference,
     confidence,
     n: total1 + total2,
@@ -27354,11 +27354,11 @@ function proportionConfidenceInterval(successes, total, options = {}) {
       measured: false
     };
   }
-  const z127 = getZScore(opts.confidence);
-  const z210 = z127 * z127;
+  const z128 = getZScore(opts.confidence);
+  const z210 = z128 * z128;
   const denominator = 1 + z210 / n;
   const center = (p + z210 / (2 * n)) / denominator;
-  const margin = z127 / denominator * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
+  const margin = z128 / denominator * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
   const lower = Math.max(0, center - margin);
   const upper = Math.min(1, center + margin);
   const standardError = Math.sqrt(p * (1 - p) / n);
@@ -27396,8 +27396,8 @@ function meanConfidenceInterval(values, options = {}) {
   const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / (n - 1 || 1);
   const stdDev = Math.sqrt(variance);
   const standardError = stdDev / Math.sqrt(n);
-  const z127 = getZScore(opts.confidence);
-  const margin = z127 * standardError;
+  const z128 = getZScore(opts.confidence);
+  const margin = z128 * standardError;
   return {
     lower: mean - margin,
     upper: mean + margin,
@@ -34523,11 +34523,96 @@ async function maybeRetryAfterTriage(opts) {
   return { ...retryResult, triageAction: triage.action, wasRetried: true };
 }
 
+// src/orchestration/aorchestra/context-distillation.ts
+import { z as z63 } from "zod";
+var PhaseDistillationSchema = z63.object({
+  /** Key decisions made during this phase */
+  decisions: z63.array(z63.string()),
+  /** Artifacts produced (file paths, URLs, IDs) */
+  artifacts: z63.array(z63.string()),
+  /** Important findings or observations */
+  findings: z63.array(z63.string()),
+  /** Errors encountered (if any) */
+  errors: z63.array(z63.string()),
+  /** One-sentence summary of the phase outcome */
+  summary: z63.string()
+});
+var DECISION_PATTERNS = [
+  /(?:decided|chosen|selected|using|went with|picked|adopted|approved)\s+(.{10,100})/gi,
+  /(?:will|should|must)\s+(use|implement|create|add|remove|change)\s+(.{10,80})/gi
+];
+var ARTIFACT_PATTERNS = [
+  /(?:created?|wrote|generated|built|saved|output)\s+(?:file|module|component|test|schema)?\s*[`"]?([/\w.-]+\.\w{1,6})[`"]?/gi,
+  /(?:commit|push|deploy|publish)(?:ed|ing)?\s+(.{10,60})/gi
+];
+var ERROR_PATTERNS = [
+  /(?:error|failed|failure|exception|crash|timeout|rejected):\s*(.{10,100})/gi,
+  /(?:could not|unable to|cannot)\s+(.{10,80})/gi
+];
+var FINDING_PATTERNS = [
+  /(?:found|discovered|detected|noticed|identified|observed)\s+(.{10,100})/gi,
+  /(?:vulnerability|issue|bug|problem|concern|risk):\s*(.{10,100})/gi
+];
+function extractMatches(text, patterns, maxItems) {
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const pattern of patterns) {
+    pattern.lastIndex = 0;
+    let match = pattern.exec(text);
+    while (match !== null && results.length < maxItems) {
+      const value = (match[match.length - 1] ?? match[0]).trim();
+      const normalized = value.toLowerCase();
+      if (value.length > 5 && !seen.has(normalized)) {
+        seen.add(normalized);
+        results.push(value);
+      }
+      match = pattern.exec(text);
+    }
+  }
+  return results;
+}
+function distillPhaseOutput(phaseOutput, maxItemsPerCategory = 5) {
+  const decisions = extractMatches(phaseOutput, DECISION_PATTERNS, maxItemsPerCategory);
+  const artifacts = extractMatches(phaseOutput, ARTIFACT_PATTERNS, maxItemsPerCategory);
+  const findings = extractMatches(phaseOutput, FINDING_PATTERNS, maxItemsPerCategory);
+  const errors = extractMatches(phaseOutput, ERROR_PATTERNS, maxItemsPerCategory);
+  const firstSentence = phaseOutput.match(/^[^.!?\n]{10,200}[.!?]/);
+  const summary = firstSentence ? firstSentence[0].trim() : phaseOutput.slice(0, 200).trim() + (phaseOutput.length > 200 ? "..." : "");
+  return { decisions, artifacts, findings, errors, summary };
+}
+function formatSection(lines, heading, items) {
+  if (items.length === 0) return;
+  lines.push("");
+  lines.push(`### ${heading}`);
+  for (const item of items) {
+    lines.push(`- ${item}`);
+  }
+}
+function formatDistillation(distillation, phaseLabel) {
+  const lines = [];
+  const heading = phaseLabel !== void 0 && phaseLabel !== "" ? `## ${phaseLabel} Summary` : "## Prior Phase Summary";
+  lines.push(heading);
+  lines.push("");
+  lines.push(distillation.summary);
+  formatSection(lines, "Decisions", distillation.decisions);
+  formatSection(lines, "Artifacts", distillation.artifacts);
+  formatSection(lines, "Findings", distillation.findings);
+  formatSection(lines, "Errors", distillation.errors);
+  return lines.join("\n");
+}
+function compressionRatio(originalLength, distilledLength) {
+  if (originalLength === 0) return 1;
+  return distilledLength / originalLength;
+}
+
 // src/orchestration/aorchestra/cross-wave-context.ts
 var logger29 = createLogger({ component: "cross-wave-context" });
 var MAX_CHARS_PER_WORKER = 1500;
 var MAX_NAMED_OMITTED_ROLES = 8;
 var MAX_PRIOR_CONTEXT_CHARS = 6e3;
+var TRUNCATED_MARKER = " [truncated]";
+var DISTILLATION_SHADOW_LOG_MESSAGE = "Prior-wave distillation shadow (#5974)";
+var PRIOR_WAVE_HEADER = "## Prior Wave Context\n\nThe following results were produced by prior wave workers. Use this context to inform your work.\n";
 var INJECTION_PATTERNS2 = [
   /<\/?(?:system|human|assistant|instructions)(?:\s[^>]*)?>[\s\S]*?(?:<\/(?:system|human|assistant|instructions)>|$)/gi,
   /<img\b[^>]*>/gi,
@@ -34585,15 +34670,14 @@ function buildPriorWaveContextBlock(results) {
     }
     return "";
   }
-  const header = "## Prior Wave Context\n\nThe following results were produced by prior wave workers. Use this context to inform your work.\n";
-  let totalChars = header.length;
+  let totalChars = PRIOR_WAVE_HEADER.length;
   const entries = [];
   const omittedRoles = [];
+  const shadowInputs = [];
   for (const result of successResults) {
     const sanitized = sanitizeWorkerOutput(result.output);
-    const truncated = sanitized.length > MAX_CHARS_PER_WORKER ? sanitized.slice(0, MAX_CHARS_PER_WORKER) + " [truncated]" : sanitized;
-    const entry = `### ${result.role} (${result.status})
-${truncated}`;
+    shadowInputs.push({ role: result.role, sanitized });
+    const entry = formatEntry(result.role, truncateWorkerOutput(sanitized));
     if (totalChars + entry.length > MAX_PRIOR_CONTEXT_CHARS) {
       omittedRoles.push(result.role);
       continue;
@@ -34601,10 +34685,68 @@ ${truncated}`;
     entries.push(entry);
     totalChars += entry.length;
   }
+  logger29.info(DISTILLATION_SHADOW_LOG_MESSAGE, { ...shadowDistillPriorWave(shadowInputs) });
   if (entries.length === 0) return "";
   const failures = buildFailureSummary(results, MAX_PRIOR_CONTEXT_CHARS - totalChars);
   const omitted = [...omittedRoles, ...failures.omittedRoles];
-  return header + "\n" + entries.join("\n\n") + failures.text + buildOmissionNotice(omitted);
+  return PRIOR_WAVE_HEADER + "\n" + entries.join("\n\n") + failures.text + buildOmissionNotice(omitted);
+}
+function truncateWorkerOutput(sanitized) {
+  return sanitized.length > MAX_CHARS_PER_WORKER ? sanitized.slice(0, MAX_CHARS_PER_WORKER) + TRUNCATED_MARKER : sanitized;
+}
+function formatEntry(role, body) {
+  return `### ${role} (success)
+${body}`;
+}
+function shadowDistillPriorWave(inputs, budgetChars = MAX_PRIOR_CONTEXT_CHARS) {
+  const workers = inputs.map((input) => measureWorker(input));
+  return {
+    workers,
+    budgetChars,
+    truncationKept: countKeptUnderBudget(workers, (w) => w.truncatedChars, budgetChars),
+    distillationWouldKeep: countKeptUnderBudget(workers, (w) => w.candidateChars, budgetChars),
+    degenerateCount: workers.filter((w) => !w.matchedAnyPattern).length,
+    totalSanitizedChars: workers.reduce((n, w) => n + w.sanitizedChars, 0),
+    totalTruncatedChars: workers.reduce((n, w) => n + w.truncatedChars, 0),
+    totalCandidateChars: workers.reduce((n, w) => n + w.candidateChars, 0)
+  };
+}
+function measureWorker(input) {
+  const { role, sanitized } = input;
+  const truncatedChars = truncateWorkerOutput(sanitized).length;
+  const distillation = distillPhaseOutput(sanitized);
+  const distilledChars = formatDistillation(distillation, role).length;
+  const patternHits = {
+    decisions: distillation.decisions.length,
+    artifacts: distillation.artifacts.length,
+    findings: distillation.findings.length,
+    errors: distillation.errors.length
+  };
+  const matchedAnyPattern = patternHits.decisions + patternHits.artifacts + patternHits.findings + patternHits.errors > 0;
+  const fellBackToTruncation = !matchedAnyPattern;
+  return {
+    role,
+    sanitizedChars: sanitized.length,
+    truncatedChars,
+    distilledChars,
+    candidateChars: fellBackToTruncation ? truncatedChars : distilledChars,
+    truncationRatio: compressionRatio(sanitized.length, truncatedChars),
+    distillationRatio: compressionRatio(sanitized.length, distilledChars),
+    patternHits,
+    matchedAnyPattern,
+    fellBackToTruncation
+  };
+}
+function countKeptUnderBudget(workers, sizeOf, budgetChars) {
+  let total = PRIOR_WAVE_HEADER.length;
+  let kept = 0;
+  for (const w of workers) {
+    const entryChars = formatEntry(w.role, "").length + sizeOf(w);
+    if (total + entryChars > budgetChars) continue;
+    total += entryChars;
+    kept += 1;
+  }
+  return kept;
 }
 var MAX_ERROR_SNIPPET_CHARS = 100;
 function buildOmissionNotice(omittedRoles) {
@@ -35759,14 +35901,14 @@ function mergeRefinedResults(original, refined) {
 }
 
 // src/mcp/tools/reflective-retriever.ts
-import { z as z63 } from "zod";
+import { z as z64 } from "zod";
 var REFLECTION_TIMEOUT_MS = REFLECTIVE_TIMEOUTS.reflectionMs;
 var MAX_CACHE_ENTRIES = 50;
 var CACHE_TTL_MS = REFLECTIVE_TIMEOUTS.cacheTtlMs;
 var REFLECTION_MAX_TOKENS = 100;
-var ReflectionCriteriaSchema = z63.object({
-  keywords: z63.array(z63.string()).min(1).max(10).describe("Expanded keywords for memory search"),
-  context: z63.string().max(200).describe("Brief context about what memories would be useful")
+var ReflectionCriteriaSchema = z64.object({
+  keywords: z64.array(z64.string()).min(1).max(10).describe("Expanded keywords for memory search"),
+  context: z64.string().max(200).describe("Brief context about what memories would be useful")
 });
 var ReflectionCache = class {
   entries = /* @__PURE__ */ new Map();
@@ -36908,42 +37050,42 @@ function registerOrchestrateTool(server, deps) {
 }
 
 // src/mcp/tools/delegate-to-model-types.ts
-import { z as z64 } from "zod";
+import { z as z65 } from "zod";
 var MODEL_CAPABILITIES2 = buildCapabilityProfiles();
-var DelegateInputSchema = z64.object({
-  task: z64.string().min(1).max(5e4).describe("Task to execute or analyze"),
-  preferred_capability: z64.enum(["reasoning", "context", "speed", "code"]).optional().describe("Preferred capability for routing: reasoning, context, speed, or code"),
-  model_hint: z64.string().max(100).optional().describe("Explicit model preference (e.g., claude-opus, gemini-pro)"),
+var DelegateInputSchema = z65.object({
+  task: z65.string().min(1).max(5e4).describe("Task to execute or analyze"),
+  preferred_capability: z65.enum(["reasoning", "context", "speed", "code"]).optional().describe("Preferred capability for routing: reasoning, context, speed, or code"),
+  model_hint: z65.string().max(100).optional().describe("Explicit model preference (e.g., claude-opus, gemini-pro)"),
   // estimate_tokens flag removed (#2723). The field was declared in two schemas
   // (here and in TOOL_SCHEMA below) but never read by any consumer — calling
   // `delegate_to_model { estimate_tokens: true }` returned the full routing
   // decision identical to omitting the flag. The output already carries
   // `estimated_tokens` so the use case the flag advertised is satisfied
   // without the flag.
-  billing_mode: z64.enum(["plan", "api"]).optional().describe("Billing mode: plan (monthly subscription, ignore cost) or api (pay-per-token)")
+  billing_mode: z65.enum(["plan", "api"]).optional().describe("Billing mode: plan (monthly subscription, ignore cost) or api (pay-per-token)")
 });
-var DelegateOutputSchema = z64.object({
-  recommended_model: z64.string().max(100).describe("The model recommended for this task"),
-  reasoning: z64.string().max(2e3).describe("Why this model was selected"),
-  capabilities: z64.object({
-    reasoning: z64.number(),
-    contextWindow: z64.number(),
-    codeGeneration: z64.number(),
-    speed: z64.number(),
-    cost: z64.number()
+var DelegateOutputSchema = z65.object({
+  recommended_model: z65.string().max(100).describe("The model recommended for this task"),
+  reasoning: z65.string().max(2e3).describe("Why this model was selected"),
+  capabilities: z65.object({
+    reasoning: z65.number(),
+    contextWindow: z65.number(),
+    codeGeneration: z65.number(),
+    speed: z65.number(),
+    cost: z65.number()
   }),
-  estimated_tokens: z64.number().describe("Estimated tokens for task"),
-  alternatives: z64.array(
-    z64.object({
-      model: z64.string().max(100),
-      score: z64.number(),
-      tradeoff: z64.string().max(500)
+  estimated_tokens: z65.number().describe("Estimated tokens for task"),
+  alternatives: z65.array(
+    z65.object({
+      model: z65.string().max(100),
+      score: z65.number(),
+      tradeoff: z65.string().max(500)
     })
   ).max(10).describe("Alternative model options with tradeoffs"),
-  governance: z64.object({
-    domain: z64.string().max(100).describe("Governance domain (e.g., security, architecture)"),
-    votingThreshold: z64.string().max(50).describe("Required voting threshold (e.g., supermajority)"),
-    promotionReason: z64.string().max(500).describe("Why governance was promoted")
+  governance: z65.object({
+    domain: z65.string().max(100).describe("Governance domain (e.g., security, architecture)"),
+    votingThreshold: z65.string().max(50).describe("Required voting threshold (e.g., supermajority)"),
+    promotionReason: z65.string().max(500).describe("Why governance was promoted")
   }).optional().describe("Present when task triggers governance promotion")
 });
 var REASONING_KEYWORDS = [
@@ -37020,11 +37162,11 @@ var EXPLORATION_KEYWORDS = [
   "navigate"
 ];
 var TOOL_SCHEMA = {
-  task: z64.string().min(1).max(5e4).describe("Task to execute or analyze"),
-  preferred_capability: z64.enum(["reasoning", "context", "speed", "code"]).optional().describe("Preferred capability for routing"),
-  model_hint: z64.string().max(100).optional().describe("Explicit model preference"),
+  task: z65.string().min(1).max(5e4).describe("Task to execute or analyze"),
+  preferred_capability: z65.enum(["reasoning", "context", "speed", "code"]).optional().describe("Preferred capability for routing"),
+  model_hint: z65.string().max(100).optional().describe("Explicit model preference"),
   // estimate_tokens removed (#2723) — see comment above on DelegateInputSchema.
-  billing_mode: z64.enum(["plan", "api"]).optional().describe("Billing mode for cost handling")
+  billing_mode: z65.enum(["plan", "api"]).optional().describe("Billing mode for cost handling")
 };
 
 // src/mcp/tools/delegate-to-model-helpers.ts
@@ -38448,9 +38590,9 @@ function standardReportHandler(state) {
 }
 
 // src/mcp/tools/list-experts.ts
-import { z as z65 } from "zod";
-var ListExpertsInputSchema = z65.object({
-  format: z65.enum(["full", "names"]).optional().default("full").describe("Output format: full (with details) or names (just role names)")
+import { z as z66 } from "zod";
+var ListExpertsInputSchema = z66.object({
+  format: z66.enum(["full", "names"]).optional().default("full").describe("Output format: full (with details) or names (just role names)")
 });
 var EXPERT_TYPE_TO_ROLE2 = {
   code: "code_expert",
@@ -38521,7 +38663,7 @@ function listExpertsHandler(args, ctx) {
 function registerListExpertsTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "list_experts" });
   const toolSchema = {
-    format: z65.enum(["full", "names"]).optional().describe("Output format: full (with details) or names (just role names)")
+    format: z66.enum(["full", "names"]).optional().describe("Output format: full (with details) or names (just role names)")
   };
   const description = "Inventory of expert ROLES available to `create_expert` (architect, security, devex, etc.). Use this BEFORE create_expert to pick a role; returns role name and capability summary.";
   const secureHandler = createSecureHandler(listExpertsHandler, {
@@ -38532,15 +38674,15 @@ function registerListExpertsTool(server, deps) {
   const timeoutMs = getToolTimeout("list_experts", deps.security);
   const wrappedHandler = wrapToolWithTimeout("list_experts", secureHandler, { timeoutMs, logger: logger57 });
   const outputSchema = {
-    experts: z65.array(
-      z65.object({
-        role: z65.string(),
-        name: z65.string(),
-        description: z65.string(),
-        capabilities: z65.array(z65.string())
+    experts: z66.array(
+      z66.object({
+        role: z66.string(),
+        name: z66.string(),
+        description: z66.string(),
+        capabilities: z66.array(z66.string())
       })
     ),
-    count: z65.number()
+    count: z66.number()
   };
   server.registerTool(
     "list_experts",
@@ -38556,10 +38698,10 @@ function registerListExpertsTool(server, deps) {
 }
 
 // src/mcp/tools/list-workflows.ts
-import { z as z66 } from "zod";
-var ListWorkflowsInputSchema = z66.object({
-  category: z66.string().optional().describe("Filter by category (e.g., development, security)"),
-  format: z66.enum(["full", "names"]).optional().default("full").describe("Output format: full (with details) or names (just template names)")
+import { z as z67 } from "zod";
+var ListWorkflowsInputSchema = z67.object({
+  category: z67.string().optional().describe("Filter by category (e.g., development, security)"),
+  format: z67.enum(["full", "names"]).optional().default("full").describe("Output format: full (with details) or names (just template names)")
 });
 async function handleListWorkflows(workflowEngine, args) {
   const templates = await workflowEngine.listTemplates();
@@ -38613,8 +38755,8 @@ function createListWorkflowsHandler(workflowEngine) {
 function registerListWorkflowsTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "list_workflows" });
   const toolSchema = {
-    category: z66.string().optional().describe("Filter by category (e.g., development, security)"),
-    format: z66.enum(["full", "names"]).optional().describe("Output format: full (with details) or names (just template names)")
+    category: z67.string().optional().describe("Filter by category (e.g., development, security)"),
+    format: z67.enum(["full", "names"]).optional().describe("Output format: full (with details) or names (just template names)")
   };
   const description = "Inventory of multi-step TEMPLATES available to `run_workflow` (code-review, security-audit, etc.). Use this BEFORE run_workflow to pick a template; returns template name, version, description, and category.";
   const secureHandler = createSecureHandler(createListWorkflowsHandler(deps.workflowEngine), {
@@ -38629,16 +38771,16 @@ function registerListWorkflowsTool(server, deps) {
     timeoutMs !== void 0 ? { timeoutMs, logger: logger57 } : { logger: logger57 }
   );
   const outputSchema = {
-    workflows: z66.array(
-      z66.object({
-        name: z66.string(),
-        version: z66.string(),
-        description: z66.string().optional(),
-        category: z66.string().optional()
+    workflows: z67.array(
+      z67.object({
+        name: z67.string(),
+        version: z67.string(),
+        description: z67.string().optional(),
+        category: z67.string().optional()
       })
     ),
-    count: z66.number(),
-    categories: z66.array(z66.string()).optional()
+    count: z67.number(),
+    categories: z67.array(z67.string()).optional()
   };
   server.registerTool(
     "list_workflows",
@@ -38654,7 +38796,7 @@ function registerListWorkflowsTool(server, deps) {
 }
 
 // src/mcp/tools/execute-expert.ts
-import { z as z68 } from "zod";
+import { z as z69 } from "zod";
 
 // src/mcp/tools/execute-expert-recording.ts
 var ROLE_TO_CATEGORY = {
@@ -38849,12 +38991,12 @@ function observeExpertContext(observation, logger57, threshold = resolveContextW
 }
 
 // src/mcp/tools/execute-expert-task-handler.ts
-import { z as z67 } from "zod";
+import { z as z68 } from "zod";
 var EXECUTE_EXPERT_TOOL_SCHEMA = {
-  expertId: z67.string().min(1).describe("Expert ID from create_expert tool"),
-  task: z67.string().min(1).max(5e4).describe("Task description for the expert to execute"),
-  context: z67.record(z67.string(), z67.unknown()).optional().describe("Additional context metadata for the task"),
-  timeoutMs: z67.number().int().min(EXPERT_TIMEOUTS.executeFloorMs).max(EXPERT_TIMEOUTS.maxMs).optional().describe("Optional timeout in ms (120s-900s). Overrides auto-detected timeout.")
+  expertId: z68.string().min(1).describe("Expert ID from create_expert tool"),
+  task: z68.string().min(1).max(5e4).describe("Task description for the expert to execute"),
+  context: z68.record(z68.string(), z68.unknown()).optional().describe("Additional context metadata for the task"),
+  timeoutMs: z68.number().int().min(EXPERT_TIMEOUTS.executeFloorMs).max(EXPERT_TIMEOUTS.maxMs).optional().describe("Optional timeout in ms (120s-900s). Overrides auto-detected timeout.")
 };
 function createTaskHandler(deps, logger57, executor) {
   const notifier = deps.notifier ?? NOOP_NOTIFIER;
@@ -38949,12 +39091,12 @@ async function runBackgroundExpertTask(opts) {
 
 // src/mcp/tools/execute-expert.ts
 var EXPERT_TIMEOUT_FLOOR_MS = EXPERT_TIMEOUTS.executeFloorMs;
-var ExecuteExpertInputSchema = z68.object({
-  expertId: z68.string().min(1).describe("Expert ID from create_expert tool"),
-  task: z68.string().min(1).max(5e4).describe("Task description for the expert to execute"),
-  context: z68.record(z68.string(), z68.unknown()).optional().describe("Additional context metadata for the task"),
-  timeoutMs: z68.number().int().min(EXPERT_TIMEOUT_FLOOR_MS).max(EXPERT_TIMEOUTS.maxMs).optional().describe("Optional timeout in ms (120s-900s). Overrides auto-detected timeout."),
-  previousExpertSummary: z68.string().max(2e3).optional().describe(
+var ExecuteExpertInputSchema = z69.object({
+  expertId: z69.string().min(1).describe("Expert ID from create_expert tool"),
+  task: z69.string().min(1).max(5e4).describe("Task description for the expert to execute"),
+  context: z69.record(z69.string(), z69.unknown()).optional().describe("Additional context metadata for the task"),
+  timeoutMs: z69.number().int().min(EXPERT_TIMEOUT_FLOOR_MS).max(EXPERT_TIMEOUTS.maxMs).optional().describe("Optional timeout in ms (120s-900s). Overrides auto-detected timeout."),
+  previousExpertSummary: z69.string().max(2e3).optional().describe(
     "Summary from a previous expert in the chain. Injected into prompt for context continuity."
   )
 });
@@ -39288,25 +39430,25 @@ function registerExecuteExpertTool(server, deps) {
 }
 
 // src/mcp/tools/research-query.ts
-import { z as z70 } from "zod";
+import { z as z71 } from "zod";
 import { join as join6 } from "node:path";
 
 // src/research/negative-results.ts
 import { readFileSync as readFileSync5 } from "node:fs";
 import { join as join5 } from "node:path";
 import yaml3 from "yaml";
-import { z as z69 } from "zod";
+import { z as z70 } from "zod";
 var logger33 = createLogger({ component: "negative-results" });
-var NegativeResultSchema = z69.object({
-  name: z69.string(),
-  paper: z69.string(),
-  rejection_date: z69.string(),
-  failure_mode: z69.string(),
-  lessons_learned: z69.array(z69.string()),
-  reopen_conditions: z69.array(z69.string())
+var NegativeResultSchema = z70.object({
+  name: z70.string(),
+  paper: z70.string(),
+  rejection_date: z70.string(),
+  failure_mode: z70.string(),
+  lessons_learned: z70.array(z70.string()),
+  reopen_conditions: z70.array(z70.string())
 });
-var NegativeResultsRegistrySchema = z69.object({
-  negative_results: z69.record(z69.string(), NegativeResultSchema)
+var NegativeResultsRegistrySchema = z70.object({
+  negative_results: z70.record(z70.string(), NegativeResultSchema)
 });
 var NEGATIVE_RESULTS_FILE = "negative-results.yaml";
 function negativeResultsPath() {
@@ -39360,23 +39502,23 @@ function formatRejectionWarning(id, result) {
 }
 
 // src/mcp/tools/research-query.ts
-var ResearchQueryInputSchema = z70.object({
-  action: z70.enum(["status", "overlap", "stats", "search"]).describe(
+var ResearchQueryInputSchema = z71.object({
+  action: z71.enum(["status", "overlap", "stats", "search"]).describe(
     "Query action: status (technique status), overlap (find related techniques), stats (registry statistics), search (text search)"
   ),
-  techniqueId: z70.string().optional().describe("Technique ID for status/overlap queries"),
-  query: z70.string().optional().describe("Search query string for search action"),
-  status: z70.enum(["implemented", "planned", "not-started", "rejected", "all"]).optional().default("all").describe("Filter by technique status (for status action)"),
-  threshold: z70.number().min(0).max(1).optional().default(0.3).describe("Overlap threshold (0-1) for overlap action")
+  techniqueId: z71.string().optional().describe("Technique ID for status/overlap queries"),
+  query: z71.string().optional().describe("Search query string for search action"),
+  status: z71.enum(["implemented", "planned", "not-started", "rejected", "all"]).optional().default("all").describe("Filter by technique status (for status action)"),
+  threshold: z71.number().min(0).max(1).optional().default(0.3).describe("Overlap threshold (0-1) for overlap action")
 });
 var ResearchQueryOutputSchema = {
-  action: z70.string(),
-  success: z70.boolean(),
-  data: z70.unknown(),
-  rejectionNotice: z70.string().optional(),
-  negativeResults: z70.object({
-    status: z70.literal("unavailable"),
-    reason: z70.string()
+  action: z71.string(),
+  success: z71.boolean(),
+  data: z71.unknown(),
+  rejectionNotice: z71.string().optional(),
+  negativeResults: z71.object({
+    status: z71.literal("unavailable"),
+    reason: z71.string()
   }).optional()
 };
 function rejectionMetadataFor(techniqueId) {
@@ -39514,11 +39656,11 @@ function createResearchQueryHandler(deps) {
 function registerResearchQueryTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "research_query" });
   const toolSchema = {
-    action: z70.enum(["status", "overlap", "stats", "search"]).describe("Query action: status, overlap, stats, or search"),
-    techniqueId: z70.string().optional().describe("Technique ID for status/overlap queries"),
-    query: z70.string().optional().describe("Search query string for search action"),
-    status: z70.enum(["implemented", "planned", "not-started", "rejected", "all"]).optional().describe("Filter by technique status"),
-    threshold: z70.number().min(0).max(1).optional().describe("Overlap threshold (0-1) for overlap action")
+    action: z71.enum(["status", "overlap", "stats", "search"]).describe("Query action: status, overlap, stats, or search"),
+    techniqueId: z71.string().optional().describe("Technique ID for status/overlap queries"),
+    query: z71.string().optional().describe("Search query string for search action"),
+    status: z71.enum(["implemented", "planned", "not-started", "rejected", "all"]).optional().describe("Filter by technique status"),
+    threshold: z71.number().min(0).max(1).optional().describe("Overlap threshold (0-1) for overlap action")
   };
   const description = "Query the research registry for technique status, overlaps, statistics, or text search. Provides read-only access to the research tracking system.";
   const secureHandler = createSecureHandler(createResearchQueryHandler(deps), {
@@ -39545,12 +39687,12 @@ function registerResearchQueryTool(server, deps) {
 }
 
 // src/mcp/tools/research-add.ts
-import { z as z71 } from "zod";
-var ResearchAddInputSchema = z71.object({
-  arxivId: z71.string().regex(/^\d{4}\.\d{4,5}$/, "Invalid arXiv ID format (expected XXXX.XXXXX)").describe('arXiv paper ID (e.g., "2401.12345")'),
-  topic: z71.string().optional().describe("Research topic to categorize the paper under"),
-  priority: z71.enum(["P1", "P2", "P3", "P4"]).optional().describe("Priority level for the paper"),
-  dryRun: z71.boolean().optional().default(false).describe("Preview what would be added without persisting")
+import { z as z72 } from "zod";
+var ResearchAddInputSchema = z72.object({
+  arxivId: z72.string().regex(/^\d{4}\.\d{4,5}$/, "Invalid arXiv ID format (expected XXXX.XXXXX)").describe('arXiv paper ID (e.g., "2401.12345")'),
+  topic: z72.string().optional().describe("Research topic to categorize the paper under"),
+  priority: z72.enum(["P1", "P2", "P3", "P4"]).optional().describe("Priority level for the paper"),
+  dryRun: z72.boolean().optional().default(false).describe("Preview what would be added without persisting")
 });
 async function executeResearchAdd(input, logger57) {
   const exists = await paperExists(input.arxivId);
@@ -39618,10 +39760,10 @@ function createResearchAddHandler(deps) {
 function registerResearchAddTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "research_add" });
   const toolSchema = {
-    arxivId: z71.string().regex(/^\d{4}\.\d{4,5}$/).describe('arXiv paper ID (e.g., "2401.12345")'),
-    topic: z71.string().optional().describe("Research topic to categorize the paper under"),
-    priority: z71.enum(["P1", "P2", "P3", "P4"]).optional().describe("Priority level"),
-    dryRun: z71.boolean().optional().default(false).describe("Preview without persisting")
+    arxivId: z72.string().regex(/^\d{4}\.\d{4,5}$/).describe('arXiv paper ID (e.g., "2401.12345")'),
+    topic: z72.string().optional().describe("Research topic to categorize the paper under"),
+    priority: z72.enum(["P1", "P2", "P3", "P4"]).optional().describe("Priority level"),
+    dryRun: z72.boolean().optional().default(false).describe("Preview without persisting")
   };
   const description = "PAPER-only: add an arXiv preprint to the research registry by arXiv ID. Fetches metadata from arxiv.org and persists to the registry. For non-paper sources (GitHub repos, tools, blogs) use `research_add_source` instead. Use dryRun=true to preview without saving.";
   const secureHandler = createSecureHandler(createResearchAddHandler(deps), {
@@ -39635,11 +39777,11 @@ function registerResearchAddTool(server, deps) {
     logger: logger57
   });
   const outputSchema = {
-    success: z71.boolean(),
-    paperId: z71.string().optional(),
-    title: z71.string().optional(),
-    message: z71.string(),
-    dryRun: z71.boolean().optional()
+    success: z72.boolean(),
+    paperId: z72.string().optional(),
+    title: z72.string().optional(),
+    message: z72.string(),
+    dryRun: z72.boolean().optional()
   };
   server.registerTool(
     "research_add",
@@ -39655,33 +39797,33 @@ function registerResearchAddTool(server, deps) {
 }
 
 // src/mcp/tools/research-add-source.ts
-import { z as z72 } from "zod";
-var SourceTypeEnum = z72.enum([
+import { z as z73 } from "zod";
+var SourceTypeEnum = z73.enum([
   "product_docs",
   "specification",
   "research_blog",
   "code_analysis",
   "open_source_repo"
 ]);
-var VerdictEnum = z72.enum(["adopted", "partially_adopted", "rejected", "monitoring", "planned"]);
-var ResearchAddSourceInputSchema = z72.object({
-  url: z72.string().min(1).max(500).describe("Source URL (GitHub repo, docs page, blog post)"),
-  name: z72.string().min(1).max(200).describe("Display name for the source"),
+var VerdictEnum = z73.enum(["adopted", "partially_adopted", "rejected", "monitoring", "planned"]);
+var ResearchAddSourceInputSchema = z73.object({
+  url: z73.string().min(1).max(500).describe("Source URL (GitHub repo, docs page, blog post)"),
+  name: z73.string().min(1).max(200).describe("Display name for the source"),
   type: SourceTypeEnum.describe("Source type classification"),
-  vendor: z72.string().max(100).optional().describe("Vendor or organization"),
-  topics: z72.array(z72.string().max(50)).max(5).optional().describe("Research topics (max 5)"),
-  tags: z72.array(z72.string().max(50)).max(10).optional().describe("Searchable tags (max 10)"),
-  quality_signals: z72.object({
-    stars_at_review: z72.number().nonnegative().optional(),
-    language: z72.string().max(50).optional(),
-    has_tests: z72.boolean().optional(),
-    has_docs: z72.boolean().optional(),
-    has_paper: z72.boolean().optional()
+  vendor: z73.string().max(100).optional().describe("Vendor or organization"),
+  topics: z73.array(z73.string().max(50)).max(5).optional().describe("Research topics (max 5)"),
+  tags: z73.array(z73.string().max(50)).max(10).optional().describe("Searchable tags (max 10)"),
+  quality_signals: z73.object({
+    stars_at_review: z73.number().nonnegative().optional(),
+    language: z73.string().max(50).optional(),
+    has_tests: z73.boolean().optional(),
+    has_docs: z73.boolean().optional(),
+    has_paper: z73.boolean().optional()
   }).optional().describe("Quality signals used to compute quality_score; provide explicitly \u2014 no GitHub metadata is fetched"),
-  techniques_extracted: z72.array(z72.string().max(100)).max(5).optional().describe("Techniques identified in this source (max 5)"),
+  techniques_extracted: z73.array(z73.string().max(100)).max(5).optional().describe("Techniques identified in this source (max 5)"),
   verdict: VerdictEnum.optional().describe("Adoption verdict"),
-  verdict_notes: z72.string().max(500).optional().describe("Notes explaining the verdict"),
-  dryRun: z72.boolean().optional().default(false).describe("Preview without persisting")
+  verdict_notes: z73.string().max(500).optional().describe("Notes explaining the verdict"),
+  dryRun: z73.boolean().optional().default(false).describe("Preview without persisting")
 });
 function generateSourceId(url) {
   const match = /github\.com\/([^/]+)\/([^/]+)/.exec(url);
@@ -39821,23 +39963,23 @@ function createResearchAddSourceHandler(deps) {
 function registerResearchAddSourceTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "research_add_source" });
   const toolSchema = {
-    url: z72.string().min(1).describe("Source URL"),
-    name: z72.string().min(1).describe("Display name"),
+    url: z73.string().min(1).describe("Source URL"),
+    name: z73.string().min(1).describe("Display name"),
     type: SourceTypeEnum.describe("Source type"),
-    vendor: z72.string().optional().describe("Vendor"),
-    topics: z72.array(z72.string()).max(5).optional().describe("Topics"),
-    tags: z72.array(z72.string()).max(10).optional().describe("Tags"),
-    quality_signals: z72.object({
-      stars_at_review: z72.number().optional(),
-      language: z72.string().optional(),
-      has_tests: z72.boolean().optional(),
-      has_docs: z72.boolean().optional(),
-      has_paper: z72.boolean().optional()
+    vendor: z73.string().optional().describe("Vendor"),
+    topics: z73.array(z73.string()).max(5).optional().describe("Topics"),
+    tags: z73.array(z73.string()).max(10).optional().describe("Tags"),
+    quality_signals: z73.object({
+      stars_at_review: z73.number().optional(),
+      language: z73.string().optional(),
+      has_tests: z73.boolean().optional(),
+      has_docs: z73.boolean().optional(),
+      has_paper: z73.boolean().optional()
     }).optional().describe("Quality signals"),
-    techniques_extracted: z72.array(z72.string()).max(5).optional().describe("Techniques"),
+    techniques_extracted: z73.array(z73.string()).max(5).optional().describe("Techniques"),
     verdict: VerdictEnum.optional().describe("Adoption verdict"),
-    verdict_notes: z72.string().max(500).optional().describe("Verdict notes"),
-    dryRun: z72.boolean().optional().default(false).describe("Preview only")
+    verdict_notes: z73.string().max(500).optional().describe("Verdict notes"),
+    dryRun: z73.boolean().optional().default(false).describe("Preview only")
   };
   const description = "NON-PAPER source: add a GitHub repo / tool / blog URL to the research registry. Auto-computes quality_score from provided quality_signals. For arXiv papers use `research_add` instead. Use dryRun=true to preview without saving.";
   const secureHandler = createSecureHandler(createResearchAddSourceHandler(deps), {
@@ -39863,22 +40005,22 @@ function registerResearchAddSourceTool(server, deps) {
   );
 }
 var RESEARCH_ADD_SOURCE_OUTPUT_SCHEMA = {
-  success: z72.boolean(),
-  sourceId: z72.string().optional(),
-  name: z72.string().optional(),
-  quality_score: z72.number().optional(),
-  evidence_tier: z72.string().optional(),
-  message: z72.string().optional(),
-  dryRun: z72.boolean().optional()
+  success: z73.boolean(),
+  sourceId: z73.string().optional(),
+  name: z73.string().optional(),
+  quality_score: z73.number().optional(),
+  evidence_tier: z73.string().optional(),
+  message: z73.string().optional(),
+  dryRun: z73.boolean().optional()
 };
 
 // src/mcp/tools/research-discover.ts
-import { z as z73 } from "zod";
+import { z as z74 } from "zod";
 var MAX_RESULTS_PER_SOURCE = 20;
 var DEFAULT_RELEVANCE_THRESHOLD = 0.3;
-var ResearchDiscoverInputSchema = z73.object({
-  topic: z73.string().min(1).max(200).describe('Research topic to search for (e.g., "multi-agent orchestration")'),
-  source: z73.enum([
+var ResearchDiscoverInputSchema = z74.object({
+  topic: z74.string().min(1).max(200).describe('Research topic to search for (e.g., "multi-agent orchestration")'),
+  source: z74.enum([
     "arxiv",
     "github",
     "google_ai",
@@ -39892,9 +40034,9 @@ var ResearchDiscoverInputSchema = z73.object({
   ]).optional().default("all").describe(
     "Source to search: arxiv, github, google_ai, meta_fair, microsoft, deepmind, semantic_scholar, papers_with_code, openalex, or all"
   ),
-  maxResults: z73.number().min(1).max(MAX_RESULTS_PER_SOURCE).optional().default(10).describe("Maximum results to return"),
-  sinceDate: z73.string().optional().describe("Only return results after this date (YYYY-MM-DD format)"),
-  relevanceThreshold: z73.number().min(0).max(1).optional().default(DEFAULT_RELEVANCE_THRESHOLD).describe(
+  maxResults: z74.number().min(1).max(MAX_RESULTS_PER_SOURCE).optional().default(10).describe("Maximum results to return"),
+  sinceDate: z74.string().optional().describe("Only return results after this date (YYYY-MM-DD format)"),
+  relevanceThreshold: z74.number().min(0).max(1).optional().default(DEFAULT_RELEVANCE_THRESHOLD).describe(
     "Minimum relevance score (0-1) to include in results. Higher values filter more aggressively."
   )
 });
@@ -40169,8 +40311,8 @@ function createResearchDiscoverHandler(deps) {
 function registerResearchDiscoverTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "research_discover" });
   const toolSchema = {
-    topic: z73.string().min(1).max(200).describe("Research topic to search for"),
-    source: z73.enum([
+    topic: z74.string().min(1).max(200).describe("Research topic to search for"),
+    source: z74.enum([
       "arxiv",
       "github",
       "google_ai",
@@ -40182,9 +40324,9 @@ function registerResearchDiscoverTool(server, deps) {
       "openalex",
       "all"
     ]).optional().describe("Source to search"),
-    maxResults: z73.number().min(1).max(MAX_RESULTS_PER_SOURCE).optional().describe("Max results"),
-    sinceDate: z73.string().optional().describe("Only results after this date (YYYY-MM-DD)"),
-    relevanceThreshold: z73.number().min(0).max(1).optional().describe("Minimum relevance score (0-1) to include results. Higher = stricter filtering.")
+    maxResults: z74.number().min(1).max(MAX_RESULTS_PER_SOURCE).optional().describe("Max results"),
+    sinceDate: z74.string().optional().describe("Only results after this date (YYYY-MM-DD)"),
+    relevanceThreshold: z74.number().min(0).max(1).optional().describe("Minimum relevance score (0-1) to include results. Higher = stricter filtering.")
   };
   const description = "Discover new research papers and repositories from external sources. Searches arXiv, GitHub, and other sources. Filters out items already in the registry.";
   const secureHandler = createSecureHandler(createResearchDiscoverHandler(deps), {
@@ -40210,24 +40352,24 @@ function registerResearchDiscoverTool(server, deps) {
   logger57.info("Registered research_discover tool with secure handler and timeout protection");
 }
 var RESEARCH_DISCOVER_OUTPUT_SCHEMA = {
-  topic: z73.string().optional(),
-  sourcesQueried: z73.array(z73.string()).optional(),
-  failedSources: z73.array(z73.string()).optional(),
-  items: z73.array(z73.unknown()).optional(),
-  totalFound: z73.number().optional(),
-  alreadyInRegistry: z73.number().optional(),
-  registryConsulted: z73.boolean().optional(),
-  newItems: z73.number().optional(),
-  filteredByRelevance: z73.number().optional()
+  topic: z74.string().optional(),
+  sourcesQueried: z74.array(z74.string()).optional(),
+  failedSources: z74.array(z74.string()).optional(),
+  items: z74.array(z74.unknown()).optional(),
+  totalFound: z74.number().optional(),
+  alreadyInRegistry: z74.number().optional(),
+  registryConsulted: z74.boolean().optional(),
+  newItems: z74.number().optional(),
+  filteredByRelevance: z74.number().optional()
 };
 
 // src/mcp/tools/research-analyze.ts
-import { z as z74 } from "zod";
-var ResearchAnalyzeInputSchema = z74.object({
-  focus: z74.enum(["gaps", "trends", "priorities", "stale", "coverage"]).describe(
+import { z as z75 } from "zod";
+var ResearchAnalyzeInputSchema = z75.object({
+  focus: z75.enum(["gaps", "trends", "priorities", "stale", "coverage"]).describe(
     "Analysis focus: gaps (missing coverage), trends (topic distribution), priorities (P1/P2 backlog), stale (outdated entries), coverage (implementation status)"
   ),
-  topic: z74.string().optional().describe("Optional topic filter to narrow analysis")
+  topic: z75.string().optional().describe("Optional topic filter to narrow analysis")
 });
 function failureResponse(focus, registry = "techniques") {
   return {
@@ -40473,8 +40615,8 @@ function createResearchAnalyzeHandler(deps) {
 function registerResearchAnalyzeTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "research_analyze" });
   const toolSchema = {
-    focus: z74.enum(["gaps", "trends", "priorities", "stale", "coverage"]).describe("Analysis focus area"),
-    topic: z74.string().optional().describe("Optional topic filter")
+    focus: z75.enum(["gaps", "trends", "priorities", "stale", "coverage"]).describe("Analysis focus area"),
+    topic: z75.string().optional().describe("Optional topic filter")
   };
   const description = "Analyze the research registry for gaps, trends, priorities, stale entries, or coverage. Returns structured analysis with recommendations.";
   const secureHandler = createSecureHandler(createResearchAnalyzeHandler(deps), {
@@ -40488,10 +40630,10 @@ function registerResearchAnalyzeTool(server, deps) {
     logger: logger57
   });
   const outputSchema = {
-    focus: z74.string().optional(),
-    success: z74.boolean().optional(),
-    analysis: z74.unknown().optional(),
-    recommendations: z74.array(z74.string()).optional()
+    focus: z75.string().optional(),
+    success: z75.boolean().optional(),
+    analysis: z75.unknown().optional(),
+    recommendations: z75.array(z75.string()).optional()
   };
   server.registerTool(
     "research_analyze",
@@ -40507,14 +40649,14 @@ function registerResearchAnalyzeTool(server, deps) {
 }
 
 // src/mcp/tools/research-catalog-review.ts
-import { z as z75 } from "zod";
-var ResearchCatalogReviewInputSchema = z75.object({
-  action: z75.enum(["list", "approve", "dismiss", "flush"]).describe(
+import { z as z76 } from "zod";
+var ResearchCatalogReviewInputSchema = z76.object({
+  action: z76.enum(["list", "approve", "dismiss", "flush"]).describe(
     "Action: list (show pending), approve (add to registry), dismiss (remove), flush (clear all)"
   ),
-  identifier: z75.string().optional().describe("Reference identifier for approve/dismiss actions (arXiv ID or GitHub URL)"),
-  topic: z75.string().optional().describe("Topic to assign when approving an arXiv paper"),
-  createIssue: z75.boolean().optional().default(false).describe("When approving, also create a GitHub issue for the paper")
+  identifier: z76.string().optional().describe("Reference identifier for approve/dismiss actions (arXiv ID or GitHub URL)"),
+  topic: z76.string().optional().describe("Topic to assign when approving an arXiv paper"),
+  createIssue: z76.boolean().optional().default(false).describe("When approving, also create a GitHub issue for the paper")
 });
 function handleList() {
   const catalog = getAutoCatalog();
@@ -40646,10 +40788,10 @@ function createCatalogReviewHandler(deps) {
 function registerResearchCatalogReviewTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "research_catalog_review" });
   const toolSchema = {
-    action: z75.enum(["list", "approve", "dismiss", "flush"]).describe("Action to perform on cataloged references"),
-    identifier: z75.string().optional().describe("Reference identifier for approve/dismiss"),
-    topic: z75.string().optional().describe("Topic for approved papers"),
-    createIssue: z75.boolean().optional().describe("Create GitHub issue when approving")
+    action: z76.enum(["list", "approve", "dismiss", "flush"]).describe("Action to perform on cataloged references"),
+    identifier: z76.string().optional().describe("Reference identifier for approve/dismiss"),
+    topic: z76.string().optional().describe("Topic for approved papers"),
+    createIssue: z76.boolean().optional().describe("Create GitHub issue when approving")
   };
   const description = "Review auto-cataloged research references found during tool execution. List pending references, approve them for registry addition (optionally filing a GitHub issue), dismiss, or clear all.";
   const secureHandler = createSecureHandler(createCatalogReviewHandler(deps), {
@@ -40663,10 +40805,10 @@ function registerResearchCatalogReviewTool(server, deps) {
     logger: logger57
   });
   const outputSchema = {
-    action: z75.string().optional(),
-    success: z75.boolean().optional(),
-    message: z75.string().optional(),
-    data: z75.unknown().optional()
+    action: z76.string().optional(),
+    success: z76.boolean().optional(),
+    message: z76.string().optional(),
+    data: z76.unknown().optional()
   };
   server.registerTool(
     "research_catalog_review",
@@ -40682,9 +40824,9 @@ function registerResearchCatalogReviewTool(server, deps) {
 }
 
 // src/mcp/tools/research-synthesize.ts
-import { z as z76 } from "zod";
-var ResearchSynthesizeInputSchema = z76.object({
-  topic: z76.string().optional().describe("Optional topic to filter synthesis to a single cluster")
+import { z as z77 } from "zod";
+var ResearchSynthesizeInputSchema = z77.object({
+  topic: z77.string().optional().describe("Optional topic to filter synthesis to a single cluster")
 });
 function createResearchSynthesizeHandler(deps) {
   return async (args, _ctx) => {
@@ -40711,7 +40853,7 @@ function createResearchSynthesizeHandler(deps) {
 function registerResearchSynthesizeTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "research_synthesize" });
   const toolSchema = {
-    topic: z76.string().optional().describe("Optional topic filter for single-cluster synthesis")
+    topic: z77.string().optional().describe("Optional topic filter for single-cluster synthesis")
   };
   const description = "Synthesize the research registry by grouping papers into topic clusters. Returns structured summaries with common themes, key insights, techniques, implementation opportunities, and cross-cutting themes across clusters.";
   const secureHandler = createSecureHandler(createResearchSynthesizeHandler(deps), {
@@ -40725,12 +40867,12 @@ function registerResearchSynthesizeTool(server, deps) {
     logger: logger57
   });
   const outputSchema = {
-    clusters: z76.array(z76.unknown()).optional(),
-    totalPapers: z76.number().optional(),
-    topicCount: z76.number().optional(),
-    crossCuttingThemes: z76.array(z76.unknown()).optional(),
-    alignmentSummary: z76.unknown().optional(),
-    featureGates: z76.array(z76.unknown()).optional()
+    clusters: z77.array(z77.unknown()).optional(),
+    totalPapers: z77.number().optional(),
+    topicCount: z77.number().optional(),
+    crossCuttingThemes: z77.array(z77.unknown()).optional(),
+    alignmentSummary: z77.unknown().optional(),
+    featureGates: z77.array(z77.unknown()).optional()
   };
   server.registerTool(
     "research_synthesize",
@@ -40746,10 +40888,10 @@ function registerResearchSynthesizeTool(server, deps) {
 }
 
 // src/mcp/tools/issue-triage-tool.ts
-import { z as z77 } from "zod";
-var IssueTriageInputSchema = z77.object({
-  issueUrl: z77.string().min(1).refine((v) => /^https?:\/\//i.test(v), "Only HTTP/HTTPS URLs are allowed").describe("GitHub issue URL (e.g., https://github.com/owner/repo/issues/123)"),
-  dryRun: z77.boolean().optional().default(true).describe("Read-only mode (default: true). When false, may apply labels.")
+import { z as z78 } from "zod";
+var IssueTriageInputSchema = z78.object({
+  issueUrl: z78.string().min(1).refine((v) => /^https?:\/\//i.test(v), "Only HTTP/HTTPS URLs are allowed").describe("GitHub issue URL (e.g., https://github.com/owner/repo/issues/123)"),
+  dryRun: z78.boolean().optional().default(true).describe("Read-only mode (default: true). When false, may apply labels.")
 });
 function buildTriageResponse(value) {
   return {
@@ -40804,8 +40946,8 @@ function createIssueTriageHandler(_deps) {
 function registerIssueTriageTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "issue_triage" });
   const toolSchema = {
-    issueUrl: z77.string().min(1).describe("GitHub issue URL (e.g., https://github.com/owner/repo/issues/123)"),
-    dryRun: z77.boolean().optional().default(true).describe("Read-only mode (default: true)")
+    issueUrl: z78.string().min(1).describe("GitHub issue URL (e.g., https://github.com/owner/repo/issues/123)"),
+    dryRun: z78.boolean().optional().default(true).describe("Read-only mode (default: true)")
   };
   const description = "Triage a GitHub issue using the full security pipeline. Classifies the issue, assesses author trust and reputation, proposes labels and actions, and validates all outputs through policy gate and corroboration checks. Read-only by default. Requires GITHUB_TOKEN or GH_TOKEN environment variable, or gh CLI auth.";
   const secureHandler = createSecureHandler(createIssueTriageHandler(deps), {
@@ -40884,7 +41026,7 @@ function recordTriageOutcome(success, durationMs, errorMsg) {
 }
 
 // src/mcp/tools/run-graph-workflow.ts
-import { z as z78 } from "zod";
+import { z as z79 } from "zod";
 import { randomUUID as randomUUID11 } from "node:crypto";
 
 // src/mcp/tools/run-graph-workflow-events.ts
@@ -40936,11 +41078,11 @@ function formatDetail(event) {
 }
 
 // src/mcp/tools/run-graph-workflow.ts
-var RunGraphWorkflowInputSchema = z78.object({
-  workflow: z78.string().min(1).max(100).describe("Name of the predefined graph workflow to execute"),
-  inputs: z78.record(z78.string(), z78.unknown()).optional().default({}).describe("Input values for the workflow"),
-  enableCheckpointing: z78.boolean().optional().default(true).describe("Enable checkpoint saving between steps"),
-  enableAuditTrail: z78.boolean().optional().default(false).describe("Enable audit trail event logging"),
+var RunGraphWorkflowInputSchema = z79.object({
+  workflow: z79.string().min(1).max(100).describe("Name of the predefined graph workflow to execute"),
+  inputs: z79.record(z79.string(), z79.unknown()).optional().default({}).describe("Input values for the workflow"),
+  enableCheckpointing: z79.boolean().optional().default(true).describe("Enable checkpoint saving between steps"),
+  enableAuditTrail: z79.boolean().optional().default(false).describe("Enable audit trail event logging"),
   /**
    * Dispatch mode (#3732). `sync` (default) runs the graph workflow inline and
    * returns the result — but a workflow of up to ~100 expert nodes can exceed
@@ -41038,12 +41180,12 @@ async function handleRunGraphWorkflow(input, logger57, auditLogger, signal) {
 }
 var GRAPH_WORKFLOW_DESCRIPTION = "Run a DAG-shaped workflow with per-node checkpoints, event streaming, and an audit trail. Checkpoints drive the executor in-process recovery (crash-resume + selective node retry) and inspection \u2014 the MCP call is fire-and-forget with NO caller resume input, and the checkpoint store is in-memory (not durable across process restarts). For straight linear templates, use `run_workflow` instead. Supports dispatch: 'async' \u2014 returns a jobId immediately; poll get_job_result.";
 var GRAPH_WORKFLOW_SCHEMA = {
-  workflow: z78.string().min(1).max(100).describe(
+  workflow: z79.string().min(1).max(100).describe(
     'Workflow name: echo, pipeline, code-review, security-scan. Use "list" for available workflows.'
   ),
-  inputs: z78.record(z78.string(), z78.unknown()).optional().describe("Input values for the workflow"),
-  enableCheckpointing: z78.boolean().optional().describe("Enable checkpoint saving"),
-  enableAuditTrail: z78.boolean().optional().describe("Enable audit trail logging"),
+  inputs: z79.record(z79.string(), z79.unknown()).optional().describe("Input values for the workflow"),
+  enableCheckpointing: z79.boolean().optional().describe("Enable checkpoint saving"),
+  enableAuditTrail: z79.boolean().optional().describe("Enable audit trail logging"),
   // #4968: the same fragment the internal schema composes — the advertised
   // shape is what the SDK parses, so the wrong-key trap must be here too.
   ...asyncDispatchInput("Ignored for the `list` sentinel.")
@@ -41651,11 +41793,11 @@ function suggestImprovement(criterion) {
 }
 
 // src/mcp/tools/execute-spec-tool.ts
-import { z as z79 } from "zod";
+import { z as z80 } from "zod";
 import { randomUUID as randomUUID12 } from "node:crypto";
-var ExecuteSpecInputSchema = z79.object({
-  spec: z79.string().min(1).max(5e4).describe("Markdown specification to execute"),
-  dryRun: z79.boolean().optional().default(false).describe("Parse and decompose only"),
+var ExecuteSpecInputSchema = z80.object({
+  spec: z80.string().min(1).max(5e4).describe("Markdown specification to execute"),
+  dryRun: z80.boolean().optional().default(false).describe("Parse and decompose only"),
   /**
    * Dispatch mode (#3732). `sync` (default) runs the full DAG pipeline inline
    * and returns the result — but a real parse→decompose→compile→execute→
@@ -41767,10 +41909,10 @@ function registerExecuteSpecTool(server, deps) {
   const timeoutMs = getToolTimeout("execute_spec", deps.security);
   const wrapped = wrapToolWithTimeout("execute_spec", secureHandler, { timeoutMs, logger: logger57 });
   const toolSchema = {
-    spec: z79.string().min(1).max(5e4).describe(
+    spec: z80.string().min(1).max(5e4).describe(
       'Markdown specification to execute. Must contain "## Requirements" and "## Acceptance Criteria" sections.'
     ),
-    dryRun: z79.boolean().optional().describe("Parse and decompose only (no execution)"),
+    dryRun: z80.boolean().optional().describe("Parse and decompose only (no execution)"),
     // #4968: the same fragment the internal schema composes — the advertised
     // shape is what the SDK parses, so the wrong-key trap must be here too.
     ...asyncDispatchInput("Ignored for dryRun.")
@@ -41841,11 +41983,11 @@ function recordSpecOutcome(success, durationMs, stage) {
 }
 
 // src/mcp/tools/memory-query.ts
-import { z as z80 } from "zod";
-var MemoryQueryInputSchema = z80.object({
-  query: z80.string().min(1).max(500).describe("Search query to match against memory contents"),
-  limit: z80.number().int().min(1).max(50).optional().default(10).describe("Maximum results to return (default: 10, max: 50)"),
-  source: z80.enum(["session", "belief", "agentic", "typed", "adaptive", "all"]).optional().default("all").describe("Filter by memory source (default: all)")
+import { z as z81 } from "zod";
+var MemoryQueryInputSchema = z81.object({
+  query: z81.string().min(1).max(500).describe("Search query to match against memory contents"),
+  limit: z81.number().int().min(1).max(50).optional().default(10).describe("Maximum results to return (default: 10, max: 50)"),
+  source: z81.enum(["session", "belief", "agentic", "typed", "adaptive", "all"]).optional().default("all").describe("Filter by memory source (default: all)")
 });
 function describeBackendCoverage(memory, source) {
   const optional = [
@@ -41952,9 +42094,9 @@ async function memoryQueryHandler(args, ctx) {
 function registerMemoryQueryTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "memory_query" });
   const toolSchema = {
-    query: z80.string().min(1).max(500).describe("Search query to match against memory contents"),
-    limit: z80.number().int().min(1).max(50).optional().describe("Maximum results to return (default: 10, max: 50)"),
-    source: z80.enum(["session", "belief", "agentic", "typed", "adaptive", "all"]).optional().describe("Filter by memory source (default: all)")
+    query: z81.string().min(1).max(500).describe("Search query to match against memory contents"),
+    limit: z81.number().int().min(1).max(50).optional().describe("Maximum results to return (default: 10, max: 50)"),
+    source: z81.enum(["session", "belief", "agentic", "typed", "adaptive", "all"]).optional().describe("Filter by memory source (default: all)")
   };
   const description = "Query across all memory backends (session, belief, agentic, adaptive, typed) with unified results. Returns memories matching the query with source attribution and relevance scores.";
   const secureHandler = createSecureHandler(memoryQueryHandler, {
@@ -41965,19 +42107,19 @@ function registerMemoryQueryTool(server, deps) {
   const timeoutMs = getToolTimeout("memory_query", deps.security);
   const wrappedHandler = wrapToolWithTimeout("memory_query", secureHandler, { timeoutMs, logger: logger57 });
   const outputSchema = {
-    query: z80.string(),
-    expandedQuery: z80.string().optional(),
-    results: z80.array(z80.unknown()),
-    count: z80.number(),
-    source: z80.string(),
+    query: z81.string(),
+    expandedQuery: z81.string().optional(),
+    results: z81.array(z81.unknown()),
+    count: z81.number(),
+    source: z81.string(),
     // #4999: the SDK validates structured content against this schema with
     // `additionalProperties: false`, so a field added to the response and not
     // declared here makes EVERY call fail with -32602 rather than merely going
     // unreported. The integration test caught that; the unit tests could not,
     // because they call the handler directly and never cross the protocol.
-    searched: z80.array(z80.string()),
-    unavailable: z80.array(z80.string()),
-    errored: z80.array(z80.string())
+    searched: z81.array(z81.string()),
+    unavailable: z81.array(z81.string()),
+    errored: z81.array(z81.string())
   };
   server.registerTool(
     "memory_query",
@@ -41993,9 +42135,9 @@ function registerMemoryQueryTool(server, deps) {
 }
 
 // src/mcp/tools/memory-stats.ts
-import { z as z81 } from "zod";
-var MemoryStatsInputSchema = z81.object({
-  includeDecay: z81.boolean().optional().default(true).describe("Include decay statistics (default: true)")
+import { z as z82 } from "zod";
+var MemoryStatsInputSchema = z82.object({
+  includeDecay: z82.boolean().optional().default(true).describe("Include decay statistics (default: true)")
 });
 function collectSessionStats(toolMemory) {
   const counts = toolMemory.getSessionCounts();
@@ -42112,7 +42254,7 @@ async function memoryStatsHandler(args, ctx) {
 function registerMemoryStatsTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "memory_stats" });
   const toolSchema = {
-    includeDecay: z81.boolean().optional().describe("Include decay statistics (default: true)")
+    includeDecay: z82.boolean().optional().describe("Include decay statistics (default: true)")
   };
   const description = "Get memory system statistics dashboard. Shows backend availability, entry counts, and decay stats across all 7 memory backends.";
   const secureHandler = createSecureHandler(memoryStatsHandler, {
@@ -42123,14 +42265,14 @@ function registerMemoryStatsTool(server, deps) {
   const timeoutMs = getToolTimeout("memory_stats", deps.security);
   const wrappedHandler = wrapToolWithTimeout("memory_stats", secureHandler, { timeoutMs, logger: logger57 });
   const outputSchema = {
-    backends: z81.unknown(),
-    session: z81.unknown().optional(),
-    belief: z81.unknown().optional(),
-    typed: z81.unknown().optional(),
-    mobimem: z81.unknown().optional(),
-    decay: z81.unknown().optional(),
-    registry: z81.array(z81.unknown()).optional(),
-    collectedAt: z81.string().optional()
+    backends: z82.unknown(),
+    session: z82.unknown().optional(),
+    belief: z82.unknown().optional(),
+    typed: z82.unknown().optional(),
+    mobimem: z82.unknown().optional(),
+    decay: z82.unknown().optional(),
+    registry: z82.array(z82.unknown()).optional(),
+    collectedAt: z82.string().optional()
   };
   server.registerTool(
     "memory_stats",
@@ -42146,15 +42288,15 @@ function registerMemoryStatsTool(server, deps) {
 }
 
 // src/mcp/tools/memory-write.ts
-import { z as z82 } from "zod";
-var MemoryWriteInputSchema = z82.object({
-  key: z82.string().min(1).max(200).describe("Memory identifier or subject"),
-  content: z82.string().min(1).max(5e3).describe("Memory content to store"),
-  backend: z82.enum(["session", "belief", "agentic", "adaptive", "typed"]).describe(
+import { z as z83 } from "zod";
+var MemoryWriteInputSchema = z83.object({
+  key: z83.string().min(1).max(200).describe("Memory identifier or subject"),
+  content: z83.string().min(1).max(5e3).describe("Memory content to store"),
+  backend: z83.enum(["session", "belief", "agentic", "adaptive", "typed"]).describe(
     "Target memory backend: session (learnings), belief (triples), agentic (knowledge), adaptive (priority-scored), typed (MIRIX-style semantic)"
   ),
-  confidence: z82.enum(["high", "medium", "low"]).optional().default("medium").describe("Confidence level (default: medium)"),
-  metadata: z82.record(z82.string().max(100), z82.string().max(500)).optional().describe("Optional key-value metadata tags")
+  confidence: z83.enum(["high", "medium", "low"]).optional().default("medium").describe("Confidence level (default: medium)"),
+  metadata: z83.record(z83.string().max(100), z83.string().max(500)).optional().describe("Optional key-value metadata tags")
 });
 function writeToSession(key, content, confidence) {
   const toolMemory = getToolMemory();
@@ -42307,13 +42449,13 @@ async function memoryWriteHandler(args, ctx) {
 function registerMemoryWriteTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "memory_write" });
   const toolSchema = {
-    key: z82.string().min(1).max(200).describe("Memory identifier or subject"),
-    content: z82.string().min(1).max(5e3).describe("Memory content to store"),
-    backend: z82.enum(["session", "belief", "agentic", "adaptive", "typed"]).describe(
+    key: z83.string().min(1).max(200).describe("Memory identifier or subject"),
+    content: z83.string().min(1).max(5e3).describe("Memory content to store"),
+    backend: z83.enum(["session", "belief", "agentic", "adaptive", "typed"]).describe(
       "Target memory backend: session (learnings), belief (triples), agentic (knowledge), adaptive (priority-scored), typed (MIRIX-style semantic)"
     ),
-    confidence: z82.enum(["high", "medium", "low"]).optional().describe("Confidence level (default: medium)"),
-    metadata: z82.record(z82.string().max(100), z82.string().max(500)).optional().describe("Optional key-value metadata tags")
+    confidence: z83.enum(["high", "medium", "low"]).optional().describe("Confidence level (default: medium)"),
+    metadata: z83.record(z83.string().max(100), z83.string().max(500)).optional().describe("Optional key-value metadata tags")
   };
   const description = "Write a memory entry to a specific backend. Supports session (learnings), belief assertions (subject + object; predicate fixed as `has_knowledge`), agentic (knowledge with attributes), adaptive (priority-scored), and typed (MIRIX-style semantic) backends.";
   const secureHandler = createSecureHandler(memoryWriteHandler, {
@@ -42325,11 +42467,11 @@ function registerMemoryWriteTool(server, deps) {
   const timeoutMs = getToolTimeout("memory_write", deps.security);
   const wrappedHandler = wrapToolWithTimeout("memory_write", guardedHandler, { timeoutMs, logger: logger57 });
   const outputSchema = {
-    success: z82.boolean(),
-    backend: z82.string(),
-    key: z82.string(),
-    deduplicated: z82.boolean().optional(),
-    error: z82.string().optional()
+    success: z83.boolean(),
+    backend: z83.string(),
+    key: z83.string(),
+    deduplicated: z83.boolean().optional(),
+    error: z83.string().optional()
   };
   server.registerTool(
     "memory_write",
@@ -42345,7 +42487,7 @@ function registerMemoryWriteTool(server, deps) {
 }
 
 // src/mcp/tools/weather-report-tool.ts
-import { z as z83 } from "zod";
+import { z as z84 } from "zod";
 function serializeReport(report) {
   return {
     ...report,
@@ -42396,8 +42538,8 @@ function weatherReportHandler(args, ctx) {
 function registerWeatherReportTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "weather_report" });
   const toolSchema = {
-    cli: z83.enum(["claude", "gemini", "codex", "opencode"]).optional().describe("Filter by CLI"),
-    category: z83.enum([
+    cli: z84.enum(["claude", "gemini", "codex", "opencode"]).optional().describe("Filter by CLI"),
+    category: z84.enum([
       "architecture",
       "code_generation",
       "code_review",
@@ -42409,7 +42551,7 @@ function registerWeatherReportTool(server, deps) {
       "devops",
       "exploration"
     ]).optional().describe("Filter by task category"),
-    includeAdaptive: z83.boolean().optional().describe("Include adaptive routing bonuses (default: true)")
+    includeAdaptive: z84.boolean().optional().describe("Include adaptive routing bonuses (default: true)")
   };
   const description = "Get multi-CLI performance weather report. Shows per-CLI success rates, per-category breakdowns, and adaptive routing bonus recommendations based on observed task outcomes.";
   const secureHandler = createSecureHandler(weatherReportHandler, {
@@ -42431,18 +42573,18 @@ function registerWeatherReportTool(server, deps) {
 }
 
 // src/mcp/tools/registry-import-types.ts
-import { z as z84 } from "zod";
-var RegistryImportInputSchema = z84.object({
+import { z as z85 } from "zod";
+var RegistryImportInputSchema = z85.object({
   /** Model provider. */
-  provider: z84.enum(["anthropic", "google", "openai"]).describe("Model provider (anthropic, google, openai)"),
+  provider: z85.enum(["anthropic", "google", "openai"]).describe("Model provider (anthropic, google, openai)"),
   /** Model identifier from the provider (e.g., "claude-4-opus-20260201"). */
-  modelId: z84.string().min(1).describe("Provider model identifier"),
+  modelId: z85.string().min(1).describe("Provider model identifier"),
   /** No-op flag echoed back in the response; the tool never persists regardless. */
-  dryRun: z84.boolean().optional().default(true).describe("No-op flag echoed back in the response; the tool never persists regardless")
+  dryRun: z85.boolean().optional().default(true).describe("No-op flag echoed back in the response; the tool never persists regardless")
 });
 
 // src/mcp/tools/registry-import-tool.ts
-import { z as z85 } from "zod";
+import { z as z86 } from "zod";
 
 // src/mcp/tools/registry-import.ts
 var PROVIDER_CLI_MAP = {
@@ -42552,9 +42694,9 @@ function registryImportHandler(args, ctx) {
 function registerRegistryImportTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "registry_import" });
   const toolSchema = {
-    provider: z85.enum(["anthropic", "google", "openai"]).describe("Model provider (anthropic, google, openai)"),
-    modelId: z85.string().min(1).describe("Provider model identifier"),
-    dryRun: z85.boolean().optional().describe("No-op flag echoed back in the response; the tool never persists regardless")
+    provider: z86.enum(["anthropic", "google", "openai"]).describe("Model provider (anthropic, google, openai)"),
+    modelId: z86.string().min(1).describe("Provider model identifier"),
+    dryRun: z86.boolean().optional().describe("No-op flag echoed back in the response; the tool never persists regardless")
   };
   const description = "Draft a registry ENTRY for a NEW model so routing can consider it later. Generates a ModelCapability YAML with conservative quality scores (5/10) for human review. Always returns a draft entry for human review (never persists). For picking among ALREADY-registered models, use `delegate_to_model`.";
   const secureHandler = createSecureHandler(registryImportHandler, {
@@ -42577,10 +42719,10 @@ function registerRegistryImportTool(server, deps) {
 }
 
 // src/mcp/tools/repo-analyze-types.ts
-import { z as z86 } from "zod";
-var RepoAnalyzeInputSchema = z86.object({
+import { z as z87 } from "zod";
+var RepoAnalyzeInputSchema = z87.object({
   /** GitHub repository in "owner/name" format or full URL. */
-  repo: z86.string().min(1).refine(
+  repo: z87.string().min(1).refine(
     (v) => !v.includes("://") || /^https?:\/\//i.test(v),
     "Only HTTP/HTTPS URLs are allowed"
   ).describe('GitHub repository in "owner/name" format (e.g., "cloudfoundry/korifi") or full URL'),
@@ -42589,13 +42731,13 @@ var RepoAnalyzeInputSchema = z86.object({
    * analysis. Both values resolve to identical behavior; retained for input-shape
    * stability until a distinct shallow path is implemented.
    */
-  depth: z86.enum(["shallow", "deep"]).optional().default("shallow").describe(
+  depth: z87.enum(["shallow", "deep"]).optional().default("shallow").describe(
     "Currently a no-op \u2014 the handler always runs the full analysis (both values identical)"
   )
 });
 
 // src/mcp/tools/repo-analyze-tool.ts
-import { z as z87 } from "zod";
+import { z as z88 } from "zod";
 async function repoAnalyzeHandler(args, ctx) {
   const parsed = RepoAnalyzeInputSchema.safeParse(args);
   if (!parsed.success) {
@@ -42614,8 +42756,8 @@ async function repoAnalyzeHandler(args, ctx) {
 function registerRepoAnalyzeTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "repo_analyze" });
   const toolSchema = {
-    repo: z87.string().min(1).describe('GitHub repository in "owner/name" format or full URL'),
-    depth: z87.enum(["shallow", "deep"]).optional().describe("Currently a no-op \u2014 the handler always runs the full analysis (both values identical)")
+    repo: z88.string().min(1).describe('GitHub repository in "owner/name" format or full URL'),
+    depth: z88.enum(["shallow", "deep"]).optional().describe("Currently a no-op \u2014 the handler always runs the full analysis (both values identical)")
   };
   const description = "Analyze a GitHub repository structure. Returns language, framework, package manager, CI provider, security tooling, Dockerfile/Helm/Makefile detection, and gap identification. Replaces multi-step manual inspection with a single structured query.";
   const secureHandler = createSecureHandler(repoAnalyzeHandler, {
@@ -42637,18 +42779,18 @@ function registerRepoAnalyzeTool(server, deps) {
 }
 
 // src/mcp/tools/repo-security-plan-types.ts
-import { z as z88 } from "zod";
-var RepoSecurityPlanInputSchema = z88.object({
+import { z as z89 } from "zod";
+var RepoSecurityPlanInputSchema = z89.object({
   /** GitHub repository in "owner/name" format or full URL. */
-  repo: z88.string().min(1).describe('GitHub repository in "owner/name" format or full URL'),
+  repo: z89.string().min(1).describe('GitHub repository in "owner/name" format or full URL'),
   /** Filter to specific scanner categories. */
-  categories: z88.array(z88.string()).optional().describe('Filter to specific categories (e.g., ["sast", "sca", "secrets"])'),
+  categories: z89.array(z89.string()).optional().describe('Filter to specific categories (e.g., ["sast", "sca", "secrets"])'),
   /** Maximum number of scanners to recommend. */
-  maxScanners: z88.number().min(1).max(20).optional().default(10).describe("Maximum scanners to recommend (default: 10)")
+  maxScanners: z89.number().min(1).max(20).optional().default(10).describe("Maximum scanners to recommend (default: 10)")
 });
 
 // src/mcp/tools/repo-security-plan-tool.ts
-import { z as z89 } from "zod";
+import { z as z90 } from "zod";
 async function handler(args, ctx) {
   const parsed = RepoSecurityPlanInputSchema.safeParse(args);
   if (!parsed.success) {
@@ -42667,9 +42809,9 @@ async function handler(args, ctx) {
 function registerRepoSecurityPlanTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "repo_security_plan" });
   const toolSchema = {
-    repo: z89.string().min(1).describe('GitHub repository in "owner/name" format or full URL'),
-    categories: z89.array(z89.string().max(50)).max(10).optional().describe('Filter to specific categories (e.g., ["sast", "sca", "secrets"])'),
-    maxScanners: z89.number().min(1).max(20).optional().describe("Maximum scanners to recommend (default: 10)")
+    repo: z90.string().min(1).describe('GitHub repository in "owner/name" format or full URL'),
+    categories: z90.array(z90.string().max(50)).max(10).optional().describe('Filter to specific categories (e.g., ["sast", "sca", "secrets"])'),
+    maxScanners: z90.number().min(1).max(20).optional().describe("Maximum scanners to recommend (default: 10)")
   };
   const description = "Generate a security scanning pipeline recommendation for a GitHub repository. Analyzes repo structure, detects languages/frameworks, and recommends specific vulnerability scanners with CI config snippets. Powered by the vulnerability scanner registry with provenance-tracked metrics.";
   const secureHandler = createSecureHandler(handler, {
@@ -42692,13 +42834,13 @@ function registerRepoSecurityPlanTool(server, deps) {
 
 // src/mcp/tools/search-codebase-tool.ts
 import { resolve as resolve6, sep as sep3 } from "node:path";
-import { z as z90 } from "zod";
-var SearchCodebaseInputSchema = z90.object({
-  query: z90.string().min(1).max(200).describe("Search query (symbol name, keyword, or pattern)"),
-  directory: z90.string().min(1).max(500).optional().describe("Directory to search (default: current working directory)"),
-  limit: z90.number().min(1).max(50).optional().describe("Max results (default: 20)"),
-  mode: z90.enum(["search", "summary", "list"]).optional().describe("search: find symbols. summary: file overview. list: list indexed files."),
-  maxDepth: z90.number().int().min(1).max(MAX_INDEX_MAX_DEPTH).optional().describe(
+import { z as z91 } from "zod";
+var SearchCodebaseInputSchema = z91.object({
+  query: z91.string().min(1).max(200).describe("Search query (symbol name, keyword, or pattern)"),
+  directory: z91.string().min(1).max(500).optional().describe("Directory to search (default: current working directory)"),
+  limit: z91.number().min(1).max(50).optional().describe("Max results (default: 20)"),
+  mode: z91.enum(["search", "summary", "list"]).optional().describe("search: find symbols. summary: file overview. list: list indexed files."),
+  maxDepth: z91.number().int().min(1).max(MAX_INDEX_MAX_DEPTH).optional().describe(
     `Max directory depth to index below "directory" (default: ${String(DEFAULT_INDEX_MAX_DEPTH)}, clamped to ${String(MAX_INDEX_MAX_DEPTH)}). Raise this if results seem incomplete for a deeply nested tree.`
   )
 });
@@ -42828,11 +42970,11 @@ async function searchCodebaseHandler(args, ctx) {
 function registerSearchCodebaseTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "search_codebase" });
   const toolSchema = {
-    query: z90.string().min(1).max(200).describe("Search query or file path"),
-    directory: z90.string().max(500).optional().describe("Directory to index"),
-    limit: z90.number().min(1).max(50).optional().describe("Max results"),
-    mode: z90.enum(["search", "summary", "list"]).optional().describe("search/summary/list"),
-    maxDepth: z90.number().int().min(1).max(MAX_INDEX_MAX_DEPTH).optional().describe(
+    query: z91.string().min(1).max(200).describe("Search query or file path"),
+    directory: z91.string().max(500).optional().describe("Directory to index"),
+    limit: z91.number().min(1).max(50).optional().describe("Max results"),
+    mode: z91.enum(["search", "summary", "list"]).optional().describe("search/summary/list"),
+    maxDepth: z91.number().int().min(1).max(MAX_INDEX_MAX_DEPTH).optional().describe(
       `Max directory depth to index (default: ${String(DEFAULT_INDEX_MAX_DEPTH)}, clamped to ${String(MAX_INDEX_MAX_DEPTH)})`
     )
   };
@@ -42854,7 +42996,7 @@ function registerSearchCodebaseTool(server, deps) {
 
 // src/mcp/tools/extract-symbols-tool.ts
 import { extname as extname3, resolve as resolve7, sep as sep4 } from "node:path";
-import { z as z91 } from "zod";
+import { z as z92 } from "zod";
 
 // src/core/task-analysis/tool-refusal-gap.ts
 function toolRefusalGapName(tool, capability) {
@@ -42880,13 +43022,13 @@ function recordToolRefusal(refusal, context, ledger = getGapLedger()) {
 // src/mcp/tools/extract-symbols-tool.ts
 var DEFAULT_EXTRACT_MAX_CHARS = 2e4;
 var DEFAULT_EXTRACT_MAX_SYMBOLS = 200;
-var ExtractSymbolsInputSchema = z91.object({
-  filePath: z91.string().min(1).max(500).describe("Path to TypeScript/JavaScript file to extract symbols from"),
-  mode: z91.enum(["index", "full"]).optional().describe("index: names+lines only (minimal tokens). full: includes source text."),
-  maxChars: z91.number().int().positive().max(1e6).optional().describe(
+var ExtractSymbolsInputSchema = z92.object({
+  filePath: z92.string().min(1).max(500).describe("Path to TypeScript/JavaScript file to extract symbols from"),
+  mode: z92.enum(["index", "full"]).optional().describe("index: names+lines only (minimal tokens). full: includes source text."),
+  maxChars: z92.number().int().positive().max(1e6).optional().describe(
     `full mode only: cap on total emitted symbol source chars (default ${String(DEFAULT_EXTRACT_MAX_CHARS)}). Excess is truncated and reported, never silently dropped.`
   ),
-  maxSymbols: z91.number().int().positive().max(1e4).optional().describe(
+  maxSymbols: z92.number().int().positive().max(1e4).optional().describe(
     `full mode only: cap on number of symbols emitted (default ${String(DEFAULT_EXTRACT_MAX_SYMBOLS)}).`
   )
 });
@@ -43030,12 +43172,12 @@ function emptyIndexMessage(reason, filePath) {
 function registerExtractSymbolsTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "extract_symbols" });
   const toolSchema = {
-    filePath: z91.string().min(1).max(500).describe("Path to TypeScript/JavaScript file"),
-    mode: z91.enum(["index", "full"]).optional().describe("index (default): names+lines. full: includes source text"),
-    maxChars: z91.number().int().positive().max(1e6).optional().describe(
+    filePath: z92.string().min(1).max(500).describe("Path to TypeScript/JavaScript file"),
+    mode: z92.enum(["index", "full"]).optional().describe("index (default): names+lines. full: includes source text"),
+    maxChars: z92.number().int().positive().max(1e6).optional().describe(
       `full mode only: cap on total emitted symbol source chars (default ${String(DEFAULT_EXTRACT_MAX_CHARS)})`
     ),
-    maxSymbols: z91.number().int().positive().max(1e4).optional().describe(
+    maxSymbols: z92.number().int().positive().max(1e4).optional().describe(
       `full mode only: cap on number of symbols emitted (default ${String(DEFAULT_EXTRACT_MAX_SYMBOLS)})`
     )
   };
@@ -43061,23 +43203,23 @@ function registerExtractSymbolsTool(server, deps) {
 // src/mcp/tools/search-usages-tool.ts
 import { readFile as readFile3 } from "node:fs/promises";
 import { relative, resolve as resolve8, sep as sep5 } from "node:path";
-import { z as z92 } from "zod";
+import { z as z93 } from "zod";
 var DEFAULT_USAGES_LIMIT = 50;
 var MAX_USAGES_LIMIT = 500;
 var DEFAULT_USAGES_MAX_DEPTH = 24;
 var MAX_USAGES_MAX_DEPTH = 64;
 var MAX_FILES_SCANNED = 5e3;
-var SearchUsagesInputSchema = z92.object({
-  symbol: z92.string().min(1).max(200).regex(IDENTIFIER_RE, "symbol must be a single JS identifier (letters, digits, _ or $)").describe("Identifier to find usages/call-sites of (a single JS identifier)"),
-  path: z92.string().min(1).max(500).optional().describe("Restrict to a single source file (takes precedence over dir)"),
-  dir: z92.string().min(1).max(500).optional().describe("Directory to search recursively (default: current working directory)"),
-  lang: z92.enum(LANG_VALUES).optional().describe(
+var SearchUsagesInputSchema = z93.object({
+  symbol: z93.string().min(1).max(200).regex(IDENTIFIER_RE, "symbol must be a single JS identifier (letters, digits, _ or $)").describe("Identifier to find usages/call-sites of (a single JS identifier)"),
+  path: z93.string().min(1).max(500).optional().describe("Restrict to a single source file (takes precedence over dir)"),
+  dir: z93.string().min(1).max(500).optional().describe("Directory to search recursively (default: current working directory)"),
+  lang: z93.enum(LANG_VALUES).optional().describe(
     "Language override (default: inferred from each file extension, fallback typescript)"
   ),
-  limit: z92.number().int().min(1).max(MAX_USAGES_LIMIT).optional().describe(
+  limit: z93.number().int().min(1).max(MAX_USAGES_LIMIT).optional().describe(
     `Max usage matches emitted (default ${String(DEFAULT_USAGES_LIMIT)}). Excess is reported.`
   ),
-  maxDepth: z92.number().int().min(1).max(MAX_USAGES_MAX_DEPTH).optional().describe(`Directory walk depth for dir scope (default ${String(DEFAULT_USAGES_MAX_DEPTH)}).`)
+  maxDepth: z93.number().int().min(1).max(MAX_USAGES_MAX_DEPTH).optional().describe(`Directory walk depth for dir scope (default ${String(DEFAULT_USAGES_MAX_DEPTH)}).`)
 });
 function resolveWithinCwd(target) {
   const resolved = resolve8(target);
@@ -43196,12 +43338,12 @@ async function searchUsagesHandler(args, ctx) {
 function registerSearchUsagesTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "search_usages" });
   const toolSchema = {
-    symbol: z92.string().min(1).max(200).regex(IDENTIFIER_RE, "symbol must be a single JS identifier").describe("Identifier to find usages/call-sites of"),
-    path: z92.string().min(1).max(500).optional().describe("Restrict to a single source file"),
-    dir: z92.string().min(1).max(500).optional().describe("Directory to search (default: cwd)"),
-    lang: z92.enum(LANG_VALUES).optional().describe("Language override (default: infer from ext)"),
-    limit: z92.number().int().min(1).max(MAX_USAGES_LIMIT).optional().describe(`Max matches (default ${String(DEFAULT_USAGES_LIMIT)})`),
-    maxDepth: z92.number().int().min(1).max(MAX_USAGES_MAX_DEPTH).optional().describe(`Directory walk depth (default ${String(DEFAULT_USAGES_MAX_DEPTH)})`)
+    symbol: z93.string().min(1).max(200).regex(IDENTIFIER_RE, "symbol must be a single JS identifier").describe("Identifier to find usages/call-sites of"),
+    path: z93.string().min(1).max(500).optional().describe("Restrict to a single source file"),
+    dir: z93.string().min(1).max(500).optional().describe("Directory to search (default: cwd)"),
+    lang: z93.enum(LANG_VALUES).optional().describe("Language override (default: infer from ext)"),
+    limit: z93.number().int().min(1).max(MAX_USAGES_LIMIT).optional().describe(`Max matches (default ${String(DEFAULT_USAGES_LIMIT)})`),
+    maxDepth: z93.number().int().min(1).max(MAX_USAGES_MAX_DEPTH).optional().describe(`Directory walk depth (default ${String(DEFAULT_USAGES_MAX_DEPTH)})`)
   };
   const description = `Structural USAGE / call-site search for a symbol via ast-grep (tree-sitter). Answers "where is X used or called" \u2014 finds calls (foo()), member calls (obj.foo()), new expressions (new Foo()), imports, and bare references, with file:line:column + snippet. This is the gap \`search_codebase\` CANNOT fill: that indexes declared symbol NAMES only, not usages. Excludes the declaration itself (use \`search_codebase\` for declarations). Syntactic, not type-aware (a same-named member on an unrelated object may match). Read-only. Results capped at ${String(DEFAULT_USAGES_LIMIT)} by default (override via limit up to ${String(MAX_USAGES_LIMIT)}); overflow is reported, never silent.`;
   const secureHandler = createSecureHandler(searchUsagesHandler, {
@@ -43222,11 +43364,11 @@ function registerSearchUsagesTool(server, deps) {
 // src/mcp/tools/query-trace-tool.ts
 import { readFile as readFile4, stat as stat3 } from "node:fs/promises";
 import { join as join7, resolve as resolve9, sep as sep6 } from "node:path";
-import { z as z93 } from "zod";
-var QueryTraceInputSchema = z93.object({
-  runId: z93.string().min(1).max(128).regex(/^[a-zA-Z0-9_-]+$/, "runId must be alphanumeric, hyphens, or underscores").describe("Run ID to query traces for"),
-  eventType: z93.string().max(100).regex(/^[a-zA-Z0-9._-]+$/, "eventType must be alphanumeric with dots, hyphens, or underscores").optional().describe("Filter by event type"),
-  limit: z93.number().min(1).max(500).optional().describe("Max events to return (default: 100)")
+import { z as z94 } from "zod";
+var QueryTraceInputSchema = z94.object({
+  runId: z94.string().min(1).max(128).regex(/^[a-zA-Z0-9_-]+$/, "runId must be alphanumeric, hyphens, or underscores").describe("Run ID to query traces for"),
+  eventType: z94.string().max(100).regex(/^[a-zA-Z0-9._-]+$/, "eventType must be alphanumeric with dots, hyphens, or underscores").optional().describe("Filter by event type"),
+  limit: z94.number().min(1).max(500).optional().describe("Max events to return (default: 100)")
 });
 var MAX_TRACE_FILE_BYTES = 100 * 1024 * 1024;
 var traceLogger = createLogger({ component: "query-trace" });
@@ -43350,9 +43492,9 @@ function queryTraceHandler(args, ctx) {
 function registerQueryTraceTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "query_trace" });
   const toolSchema = {
-    runId: z93.string().min(1).max(128).regex(/^[a-zA-Z0-9_-]+$/, "runId must be alphanumeric, hyphens, or underscores").describe("Run ID to query traces for"),
-    eventType: z93.string().max(100).regex(/^[a-zA-Z0-9._-]+$/).optional().describe("Filter by event type (e.g., model.called)"),
-    limit: z93.number().min(1).max(500).optional().describe("Max events to return (default: 100)")
+    runId: z94.string().min(1).max(128).regex(/^[a-zA-Z0-9_-]+$/, "runId must be alphanumeric, hyphens, or underscores").describe("Run ID to query traces for"),
+    eventType: z94.string().max(100).regex(/^[a-zA-Z0-9._-]+$/).optional().describe("Filter by event type (e.g., model.called)"),
+    limit: z94.number().min(1).max(500).optional().describe("Max events to return (default: 100)")
   };
   const description = "Query execution traces by run ID. Returns agent and model attribution for pipeline runs including decision paths, error taxonomy, and timing data.";
   const secureHandler = createSecureHandler(queryTraceHandler, {
@@ -43371,7 +43513,7 @@ function registerQueryTraceTool(server, deps) {
 }
 
 // src/mcp/tools/get-job-result-tool.ts
-import { z as z94 } from "zod";
+import { z as z95 } from "zod";
 
 // src/mcp/jobs/task-state-source.ts
 var logger34 = createLogger({ component: "task-state-source" });
@@ -43494,8 +43636,8 @@ function resolveJobListing(customDir) {
 }
 
 // src/mcp/tools/get-job-result-tool.ts
-var GetJobResultInputSchema = z94.object({
-  jobId: z94.string().min(1).max(128).describe('Job ID returned by any tool called with dispatch: "async" (e.g. orchestrate)')
+var GetJobResultInputSchema = z95.object({
+  jobId: z95.string().min(1).max(128).describe('Job ID returned by any tool called with dispatch: "async" (e.g. orchestrate)')
 });
 function getJobResultHandler(args) {
   const parsed = GetJobResultInputSchema.safeParse(args);
@@ -43534,7 +43676,7 @@ function getJobResultHandler(args) {
 function registerGetJobResultTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "get_job_result" });
   const toolSchema = {
-    jobId: z94.string().min(1).max(128).describe('Job ID returned by any tool called with dispatch: "async" (e.g. orchestrate)')
+    jobId: z95.string().min(1).max(128).describe('Job ID returned by any tool called with dispatch: "async" (e.g. orchestrate)')
   };
   const description = `Read the result of an async-mode tool invocation by jobId. Returns the structured record (status, result | error, timestamps, producerVersion) plus producerVersionMeasured \u2014 false when the producer was a dev build or the record predates the field, so its version must not be compared to this server's _meta build stamp \u2014 and producerVersionSource (sidecar | task_state; a task_state record never carries a version). Poll until status !== "pending". Stage-1 of epic #2631 \u2014 Stage 2 will fold this into query_task_state once StructuredTaskState gains the result field.`;
   const secureHandler = createSecureHandler(getJobResultHandler, {
@@ -43556,14 +43698,14 @@ function registerGetJobResultTool(server, deps) {
 }
 
 // src/mcp/tools/list-jobs-tool.ts
-import { z as z95 } from "zod";
+import { z as z96 } from "zod";
 var MAX_LIST_JOBS_RESULTS = 200;
-var ListJobsInputSchema = z95.object({
+var ListJobsInputSchema = z96.object({
   /**
    * Filter to jobs from a specific tool (exact match — e.g. `'orchestrate'`).
    * Omit to list every tool's jobs.
    */
-  toolName: z95.string().min(1).max(128).optional().describe("Filter to one tool (exact match)."),
+  toolName: z96.string().min(1).max(128).optional().describe("Filter to one tool (exact match)."),
   /**
    * Filter to jobs in a specific lifecycle state.
    * Omit to list every state.
@@ -43576,7 +43718,7 @@ var ListJobsInputSchema = z95.object({
    * Newest jobs are returned first, so a smaller limit shows the most
    * recent activity.
    */
-  limit: z95.number().int().min(1).max(MAX_LIST_JOBS_RESULTS).optional().describe(`Max summaries to return (1-${String(MAX_LIST_JOBS_RESULTS)}, newest first).`)
+  limit: z96.number().int().min(1).max(MAX_LIST_JOBS_RESULTS).optional().describe(`Max summaries to return (1-${String(MAX_LIST_JOBS_RESULTS)}, newest first).`)
 });
 function listJobsHandler(args) {
   const parsed = ListJobsInputSchema.safeParse(args);
@@ -43617,11 +43759,11 @@ function listJobsHandler(args) {
 function registerListJobsTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "list_jobs" });
   const toolSchema = {
-    toolName: z95.string().min(1).max(128).optional().describe("Filter to one tool (exact match)."),
+    toolName: z96.string().min(1).max(128).optional().describe("Filter to one tool (exact match)."),
     status: JobStatusSchema.optional().describe(
       "Filter to pending | complete | failed | cancelled. Omit for all."
     ),
-    limit: z95.number().int().min(1).max(MAX_LIST_JOBS_RESULTS).optional().describe(`Max summaries to return (1-${String(MAX_LIST_JOBS_RESULTS)}, newest first).`)
+    limit: z96.number().int().min(1).max(MAX_LIST_JOBS_RESULTS).optional().describe(`Max summaries to return (1-${String(MAX_LIST_JOBS_RESULTS)}, newest first).`)
   };
   const description = "List async-mode jobs (cross-session discovery). Returns summaries \u2014 jobId, toolName, status, timestamps \u2014 newest first. Filter by toolName / status / limit. Result payloads excluded; fetch via get_job_result(jobId). Stage 5 of epic #2631.";
   const secureHandler = createSecureHandler(listJobsHandler, {
@@ -43643,11 +43785,11 @@ function registerListJobsTool(server, deps) {
 }
 
 // src/mcp/tools/cancel-job-tool.ts
-import { z as z96 } from "zod";
+import { z as z97 } from "zod";
 var defaultLogger3 = createLogger({ tool: "cancel_job" });
-var CancelJobInputSchema = z96.object({
-  jobId: z96.string().min(1).max(128).describe("Job ID returned by orchestrate / run_workflow / consensus_vote in async mode"),
-  reason: z96.string().max(1e3).optional().describe('Optional human-readable note (e.g. "user clicked cancel").')
+var CancelJobInputSchema = z97.object({
+  jobId: z97.string().min(1).max(128).describe("Job ID returned by orchestrate / run_workflow / consensus_vote in async mode"),
+  reason: z97.string().max(1e3).optional().describe('Optional human-readable note (e.g. "user clicked cancel").')
 });
 function cancelJobHandler(args, logger57 = defaultLogger3) {
   const parsed = CancelJobInputSchema.safeParse(args);
@@ -43716,8 +43858,8 @@ function cancelPendingJob(jobId, toolName, logger57, reason) {
 function registerCancelJobTool(server, deps) {
   const logger57 = deps.logger ?? defaultLogger3;
   const toolSchema = {
-    jobId: z96.string().min(1).max(128).describe("Job ID returned by orchestrate / run_workflow / consensus_vote in async mode"),
-    reason: z96.string().max(1e3).optional().describe('Optional human-readable note (e.g. "user clicked cancel").')
+    jobId: z97.string().min(1).max(128).describe("Job ID returned by orchestrate / run_workflow / consensus_vote in async mode"),
+    reason: z97.string().max(1e3).optional().describe('Optional human-readable note (e.g. "user clicked cancel").')
   };
   const description = "Mark an async-mode job as cancelled (#3042 Stage 1b / epic #2631). Same-process dispatcher unwinds via AbortSignal (#3035/#3038); cross-process workers observe via get_job_result. Idempotent \u2014 cancel-after-complete is a no-op (preserves the terminal record); second cancel returns already_cancelled.";
   const secureHandler = createSecureHandler((args) => cancelJobHandler(args, logger57), {
@@ -43739,7 +43881,7 @@ function registerCancelJobTool(server, deps) {
 }
 
 // src/audit/audit-types.ts
-import { z as z97 } from "zod";
+import { z as z98 } from "zod";
 var AuditError = class extends Error {
   code = "AUDIT_ERROR";
   context;
@@ -43751,7 +43893,7 @@ var AuditError = class extends Error {
     this.context = options?.context;
   }
 };
-var AuditCategorySchema = z97.enum([
+var AuditCategorySchema = z98.enum([
   "authentication",
   // Login, logout, token refresh
   "authorization",
@@ -43771,28 +43913,28 @@ var AuditCategorySchema = z97.enum([
   "governance"
   // Authority-tier transitions, ratification (Epic D, #3842)
 ]);
-var TierTransitionKindSchema = z97.enum(["promotion", "demotion"]);
-var TierTransitionTierSchema = z97.enum(["observe", "suggest", "advisory", "enforce"]);
-var TierTransitionPayloadSchema = z97.object({
+var TierTransitionKindSchema = z98.enum(["promotion", "demotion"]);
+var TierTransitionTierSchema = z98.enum(["observe", "suggest", "advisory", "enforce"]);
+var TierTransitionPayloadSchema = z98.object({
   /** Whether the loop moved up (`promotion`) or down (`demotion`) the ladder. */
   kind: TierTransitionKindSchema,
   /** The loop/strategy whose tier changed (manifest `id` or loop identifier). */
-  subject: z97.string().min(1),
+  subject: z98.string().min(1),
   /** Tier before the transition. */
   fromTier: TierTransitionTierSchema,
   /** Tier after the transition. */
   toTier: TierTransitionTierSchema,
   /** Ref to the promotion-evidence record this transition was earned against. */
-  evidenceRef: z97.string().min(1),
+  evidenceRef: z98.string().min(1),
   /**
    * Ref to the recorded `consensus_vote` that ratified a PROMOTION. Required
    * by the ratification gate for `kind: 'promotion'`; legitimately absent for
    * `kind: 'demotion'` (automatic, ADR-0017 §"Demotion is automatic").
    */
-  ratificationVoteRef: z97.string().min(1).optional()
+  ratificationVoteRef: z98.string().min(1).optional()
 }).strict();
 var TIER_TRANSITION_METADATA_KEY = "tierTransition";
-var AuditSeveritySchema = z97.enum([
+var AuditSeveritySchema = z98.enum([
   "info",
   // Normal operations
   "warning",
@@ -43800,7 +43942,7 @@ var AuditSeveritySchema = z97.enum([
   "critical"
   // Security violations, failures
 ]);
-var AuditOutcomeSchema = z97.enum([
+var AuditOutcomeSchema = z98.enum([
   "success",
   // Operation completed successfully
   "failure",
@@ -43810,56 +43952,56 @@ var AuditOutcomeSchema = z97.enum([
   "error"
   // Unexpected error occurred
 ]);
-var AuditActorSchema = z97.object({
-  type: z97.enum(["user", "agent", "system", "external"]),
-  id: z97.string().min(1),
-  name: z97.string().optional(),
-  ip: z97.string().optional(),
-  userAgent: z97.string().optional()
+var AuditActorSchema = z98.object({
+  type: z98.enum(["user", "agent", "system", "external"]),
+  id: z98.string().min(1),
+  name: z98.string().optional(),
+  ip: z98.string().optional(),
+  userAgent: z98.string().optional()
 });
-var AuditResourceSchema = z97.object({
-  type: z97.string().min(1),
+var AuditResourceSchema = z98.object({
+  type: z98.string().min(1),
   // e.g., 'file', 'tool', 'config', 'agent'
-  id: z97.string().min(1),
-  name: z97.string().optional(),
-  path: z97.string().optional()
+  id: z98.string().min(1),
+  name: z98.string().optional(),
+  path: z98.string().optional()
 });
-var AuditEventSchema = z97.object({
+var AuditEventSchema = z98.object({
   // Identity
-  id: z97.string().min(1),
+  id: z98.string().min(1),
   // Unique event ID
-  version: z97.literal("1.0"),
+  version: z98.literal("1.0"),
   // Schema version for migrations
   // Timing
-  timestamp: z97.string(),
+  timestamp: z98.string(),
   // ISO 8601 format
-  timestampMs: z97.number(),
+  timestampMs: z98.number(),
   // Unix epoch milliseconds
   // Classification
   category: AuditCategorySchema,
   severity: AuditSeveritySchema,
   outcome: AuditOutcomeSchema,
   // Event details
-  action: z97.string().min(1),
+  action: z98.string().min(1),
   // e.g., 'tool.invoke', 'policy.evaluate'
-  description: z97.string().optional(),
+  description: z98.string().optional(),
   // Actors and resources
   actor: AuditActorSchema,
   resource: AuditResourceSchema.optional(),
   // Correlation
-  requestId: z97.string().optional(),
+  requestId: z98.string().optional(),
   // Request correlation ID
-  traceId: z97.string().optional(),
+  traceId: z98.string().optional(),
   // Distributed trace ID
-  sessionId: z97.string().optional(),
+  sessionId: z98.string().optional(),
   // Session correlation ID
   // Context
-  toolName: z97.string().optional(),
-  durationMs: z97.number().optional(),
-  metadata: z97.record(z97.string(), z97.unknown()).optional(),
+  toolName: z98.string().optional(),
+  durationMs: z98.number().optional(),
+  metadata: z98.record(z98.string(), z98.unknown()).optional(),
   // Policy and security
-  policyName: z97.string().optional(),
-  policyDecision: z97.string().optional(),
+  policyName: z98.string().optional(),
+  policyDecision: z98.string().optional(),
   /**
    * Which occurrence of this `{tool, rule}` near-miss the record represents
    * (#5228 review). Present only on a sampled `would_deny`.
@@ -43876,12 +44018,12 @@ var AuditEventSchema = z97.object({
    * Absent means "not sampled" — every occurrence was recorded — which is
    * distinct from `1`.
    */
-  policyOccurrence: z97.number().int().min(1).optional(),
-  violationType: z97.string().optional(),
+  policyOccurrence: z98.number().int().min(1).optional(),
+  violationType: z98.string().optional(),
   // Integrity (for tamper-evidence)
-  previousHash: z97.string().optional(),
+  previousHash: z98.string().optional(),
   // Hash of previous event (chain)
-  hash: z97.string().optional(),
+  hash: z98.string().optional(),
   // Hash of this event
   /**
    * Hash-projection version (#3921). ABSENT/`1` = the legacy projection
@@ -43891,62 +44033,62 @@ var AuditEventSchema = z97.object({
    * Versioned so pre-existing v1 chains keep verifying under their own
    * projection (see {@link AUDIT_HASH_VERSION_TIER_TRANSITION}).
    */
-  hashVersion: z97.number().int().positive().optional()
+  hashVersion: z98.number().int().positive().optional()
 });
 var AUDIT_HASH_VERSION_TIER_TRANSITION = 2;
-var AuditEventInputSchema = z97.object({
+var AuditEventInputSchema = z98.object({
   category: AuditCategorySchema,
   severity: AuditSeveritySchema.optional().default("info"),
   outcome: AuditOutcomeSchema,
-  action: z97.string().min(1),
-  description: z97.string().optional(),
+  action: z98.string().min(1),
+  description: z98.string().optional(),
   actor: AuditActorSchema,
   resource: AuditResourceSchema.optional(),
-  requestId: z97.string().optional(),
-  traceId: z97.string().optional(),
-  sessionId: z97.string().optional(),
-  toolName: z97.string().optional(),
-  durationMs: z97.number().optional(),
-  metadata: z97.record(z97.string(), z97.unknown()).optional(),
-  policyName: z97.string().optional(),
-  policyDecision: z97.string().optional(),
+  requestId: z98.string().optional(),
+  traceId: z98.string().optional(),
+  sessionId: z98.string().optional(),
+  toolName: z98.string().optional(),
+  durationMs: z98.number().optional(),
+  metadata: z98.record(z98.string(), z98.unknown()).optional(),
+  policyName: z98.string().optional(),
+  policyDecision: z98.string().optional(),
   /** @see AuditEventSchema.policyOccurrence (#5228 review). */
-  policyOccurrence: z97.number().int().min(1).optional(),
-  violationType: z97.string().optional()
+  policyOccurrence: z98.number().int().min(1).optional(),
+  violationType: z98.string().optional()
 });
-var AuditLogConfigSchema = z97.object({
+var AuditLogConfigSchema = z98.object({
   // Storage
-  logDir: z97.string().min(1),
-  filePrefix: z97.string().optional().default("audit"),
-  maxFileSizeBytes: z97.number().positive().optional().default(10 * 1024 * 1024),
+  logDir: z98.string().min(1),
+  filePrefix: z98.string().optional().default("audit"),
+  maxFileSizeBytes: z98.number().positive().optional().default(10 * 1024 * 1024),
   // 10MB
-  maxFiles: z97.number().positive().optional().default(10),
+  maxFiles: z98.number().positive().optional().default(10),
   // Features
-  enableHashChain: z97.boolean().optional().default(true),
-  enableCompression: z97.boolean().optional().default(false),
-  flushIntervalMs: z97.number().positive().optional().default(1e3),
+  enableHashChain: z98.boolean().optional().default(true),
+  enableCompression: z98.boolean().optional().default(false),
+  flushIntervalMs: z98.number().positive().optional().default(1e3),
   /**
    * Maximum in-memory event queue depth before drop-oldest backpressure
    * engages. Bounds memory under load when storage.write is slow or the flush
    * timer is overlapping; see #2979.
    */
-  maxQueueDepth: z97.number().positive().optional().default(1e4),
+  maxQueueDepth: z98.number().positive().optional().default(1e4),
   // Filtering
   minSeverity: AuditSeveritySchema.optional().default("info"),
-  categories: z97.array(AuditCategorySchema).optional()
+  categories: z98.array(AuditCategorySchema).optional()
 });
-var AuditQueryCriteriaSchema = z97.object({
-  startTime: z97.date().optional(),
-  endTime: z97.date().optional(),
-  categories: z97.array(AuditCategorySchema).optional(),
-  severities: z97.array(AuditSeveritySchema).optional(),
-  outcomes: z97.array(AuditOutcomeSchema).optional(),
-  actorId: z97.string().optional(),
-  resourceId: z97.string().optional(),
-  requestId: z97.string().optional(),
-  traceId: z97.string().optional(),
-  limit: z97.number().positive().optional().default(100),
-  offset: z97.number().nonnegative().optional().default(0)
+var AuditQueryCriteriaSchema = z98.object({
+  startTime: z98.date().optional(),
+  endTime: z98.date().optional(),
+  categories: z98.array(AuditCategorySchema).optional(),
+  severities: z98.array(AuditSeveritySchema).optional(),
+  outcomes: z98.array(AuditOutcomeSchema).optional(),
+  actorId: z98.string().optional(),
+  resourceId: z98.string().optional(),
+  requestId: z98.string().optional(),
+  traceId: z98.string().optional(),
+  limit: z98.number().positive().optional().default(100),
+  offset: z98.number().nonnegative().optional().default(0)
 });
 
 // src/audit/audit-storage-queries.ts
@@ -45431,7 +45573,7 @@ function ensureRunnableTemplate(template, stages) {
 // src/pipeline/pipeline-checkpoint.ts
 import * as fs6 from "node:fs";
 import * as path4 from "node:path";
-import { z as z98 } from "zod";
+import { z as z99 } from "zod";
 var logger39 = createLogger({ component: "pipeline-checkpoint" });
 var SESSION_ID_REGEX = /^[a-zA-Z0-9_-]{1,128}$/;
 function validateSessionId(sessionId) {
@@ -45479,7 +45621,7 @@ function loadCheckpointState(sessionId, customDir) {
     return null;
   }
 }
-var PipelineStageSchema = z98.enum([
+var PipelineStageSchema = z99.enum([
   "research",
   "plan",
   "vote",
@@ -45487,27 +45629,27 @@ var PipelineStageSchema = z98.enum([
   "implement",
   "security"
 ]);
-var PipelineStageDataSchema = z98.discriminatedUnion("type", [
-  z98.object({ type: z98.literal("research"), text: z98.string() }),
-  z98.object({ type: z98.literal("plan"), text: z98.string(), iterations: z98.number() }),
-  z98.object({
-    type: z98.literal("vote"),
-    approved: z98.boolean(),
-    conditional: z98.boolean(),
-    conditions: z98.array(z98.string()).optional(),
-    caveats: z98.array(z98.string()).optional(),
-    iterations: z98.number()
+var PipelineStageDataSchema = z99.discriminatedUnion("type", [
+  z99.object({ type: z99.literal("research"), text: z99.string() }),
+  z99.object({ type: z99.literal("plan"), text: z99.string(), iterations: z99.number() }),
+  z99.object({
+    type: z99.literal("vote"),
+    approved: z99.boolean(),
+    conditional: z99.boolean(),
+    conditions: z99.array(z99.string()).optional(),
+    caveats: z99.array(z99.string()).optional(),
+    iterations: z99.number()
   }),
   // PipelineTask shape is loose at the persistence layer — capture as
   // `z.unknown()` and trust the downstream consumer's narrower validation.
-  z98.object({ type: z98.literal("decompose"), tasks: z98.array(z98.unknown()) }),
-  z98.object({ type: z98.literal("implement"), tasks: z98.array(z98.unknown()) }),
-  z98.object({ type: z98.literal("security"), passed: z98.boolean() })
+  z99.object({ type: z99.literal("decompose"), tasks: z99.array(z99.unknown()) }),
+  z99.object({ type: z99.literal("implement"), tasks: z99.array(z99.unknown()) }),
+  z99.object({ type: z99.literal("security"), passed: z99.boolean() })
 ]);
-var PipelineCheckpointEntrySchema = z98.object({
-  sessionId: z98.string(),
+var PipelineCheckpointEntrySchema = z99.object({
+  sessionId: z99.string(),
   stage: PipelineStageSchema,
-  timestamp: z98.string(),
+  timestamp: z99.string(),
   data: PipelineStageDataSchema
 });
 function rebuildState(lines) {
@@ -45697,7 +45839,7 @@ function buildVotingInput(plan, config) {
 }
 async function executeSingleVote(plan, config, log) {
   try {
-    const { executeVoting } = await import("./consensus-vote-YWUJNA4A.js");
+    const { executeVoting } = await import("./consensus-vote-OL7DLZNL.js");
     const input = buildVotingInput(plan, config);
     const result = await executeVoting(input, log);
     return parseVotingResult(result);
@@ -46421,49 +46563,49 @@ Verdict: PASS/NEEDS_WORK/REJECT`;
 }
 
 // src/security/sarif-parser.ts
-import { z as z99 } from "zod";
-var SarifLocationSchema = z99.object({
-  physicalLocation: z99.object({
-    artifactLocation: z99.object({ uri: z99.string().optional().catch(void 0) }).optional(),
-    region: z99.object({
-      startLine: z99.number().optional().catch(void 0),
-      endLine: z99.number().int().min(1).optional().catch(void 0),
-      snippet: z99.object({ text: z99.string().optional().catch(void 0) }).optional().catch(void 0)
+import { z as z100 } from "zod";
+var SarifLocationSchema = z100.object({
+  physicalLocation: z100.object({
+    artifactLocation: z100.object({ uri: z100.string().optional().catch(void 0) }).optional(),
+    region: z100.object({
+      startLine: z100.number().optional().catch(void 0),
+      endLine: z100.number().int().min(1).optional().catch(void 0),
+      snippet: z100.object({ text: z100.string().optional().catch(void 0) }).optional().catch(void 0)
     }).optional()
   }).optional()
 });
-var SarifResultSchema = z99.object({
-  ruleId: z99.string().nullish(),
-  level: z99.string().nullish(),
-  message: z99.object({ text: z99.string().optional() }).nullish(),
-  locations: z99.array(SarifLocationSchema).nullish()
+var SarifResultSchema = z100.object({
+  ruleId: z100.string().nullish(),
+  level: z100.string().nullish(),
+  message: z100.object({ text: z100.string().optional() }).nullish(),
+  locations: z100.array(SarifLocationSchema).nullish()
 });
-var SarifRuleSchema = z99.object({
-  id: z99.string(),
-  shortDescription: z99.object({ text: z99.string().optional().catch(void 0) }).optional(),
-  defaultConfiguration: z99.object({ level: z99.string().optional().catch(void 0) }).optional(),
-  properties: z99.object({
-    precision: z99.string().optional().catch(void 0),
-    tags: z99.array(z99.string()).optional().catch(void 0),
+var SarifRuleSchema = z100.object({
+  id: z100.string(),
+  shortDescription: z100.object({ text: z100.string().optional().catch(void 0) }).optional(),
+  defaultConfiguration: z100.object({ level: z100.string().optional().catch(void 0) }).optional(),
+  properties: z100.object({
+    precision: z100.string().optional().catch(void 0),
+    tags: z100.array(z100.string()).optional().catch(void 0),
     // Accept the number form and normalize; `resolveSeverityFromScore`
     // parses it either way.
-    "security-severity": z99.union([z99.string(), z99.number()]).optional().catch(void 0)
+    "security-severity": z100.union([z100.string(), z100.number()]).optional().catch(void 0)
   }).optional().catch(void 0),
-  helpUri: z99.string().optional().catch(void 0),
-  help: z99.object({ markdown: z99.string().optional().catch(void 0) }).optional()
+  helpUri: z100.string().optional().catch(void 0),
+  help: z100.object({ markdown: z100.string().optional().catch(void 0) }).optional()
 });
-var SarifRunSchema = z99.object({
-  tool: z99.object({
-    driver: z99.object({
-      name: z99.string().optional(),
-      rules: z99.array(z99.unknown()).optional()
+var SarifRunSchema = z100.object({
+  tool: z100.object({
+    driver: z100.object({
+      name: z100.string().optional(),
+      rules: z100.array(z100.unknown()).optional()
     }).optional()
   }).optional(),
-  results: z99.array(z99.unknown()).nullish()
+  results: z100.array(z100.unknown()).nullish()
 });
-var SarifLogSchema = z99.object({
-  version: z99.string().optional(),
-  runs: z99.array(z99.unknown()).optional()
+var SarifLogSchema = z100.object({
+  version: z100.string().optional(),
+  runs: z100.array(z100.unknown()).optional()
 });
 var UNMAPPED_LEVEL_SEVERITY = "high";
 var MAX_MESSAGE_LENGTH = 2e3;
@@ -46731,18 +46873,18 @@ async function executeSecurityScan(input) {
 }
 
 // src/security/osv-lookup.ts
-import { z as z100 } from "zod";
+import { z as z101 } from "zod";
 var logger44 = createLogger({ component: "osv-lookup" });
 var OSV_API_URL = "https://api.osv.dev/v1/query";
 var DEFAULT_TIMEOUT_MS4 = NETWORK_FETCH_TIMEOUT_MS;
-var OsvVulnerabilitySchema = z100.object({
-  id: z100.string(),
-  summary: z100.string().optional(),
-  severity: z100.enum(["CRITICAL", "HIGH", "MODERATE", "LOW", "UNKNOWN"]).optional(),
-  aliases: z100.array(z100.string()).default([]),
-  affectedVersions: z100.string().optional(),
-  fixedVersion: z100.string().optional(),
-  url: z100.string().optional()
+var OsvVulnerabilitySchema = z101.object({
+  id: z101.string(),
+  summary: z101.string().optional(),
+  severity: z101.enum(["CRITICAL", "HIGH", "MODERATE", "LOW", "UNKNOWN"]).optional(),
+  aliases: z101.array(z101.string()).default([]),
+  affectedVersions: z101.string().optional(),
+  fixedVersion: z101.string().optional(),
+  url: z101.string().optional()
 });
 var DEFAULT_OSV_CONFIG = {
   timeoutMs: DEFAULT_TIMEOUT_MS4
@@ -47495,7 +47637,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-YWUJNA4A.js");
+        const { executeVoting } = await import("./consensus-vote-OL7DLZNL.js");
         const votingResult = await executeVoting(
           {
             proposal: buildVoteProposal(plan, research),
@@ -48204,7 +48346,7 @@ ${FINDINGS_FORMAT_INSTRUCTIONS}
 }
 
 // src/mcp/tools/pr-review-tool.ts
-import { z as z102 } from "zod";
+import { z as z103 } from "zod";
 import { randomUUID as randomUUID13 } from "node:crypto";
 
 // src/audit/reviewed-diff-hash.ts
@@ -48240,17 +48382,17 @@ import { dirname as dirname3, isAbsolute, join as join11, resolve as resolve12 }
 
 // src/audit/pr-review-record.ts
 import * as crypto3 from "node:crypto";
-import { z as z101 } from "zod";
-var PrReviewVerdictSchema = z101.enum(["approve", "request_changes", "abstain"]);
-var PrReviewVoteCountsSchema = z101.object({
-  approve: z101.number().int().nonnegative(),
-  request_changes: z101.number().int().nonnegative(),
-  abstain: z101.number().int().nonnegative(),
-  error: z101.number().int().nonnegative(),
-  total: z101.number().int().nonnegative()
+import { z as z102 } from "zod";
+var PrReviewVerdictSchema = z102.enum(["approve", "request_changes", "abstain"]);
+var PrReviewVoteCountsSchema = z102.object({
+  approve: z102.number().int().nonnegative(),
+  request_changes: z102.number().int().nonnegative(),
+  abstain: z102.number().int().nonnegative(),
+  error: z102.number().int().nonnegative(),
+  total: z102.number().int().nonnegative()
 }).strict();
-var PrReviewDiffSourceSchema = z101.enum(["canonical-git", "caller-supplied"]);
-var PrReviewDiffProvenanceSchema = z101.object({
+var PrReviewDiffSourceSchema = z102.enum(["canonical-git", "caller-supplied"]);
+var PrReviewDiffProvenanceSchema = z102.object({
   /** How the reviewed diff was obtained. */
   source: PrReviewDiffSourceSchema,
   /**
@@ -48262,9 +48404,9 @@ var PrReviewDiffProvenanceSchema = z101.object({
    * per-file attribution is unavailable. `false` means "a diff, but the packer
    * saw it as one undifferentiated blob".
    */
-  fileBoundaries: z101.boolean()
+  fileBoundaries: z102.boolean()
 }).strict();
-var PrReviewSanitizationSchema = z101.object({
+var PrReviewSanitizationSchema = z102.object({
   /**
    * The canonical hash (same {@link computeReviewedDiffHash} form) of the
    * once-sanitized FULL diff. Equal to the record's `reviewedDiffHash` exactly
@@ -48282,14 +48424,14 @@ var PrReviewSanitizationSchema = z101.object({
    * not tell an auditor WHICH one moved it. This field isolates the
    * sanitization gap, which is the one `reviewedDiffHash` alone cannot show.
    */
-  sanitizedDiffHash: z101.string().length(64),
+  sanitizedDiffHash: z102.string().length(64),
   /**
    * HTML comments the middleware stripped before dispatch. Non-zero with an
    * EQUAL `sanitizedDiffHash` is not a contradiction: the counter is over the
    * whole args object, the hash only over `prDiff`, so a comment stripped from
    * a sibling field increments one without moving the other.
    */
-  commentsRemoved: z101.number().int().nonnegative(),
+  commentsRemoved: z102.number().int().nonnegative(),
   /**
    * How many FIELDS the sanitizer changed at all.
    *
@@ -48304,7 +48446,7 @@ var PrReviewSanitizationSchema = z101.object({
    * `fieldsModified === 0` is therefore the ONLY state that licenses "the
    * sanitizer removed nothing".
    */
-  fieldsModified: z101.number().int().nonnegative(),
+  fieldsModified: z102.number().int().nonnegative(),
   /**
    * XML-like conversation-structure tags the sanitizer removed.
    *
@@ -48315,38 +48457,38 @@ var PrReviewSanitizationSchema = z101.object({
    * removal was routine. That is the reassurance an attacker wants, and it
    * costs them only an HTML comment.
    */
-  tagsRemoved: z101.number().int().nonnegative()
+  tagsRemoved: z102.number().int().nonnegative()
 }).strict();
-var PrReviewBudgetSourceSchema = z101.enum(["registry", "binding-cap-fallback"]);
-var PrReviewPanelCoverageSchema = z101.object({
+var PrReviewBudgetSourceSchema = z102.enum(["registry", "binding-cap-fallback"]);
+var PrReviewPanelCoverageSchema = z102.object({
   /** `'full'` — the panel was sent the whole diff; `'partial'` — a packed subset. */
-  panelRead: z101.enum(["full", "partial"]),
+  panelRead: z102.enum(["full", "partial"]),
   /** Files whose full diff the panel actually reviewed. */
-  reviewedFiles: z101.number().int().nonnegative(),
+  reviewedFiles: z102.number().int().nonnegative(),
   /** Files in the original diff. */
-  totalFiles: z101.number().int().nonnegative(),
+  totalFiles: z102.number().int().nonnegative(),
   /**
    * EVERY path the panel did not fully review — the complete list, never a
    * prefix of it. The summary stamp lists at most a few of these and says
    * `N dropped (k listed)`; this field is where the rest live.
    */
-  droppedFiles: z101.array(z101.string()),
+  droppedFiles: z102.array(z102.string()),
   /** UTF-8 bytes of the diff text the panel actually read. */
-  reviewedBytes: z101.number().int().nonnegative(),
+  reviewedBytes: z102.number().int().nonnegative(),
   /** UTF-8 bytes of the input diff. */
-  totalBytes: z101.number().int().nonnegative(),
+  totalBytes: z102.number().int().nonnegative(),
   /** Where the panel-read budget came from. */
   budgetSource: PrReviewBudgetSourceSchema,
   /** The budget derivation (registry) or the fallback reason, verbatim. */
-  budgetDetail: z101.string()
+  budgetDetail: z102.string()
 }).strict();
-var PrReviewBindingBoundsSchema = z101.object({
+var PrReviewBindingBoundsSchema = z102.object({
   /** `'full'` — the hash covers every byte; `'prefix'` — only the first `boundBytes`. */
-  kind: z101.enum(["full", "prefix"]),
+  kind: z102.enum(["full", "prefix"]),
   /** UTF-8 bytes the hash binds: `min(totalBytes, MAX_REVIEWED_DIFF_BYTES)`. */
-  boundBytes: z101.number().int().nonnegative()
+  boundBytes: z102.number().int().nonnegative()
 }).strict();
-var PrReviewRecordSchema = z101.object({
+var PrReviewRecordSchema = z102.object({
   /**
    * Schema version. '1.1' was the Option-C binding (#3831): the record binds to
    * `{prNumber, baseSha, reviewedDiffHash}` instead of the rejected `headSha`.
@@ -48374,22 +48516,22 @@ var PrReviewRecordSchema = z101.object({
    * in which fields it CAN carry, and reading it as 1.4 is safe because its
    * hash binds the same raw bytes. Tiers are labels; nothing orders them.
    */
-  version: z101.enum(["1.3", "1.4"]),
+  version: z102.enum(["1.3", "1.4"]),
   /**
    * Monotonic sequence number (integer ≥ 0). Assigned as (max existing
    * sequence)+1 at write time. Sorted, the set of sequences must cover
    * 0..maxSeq with no gap (omission detection); DUPLICATE sequences are a
    * benign concurrent-fork signal, not tampering.
    */
-  sequence: z101.number().int().nonnegative(),
+  sequence: z102.number().int().nonnegative(),
   /** The PR number the review covers. */
-  prNumber: z101.number().int().positive(),
+  prNumber: z102.number().int().positive(),
   /**
    * The 40-hex BASE commit SHA the reviewed diff was computed against (the
    * `<base>..<head>` range base). Part of the Option-C binding so the gate knows
    * which range to recompute {@link reviewedDiffHash} over.
    */
-  baseSha: z101.string().regex(/^[0-9a-f]{40}$/, "baseSha must be a 40-char lowercase hex commit sha"),
+  baseSha: z102.string().regex(/^[0-9a-f]{40}$/, "baseSha must be a 40-char lowercase hex commit sha"),
   /**
    * DIFF-BINDING (Option-C, #3831): sha256 of the canonical reviewed diff bytes
    * (see `audit/reviewed-diff-hash.ts` — pinned `git diff` invocation + 50k
@@ -48398,9 +48540,9 @@ var PrReviewRecordSchema = z101.object({
    * byte-identical to what the voters saw. Covered by the self-hash below, so it
    * cannot be edited to claim a different reviewed diff.
    */
-  reviewedDiffHash: z101.string().length(64),
+  reviewedDiffHash: z102.string().length(64),
   /** ISO-8601 timestamp the review was recorded. */
-  recordedAt: z101.string().min(1),
+  recordedAt: z102.string().min(1),
   /** The resolved aggregate verdict. */
   verdict: PrReviewVerdictSchema,
   /**
@@ -48408,13 +48550,13 @@ var PrReviewRecordSchema = z101.object({
    * `request_changes` with `verified: true` is a strict blocker; covered by the
    * hash so it cannot be flipped without detection.
    */
-  verified: z101.boolean(),
+  verified: z102.boolean(),
   /** Per-decision voter tally from the pr_review aggregate. */
   voteCounts: PrReviewVoteCountsSchema,
   /** Truncated human-readable review summary for the reviewer record. */
-  summary: z101.string(),
+  summary: z102.string(),
   /** Optional correlation/decision id linking to the cost rollup / trace. */
-  correlationId: z101.string().min(1).optional(),
+  correlationId: z102.string().min(1).optional(),
   /**
    * What this record was DERIVED FROM (#4459). OPTIONAL by necessity: the
    * schema is `.strict()`, so a required field would reject every record
@@ -48449,9 +48591,9 @@ var PrReviewRecordSchema = z101.object({
    * Retained for audit texture but NOT covered by `hash` and NOT verified —
    * the record-set model is position-independent (mirrors #3927).
    */
-  previousHash: z101.string().length(64).optional(),
+  previousHash: z102.string().length(64).optional(),
   /** SHA-256 over every field above EXCEPT `previousHash` (and except `hash`). */
-  hash: z101.string().length(64)
+  hash: z102.string().length(64)
 }).strict();
 function projectPanelCoverage(c) {
   return {
@@ -49201,19 +49343,19 @@ var MAX_REPO_CONTEXT_LENGTH = 2e3;
 var MAX_TITLE_LENGTH = 500;
 var MAX_DESCRIPTION_LENGTH = 1e4;
 var PR_REVIEW_ASYNC_HINT = "A pr_review run fans out to 5 live LLM voters and can exceed the synchronous MCP request timeout. Retry with `dispatch: 'async'` to get a jobId immediately, then poll get_job_result({ jobId }) for the result.";
-var PrReviewInputSchema = z102.object({
-  prTitle: z102.string().min(1).max(MAX_TITLE_LENGTH).describe("PR title"),
-  prDescription: z102.string().max(MAX_DESCRIPTION_LENGTH).optional().describe("PR body / description"),
-  prDiff: z102.string().min(1).max(MAX_DIFF_INPUT_LENGTH).refine(looksLikeUnifiedDiff, {
+var PrReviewInputSchema = z103.object({
+  prTitle: z103.string().min(1).max(MAX_TITLE_LENGTH).describe("PR title"),
+  prDescription: z103.string().max(MAX_DESCRIPTION_LENGTH).optional().describe("PR body / description"),
+  prDiff: z103.string().min(1).max(MAX_DIFF_INPUT_LENGTH).refine(looksLikeUnifiedDiff, {
     message: "prDiff must be a unified diff (expected a `diff --git`, `---`/`+++`, or `@@ \u2026 @@` line). Prose descriptions of a change are rejected: a review of a summary is not a review of the code, and would be recorded as though it were (#4451)."
   }).describe(
     `Unified diff text (max ${String(MAX_DIFF_INPUT_LENGTH)} chars). REQUIRED SHAPE (#4451): must contain a \`diff --git\` header, an \`@@ \u2026 @@\` hunk header backed by +/- lines, or a \`---\`/\`+++\` header pair \u2014 a prose summary of the change is REJECTED, because reviewing a summary is not reviewing the code and would be recorded as though it were. (Stated here because Zod refinements do not survive JSON-schema generation, so this constraint is otherwise invisible to clients.) No need to truncate before calling: the panel reads the whole diff whenever it fits the voters' context windows (#6003); a diff larger than that is security-prioritized and PARTIALLY reviewed (lowest-priority whole files dropped; a partial panel read can block but never verified-approve). Separately, the audit record's hash binds only the first ${String(MAX_DIFF_LENGTH)} UTF-8 bytes; the response \`coverage\` and the record summary state both what the panel read and what the hash binds.`
   ),
-  repoContext: z102.string().max(MAX_REPO_CONTEXT_LENGTH).optional().describe(
+  repoContext: z103.string().max(MAX_REPO_CONTEXT_LENGTH).optional().describe(
     `Optional one-paragraph repo context (architecture, conventions; max ${String(MAX_REPO_CONTEXT_LENGTH)} chars; trim before calling)`
   ),
-  baseRef: z102.string().max(200).optional().describe("Base branch ref (e.g. main)"),
-  headRef: z102.string().max(200).optional().describe("Head branch ref"),
+  baseRef: z103.string().max(200).optional().describe("Base branch ref (e.g. main)"),
+  headRef: z103.string().max(200).optional().describe("Head branch ref"),
   /**
    * Option-C audit binding (#4031). When BOTH `prNumber` and `baseSha` are
    * supplied AND the review is live (not simulated), pr_review persists an
@@ -49229,14 +49371,14 @@ var PrReviewInputSchema = z102.object({
    * the PR opened and drifts as main advances), so pass the merge-base as
    * `baseSha` or the record will not match on an aged branch (#5692).
    */
-  prNumber: z102.number().int().positive().optional().describe("PR number \u2014 with baseSha, enables Option-C audit-record persistence (#4031)"),
-  baseSha: z102.string().regex(/^[0-9a-f]{40}$/, "baseSha must be a 40-char lowercase hex commit sha").optional().describe(
+  prNumber: z103.number().int().positive().optional().describe("PR number \u2014 with baseSha, enables Option-C audit-record persistence (#4031)"),
+  baseSha: z103.string().regex(/^[0-9a-f]{40}$/, "baseSha must be a 40-char lowercase hex commit sha").optional().describe(
     "40-hex base commit sha the reviewed diff was computed from \u2014 pass `git merge-base origin/<base> <head>`, the base the gate recomputes (Option-C binding, #4031, #5692)"
   ),
-  repoPath: z102.string().max(1024).optional().describe(
+  repoPath: z103.string().max(1024).optional().describe(
     "Repo root path for persisting the governance pr-review record (overrides cwd auto-detection). Must contain a .git ancestor \u2014 relative paths are resolved against cwd; ignored (falls back to cwd auto-detection) if it is not a real repo root. Env NEXUS_PR_REVIEW_RECORDS_PATH still takes precedence and is unrestricted."
   ),
-  simulate: z102.boolean().default(false).describe("Use simulated voters (testing only; never ship live with this true)"),
+  simulate: z103.boolean().default(false).describe("Use simulated voters (testing only; never ship live with this true)"),
   /**
    * Error policy (#4132). `standard` (default) keeps the pre-#4132 aggregation:
    * an errored voter is simply excluded from the panel. `absolute_quorum` gates
@@ -49248,7 +49390,7 @@ var PrReviewInputSchema = z102.object({
    * verified approve. A genuine `request_changes` blocker still wins (Tiers 1-2
    * run first).
    */
-  errorPolicy: z102.enum(["standard", "absolute_quorum"]).default("standard").describe(
+  errorPolicy: z103.enum(["standard", "absolute_quorum"]).default("standard").describe(
     "Error policy (#4132). 'standard' (default): errored voters excluded. 'absolute_quorum': any errored voter \u2014 esp. the contrarian \u2014 degrades a would-be approve to a recoverable abstain (verified:false); never manufactures a verified approve from an induced error."
   ),
   // #6123: same field as consensus_vote — the panel judges the caller's project.
@@ -49473,27 +49615,27 @@ function registerPrReviewTool(server, deps) {
 }
 
 // src/mcp/tools/survey-oss-landscape.ts
-import { z as z103 } from "zod";
-var SurveyOssLandscapeInputSchema = z103.object({
-  query: z103.string().min(1).max(200).describe('Free-text search query, e.g. "cargo nextest replacement" or "OSS SBOM tools"'),
-  maxResults: z103.number().int().min(1).max(50).optional().default(10).describe("Maximum candidates to return (1-50; default 10)"),
-  minStars: z103.number().int().min(0).optional().default(0).describe("Minimum star count to include (default 0; useful for filtering noise)"),
-  language: z103.string().max(50).optional().describe('GitHub language filter, e.g. "rust" or "typescript"')
+import { z as z104 } from "zod";
+var SurveyOssLandscapeInputSchema = z104.object({
+  query: z104.string().min(1).max(200).describe('Free-text search query, e.g. "cargo nextest replacement" or "OSS SBOM tools"'),
+  maxResults: z104.number().int().min(1).max(50).optional().default(10).describe("Maximum candidates to return (1-50; default 10)"),
+  minStars: z104.number().int().min(0).optional().default(0).describe("Minimum star count to include (default 0; useful for filtering noise)"),
+  language: z104.string().max(50).optional().describe('GitHub language filter, e.g. "rust" or "typescript"')
 });
-var GitHubRepoSchema = z103.object({
-  full_name: z103.string().optional(),
-  html_url: z103.string().optional(),
-  description: z103.string().nullable().optional(),
-  stargazers_count: z103.number().optional(),
-  pushed_at: z103.string().nullable().optional(),
-  language: z103.string().nullable().optional(),
-  license: z103.object({
-    spdx_id: z103.string().nullable().optional()
+var GitHubRepoSchema = z104.object({
+  full_name: z104.string().optional(),
+  html_url: z104.string().optional(),
+  description: z104.string().nullable().optional(),
+  stargazers_count: z104.number().optional(),
+  pushed_at: z104.string().nullable().optional(),
+  language: z104.string().nullable().optional(),
+  license: z104.object({
+    spdx_id: z104.string().nullable().optional()
   }).nullable().optional()
 });
-var GitHubSearchResponseSchema = z103.object({
-  total_count: z103.number().optional(),
-  items: z103.array(GitHubRepoSchema).optional()
+var GitHubSearchResponseSchema = z104.object({
+  total_count: z104.number().optional(),
+  items: z104.array(GitHubRepoSchema).optional()
 });
 var GITHUB_SEARCH_BASE = "https://api.github.com/search/repositories";
 function buildGithubQuery(input) {
@@ -49620,11 +49762,11 @@ function createSurveyHandler(deps) {
   };
 }
 var SURVEY_OUTPUT_SCHEMA = {
-  query: z103.string(),
-  totalFound: z103.number(),
-  candidates: z103.array(z103.unknown()),
-  sourcesQueried: z103.array(z103.string()),
-  sourcesFailed: z103.array(z103.string())
+  query: z104.string(),
+  totalFound: z104.number(),
+  candidates: z104.array(z104.unknown()),
+  sourcesQueried: z104.array(z104.string()),
+  sourcesFailed: z104.array(z104.string())
 };
 var SURVEY_DESCRIPTION = 'Transient OSS project search. Returns a ranked list of GitHub repositories with license, last-commit, star-count, and one-line description. Does NOT persist to the research registry \u2014 use `research_add_source` for that. Best for one-off engineering decisions like "what tools exist in this space?".';
 function registerSurveyOssLandscapeTool(server, deps) {
@@ -49653,7 +49795,7 @@ function registerSurveyOssLandscapeTool(server, deps) {
 }
 
 // src/mcp/tools/vendor-publishing-audit.ts
-import { z as z104 } from "zod";
+import { z as z105 } from "zod";
 
 // src/mcp/tools/vendor-publishing-seed.ts
 var VENDOR_PUBLISHING_SEED = {
@@ -49726,8 +49868,8 @@ function listKnownVendors() {
 }
 
 // src/mcp/tools/vendor-publishing-audit.ts
-var VendorPublishingAuditInputSchema = z104.object({
-  vendor: z104.string().min(1).max(50).toLowerCase().describe('Vendor identifier, lowercase. e.g. "ubuntu", "debian", "fedora"')
+var VendorPublishingAuditInputSchema = z105.object({
+  vendor: z105.string().min(1).max(50).toLowerCase().describe('Vendor identifier, lowercase. e.g. "ubuntu", "debian", "fedora"')
 });
 function lookupVendor(vendor) {
   if (isKnownVendor(vendor)) {
@@ -49759,20 +49901,20 @@ function createVendorPublishingAuditHandler(deps) {
   };
 }
 var VENDOR_PUBLISHING_OUTPUT_SCHEMA = {
-  vendor: z104.string(),
-  known: z104.boolean(),
+  vendor: z105.string(),
+  known: z105.boolean(),
   // Fields below populate when known=true; permissive optional for known=false.
-  sha256SumsUrlPattern: z104.string().optional(),
-  sha256SumsSignatureUrlPattern: z104.string().optional(),
-  signaturePattern: z104.string().optional(),
-  gpgKeys: z104.array(z104.unknown()).optional(),
-  releaseCadence: z104.string().optional(),
-  keyRotationNotes: z104.string().optional(),
-  vendorDocUrl: z104.string().optional(),
-  citedAt: z104.string().optional(),
+  sha256SumsUrlPattern: z105.string().optional(),
+  sha256SumsSignatureUrlPattern: z105.string().optional(),
+  signaturePattern: z105.string().optional(),
+  gpgKeys: z105.array(z105.unknown()).optional(),
+  releaseCadence: z105.string().optional(),
+  keyRotationNotes: z105.string().optional(),
+  vendorDocUrl: z105.string().optional(),
+  citedAt: z105.string().optional(),
   // Fields below populate when known=false.
-  message: z104.string().optional(),
-  knownVendors: z104.array(z104.string()).optional()
+  message: z105.string().optional(),
+  knownVendors: z105.array(z105.string()).optional()
 };
 var VENDOR_PUBLISHING_DESCRIPTION = "Look up a vendor's published-artifact signing infrastructure: GPG key fingerprints, SHA256SUMS URL pattern, signature shape (clearsigned / detached / detached-on-iso), release cadence, key rotation notes, and the vendor doc citation. Static lookup against a curated seed dataset; the vendor doc URL is the authoritative source. Returns `{known: false, knownVendors: [...]}` for vendors without a seed entry. v1 covers ubuntu, debian, fedora.";
 function registerVendorPublishingAuditTool(server, deps) {
@@ -49801,17 +49943,17 @@ function registerVendorPublishingAuditTool(server, deps) {
 }
 
 // src/mcp/tools/compare-data-feeds.ts
-import { z as z105 } from "zod";
+import { z as z106 } from "zod";
 import * as path6 from "node:path";
 import * as fs7 from "node:fs";
 import * as yaml4 from "yaml";
-var CompareDataFeedsInputSchema = z105.object({
-  feedAPath: z105.string().min(1).max(1e3).describe("Filesystem path to feed A (YAML or JSON, auto-detected by extension)"),
-  feedBPath: z105.string().min(1).max(1e3).describe("Filesystem path to feed B"),
-  keyPath: z105.string().min(1).max(200).describe(
+var CompareDataFeedsInputSchema = z106.object({
+  feedAPath: z106.string().min(1).max(1e3).describe("Filesystem path to feed A (YAML or JSON, auto-detected by extension)"),
+  feedBPath: z106.string().min(1).max(1e3).describe("Filesystem path to feed B"),
+  keyPath: z106.string().min(1).max(200).describe(
     'Dotted path to the entry key, e.g. "id" or "name". Each entry must have this field.'
   ),
-  compareFields: z105.array(z105.string().min(1).max(200)).max(20).optional().describe(
+  compareFields: z106.array(z106.string().min(1).max(200)).max(20).optional().describe(
     'Optional dotted field paths to compare across matched entries (e.g. ["license", "sha256"])'
   )
 });
@@ -49995,24 +50137,24 @@ function createCompareDataFeedsHandler(deps) {
   };
 }
 var COMPARE_OUTPUT_SCHEMA = {
-  feedAPath: z105.string(),
-  feedBPath: z105.string(),
-  keyPath: z105.string(),
-  counts: z105.object({
-    entriesInA: z105.number(),
-    entriesInB: z105.number(),
-    onlyInA: z105.number(),
-    onlyInB: z105.number(),
-    inBoth: z105.number(),
-    fieldDifferences: z105.number()
+  feedAPath: z106.string(),
+  feedBPath: z106.string(),
+  keyPath: z106.string(),
+  counts: z106.object({
+    entriesInA: z106.number(),
+    entriesInB: z106.number(),
+    onlyInA: z106.number(),
+    onlyInB: z106.number(),
+    inBoth: z106.number(),
+    fieldDifferences: z106.number()
   }),
-  coverage: z105.object({
-    onlyInA: z105.array(z105.string()),
-    onlyInB: z105.array(z105.string()),
-    inBoth: z105.array(z105.string())
+  coverage: z106.object({
+    onlyInA: z106.array(z106.string()),
+    onlyInB: z106.array(z106.string()),
+    inBoth: z106.array(z106.string())
   }),
-  fieldDifferences: z105.array(z105.unknown()),
-  summary: z105.string()
+  fieldDifferences: z106.array(z106.unknown()),
+  summary: z106.string()
 };
 var COMPARE_DESCRIPTION = "Diff two upstream data feeds (YAML or JSON files) along coverage and per-field axes. Returns which entries exist in A, B, both, plus optional field-level diffs across matched entries. v1 takes file paths only (no URL fetch \u2014 that needs an SSRF design pass). Both feeds must be a top-level array OR a top-level object with exactly one array field.";
 function registerCompareDataFeedsTool(server, deps) {
@@ -50041,9 +50183,9 @@ function registerCompareDataFeedsTool(server, deps) {
 }
 
 // src/mcp/tools/query-task-state-tool.ts
-import { z as z106 } from "zod";
-var QueryTaskStateInputSchema = z106.object({
-  taskId: z106.string().min(1).max(128).describe("Task ID whose structured state log should be read")
+import { z as z107 } from "zod";
+var QueryTaskStateInputSchema = z107.object({
+  taskId: z107.string().min(1).max(128).describe("Task ID whose structured state log should be read")
 });
 function queryTaskStateHandler(args, ctx) {
   const parsed = QueryTaskStateInputSchema.safeParse(args);
@@ -50078,7 +50220,7 @@ function queryTaskStateHandler(args, ctx) {
 function registerQueryTaskStateTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "query_task_state" });
   const toolSchema = {
-    taskId: z106.string().min(1).max(128).describe("Task ID whose structured state log should be read")
+    taskId: z107.string().min(1).max(128).describe("Task ID whose structured state log should be read")
   };
   const description = "Read the structured state log for a task ID and return the current snapshot. Includes Magentic-One Task Ledger (facts/guesses/openQuestions) and Progress Ledger (per-step reflections with suggestedAction) when orchestrators have written them. Structured state is only written when NEXUS_TASK_STATE_ENABLED=1 was set during the orchestrate invocation.";
   const secureHandler = createSecureHandler(queryTaskStateHandler, {
@@ -50100,28 +50242,28 @@ function registerQueryTaskStateTool(server, deps) {
 }
 
 // src/mcp/tools/ci-health-check-tool.ts
-import { z as z109 } from "zod";
+import { z as z110 } from "zod";
 
 // src/mcp/tools/ci-health-log.ts
 import { appendFileSync as appendFileSync4, existsSync as existsSync11, readFileSync as readFileSync10, statSync as statSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import { z as z108 } from "zod";
+import { z as z109 } from "zod";
 
 // src/mcp/tools/ci-health-types.ts
-import { z as z107 } from "zod";
-var CiHealthStatusSchema = z107.enum(["healthy", "degraded", "outage", "unknown"]);
+import { z as z108 } from "zod";
+var CiHealthStatusSchema = z108.enum(["healthy", "degraded", "outage", "unknown"]);
 
 // src/mcp/tools/ci-health-log.ts
 var logger47 = createLogger({ component: "ci-health-log" });
-var CiHealthEventSchema = z108.object({
-  v: z108.literal(1),
-  ts: z108.iso.datetime(),
+var CiHealthEventSchema = z109.object({
+  v: z109.literal(1),
+  ts: z109.iso.datetime(),
   status: CiHealthStatusSchema,
-  repo: z108.string().optional(),
-  signals: z108.array(
-    z108.object({
-      source: z108.enum(["github-status", "repo-activity-window"]),
+  repo: z109.string().optional(),
+  signals: z109.array(
+    z109.object({
+      source: z109.enum(["github-status", "repo-activity-window"]),
       status: CiHealthStatusSchema,
-      evidence: z108.string()
+      evidence: z109.string()
     })
   )
 });
@@ -50201,17 +50343,17 @@ function eventFromCheck(params) {
 }
 
 // src/mcp/tools/ci-health-check-tool.ts
-var CiHealthCheckInputSchema = z109.object({
+var CiHealthCheckInputSchema = z110.object({
   /**
    * Repo to check for the recent-runs activity signal (in `owner/repo` form).
    * Optional — when omitted, only the status-page signal is consulted.
    */
-  repo: z109.string().regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/, "Must be owner/repo form").optional().describe("GitHub repo (owner/repo) to check for recent CI activity. Optional."),
+  repo: z110.string().regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/, "Must be owner/repo form").optional().describe("GitHub repo (owner/repo) to check for recent CI activity. Optional."),
   /**
    * How far back to look for recent-runs activity (minutes). Default 30 —
    * matches the typical wedge-detection window from the #3070 / #3076 outages.
    */
-  activityWindowMinutes: z109.number().int().min(5).max(180).default(30).describe("Recent-runs lookback window in minutes (5-180; default 30).")
+  activityWindowMinutes: z110.number().int().min(5).max(180).default(30).describe("Recent-runs lookback window in minutes (5-180; default 30).")
 });
 var STATUS_PAGE_URL = "https://www.githubstatus.com/api/v2/components.json";
 function mapStatusPageStatus(raw) {
@@ -50344,8 +50486,8 @@ var DESCRIPTION = "Check CI infrastructure health before triggering / polling ru
 function registerCiHealthCheckTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "ci_health_check" });
   const toolSchema = {
-    repo: z109.string().regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/, "Must be owner/repo form").optional().describe("GitHub repo (owner/repo) to check for recent CI activity. Optional."),
-    activityWindowMinutes: z109.number().int().min(5).max(180).optional().describe("Recent-runs lookback window in minutes (5-180; default 30).")
+    repo: z110.string().regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/, "Must be owner/repo form").optional().describe("GitHub repo (owner/repo) to check for recent CI activity. Optional."),
+    activityWindowMinutes: z110.number().int().min(5).max(180).optional().describe("Recent-runs lookback window in minutes (5-180; default 30).")
   };
   const secureHandler = createSecureHandler((args) => ciHealthCheckHandler(args, logger57), {
     toolName: "ci_health_check",
@@ -50371,18 +50513,18 @@ function registerCiHealthCheckTool(server, deps) {
 
 // src/mcp/tools/quality-gate-tool.ts
 import { statSync as statSync3 } from "node:fs";
-import { z as z110 } from "zod";
-var QualityCheckSchema = z110.enum(["typecheck", "lint", "tests", "build", "security"]);
+import { z as z111 } from "zod";
+var QualityCheckSchema = z111.enum(["typecheck", "lint", "tests", "build", "security"]);
 var DEFAULT_CHECKS = ["typecheck", "lint", "tests"];
-var RunQualityGateInputSchema = z110.object({
+var RunQualityGateInputSchema = z111.object({
   /** Project directory to run checks against. Must resolve inside the repo/cwd root. */
-  projectDir: z110.string().optional().describe(
+  projectDir: z111.string().optional().describe(
     "Project directory to run checks against (default: cwd). Must stay inside the repo root."
   ),
   /** Which allowlisted checks to run. */
-  checks: z110.array(QualityCheckSchema).nonempty().default([...DEFAULT_CHECKS]).describe("Allowlisted checks to run (default: ['typecheck','lint','tests'])."),
+  checks: z111.array(QualityCheckSchema).nonempty().default([...DEFAULT_CHECKS]).describe("Allowlisted checks to run (default: ['typecheck','lint','tests'])."),
   /** 1-based iteration counter, forwarded to the engine for feedback context. */
-  iteration: z110.number().int().min(1).default(1).describe("1-based iteration number (default 1).")
+  iteration: z111.number().int().min(1).default(1).describe("1-based iteration number (default 1).")
 });
 function validateProjectDir(raw) {
   const candidate = raw ?? process.cwd();
@@ -50457,11 +50599,11 @@ var DESCRIPTION2 = "Run the QA quality gate (#1684 engine) against a project dir
 function registerRunQualityGateTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "run_quality_gate" });
   const toolSchema = {
-    projectDir: z110.string().optional().describe(
+    projectDir: z111.string().optional().describe(
       "Project directory to run checks against (default: cwd). Must stay inside the repo root."
     ),
-    checks: z110.array(QualityCheckSchema).nonempty().optional().describe("Allowlisted checks to run (default: ['typecheck','lint','tests'])."),
-    iteration: z110.number().int().min(1).optional().describe("1-based iteration number (default 1).")
+    checks: z111.array(QualityCheckSchema).nonempty().optional().describe("Allowlisted checks to run (default: ['typecheck','lint','tests'])."),
+    iteration: z111.number().int().min(1).optional().describe("1-based iteration number (default 1).")
   };
   const secureHandler = createSecureHandler(
     (args) => runQualityGateHandler(args, logger57),
@@ -50491,9 +50633,9 @@ function registerRunQualityGateTool(server, deps) {
 // src/mcp/tools/verify-audit-chain-tool.ts
 import * as fs8 from "node:fs/promises";
 import * as path7 from "node:path";
-import { z as z111 } from "zod";
-var VerifyAuditChainInputSchema = z111.object({
-  logDir: z111.string().min(1).max(512).describe(
+import { z as z112 } from "zod";
+var VerifyAuditChainInputSchema = z112.object({
+  logDir: z112.string().min(1).max(512).describe(
     "Filesystem path to the FileAuditStorage log directory. Tool reads all `audit-*.jsonl` files in lexicographic order and verifies the combined chain."
   )
 });
@@ -50583,7 +50725,7 @@ async function handler2(args, ctx) {
 function registerVerifyAuditChainTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "verify_audit_chain" });
   const toolSchema = {
-    logDir: z111.string().min(1).max(512).describe(
+    logDir: z112.string().min(1).max(512).describe(
       "Filesystem path to the FileAuditStorage log directory. Tool reads all `audit-*.jsonl` files and verifies the combined hash chain."
     )
   };
@@ -50607,7 +50749,7 @@ function registerVerifyAuditChainTool(server, deps) {
 }
 
 // src/mcp/tools/suggest-research-tasks-tool.ts
-import { z as z112 } from "zod";
+import { z as z113 } from "zod";
 var SUGGEST_RESEARCH_TASKS_NOTE = "Suggestions derived from external research (untrusted); review before acting \u2014 nothing was executed or filed.";
 var RESEARCH_BUDGET_MS = 2e4;
 var RESEARCH_TIMED_OUT = /* @__PURE__ */ Symbol("research-budget-exceeded");
@@ -50624,11 +50766,11 @@ async function withResearchBudget(p, ms) {
     if (timer !== void 0) clearTimeout(timer);
   }
 }
-var SuggestResearchTasksInputSchema = z112.object({
-  topic: z112.string().optional().describe("Topic filter passed to research_discover. Optional."),
-  qualityThreshold: z112.number().min(0).max(10).optional().describe("Minimum quality score (0-10) a discovery must meet to be suggested. Optional."),
-  maxTriggers: z112.number().int().min(1).optional().describe("Max number of candidate tasks to return (>=1). Optional."),
-  existingTaskIds: z112.array(z112.string()).optional().describe("Known task IDs to skip (dedup). Optional.")
+var SuggestResearchTasksInputSchema = z113.object({
+  topic: z113.string().optional().describe("Topic filter passed to research_discover. Optional."),
+  qualityThreshold: z113.number().min(0).max(10).optional().describe("Minimum quality score (0-10) a discovery must meet to be suggested. Optional."),
+  maxTriggers: z113.number().int().min(1).optional().describe("Max number of candidate tasks to return (>=1). Optional."),
+  existingTaskIds: z113.array(z113.string()).optional().describe("Known task IDs to skip (dedup). Optional.")
 });
 function toTriggerConfig(input) {
   return {
@@ -50685,10 +50827,10 @@ var DESCRIPTION3 = "SUGGEST-ONLY: surface candidate pipeline tasks for human/orc
 function registerSuggestResearchTasksTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "suggest_research_tasks" });
   const toolSchema = {
-    topic: z112.string().optional().describe("Topic filter passed to research_discover. Optional."),
-    qualityThreshold: z112.number().min(0).max(10).optional().describe("Minimum quality score (0-10) a discovery must meet to be suggested. Optional."),
-    maxTriggers: z112.number().int().min(1).optional().describe("Max number of candidate tasks to return (>=1). Optional."),
-    existingTaskIds: z112.array(z112.string()).optional().describe("Known task IDs to skip (dedup). Optional.")
+    topic: z113.string().optional().describe("Topic filter passed to research_discover. Optional."),
+    qualityThreshold: z113.number().min(0).max(10).optional().describe("Minimum quality score (0-10) a discovery must meet to be suggested. Optional."),
+    maxTriggers: z113.number().int().min(1).optional().describe("Max number of candidate tasks to return (>=1). Optional."),
+    existingTaskIds: z113.array(z113.string()).optional().describe("Known task IDs to skip (dedup). Optional.")
   };
   const secureHandler = createSecureHandler(
     (args) => suggestResearchTasksHandler(args, logger57),
@@ -50716,7 +50858,7 @@ function registerSuggestResearchTasksTool(server, deps) {
 }
 
 // src/mcp/tools/run-tool.ts
-import { z as z116 } from "zod";
+import { z as z117 } from "zod";
 import { randomUUID as randomUUID17 } from "node:crypto";
 
 // src/orchestration/meta-dispatcher.ts
@@ -51176,7 +51318,7 @@ function createMetaOrchestrator(options) {
 
 // src/orchestration/meta-shadow-selector.ts
 import { appendFileSync as appendFileSync5, existsSync as existsSync12, readFileSync as readFileSync11 } from "node:fs";
-import { z as z113 } from "zod";
+import { z as z114 } from "zod";
 var SHADOW_STRATEGY_ARMS = [
   "single-shot",
   "dev-pipeline",
@@ -51263,19 +51405,19 @@ function createHydratableSelector() {
 var META_OUTCOME_SCHEMA_VERSION = 1;
 var HYDRATE_LOOKBACK_DAYS = 30;
 var HYDRATE_LOOKBACK_MS = HYDRATE_LOOKBACK_DAYS * 24 * 60 * 60 * 1e3;
-var PersistedContextSchema = z113.object({
-  taskComplexity: z113.number(),
-  contextLengthNormalized: z113.number(),
-  isCodeTask: z113.number(),
-  isReasoningTask: z113.number(),
-  budgetUtilization: z113.number(),
-  timePressure: z113.number()
+var PersistedContextSchema = z114.object({
+  taskComplexity: z114.number(),
+  contextLengthNormalized: z114.number(),
+  isCodeTask: z114.number(),
+  isReasoningTask: z114.number(),
+  budgetUtilization: z114.number(),
+  timePressure: z114.number()
 });
-var PersistedMetaOutcomeSchema = z113.object({
-  schema: z113.literal(META_OUTCOME_SCHEMA_VERSION),
-  timestamp: z113.string(),
-  strategy: z113.enum(SHADOW_STRATEGY_ARMS),
-  success: z113.boolean(),
+var PersistedMetaOutcomeSchema = z114.object({
+  schema: z114.literal(META_OUTCOME_SCHEMA_VERSION),
+  timestamp: z114.string(),
+  strategy: z114.enum(SHADOW_STRATEGY_ARMS),
+  success: z114.boolean(),
   context: PersistedContextSchema
 });
 var persistLogger = createLogger({ component: "MetaShadowSelector" });
@@ -51668,7 +51810,7 @@ function evaluateMetaStrategyReadiness(result, config = DEFAULT_META_STRATEGY_RE
 }
 
 // src/mcp/tools/dev-pipeline-tool.ts
-import { z as z114 } from "zod";
+import { z as z115 } from "zod";
 import * as fs10 from "node:fs";
 import * as path9 from "node:path";
 import { randomUUID as randomUUID15 } from "node:crypto";
@@ -51821,36 +51963,36 @@ var DEV_PIPELINE_DRY_RUN_NOTE = "This was a dry run (plan+vote), which always ru
 function dispatchNoteFor(dryRun) {
   return dryRun ? DEV_PIPELINE_DRY_RUN_NOTE : DEV_PIPELINE_ASYNC_HINT;
 }
-var DevPipelineInputSchema = z114.object({
+var DevPipelineInputSchema = z115.object({
   /** Direct task instructions. */
-  task: z114.string().max(1e4).optional().describe("Direct task instructions (what to build)"),
+  task: z115.string().max(1e4).optional().describe("Direct task instructions (what to build)"),
   /** Path to a plan file (.md, .yaml, .txt) to use as input. */
-  planFile: z114.string().max(500).optional().describe("Path to a plan/spec file to use as input"),
+  planFile: z115.string().max(500).optional().describe("Path to a plan/spec file to use as input"),
   /** Whether to run in dry-run mode (plan+vote only, no implementation). */
-  dryRun: z114.boolean().default(false).describe("If true, stop after plan+vote (no implementation)"),
+  dryRun: z115.boolean().default(false).describe("If true, stop after plan+vote (no implementation)"),
   /** Maximum vote iterations before proceeding (default: 3). */
-  maxVoteIterations: z114.number().int().min(1).max(5).default(3).describe("Max plan\u2192vote iterations"),
+  maxVoteIterations: z115.number().int().min(1).max(5).default(3).describe("Max plan\u2192vote iterations"),
   /** Maximum QA iterations per task (default: 3). */
-  maxQaIterations: z114.number().int().min(1).max(5).default(3).describe("Max QA review iterations per task"),
+  maxQaIterations: z115.number().int().min(1).max(5).default(3).describe("Max QA review iterations per task"),
   /** Working directory for the pipeline (default: cwd). Used for security scan and context. */
-  workingDir: z114.string().max(500).optional().describe("Working directory (default: cwd)"),
+  workingDir: z115.string().max(500).optional().describe("Working directory (default: cwd)"),
   /** GitHub issue number to track progress on. Updates posted as comments. */
-  issueNumber: z114.number().int().positive().optional().describe("GitHub issue to post progress to"),
+  issueNumber: z115.number().int().positive().optional().describe("GitHub issue to post progress to"),
   /** GitHub repo (owner/name) for issue tracking. */
-  repo: z114.string().max(200).optional().describe("GitHub repo for issue tracking (e.g., owner/repo)"),
+  repo: z115.string().max(200).optional().describe("GitHub repo for issue tracking (e.g., owner/repo)"),
   /** Task tracking backend: github, gitlab, or json (default: json). */
-  trackerBackend: z114.enum(["github", "gitlab", "json"]).default("json").describe("Task tracking backend for issue creation"),
+  trackerBackend: z115.enum(["github", "gitlab", "json"]).default("json").describe("Task tracking backend for issue creation"),
   /** Labels to apply to created issues. */
-  labels: z114.array(z114.string()).optional().describe("Labels for created issues"),
+  labels: z115.array(z115.string()).optional().describe("Labels for created issues"),
   /** Session ID for checkpoint/resume. Enables crash recovery. */
-  sessionId: z114.string().max(128).regex(/^[a-zA-Z0-9_-]+$/).optional().describe("Session ID for checkpoint/resume (crash recovery)"),
+  sessionId: z115.string().max(128).regex(/^[a-zA-Z0-9_-]+$/).optional().describe("Session ID for checkpoint/resume (crash recovery)"),
   /**
    * TESTS ONLY — when true, voters return random decisions. Must not be used as
    * a fallback when adapters are unavailable; configure an adapter instead. (#2319)
    */
-  simulateVotes: z114.boolean().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)"),
+  simulateVotes: z115.boolean().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)"),
   /** Voting strategy for consensus stages. */
-  votingStrategy: z114.enum([
+  votingStrategy: z115.enum([
     "simple_majority",
     "supermajority",
     "unanimous",
@@ -51859,15 +52001,15 @@ var DevPipelineInputSchema = z114.object({
     "opinion_wise"
   ]).optional().describe("Voting strategy for plan approval (default: higher_order)"),
   /** Use 3 agents instead of 6 for faster voting. */
-  quickMode: z114.boolean().default(false).describe("Use 3 agents instead of 6 for faster consensus voting"),
+  quickMode: z115.boolean().default(false).describe("Use 3 agents instead of 6 for faster consensus voting"),
   /** Maximum execution time per stage in milliseconds (min 30s, max 600s). */
-  timeoutMs: z114.number().int().min(3e4).max(6e5).optional().describe("Max time per stage in ms (30000-600000). Default: varies by stage complexity"),
+  timeoutMs: z115.number().int().min(3e4).max(6e5).optional().describe("Max time per stage in ms (30000-600000). Default: varies by stage complexity"),
   /**
    * Pipeline execution mode — a REAL field on this tool, unrelated to async
    * dispatch. A caller who learned `mode: 'async'` elsewhere gets an error
    * naming `dispatch` rather than the bare enum message (#4968).
    */
-  mode: z114.enum(["autonomous", "harness"], { error: modeEnumErrorNamingDispatch }).default("autonomous").describe(
+  mode: z115.enum(["autonomous", "harness"], { error: modeEnumErrorNamingDispatch }).default("autonomous").describe(
     "'autonomous': full pipeline. 'harness': stops after decompose, returns tasks for caller to implement. (Not the async switch \u2014 that is `dispatch`.)"
   ),
   /**
@@ -51881,11 +52023,11 @@ var DevPipelineInputSchema = z114.object({
    */
   dispatch: dispatchFieldDefaultSync("Ignored for dryRun."),
   /** Local pre-ship quality gate (typecheck/lint/tests) mode (#3356). */
-  qualityGate: z114.enum(["off", "advisory", "blocking"]).default("off").describe(
+  qualityGate: z115.enum(["off", "advisory", "blocking"]).default("off").describe(
     "Pre-ship local quality gate. 'off' (default): skip. 'advisory': run + record feedback, never fail. 'blocking': a red gate fails the pipeline."
   ),
   /** Opt-in per-run token budget — a safety cap for unattended runs (#3395). */
-  maxBudgetTokens: z114.number().int().positive().optional().describe(
+  maxBudgetTokens: z115.number().int().positive().optional().describe(
     "Per-run token ceiling (#3395). When set, expert calls stop (returning failures) once cumulative usage crosses it \u2014 a hard-stop safety cap for unattended/multi-day runs. Omit to disable (default)."
   )
 });
@@ -52113,20 +52255,20 @@ function registerDevPipelineTool(server, deps) {
 }
 
 // src/mcp/tools/pipeline-tool.ts
-import { z as z115 } from "zod";
+import { z as z116 } from "zod";
 import * as fs11 from "node:fs";
 import * as path10 from "node:path";
 import { randomUUID as randomUUID16 } from "node:crypto";
 var PIPELINE_ASYNC_HINT = "A full run_pipeline run can exceed the synchronous MCP request timeout. Retry with `dispatch: 'async'` to get a jobId immediately, then poll get_job_result({ jobId }) for the result.";
-var PipelineInputSchema = z115.object({
+var PipelineInputSchema = z116.object({
   /** The task to execute. */
-  task: z115.string().min(5).max(1e4).describe("Task description \u2014 pipeline template auto-selected based on content"),
+  task: z116.string().min(5).max(1e4).describe("Task description \u2014 pipeline template auto-selected based on content"),
   /** Path to a spec file (.md, .yaml) to use as task input. */
-  specFile: z115.string().max(500).optional().describe("Path to a spec file \u2014 content prepended to task for greenfield projects"),
+  specFile: z116.string().max(500).optional().describe("Path to a spec file \u2014 content prepended to task for greenfield projects"),
   /** Override template — see `listTemplateIds()` for the canonical list (#2728). Auto-detected if omitted. */
-  template: z115.string().max(50).optional().describe(`Pipeline template override. Available: ${listTemplateIds().join(", ")}`),
+  template: z116.string().max(50).optional().describe(`Pipeline template override. Available: ${listTemplateIds().join(", ")}`),
   /** Voting strategy for consensus stages. */
-  votingStrategy: z115.enum([
+  votingStrategy: z116.enum([
     "simple_majority",
     "supermajority",
     "unanimous",
@@ -52137,11 +52279,11 @@ var PipelineInputSchema = z115.object({
     "Voting strategy for plan approval. simple_majority (default), supermajority (67%), unanimous, higher_order (Bayesian), proof_of_learning, opinion_wise"
   ),
   /** Use 3 agents instead of 6 for faster voting. */
-  quickMode: z115.boolean().default(false).describe("Use 3 agents instead of 6 for faster consensus voting"),
+  quickMode: z116.boolean().default(false).describe("Use 3 agents instead of 6 for faster consensus voting"),
   /** Maximum execution time per stage in milliseconds (min 30s, max 600s). */
-  timeoutMs: z115.number().int().min(3e4).max(6e5).optional().describe("Max time per stage in ms (30000-600000). Default: varies by stage complexity"),
+  timeoutMs: z116.number().int().min(3e4).max(6e5).optional().describe("Max time per stage in ms (30000-600000). Default: varies by stage complexity"),
   /** Stop after planning/voting (no implementation). */
-  dryRun: z115.boolean().default(false).describe("Stop after vote stage (no implementation)"),
+  dryRun: z116.boolean().default(false).describe("Stop after vote stage (no implementation)"),
   /**
    * Dispatch mode (#3730). `sync` (default) runs the pipeline inline and
    * returns the result — but a real multi-stage adaptive run can exceed the
@@ -52152,7 +52294,7 @@ var PipelineInputSchema = z115.object({
    */
   ...asyncDispatchInputDefaultSync("Ignored for dryRun."),
   /** TESTS ONLY — random output, must not be used for real decisions. (#2319) */
-  simulateVotes: z115.boolean().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
+  simulateVotes: z116.boolean().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
 });
 function buildOutput3(result, simulated) {
   return {
@@ -52326,9 +52468,9 @@ function registerPipelineTool(server, deps) {
 }
 
 // src/mcp/tools/run-tool.ts
-var RunInputSchema = z116.object({
-  goal: z116.string().min(1).describe("Natural-language goal. nexus-agents selects how to execute it."),
-  forceStrategy: z116.enum([
+var RunInputSchema = z117.object({
+  goal: z117.string().min(1).describe("Natural-language goal. nexus-agents selects how to execute it."),
+  forceStrategy: z117.enum([
     "single-shot",
     "dev-pipeline",
     "pipeline",
@@ -52340,10 +52482,10 @@ var RunInputSchema = z116.object({
   ]).optional().describe(
     "Power-user override: force a specific strategy instead of letting the router choose."
   ),
-  requiresConsensus: z116.boolean().optional().describe("Hint: the task needs a multi-perspective consensus decision."),
-  dependencyStructure: z116.enum(["linear", "dag", "independent", "unknown"]).optional().describe("Hint: the dependency structure of the work."),
-  isNovel: z116.boolean().optional().describe("Hint: this kind of task has not been seen before."),
-  execute: z116.boolean().optional().describe(
+  requiresConsensus: z117.boolean().optional().describe("Hint: the task needs a multi-perspective consensus decision."),
+  dependencyStructure: z117.enum(["linear", "dag", "independent", "unknown"]).optional().describe("Hint: the dependency structure of the work."),
+  isNovel: z117.boolean().optional().describe("Hint: this kind of task has not been seen before."),
+  execute: z117.boolean().optional().describe(
     "When true, actually run the selected strategy (if an executor is wired) and return its result; otherwise return the routing decision only (default false, read-only)."
   ),
   /**
@@ -52358,7 +52500,7 @@ var RunInputSchema = z116.object({
    * other, the call is REFUSED rather than executed: silently ignoring a
    * do-not-act flag is the one outcome a governance substrate cannot allow.
    */
-  dryRun: z116.boolean().optional().describe(
+  dryRun: z117.boolean().optional().describe(
     "Plan and vote only, no implementation (#4806). Requires the dev-pipeline strategy \u2014 refused (never silently executed) when the router selects another."
   ),
   /**
@@ -52593,12 +52735,12 @@ function registerRunTool(server, deps) {
 }
 
 // src/mcp/tools/list-available-models-tool.ts
-import { z as z117 } from "zod";
+import { z as z118 } from "zod";
 var DESCRIPTION5 = "Probe every model-discovery transport (OpenRouter API + opencode/claude/codex/gemini CLIs) and report a per-transport health summary: probe ok/failed, model count, and a sample of ids. Use it to validate the CLIs and APIs are wired and reachable. Read-only; does not change routing.";
 var PROBE_TIMEOUT_MS = 12e3;
-var ListAvailableModelsInputSchema = z117.object({
-  includeModelIds: z117.boolean().optional().describe("Include the full model-id list per transport (default false \u2192 sample of 5 only)."),
-  includeOpenRouter: z117.boolean().optional().describe("Probe the OpenRouter live catalog (default true).")
+var ListAvailableModelsInputSchema = z118.object({
+  includeModelIds: z118.boolean().optional().describe("Include the full model-id list per transport (default false \u2192 sample of 5 only)."),
+  includeOpenRouter: z118.boolean().optional().describe("Probe the OpenRouter live catalog (default true).")
 });
 async function probeSource(source, includeModelIds) {
   let timer;
@@ -52665,8 +52807,8 @@ async function listAvailableModelsHandler(args, deps, logger57) {
 function registerListAvailableModelsTool(server, deps) {
   const logger57 = deps.logger ?? createLogger({ tool: "list_available_models" });
   const toolSchema = {
-    includeModelIds: z117.boolean().optional().describe("Include the full model-id list per transport (default false \u2192 sample of 5 only)."),
-    includeOpenRouter: z117.boolean().optional().describe("Probe the OpenRouter live catalog (default true).")
+    includeModelIds: z118.boolean().optional().describe("Include the full model-id list per transport (default false \u2192 sample of 5 only)."),
+    includeOpenRouter: z118.boolean().optional().describe("Probe the OpenRouter live catalog (default true).")
   };
   const secureHandler = createSecureHandler(
     (args) => listAvailableModelsHandler(args, deps, logger57),
@@ -52690,7 +52832,7 @@ function registerListAvailableModelsTool(server, deps) {
 }
 
 // src/mcp/tools/pr-review-eval-types.ts
-import { z as z118 } from "zod";
+import { z as z119 } from "zod";
 var PR_REVIEW_EVAL_ROLES = [
   "architect",
   "security",
@@ -52698,43 +52840,43 @@ var PR_REVIEW_EVAL_ROLES = [
   "catfish",
   "scope_steward"
 ];
-var PrReviewEvalRoleSchema = z118.enum(PR_REVIEW_EVAL_ROLES);
-var PrReviewCaseClassSchema = z118.enum(["buggy", "clean", "borderline"]);
-var VoterEvalVerdictSchema = z118.object({
+var PrReviewEvalRoleSchema = z119.enum(PR_REVIEW_EVAL_ROLES);
+var PrReviewCaseClassSchema = z119.enum(["buggy", "clean", "borderline"]);
+var VoterEvalVerdictSchema = z119.object({
   /** Stable record id (e.g. `${runId}:${caseNumber}:${role}`). */
-  id: z118.string().min(1).max(160),
+  id: z119.string().min(1).max(160),
   /** The pr_review run / batch this verdict belongs to. */
-  runId: z118.string().min(1).max(64),
+  runId: z119.string().min(1).max(64),
   /** Dataset case identifier (the dataset's `number` field). */
-  caseNumber: z118.string().min(1).max(80),
+  caseNumber: z119.string().min(1).max(80),
   /** Rubric class of the case (ground-truth label). */
   caseClass: PrReviewCaseClassSchema,
   /** The voter role being scored. */
   role: PrReviewEvalRoleSchema,
   /** Verified findings that matched a known bug. */
-  truePositives: z118.number().int().nonnegative(),
+  truePositives: z119.number().int().nonnegative(),
   /** Verified findings on clean code that matched no known bug. */
-  falsePositives: z118.number().int().nonnegative(),
+  falsePositives: z119.number().int().nonnegative(),
   /** Known bugs this voter failed to flag. */
-  falseNegatives: z118.number().int().nonnegative(),
+  falseNegatives: z119.number().int().nonnegative(),
   /** Rubric version the ground truth was adjudicated under. */
-  rubricVersion: z118.string().min(1).max(32),
+  rubricVersion: z119.string().min(1).max(32),
   /** ISO-8601 timestamp the verdict was recorded. */
-  timestamp: z118.string().min(1).max(40)
+  timestamp: z119.string().min(1).max(40)
 });
-var VoterEvalVerdictQuerySchema = z118.object({
+var VoterEvalVerdictQuerySchema = z119.object({
   role: PrReviewEvalRoleSchema.optional(),
-  runId: z118.string().min(1).max(64).optional(),
+  runId: z119.string().min(1).max(64).optional(),
   caseClass: PrReviewCaseClassSchema.optional(),
-  rubricVersion: z118.string().min(1).max(32).optional(),
+  rubricVersion: z119.string().min(1).max(32).optional(),
   /** ISO-8601 lower bound (inclusive) on `timestamp`. */
-  since: z118.string().optional(),
+  since: z119.string().optional(),
   /** Most-recent-N cap. */
-  limit: z118.number().int().positive().optional()
+  limit: z119.number().int().positive().optional()
 });
 
 // src/mcp/tools/supply-chain-tradeoff-panel.ts
-import { z as z119 } from "zod";
+import { z as z120 } from "zod";
 import { randomUUID as randomUUID18 } from "node:crypto";
 var DEFAULT_AXES = [
   "build_time_determinism",
@@ -52756,16 +52898,16 @@ var FULL_PANEL = [
   "scope_steward"
 ];
 var QUICK_PANEL = ["architect", "security", "scope_steward"];
-var SupplyChainTradeoffPanelInputSchema = z119.object({
-  proposal: z119.string().min(1).max(MAX_PROPOSAL_LENGTH).describe('The proposal under tradeoff review (e.g. "Should aegis-boot adopt cargo-nextest?")'),
-  axes: z119.array(z119.string().min(1).max(MAX_AXIS_NAME_LENGTH)).min(1).max(MAX_AXES).optional().describe(
+var SupplyChainTradeoffPanelInputSchema = z120.object({
+  proposal: z120.string().min(1).max(MAX_PROPOSAL_LENGTH).describe('The proposal under tradeoff review (e.g. "Should aegis-boot adopt cargo-nextest?")'),
+  axes: z120.array(z120.string().min(1).max(MAX_AXIS_NAME_LENGTH)).min(1).max(MAX_AXES).optional().describe(
     `Tradeoff axes to evaluate. Default: ${DEFAULT_AXES.join(", ")}. Custom axes accepted; max ${String(MAX_AXES)}.`
   ),
-  context: z119.string().max(MAX_CONTEXT_LENGTH).optional().describe(
+  context: z120.string().max(MAX_CONTEXT_LENGTH).optional().describe(
     "Optional context: relevant repo state, dependency tree, vendor publishing patterns, etc."
   ),
-  quickMode: z119.boolean().optional().default(false).describe("Use 3 voters (architect, security, scope_steward) instead of 7"),
-  simulate: z119.boolean().optional().default(false).describe("Use simulated voters (testing only)"),
+  quickMode: z120.boolean().optional().default(false).describe("Use 3 voters (architect, security, scope_steward) instead of 7"),
+  simulate: z120.boolean().optional().default(false).describe("Use simulated voters (testing only)"),
   // #6123: same field as consensus_vote — the panel judges the caller's project.
   project: VoterProjectInputSchema,
   /**
@@ -53258,40 +53400,40 @@ var RiskLevel = /* @__PURE__ */ ((RiskLevel2) => {
 })(RiskLevel || {});
 
 // src/mcp/safety/stpa-schemas.ts
-import { z as z120 } from "zod";
-var HazardCategorySchema = z120.enum(HazardCategory);
-var HazardSeveritySchema = z120.enum(HazardSeverity);
-var ConstraintPrioritySchema = z120.enum(ConstraintPriority);
-var RiskLevelSchema = z120.enum(RiskLevel);
-var TriggerPatternSchema = z120.object({
-  parameter: z120.string().min(1),
-  matchType: z120.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
-  pattern: z120.string(),
-  reason: z120.string()
+import { z as z121 } from "zod";
+var HazardCategorySchema = z121.enum(HazardCategory);
+var HazardSeveritySchema = z121.enum(HazardSeverity);
+var ConstraintPrioritySchema = z121.enum(ConstraintPriority);
+var RiskLevelSchema = z121.enum(RiskLevel);
+var TriggerPatternSchema = z121.object({
+  parameter: z121.string().min(1),
+  matchType: z121.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
+  pattern: z121.string(),
+  reason: z121.string()
 });
-var HazardSchema = z120.object({
-  id: z120.string().min(1),
-  description: z120.string(),
+var HazardSchema = z121.object({
+  id: z121.string().min(1),
+  description: z121.string(),
   category: HazardCategorySchema,
   severity: HazardSeveritySchema,
-  likelihood: z120.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
-  triggerConditions: z120.array(z120.string()),
-  consequences: z120.array(z120.string())
+  likelihood: z121.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
+  triggerConditions: z121.array(z121.string()),
+  consequences: z121.array(z121.string())
 });
-var UnsafeControlActionSchema = z120.object({
-  id: z120.string().min(1),
-  toolName: z120.string().min(1),
-  type: z120.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
-  description: z120.string(),
-  unsafeContext: z120.string(),
-  relatedHazards: z120.array(z120.string()),
-  triggerPatterns: z120.array(TriggerPatternSchema).optional()
+var UnsafeControlActionSchema = z121.object({
+  id: z121.string().min(1),
+  toolName: z121.string().min(1),
+  type: z121.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
+  description: z121.string(),
+  unsafeContext: z121.string(),
+  relatedHazards: z121.array(z121.string()),
+  triggerPatterns: z121.array(TriggerPatternSchema).optional()
 });
-var SafetyConstraintSchema = z120.object({
-  id: z120.string().min(1),
-  description: z120.string(),
-  mitigates: z120.array(z120.string()),
-  enforcement: z120.enum([
+var SafetyConstraintSchema = z121.object({
+  id: z121.string().min(1),
+  description: z121.string(),
+  mitigates: z121.array(z121.string()),
+  enforcement: z121.enum([
     "prevent",
     "require_confirmation",
     "alert",
@@ -53299,52 +53441,52 @@ var SafetyConstraintSchema = z120.object({
     "rate_limit",
     "require_privilege"
   ]),
-  validationFunction: z120.string().optional(),
+  validationFunction: z121.string().optional(),
   priority: ConstraintPrioritySchema
 });
-var PropertySchemaSchema = z120.object({
-  type: z120.string(),
-  description: z120.string().optional(),
-  enum: z120.array(z120.unknown()).optional(),
-  pattern: z120.string().optional(),
-  minimum: z120.number().optional(),
-  maximum: z120.number().optional()
+var PropertySchemaSchema = z121.object({
+  type: z121.string(),
+  description: z121.string().optional(),
+  enum: z121.array(z121.unknown()).optional(),
+  pattern: z121.string().optional(),
+  minimum: z121.number().optional(),
+  maximum: z121.number().optional()
 });
-var ToolInputSchemaSchema = z120.object({
-  type: z120.string(),
-  properties: z120.record(z120.string(), PropertySchemaSchema).optional(),
-  required: z120.array(z120.string()).optional(),
-  additionalProperties: z120.boolean().optional()
+var ToolInputSchemaSchema = z121.object({
+  type: z121.string(),
+  properties: z121.record(z121.string(), PropertySchemaSchema).optional(),
+  required: z121.array(z121.string()).optional(),
+  additionalProperties: z121.boolean().optional()
 });
-var ToolDefinitionSchema = z120.object({
-  name: z120.string().min(1),
-  description: z120.string(),
+var ToolDefinitionSchema = z121.object({
+  name: z121.string().min(1),
+  description: z121.string(),
   inputSchema: ToolInputSchemaSchema
 });
-var AnalysisConfigurationSchema = z120.object({
-  includeLowSeverity: z120.boolean().default(true),
-  generateAllConstraints: z120.boolean().default(true),
-  checkInteractions: z120.boolean().default(true),
-  maxHazardsPerTool: z120.number().int().min(1).max(100).default(50),
-  categories: z120.array(HazardCategorySchema).default([])
+var AnalysisConfigurationSchema = z121.object({
+  includeLowSeverity: z121.boolean().default(true),
+  generateAllConstraints: z121.boolean().default(true),
+  checkInteractions: z121.boolean().default(true),
+  maxHazardsPerTool: z121.number().int().min(1).max(100).default(50),
+  categories: z121.array(HazardCategorySchema).default([])
 });
-var ConstraintViolationSchema = z120.object({
-  constraintId: z120.string().min(1),
-  constraintDescription: z120.string(),
+var ConstraintViolationSchema = z121.object({
+  constraintId: z121.string().min(1),
+  constraintDescription: z121.string(),
   severity: HazardSeveritySchema,
-  details: z120.string(),
-  remediation: z120.string()
+  details: z121.string(),
+  remediation: z121.string()
 });
-var ValidationWarningSchema = z120.object({
-  code: z120.string().min(1),
-  message: z120.string(),
-  affected: z120.string()
+var ValidationWarningSchema = z121.object({
+  code: z121.string().min(1),
+  message: z121.string(),
+  affected: z121.string()
 });
-var ValidationResultSchema = z120.object({
-  valid: z120.boolean(),
-  toolName: z120.string().min(1),
-  violations: z120.array(ConstraintViolationSchema),
-  passed: z120.array(z120.string()),
+var ValidationResultSchema = z121.object({
+  valid: z121.boolean(),
+  toolName: z121.string().min(1),
+  violations: z121.array(ConstraintViolationSchema),
+  passed: z121.array(z121.string()),
   // Optional rather than required, deliberately. `ValidationResult` declares
   // both fields required because every result this package produces has them;
   // the schema is the lenient inbound edge for a result that arrived from
@@ -53355,10 +53497,10 @@ var ValidationResultSchema = z120.object({
   // "nothing was evaluated". The strict/lenient split is safe because nothing
   // bridges the two with `z.infer`: a parsed result will not typecheck as a
   // `ValidationResult` without handling the absent fields.
-  evaluated: z120.array(z120.string()).optional(),
-  notApplicable: z120.array(z120.string()).optional(),
-  warnings: z120.array(ValidationWarningSchema),
-  validatedAt: z120.date()
+  evaluated: z121.array(z121.string()).optional(),
+  notApplicable: z121.array(z121.string()).optional(),
+  warnings: z121.array(ValidationWarningSchema),
+  validatedAt: z121.date()
 });
 
 // src/mcp/safety/stpa-types.ts
@@ -54443,9 +54585,9 @@ var GeminiResponseParser = class {
 };
 
 // src/cli-adapters/router-types.ts
-import { z as z121 } from "zod";
-var RouterConfigSchema = z121.object({
-  preferCostEfficient: z121.boolean().default(false),
+import { z as z122 } from "zod";
+var RouterConfigSchema = z122.object({
+  preferCostEfficient: z122.boolean().default(false),
   /**
    * @deprecated Declared but NEVER ENFORCED — nothing on the routing path
    * compares anything to it, and `composite-router.ts` measures
@@ -54454,51 +54596,51 @@ var RouterConfigSchema = z121.object({
    * because of this. Scheduled for removal in the next major (#5963); the
    * default is 50 here and in every other declaration since #5918.
    */
-  maxDecisionTimeMs: z121.number().min(1).max(1e3).default(50)
+  maxDecisionTimeMs: z122.number().min(1).max(1e3).default(50)
 });
 
 // src/cli-adapters/agreement-cascade-types.ts
-import { z as z122 } from "zod";
-var AgreementCascadeConfigSchema = z122.object({
-  agreementThreshold: z122.number().min(0.5).max(1).default(0.7),
-  maxStages: z122.number().int().min(1).max(5).default(3),
-  modelTimeoutMs: z122.number().int().min(1e3).max(3e5).default(6e4)
+import { z as z123 } from "zod";
+var AgreementCascadeConfigSchema = z123.object({
+  agreementThreshold: z123.number().min(0.5).max(1).default(0.7),
+  maxStages: z123.number().int().min(1).max(5).default(3),
+  modelTimeoutMs: z123.number().int().min(1e3).max(3e5).default(6e4)
 });
 
 // src/cli-adapters/agreement-cascade-router.ts
 var logger50 = createLogger({ component: "agreement-cascade-router" });
 
 // src/cli-adapters/task-classifier.ts
-import { z as z123 } from "zod";
-var ClassificationPatternsSchema = z123.object({
-  code: z123.array(z123.string()).readonly(),
-  research: z123.array(z123.string()).readonly(),
-  documentation: z123.array(z123.string()).readonly(),
-  analysis: z123.array(z123.string()).readonly()
+import { z as z124 } from "zod";
+var ClassificationPatternsSchema = z124.object({
+  code: z124.array(z124.string()).readonly(),
+  research: z124.array(z124.string()).readonly(),
+  documentation: z124.array(z124.string()).readonly(),
+  analysis: z124.array(z124.string()).readonly()
 });
 
 // src/cli-adapters/response-cache-types.ts
-import { z as z124 } from "zod";
-var ResponseCacheConfigSchema = z124.object({
-  defaultTTL: z124.number().min(1e3).max(36e5).default(3e5),
+import { z as z125 } from "zod";
+var ResponseCacheConfigSchema = z125.object({
+  defaultTTL: z125.number().min(1e3).max(36e5).default(3e5),
   // 5 minutes
-  maxEntries: z124.number().min(10).max(1e5).default(1e3),
-  maxMemoryMB: z124.number().min(1).max(1e3).default(50),
-  cleanupInterval: z124.number().min(1e3).max(6e5).default(6e4),
+  maxEntries: z125.number().min(10).max(1e5).default(1e3),
+  maxMemoryMB: z125.number().min(1).max(1e3).default(50),
+  cleanupInterval: z125.number().min(1e3).max(6e5).default(6e4),
   // 1 minute
-  enableLogging: z124.boolean().default(false)
+  enableLogging: z125.boolean().default(false)
 });
 
 // src/cli-adapters/response-cache-utils.ts
 var logger51 = createLogger({ component: "ResponseCacheUtils" });
 
 // src/cli-adapters/unified-routing-types.ts
-import { z as z125 } from "zod";
-var UnifiedRoutingDecisionSchema = z125.object({
-  selectedCli: z125.string(),
-  confidence: z125.number().min(0).max(1),
-  reason: z125.string(),
-  strategy: z125.enum([
+import { z as z126 } from "zod";
+var UnifiedRoutingDecisionSchema = z126.object({
+  selectedCli: z126.string(),
+  confidence: z126.number().min(0).max(1),
+  reason: z126.string(),
+  strategy: z126.enum([
     "composite",
     "quality",
     "budget",
@@ -54510,60 +54652,60 @@ var UnifiedRoutingDecisionSchema = z125.object({
     "linucb",
     "direct"
   ]),
-  decisionTimeMs: z125.number().nonnegative(),
-  alternatives: z125.array(z125.string()).readonly(),
-  stagesExecuted: z125.array(z125.string()).readonly(),
-  withinBudget: z125.boolean().optional(),
-  estimatedComplexity: z125.enum(["simple", "moderate", "complex", "expert"]).optional(),
-  estimatedTokens: z125.number().int().positive().optional(),
-  topsisScore: z125.number().optional(),
-  ucbScore: z125.number().optional(),
-  resolvedAtStage: z125.number().int().nonnegative().optional(),
-  consensusReached: z125.boolean().optional(),
-  agreementScore: z125.number().min(0).max(1).optional(),
-  metadata: z125.record(z125.string(), z125.unknown()).optional()
+  decisionTimeMs: z126.number().nonnegative(),
+  alternatives: z126.array(z126.string()).readonly(),
+  stagesExecuted: z126.array(z126.string()).readonly(),
+  withinBudget: z126.boolean().optional(),
+  estimatedComplexity: z126.enum(["simple", "moderate", "complex", "expert"]).optional(),
+  estimatedTokens: z126.number().int().positive().optional(),
+  topsisScore: z126.number().optional(),
+  ucbScore: z126.number().optional(),
+  resolvedAtStage: z126.number().int().nonnegative().optional(),
+  consensusReached: z126.boolean().optional(),
+  agreementScore: z126.number().min(0).max(1).optional(),
+  metadata: z126.record(z126.string(), z126.unknown()).optional()
 });
 
 // src/learning/outcome-feedback-types.ts
-import { z as z126 } from "zod";
-var QualitySignalsSchema = z126.object({
-  testsPass: z126.boolean().optional(),
-  lintErrors: z126.number().int().min(0).optional(),
-  userApproved: z126.boolean().optional(),
-  retryCount: z126.number().int().min(0).default(0),
-  completionRatio: z126.number().min(0).max(1).default(1),
-  validStructure: z126.boolean().optional(),
-  coherenceScore: z126.number().min(0).max(1).optional()
+import { z as z127 } from "zod";
+var QualitySignalsSchema = z127.object({
+  testsPass: z127.boolean().optional(),
+  lintErrors: z127.number().int().min(0).optional(),
+  userApproved: z127.boolean().optional(),
+  retryCount: z127.number().int().min(0).default(0),
+  completionRatio: z127.number().min(0).max(1).default(1),
+  validStructure: z127.boolean().optional(),
+  coherenceScore: z127.number().min(0).max(1).optional()
 });
-var RoutingDecisionSchema = z126.object({
-  id: z126.uuid(),
-  timestamp: z126.iso.datetime(),
-  query: z126.string(),
-  routerType: z126.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
+var RoutingDecisionSchema = z127.object({
+  id: z127.uuid(),
+  timestamp: z127.iso.datetime(),
+  query: z127.string(),
+  routerType: z127.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
   // Optional so a row persisted before #5812 still parses. Absence is read as
   // unmeasured by `isRouterTypeMeasured`, never as measured.
-  routerTypeMeasured: z126.boolean().optional(),
-  selectedModel: z126.string(),
-  selectedTier: z126.enum(["strong", "weak"]).optional(),
-  armIndex: z126.number().int().min(0).optional(),
-  banditContext: z126.record(z126.string(), z126.unknown()).optional(),
-  queryFeatures: z126.record(z126.string(), z126.unknown()).optional(),
-  ucbScore: z126.number().optional(),
-  confidence: z126.number().min(0).max(1).optional(),
-  traceId: z126.string(),
-  domain: z126.string().optional()
+  routerTypeMeasured: z127.boolean().optional(),
+  selectedModel: z127.string(),
+  selectedTier: z127.enum(["strong", "weak"]).optional(),
+  armIndex: z127.number().int().min(0).optional(),
+  banditContext: z127.record(z127.string(), z127.unknown()).optional(),
+  queryFeatures: z127.record(z127.string(), z127.unknown()).optional(),
+  ucbScore: z127.number().optional(),
+  confidence: z127.number().min(0).max(1).optional(),
+  traceId: z127.string(),
+  domain: z127.string().optional()
 });
-var TaskOutcomeSchema = z126.object({
-  routingDecisionId: z126.uuid(),
-  timestamp: z126.iso.datetime(),
-  outcomeClass: z126.enum(["success", "partial", "failure", "timeout", "error"]),
-  success: z126.boolean(),
-  qualityScore: z126.number().min(0).max(1),
-  durationMs: z126.number().min(0),
-  tokenUsage: z126.number().int().min(0),
-  errorMessage: z126.string().optional(),
+var TaskOutcomeSchema = z127.object({
+  routingDecisionId: z127.uuid(),
+  timestamp: z127.iso.datetime(),
+  outcomeClass: z127.enum(["success", "partial", "failure", "timeout", "error"]),
+  success: z127.boolean(),
+  qualityScore: z127.number().min(0).max(1),
+  durationMs: z127.number().min(0),
+  tokenUsage: z127.number().int().min(0),
+  errorMessage: z127.string().optional(),
   qualitySignals: QualitySignalsSchema,
-  traceId: z126.string()
+  traceId: z127.string()
 });
 var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   maxPendingDecisions: 1e3,
@@ -54578,17 +54720,17 @@ var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   targetTokenUsage: 2e3,
   maxHistorySize: 1e4
 };
-var FeedbackCollectorConfigSchema = z126.object({
-  maxPendingDecisions: z126.number().int().positive().default(1e3),
-  pendingTimeoutMs: z126.number().positive().default(3e5),
-  enableAutoReward: z126.boolean().default(true),
-  qualityWeight: z126.number().min(0).max(1).default(0.5),
-  speedWeight: z126.number().min(0).max(1).default(0.2),
-  efficiencyWeight: z126.number().min(0).max(1).default(0.2),
-  retryPenalty: z126.number().min(0).max(1).default(0.1),
-  targetDurationMs: z126.number().positive().default(5e3),
-  targetTokenUsage: z126.number().positive().default(2e3),
-  maxHistorySize: z126.number().int().positive().default(1e4)
+var FeedbackCollectorConfigSchema = z127.object({
+  maxPendingDecisions: z127.number().int().positive().default(1e3),
+  pendingTimeoutMs: z127.number().positive().default(3e5),
+  enableAutoReward: z127.boolean().default(true),
+  qualityWeight: z127.number().min(0).max(1).default(0.5),
+  speedWeight: z127.number().min(0).max(1).default(0.2),
+  efficiencyWeight: z127.number().min(0).max(1).default(0.2),
+  retryPenalty: z127.number().min(0).max(1).default(0.1),
+  targetDurationMs: z127.number().positive().default(5e3),
+  targetTokenUsage: z127.number().positive().default(2e3),
+  maxHistorySize: z127.number().int().positive().default(1e4)
 });
 
 // src/learning/outcome-feedback-helpers.ts
@@ -56708,4 +56850,4 @@ export {
   startPipelineEventBridge,
   shutdownPipelineEventBridge
 };
-//# sourceMappingURL=chunk-SYMY2WZI.js.map
+//# sourceMappingURL=chunk-TZKXFJSF.js.map