nexus-agents 2.131.1 → 2.132.1

package/dist/{chunk-ZLQCJRYK.js → chunk-EEQVXGZ2.js}

@@ -1,6 +1,6 @@
 import {
   generateSecurityPlan
-} from "./chunk-TRTCKEHS.js";
+} from "./chunk-GET2MTLW.js";
 import {
   CodebaseIndex,
   extractSymbolIndex,
@@ -13,7 +13,7 @@ import {
 } from "./chunk-WAYGXUSM.js";
 import {
   executeExpert
-} from "./chunk-GVBEF6LQ.js";
+} from "./chunk-RAWF4JOT.js";
 import {
   JobStatusSchema,
   collectRealVotes,
@@ -24,6 +24,7 @@ import {
   isRateLimitError,
   listJobs,
   readJobResult,
+  recordDecisionCost,
   registerIdempotentJob,
   resolveIdempotency,
   runAsJob,
@@ -31,24 +32,24 @@ import {
   toJobSummary,
   warnIfSimulatedOutsideTests,
   writeJobCancelled
-} from "./chunk-DEL26PXS.js";
+} from "./chunk-I2SW34K6.js";
 import {
   normalizeTopicToCanonical,
   synthesizeResearch
-} from "./chunk-WUJCVZIQ.js";
+} from "./chunk-EFDXX5MC.js";
 import {
   IssueTriage,
   createAuditTrail,
   createGraphAuditBridge,
   emitPipelinePolicyEvent
-} from "./chunk-3TTMRJUQ.js";
+} from "./chunk-J435FU54.js";
 import {
   resolveEnvMode,
   sanitizeInput
-} from "./chunk-DI6SRBCT.js";
+} from "./chunk-QMCHVYZB.js";
 import {
   withPrerequisite
-} from "./chunk-KMNAZ5RC.js";
+} from "./chunk-MHIJSCPR.js";
 import {
   NOOP_NOTIFIER,
   RateLimiter,
@@ -70,7 +71,7 @@ import {
   withAccessPolicy,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-4SNH5EMQ.js";
+} from "./chunk-4CLBJ2NA.js";
 import {
   analyzeGitHubRepo
 } from "./chunk-HFOQKCD2.js";
@@ -101,29 +102,29 @@ import {
   parseRegistry,
   sourceExistsInRegistry,
   summarizeContextForPrompt
-} from "./chunk-FCPANF6R.js";
+} from "./chunk-S4U3Z6ZS.js";
 import {
   getTokenEnvVars,
   resolveToken
-} from "./chunk-4DJNJGIB.js";
+} from "./chunk-ZQEQVCIU.js";
 import {
   loadPapersRegistry,
   loadTechniquesRegistry
-} from "./chunk-HM77WNJG.js";
+} from "./chunk-2CLFX73Y.js";
 import {
   DEFAULT_RELEVANCE_CONFIG,
   MemoryImportance,
   calculateTextJaccardSimilarity,
   getToolMemory
-} from "./chunk-NINNWQ42.js";
+} from "./chunk-GYDO2WOR.js";
 import {
   createSessionMemory
-} from "./chunk-PGGSGUO4.js";
+} from "./chunk-NZGNOXXW.js";
 import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-PID22PMZ.js";
+} from "./chunk-P6FBH2UG.js";
 import {
   resolveInsideRoot
 } from "./chunk-NUBSJGQZ.js";
@@ -145,7 +146,7 @@ import {
   createEvent,
   getGlobalEventBus,
   getGlobalRegistry
-} from "./chunk-BDERGLIX.js";
+} from "./chunk-XIFOAZ5B.js";
 import {
   CliDetectionCache,
   asRecord,
@@ -153,19 +154,19 @@ import {
   getAvailableClis,
   sleep,
   withTimeout
-} from "./chunk-2QFUW2SP.js";
+} from "./chunk-VZCQRLXT.js";
 import {
   DEFAULTS
-} from "./chunk-JTECUWWI.js";
+} from "./chunk-WHZD2W6Q.js";
 import {
   getAvailabilityCache,
   getCliForModelId,
   resolveFallback
-} from "./chunk-JPBPQN4U.js";
+} from "./chunk-7BONPRR2.js";
 import {
   generateHyphenId,
   generateUUID
-} from "./chunk-PARI43LB.js";
+} from "./chunk-E4IYX7LD.js";
 import {
   AGENT_ROUTER_TIMEOUTS,
   API_TIMEOUTS,
@@ -217,6 +218,7 @@ import {
   detectCapabilityGaps,
   detectTaskCategory,
   detectTrend,
+  entrypointToolFor,
   err,
   extractJsonArray,
   extractJsonObject,
@@ -239,6 +241,7 @@ import {
   getOutcomeSummaryText,
   getPipelineEventBus,
   getRandomProvider,
+  getStrategyManifest,
   getTimeProvider,
   getTokenEstimator,
   isErr,
@@ -246,21 +249,23 @@ import {
   lookupInTreeCapability,
   modelSupportsAll,
   ok,
+  rankStrategiesByManifest,
   recordRoutingGaps,
   researchContextFromText,
   resolveModelIdentity,
   resolveModelIdentitySync,
   routingArmDisplaySlot,
+  selectStrategyByManifest,
   toExpertTaskAnalysisResult,
   withStep
-} from "./chunk-4KBG4ICZ.js";
+} from "./chunk-QJIHSQZX.js";
 import {
   ensureLearningDir,
   getMetaOutcomesFile,
   isPersistenceEnabled,
   nexusDataPath,
   nexusDataPathEnsure
-} from "./chunk-ZGLIHPGJ.js";
+} from "./chunk-RUSP5PJR.js";
 
 // src/agents/state-machine-types.ts
 var VALID_TRANSITIONS = /* @__PURE__ */ new Map([
@@ -2098,6 +2103,7 @@ var AgentMemoryError = class extends Error {
     this.context = context;
     this.name = "AgentMemoryError";
   }
+  context;
 };
 function createInitialMemoryState(agentId, role) {
   return {
@@ -6116,6 +6122,7 @@ var BaseProtocol = class {
     this.options = options;
     this.logger = options.logger ?? createLogger({ component: "CollaborationProtocol" });
   }
+  options;
   logger;
   session = null;
   cancelled = false;
@@ -14364,6 +14371,8 @@ var ExternalPackError = class extends Error {
     this.source = source;
     this.name = "ExternalPackError";
   }
+  packName;
+  source;
 };
 var ExternalSkillParameterSchema = z19.object({
   name: z19.string().min(1),
@@ -16119,6 +16128,8 @@ var PolicyError = class _PolicyError extends Error {
     this.name = "PolicyError";
     Object.setPrototypeOf(this, _PolicyError.prototype);
   }
+  code;
+  context;
 };
 var DEFAULT_POLICY_PARAMETERS = {
   version: "1.0.0",
@@ -17494,6 +17505,8 @@ var StepExecutionError = class _StepExecutionError extends Error {
     this.name = "StepExecutionError";
     Object.setPrototypeOf(this, _StepExecutionError.prototype);
   }
+  code;
+  context;
 };
 async function executeStep(context, state, agentIds, agentMap, originalTask) {
   const { policyEngine, stateManager } = context;
@@ -17554,6 +17567,8 @@ var PuppeteerError = class _PuppeteerError extends Error {
     this.name = "PuppeteerError";
     Object.setPrototypeOf(this, _PuppeteerError.prototype);
   }
+  code;
+  context;
   /**
    * Create from a StepExecutionError.
    */
@@ -20658,6 +20673,7 @@ var BudgetCircuitBreaker = class {
     this.lastStateChange = getTimeProvider().now();
     this.logger = logger57 ?? createLogger({ component: "budget-circuit-breaker" });
   }
+  maxTokens;
   state = "closed";
   lastStateChange;
   violationCount = 0;
@@ -23618,10 +23634,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 z114 = getZScore(confidence);
+  const z115 = getZScore(confidence);
   return {
-    lower: difference - z114 * seDiff,
-    upper: difference + z114 * seDiff,
+    lower: difference - z115 * seDiff,
+    upper: difference + z115 * seDiff,
     estimate: difference,
     confidence,
     n: total1 + total2,
@@ -23644,11 +23660,11 @@ function proportionConfidenceInterval(successes, total, options = {}) {
       standardError: 0
     };
   }
-  const z114 = getZScore(opts.confidence);
-  const z210 = z114 * z114;
+  const z115 = getZScore(opts.confidence);
+  const z210 = z115 * z115;
   const denominator = 1 + z210 / n;
   const center = (p + z210 / (2 * n)) / denominator;
-  const margin = z114 / denominator * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
+  const margin = z115 / 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);
@@ -23678,8 +23694,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 z114 = getZScore(opts.confidence);
-  const margin = z114 * standardError;
+  const z115 = getZScore(opts.confidence);
+  const margin = z115 * standardError;
   return {
     lower: mean - margin,
     upper: mean + margin,
@@ -26281,7 +26297,7 @@ function execIdFields(executionId) {
 async function populateUnifiedContextOnState(state, options) {
   const taskCandidate = state["task"];
   if (typeof taskCandidate !== "string" || taskCandidate === "") return;
-  const { getContextForTask: getContextForTask2, inferTaskCategory: inferTaskCategory2 } = await import("./context-retriever-GRMH7WSS.js");
+  const { getContextForTask: getContextForTask2, inferTaskCategory: inferTaskCategory2 } = await import("./context-retriever-5OVRAWNZ.js");
   const category = inferTaskCategory2(taskCandidate);
   const executionId = options?.executionId;
   const execFields = execIdFields(executionId);
@@ -27718,6 +27734,7 @@ var TraceWriter = class {
       }
     });
   }
+  options;
   buffer = [];
   unsubscribe;
   runDir;
@@ -29843,6 +29860,7 @@ var CycleError = class extends Error {
     super(message);
     this.cycleRoles = cycleRoles;
   }
+  cycleRoles;
   name = "CycleError";
 };
 var MissingDependencyError = class extends Error {
@@ -29851,6 +29869,8 @@ var MissingDependencyError = class extends Error {
     this.sourceRole = sourceRole;
     this.missingRole = missingRole;
   }
+  sourceRole;
+  missingRole;
   name = "MissingDependencyError";
 };
 function topologicalWaveAssign(entries) {
@@ -40001,9 +40021,58 @@ var AuditCategorySchema = z85.enum([
   // Settings changes
   "security",
   // Security events, violations
-  "system"
+  "system",
   // System events, startup, shutdown
+  "governance"
+  // Authority-tier transitions, ratification (Epic D, #3842)
 ]);
+var TierTransitionKindSchema = z85.enum(["promotion", "demotion"]);
+var TierTransitionTierSchema = z85.enum(["observe", "suggest", "advisory", "enforce"]);
+var TierTransitionPayloadSchema = z85.object({
+  /** Whether the loop moved up (`promotion`) or down (`demotion`) the ladder. */
+  kind: TierTransitionKindSchema,
+  /** The loop/strategy whose tier changed (manifest `id` or loop identifier). */
+  subject: z85.string().min(1),
+  /** Tier before the transition. */
+  fromTier: TierTransitionTierSchema,
+  /** Tier after the transition. */
+  toTier: TierTransitionTierSchema,
+  /** Ref to the promotion-evidence record this transition was earned against. */
+  evidenceRef: z85.string().min(1),
+  /**
+   * Ref to the recorded `consensus_vote` that ratified a PROMOTION. Required
+   * by the ratification gate for `kind: 'promotion'`; legitimately absent for
+   * `kind: 'demotion'` (automatic, ADR-0017 §"Demotion is automatic").
+   */
+  ratificationVoteRef: z85.string().min(1).optional()
+}).strict();
+var TIER_TRANSITION_METADATA_KEY = "tierTransition";
+var RatificationVoteSchema = z85.object({
+  /** The ref a tier-transition's `ratificationVoteRef` must equal to resolve. */
+  id: z85.string().min(1),
+  /** The loop/strategy the vote ratified (cross-checked against the transition subject). */
+  subject: z85.string().min(1),
+  /**
+   * The recorded decision. Only `approved` ratifies a promotion; `rejected`
+   * fails the gate (`promotion-ratification-not-approved`).
+   */
+  decision: z85.enum(["approved", "rejected"]),
+  /**
+   * The voting strategy. A promotion is governance-of-the-governor and must be
+   * ratified by a `higher_order` consensus_vote (ADR-0017).
+   */
+  strategy: z85.enum(["higher_order", "simple_majority", "supermajority", "unanimous"]),
+  /** ISO-8601 timestamp the vote was recorded. */
+  votedAt: z85.string().min(1),
+  /** Optional approval fraction / quorum detail, for the human record. */
+  approvalPercentage: z85.number().min(0).max(100).optional(),
+  /** Optional link to the vote artifact / issue thread for the human record. */
+  voteUri: z85.string().min(1).optional()
+}).strict();
+var RatificationVoteLedgerSchema = z85.object({
+  version: z85.number().int().positive(),
+  votes: z85.array(RatificationVoteSchema)
+}).strict();
 var AuditSeveritySchema = z85.enum([
   "info",
   // Normal operations
@@ -40076,9 +40145,19 @@ var AuditEventSchema = z85.object({
   // Integrity (for tamper-evidence)
   previousHash: z85.string().optional(),
   // Hash of previous event (chain)
-  hash: z85.string().optional()
+  hash: z85.string().optional(),
   // Hash of this event
+  /**
+   * Hash-projection version (#3921). ABSENT/`1` = the legacy projection
+   * ({id,timestamp,category,action,outcome,actor,previousHash}); `2` =
+   * the legacy projection PLUS the canonicalized `metadata.tierTransition`
+   * payload, so a tier-transition's integrity-critical payload is hash-covered.
+   * Versioned so pre-existing v1 chains keep verifying under their own
+   * projection (see {@link AUDIT_HASH_VERSION_TIER_TRANSITION}).
+   */
+  hashVersion: z85.number().int().positive().optional()
 });
+var AUDIT_HASH_VERSION_TIER_TRANSITION = 2;
 var AuditEventInputSchema = z85.object({
   category: AuditCategorySchema,
   severity: AuditSeveritySchema.optional().default("info"),
@@ -40445,13 +40524,33 @@ var FileAuditStorage = class _FileAuditStorage {
 
 // src/audit/audit-logger.ts
 import * as crypto from "crypto";
+
+// src/audit/tier-transition-hash.ts
+function isTierTransitionEvent(event) {
+  return event.category === "governance" && event.action.startsWith("tier.");
+}
+function canonicalTierTransition(raw) {
+  const parsed = TierTransitionPayloadSchema.safeParse(raw);
+  if (!parsed.success) return JSON.stringify({ tierTransitionInvalid: raw });
+  const p = parsed.data;
+  return JSON.stringify({
+    kind: p.kind,
+    subject: p.subject,
+    fromTier: p.fromTier,
+    toTier: p.toTier,
+    evidenceRef: p.evidenceRef,
+    ratificationVoteRef: p.ratificationVoteRef ?? null
+  });
+}
+
+// src/audit/audit-logger.ts
 function generateEventId() {
   const timestamp = getTimeProvider().now().toString(36);
   const random = crypto.randomBytes(6).toString("hex");
   return `aud_${timestamp}_${random}`;
 }
 function computeEventHash(event) {
-  const data = JSON.stringify({
+  const projection = {
     id: event.id,
     timestamp: event.timestamp,
     category: event.category,
@@ -40459,8 +40558,13 @@ function computeEventHash(event) {
     outcome: event.outcome,
     actor: event.actor,
     previousHash: event.previousHash
-  });
-  return crypto.createHash("sha256").update(data).digest("hex");
+  };
+  if (isTierTransitionEvent(event)) {
+    projection["hashVersion"] = AUDIT_HASH_VERSION_TIER_TRANSITION;
+    const raw = event.metadata?.[TIER_TRANSITION_METADATA_KEY];
+    projection["tierTransition"] = canonicalTierTransition(raw);
+  }
+  return crypto.createHash("sha256").update(JSON.stringify(projection)).digest("hex");
 }
 function verifyEvent(event, index, priorHash) {
   if (event.hash === void 0) {
@@ -40526,7 +40630,9 @@ var AuditLogger = class {
   closed = false;
   inFlightFlush = null;
   droppedEventCount = 0;
-  constructor(config, storage, logger57) {
+  persistFailureCount = 0;
+  onPersistFailure;
+  constructor(config, storage, logger57, onPersistFailure) {
     const validated = AuditLogConfigSchema.safeParse(config);
     if (!validated.success) {
       const issues = validated.error.issues.map((i) => i.path.join(".") + ": " + i.message).join("; ");
@@ -40539,16 +40645,53 @@ var AuditLogger = class {
     this.flushIntervalMs = validated.data.flushIntervalMs;
     this.maxQueueDepth = validated.data.maxQueueDepth;
     this.storage = storage ?? new FileAuditStorage(validated.data, this.logger);
+    this.onPersistFailure = onPersistFailure;
     this.startFlushTimer();
     this.logger.info("AuditLogger initialized", { logDir: config.logDir });
   }
   startFlushTimer() {
     this.flushTimer = setInterval(() => {
-      this.flush().catch((err2) => {
-        this.logger.error("Audit flush failed", err2 instanceof Error ? err2 : void 0);
+      this.flush().catch(() => {
       });
     }, this.flushIntervalMs);
   }
+  /**
+   * Fail-loud handler for an audit-persist failure (#3916). A dropped/failed
+   * audit write undermines the tamper-evident hash chain (ADR-0017 /
+   * docs/security/audit-hash-chain-threat-model.md), so unlike the best-effort
+   * cost path this is NOT swallowed: it logs prominently at error level,
+   * increments a process-lifetime counter (exposed via
+   * {@link getPersistFailureCount}), and invokes the optional `onPersistFailure`
+   * hook so a governance consumer can escalate (e.g. raise/alert). Callers on the
+   * awaited flush()/close() path additionally receive the thrown error directly.
+   */
+  recordPersistFailure(err2) {
+    this.persistFailureCount += 1;
+    const error = err2 instanceof Error ? err2 : new AuditError(String(err2));
+    this.logger.error("AUDIT PERSIST FAILURE \u2014 audit event NOT durably written", error, {
+      totalPersistFailures: this.persistFailureCount,
+      hashChainEnabled: this.enableHashChain
+    });
+    if (this.onPersistFailure !== void 0) {
+      try {
+        this.onPersistFailure(error);
+      } catch (hookErr) {
+        this.logger.error(
+          "AUDIT PERSIST FAILURE \u2014 onPersistFailure hook threw (original audit error preserved)",
+          hookErr instanceof Error ? hookErr : new AuditError(String(hookErr))
+        );
+      }
+    }
+  }
+  /**
+   * Process-lifetime count of audit flushes that FAILED to persist (#3916). A
+   * non-zero value means at least one audit event was not durably written — the
+   * hash chain may have a gap. Surfaced so the failure is observable rather than
+   * silent.
+   */
+  getPersistFailureCount() {
+    return this.persistFailureCount;
+  }
   shouldLog(input) {
     const severityLevels = { info: 0, warning: 1, critical: 2 };
     const inputLevel = severityLevels[input.severity];
@@ -40582,6 +40725,7 @@ var AuditLogger = class {
       violationType: input.violationType,
       previousHash: this.enableHashChain ? this.lastHash ?? void 0 : void 0
     };
+    if (isTierTransitionEvent(event)) event.hashVersion = AUDIT_HASH_VERSION_TIER_TRANSITION;
     if (this.enableHashChain) {
       event.hash = computeEventHash(event);
       this.lastHash = event.hash;
@@ -40672,6 +40816,42 @@ var AuditLogger = class {
       metadata: { currentRate: opts.currentRate, limitRate: opts.limitRate }
     });
   }
+  /**
+   * Log an authority-tier transition (Epic D / ADR-0017, #3842). A promotion or
+   * demotion of a loop's authority tier is recorded as a hash-chained
+   * `governance`-category event whose `metadata.tierTransition` carries the
+   * structured {@link TierTransitionPayload} ({subject, fromTier, toTier,
+   * evidenceRef, ratificationVoteRef?}).
+   *
+   * The emitter does NOT itself enforce the ratification invariant (a promotion
+   * with no `ratificationVoteRef` is still chained — tampering with the log to
+   * remove the field must not erase the event). The invariant is enforced by the
+   * ratification gate (`scripts/check-authority-tier-drift.ts`), which reads the
+   * chained events back and FAILS a `promotion` lacking a vote ref. A promotion
+   * is emitted at `warning` severity (it grants authority) so it surfaces above
+   * the default info floor; a demotion is `info` (it is the safe direction).
+   */
+  logTierTransition(opts) {
+    const payload = TierTransitionPayloadSchema.parse({
+      kind: opts.kind,
+      subject: opts.subject,
+      fromTier: opts.fromTier,
+      toTier: opts.toTier,
+      evidenceRef: opts.evidenceRef,
+      ...opts.ratificationVoteRef !== void 0 ? { ratificationVoteRef: opts.ratificationVoteRef } : {}
+    });
+    this.log({
+      category: "governance",
+      severity: opts.kind === "promotion" ? "warning" : "info",
+      outcome: "success",
+      action: `tier.${opts.kind}`,
+      description: `Authority-tier ${opts.kind}: '${opts.subject}' ${opts.fromTier} \u2192 ${opts.toTier}`,
+      actor: opts.actor ?? SYSTEM_ACTOR,
+      resource: { type: "loop", id: opts.subject, name: opts.subject },
+      requestId: opts.requestId,
+      metadata: { ...opts.metadata, [TIER_TRANSITION_METADATA_KEY]: payload }
+    });
+  }
   /** Log system startup event */
   logSystemStartup(metadata) {
     this.log({
@@ -40715,7 +40895,10 @@ var AuditLogger = class {
    */
   async flush() {
     if (this.inFlightFlush !== null) return this.inFlightFlush;
-    const drain = this.drainAndFlushOnce().finally(() => {
+    const drain = this.drainAndFlushOnce().catch((err2) => {
+      this.recordPersistFailure(err2);
+      throw err2;
+    }).finally(() => {
       this.inFlightFlush = null;
     });
     this.inFlightFlush = drain;
@@ -40733,8 +40916,8 @@ var AuditLogger = class {
     this.logger.info("AuditLogger closed");
   }
 };
-function createAuditLogger(config, storage, logger57) {
-  return new AuditLogger(config, storage, logger57);
+function createAuditLogger(config, storage, logger57, onPersistFailure) {
+  return new AuditLogger(config, storage, logger57, onPersistFailure);
 }
 
 // src/pipeline/research-trigger.ts
@@ -41204,7 +41387,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-PYHGDQHK.js");
+    const { createIssueTriage } = await import("./issue-triage-CZPFNGB7.js");
     const triage = createIssueTriage();
     const owner = issueMatch[1] ?? "";
     const num = issueMatch[2] ?? "";
@@ -41232,7 +41415,7 @@ var VALID_TEMPLATES = /* @__PURE__ */ new Set([
 ]);
 async function classifyWithLLM(task) {
   try {
-    const { executeExpert: executeExpert2 } = await import("./expert-bridge-BW55FRAH.js");
+    const { executeExpert: executeExpert2 } = await import("./expert-bridge-MINXBC73.js");
     const prompt = [
       "Classify this task into exactly one pipeline template.",
       "Templates: dev (implementation/bug fix/refactor), research (investigate/evaluate/compare),",
@@ -42998,8 +43181,8 @@ var memoryInitPromise = null;
 async function initPipelineMemory() {
   if (cachedMemory !== null) return cachedMemory;
   try {
-    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-MJHN5FXI.js");
-    const { getLearningDir } = await import("./learning-persistence-C737Q6EP.js");
+    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-HQWAXH3C.js");
+    const { getLearningDir } = await import("./learning-persistence-QFCQ5POD.js");
     const mem = createSessionMemory2(getLearningDir());
     mem.startSession(`pipeline-${String(getTimeProvider().now())}`);
     cachedMemory = {
@@ -43060,7 +43243,7 @@ function recordRoutingExperience(category, success, durationMs, tokensUsed = 0,
     callRecord(routingMemoryCache);
     return;
   }
-  routingMemoryInitPromise ??= import("./routing-memory-BQ6MUC5Y.js").then(({ createRoutingMemory }) => {
+  routingMemoryInitPromise ??= import("./routing-memory-OGUOL7UF.js").then(({ createRoutingMemory }) => {
     routingMemoryCache ??= createRoutingMemory();
     return routingMemoryCache;
   }).catch((error) => {
@@ -43094,7 +43277,7 @@ ${text}` : "";
 }
 async function getWeatherContext() {
   try {
-    const { generateWeatherReport: generateWeatherReport2 } = await import("./weather-report-7WC3RKE7.js");
+    const { generateWeatherReport: generateWeatherReport2 } = await import("./weather-report-GX7OIUL2.js");
     const report = generateWeatherReport2({ includeAdaptive: true });
     const mappings = "recommendedMappings" in report ? report.recommendedMappings : [];
     if (!Array.isArray(mappings) || mappings.length === 0) return "";
@@ -43112,8 +43295,8 @@ ${lines}
 }
 async function getMemoryContext(task) {
   try {
-    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-MJHN5FXI.js");
-    const { getLearningDir } = await import("./learning-persistence-C737Q6EP.js");
+    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-HQWAXH3C.js");
+    const { getLearningDir } = await import("./learning-persistence-QFCQ5POD.js");
     const memory = createSessionMemory2(getLearningDir(), { maxLearningsInContext: 10 });
     const learnings = memory.searchLearnings(task.slice(0, 200));
     if (learnings.length === 0) return "";
@@ -43224,7 +43407,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-PEWNN4WK.js");
+        const { executeVoting } = await import("./consensus-vote-E2WJFEIJ.js");
         const votingResult = await executeVoting(
           {
             proposal: buildVoteProposal(plan, research),
@@ -43646,7 +43829,7 @@ function createScaffoldStageWrapper() {
 }
 async function searchCodebaseForTask(task) {
   try {
-    const { CodebaseIndex: CodebaseIndex2 } = await import("./codebase-search-ZFJUVMVR.js");
+    const { CodebaseIndex: CodebaseIndex2 } = await import("./codebase-search-PWMWLU7O.js");
     const index = new CodebaseIndex2(process.cwd());
     const terms = task.toLowerCase().split(/\s+/).filter((w) => w.length > 4).slice(0, 3);
     if (terms.length === 0) return null;
@@ -43661,7 +43844,7 @@ async function searchCodebaseForTask(task) {
 }
 async function queryResearchRegistry(task) {
   try {
-    const { synthesizeResearch: synthesizeResearch2 } = await import("./research-helpers-synthesize-EDT6REQJ.js");
+    const { synthesizeResearch: synthesizeResearch2 } = await import("./research-helpers-synthesize-IQHDU27S.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));
@@ -43713,7 +43896,7 @@ function createAnalyzeStageWrapper() {
             true
           );
         }
-        const { analyzeGitHubRepo: analyzeGitHubRepo2 } = await import("./repo-analyze-JZEMBE6R.js");
+        const { analyzeGitHubRepo: analyzeGitHubRepo2 } = await import("./repo-analyze-UJOWFGNM.js");
         const analysis = await analyzeGitHubRepo2({ repo: slug, depth: "deep" });
         const summary = `Language: ${String(analysis.language)}, Framework: ${String(analysis.framework)}, CI: ${String(analysis.ciProvider)}, Security: ${analysis.securityTooling.join(", ") || "none"}`;
         return output(PIPELINE_STATE_KEYS.RESEARCH, summary, getTimeProvider().now() - start, true);
@@ -43732,7 +43915,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-5V43DEGA.js");
+          const { generateSecurityPlan: generateSecurityPlan2 } = await import("./repo-security-plan-HSYGGVEJ.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("; ");
           return output(PIPELINE_STATE_KEYS.FINDINGS, recs, getTimeProvider().now() - start, true);
@@ -44002,12 +44185,25 @@ async function executePrReviewBody(input, logger57) {
   const reviews = voteResults.map(toPrReviewVote);
   const counts = summarizeReviews(reviews);
   const aggregate = aggregatePrDecisions(reviews);
+  let costSummary;
+  try {
+    costSummary = recordDecisionCost({
+      decisionId: `pr-${randomUUID13().slice(0, 8)}`,
+      gate: "pr_review",
+      votes: voteResults
+    });
+  } catch (costError) {
+    logger57.warn("Per-decision cost rollup failed (non-fatal)", {
+      error: getErrorMessage(costError)
+    });
+  }
   const response = {
     summary: aggregate.decision,
     verified: aggregate.verified,
     ...counts,
     reviews,
-    totalDurationMs: Date.now() - start
+    totalDurationMs: Date.now() - start,
+    ...costSummary !== void 0 ? { costSummary } : {}
   };
   return toolSuccess(JSON.stringify(response, null, 2));
 }
@@ -45296,103 +45492,50 @@ import { randomUUID as randomUUID17 } from "crypto";
 
 // src/orchestration/meta-orchestrator.ts
 import { randomUUID as randomUUID14 } from "crypto";
-function createAuditLogSink(logger57) {
-  return {
-    record(record) {
-      logger57.info("MetaOrchestrator selection decision", { ...record });
-    }
-  };
-}
-function strategyFromPattern(pattern, complexity) {
-  switch (pattern) {
-    case "consensus":
-      return "consensus";
-    case "graph":
-      return "graph-workflow";
-    case "wave":
-    case "aflow":
-    case "puppeteer":
-      return "orchestrate";
-    case "sequential":
-      return complexity === "simple" ? "single-shot" : "dev-pipeline";
-    default: {
-      const _exhaustive = pattern;
-      return _exhaustive;
-    }
-  }
-}
-function strategyFromPipelineType(pipelineType) {
-  switch (pipelineType) {
-    case "greenfield":
-      return "spec";
-    case "research":
-      return "research";
-    case "audit":
-      return "pipeline";
-    case "dev":
-      return "dev-pipeline";
-    case "general":
-      return "pipeline";
-    default: {
-      const _exhaustive = pipelineType;
-      return _exhaustive;
-    }
-  }
+
+// src/orchestration/meta-orchestrator-routing.ts
+function reasoningFor(selection, routing) {
+  const { manifest, rule } = selection;
+  const cause = rule.pipelineTypes !== void 0 && rule.patterns === void 0 ? `pipeline template "${rule.pipelineTypes.join("/")}"` : rule.pipelineTypes !== void 0 ? `pipeline template "${rule.pipelineTypes.join("/")}" under pattern "${routing.pattern}"` : `pattern "${routing.pattern}"`;
+  return `${cause} \u2192 ${manifest.strategy} (manifest ${manifest.id}; ${routing.reasoning})`;
 }
 function decideStrategy(routing, classification) {
   const { pattern, analysis } = routing;
   const { pipelineType } = classification;
-  if (pattern === "consensus") {
-    return {
-      strategy: "consensus",
-      reasoning: `Consensus pattern selected (${routing.reasoning}) \u2014 routing to a multi-perspective vote`,
-      confidence: routing.confidence
-    };
-  }
-  if (pipelineType === "greenfield") {
-    return {
-      strategy: "spec",
-      reasoning: "Greenfield work detected \u2014 routing to a spec-driven build",
-      confidence: classification.confidence
-    };
-  }
-  if (pipelineType === "research") {
-    return {
-      strategy: "research",
-      reasoning: "Research-heavy work detected \u2014 routing to the research pipeline",
-      confidence: classification.confidence
-    };
-  }
-  const patternStrategy = strategyFromPattern(pattern, analysis.complexity);
-  if (pipelineType === "audit" && (patternStrategy === "dev-pipeline" || patternStrategy === "single-shot")) {
+  const selection = selectStrategyByManifest({
+    pattern,
+    pipelineType,
+    complexity: analysis.complexity
+  });
+  if (selection === void 0) {
+    const fallback = "orchestrate";
     return {
-      strategy: "pipeline",
-      reasoning: "Audit work detected \u2014 routing to the templated audit pipeline",
-      confidence: classification.confidence
+      strategy: fallback,
+      reasoning: `No manifest rule matched pattern "${pattern}" \u2014 structural fallback to ${fallback}`,
+      confidence: routing.confidence,
+      manifestId: fallback,
+      manifestSchemaVersion: 0
     };
   }
+  const fromTemplate = selection.rule.pipelineTypes !== void 0;
   return {
-    strategy: patternStrategy,
-    reasoning: `Pattern "${pattern}" \u2192 ${patternStrategy} (${routing.reasoning})`,
-    confidence: routing.confidence
+    strategy: selection.strategy,
+    reasoning: reasoningFor(selection, routing),
+    confidence: fromTemplate ? classification.confidence : routing.confidence,
+    manifestId: selection.manifest.id,
+    manifestSchemaVersion: selection.manifest.schemaVersion
   };
 }
 function buildAlternatives(chosen, routing, classification) {
-  const candidates = [
-    strategyFromPattern(routing.pattern, routing.analysis.complexity),
-    strategyFromPipelineType(classification.pipelineType),
-    "orchestrate"
-  ];
-  const seen = /* @__PURE__ */ new Set([chosen]);
-  const alternatives = [];
-  for (const c of candidates) {
-    if (!seen.has(c)) {
-      seen.add(c);
-      alternatives.push(c);
-    }
-  }
-  return alternatives;
+  const ranked = rankStrategiesByManifest({
+    pattern: routing.pattern,
+    pipelineType: classification.pipelineType,
+    complexity: routing.analysis.complexity
+  });
+  return ranked.filter((s) => s !== chosen);
 }
+
+// src/orchestration/meta-orchestrator-decision.ts
 function subSignals(routing, classification) {
   return {
     pattern: routing.pattern,
@@ -45402,12 +45545,15 @@ function subSignals(routing, classification) {
   };
 }
 function buildForcedDecision(forced, routing, classification) {
+  const manifest = getStrategyManifest(forced);
   return {
     strategy: forced,
-    reasoning: `Strategy forced by caller: ${forced}`,
+    reasoning: `Strategy forced by caller: ${forced} (entrypoint ${entrypointToolFor(forced)})`,
     confidence: 1,
     alternatives: buildAlternatives(forced, routing, classification),
     needsShaping: false,
+    manifestId: manifest?.id ?? forced,
+    manifestSchemaVersion: manifest?.schemaVersion ?? 0,
     ...subSignals(routing, classification)
   };
 }
@@ -45420,6 +45566,8 @@ function buildSelectedDecision(routing, classification) {
     confidence: core.confidence,
     alternatives: buildAlternatives(core.strategy, routing, classification),
     needsShaping,
+    manifestId: core.manifestId,
+    manifestSchemaVersion: core.manifestSchemaVersion,
     ...needsShaping && routing.suggestedQuestions !== void 0 ? { shapingQuestions: routing.suggestedQuestions } : {},
     ...subSignals(routing, classification)
   };
@@ -45435,7 +45583,88 @@ function toRecord(decision, goal, forced, timestamp) {
     pipelineType: decision.pipelineType,
     alternatives: decision.alternatives,
     needsShaping: decision.needsShaping,
-    forced
+    forced,
+    manifestId: decision.manifestId,
+    manifestSchemaVersion: decision.manifestSchemaVersion
+  };
+}
+
+// src/orchestration/authority-tier-guard.ts
+var ACTION_CLASSES = ["observe", "suggest", "advisory", "enforce"];
+var RANK = Object.freeze(
+  Object.fromEntries(ACTION_CLASSES.map((c, i) => [c, i]))
+);
+function authorityRank(level) {
+  return RANK[level];
+}
+function permitsAction(declaredTier, actionClass) {
+  const ceiling = declaredTier === void 0 ? 0 : authorityRank(declaredTier);
+  return authorityRank(actionClass) <= ceiling;
+}
+function dispatchActionClass(_mode) {
+  return "suggest";
+}
+var AuthorityRefusalError = class extends Error {
+  code;
+  strategy;
+  /** The tier the strategy's manifest declared (undefined ⇒ none declared). */
+  declaredTier;
+  /** The authority class of the action that was refused. */
+  attemptedAction;
+  constructor(args) {
+    super(args.message);
+    this.name = "AuthorityRefusalError";
+    this.code = args.code;
+    this.strategy = args.strategy;
+    this.declaredTier = args.declaredTier;
+    this.attemptedAction = args.attemptedAction;
+  }
+};
+function evaluateAuthority(strategy, actionClass) {
+  const manifest = getStrategyManifest(strategy);
+  const declaredTier = manifest?.authorityTier;
+  if (declaredTier === void 0) {
+    if (authorityRank(actionClass) === 0) {
+      return { permitted: true, declaredTier: "observe" };
+    }
+    return {
+      permitted: false,
+      refusal: new AuthorityRefusalError({
+        code: "tier_undeclared",
+        strategy,
+        declaredTier: void 0,
+        attemptedAction: actionClass,
+        message: `Strategy '${strategy}' has no declared authorityTier but attempted an '${actionClass}'-class action. Fail-closed refusal (ADR-0017): declare a tier in governance/strategy-manifests.yaml.`
+      })
+    };
+  }
+  if (permitsAction(declaredTier, actionClass)) {
+    return { permitted: true, declaredTier };
+  }
+  return {
+    permitted: false,
+    refusal: new AuthorityRefusalError({
+      code: "above_declared_tier",
+      strategy,
+      declaredTier,
+      attemptedAction: actionClass,
+      message: `Strategy '${strategy}' is declared authorityTier='${declaredTier}' but attempted an '${actionClass}'-class action, which is above its tier. Refused fail-closed (ADR-0017): promotion requires an evidence record + ratification, not a default flip.`
+    })
+  };
+}
+function guardAuthority(strategy, actionClass) {
+  const decision = evaluateAuthority(strategy, actionClass);
+  if (!decision.permitted) {
+    throw decision.refusal;
+  }
+}
+
+// src/orchestration/meta-orchestrator.ts
+function createAuditLogSink(logger57) {
+  return {
+    record(record) {
+      logger57.info("MetaOrchestrator selection decision", { ...record });
+    }
   };
 }
 function recordShadow(shadowSelector, shadowSink, decision, timestamp, logger57) {
@@ -45454,6 +45683,19 @@ function recordShadow(shadowSelector, shadowSink, decision, timestamp, logger57)
     logger57.warn("Shadow selection failed (non-fatal)", { error: getErrorMessage(err2) });
   }
 }
+function logSelection(logger57, decision, forced) {
+  logger57.info("MetaOrchestrator strategy selected", {
+    decisionId: decision.decisionId,
+    strategy: decision.strategy,
+    confidence: decision.confidence,
+    pattern: decision.pattern,
+    pipelineType: decision.pipelineType,
+    needsShaping: decision.needsShaping,
+    forced,
+    manifestId: decision.manifestId,
+    manifestSchemaVersion: decision.manifestSchemaVersion
+  });
+}
 function createMetaOrchestrator(options) {
   const logger57 = options?.logger ?? createLogger({ component: "MetaOrchestrator" });
   const router = options?.router ?? createWorkflowRouter({ logger: logger57 });
@@ -45469,6 +45711,9 @@ function createMetaOrchestrator(options) {
       const forced = input.forceStrategy !== void 0;
       const base = input.forceStrategy !== void 0 ? buildForcedDecision(input.forceStrategy, routing, classification) : buildSelectedDecision(routing, classification);
       const decision = { ...base, decisionId: randomUUID14() };
+      if (input.requiredAuthority !== void 0) {
+        guardAuthority(decision.strategy, input.requiredAuthority);
+      }
       const timestamp = new Date(getTimeProvider().now()).toISOString();
       sink.record(toRecord(decision, input.goal, forced, timestamp));
       if (shadowSelector !== void 0 && shadowSink !== void 0) {
@@ -45480,15 +45725,7 @@ function createMetaOrchestrator(options) {
           decisionId: decision.decisionId
         });
       }
-      logger57.info("MetaOrchestrator strategy selected", {
-        decisionId: decision.decisionId,
-        strategy: decision.strategy,
-        confidence: decision.confidence,
-        pattern: decision.pattern,
-        pipelineType: decision.pipelineType,
-        needsShaping: decision.needsShaping,
-        forced
-      });
+      logSelection(logger57, decision, forced);
       return decision;
     }
   };
@@ -45780,10 +46017,11 @@ var GitHubTaskTracker = class {
   constructor(config) {
     this.config = config;
   }
+  config;
   cachedProvider = null;
   async getProvider() {
     if (this.cachedProvider !== null) return this.cachedProvider;
-    const { createScmProvider } = await import("./factory-YKXAMYW6.js");
+    const { createScmProvider } = await import("./factory-ZG2FZYVA.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;
@@ -45812,6 +46050,7 @@ var GitLabTaskTracker = class {
   constructor(config) {
     this.config = config;
   }
+  config;
   async createTask(title, body) {
     const repo = this.config.repo;
     if (repo === void 0) throw new Error("GitLab backend requires repo config");
@@ -46320,16 +46559,6 @@ function registerPipelineTool(server, deps) {
 }
 
 // src/mcp/tools/run-tool.ts
-var STRATEGY_ENTRYPOINT_TOOL = {
-  "single-shot": "delegate_to_model",
-  "dev-pipeline": "run_dev_pipeline",
-  pipeline: "run_pipeline",
-  "graph-workflow": "run_graph_workflow",
-  orchestrate: "orchestrate",
-  consensus: "consensus_vote",
-  spec: "execute_spec",
-  research: "run_pipeline"
-};
 var RunInputSchema = z104.object({
   goal: z104.string().min(1).describe("Natural-language goal. nexus-agents selects how to execute it."),
   forceStrategy: z104.enum([
@@ -46363,7 +46592,7 @@ var RunInputSchema = z104.object({
   )
 });
 var NOTE = "Routing decision only (read-only). Invoke the recommendedTool to execute, or wait for inline execution (run execute: true) in a later release. The other pipeline tools remain available as advanced force-strategy paths.";
-function toMetaInput(input) {
+function toMetaInput(input, mode) {
   const signals = {};
   if (input.requiresConsensus !== void 0) signals.requiresConsensus = input.requiresConsensus;
   if (input.dependencyStructure !== void 0)
@@ -46371,20 +46600,21 @@ function toMetaInput(input) {
   if (input.isNovel !== void 0) signals.isNovel = input.isNovel;
   return {
     goal: input.goal,
+    requiredAuthority: dispatchActionClass(mode),
     ...Object.keys(signals).length > 0 ? { signals } : {},
     ...input.forceStrategy !== void 0 ? { forceStrategy: input.forceStrategy } : {}
   };
 }
-function selectDecision(input, logger57) {
+function selectDecision(input, mode, logger57) {
   const meta = createMetaOrchestrator({
     ...logger57 !== void 0 ? { logger: logger57 } : {},
     shadowSelector: getShadowSelector(),
     shadowSink: getShadowSink()
   });
-  return meta.select(toMetaInput(input));
+  return meta.select(toMetaInput(input, mode));
 }
 function routeGoal(input, logger57) {
-  const decision = selectDecision(input, logger57);
+  const decision = selectDecision(input, "route", logger57);
   return {
     strategy: decision.strategy,
     reasoning: decision.reasoning,
@@ -46392,7 +46622,7 @@ function routeGoal(input, logger57) {
     alternatives: decision.alternatives,
     needsShaping: decision.needsShaping,
     ...decision.shapingQuestions !== void 0 ? { shapingQuestions: decision.shapingQuestions } : {},
-    recommendedTool: STRATEGY_ENTRYPOINT_TOOL[decision.strategy],
+    recommendedTool: entrypointToolFor(decision.strategy),
     decisionId: decision.decisionId,
     note: NOTE
   };
@@ -46424,7 +46654,7 @@ function buildShadowTrainObserver(logger57) {
   };
 }
 async function executeGoal(input, opts = {}) {
-  const decision = selectDecision(input, opts.logger);
+  const decision = selectDecision(input, "execute", opts.logger);
   const onOutcome = opts.onOutcome ?? buildShadowTrainObserver(opts.logger);
   const dispatcher = createMetaDispatcher({
     executors: opts.executors ?? buildDefaultExecutors(opts.trustTier),
@@ -46432,7 +46662,7 @@ async function executeGoal(input, opts = {}) {
     ...opts.outcomeSink !== void 0 ? { outcomeSink: opts.outcomeSink } : {},
     ...onOutcome !== void 0 ? { onOutcome } : {}
   });
-  const dispatch = await dispatcher.dispatch(decision, toMetaInput(input));
+  const dispatch = await dispatcher.dispatch(decision, toMetaInput(input, "execute"));
   return {
     strategy: dispatch.strategy,
     decisionId: dispatch.decisionId,
@@ -46456,8 +46686,9 @@ async function executeRunBody(input, logger57, trustTier) {
     return toolSuccess(JSON.stringify(exec2, null, 2));
   } catch (err2) {
     const noExecutor = err2 instanceof MetaDispatchError && err2.code === "no_executor";
+    const refused = err2 instanceof AuthorityRefusalError;
     return toolStructuredError({
-      errorCategory: noExecutor ? "business" : "internal",
+      errorCategory: noExecutor || refused ? "business" : "internal",
       message: err2 instanceof Error ? err2.message : String(err2)
     });
   }
@@ -46555,7 +46786,7 @@ async function probeSource(source, includeModelIds) {
   }
 }
 async function defaultSources(includeOpenRouter) {
-  const { createAllAdapters: createAllAdapters2 } = await import("./factory-4EV6EDZF.js");
+  const { createAllAdapters: createAllAdapters2 } = await import("./factory-KC7BYHAP.js");
   const adapters = createAllAdapters2();
   return buildDefaultModelSources(adapters, { includeOpenRouter });
 }
@@ -46611,8 +46842,52 @@ function registerListAvailableModelsTool(server, deps) {
   logger57.info("Registered list_available_models tool");
 }
 
-// src/mcp/tools/supply-chain-tradeoff-panel.ts
+// src/mcp/tools/pr-review-eval-types.ts
 import { z as z106 } from "zod";
+var PR_REVIEW_EVAL_ROLES = [
+  "architect",
+  "security",
+  "devex",
+  "catfish",
+  "scope_steward"
+];
+var PrReviewEvalRoleSchema = z106.enum(PR_REVIEW_EVAL_ROLES);
+var PrReviewCaseClassSchema = z106.enum(["buggy", "clean", "borderline"]);
+var VoterEvalVerdictSchema = z106.object({
+  /** Stable record id (e.g. `${runId}:${caseNumber}:${role}`). */
+  id: z106.string().min(1).max(160),
+  /** The pr_review run / batch this verdict belongs to. */
+  runId: z106.string().min(1).max(64),
+  /** Dataset case identifier (the dataset's `number` field). */
+  caseNumber: z106.string().min(1).max(80),
+  /** Rubric class of the case (ground-truth label). */
+  caseClass: PrReviewCaseClassSchema,
+  /** The voter role being scored. */
+  role: PrReviewEvalRoleSchema,
+  /** Verified findings that matched a known bug. */
+  truePositives: z106.number().int().nonnegative(),
+  /** Verified findings on clean code that matched no known bug. */
+  falsePositives: z106.number().int().nonnegative(),
+  /** Known bugs this voter failed to flag. */
+  falseNegatives: z106.number().int().nonnegative(),
+  /** Rubric version the ground truth was adjudicated under. */
+  rubricVersion: z106.string().min(1).max(32),
+  /** ISO-8601 timestamp the verdict was recorded. */
+  timestamp: z106.string().min(1).max(40)
+});
+var VoterEvalVerdictQuerySchema = z106.object({
+  role: PrReviewEvalRoleSchema.optional(),
+  runId: z106.string().min(1).max(64).optional(),
+  caseClass: PrReviewCaseClassSchema.optional(),
+  rubricVersion: z106.string().min(1).max(32).optional(),
+  /** ISO-8601 lower bound (inclusive) on `timestamp`. */
+  since: z106.string().optional(),
+  /** Most-recent-N cap. */
+  limit: z106.number().int().positive().optional()
+});
+
+// src/mcp/tools/supply-chain-tradeoff-panel.ts
+import { z as z107 } from "zod";
 import { randomUUID as randomUUID18 } from "crypto";
 var DEFAULT_AXES = [
   "build_time_determinism",
@@ -46634,16 +46909,16 @@ var FULL_PANEL = [
   "scope_steward"
 ];
 var QUICK_PANEL = ["architect", "security", "scope_steward"];
-var SupplyChainTradeoffPanelInputSchema = z106.object({
-  proposal: z106.string().min(1).max(MAX_PROPOSAL_LENGTH).describe('The proposal under tradeoff review (e.g. "Should aegis-boot adopt cargo-nextest?")'),
-  axes: z106.array(z106.string().min(1).max(MAX_AXIS_NAME_LENGTH)).min(1).max(MAX_AXES).optional().describe(
+var SupplyChainTradeoffPanelInputSchema = z107.object({
+  proposal: z107.string().min(1).max(MAX_PROPOSAL_LENGTH).describe('The proposal under tradeoff review (e.g. "Should aegis-boot adopt cargo-nextest?")'),
+  axes: z107.array(z107.string().min(1).max(MAX_AXIS_NAME_LENGTH)).min(1).max(MAX_AXES).optional().describe(
     `Tradeoff axes to evaluate. Default: ${DEFAULT_AXES.join(", ")}. Custom axes accepted; max ${String(MAX_AXES)}.`
   ),
-  context: z106.string().max(MAX_CONTEXT_LENGTH).optional().describe(
+  context: z107.string().max(MAX_CONTEXT_LENGTH).optional().describe(
     "Optional context: relevant repo state, dependency tree, vendor publishing patterns, etc."
   ),
-  quickMode: z106.boolean().optional().default(false).describe("Use 3 voters (architect, security, scope_steward) instead of 7"),
-  simulate: z106.boolean().optional().default(false).describe("Use simulated voters (testing only)"),
+  quickMode: z107.boolean().optional().default(false).describe("Use 3 voters (architect, security, scope_steward) instead of 7"),
+  simulate: z107.boolean().optional().default(false).describe("Use simulated voters (testing only)"),
   /**
    * Dispatch mode (#3731). `sync` (default) runs the panel inline and returns
    * the result — but a live fan-out (up to 7 voters) can exceed the MCP request
@@ -46651,7 +46926,7 @@ var SupplyChainTradeoffPanelInputSchema = z106.object({
    * immediately and runs the panel in the background; poll
    * `get_job_result({ jobId })` for the result.
    */
-  dispatch: z106.enum(["sync", "async"]).default("sync").describe(
+  dispatch: z107.enum(["sync", "async"]).default("sync").describe(
     "Dispatch mode (#3731). 'sync' (default): run inline. 'async': return a jobId immediately + run the panel in background (poll get_job_result)."
   )
 });
@@ -47118,40 +47393,40 @@ var RiskLevel = /* @__PURE__ */ ((RiskLevel2) => {
 })(RiskLevel || {});
 
 // src/mcp/safety/stpa-schemas.ts
-import { z as z107 } from "zod";
-var HazardCategorySchema = z107.enum(HazardCategory);
-var HazardSeveritySchema = z107.enum(HazardSeverity);
-var ConstraintPrioritySchema = z107.enum(ConstraintPriority);
-var RiskLevelSchema = z107.enum(RiskLevel);
-var TriggerPatternSchema = z107.object({
-  parameter: z107.string().min(1),
-  matchType: z107.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
-  pattern: z107.string(),
-  reason: z107.string()
+import { z as z108 } from "zod";
+var HazardCategorySchema = z108.enum(HazardCategory);
+var HazardSeveritySchema = z108.enum(HazardSeverity);
+var ConstraintPrioritySchema = z108.enum(ConstraintPriority);
+var RiskLevelSchema = z108.enum(RiskLevel);
+var TriggerPatternSchema = z108.object({
+  parameter: z108.string().min(1),
+  matchType: z108.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
+  pattern: z108.string(),
+  reason: z108.string()
 });
-var HazardSchema = z107.object({
-  id: z107.string().min(1),
-  description: z107.string(),
+var HazardSchema = z108.object({
+  id: z108.string().min(1),
+  description: z108.string(),
   category: HazardCategorySchema,
   severity: HazardSeveritySchema,
-  likelihood: z107.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
-  triggerConditions: z107.array(z107.string()),
-  consequences: z107.array(z107.string())
+  likelihood: z108.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
+  triggerConditions: z108.array(z108.string()),
+  consequences: z108.array(z108.string())
 });
-var UnsafeControlActionSchema = z107.object({
-  id: z107.string().min(1),
-  toolName: z107.string().min(1),
-  type: z107.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
-  description: z107.string(),
-  unsafeContext: z107.string(),
-  relatedHazards: z107.array(z107.string()),
-  triggerPatterns: z107.array(TriggerPatternSchema).optional()
+var UnsafeControlActionSchema = z108.object({
+  id: z108.string().min(1),
+  toolName: z108.string().min(1),
+  type: z108.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
+  description: z108.string(),
+  unsafeContext: z108.string(),
+  relatedHazards: z108.array(z108.string()),
+  triggerPatterns: z108.array(TriggerPatternSchema).optional()
 });
-var SafetyConstraintSchema = z107.object({
-  id: z107.string().min(1),
-  description: z107.string(),
-  mitigates: z107.array(z107.string()),
-  enforcement: z107.enum([
+var SafetyConstraintSchema = z108.object({
+  id: z108.string().min(1),
+  description: z108.string(),
+  mitigates: z108.array(z108.string()),
+  enforcement: z108.enum([
     "prevent",
     "require_confirmation",
     "alert",
@@ -47159,54 +47434,54 @@ var SafetyConstraintSchema = z107.object({
     "rate_limit",
     "require_privilege"
   ]),
-  validationFunction: z107.string().optional(),
+  validationFunction: z108.string().optional(),
   priority: ConstraintPrioritySchema
 });
-var PropertySchemaSchema = z107.object({
-  type: z107.string(),
-  description: z107.string().optional(),
-  enum: z107.array(z107.unknown()).optional(),
-  pattern: z107.string().optional(),
-  minimum: z107.number().optional(),
-  maximum: z107.number().optional()
+var PropertySchemaSchema = z108.object({
+  type: z108.string(),
+  description: z108.string().optional(),
+  enum: z108.array(z108.unknown()).optional(),
+  pattern: z108.string().optional(),
+  minimum: z108.number().optional(),
+  maximum: z108.number().optional()
 });
-var ToolInputSchemaSchema = z107.object({
-  type: z107.string(),
-  properties: z107.record(z107.string(), PropertySchemaSchema).optional(),
-  required: z107.array(z107.string()).optional(),
-  additionalProperties: z107.boolean().optional()
+var ToolInputSchemaSchema = z108.object({
+  type: z108.string(),
+  properties: z108.record(z108.string(), PropertySchemaSchema).optional(),
+  required: z108.array(z108.string()).optional(),
+  additionalProperties: z108.boolean().optional()
 });
-var ToolDefinitionSchema = z107.object({
-  name: z107.string().min(1),
-  description: z107.string(),
+var ToolDefinitionSchema = z108.object({
+  name: z108.string().min(1),
+  description: z108.string(),
   inputSchema: ToolInputSchemaSchema
 });
-var AnalysisConfigurationSchema = z107.object({
-  includeLowSeverity: z107.boolean().default(true),
-  generateAllConstraints: z107.boolean().default(true),
-  checkInteractions: z107.boolean().default(true),
-  maxHazardsPerTool: z107.number().int().min(1).max(100).default(50),
-  categories: z107.array(HazardCategorySchema).default([])
+var AnalysisConfigurationSchema = z108.object({
+  includeLowSeverity: z108.boolean().default(true),
+  generateAllConstraints: z108.boolean().default(true),
+  checkInteractions: z108.boolean().default(true),
+  maxHazardsPerTool: z108.number().int().min(1).max(100).default(50),
+  categories: z108.array(HazardCategorySchema).default([])
 });
-var ConstraintViolationSchema = z107.object({
-  constraintId: z107.string().min(1),
-  constraintDescription: z107.string(),
+var ConstraintViolationSchema = z108.object({
+  constraintId: z108.string().min(1),
+  constraintDescription: z108.string(),
   severity: HazardSeveritySchema,
-  details: z107.string(),
-  remediation: z107.string()
+  details: z108.string(),
+  remediation: z108.string()
 });
-var ValidationWarningSchema = z107.object({
-  code: z107.string().min(1),
-  message: z107.string(),
-  affected: z107.string()
+var ValidationWarningSchema = z108.object({
+  code: z108.string().min(1),
+  message: z108.string(),
+  affected: z108.string()
 });
-var ValidationResultSchema = z107.object({
-  valid: z107.boolean(),
-  toolName: z107.string().min(1),
-  violations: z107.array(ConstraintViolationSchema),
-  passed: z107.array(z107.string()),
-  warnings: z107.array(ValidationWarningSchema),
-  validatedAt: z107.date()
+var ValidationResultSchema = z108.object({
+  valid: z108.boolean(),
+  toolName: z108.string().min(1),
+  violations: z108.array(ConstraintViolationSchema),
+  passed: z108.array(z108.string()),
+  warnings: z108.array(ValidationWarningSchema),
+  validatedAt: z108.date()
 });
 
 // src/mcp/safety/stpa-types.ts
@@ -48291,43 +48566,43 @@ var GeminiResponseParser = class {
 };
 
 // src/cli-adapters/router-types.ts
-import { z as z108 } from "zod";
-var RouterConfigSchema = z108.object({
-  minCapacityThreshold: z108.number().min(0).max(1).default(0.1),
-  preferCostEfficient: z108.boolean().default(false),
-  maxDecisionTimeMs: z108.number().min(1).max(1e3).default(100)
+import { z as z109 } from "zod";
+var RouterConfigSchema = z109.object({
+  minCapacityThreshold: z109.number().min(0).max(1).default(0.1),
+  preferCostEfficient: z109.boolean().default(false),
+  maxDecisionTimeMs: z109.number().min(1).max(1e3).default(100)
 });
 
 // src/cli-adapters/agreement-cascade-types.ts
-import { z as z109 } from "zod";
-var AgreementCascadeConfigSchema = z109.object({
-  agreementThreshold: z109.number().min(0.5).max(1).default(0.7),
-  maxStages: z109.number().int().min(1).max(5).default(3),
-  modelTimeoutMs: z109.number().int().min(1e3).max(3e5).default(6e4)
+import { z as z110 } from "zod";
+var AgreementCascadeConfigSchema = z110.object({
+  agreementThreshold: z110.number().min(0.5).max(1).default(0.7),
+  maxStages: z110.number().int().min(1).max(5).default(3),
+  modelTimeoutMs: z110.number().int().min(1e3).max(3e5).default(6e4)
 });
 
 // src/cli-adapters/agreement-cascade-router.ts
 var logger48 = createLogger({ component: "agreement-cascade-router" });
 
 // src/cli-adapters/task-classifier.ts
-import { z as z110 } from "zod";
-var ClassificationPatternsSchema = z110.object({
-  code: z110.array(z110.string()).readonly(),
-  research: z110.array(z110.string()).readonly(),
-  documentation: z110.array(z110.string()).readonly(),
-  analysis: z110.array(z110.string()).readonly()
+import { z as z111 } from "zod";
+var ClassificationPatternsSchema = z111.object({
+  code: z111.array(z111.string()).readonly(),
+  research: z111.array(z111.string()).readonly(),
+  documentation: z111.array(z111.string()).readonly(),
+  analysis: z111.array(z111.string()).readonly()
 });
 
 // src/cli-adapters/response-cache-types.ts
-import { z as z111 } from "zod";
-var ResponseCacheConfigSchema = z111.object({
-  defaultTTL: z111.number().min(1e3).max(36e5).default(3e5),
+import { z as z112 } from "zod";
+var ResponseCacheConfigSchema = z112.object({
+  defaultTTL: z112.number().min(1e3).max(36e5).default(3e5),
   // 5 minutes
-  maxEntries: z111.number().min(10).max(1e5).default(1e3),
-  maxMemoryMB: z111.number().min(1).max(1e3).default(50),
-  cleanupInterval: z111.number().min(1e3).max(6e5).default(6e4),
+  maxEntries: z112.number().min(10).max(1e5).default(1e3),
+  maxMemoryMB: z112.number().min(1).max(1e3).default(50),
+  cleanupInterval: z112.number().min(1e3).max(6e5).default(6e4),
   // 1 minute
-  enableLogging: z111.boolean().default(false)
+  enableLogging: z112.boolean().default(false)
 });
 
 // src/cli-adapters/response-cache-utils.ts
@@ -48335,12 +48610,12 @@ import { createHash as createHash4 } from "crypto";
 var logger49 = createLogger({ component: "ResponseCacheUtils" });
 
 // src/cli-adapters/unified-routing-types.ts
-import { z as z112 } from "zod";
-var UnifiedRoutingDecisionSchema = z112.object({
-  selectedCli: z112.string(),
-  confidence: z112.number().min(0).max(1),
-  reason: z112.string(),
-  strategy: z112.enum([
+import { z as z113 } from "zod";
+var UnifiedRoutingDecisionSchema = z113.object({
+  selectedCli: z113.string(),
+  confidence: z113.number().min(0).max(1),
+  reason: z113.string(),
+  strategy: z113.enum([
     "composite",
     "quality",
     "budget",
@@ -48352,57 +48627,57 @@ var UnifiedRoutingDecisionSchema = z112.object({
     "linucb",
     "direct"
   ]),
-  decisionTimeMs: z112.number().nonnegative(),
-  alternatives: z112.array(z112.string()).readonly(),
-  stagesExecuted: z112.array(z112.string()).readonly(),
-  withinBudget: z112.boolean().optional(),
-  estimatedComplexity: z112.enum(["simple", "moderate", "complex", "expert"]).optional(),
-  estimatedTokens: z112.number().int().positive().optional(),
-  topsisScore: z112.number().optional(),
-  ucbScore: z112.number().optional(),
-  resolvedAtStage: z112.number().int().nonnegative().optional(),
-  consensusReached: z112.boolean().optional(),
-  agreementScore: z112.number().min(0).max(1).optional(),
-  metadata: z112.record(z112.string(), z112.unknown()).optional()
+  decisionTimeMs: z113.number().nonnegative(),
+  alternatives: z113.array(z113.string()).readonly(),
+  stagesExecuted: z113.array(z113.string()).readonly(),
+  withinBudget: z113.boolean().optional(),
+  estimatedComplexity: z113.enum(["simple", "moderate", "complex", "expert"]).optional(),
+  estimatedTokens: z113.number().int().positive().optional(),
+  topsisScore: z113.number().optional(),
+  ucbScore: z113.number().optional(),
+  resolvedAtStage: z113.number().int().nonnegative().optional(),
+  consensusReached: z113.boolean().optional(),
+  agreementScore: z113.number().min(0).max(1).optional(),
+  metadata: z113.record(z113.string(), z113.unknown()).optional()
 });
 
 // src/learning/outcome-feedback-types.ts
-import { z as z113 } from "zod";
-var QualitySignalsSchema = z113.object({
-  testsPass: z113.boolean().optional(),
-  lintErrors: z113.number().int().min(0).optional(),
-  userApproved: z113.boolean().optional(),
-  retryCount: z113.number().int().min(0).default(0),
-  completionRatio: z113.number().min(0).max(1).default(1),
-  validStructure: z113.boolean().optional(),
-  coherenceScore: z113.number().min(0).max(1).optional()
+import { z as z114 } from "zod";
+var QualitySignalsSchema = z114.object({
+  testsPass: z114.boolean().optional(),
+  lintErrors: z114.number().int().min(0).optional(),
+  userApproved: z114.boolean().optional(),
+  retryCount: z114.number().int().min(0).default(0),
+  completionRatio: z114.number().min(0).max(1).default(1),
+  validStructure: z114.boolean().optional(),
+  coherenceScore: z114.number().min(0).max(1).optional()
 });
-var RoutingDecisionSchema = z113.object({
-  id: z113.uuid(),
-  timestamp: z113.iso.datetime(),
-  query: z113.string(),
-  routerType: z113.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
-  selectedModel: z113.string(),
-  selectedTier: z113.enum(["strong", "weak"]).optional(),
-  armIndex: z113.number().int().min(0).optional(),
-  banditContext: z113.record(z113.string(), z113.unknown()).optional(),
-  queryFeatures: z113.record(z113.string(), z113.unknown()).optional(),
-  ucbScore: z113.number().optional(),
-  confidence: z113.number().min(0).max(1).optional(),
-  traceId: z113.string(),
-  domain: z113.string().optional()
+var RoutingDecisionSchema = z114.object({
+  id: z114.uuid(),
+  timestamp: z114.iso.datetime(),
+  query: z114.string(),
+  routerType: z114.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
+  selectedModel: z114.string(),
+  selectedTier: z114.enum(["strong", "weak"]).optional(),
+  armIndex: z114.number().int().min(0).optional(),
+  banditContext: z114.record(z114.string(), z114.unknown()).optional(),
+  queryFeatures: z114.record(z114.string(), z114.unknown()).optional(),
+  ucbScore: z114.number().optional(),
+  confidence: z114.number().min(0).max(1).optional(),
+  traceId: z114.string(),
+  domain: z114.string().optional()
 });
-var TaskOutcomeSchema = z113.object({
-  routingDecisionId: z113.uuid(),
-  timestamp: z113.iso.datetime(),
-  outcomeClass: z113.enum(["success", "partial", "failure", "timeout", "error"]),
-  success: z113.boolean(),
-  qualityScore: z113.number().min(0).max(1),
-  durationMs: z113.number().min(0),
-  tokenUsage: z113.number().int().min(0),
-  errorMessage: z113.string().optional(),
+var TaskOutcomeSchema = z114.object({
+  routingDecisionId: z114.uuid(),
+  timestamp: z114.iso.datetime(),
+  outcomeClass: z114.enum(["success", "partial", "failure", "timeout", "error"]),
+  success: z114.boolean(),
+  qualityScore: z114.number().min(0).max(1),
+  durationMs: z114.number().min(0),
+  tokenUsage: z114.number().int().min(0),
+  errorMessage: z114.string().optional(),
   qualitySignals: QualitySignalsSchema,
-  traceId: z113.string()
+  traceId: z114.string()
 });
 var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   maxPendingDecisions: 1e3,
@@ -48417,17 +48692,17 @@ var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   targetTokenUsage: 2e3,
   maxHistorySize: 1e4
 };
-var FeedbackCollectorConfigSchema = z113.object({
-  maxPendingDecisions: z113.number().int().positive().default(1e3),
-  pendingTimeoutMs: z113.number().positive().default(3e5),
-  enableAutoReward: z113.boolean().default(true),
-  qualityWeight: z113.number().min(0).max(1).default(0.5),
-  speedWeight: z113.number().min(0).max(1).default(0.2),
-  efficiencyWeight: z113.number().min(0).max(1).default(0.2),
-  retryPenalty: z113.number().min(0).max(1).default(0.1),
-  targetDurationMs: z113.number().positive().default(5e3),
-  targetTokenUsage: z113.number().positive().default(2e3),
-  maxHistorySize: z113.number().int().positive().default(1e4)
+var FeedbackCollectorConfigSchema = z114.object({
+  maxPendingDecisions: z114.number().int().positive().default(1e3),
+  pendingTimeoutMs: z114.number().positive().default(3e5),
+  enableAutoReward: z114.boolean().default(true),
+  qualityWeight: z114.number().min(0).max(1).default(0.5),
+  speedWeight: z114.number().min(0).max(1).default(0.2),
+  efficiencyWeight: z114.number().min(0).max(1).default(0.2),
+  retryPenalty: z114.number().min(0).max(1).default(0.1),
+  targetDurationMs: z114.number().positive().default(5e3),
+  targetTokenUsage: z114.number().positive().default(2e3),
+  maxHistorySize: z114.number().int().positive().default(1e4)
 });
 
 // src/learning/outcome-feedback-helpers.ts
@@ -50574,4 +50849,4 @@ export {
   shutdownFeedbackSubscriber,
   createEventBusBridge
 };
-//# sourceMappingURL=chunk-ZLQCJRYK.js.map
+//# sourceMappingURL=chunk-EEQVXGZ2.js.map