nexus-agents 2.81.2 → 2.81.4

package/dist/{chunk-37ZXD5B6.js → chunk-M6KXR4LO.js}

@@ -7,10 +7,10 @@ import {
 import {
   getTokenEnvVars,
   resolveToken
-} from "./chunk-UZCDHAY3.js";
+} from "./chunk-ZAY5M2AN.js";
 import {
   executeExpert
-} from "./chunk-SVKH6ASN.js";
+} from "./chunk-2GW2FZXY.js";
 import {
   EventTopics,
   NOOP_NOTIFIER,
@@ -36,7 +36,7 @@ import {
   withAccessPolicy,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-P4W7PV6L.js";
+} from "./chunk-R2VJY7Z4.js";
 import {
   REGISTRY_PATH,
   getProjectRoot,
@@ -45,14 +45,14 @@ import {
   normalizeTopicToCanonical,
   savePapersRegistry,
   synthesizeResearch
-} from "./chunk-ERWTZSAR.js";
+} from "./chunk-EGK4RZV5.js";
 import {
   IssueTriage,
   sanitizeInput
-} from "./chunk-RLQZOEMX.js";
+} from "./chunk-ITMLH7TF.js";
 import {
   generateSecurityPlan
-} from "./chunk-SZ7VPIRA.js";
+} from "./chunk-RGKUBFTE.js";
 import {
   analyzeGitHubRepo
 } from "./chunk-7J7PNOJQ.js";
@@ -64,7 +64,7 @@ import {
   getContextForTask,
   inferTaskCategory,
   summarizeContextForPrompt
-} from "./chunk-4OPS2AUD.js";
+} from "./chunk-S5HMID6I.js";
 import {
   DEFAULT_RELEVANCE_CONFIG,
   MemoryImportance,
@@ -72,19 +72,19 @@ import {
   generateHyphenId,
   generateUUID,
   getToolMemory
-} from "./chunk-PZEE6T5Y.js";
+} from "./chunk-JSQV2EOZ.js";
 import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-6KO6LO3L.js";
+} from "./chunk-F7N2T53R.js";
 import {
   getAvailabilityCache,
   resolveFallback
-} from "./chunk-WZGCVCRQ.js";
+} from "./chunk-6M44ZXB4.js";
 import {
   DEFAULTS
-} from "./chunk-V2KWEIV5.js";
+} from "./chunk-2HBQ6XXA.js";
 import {
   resolveInsideRoot
 } from "./chunk-NUBSJGQZ.js";
@@ -100,7 +100,7 @@ import {
   getAvailableClis,
   sleep,
   withTimeout
-} from "./chunk-BMNWUPJO.js";
+} from "./chunk-WVSQGGAH.js";
 import {
   BUILT_IN_EXPERTS,
   BuiltInExpertTypeSchema,
@@ -112,7 +112,7 @@ import {
 } from "./chunk-PQHVC4BD.js";
 import {
   createSessionMemory
-} from "./chunk-PV3OEDLO.js";
+} from "./chunk-B3MCX46I.js";
 import {
   AGENT_ROUTER_TIMEOUTS,
   API_TIMEOUTS,
@@ -182,7 +182,7 @@ import {
   resolveModelIdentitySync,
   toExpertTaskAnalysisResult,
   withStep
-} from "./chunk-LJIB6TNE.js";
+} from "./chunk-HFSSADUV.js";
 import {
   getNexusDataDir,
   nexusDataPath
@@ -17713,7 +17713,7 @@ var ExperienceBuffer = class _ExperienceBuffer {
     }
     const totalReward = this.computeTotalReward(steps);
     const episode = {
-      id: crypto.randomUUID(),
+      id: getRandomProvider().uuid(),
       sessionId,
       steps: [...steps],
       totalReward,
@@ -26699,7 +26699,7 @@ async function populateUnifiedContextOnState(state) {
   try {
     const taskCandidate = state["task"];
     if (typeof taskCandidate !== "string" || taskCandidate === "") return;
-    const { getContextForTask: getContextForTask2, inferTaskCategory: inferTaskCategory2 } = await import("./context-retriever-KLJ5X4TL.js");
+    const { getContextForTask: getContextForTask2, inferTaskCategory: inferTaskCategory2 } = await import("./context-retriever-R5W4I4IB.js");
     const ctx = await getContextForTask2({
       task: taskCandidate,
       category: inferTaskCategory2(taskCandidate),
@@ -28246,15 +28246,12 @@ var PolicyEngine = class {
     return matched.sort((a, b) => b.priority - a.priority);
   }
 };
-var DEFAULT_MAX_ATTEMPTS = 3;
-var COST_WARNING_THRESHOLD = 0.8;
 var trustTierRule = {
   id: "trust-tier",
   priority: 100,
   evaluate(context) {
-    const state = context.pipelineState;
-    const tierVal = state["trustTier"];
-    const numericTier = typeof tierVal === "number" ? tierVal : typeof tierVal === "string" ? Number(tierVal) : Number.NaN;
+    const tierVal = context.pipelineState.trustTier;
+    const numericTier = tierVal === void 0 ? Number.NaN : Number(tierVal);
     const tier = Number.isFinite(numericTier) ? numericTier : void 0;
     if (tier !== void 0 && tier >= 3 && context.stageType === "execute") {
       return {
@@ -28266,83 +28263,7 @@ var trustTierRule = {
     return { allow: true };
   }
 };
-var securityReviewRule = {
-  id: "security-review",
-  priority: 90,
-  evaluate(context) {
-    const state = context.pipelineState;
-    const needsReview = state["securityReviewRequired"] === true;
-    const hasReview = state["securityReviewComplete"] === true;
-    if (needsReview && !hasReview && context.stageType === "execute") {
-      return {
-        allow: false,
-        reason: "Security review required before implementation"
-      };
-    }
-    return { allow: true };
-  }
-};
-var boundedIterationRule = {
-  id: "bounded-iteration",
-  priority: 80,
-  evaluate(context) {
-    const state = context.pipelineState;
-    const attemptsVal = state["stageAttempts"];
-    const attempts = typeof attemptsVal === "number" ? attemptsVal : void 0;
-    if (attempts !== void 0 && attempts >= DEFAULT_MAX_ATTEMPTS) {
-      return {
-        allow: false,
-        reason: `Stage "${context.stageId}" exceeded max retries`
-      };
-    }
-    return { allow: true };
-  }
-};
-var costBudgetRule = {
-  id: "cost-budget",
-  priority: 70,
-  evaluate(context) {
-    const state = context.pipelineState;
-    const spentVal = state["costAccumulator"];
-    const spent = typeof spentVal === "number" ? spentVal : void 0;
-    const budgetVal = state["costBudget"];
-    const budget = typeof budgetVal === "number" ? budgetVal : void 0;
-    if (spent !== void 0 && budget !== void 0) {
-      if (spent > budget * COST_WARNING_THRESHOLD) {
-        return {
-          allow: false,
-          reason: "Approaching cost budget limit",
-          escalateTo: "user"
-        };
-      }
-    }
-    return { allow: true };
-  }
-};
-var highRiskApprovalRule = {
-  id: "high-risk-approval",
-  priority: 60,
-  evaluate(context) {
-    const state = context.pipelineState;
-    const isHighRisk = state["highRisk"] === true;
-    const approved = state["userApproved"] === true;
-    if (isHighRisk && !approved) {
-      return {
-        allow: false,
-        reason: "High-risk action requires user approval",
-        escalateTo: "user"
-      };
-    }
-    return { allow: true };
-  }
-};
-var BUILT_IN_RULES = [
-  trustTierRule,
-  securityReviewRule,
-  boundedIterationRule,
-  costBudgetRule,
-  highRiskApprovalRule
-];
+var BUILT_IN_RULES = [trustTierRule];
 function createDefaultPolicyEngine() {
   const engine = new PolicyEngine();
   for (const rule of BUILT_IN_RULES) {
@@ -28482,6 +28403,10 @@ function buildBaseTaskContract(input) {
 }
 
 // src/pipeline/v2-delegate.ts
+function toPipelineStateSnapshot(metadata) {
+  const trustTier = metadata["trustTier"];
+  return typeof trustTier === "string" ? { trustTier } : {};
+}
 var logger22 = createLogger({ component: "V2Delegate" });
 function createDelegatePipeline(task) {
   const plan = buildPlan(task);
@@ -28541,7 +28466,10 @@ function checkPipelinePolicy(task, stageType) {
     taskId: task.id,
     stageId: `pre-execution-${stageType}`,
     stageType,
-    pipelineState: task.metadata
+    // #2932: typed extraction. The untyped `task.metadata` is the producer
+    // surface — we narrow to the policy snapshot here so adding a new rule
+    // forces an explicit producer wire-up at this single chokepoint.
+    pipelineState: toPipelineStateSnapshot(task.metadata)
   };
   const result = evaluatePolicy2({ engine, mode }, context);
   if (!result.allowed) {
@@ -34255,6 +34183,8 @@ function instrumentV2Pipeline(input, logger52) {
   const tc = delegateInputToTaskContract(input);
   void executeDelegatePipeline(tc).then((m) => {
     logger52.info("V2 delegate pipeline", { ...m });
+  }).catch((error) => {
+    logger52.warn("V2 delegate instrumentation failed", { error: getErrorMessage(error) });
   });
 }
 function notifyAndRecord(opts) {
@@ -41342,10 +41272,10 @@ var FileAuditStorage = class _FileAuditStorage {
 };
 
 // src/audit/audit-logger.ts
-import * as crypto2 from "crypto";
+import * as crypto from "crypto";
 function generateEventId() {
   const timestamp = getTimeProvider().now().toString(36);
-  const random = crypto2.randomBytes(6).toString("hex");
+  const random = crypto.randomBytes(6).toString("hex");
   return `aud_${timestamp}_${random}`;
 }
 function computeEventHash(event) {
@@ -41358,7 +41288,7 @@ function computeEventHash(event) {
     actor: event.actor,
     previousHash: event.previousHash
   });
-  return crypto2.createHash("sha256").update(data).digest("hex");
+  return crypto.createHash("sha256").update(data).digest("hex");
 }
 function verifyEvent(event, index, priorHash) {
   if (event.hash === void 0) {
@@ -41988,7 +41918,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-H5VLNGWU.js");
+    const { createIssueTriage } = await import("./issue-triage-CRUJLWFY.js");
     const triage = createIssueTriage();
     const owner = issueMatch[1] ?? "";
     const num = issueMatch[2] ?? "";
@@ -42016,7 +41946,7 @@ var VALID_TEMPLATES = /* @__PURE__ */ new Set([
 ]);
 async function classifyWithLLM(task) {
   try {
-    const { executeExpert: executeExpert2 } = await import("./expert-bridge-EKPDZKMD.js");
+    const { executeExpert: executeExpert2 } = await import("./expert-bridge-J5ZKCYL5.js");
     const prompt = [
       "Classify this task into exactly one pipeline template.",
       "Templates: dev (implementation/bug fix/refactor), research (investigate/evaluate/compare),",
@@ -42776,14 +42706,15 @@ function recordOutcome(args) {
     return;
   }
   try {
+    const nowMs = getTimeProvider().now();
     getOutcomeStore().append({
-      id: `pipeline-${args.taskId}-${String(Date.now())}`,
+      id: `pipeline-${args.taskId}-${String(nowMs)}`,
       cli: args.cli,
       category: args.category,
       model: "pipeline",
       success: args.success,
       durationMs: args.durationMs,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      timestamp: new Date(nowMs).toISOString(),
       source: "delegate",
       routingStage: args.routingStage,
       retryCount: args.retryCount
@@ -42797,10 +42728,10 @@ var memoryInitPromise = null;
 async function initPipelineMemory() {
   if (cachedMemory !== null) return cachedMemory;
   try {
-    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-N76TNRSK.js");
+    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-LV35VSBK.js");
     const { getLearningDir } = await import("./learning-persistence-NX2KHL5T.js");
     const mem = createSessionMemory2(getLearningDir());
-    mem.startSession(`pipeline-${String(Date.now())}`);
+    mem.startSession(`pipeline-${String(getTimeProvider().now())}`);
     cachedMemory = {
       recordLearning: (l) => {
         try {
@@ -42853,7 +42784,7 @@ function recordRoutingExperience(category, success, durationMs) {
     callRecord(routingMemoryCache);
     return;
   }
-  void import("./routing-memory-QKQ3OGWW.js").then(({ createRoutingMemory }) => {
+  void import("./routing-memory-7DA6WNSA.js").then(({ createRoutingMemory }) => {
     routingMemoryCache = createRoutingMemory();
     callRecord(routingMemoryCache);
   }).catch((error) => {
@@ -42882,7 +42813,7 @@ ${text}` : "";
 }
 async function getWeatherContext() {
   try {
-    const { generateWeatherReport: generateWeatherReport2 } = await import("./weather-report-IXPYIYE4.js");
+    const { generateWeatherReport: generateWeatherReport2 } = await import("./weather-report-CCOWOPFG.js");
     const report = generateWeatherReport2({ includeAdaptive: true });
     const mappings = "recommendedMappings" in report ? report.recommendedMappings : [];
     if (!Array.isArray(mappings) || mappings.length === 0) return "";
@@ -42900,7 +42831,7 @@ ${lines}
 }
 async function getMemoryContext(task) {
   try {
-    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-N76TNRSK.js");
+    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-LV35VSBK.js");
     const { getLearningDir } = await import("./learning-persistence-NX2KHL5T.js");
     const memory = createSessionMemory2(getLearningDir(), { maxLearningsInContext: 10 });
     const learnings = memory.searchLearnings(task.slice(0, 200));
@@ -43006,7 +42937,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-VBXLXVFF.js");
+        const { executeVoting } = await import("./consensus-vote-7PLEGFWZ.js");
         const votingResult = await executeVoting(
           {
             proposal: plan.slice(0, 4e3),
@@ -43428,7 +43359,9 @@ function reinforcePlanBeliefs(bm, task, iterations) {
 function applyPipelineHindsight(bm, task, sessionId, result) {
   if (bm === void 0) return;
   const record = {
-    hindsightId: `pipeline-${sessionId ?? "ephemeral"}-${Date.now().toString(36)}`,
+    // #2961: hindsightId is the persisted belief-store key — must go
+    // through the time provider so replay/snapshot tests reproduce.
+    hindsightId: `pipeline-${sessionId ?? "ephemeral"}-${getTimeProvider().now().toString(36)}`,
     taskId: sessionId ?? task.slice(0, 40),
     priorBeliefs: [],
     expectedOutcome: "Pipeline completes with all gates passed",
@@ -43900,7 +43833,7 @@ async function extractSymbolsForTask(task) {
 }
 async function queryResearchRegistry(task) {
   try {
-    const { synthesizeResearch: synthesizeResearch2 } = await import("./research-helpers-synthesize-XUTBDVI7.js");
+    const { synthesizeResearch: synthesizeResearch2 } = await import("./research-helpers-synthesize-NMYYERCP.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));
@@ -43985,7 +43918,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-VJCWWPWO.js");
+          const { generateSecurityPlan: generateSecurityPlan2 } = await import("./repo-security-plan-I4FZP7QA.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 });
@@ -46049,6 +45982,16 @@ var MAX_AXES = 6;
 var MAX_AXIS_NAME_LENGTH = 64;
 var MAX_PROPOSAL_LENGTH = 4e3;
 var MAX_CONTEXT_LENGTH = 4e3;
+var FULL_PANEL = [
+  "architect",
+  "security",
+  "devex",
+  "ai_ml",
+  "pm",
+  "catfish",
+  "scope_steward"
+];
+var QUICK_PANEL = ["architect", "security", "scope_steward"];
 var SupplyChainTradeoffPanelInputSchema = z98.object({
   proposal: z98.string().min(1).max(MAX_PROPOSAL_LENGTH).describe('The proposal under tradeoff review (e.g. "Should aegis-boot adopt cargo-nextest?")'),
   axes: z98.array(z98.string().min(1).max(MAX_AXIS_NAME_LENGTH)).min(1).max(MAX_AXES).optional().describe(
@@ -46060,6 +46003,249 @@ var SupplyChainTradeoffPanelInputSchema = z98.object({
   quickMode: z98.boolean().optional().default(false).describe("Use 3 voters (architect, security, scope_steward) instead of 7"),
   simulate: z98.boolean().optional().default(false).describe("Use simulated voters (testing only)")
 });
+function buildTradeoffProposal(input) {
+  const axes = input.axes ?? DEFAULT_AXES;
+  const parts = [];
+  parts.push(`# Supply-Chain Tradeoff Review
+
+`);
+  parts.push(`**Proposal:** ${input.proposal}
+`);
+  if (input.context !== void 0 && input.context !== "") {
+    parts.push(`
+**Context:**
+${input.context}
+`);
+  }
+  parts.push(`
+## Axes
+
+Evaluate the proposal along EACH of these axes independently:
+`);
+  for (const axis of axes) parts.push(`- \`${axis}\`
+`);
+  parts.push(`
+## Your task
+
+`);
+  parts.push(
+    `For each axis, decide approve / reject / abstain with a one-line reason. It is normal \u2014 and expected \u2014 for the verdict to differ across axes (a proposal can be a win on update cadence and a loss on supply-chain risk).
+
+`
+  );
+  parts.push(`After your reasoning, emit a JSON block with this exact shape:
+
+`);
+  parts.push("```json\n");
+  parts.push('{\n  "axes": {\n');
+  axes.forEach((axis, idx) => {
+    const comma = idx < axes.length - 1 ? "," : "";
+    parts.push(`    "${axis}": {"decision": "approve|reject|abstain", "reason": "..."}${comma}
+`);
+  });
+  parts.push("  }\n}\n");
+  parts.push("```\n\n");
+  parts.push(
+    `Your overall vote (approve/reject/abstain) should reflect: approve if MOST axes are approve; reject if any axis is a strong reject; abstain otherwise.
+`
+  );
+  return parts.join("");
+}
+function extractJsonBlock(reasoning) {
+  const fenced = /```json\s*\n([\s\S]*?)\n```/.exec(reasoning);
+  if (fenced !== null) return fenced[1];
+  const start = reasoning.indexOf("{");
+  if (start === -1) return void 0;
+  let depth = 0;
+  for (let i = start; i < reasoning.length; i++) {
+    if (reasoning[i] === "{") depth++;
+    else if (reasoning[i] === "}") {
+      depth--;
+      if (depth === 0) {
+        const candidate = reasoning.slice(start, i + 1);
+        if (candidate.includes("axes") || candidate.includes("axis")) return candidate;
+      }
+    }
+  }
+  return void 0;
+}
+function isValidAxisDecision(d) {
+  return d === "approve" || d === "reject" || d === "abstain";
+}
+function safeJsonParse2(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function resolveAxesContainer(parsed) {
+  if (typeof parsed !== "object" || parsed === null) return void 0;
+  const root = parsed;
+  const axesObj = root.axes ?? parsed;
+  if (typeof axesObj !== "object") return void 0;
+  return axesObj;
+}
+function parseSingleAxisEntry(entry) {
+  if (typeof entry !== "object" || entry === null) return void 0;
+  const e = entry;
+  if (!isValidAxisDecision(e.decision)) return void 0;
+  return { decision: e.decision, reason: typeof e.reason === "string" ? e.reason : "" };
+}
+function parseAxisVerdicts(reasoning, axes) {
+  const block = extractJsonBlock(reasoning);
+  if (block === void 0) return {};
+  const parsed = safeJsonParse2(block);
+  const container = resolveAxesContainer(parsed);
+  if (container === void 0) return {};
+  const out = {};
+  for (const axis of axes) {
+    const entry = parseSingleAxisEntry(container[axis]);
+    if (entry !== void 0) out[axis] = entry;
+  }
+  return out;
+}
+function aggregateAxis(axis, votes) {
+  const valid = votes.filter((v) => v.source !== "error" && axis in v.axisVotes);
+  let approveCount = 0;
+  let rejectCount = 0;
+  let abstainCount = 0;
+  const supporters = [];
+  const reasons = [];
+  for (const v of valid) {
+    const entry = v.axisVotes[axis];
+    if (entry === void 0) continue;
+    if (entry.decision === "approve") {
+      approveCount++;
+      supporters.push(v.role);
+    } else if (entry.decision === "reject") {
+      rejectCount++;
+    } else {
+      abstainCount++;
+    }
+    if (entry.reason !== "") reasons.push(`${v.role}: ${entry.reason}`);
+  }
+  const decision = decideAxis(approveCount, rejectCount, abstainCount);
+  const total = approveCount + rejectCount + abstainCount;
+  const confidence = total === 0 ? 0 : Math.max(approveCount, rejectCount) / total;
+  return {
+    axis,
+    decision,
+    confidence,
+    approveCount,
+    rejectCount,
+    abstainCount,
+    summary: reasons.slice(0, 3).join(" | "),
+    supportingVoters: supporters
+  };
+}
+function decideAxis(approve, reject, abstain) {
+  const total = approve + reject + abstain;
+  if (total === 0) return "unknown";
+  if (approve > reject && approve > abstain) return "approve";
+  if (reject > approve && reject > abstain) return "reject";
+  if (approve === reject && approve > 0) return "mixed";
+  return "mixed";
+}
+function aggregatePanel(verdicts) {
+  if (verdicts.length === 0) return "mixed";
+  const allApprove = verdicts.every((v) => v.decision === "approve");
+  if (allApprove) return "approve";
+  const anyReject = verdicts.some((v) => v.decision === "reject");
+  if (anyReject) return "reject";
+  return "mixed";
+}
+function buildRecommendation(decision, verdicts) {
+  if (decision === "approve") {
+    return `Approve: all ${String(verdicts.length)} axes approve.`;
+  }
+  if (decision === "reject") {
+    const blockers = verdicts.filter((v) => v.decision === "reject").map((v) => v.axis).join(", ");
+    return `Reject: blocking concerns on ${blockers}.`;
+  }
+  const wins = verdicts.filter((v) => v.decision === "approve").map((v) => v.axis);
+  const losses = verdicts.filter((v) => v.decision === "reject" || v.decision === "mixed" || v.decision === "unknown").map((v) => v.axis);
+  return `Mixed: wins on ${wins.join(", ") || "(none)"}; concerns on ${losses.join(", ") || "(none)"}. Apply judgment.`;
+}
+function toPanelVote(result, axes) {
+  const axisVotes = parseAxisVerdicts(result.vote.reasoning, axes);
+  return {
+    role: result.role,
+    overallDecision: result.vote.decision,
+    axisVotes,
+    reasoning: result.vote.reasoning,
+    source: result.source,
+    cli: result.cli,
+    ...result.error !== void 0 && { errorMessage: result.error }
+  };
+}
+async function tradeoffPanelHandler(args, ctx) {
+  const parsed = SupplyChainTradeoffPanelInputSchema.safeParse(args);
+  if (!parsed.success) {
+    return toolStructuredError({
+      errorCategory: "validation",
+      message: `Validation error: ${formatZodError(parsed.error)}`
+    });
+  }
+  const input = parsed.data;
+  const axes = input.axes ?? DEFAULT_AXES;
+  const roles = input.quickMode ? QUICK_PANEL : FULL_PANEL;
+  const start = Date.now();
+  try {
+    const proposal = buildTradeoffProposal(input);
+    const voteResults = await collectRealVotes({
+      roles,
+      proposal,
+      simulate: input.simulate,
+      logger: ctx.logger
+    });
+    const votes = voteResults.map((r) => toPanelVote(r, axes));
+    const axisVerdicts = axes.map((a) => aggregateAxis(a, votes));
+    const decision = aggregatePanel(axisVerdicts);
+    const recommendation = buildRecommendation(decision, axisVerdicts);
+    const voterErrors = votes.filter((v) => v.source === "error").length;
+    const response = {
+      proposal: input.proposal,
+      axes,
+      decision,
+      axisVerdicts,
+      recommendation,
+      votes,
+      voterErrors,
+      durationMs: Date.now() - start
+    };
+    return toolSuccess(JSON.stringify(response, null, 2));
+  } catch (error) {
+    return toolStructuredError({
+      errorCategory: "internal",
+      message: `Tradeoff panel failed: ${getErrorMessage(error)}`
+    });
+  }
+}
+function registerSupplyChainTradeoffPanelTool(server, deps) {
+  const logger52 = deps.logger ?? createLogger({ tool: "supply_chain_tradeoff_panel" });
+  const description2 = "Run a structured per-axis tradeoff vote on an engineering proposal (#2294). Default axes: build_time_determinism / supply_chain_risk / update_cadence. Voters answer EACH axis independently; aggregator surfaces per-axis verdicts so legitimate tradeoffs are not masked by a single approve/reject.";
+  const secureHandler = createSecureHandler(tradeoffPanelHandler, {
+    toolName: "supply_chain_tradeoff_panel",
+    rateLimiter: deps.rateLimiter,
+    logger: logger52
+  });
+  const timeoutMs = getToolTimeout("supply_chain_tradeoff_panel", deps.security);
+  const wrappedHandler = wrapToolWithTimeout("supply_chain_tradeoff_panel", secureHandler, {
+    timeoutMs,
+    logger: logger52
+  });
+  server.registerTool(
+    "supply_chain_tradeoff_panel",
+    {
+      description: description2,
+      inputSchema: SupplyChainTradeoffPanelInputSchema.shape,
+      annotations: getToolAnnotations("supply_chain_tradeoff_panel")
+    },
+    toSdkCallback(wrappedHandler)
+  );
+  logger52.info("Registered supply_chain_tradeoff_panel tool");
+}
 
 // src/mcp/tools/tool-annotations.ts
 var TOOL_ANNOTATIONS = {
@@ -46415,6 +46601,152 @@ var TOOL_ANNOTATIONS = {
       },
       { category: "implicit", description: "Consumes rate limit quota" }
     ]
+  },
+  research_add_source: {
+    annotations: {
+      title: "Research Add Source",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    sideEffects: [
+      { category: "explicit", description: "Adds a non-paper source to the research registry" },
+      { category: "coupling", description: "New entries affect research_discover/research_query" }
+    ]
+  },
+  research_synthesize: {
+    annotations: {
+      title: "Research Synthesize",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    sideEffects: [{ category: "implicit", description: "Reads research catalog + alignment map" }]
+  },
+  query_task_state: {
+    annotations: {
+      title: "Query Task State",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    sideEffects: [
+      { category: "implicit", description: "Reads the structured task-state log (#2278)" }
+    ]
+  },
+  verify_audit_chain: {
+    annotations: {
+      title: "Verify Audit Chain",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    sideEffects: [
+      {
+        category: "implicit",
+        description: "Reads the immutable audit log and verifies the hash chain"
+      }
+    ]
+  },
+  extract_symbols: {
+    annotations: {
+      title: "Extract Symbols",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    sideEffects: [{ category: "implicit", description: "Reads source files and walks their ASTs" }]
+  },
+  search_codebase: {
+    annotations: {
+      title: "Search Codebase",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    sideEffects: [
+      {
+        category: "implicit",
+        description: "Reads source files and builds an in-memory symbol index"
+      }
+    ]
+  },
+  run_dev_pipeline: {
+    annotations: {
+      title: "Run Dev Pipeline",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    sideEffects: [
+      {
+        category: "explicit",
+        description: "Executes the V2 dev pipeline (delegates to CLI adapters)"
+      },
+      {
+        category: "implicit",
+        description: "Consumes API tokens; persists outcomes and checkpoints"
+      },
+      {
+        category: "coupling",
+        description: "Writes routing/learning state consumed by future runs"
+      }
+    ]
+  },
+  run_pipeline: {
+    annotations: {
+      title: "Run Pipeline",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    sideEffects: [
+      { category: "explicit", description: "Executes a generic V2 pipeline TaskContract" },
+      { category: "implicit", description: "Consumes API tokens; emits pipeline events" },
+      { category: "coupling", description: "Writes policy/audit state consumed by other tools" }
+    ]
+  },
+  pr_review: {
+    annotations: {
+      title: "PR Review",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    sideEffects: [
+      {
+        category: "explicit",
+        description: "Runs multi-voter PR review with verification gate (#2233)"
+      },
+      { category: "implicit", description: "Consumes API tokens across voter CLIs" },
+      { category: "coupling", description: "Records voter outcomes for weather report" }
+    ]
+  },
+  supply_chain_tradeoff_panel: {
+    annotations: {
+      title: "Supply-chain Tradeoff Panel",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    sideEffects: [
+      {
+        category: "explicit",
+        description: "Runs per-axis tradeoff vote (build_time_determinism / supply_chain_risk / update_cadence) (#2294)"
+      },
+      { category: "implicit", description: "Consumes API tokens across voter CLIs" },
+      { category: "coupling", description: "Records voter outcomes for weather report" }
+    ]
   }
 };
 function getMcpAnnotations(toolName) {
@@ -49596,7 +49928,7 @@ var GitHubTaskTracker = class {
   cachedProvider = null;
   async getProvider() {
     if (this.cachedProvider !== null) return this.cachedProvider;
-    const { createScmProvider } = await import("./factory-FTE7TDCT.js");
+    const { createScmProvider } = await import("./factory-DD2FPM3H.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;
@@ -50267,6 +50599,7 @@ export {
   aggregatePrDecisions,
   buildPrReviewProposal,
   registerPrReviewTool,
+  registerSupplyChainTradeoffPanelTool,
   createAnnotationsProxy,
   createToolObservabilityProxy,
   registerTools,
@@ -50301,4 +50634,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-37ZXD5B6.js.map
+//# sourceMappingURL=chunk-M6KXR4LO.js.map