nexus-agents 2.56.0 → 2.57.0

package/dist/{chunk-EJLWDYK7.js → chunk-ZL3IBCH6.js}

@@ -1,13 +1,15 @@
 import {
   getTokenEnvVars,
   resolveToken
-} from "./chunk-2SPRLBOS.js";
+} from "./chunk-EZXOJZYE.js";
 import {
   ClaudeAdapter,
   DEFAULT_RELEVANCE_CONFIG,
   EventTopics,
   NOOP_NOTIFIER,
   RateLimiter,
+  abortSignalStorage,
+  collectRealVotes,
   createDefaultRateLimiter,
   createEvent,
   createMcpNotifier,
@@ -27,7 +29,7 @@ import {
   withAccessPolicy,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-BPMQRYGU.js";
+} from "./chunk-BOZ26RIB.js";
 import {
   REGISTRY_PATH,
   getProjectRoot,
@@ -36,14 +38,14 @@ import {
   normalizeTopicToCanonical,
   savePapersRegistry,
   synthesizeResearch
-} from "./chunk-PCMWLXT4.js";
+} from "./chunk-TC46TRLR.js";
 import {
   IssueTriage,
   sanitizeInput
-} from "./chunk-FWSTXEG2.js";
+} from "./chunk-AFSIP6JH.js";
 import {
   generateSecurityPlan
-} from "./chunk-Q5TKQWOI.js";
+} from "./chunk-V5CGWMYL.js";
 import {
   analyzeGitHubRepo
 } from "./chunk-BC3M4VLP.js";
@@ -58,13 +60,15 @@ import {
   SharedMemoryStore
 } from "./chunk-ED6VQWNG.js";
 import {
-  DEFAULTS,
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl,
   getAvailabilityCache,
   resolveFallback
-} from "./chunk-C3FGEDD7.js";
+} from "./chunk-Y7CD6AZW.js";
+import {
+  DEFAULTS
+} from "./chunk-H43PABG4.js";
 import {
   resolveInsideRoot
 } from "./chunk-NUBSJGQZ.js";
@@ -76,11 +80,11 @@ import {
 } from "./chunk-GJVHRJO2.js";
 import {
   createSessionMemory
-} from "./chunk-NYNBDP7M.js";
+} from "./chunk-7Y36JLES.js";
 import {
   MemoryImportance,
   calculateTextJaccardSimilarity
-} from "./chunk-3IDJSFWT.js";
+} from "./chunk-TFEFN37P.js";
 import {
   STOPWORDS,
   capitalize,
@@ -89,13 +93,13 @@ import {
 } from "./chunk-633WH2ML.js";
 import {
   generateMcpConfig
-} from "./chunk-VKZKC4SM.js";
+} from "./chunk-EDGG3RQE.js";
 import {
   getFallbackChainForCategory
-} from "./chunk-KRIFBGWZ.js";
+} from "./chunk-PTGBJFSD.js";
 import {
   executeExpert
-} from "./chunk-VLVHPC72.js";
+} from "./chunk-ZUWOFHNC.js";
 import {
   ClaudeCliAdapter,
   CliDetectionCache,
@@ -104,7 +108,7 @@ import {
   getAvailableClis,
   sleep,
   withTimeout
-} from "./chunk-RSUCXOQM.js";
+} from "./chunk-SXWZS2V4.js";
 import {
   AGENT_ROUTER_TIMEOUTS,
   API_TIMEOUTS,
@@ -169,7 +173,7 @@ import {
   ok,
   toExpertTaskAnalysisResult,
   withStep
-} from "./chunk-UOUJZIKH.js";
+} from "./chunk-R2Y57PM3.js";
 
 // src/agents/state-machine-types.ts
 var VALID_TRANSITIONS = /* @__PURE__ */ new Map([
@@ -23433,10 +23437,10 @@ function calculateZStatistic(params) {
 function calculateDifferenceCI(p1, p2, total1, total2, confidence) {
   const difference = p1 - p2;
   const seDiff = Math.sqrt(p1 * (1 - p1) / (total1 || 1) + p2 * (1 - p2) / (total2 || 1));
-  const z101 = getZScore(confidence);
+  const z102 = getZScore(confidence);
   return {
-    lower: difference - z101 * seDiff,
-    upper: difference + z101 * seDiff,
+    lower: difference - z102 * seDiff,
+    upper: difference + z102 * seDiff,
     estimate: difference,
     confidence,
     n: total1 + total2,
@@ -23459,11 +23463,11 @@ function proportionConfidenceInterval(successes, total, options = {}) {
       standardError: 0
     };
   }
-  const z101 = getZScore(opts.confidence);
-  const z210 = z101 * z101;
+  const z102 = getZScore(opts.confidence);
+  const z210 = z102 * z102;
   const denominator = 1 + z210 / n;
   const center = (p + z210 / (2 * n)) / denominator;
-  const margin = z101 / denominator * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
+  const margin = z102 / 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);
@@ -23493,8 +23497,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 z101 = getZScore(opts.confidence);
-  const margin = z101 * standardError;
+  const z102 = getZScore(opts.confidence);
+  const margin = z102 * standardError;
   return {
     lower: mean - margin,
     upper: mean + margin,
@@ -26648,7 +26652,14 @@ async function executeSuperStep(graph, ctx, options) {
   const completedIds = results.filter((r) => r.status === "success").map((r) => r.nodeId);
   ctx.runnableIds = resolveNextNodes(graph, completedIds, ctx.state, ctx);
   for (const result of results) {
-    options?.onNodeComplete?.(result);
+    try {
+      options?.onNodeComplete?.(result);
+    } catch (error) {
+      logger15.warn("onNodeComplete callback threw \u2014 continuing execution", {
+        nodeId: result.nodeId,
+        error: getErrorMessage(error)
+      });
+    }
   }
   emitNodeResults(ctx, results, options);
   emitStateUpdated(ctx, results, options);
@@ -26682,7 +26693,16 @@ function saveCheckpointIfConfigured(ctx, options) {
     pendingNodeIds: ctx.runnableIds,
     completedResults: ctx.allResults
   });
-  store.save(checkpoint);
+  try {
+    store.save(checkpoint);
+  } catch (err2) {
+    const error = err2 instanceof Error ? err2 : new Error(String(err2));
+    logger15.warn("Checkpoint save failed; execution continues without resumable state", {
+      executionId: execId,
+      stepNumber: ctx.stepsExecuted,
+      errorMessage: error.message
+    });
+  }
 }
 function initializeState(graph, inputs) {
   const state = {};
@@ -26702,11 +26722,20 @@ function mergeNodeResults(graph, currentState, results) {
   }
   return state;
 }
+var undeclaredFieldWarned = /* @__PURE__ */ new Set();
 function applyStateUpdates(graph, state, updates) {
   const newState = { ...state };
   for (const [field, value] of Object.entries(updates)) {
     const schema = graph.stateSchema[field];
     if (schema === void 0) {
+      const key = `${String(Object.keys(graph.stateSchema).length)}:${field}`;
+      if (!undeclaredFieldWarned.has(key)) {
+        undeclaredFieldWarned.add(key);
+        logger15.warn("Node wrote to undeclared state field; defaulting to overwrite reducer", {
+          field,
+          knownFields: Object.keys(graph.stateSchema)
+        });
+      }
       newState[field] = value;
       continue;
     }
@@ -28091,7 +28120,22 @@ function evaluatePolicy2(options, context) {
   const violations = [];
   const rules = options.engine.listRules();
   for (const rule of rules) {
-    const decision = rule.evaluate(context);
+    let decision;
+    try {
+      decision = rule.evaluate(context);
+    } catch (err2) {
+      const error = err2 instanceof Error ? err2 : new Error(String(err2));
+      logger20.error("Policy rule threw during evaluation", error, {
+        ruleId: rule.id,
+        stageId: context.stageId
+      });
+      const message = error.message;
+      violations.push({
+        ruleId: rule.id,
+        reason: `Rule threw during evaluation: ${message}`
+      });
+      continue;
+    }
     if (!decision.allow) {
       violations.push({
         ruleId: rule.id,
@@ -30215,11 +30259,15 @@ var RoleFailureTracker = class {
     });
   }
 };
-async function executeWithConcurrencyLimit(tasks, limit) {
+function isCancelled2(signal) {
+  return signal?.aborted === true;
+}
+async function executeWithConcurrencyLimit(tasks, limit, signal) {
   const results = [];
   let nextIndex = 0;
   async function runNext() {
     while (nextIndex < tasks.length) {
+      if (isCancelled2(signal)) return;
       const currentIndex = nextIndex;
       nextIndex++;
       const task = tasks[currentIndex];
@@ -30245,6 +30293,7 @@ async function dispatchWorkers(entries, options) {
   const execId = options.executionId ?? `dispatch-${Date.now().toString(36)}`;
   const staggerDelayMs = options.staggerDelayMs ?? DEFAULT_STAGGER_DELAY_MS;
   for (const [waveIdx, wave] of waves.entries()) {
+    if (isCancelled2(options.signal)) break;
     const waveResults = await processWave(wave, waveIdx, waves.length, {
       bus,
       executionId: execId,
@@ -30321,7 +30370,11 @@ async function processWave(wave, waveIdx, totalWaves, opts) {
   const tasks = wave.map(
     (entry, taskIndex) => createWorkerTask(entry, taskIndex, waveNumber, opts)
   );
-  const waveResults = await executeWithConcurrencyLimit(tasks, opts.maxConcurrency);
+  const waveResults = await executeWithConcurrencyLimit(
+    tasks,
+    opts.maxConcurrency,
+    opts.options.signal
+  );
   for (const result of waveResults) {
     opts.failureTracker.record(result);
   }
@@ -33098,6 +33151,11 @@ async function tryWorkerDispatch(agentPlan, task, deps, logger56, notifier) {
   if (agentPlan === void 0 || !isWorkerDispatchEnabled() || adapter === void 0) {
     return void 0;
   }
+  const abortSignal = abortSignalStorage.getStore();
+  if (abortSignal?.aborted === true) {
+    logger56.info("Worker dispatch aborted before start (client cancelled)");
+    return void 0;
+  }
   try {
     return await withProgressHeartbeat(
       "worker-dispatch",
@@ -35073,7 +35131,8 @@ function resolveContextWarnThreshold(env = process.env) {
   return DEFAULT_CONTEXT_WARN_THRESHOLD;
 }
 function computeExpertContextUtilization(observation, threshold = DEFAULT_CONTEXT_WARN_THRESHOLD) {
-  const contextWindow = observation.modelId !== void 0 ? getModelContextWindow(observation.modelId) : 2e5;
+  const UNKNOWN_MODEL_CTX_DEFAULT = 8192;
+  const contextWindow = observation.modelId !== void 0 ? getModelContextWindow(observation.modelId) : UNKNOWN_MODEL_CTX_DEFAULT;
   const utilization = contextWindow > 0 ? observation.tokensUsed / contextWindow : 0;
   return {
     tokensUsed: observation.tokensUsed,
@@ -35278,15 +35337,17 @@ async function tryExpertFallback(expert, task, logger56) {
   logger56?.info("Retrying expert with fallback CLI", { role: expert.role, fallbackCli });
   const fallbackResult = createExpert(expert.expertConfig, { adapter: fallbackAdapter });
   if (!fallbackResult.ok) return void 0;
+  const fallbackStart = getTimeProvider().now();
   const result = await fallbackResult.value.execute(task);
   if (!result.ok) return void 0;
+  const fallbackDurationMs = getTimeProvider().now() - fallbackStart;
   return {
     ok: true,
     value: buildSuccessResponse({
       expertId: expert.id,
       role: expert.role,
       output: result.value.output,
-      durationMs: 0,
+      durationMs: fallbackDurationMs,
       tokensUsed: result.value.metadata.tokensUsed,
       modelUsed: fallbackCli
     })
@@ -36114,6 +36175,12 @@ function createError(code, source, message, cause) {
 function getToday() {
   return (/* @__PURE__ */ new Date()).toISOString().split("T")[0] ?? "";
 }
+function buildHttpErrorResult(status, source) {
+  const isRateLimit = status === 429;
+  const envHint = source === "github" ? "GITHUB_TOKEN" : `${source.toUpperCase()}_API_KEY`;
+  const message = isRateLimit ? `${source} rate-limited (HTTP 429) \u2014 set ${envHint} or retry later` : `API returned ${String(status)}`;
+  return createError(isRateLimit ? "RATE_LIMIT" : "HTTP_ERROR", source, message);
+}
 async function fetchSource(options) {
   const { url, source, headers, timeoutMs = SOURCE_API_TIMEOUT_MS } = options;
   try {
@@ -36121,10 +36188,7 @@ async function fetchSource(options) {
     if (headers !== void 0) fetchInit.headers = headers;
     const response = await fetch(url, fetchInit);
     if (!response.ok) {
-      return {
-        ok: false,
-        error: createError("HTTP_ERROR", source, `API returned ${String(response.status)}`)
-      };
+      return { ok: false, error: buildHttpErrorResult(response.status, source) };
     }
     return { ok: true, value: response };
   } catch (error) {
@@ -36151,7 +36215,7 @@ function parseGitHubRepos(data) {
   }));
 }
 async function discoverGitHubRepos(topic, maxResults = 10) {
-  const query = encodeURIComponent(`${topic} language:python OR language:typescript`);
+  const query = encodeURIComponent(topic);
   const url = `https://api.github.com/search/repositories?q=${query}&sort=stars&order=desc&per_page=${String(maxResults)}`;
   const headers = {
     Accept: "application/vnd.github.v3+json",
@@ -36395,10 +36459,18 @@ async function discoverSemanticScholar(topic, maxResults = 10) {
   const query = encodeURIComponent(topic);
   const fields = "title,url,abstract,citationCount,year,isOpenAccess,externalIds";
   const url = `https://api.semanticscholar.org/graph/v1/paper/search?query=${query}&limit=${String(maxResults)}&fields=${fields}`;
+  const headers = {
+    "User-Agent": "nexus-agents",
+    Accept: "application/json"
+  };
+  const apiKey = process.env["SEMANTIC_SCHOLAR_API_KEY"];
+  if (apiKey !== void 0 && apiKey !== "") {
+    headers["x-api-key"] = apiKey;
+  }
   const fetchResult = await fetchSource({
     url,
     source: "semantic_scholar",
-    headers: { "User-Agent": "nexus-agents", Accept: "application/json" }
+    headers
   });
   if (!fetchResult.ok) return fetchResult;
   let raw;
@@ -38082,6 +38154,7 @@ function recordTriageOutcome(success, durationMs, errorMsg) {
 
 // src/security/audit-trail.ts
 var MAX_EVENTS = 1e4;
+var MAX_STRIPPED_ELEMENTS_PER_EVENT = 20;
 var AuditTrail = class {
   events = [];
   nextId = 1;
@@ -40366,7 +40439,7 @@ async function tryIssueTriage(task) {
   try {
     const issueMatch = task.match(/github\.com\/([^/]+\/[^/]+)\/issues\/(\d+)/);
     if (issueMatch === null) return null;
-    const { createIssueTriage } = await import("./issue-triage-O3C7P66H.js");
+    const { createIssueTriage } = await import("./issue-triage-YYTE6KTC.js");
     const triage = createIssueTriage();
     const owner = issueMatch[1] ?? "";
     const num = issueMatch[2] ?? "";
@@ -40394,7 +40467,7 @@ var VALID_TEMPLATES = /* @__PURE__ */ new Set([
 ]);
 async function classifyWithLLM(task) {
   try {
-    const { executeExpert: executeExpert2 } = await import("./expert-bridge-KHHE42JP.js");
+    const { executeExpert: executeExpert2 } = await import("./expert-bridge-LT7PKUPS.js");
     const prompt = [
       "Classify this task into exactly one pipeline template.",
       "Templates: dev (implementation/bug fix/refactor), research (investigate/evaluate/compare),",
@@ -41188,7 +41261,7 @@ var memoryInitPromise = null;
 async function initPipelineMemory() {
   if (cachedMemory !== null) return cachedMemory;
   try {
-    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-HL5XDBIL.js");
+    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-DWF5Z2LC.js");
     const { LEARNING_DIR } = await import("./learning-persistence-WMWZJZ35.js");
     const mem = createSessionMemory2(LEARNING_DIR);
     mem.startSession(`pipeline-${String(Date.now())}`);
@@ -41241,7 +41314,7 @@ async function persistMobiMemState() {
     if (!isPersistenceEnabled()) return;
     const os6 = await import("os");
     const path20 = await import("path");
-    const { createMobiMem } = await import("./mobimem-FAOAXV3B.js");
+    const { createMobiMem } = await import("./mobimem-QDBP37H7.js");
     const mobimem = createMobiMem();
     const savePath = path20.join(os6.homedir(), ".nexus-agents", "memory", "mobimem-state.json");
     await mobimem.save(savePath);
@@ -41258,7 +41331,7 @@ function recordRoutingExperience(category, success, durationMs) {
     callRecord(routingMemoryCache);
     return;
   }
-  void import("./routing-memory-MXF45FXT.js").then(({ createRoutingMemory }) => {
+  void import("./routing-memory-W3YWMLJM.js").then(({ createRoutingMemory }) => {
     routingMemoryCache = createRoutingMemory();
     callRecord(routingMemoryCache);
   }).catch((error) => {
@@ -41287,7 +41360,7 @@ ${text}` : "";
 }
 async function getWeatherContext() {
   try {
-    const { generateWeatherReport: generateWeatherReport2 } = await import("./weather-report-XZ5CENHE.js");
+    const { generateWeatherReport: generateWeatherReport2 } = await import("./weather-report-YQSLX4MS.js");
     const report = generateWeatherReport2({ includeAdaptive: true });
     const mappings = "recommendedMappings" in report ? report.recommendedMappings : [];
     if (!Array.isArray(mappings) || mappings.length === 0) return "";
@@ -41304,7 +41377,7 @@ ${lines}
 }
 async function getMemoryContext(task) {
   try {
-    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-HL5XDBIL.js");
+    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-DWF5Z2LC.js");
     const { LEARNING_DIR } = await import("./learning-persistence-WMWZJZ35.js");
     const memory = createSessionMemory2(LEARNING_DIR, { maxLearningsInContext: 10 });
     const learnings = memory.searchLearnings(task.slice(0, 200));
@@ -41397,7 +41470,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-G6H532ME.js");
+        const { executeVoting } = await import("./consensus-vote-CQ2JP6DC.js");
         const votingResult = await executeVoting(
           {
             proposal: plan.slice(0, 4e3),
@@ -42266,7 +42339,7 @@ async function extractSymbolsForTask(task) {
 }
 async function retrieveAdaptiveMemory(task) {
   try {
-    const { AdaptiveMemoryBackend } = await import("./adaptive-memory-SUNFPY2W.js");
+    const { AdaptiveMemoryBackend } = await import("./adaptive-memory-TSZEJUJC.js");
     const os6 = await import("os");
     const path20 = await import("path");
     const baseDir = path20.join(os6.homedir(), ".nexus-agents", "memory");
@@ -42285,7 +42358,7 @@ async function retrieveAdaptiveMemory(task) {
 }
 async function queryResearchRegistry(task) {
   try {
-    const { synthesizeResearch: synthesizeResearch2 } = await import("./research-helpers-synthesize-E6WQLQKP.js");
+    const { synthesizeResearch: synthesizeResearch2 } = await import("./research-helpers-synthesize-NVQIWLQL.js");
     const topic = task.split(/[.!?\n]/).filter((s) => s.trim().length > 10)[0]?.trim();
     if (topic === void 0) return null;
     const result = await synthesizeResearch2(topic.slice(0, 50));
@@ -42370,7 +42443,7 @@ function createScanStageWrapper() {
       try {
         const slug = ctx.task.match(/([a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+)/)?.[1];
         if (slug !== void 0) {
-          const { generateSecurityPlan: generateSecurityPlan2 } = await import("./repo-security-plan-AZ5HMGFC.js");
+          const { generateSecurityPlan: generateSecurityPlan2 } = await import("./repo-security-plan-C3LLE3Z7.js");
           const plan = await generateSecurityPlan2({ repo: slug, maxScanners: 10 });
           const recs = plan.recommendations.slice(0, 5).map((r) => `${r.priority}: ${r.displayName} (${r.category})`).join("; ");
           ctx.sharedMemory.write("scan", "decision", { recommendations: recs });
@@ -42410,10 +42483,265 @@ function createAuditStageRegistry() {
   ]);
 }
 
-// src/mcp/tools/query-task-state-tool.ts
+// src/mcp/tools/pr-review-tool.ts
 import { z as z89 } from "zod";
-var QueryTaskStateInputSchema = z89.object({
-  taskId: z89.string().min(1).max(128).describe("Task ID whose structured state log should be read")
+
+// src/mcp/tools/pr-review-findings.ts
+import { parse as parseYaml3 } from "yaml";
+function isFindingVerified(gate) {
+  if (gate.reread_cited_line !== "passed") return false;
+  if (gate.traced_call_path !== "passed") return false;
+  if (gate.ruled_out_language_non_issue !== "passed") return false;
+  if (gate.named_assertion.trim().length < 10) return false;
+  if (/^(passed|ok|yes|done|verified)$/i.test(gate.named_assertion.trim())) return false;
+  return true;
+}
+var FINDINGS_BLOCK_RE = /```yaml findings\n([\s\S]*?)\n```/;
+function parseFindings(reasoning) {
+  const match = FINDINGS_BLOCK_RE.exec(reasoning);
+  if (match === null) return [];
+  const yamlBody = match[1];
+  if (yamlBody === void 0 || yamlBody.trim() === "") return [];
+  let parsed;
+  try {
+    parsed = parseYaml3(yamlBody);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  return parsed.map(coerceFinding).filter((f) => f !== null);
+}
+function coerceFinding(raw) {
+  if (raw === null || typeof raw !== "object") return null;
+  const r = raw;
+  if (typeof r["summary"] !== "string" || r["summary"].trim() === "") return null;
+  if (typeof r["location"] !== "string" || r["location"].trim() === "") return null;
+  if (typeof r["claim"] !== "string" || r["claim"].trim() === "") return null;
+  const gate = coerceGate(r["gate"]);
+  if (gate === null) return null;
+  const severity = coerceSeverity(r["severity"]);
+  const finding = {
+    summary: r["summary"].trim(),
+    location: r["location"].trim(),
+    severity,
+    gate,
+    claim: r["claim"].trim(),
+    verified: isFindingVerified(gate)
+  };
+  return finding;
+}
+function coerceGate(raw) {
+  if (raw === null || typeof raw !== "object") return null;
+  const r = raw;
+  return {
+    reread_cited_line: coerceGateCheck(r["reread_cited_line"]),
+    traced_call_path: coerceGateCheck(r["traced_call_path"]),
+    named_assertion: typeof r["named_assertion"] === "string" ? r["named_assertion"] : "",
+    ruled_out_language_non_issue: coerceGateCheck(r["ruled_out_language_non_issue"])
+  };
+}
+function coerceGateCheck(raw) {
+  if (raw === "passed" || raw === "failed" || raw === "skipped") return raw;
+  if (raw === true) return "passed";
+  if (raw === false) return "failed";
+  return "skipped";
+}
+function coerceSeverity(raw) {
+  if (raw === "critical" || raw === "high" || raw === "medium" || raw === "low") return raw;
+  return "medium";
+}
+var FINDINGS_FORMAT_INSTRUCTIONS = `If you have one or more findings (claims that justify request_changes), emit them in a fenced YAML block at the END of your reasoning, exactly as below. If you're approving, OMIT the block entirely.
+
+\`\`\`yaml findings
+- summary: 'One-line summary of the issue'
+  location: path/file.ext:LINE
+  severity: critical | high | medium | low
+  gate:
+    reread_cited_line: passed
+    traced_call_path: passed
+    named_assertion: 'Concrete failing assertion \u2014 what test would fail and how. Must be substantive, not "passed".'
+    ruled_out_language_non_issue: passed
+  claim: 'What is wrong and why it justifies blocking the merge.'
+\`\`\`
+
+A finding only triggers request_changes if ALL FOUR gate checks are 'passed' AND named_assertion is substantive (>10 chars, naming a concrete failure). Findings missing any of those surface as informational only \u2014 they do not block the merge. This is the #2225 verification gate; the 2026-04-25 audit found a 100% false-positive rate when this gate was not enforced.`;
+
+// src/mcp/tools/pr-review-tool.ts
+var PR_REVIEW_ROLES = [
+  "architect",
+  "security",
+  "devex",
+  "catfish",
+  "scope_steward"
+];
+var MAX_DIFF_LENGTH = 5e4;
+var MAX_DESCRIPTION_LENGTH = 1e4;
+var PrReviewInputSchema = z89.object({
+  prTitle: z89.string().min(1).max(500).describe("PR title"),
+  prDescription: z89.string().max(MAX_DESCRIPTION_LENGTH).optional().describe("PR body / description"),
+  prDiff: z89.string().min(1).max(MAX_DIFF_LENGTH).describe(`Unified diff text (max ${String(MAX_DIFF_LENGTH)} chars; truncate before calling)`),
+  repoContext: z89.string().max(2e3).optional().describe("Optional one-paragraph repo context (architecture, conventions)"),
+  baseRef: z89.string().max(200).optional().describe("Base branch ref (e.g. main)"),
+  headRef: z89.string().max(200).optional().describe("Head branch ref"),
+  simulate: z89.boolean().default(false).describe("Use simulated voters (testing only; never ship live with this true)")
+});
+function mapVoteDecisionToPrDecision(voteDecision) {
+  if (voteDecision === "reject") return "request_changes";
+  return voteDecision;
+}
+var SOFT_BLOCK_REQUEST_CHANGES_THRESHOLD = 3;
+function aggregatePrDecisions(reviews) {
+  const valid = reviews.filter((r) => r.source !== "error");
+  if (valid.length === 0) return { decision: "abstain", verified: true };
+  const hasVerifiedBlocker = valid.some(
+    (r) => r.decision === "request_changes" && r.findings.some((f) => f.verified)
+  );
+  if (hasVerifiedBlocker) return { decision: "request_changes", verified: true };
+  const requestChangesVoters = valid.filter((r) => r.decision === "request_changes").length;
+  if (requestChangesVoters >= SOFT_BLOCK_REQUEST_CHANGES_THRESHOLD) {
+    return { decision: "request_changes", verified: false };
+  }
+  if (valid.every((r) => r.decision === "approve")) {
+    return { decision: "approve", verified: true };
+  }
+  return { decision: "abstain", verified: true };
+}
+function buildPrReviewProposal(input) {
+  const parts = [];
+  parts.push(`# Pull Request Review
+`);
+  parts.push(`**Title:** ${input.prTitle}
+`);
+  if (input.baseRef !== void 0 && input.headRef !== void 0) {
+    parts.push(`**Branches:** ${input.headRef} \u2192 ${input.baseRef}
+`);
+  }
+  if (input.repoContext !== void 0 && input.repoContext !== "") {
+    parts.push(`
+**Repo context:**
+${input.repoContext}
+`);
+  }
+  if (input.prDescription !== void 0 && input.prDescription !== "") {
+    parts.push(`
+**Description:**
+${input.prDescription}
+`);
+  }
+  parts.push(`
+## Diff
+
+\`\`\`diff
+${input.prDiff}
+\`\`\`
+`);
+  parts.push(`
+## Your task
+`);
+  parts.push(`Review this PR from your role's perspective. Decide: should it be merged as-is?
+`);
+  parts.push(`- **APPROVE** if the diff is correct, complete, and aligned with your role.
+`);
+  parts.push(
+    `- **REJECT** (= "request changes") if there is at least one concrete defect, missing requirement, or violation that justifies blocking the merge.
+`
+  );
+  parts.push(`- **ABSTAIN** if the diff is outside your role's concerns.
+`);
+  parts.push(`
+${FINDINGS_FORMAT_INSTRUCTIONS}
+`);
+  return parts.join("");
+}
+function resolveFindings(result) {
+  const raw = result.vote.findings;
+  if (raw !== void 0 && raw.length > 0) {
+    return raw.map((f) => ({
+      summary: f.summary,
+      location: f.location,
+      severity: f.severity,
+      gate: f.gate,
+      claim: f.claim,
+      verified: isFindingVerified(f.gate)
+    }));
+  }
+  return parseFindings(result.vote.reasoning);
+}
+function toPrReviewVote(result) {
+  return {
+    role: result.role,
+    decision: mapVoteDecisionToPrDecision(result.vote.decision),
+    confidence: result.vote.confidence,
+    reasoning: result.vote.reasoning,
+    findings: resolveFindings(result),
+    source: result.source,
+    cli: result.cli,
+    processingTimeMs: result.processingTimeMs,
+    ...result.error !== void 0 && { errorMessage: result.error }
+  };
+}
+function summarizeReviews(reviews) {
+  return {
+    approveCount: reviews.filter((r) => r.source !== "error" && r.decision === "approve").length,
+    requestChangesCount: reviews.filter(
+      (r) => r.source !== "error" && r.decision === "request_changes"
+    ).length,
+    abstainCount: reviews.filter((r) => r.source !== "error" && r.decision === "abstain").length,
+    errorCount: reviews.filter((r) => r.source === "error").length
+  };
+}
+async function prReviewHandler(args, ctx) {
+  const parsed = PrReviewInputSchema.safeParse(args);
+  if (!parsed.success) {
+    return toolError(`Validation error: ${formatZodError(parsed.error)}`);
+  }
+  const input = parsed.data;
+  const start = Date.now();
+  try {
+    const proposal = buildPrReviewProposal(input);
+    const voteResults = await collectRealVotes({
+      roles: PR_REVIEW_ROLES,
+      proposal,
+      simulate: input.simulate,
+      logger: ctx.logger
+    });
+    const reviews = voteResults.map(toPrReviewVote);
+    const counts = summarizeReviews(reviews);
+    const aggregate = aggregatePrDecisions(reviews);
+    const response = {
+      summary: aggregate.decision,
+      verified: aggregate.verified,
+      ...counts,
+      reviews,
+      totalDurationMs: Date.now() - start
+    };
+    return toolSuccess(JSON.stringify(response, null, 2));
+  } catch (error) {
+    return toolError(`PR review failed: ${getErrorMessage(error)}`);
+  }
+}
+function registerPrReviewTool(server, deps) {
+  const logger56 = deps.logger ?? createLogger({ tool: "pr_review" });
+  const description = "Run multi-voter consensus review on a PR diff (#2233). 5 voters (architect, security, devex, catfish, scope_steward) each emit approve/request_changes/abstain with reasoning and citations. Reuses consensus_vote infra; experimental.";
+  const secureHandler = createSecureHandler(prReviewHandler, {
+    toolName: "pr_review",
+    rateLimiter: deps.rateLimiter,
+    logger: logger56
+  });
+  const timeoutMs = getToolTimeout("pr_review", deps.security);
+  const wrappedHandler = wrapToolWithTimeout("pr_review", secureHandler, { timeoutMs, logger: logger56 });
+  server.registerTool(
+    "pr_review",
+    { description, inputSchema: PrReviewInputSchema.shape },
+    toSdkCallback(wrappedHandler)
+  );
+  logger56.info("Registered pr_review tool");
+}
+
+// src/mcp/tools/query-task-state-tool.ts
+import { z as z90 } from "zod";
+var QueryTaskStateInputSchema = z90.object({
+  taskId: z90.string().min(1).max(128).describe("Task ID whose structured state log should be read")
 });
 function queryTaskStateHandler(args, ctx) {
   const parsed = QueryTaskStateInputSchema.safeParse(args);
@@ -42443,7 +42771,7 @@ function queryTaskStateHandler(args, ctx) {
 function registerQueryTaskStateTool(server, deps) {
   const logger56 = deps.logger ?? createLogger({ tool: "query_task_state" });
   const toolSchema = {
-    taskId: z89.string().min(1).max(128).describe("Task ID whose structured state log should be read")
+    taskId: z90.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. Structured state is only written when NEXUS_TASK_STATE_ENABLED=1 was set during the orchestrate invocation.";
   const secureHandler = createSecureHandler(queryTaskStateHandler, {
@@ -42465,18 +42793,18 @@ function registerQueryTaskStateTool(server, deps) {
 }
 
 // src/mcp/tools/pipeline-tool.ts
-import { z as z90 } from "zod";
+import { z as z91 } from "zod";
 import * as fs9 from "fs";
 import * as path11 from "path";
-var PipelineInputSchema = z90.object({
+var PipelineInputSchema = z91.object({
   /** The task to execute. */
-  task: z90.string().min(5).max(1e4).describe("Task description \u2014 pipeline template auto-selected based on content"),
+  task: z91.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: z90.string().max(500).optional().describe("Path to a spec file \u2014 content prepended to task for greenfield projects"),
+  specFile: z91.string().max(500).optional().describe("Path to a spec file \u2014 content prepended to task for greenfield projects"),
   /** Override template (dev, research, audit, greenfield). Auto-detected if omitted. */
-  template: z90.string().max(50).optional().describe(`Pipeline template override. Available: ${listTemplateIds().join(", ")}`),
+  template: z91.string().max(50).optional().describe(`Pipeline template override. Available: ${listTemplateIds().join(", ")}`),
   /** Voting strategy for consensus stages. */
-  votingStrategy: z90.enum([
+  votingStrategy: z91.enum([
     "simple_majority",
     "supermajority",
     "unanimous",
@@ -42487,13 +42815,13 @@ var PipelineInputSchema = z90.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: z90.boolean().default(false).describe("Use 3 agents instead of 6 for faster consensus voting"),
+  quickMode: z91.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: z90.number().int().min(3e4).max(6e5).optional().describe("Max time per stage in ms (30000-600000). Default: varies by stage complexity"),
+  timeoutMs: z91.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: z90.boolean().default(false).describe("Stop after vote stage (no implementation)"),
+  dryRun: z91.boolean().default(false).describe("Stop after vote stage (no implementation)"),
   /** Use simulated votes (for testing). */
-  simulateVotes: z90.boolean().default(false).describe("Use simulated votes (for testing without real CLIs)")
+  simulateVotes: z91.boolean().default(false).describe("Use simulated votes (for testing without real CLIs)")
 });
 function buildOutput2(result) {
   return {
@@ -42981,7 +43309,8 @@ function registerTools(server, options) {
       "extract_symbols",
       "search_codebase",
       "run_dev_pipeline",
-      "run_pipeline"
+      "run_pipeline",
+      "pr_review"
     ],
     logger: logger56,
     rateLimiter
@@ -43109,40 +43438,40 @@ var RiskLevel = /* @__PURE__ */ ((RiskLevel2) => {
 })(RiskLevel || {});
 
 // src/mcp/safety/stpa-schemas.ts
-import { z as z91 } from "zod";
-var HazardCategorySchema = z91.enum(HazardCategory);
-var HazardSeveritySchema = z91.enum(HazardSeverity);
-var ConstraintPrioritySchema = z91.enum(ConstraintPriority);
-var RiskLevelSchema = z91.enum(RiskLevel);
-var TriggerPatternSchema = z91.object({
-  parameter: z91.string().min(1),
-  matchType: z91.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
-  pattern: z91.string(),
-  reason: z91.string()
+import { z as z92 } from "zod";
+var HazardCategorySchema = z92.enum(HazardCategory);
+var HazardSeveritySchema = z92.enum(HazardSeverity);
+var ConstraintPrioritySchema = z92.enum(ConstraintPriority);
+var RiskLevelSchema = z92.enum(RiskLevel);
+var TriggerPatternSchema = z92.object({
+  parameter: z92.string().min(1),
+  matchType: z92.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
+  pattern: z92.string(),
+  reason: z92.string()
 });
-var HazardSchema = z91.object({
-  id: z91.string().min(1),
-  description: z91.string(),
+var HazardSchema = z92.object({
+  id: z92.string().min(1),
+  description: z92.string(),
   category: HazardCategorySchema,
   severity: HazardSeveritySchema,
-  likelihood: z91.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
-  triggerConditions: z91.array(z91.string()),
-  consequences: z91.array(z91.string())
+  likelihood: z92.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
+  triggerConditions: z92.array(z92.string()),
+  consequences: z92.array(z92.string())
 });
-var UnsafeControlActionSchema = z91.object({
-  id: z91.string().min(1),
-  toolName: z91.string().min(1),
-  type: z91.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
-  description: z91.string(),
-  unsafeContext: z91.string(),
-  relatedHazards: z91.array(z91.string()),
-  triggerPatterns: z91.array(TriggerPatternSchema).optional()
+var UnsafeControlActionSchema = z92.object({
+  id: z92.string().min(1),
+  toolName: z92.string().min(1),
+  type: z92.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
+  description: z92.string(),
+  unsafeContext: z92.string(),
+  relatedHazards: z92.array(z92.string()),
+  triggerPatterns: z92.array(TriggerPatternSchema).optional()
 });
-var SafetyConstraintSchema = z91.object({
-  id: z91.string().min(1),
-  description: z91.string(),
-  mitigates: z91.array(z91.string()),
-  enforcement: z91.enum([
+var SafetyConstraintSchema = z92.object({
+  id: z92.string().min(1),
+  description: z92.string(),
+  mitigates: z92.array(z92.string()),
+  enforcement: z92.enum([
     "prevent",
     "require_confirmation",
     "alert",
@@ -43150,54 +43479,54 @@ var SafetyConstraintSchema = z91.object({
     "rate_limit",
     "require_privilege"
   ]),
-  validationFunction: z91.string().optional(),
+  validationFunction: z92.string().optional(),
   priority: ConstraintPrioritySchema
 });
-var PropertySchemaSchema = z91.object({
-  type: z91.string(),
-  description: z91.string().optional(),
-  enum: z91.array(z91.unknown()).optional(),
-  pattern: z91.string().optional(),
-  minimum: z91.number().optional(),
-  maximum: z91.number().optional()
+var PropertySchemaSchema = z92.object({
+  type: z92.string(),
+  description: z92.string().optional(),
+  enum: z92.array(z92.unknown()).optional(),
+  pattern: z92.string().optional(),
+  minimum: z92.number().optional(),
+  maximum: z92.number().optional()
 });
-var ToolInputSchemaSchema = z91.object({
-  type: z91.string(),
-  properties: z91.record(z91.string(), PropertySchemaSchema).optional(),
-  required: z91.array(z91.string()).optional(),
-  additionalProperties: z91.boolean().optional()
+var ToolInputSchemaSchema = z92.object({
+  type: z92.string(),
+  properties: z92.record(z92.string(), PropertySchemaSchema).optional(),
+  required: z92.array(z92.string()).optional(),
+  additionalProperties: z92.boolean().optional()
 });
-var ToolDefinitionSchema = z91.object({
-  name: z91.string().min(1),
-  description: z91.string(),
+var ToolDefinitionSchema = z92.object({
+  name: z92.string().min(1),
+  description: z92.string(),
   inputSchema: ToolInputSchemaSchema
 });
-var AnalysisConfigurationSchema = z91.object({
-  includeLowSeverity: z91.boolean().default(true),
-  generateAllConstraints: z91.boolean().default(true),
-  checkInteractions: z91.boolean().default(true),
-  maxHazardsPerTool: z91.number().int().min(1).max(100).default(50),
-  categories: z91.array(HazardCategorySchema).default([])
+var AnalysisConfigurationSchema = z92.object({
+  includeLowSeverity: z92.boolean().default(true),
+  generateAllConstraints: z92.boolean().default(true),
+  checkInteractions: z92.boolean().default(true),
+  maxHazardsPerTool: z92.number().int().min(1).max(100).default(50),
+  categories: z92.array(HazardCategorySchema).default([])
 });
-var ConstraintViolationSchema = z91.object({
-  constraintId: z91.string().min(1),
-  constraintDescription: z91.string(),
+var ConstraintViolationSchema = z92.object({
+  constraintId: z92.string().min(1),
+  constraintDescription: z92.string(),
   severity: HazardSeveritySchema,
-  details: z91.string(),
-  remediation: z91.string()
+  details: z92.string(),
+  remediation: z92.string()
 });
-var ValidationWarningSchema = z91.object({
-  code: z91.string().min(1),
-  message: z91.string(),
-  affected: z91.string()
+var ValidationWarningSchema = z92.object({
+  code: z92.string().min(1),
+  message: z92.string(),
+  affected: z92.string()
 });
-var ValidationResultSchema = z91.object({
-  valid: z91.boolean(),
-  toolName: z91.string().min(1),
-  violations: z91.array(ConstraintViolationSchema),
-  passed: z91.array(z91.string()),
-  warnings: z91.array(ValidationWarningSchema),
-  validatedAt: z91.date()
+var ValidationResultSchema = z92.object({
+  valid: z92.boolean(),
+  toolName: z92.string().min(1),
+  violations: z92.array(ConstraintViolationSchema),
+  passed: z92.array(z92.string()),
+  warnings: z92.array(ValidationWarningSchema),
+  validatedAt: z92.date()
 });
 
 // src/mcp/safety/stpa-types.ts
@@ -44282,22 +44611,22 @@ var GeminiResponseParser = class {
 };
 
 // src/cli-adapters/task-analyzer.ts
-import { z as z92 } from "zod";
-var TaskProfileSchema = z92.object({
+import { z as z93 } from "zod";
+var TaskProfileSchema = z93.object({
   /** Estimated input tokens required */
-  contextRequired: z92.number().min(0),
+  contextRequired: z93.number().min(0),
   /** Reasoning complexity on 0-10 scale */
-  reasoningComplexity: z92.number().min(0).max(10),
+  reasoningComplexity: z93.number().min(0).max(10),
   /** Whether task involves code generation */
-  codeGeneration: z92.boolean(),
+  codeGeneration: z93.boolean(),
   /** Whether task involves multimodal content (images, etc.) */
-  multimodal: z92.boolean(),
+  multimodal: z93.boolean(),
   /** Whether task can be split into parallel subtasks */
-  parallelizable: z92.boolean(),
+  parallelizable: z93.boolean(),
   /** Whether cost should be minimized */
-  budgetSensitive: z92.boolean(),
+  budgetSensitive: z93.boolean(),
   /** Primary task type classification */
-  taskType: z92.enum([
+  taskType: z93.enum([
     "architecture",
     "code_implementation",
     "code_review",
@@ -44311,53 +44640,53 @@ var TaskProfileSchema = z92.object({
 });
 
 // src/cli-adapters/router-types.ts
-import { z as z93 } from "zod";
-var RouterConfigSchema = z93.object({
-  minCapacityThreshold: z93.number().min(0).max(1).default(0.1),
-  preferCostEfficient: z93.boolean().default(false),
-  maxDecisionTimeMs: z93.number().min(1).max(1e3).default(100)
+import { z as z94 } from "zod";
+var RouterConfigSchema = z94.object({
+  minCapacityThreshold: z94.number().min(0).max(1).default(0.1),
+  preferCostEfficient: z94.boolean().default(false),
+  maxDecisionTimeMs: z94.number().min(1).max(1e3).default(100)
 });
 
 // src/cli-adapters/agreement-cascade-types.ts
-import { z as z94 } from "zod";
-var AgreementCascadeConfigSchema = z94.object({
-  agreementThreshold: z94.number().min(0.5).max(1).default(0.7),
-  maxStages: z94.number().int().min(1).max(5).default(3),
-  modelTimeoutMs: z94.number().int().min(1e3).max(3e5).default(6e4)
+import { z as z95 } from "zod";
+var AgreementCascadeConfigSchema = z95.object({
+  agreementThreshold: z95.number().min(0.5).max(1).default(0.7),
+  maxStages: z95.number().int().min(1).max(5).default(3),
+  modelTimeoutMs: z95.number().int().min(1e3).max(3e5).default(6e4)
 });
 
 // src/cli-adapters/agreement-cascade-router.ts
 var logger42 = createLogger({ component: "agreement-cascade-router" });
 
 // src/cli-adapters/daao-types.ts
-import { z as z95 } from "zod";
-var EncodedFeaturesSchema = z95.object({
+import { z as z96 } from "zod";
+var EncodedFeaturesSchema = z96.object({
   /** Lexical complexity score (vocabulary diversity, rare words) */
-  lexicalComplexity: z95.number().min(0).max(1),
+  lexicalComplexity: z96.number().min(0).max(1),
   /** Syntactic complexity score (sentence structure, nesting) */
-  syntacticComplexity: z95.number().min(0).max(1),
+  syntacticComplexity: z96.number().min(0).max(1),
   /** Semantic density score (concept density, abstraction level) */
-  semanticDensity: z95.number().min(0).max(1),
+  semanticDensity: z96.number().min(0).max(1),
   /** Technical specificity (domain-specific terminology) */
-  technicalSpecificity: z95.number().min(0).max(1),
+  technicalSpecificity: z96.number().min(0).max(1),
   /** Task scope (breadth of requirements) */
-  taskScope: z95.number().min(0).max(1),
+  taskScope: z96.number().min(0).max(1),
   /** Constraint complexity (constraints, edge cases, requirements) */
-  constraintComplexity: z95.number().min(0).max(1),
+  constraintComplexity: z96.number().min(0).max(1),
   /** Ambiguity level (inverse - higher means more clear/specific) */
-  clarity: z95.number().min(0).max(1),
+  clarity: z96.number().min(0).max(1),
   /** Output complexity expectation */
-  outputComplexity: z95.number().min(0).max(1)
+  outputComplexity: z96.number().min(0).max(1)
 });
-var FeatureWeightsSchema = z95.object({
-  lexicalComplexity: z95.number().min(0).max(1),
-  syntacticComplexity: z95.number().min(0).max(1),
-  semanticDensity: z95.number().min(0).max(1),
-  technicalSpecificity: z95.number().min(0).max(1),
-  taskScope: z95.number().min(0).max(1),
-  constraintComplexity: z95.number().min(0).max(1),
-  clarity: z95.number().min(0).max(1),
-  outputComplexity: z95.number().min(0).max(1)
+var FeatureWeightsSchema = z96.object({
+  lexicalComplexity: z96.number().min(0).max(1),
+  syntacticComplexity: z96.number().min(0).max(1),
+  semanticDensity: z96.number().min(0).max(1),
+  technicalSpecificity: z96.number().min(0).max(1),
+  taskScope: z96.number().min(0).max(1),
+  constraintComplexity: z96.number().min(0).max(1),
+  clarity: z96.number().min(0).max(1),
+  outputComplexity: z96.number().min(0).max(1)
 });
 var DEFAULT_FEATURE_WEIGHTS = {
   lexicalComplexity: 0.1,
@@ -44379,50 +44708,50 @@ var DEFAULT_DAAO_TIER_TO_CLIS = {
   balanced: ["codex", "opencode", "gemini", "claude"],
   powerful: ["claude", "codex", "opencode", "gemini"]
 };
-var DAAOConfigSchema = z95.object({
+var DAAOConfigSchema = z96.object({
   /** Difficulty thresholds for level classification */
-  thresholds: z95.object({
-    easyUpperBound: z95.number().min(0).max(1),
-    hardLowerBound: z95.number().min(0).max(1)
+  thresholds: z96.object({
+    easyUpperBound: z96.number().min(0).max(1),
+    hardLowerBound: z96.number().min(0).max(1)
   }).default(DEFAULT_DAAO_THRESHOLDS),
   /** Feature weights for difficulty aggregation */
   weights: FeatureWeightsSchema.default(DEFAULT_FEATURE_WEIGHTS),
   /** Mapping from model tier to CLI preference order */
-  tierToClis: z95.record(
-    z95.enum(["fast", "balanced", "powerful"]),
-    z95.array(z95.enum(["claude", "gemini", "codex", "opencode"]))
+  tierToClis: z96.record(
+    z96.enum(["fast", "balanced", "powerful"]),
+    z96.array(z96.enum(["claude", "gemini", "codex", "opencode"]))
   ).default(DEFAULT_DAAO_TIER_TO_CLIS),
   /** Enable adaptive calibration from outcomes */
-  enableCalibration: z95.boolean().default(true),
+  enableCalibration: z96.boolean().default(true),
   /** Maximum outcomes to store for calibration */
-  maxCalibrationOutcomes: z95.number().int().positive().default(1e3),
+  maxCalibrationOutcomes: z96.number().int().positive().default(1e3),
   /** Minimum outcomes before applying calibration adjustments */
-  minCalibrationOutcomes: z95.number().int().positive().default(50),
+  minCalibrationOutcomes: z96.number().int().positive().default(50),
   /** Reconstruction error threshold for typical patterns */
-  typicalPatternThreshold: z95.number().min(0).max(1).default(0.3),
+  typicalPatternThreshold: z96.number().min(0).max(1).default(0.3),
   /** Verbose logging */
-  verbose: z95.boolean().default(false)
+  verbose: z96.boolean().default(false)
 });
 
 // src/cli-adapters/task-classifier.ts
-import { z as z96 } from "zod";
-var ClassificationPatternsSchema = z96.object({
-  code: z96.array(z96.string()).readonly(),
-  research: z96.array(z96.string()).readonly(),
-  documentation: z96.array(z96.string()).readonly(),
-  analysis: z96.array(z96.string()).readonly()
+import { z as z97 } from "zod";
+var ClassificationPatternsSchema = z97.object({
+  code: z97.array(z97.string()).readonly(),
+  research: z97.array(z97.string()).readonly(),
+  documentation: z97.array(z97.string()).readonly(),
+  analysis: z97.array(z97.string()).readonly()
 });
 
 // src/cli-adapters/response-cache-types.ts
-import { z as z97 } from "zod";
-var ResponseCacheConfigSchema = z97.object({
-  defaultTTL: z97.number().min(1e3).max(36e5).default(3e5),
+import { z as z98 } from "zod";
+var ResponseCacheConfigSchema = z98.object({
+  defaultTTL: z98.number().min(1e3).max(36e5).default(3e5),
   // 5 minutes
-  maxEntries: z97.number().min(10).max(1e5).default(1e3),
-  maxMemoryMB: z97.number().min(1).max(1e3).default(50),
-  cleanupInterval: z97.number().min(1e3).max(6e5).default(6e4),
+  maxEntries: z98.number().min(10).max(1e5).default(1e3),
+  maxMemoryMB: z98.number().min(1).max(1e3).default(50),
+  cleanupInterval: z98.number().min(1e3).max(6e5).default(6e4),
   // 1 minute
-  enableLogging: z97.boolean().default(false)
+  enableLogging: z98.boolean().default(false)
 });
 
 // src/cli-adapters/response-cache-utils.ts
@@ -44430,12 +44759,12 @@ import { createHash as createHash3 } from "crypto";
 var logger43 = createLogger({ component: "ResponseCacheUtils" });
 
 // src/cli-adapters/unified-routing-types.ts
-import { z as z98 } from "zod";
-var UnifiedRoutingDecisionSchema = z98.object({
-  selectedCli: z98.string(),
-  confidence: z98.number().min(0).max(1),
-  reason: z98.string(),
-  strategy: z98.enum([
+import { z as z99 } from "zod";
+var UnifiedRoutingDecisionSchema = z99.object({
+  selectedCli: z99.string(),
+  confidence: z99.number().min(0).max(1),
+  reason: z99.string(),
+  strategy: z99.enum([
     "composite",
     "quality",
     "budget",
@@ -44447,57 +44776,57 @@ var UnifiedRoutingDecisionSchema = z98.object({
     "linucb",
     "direct"
   ]),
-  decisionTimeMs: z98.number().nonnegative(),
-  alternatives: z98.array(z98.string()).readonly(),
-  stagesExecuted: z98.array(z98.string()).readonly(),
-  withinBudget: z98.boolean().optional(),
-  estimatedComplexity: z98.enum(["simple", "moderate", "complex", "expert"]).optional(),
-  estimatedTokens: z98.number().int().positive().optional(),
-  topsisScore: z98.number().optional(),
-  ucbScore: z98.number().optional(),
-  resolvedAtStage: z98.number().int().nonnegative().optional(),
-  consensusReached: z98.boolean().optional(),
-  agreementScore: z98.number().min(0).max(1).optional(),
-  metadata: z98.record(z98.string(), z98.unknown()).optional()
+  decisionTimeMs: z99.number().nonnegative(),
+  alternatives: z99.array(z99.string()).readonly(),
+  stagesExecuted: z99.array(z99.string()).readonly(),
+  withinBudget: z99.boolean().optional(),
+  estimatedComplexity: z99.enum(["simple", "moderate", "complex", "expert"]).optional(),
+  estimatedTokens: z99.number().int().positive().optional(),
+  topsisScore: z99.number().optional(),
+  ucbScore: z99.number().optional(),
+  resolvedAtStage: z99.number().int().nonnegative().optional(),
+  consensusReached: z99.boolean().optional(),
+  agreementScore: z99.number().min(0).max(1).optional(),
+  metadata: z99.record(z99.string(), z99.unknown()).optional()
 });
 
 // src/learning/outcome-feedback-types.ts
-import { z as z99 } from "zod";
-var QualitySignalsSchema = z99.object({
-  testsPass: z99.boolean().optional(),
-  lintErrors: z99.number().int().min(0).optional(),
-  userApproved: z99.boolean().optional(),
-  retryCount: z99.number().int().min(0).default(0),
-  completionRatio: z99.number().min(0).max(1).default(1),
-  validStructure: z99.boolean().optional(),
-  coherenceScore: z99.number().min(0).max(1).optional()
+import { z as z100 } from "zod";
+var QualitySignalsSchema = z100.object({
+  testsPass: z100.boolean().optional(),
+  lintErrors: z100.number().int().min(0).optional(),
+  userApproved: z100.boolean().optional(),
+  retryCount: z100.number().int().min(0).default(0),
+  completionRatio: z100.number().min(0).max(1).default(1),
+  validStructure: z100.boolean().optional(),
+  coherenceScore: z100.number().min(0).max(1).optional()
 });
-var RoutingDecisionSchema = z99.object({
-  id: z99.uuid(),
-  timestamp: z99.iso.datetime(),
-  query: z99.string(),
-  routerType: z99.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
-  selectedModel: z99.string(),
-  selectedTier: z99.enum(["strong", "weak"]).optional(),
-  armIndex: z99.number().int().min(0).optional(),
-  banditContext: z99.record(z99.string(), z99.unknown()).optional(),
-  queryFeatures: z99.record(z99.string(), z99.unknown()).optional(),
-  ucbScore: z99.number().optional(),
-  confidence: z99.number().min(0).max(1).optional(),
-  traceId: z99.string(),
-  domain: z99.string().optional()
+var RoutingDecisionSchema = z100.object({
+  id: z100.uuid(),
+  timestamp: z100.iso.datetime(),
+  query: z100.string(),
+  routerType: z100.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
+  selectedModel: z100.string(),
+  selectedTier: z100.enum(["strong", "weak"]).optional(),
+  armIndex: z100.number().int().min(0).optional(),
+  banditContext: z100.record(z100.string(), z100.unknown()).optional(),
+  queryFeatures: z100.record(z100.string(), z100.unknown()).optional(),
+  ucbScore: z100.number().optional(),
+  confidence: z100.number().min(0).max(1).optional(),
+  traceId: z100.string(),
+  domain: z100.string().optional()
 });
-var TaskOutcomeSchema = z99.object({
-  routingDecisionId: z99.uuid(),
-  timestamp: z99.iso.datetime(),
-  outcomeClass: z99.enum(["success", "partial", "failure", "timeout", "error"]),
-  success: z99.boolean(),
-  qualityScore: z99.number().min(0).max(1),
-  durationMs: z99.number().min(0),
-  tokenUsage: z99.number().int().min(0),
-  errorMessage: z99.string().optional(),
+var TaskOutcomeSchema = z100.object({
+  routingDecisionId: z100.uuid(),
+  timestamp: z100.iso.datetime(),
+  outcomeClass: z100.enum(["success", "partial", "failure", "timeout", "error"]),
+  success: z100.boolean(),
+  qualityScore: z100.number().min(0).max(1),
+  durationMs: z100.number().min(0),
+  tokenUsage: z100.number().int().min(0),
+  errorMessage: z100.string().optional(),
   qualitySignals: QualitySignalsSchema,
-  traceId: z99.string()
+  traceId: z100.string()
 });
 var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   maxPendingDecisions: 1e3,
@@ -44512,17 +44841,17 @@ var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   targetTokenUsage: 2e3,
   maxHistorySize: 1e4
 };
-var FeedbackCollectorConfigSchema = z99.object({
-  maxPendingDecisions: z99.number().int().positive().default(1e3),
-  pendingTimeoutMs: z99.number().positive().default(3e5),
-  enableAutoReward: z99.boolean().default(true),
-  qualityWeight: z99.number().min(0).max(1).default(0.5),
-  speedWeight: z99.number().min(0).max(1).default(0.2),
-  efficiencyWeight: z99.number().min(0).max(1).default(0.2),
-  retryPenalty: z99.number().min(0).max(1).default(0.1),
-  targetDurationMs: z99.number().positive().default(5e3),
-  targetTokenUsage: z99.number().positive().default(2e3),
-  maxHistorySize: z99.number().int().positive().default(1e4)
+var FeedbackCollectorConfigSchema = z100.object({
+  maxPendingDecisions: z100.number().int().positive().default(1e3),
+  pendingTimeoutMs: z100.number().positive().default(3e5),
+  enableAutoReward: z100.boolean().default(true),
+  qualityWeight: z100.number().min(0).max(1).default(0.5),
+  speedWeight: z100.number().min(0).max(1).default(0.2),
+  efficiencyWeight: z100.number().min(0).max(1).default(0.2),
+  retryPenalty: z100.number().min(0).max(1).default(0.1),
+  targetDurationMs: z100.number().positive().default(5e3),
+  targetTokenUsage: z100.number().positive().default(2e3),
+  maxHistorySize: z100.number().int().positive().default(1e4)
 });
 
 // src/learning/outcome-feedback-helpers.ts
@@ -45172,7 +45501,7 @@ function computeOutcomeReward(collector, outcome) {
 }
 
 // src/audit/audit-types.ts
-import { z as z100 } from "zod";
+import { z as z101 } from "zod";
 var AuditError = class extends Error {
   code = "AUDIT_ERROR";
   context;
@@ -45184,7 +45513,7 @@ var AuditError = class extends Error {
     this.context = options?.context;
   }
 };
-var AuditCategorySchema = z100.enum([
+var AuditCategorySchema = z101.enum([
   "authentication",
   // Login, logout, token refresh
   "authorization",
@@ -45202,7 +45531,7 @@ var AuditCategorySchema = z100.enum([
   "system"
   // System events, startup, shutdown
 ]);
-var AuditSeveritySchema = z100.enum([
+var AuditSeveritySchema = z101.enum([
   "info",
   // Normal operations
   "warning",
@@ -45210,7 +45539,7 @@ var AuditSeveritySchema = z100.enum([
   "critical"
   // Security violations, failures
 ]);
-var AuditOutcomeSchema = z100.enum([
+var AuditOutcomeSchema = z101.enum([
   "success",
   // Operation completed successfully
   "failure",
@@ -45220,108 +45549,108 @@ var AuditOutcomeSchema = z100.enum([
   "error"
   // Unexpected error occurred
 ]);
-var AuditActorSchema = z100.object({
-  type: z100.enum(["user", "agent", "system", "external"]),
-  id: z100.string().min(1),
-  name: z100.string().optional(),
-  ip: z100.string().optional(),
-  userAgent: z100.string().optional()
+var AuditActorSchema = z101.object({
+  type: z101.enum(["user", "agent", "system", "external"]),
+  id: z101.string().min(1),
+  name: z101.string().optional(),
+  ip: z101.string().optional(),
+  userAgent: z101.string().optional()
 });
-var AuditResourceSchema = z100.object({
-  type: z100.string().min(1),
+var AuditResourceSchema = z101.object({
+  type: z101.string().min(1),
   // e.g., 'file', 'tool', 'config', 'agent'
-  id: z100.string().min(1),
-  name: z100.string().optional(),
-  path: z100.string().optional()
+  id: z101.string().min(1),
+  name: z101.string().optional(),
+  path: z101.string().optional()
 });
-var AuditEventSchema = z100.object({
+var AuditEventSchema = z101.object({
   // Identity
-  id: z100.string().min(1),
+  id: z101.string().min(1),
   // Unique event ID
-  version: z100.literal("1.0"),
+  version: z101.literal("1.0"),
   // Schema version for migrations
   // Timing
-  timestamp: z100.string(),
+  timestamp: z101.string(),
   // ISO 8601 format
-  timestampMs: z100.number(),
+  timestampMs: z101.number(),
   // Unix epoch milliseconds
   // Classification
   category: AuditCategorySchema,
   severity: AuditSeveritySchema,
   outcome: AuditOutcomeSchema,
   // Event details
-  action: z100.string().min(1),
+  action: z101.string().min(1),
   // e.g., 'tool.invoke', 'policy.evaluate'
-  description: z100.string().optional(),
+  description: z101.string().optional(),
   // Actors and resources
   actor: AuditActorSchema,
   resource: AuditResourceSchema.optional(),
   // Correlation
-  requestId: z100.string().optional(),
+  requestId: z101.string().optional(),
   // Request correlation ID
-  traceId: z100.string().optional(),
+  traceId: z101.string().optional(),
   // Distributed trace ID
-  sessionId: z100.string().optional(),
+  sessionId: z101.string().optional(),
   // Session correlation ID
   // Context
-  toolName: z100.string().optional(),
-  durationMs: z100.number().optional(),
-  metadata: z100.record(z100.string(), z100.unknown()).optional(),
+  toolName: z101.string().optional(),
+  durationMs: z101.number().optional(),
+  metadata: z101.record(z101.string(), z101.unknown()).optional(),
   // Policy and security
-  policyName: z100.string().optional(),
-  policyDecision: z100.string().optional(),
-  violationType: z100.string().optional(),
+  policyName: z101.string().optional(),
+  policyDecision: z101.string().optional(),
+  violationType: z101.string().optional(),
   // Integrity (for tamper-evidence)
-  previousHash: z100.string().optional(),
+  previousHash: z101.string().optional(),
   // Hash of previous event (chain)
-  hash: z100.string().optional()
+  hash: z101.string().optional()
   // Hash of this event
 });
-var AuditEventInputSchema = z100.object({
+var AuditEventInputSchema = z101.object({
   category: AuditCategorySchema,
   severity: AuditSeveritySchema.optional().default("info"),
   outcome: AuditOutcomeSchema,
-  action: z100.string().min(1),
-  description: z100.string().optional(),
+  action: z101.string().min(1),
+  description: z101.string().optional(),
   actor: AuditActorSchema,
   resource: AuditResourceSchema.optional(),
-  requestId: z100.string().optional(),
-  traceId: z100.string().optional(),
-  sessionId: z100.string().optional(),
-  toolName: z100.string().optional(),
-  durationMs: z100.number().optional(),
-  metadata: z100.record(z100.string(), z100.unknown()).optional(),
-  policyName: z100.string().optional(),
-  policyDecision: z100.string().optional(),
-  violationType: z100.string().optional()
+  requestId: z101.string().optional(),
+  traceId: z101.string().optional(),
+  sessionId: z101.string().optional(),
+  toolName: z101.string().optional(),
+  durationMs: z101.number().optional(),
+  metadata: z101.record(z101.string(), z101.unknown()).optional(),
+  policyName: z101.string().optional(),
+  policyDecision: z101.string().optional(),
+  violationType: z101.string().optional()
 });
-var AuditLogConfigSchema = z100.object({
+var AuditLogConfigSchema = z101.object({
   // Storage
-  logDir: z100.string().min(1),
-  filePrefix: z100.string().optional().default("audit"),
-  maxFileSizeBytes: z100.number().positive().optional().default(10 * 1024 * 1024),
+  logDir: z101.string().min(1),
+  filePrefix: z101.string().optional().default("audit"),
+  maxFileSizeBytes: z101.number().positive().optional().default(10 * 1024 * 1024),
   // 10MB
-  maxFiles: z100.number().positive().optional().default(10),
+  maxFiles: z101.number().positive().optional().default(10),
   // Features
-  enableHashChain: z100.boolean().optional().default(true),
-  enableCompression: z100.boolean().optional().default(false),
-  flushIntervalMs: z100.number().positive().optional().default(1e3),
+  enableHashChain: z101.boolean().optional().default(true),
+  enableCompression: z101.boolean().optional().default(false),
+  flushIntervalMs: z101.number().positive().optional().default(1e3),
   // Filtering
   minSeverity: AuditSeveritySchema.optional().default("info"),
-  categories: z100.array(AuditCategorySchema).optional()
+  categories: z101.array(AuditCategorySchema).optional()
 });
-var AuditQueryCriteriaSchema = z100.object({
-  startTime: z100.date().optional(),
-  endTime: z100.date().optional(),
-  categories: z100.array(AuditCategorySchema).optional(),
-  severities: z100.array(AuditSeveritySchema).optional(),
-  outcomes: z100.array(AuditOutcomeSchema).optional(),
-  actorId: z100.string().optional(),
-  resourceId: z100.string().optional(),
-  requestId: z100.string().optional(),
-  traceId: z100.string().optional(),
-  limit: z100.number().positive().optional().default(100),
-  offset: z100.number().nonnegative().optional().default(0)
+var AuditQueryCriteriaSchema = z101.object({
+  startTime: z101.date().optional(),
+  endTime: z101.date().optional(),
+  categories: z101.array(AuditCategorySchema).optional(),
+  severities: z101.array(AuditSeveritySchema).optional(),
+  outcomes: z101.array(AuditOutcomeSchema).optional(),
+  actorId: z101.string().optional(),
+  resourceId: z101.string().optional(),
+  requestId: z101.string().optional(),
+  traceId: z101.string().optional(),
+  limit: z101.number().positive().optional().default(100),
+  offset: z101.number().nonnegative().optional().default(0)
 });
 
 // src/audit/audit-storage-queries.ts
@@ -52289,7 +52618,7 @@ var GitHubTaskTracker = class {
   cachedProvider = null;
   async getProvider() {
     if (this.cachedProvider !== null) return this.cachedProvider;
-    const { createScmProvider } = await import("./factory-KRNR7XHD.js");
+    const { createScmProvider } = await import("./factory-FA7WDPZW.js");
     const result = await createScmProvider({ repo: this.config.repo ?? "" });
     if (!result.ok) throw new Error(`SCM provider error: ${result.error.message}`);
     this.cachedProvider = result.value;
@@ -52868,6 +53197,7 @@ export {
   registerResearchSynthesizeTool,
   IssueTriageInputSchema,
   registerIssueTriageTool,
+  MAX_STRIPPED_ELEMENTS_PER_EVENT,
   AuditTrail,
   emitTrustEvent,
   emitPolicyEvent,
@@ -52930,6 +53260,13 @@ export {
   runDevPipeline,
   createDevStageRegistry,
   registerPipelineTool,
+  PR_REVIEW_ROLES,
+  MAX_DIFF_LENGTH,
+  PrReviewInputSchema,
+  mapVoteDecisionToPrDecision,
+  aggregatePrDecisions,
+  buildPrReviewProposal,
+  registerPrReviewTool,
   createAnnotationsProxy,
   createToolObservabilityProxy,
   registerTools,
@@ -53103,4 +53440,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-EJLWDYK7.js.map
+//# sourceMappingURL=chunk-ZL3IBCH6.js.map