nexus-agents 2.86.0 → 2.87.1

package/dist/{chunk-RZNED4KY.js → chunk-QDGD5FVT.js}

@@ -42,7 +42,7 @@ import {
   writeJobComplete,
   writeJobFailed,
   writeJobPending
-} from "./chunk-EHBSXLX6.js";
+} from "./chunk-YYUNZPDK.js";
 import {
   REGISTRY_PATH,
   getProjectRoot,
@@ -82,7 +82,7 @@ import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-QOOYL3B3.js";
+} from "./chunk-ISWYUTXP.js";
 import {
   getAvailabilityCache,
   resolveFallback
@@ -23547,10 +23547,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 z110 = getZScore(confidence);
+  const z111 = getZScore(confidence);
   return {
-    lower: difference - z110 * seDiff,
-    upper: difference + z110 * seDiff,
+    lower: difference - z111 * seDiff,
+    upper: difference + z111 * seDiff,
     estimate: difference,
     confidence,
     n: total1 + total2,
@@ -23573,11 +23573,11 @@ function proportionConfidenceInterval(successes, total, options = {}) {
       standardError: 0
     };
   }
-  const z110 = getZScore(opts.confidence);
-  const z210 = z110 * z110;
+  const z111 = getZScore(opts.confidence);
+  const z210 = z111 * z111;
   const denominator = 1 + z210 / n;
   const center = (p + z210 / (2 * n)) / denominator;
-  const margin = z110 / denominator * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
+  const margin = z111 / 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);
@@ -23607,8 +23607,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 z110 = getZScore(opts.confidence);
-  const margin = z110 * standardError;
+  const z111 = getZScore(opts.confidence);
+  const margin = z111 * standardError;
   return {
     lower: mean - margin,
     upper: mean + margin,
@@ -43476,7 +43476,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-K7HSOLYR.js");
+        const { executeVoting } = await import("./consensus-vote-ZP33MR4A.js");
         const votingResult = await executeVoting(
           {
             proposal: plan.slice(0, 4e3),
@@ -46501,12 +46501,180 @@ function registerCancelJobTool(server, deps) {
   logger53.info("Registered cancel_job tool");
 }
 
+// src/mcp/tools/ci-health-check-tool.ts
+import { z as z100 } from "zod";
+var CiHealthStatusSchema = z100.enum(["healthy", "degraded", "outage", "unknown"]);
+var CiHealthCheckInputSchema = z100.object({
+  /**
+   * Repo to check for the recent-runs activity signal (in `owner/repo` form).
+   * Optional — when omitted, only the status-page signal is consulted.
+   */
+  repo: z100.string().regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/, "Must be owner/repo form").optional().describe("GitHub repo (owner/repo) to check for recent CI activity. Optional."),
+  /**
+   * How far back to look for recent-runs activity (minutes). Default 30 —
+   * matches the typical wedge-detection window from the #3070 / #3076 outages.
+   */
+  activityWindowMinutes: z100.number().int().min(5).max(180).default(30).describe("Recent-runs lookback window in minutes (5-180; default 30).")
+});
+var STATUS_PAGE_URL = "https://www.githubstatus.com/api/v2/components.json";
+function mapStatusPageStatus(raw) {
+  if (raw === "operational") return "healthy";
+  if (raw === "degraded_performance" || raw === "under_maintenance") return "degraded";
+  if (raw === "partial_outage" || raw === "major_outage") return "outage";
+  return "unknown";
+}
+async function checkGithubStatus(logger53) {
+  try {
+    const res = await fetch(STATUS_PAGE_URL, {
+      // 5s budget — status page is fast, hangs here are themselves a degraded signal.
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!res.ok) {
+      return {
+        source: "github-status",
+        status: "unknown",
+        evidence: `status page returned HTTP ${String(res.status)}`
+      };
+    }
+    const payload = await res.json();
+    const actions = payload.components?.find((c) => c.name === "GitHub Actions");
+    if (actions?.status === void 0) {
+      return {
+        source: "github-status",
+        status: "unknown",
+        evidence: "GitHub Actions component not found in status page response"
+      };
+    }
+    return {
+      source: "github-status",
+      status: mapStatusPageStatus(actions.status),
+      evidence: `GitHub Actions component reports: ${actions.status}`
+    };
+  } catch (err2) {
+    logger53.warn("Status page fetch failed", {
+      error: err2 instanceof Error ? err2.message : String(err2)
+    });
+    return {
+      source: "github-status",
+      status: "unknown",
+      evidence: `status page fetch failed: ${err2 instanceof Error ? err2.message : "network error"}`
+    };
+  }
+}
+function countRecentRuns(runs, sinceMs) {
+  return runs.filter((r) => r.created_at !== void 0 && Date.parse(r.created_at) >= sinceMs).length;
+}
+async function checkRepoActivity(repo, windowMinutes, logger53) {
+  const sinceMs = Date.now() - windowMinutes * 6e4;
+  try {
+    const res = await fetch(`https://api.github.com/repos/${repo}/actions/runs?per_page=30`, {
+      signal: AbortSignal.timeout(8e3),
+      headers: { Accept: "application/vnd.github+json" }
+    });
+    if (!res.ok) {
+      return {
+        source: "repo-activity-window",
+        status: "unknown",
+        evidence: `actions/runs API returned HTTP ${String(res.status)}`
+      };
+    }
+    const payload = await res.json();
+    const recentCount = countRecentRuns(payload.workflow_runs ?? [], sinceMs);
+    if (recentCount === 0) {
+      return {
+        source: "repo-activity-window",
+        status: "degraded",
+        evidence: `no workflow runs in last ${String(windowMinutes)} min on ${repo} \u2014 could be wedge or quiet repo`
+      };
+    }
+    return {
+      source: "repo-activity-window",
+      status: "healthy",
+      evidence: `${String(recentCount)} workflow run(s) in last ${String(windowMinutes)} min on ${repo}`
+    };
+  } catch (err2) {
+    logger53.warn("Repo activity check failed", {
+      repo,
+      error: err2 instanceof Error ? err2.message : String(err2)
+    });
+    return {
+      source: "repo-activity-window",
+      status: "unknown",
+      evidence: `actions/runs API fetch failed: ${err2 instanceof Error ? err2.message : "network error"}`
+    };
+  }
+}
+function combineSignals(signals) {
+  const PRIORITY = {
+    outage: 3,
+    degraded: 2,
+    healthy: 1,
+    unknown: 0
+  };
+  let worst = "unknown";
+  for (const s of signals) {
+    if (s.status !== "unknown" && PRIORITY[s.status] > PRIORITY[worst]) {
+      worst = s.status;
+    }
+  }
+  return worst;
+}
+async function ciHealthCheckHandler(args, logger53) {
+  const parsed = CiHealthCheckInputSchema.safeParse(args);
+  if (!parsed.success) {
+    return toolStructuredError({
+      errorCategory: "validation",
+      message: `Validation error: ${formatZodError(parsed.error)}`
+    });
+  }
+  const { repo, activityWindowMinutes } = parsed.data;
+  const signals = [];
+  signals.push(await checkGithubStatus(logger53));
+  if (repo !== void 0) {
+    signals.push(await checkRepoActivity(repo, activityWindowMinutes, logger53));
+  }
+  const response = {
+    status: combineSignals(signals),
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    signals
+  };
+  return toolSuccess(JSON.stringify(response, null, 2));
+}
+var DESCRIPTION = "Check CI infrastructure health before triggering / polling runs (#3076). Returns { status: healthy|degraded|outage|unknown, signals } composing GitHub status-page state + the configured repo's recent workflow-runs activity. Use BEFORE a long auto-merge wait to skip the wedge cycle when CI is broken org-wide. Read-only, idempotent, no network state mutated.";
+function registerCiHealthCheckTool(server, deps) {
+  const logger53 = deps.logger ?? createLogger({ tool: "ci_health_check" });
+  const toolSchema = {
+    repo: z100.string().regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/, "Must be owner/repo form").optional().describe("GitHub repo (owner/repo) to check for recent CI activity. Optional."),
+    activityWindowMinutes: z100.number().int().min(5).max(180).optional().describe("Recent-runs lookback window in minutes (5-180; default 30).")
+  };
+  const secureHandler = createSecureHandler((args) => ciHealthCheckHandler(args, logger53), {
+    toolName: "ci_health_check",
+    rateLimiter: deps.rateLimiter,
+    logger: logger53
+  });
+  const timeoutMs = getToolTimeout("ci_health_check", deps.security);
+  const wrappedHandler = wrapToolWithTimeout("ci_health_check", secureHandler, {
+    timeoutMs,
+    logger: logger53
+  });
+  server.registerTool(
+    "ci_health_check",
+    {
+      description: DESCRIPTION,
+      inputSchema: toolSchema,
+      annotations: getToolAnnotations("ci_health_check")
+    },
+    toSdkCallback(wrappedHandler)
+  );
+  logger53.info("Registered ci_health_check tool");
+}
+
 // src/mcp/tools/verify-audit-chain-tool.ts
 import * as fs12 from "fs/promises";
 import * as path11 from "path";
-import { z as z100 } from "zod";
-var VerifyAuditChainInputSchema = z100.object({
-  logDir: z100.string().min(1).max(512).describe(
+import { z as z101 } from "zod";
+var VerifyAuditChainInputSchema = z101.object({
+  logDir: z101.string().min(1).max(512).describe(
     "Filesystem path to the FileAuditStorage log directory. Tool reads all `audit-*.jsonl` files in lexicographic order and verifies the combined chain."
   )
 });
@@ -46583,7 +46751,7 @@ async function handler2(args, ctx) {
 function registerVerifyAuditChainTool(server, deps) {
   const logger53 = deps.logger ?? createLogger({ tool: "verify_audit_chain" });
   const toolSchema = {
-    logDir: z100.string().min(1).max(512).describe(
+    logDir: z101.string().min(1).max(512).describe(
       "Filesystem path to the FileAuditStorage log directory. Tool reads all `audit-*.jsonl` files and verifies the combined hash chain."
     )
   };
@@ -46607,18 +46775,18 @@ function registerVerifyAuditChainTool(server, deps) {
 }
 
 // src/mcp/tools/pipeline-tool.ts
-import { z as z101 } from "zod";
+import { z as z102 } from "zod";
 import * as fs13 from "fs";
 import * as path12 from "path";
-var PipelineInputSchema = z101.object({
+var PipelineInputSchema = z102.object({
   /** The task to execute. */
-  task: z101.string().min(5).max(1e4).describe("Task description \u2014 pipeline template auto-selected based on content"),
+  task: z102.string().min(5).max(1e4).describe("Task description \u2014 pipeline template auto-selected based on content"),
   /** Path to a spec file (.md, .yaml) to use as task input. */
-  specFile: z101.string().max(500).optional().describe("Path to a spec file \u2014 content prepended to task for greenfield projects"),
+  specFile: z102.string().max(500).optional().describe("Path to a spec file \u2014 content prepended to task for greenfield projects"),
   /** Override template — see `listTemplateIds()` for the canonical list (#2728). Auto-detected if omitted. */
-  template: z101.string().max(50).optional().describe(`Pipeline template override. Available: ${listTemplateIds().join(", ")}`),
+  template: z102.string().max(50).optional().describe(`Pipeline template override. Available: ${listTemplateIds().join(", ")}`),
   /** Voting strategy for consensus stages. */
-  votingStrategy: z101.enum([
+  votingStrategy: z102.enum([
     "simple_majority",
     "supermajority",
     "unanimous",
@@ -46629,13 +46797,13 @@ var PipelineInputSchema = z101.object({
     "Voting strategy for plan approval. simple_majority (default), supermajority (67%), unanimous, higher_order (Bayesian), proof_of_learning, opinion_wise"
   ),
   /** Use 3 agents instead of 6 for faster voting. */
-  quickMode: z101.boolean().default(false).describe("Use 3 agents instead of 6 for faster consensus voting"),
+  quickMode: z102.boolean().default(false).describe("Use 3 agents instead of 6 for faster consensus voting"),
   /** Maximum execution time per stage in milliseconds (min 30s, max 600s). */
-  timeoutMs: z101.number().int().min(3e4).max(6e5).optional().describe("Max time per stage in ms (30000-600000). Default: varies by stage complexity"),
+  timeoutMs: z102.number().int().min(3e4).max(6e5).optional().describe("Max time per stage in ms (30000-600000). Default: varies by stage complexity"),
   /** Stop after planning/voting (no implementation). */
-  dryRun: z101.boolean().default(false).describe("Stop after vote stage (no implementation)"),
+  dryRun: z102.boolean().default(false).describe("Stop after vote stage (no implementation)"),
   /** TESTS ONLY — random output, must not be used for real decisions. (#2319) */
-  simulateVotes: z101.boolean().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
+  simulateVotes: z102.boolean().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
 });
 function buildOutput2(result) {
   return {
@@ -46737,7 +46905,7 @@ function registerPipelineTool(server, deps) {
 }
 
 // src/mcp/tools/supply-chain-tradeoff-panel.ts
-import { z as z102 } from "zod";
+import { z as z103 } from "zod";
 var DEFAULT_AXES = [
   "build_time_determinism",
   "supply_chain_risk",
@@ -46757,16 +46925,16 @@ var FULL_PANEL = [
   "scope_steward"
 ];
 var QUICK_PANEL = ["architect", "security", "scope_steward"];
-var SupplyChainTradeoffPanelInputSchema = z102.object({
-  proposal: z102.string().min(1).max(MAX_PROPOSAL_LENGTH).describe('The proposal under tradeoff review (e.g. "Should aegis-boot adopt cargo-nextest?")'),
-  axes: z102.array(z102.string().min(1).max(MAX_AXIS_NAME_LENGTH)).min(1).max(MAX_AXES).optional().describe(
+var SupplyChainTradeoffPanelInputSchema = z103.object({
+  proposal: z103.string().min(1).max(MAX_PROPOSAL_LENGTH).describe('The proposal under tradeoff review (e.g. "Should aegis-boot adopt cargo-nextest?")'),
+  axes: z103.array(z103.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: z102.string().max(MAX_CONTEXT_LENGTH).optional().describe(
+  context: z103.string().max(MAX_CONTEXT_LENGTH).optional().describe(
     "Optional context: relevant repo state, dependency tree, vendor publishing patterns, etc."
   ),
-  quickMode: z102.boolean().optional().default(false).describe("Use 3 voters (architect, security, scope_steward) instead of 7"),
-  simulate: z102.boolean().optional().default(false).describe("Use simulated voters (testing only)")
+  quickMode: z103.boolean().optional().default(false).describe("Use 3 voters (architect, security, scope_steward) instead of 7"),
+  simulate: z103.boolean().optional().default(false).describe("Use simulated voters (testing only)")
 });
 function buildTradeoffProposal(input) {
   const axes = input.axes ?? DEFAULT_AXES;
@@ -47466,6 +47634,22 @@ var TOOL_ANNOTATIONS = {
       }
     ]
   },
+  ci_health_check: {
+    annotations: {
+      title: "CI Health Check",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      // Outbound network to githubstatus.com + GitHub API.
+      openWorldHint: true
+    },
+    sideEffects: [
+      {
+        category: "implicit",
+        description: "Fetches GitHub status-page + repo actions/runs to assess CI infrastructure health (#3076)"
+      }
+    ]
+  },
   extract_symbols: {
     annotations: {
       title: "Extract Symbols",
@@ -47670,6 +47854,7 @@ var REGISTERED_TOOL_NAMES = [
   "get_job_result",
   "list_jobs",
   "cancel_job",
+  "ci_health_check",
   "verify_audit_chain",
   "repo_analyze",
   "repo_security_plan",
@@ -47814,40 +47999,40 @@ var RiskLevel = /* @__PURE__ */ ((RiskLevel2) => {
 })(RiskLevel || {});
 
 // src/mcp/safety/stpa-schemas.ts
-import { z as z103 } from "zod";
-var HazardCategorySchema = z103.enum(HazardCategory);
-var HazardSeveritySchema = z103.enum(HazardSeverity);
-var ConstraintPrioritySchema = z103.enum(ConstraintPriority);
-var RiskLevelSchema = z103.enum(RiskLevel);
-var TriggerPatternSchema = z103.object({
-  parameter: z103.string().min(1),
-  matchType: z103.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
-  pattern: z103.string(),
-  reason: z103.string()
+import { z as z104 } from "zod";
+var HazardCategorySchema = z104.enum(HazardCategory);
+var HazardSeveritySchema = z104.enum(HazardSeverity);
+var ConstraintPrioritySchema = z104.enum(ConstraintPriority);
+var RiskLevelSchema = z104.enum(RiskLevel);
+var TriggerPatternSchema = z104.object({
+  parameter: z104.string().min(1),
+  matchType: z104.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
+  pattern: z104.string(),
+  reason: z104.string()
 });
-var HazardSchema = z103.object({
-  id: z103.string().min(1),
-  description: z103.string(),
+var HazardSchema = z104.object({
+  id: z104.string().min(1),
+  description: z104.string(),
   category: HazardCategorySchema,
   severity: HazardSeveritySchema,
-  likelihood: z103.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
-  triggerConditions: z103.array(z103.string()),
-  consequences: z103.array(z103.string())
+  likelihood: z104.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
+  triggerConditions: z104.array(z104.string()),
+  consequences: z104.array(z104.string())
 });
-var UnsafeControlActionSchema = z103.object({
-  id: z103.string().min(1),
-  toolName: z103.string().min(1),
-  type: z103.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
-  description: z103.string(),
-  unsafeContext: z103.string(),
-  relatedHazards: z103.array(z103.string()),
-  triggerPatterns: z103.array(TriggerPatternSchema).optional()
+var UnsafeControlActionSchema = z104.object({
+  id: z104.string().min(1),
+  toolName: z104.string().min(1),
+  type: z104.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
+  description: z104.string(),
+  unsafeContext: z104.string(),
+  relatedHazards: z104.array(z104.string()),
+  triggerPatterns: z104.array(TriggerPatternSchema).optional()
 });
-var SafetyConstraintSchema = z103.object({
-  id: z103.string().min(1),
-  description: z103.string(),
-  mitigates: z103.array(z103.string()),
-  enforcement: z103.enum([
+var SafetyConstraintSchema = z104.object({
+  id: z104.string().min(1),
+  description: z104.string(),
+  mitigates: z104.array(z104.string()),
+  enforcement: z104.enum([
     "prevent",
     "require_confirmation",
     "alert",
@@ -47855,54 +48040,54 @@ var SafetyConstraintSchema = z103.object({
     "rate_limit",
     "require_privilege"
   ]),
-  validationFunction: z103.string().optional(),
+  validationFunction: z104.string().optional(),
   priority: ConstraintPrioritySchema
 });
-var PropertySchemaSchema = z103.object({
-  type: z103.string(),
-  description: z103.string().optional(),
-  enum: z103.array(z103.unknown()).optional(),
-  pattern: z103.string().optional(),
-  minimum: z103.number().optional(),
-  maximum: z103.number().optional()
+var PropertySchemaSchema = z104.object({
+  type: z104.string(),
+  description: z104.string().optional(),
+  enum: z104.array(z104.unknown()).optional(),
+  pattern: z104.string().optional(),
+  minimum: z104.number().optional(),
+  maximum: z104.number().optional()
 });
-var ToolInputSchemaSchema = z103.object({
-  type: z103.string(),
-  properties: z103.record(z103.string(), PropertySchemaSchema).optional(),
-  required: z103.array(z103.string()).optional(),
-  additionalProperties: z103.boolean().optional()
+var ToolInputSchemaSchema = z104.object({
+  type: z104.string(),
+  properties: z104.record(z104.string(), PropertySchemaSchema).optional(),
+  required: z104.array(z104.string()).optional(),
+  additionalProperties: z104.boolean().optional()
 });
-var ToolDefinitionSchema = z103.object({
-  name: z103.string().min(1),
-  description: z103.string(),
+var ToolDefinitionSchema = z104.object({
+  name: z104.string().min(1),
+  description: z104.string(),
   inputSchema: ToolInputSchemaSchema
 });
-var AnalysisConfigurationSchema = z103.object({
-  includeLowSeverity: z103.boolean().default(true),
-  generateAllConstraints: z103.boolean().default(true),
-  checkInteractions: z103.boolean().default(true),
-  maxHazardsPerTool: z103.number().int().min(1).max(100).default(50),
-  categories: z103.array(HazardCategorySchema).default([])
+var AnalysisConfigurationSchema = z104.object({
+  includeLowSeverity: z104.boolean().default(true),
+  generateAllConstraints: z104.boolean().default(true),
+  checkInteractions: z104.boolean().default(true),
+  maxHazardsPerTool: z104.number().int().min(1).max(100).default(50),
+  categories: z104.array(HazardCategorySchema).default([])
 });
-var ConstraintViolationSchema = z103.object({
-  constraintId: z103.string().min(1),
-  constraintDescription: z103.string(),
+var ConstraintViolationSchema = z104.object({
+  constraintId: z104.string().min(1),
+  constraintDescription: z104.string(),
   severity: HazardSeveritySchema,
-  details: z103.string(),
-  remediation: z103.string()
+  details: z104.string(),
+  remediation: z104.string()
 });
-var ValidationWarningSchema = z103.object({
-  code: z103.string().min(1),
-  message: z103.string(),
-  affected: z103.string()
+var ValidationWarningSchema = z104.object({
+  code: z104.string().min(1),
+  message: z104.string(),
+  affected: z104.string()
 });
-var ValidationResultSchema = z103.object({
-  valid: z103.boolean(),
-  toolName: z103.string().min(1),
-  violations: z103.array(ConstraintViolationSchema),
-  passed: z103.array(z103.string()),
-  warnings: z103.array(ValidationWarningSchema),
-  validatedAt: z103.date()
+var ValidationResultSchema = z104.object({
+  valid: z104.boolean(),
+  toolName: z104.string().min(1),
+  violations: z104.array(ConstraintViolationSchema),
+  passed: z104.array(z104.string()),
+  warnings: z104.array(ValidationWarningSchema),
+  validatedAt: z104.date()
 });
 
 // src/mcp/safety/stpa-types.ts
@@ -48987,43 +49172,43 @@ var GeminiResponseParser = class {
 };
 
 // src/cli-adapters/router-types.ts
-import { z as z104 } from "zod";
-var RouterConfigSchema = z104.object({
-  minCapacityThreshold: z104.number().min(0).max(1).default(0.1),
-  preferCostEfficient: z104.boolean().default(false),
-  maxDecisionTimeMs: z104.number().min(1).max(1e3).default(100)
+import { z as z105 } from "zod";
+var RouterConfigSchema = z105.object({
+  minCapacityThreshold: z105.number().min(0).max(1).default(0.1),
+  preferCostEfficient: z105.boolean().default(false),
+  maxDecisionTimeMs: z105.number().min(1).max(1e3).default(100)
 });
 
 // src/cli-adapters/agreement-cascade-types.ts
-import { z as z105 } from "zod";
-var AgreementCascadeConfigSchema = z105.object({
-  agreementThreshold: z105.number().min(0.5).max(1).default(0.7),
-  maxStages: z105.number().int().min(1).max(5).default(3),
-  modelTimeoutMs: z105.number().int().min(1e3).max(3e5).default(6e4)
+import { z as z106 } from "zod";
+var AgreementCascadeConfigSchema = z106.object({
+  agreementThreshold: z106.number().min(0.5).max(1).default(0.7),
+  maxStages: z106.number().int().min(1).max(5).default(3),
+  modelTimeoutMs: z106.number().int().min(1e3).max(3e5).default(6e4)
 });
 
 // src/cli-adapters/agreement-cascade-router.ts
 var logger43 = createLogger({ component: "agreement-cascade-router" });
 
 // src/cli-adapters/task-classifier.ts
-import { z as z106 } from "zod";
-var ClassificationPatternsSchema = z106.object({
-  code: z106.array(z106.string()).readonly(),
-  research: z106.array(z106.string()).readonly(),
-  documentation: z106.array(z106.string()).readonly(),
-  analysis: z106.array(z106.string()).readonly()
+import { z as z107 } from "zod";
+var ClassificationPatternsSchema = z107.object({
+  code: z107.array(z107.string()).readonly(),
+  research: z107.array(z107.string()).readonly(),
+  documentation: z107.array(z107.string()).readonly(),
+  analysis: z107.array(z107.string()).readonly()
 });
 
 // src/cli-adapters/response-cache-types.ts
-import { z as z107 } from "zod";
-var ResponseCacheConfigSchema = z107.object({
-  defaultTTL: z107.number().min(1e3).max(36e5).default(3e5),
+import { z as z108 } from "zod";
+var ResponseCacheConfigSchema = z108.object({
+  defaultTTL: z108.number().min(1e3).max(36e5).default(3e5),
   // 5 minutes
-  maxEntries: z107.number().min(10).max(1e5).default(1e3),
-  maxMemoryMB: z107.number().min(1).max(1e3).default(50),
-  cleanupInterval: z107.number().min(1e3).max(6e5).default(6e4),
+  maxEntries: z108.number().min(10).max(1e5).default(1e3),
+  maxMemoryMB: z108.number().min(1).max(1e3).default(50),
+  cleanupInterval: z108.number().min(1e3).max(6e5).default(6e4),
   // 1 minute
-  enableLogging: z107.boolean().default(false)
+  enableLogging: z108.boolean().default(false)
 });
 
 // src/cli-adapters/response-cache-utils.ts
@@ -49031,12 +49216,12 @@ import { createHash as createHash4 } from "crypto";
 var logger44 = createLogger({ component: "ResponseCacheUtils" });
 
 // src/cli-adapters/unified-routing-types.ts
-import { z as z108 } from "zod";
-var UnifiedRoutingDecisionSchema = z108.object({
-  selectedCli: z108.string(),
-  confidence: z108.number().min(0).max(1),
-  reason: z108.string(),
-  strategy: z108.enum([
+import { z as z109 } from "zod";
+var UnifiedRoutingDecisionSchema = z109.object({
+  selectedCli: z109.string(),
+  confidence: z109.number().min(0).max(1),
+  reason: z109.string(),
+  strategy: z109.enum([
     "composite",
     "quality",
     "budget",
@@ -49048,57 +49233,57 @@ var UnifiedRoutingDecisionSchema = z108.object({
     "linucb",
     "direct"
   ]),
-  decisionTimeMs: z108.number().nonnegative(),
-  alternatives: z108.array(z108.string()).readonly(),
-  stagesExecuted: z108.array(z108.string()).readonly(),
-  withinBudget: z108.boolean().optional(),
-  estimatedComplexity: z108.enum(["simple", "moderate", "complex", "expert"]).optional(),
-  estimatedTokens: z108.number().int().positive().optional(),
-  topsisScore: z108.number().optional(),
-  ucbScore: z108.number().optional(),
-  resolvedAtStage: z108.number().int().nonnegative().optional(),
-  consensusReached: z108.boolean().optional(),
-  agreementScore: z108.number().min(0).max(1).optional(),
-  metadata: z108.record(z108.string(), z108.unknown()).optional()
+  decisionTimeMs: z109.number().nonnegative(),
+  alternatives: z109.array(z109.string()).readonly(),
+  stagesExecuted: z109.array(z109.string()).readonly(),
+  withinBudget: z109.boolean().optional(),
+  estimatedComplexity: z109.enum(["simple", "moderate", "complex", "expert"]).optional(),
+  estimatedTokens: z109.number().int().positive().optional(),
+  topsisScore: z109.number().optional(),
+  ucbScore: z109.number().optional(),
+  resolvedAtStage: z109.number().int().nonnegative().optional(),
+  consensusReached: z109.boolean().optional(),
+  agreementScore: z109.number().min(0).max(1).optional(),
+  metadata: z109.record(z109.string(), z109.unknown()).optional()
 });
 
 // src/learning/outcome-feedback-types.ts
-import { z as z109 } from "zod";
-var QualitySignalsSchema = z109.object({
-  testsPass: z109.boolean().optional(),
-  lintErrors: z109.number().int().min(0).optional(),
-  userApproved: z109.boolean().optional(),
-  retryCount: z109.number().int().min(0).default(0),
-  completionRatio: z109.number().min(0).max(1).default(1),
-  validStructure: z109.boolean().optional(),
-  coherenceScore: z109.number().min(0).max(1).optional()
+import { z as z110 } from "zod";
+var QualitySignalsSchema = z110.object({
+  testsPass: z110.boolean().optional(),
+  lintErrors: z110.number().int().min(0).optional(),
+  userApproved: z110.boolean().optional(),
+  retryCount: z110.number().int().min(0).default(0),
+  completionRatio: z110.number().min(0).max(1).default(1),
+  validStructure: z110.boolean().optional(),
+  coherenceScore: z110.number().min(0).max(1).optional()
 });
-var RoutingDecisionSchema = z109.object({
-  id: z109.uuid(),
-  timestamp: z109.iso.datetime(),
-  query: z109.string(),
-  routerType: z109.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
-  selectedModel: z109.string(),
-  selectedTier: z109.enum(["strong", "weak"]).optional(),
-  armIndex: z109.number().int().min(0).optional(),
-  banditContext: z109.record(z109.string(), z109.unknown()).optional(),
-  queryFeatures: z109.record(z109.string(), z109.unknown()).optional(),
-  ucbScore: z109.number().optional(),
-  confidence: z109.number().min(0).max(1).optional(),
-  traceId: z109.string(),
-  domain: z109.string().optional()
+var RoutingDecisionSchema = z110.object({
+  id: z110.uuid(),
+  timestamp: z110.iso.datetime(),
+  query: z110.string(),
+  routerType: z110.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
+  selectedModel: z110.string(),
+  selectedTier: z110.enum(["strong", "weak"]).optional(),
+  armIndex: z110.number().int().min(0).optional(),
+  banditContext: z110.record(z110.string(), z110.unknown()).optional(),
+  queryFeatures: z110.record(z110.string(), z110.unknown()).optional(),
+  ucbScore: z110.number().optional(),
+  confidence: z110.number().min(0).max(1).optional(),
+  traceId: z110.string(),
+  domain: z110.string().optional()
 });
-var TaskOutcomeSchema = z109.object({
-  routingDecisionId: z109.uuid(),
-  timestamp: z109.iso.datetime(),
-  outcomeClass: z109.enum(["success", "partial", "failure", "timeout", "error"]),
-  success: z109.boolean(),
-  qualityScore: z109.number().min(0).max(1),
-  durationMs: z109.number().min(0),
-  tokenUsage: z109.number().int().min(0),
-  errorMessage: z109.string().optional(),
+var TaskOutcomeSchema = z110.object({
+  routingDecisionId: z110.uuid(),
+  timestamp: z110.iso.datetime(),
+  outcomeClass: z110.enum(["success", "partial", "failure", "timeout", "error"]),
+  success: z110.boolean(),
+  qualityScore: z110.number().min(0).max(1),
+  durationMs: z110.number().min(0),
+  tokenUsage: z110.number().int().min(0),
+  errorMessage: z110.string().optional(),
   qualitySignals: QualitySignalsSchema,
-  traceId: z109.string()
+  traceId: z110.string()
 });
 var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   maxPendingDecisions: 1e3,
@@ -49113,17 +49298,17 @@ var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   targetTokenUsage: 2e3,
   maxHistorySize: 1e4
 };
-var FeedbackCollectorConfigSchema = z109.object({
-  maxPendingDecisions: z109.number().int().positive().default(1e3),
-  pendingTimeoutMs: z109.number().positive().default(3e5),
-  enableAutoReward: z109.boolean().default(true),
-  qualityWeight: z109.number().min(0).max(1).default(0.5),
-  speedWeight: z109.number().min(0).max(1).default(0.2),
-  efficiencyWeight: z109.number().min(0).max(1).default(0.2),
-  retryPenalty: z109.number().min(0).max(1).default(0.1),
-  targetDurationMs: z109.number().positive().default(5e3),
-  targetTokenUsage: z109.number().positive().default(2e3),
-  maxHistorySize: z109.number().int().positive().default(1e4)
+var FeedbackCollectorConfigSchema = z110.object({
+  maxPendingDecisions: z110.number().int().positive().default(1e3),
+  pendingTimeoutMs: z110.number().positive().default(3e5),
+  enableAutoReward: z110.boolean().default(true),
+  qualityWeight: z110.number().min(0).max(1).default(0.5),
+  speedWeight: z110.number().min(0).max(1).default(0.2),
+  efficiencyWeight: z110.number().min(0).max(1).default(0.2),
+  retryPenalty: z110.number().min(0).max(1).default(0.1),
+  targetDurationMs: z110.number().positive().default(5e3),
+  targetTokenUsage: z110.number().positive().default(2e3),
+  maxHistorySize: z110.number().int().positive().default(1e4)
 });
 
 // src/learning/outcome-feedback-helpers.ts
@@ -51370,6 +51555,7 @@ export {
   registerGetJobResultTool,
   registerListJobsTool,
   registerCancelJobTool,
+  registerCiHealthCheckTool,
   AuditError,
   AuditCategorySchema,
   AuditSeveritySchema,
@@ -51453,4 +51639,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-RZNED4KY.js.map
+//# sourceMappingURL=chunk-QDGD5FVT.js.map