nexus-agents 2.98.0 → 2.100.0

package/dist/{chunk-DE3J2HYT.js → chunk-B364VMMP.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-UWQ3BALH.js";
 import {
   executeExpert
-} from "./chunk-6IHEDRKI.js";
+} from "./chunk-H4LBBFCO.js";
 import {
   EventTopics,
   JobStatusSchema,
@@ -30,7 +30,7 @@ import {
   writeJobComplete,
   writeJobFailed,
   writeJobPending
-} from "./chunk-RCKLAJ2H.js";
+} from "./chunk-TYELRYRO.js";
 import {
   REGISTRY_PATH,
   getProjectRoot,
@@ -51,7 +51,7 @@ import {
 } from "./chunk-VD4TXDMR.js";
 import {
   withPrerequisite
-} from "./chunk-MKFLI5DK.js";
+} from "./chunk-YREYQSYA.js";
 import {
   NOOP_NOTIFIER,
   RateLimiter,
@@ -70,7 +70,7 @@ import {
   withAccessPolicy,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-G4A7SSML.js";
+} from "./chunk-JFFI54DW.js";
 import {
   generateSecurityPlan
 } from "./chunk-BKUKBOGV.js";
@@ -92,7 +92,7 @@ import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-6ZXNMJEX.js";
+} from "./chunk-BFN7RO3R.js";
 import {
   getAvailabilityCache,
   getCliForModelId,
@@ -116,7 +116,7 @@ import {
   getAvailableClis,
   sleep,
   withTimeout
-} from "./chunk-EM7NUGMG.js";
+} from "./chunk-P453545L.js";
 import {
   generateHyphenId,
   generateUUID
@@ -23559,10 +23559,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 z111 = getZScore(confidence);
+  const z112 = getZScore(confidence);
   return {
-    lower: difference - z111 * seDiff,
-    upper: difference + z111 * seDiff,
+    lower: difference - z112 * seDiff,
+    upper: difference + z112 * seDiff,
     estimate: difference,
     confidence,
     n: total1 + total2,
@@ -23585,11 +23585,11 @@ function proportionConfidenceInterval(successes, total, options = {}) {
       standardError: 0
     };
   }
-  const z111 = getZScore(opts.confidence);
-  const z210 = z111 * z111;
+  const z112 = getZScore(opts.confidence);
+  const z210 = z112 * z112;
   const denominator = 1 + z210 / n;
   const center = (p + z210 / (2 * n)) / denominator;
-  const margin = z111 / denominator * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
+  const margin = z112 / 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);
@@ -23619,8 +23619,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 z111 = getZScore(opts.confidence);
-  const margin = z111 * standardError;
+  const z112 = getZScore(opts.confidence);
+  const margin = z112 * standardError;
   return {
     lower: mean - margin,
     upper: mean + margin,
@@ -42436,7 +42436,7 @@ var VALID_TEMPLATES = /* @__PURE__ */ new Set([
 ]);
 async function classifyWithLLM(task) {
   try {
-    const { executeExpert: executeExpert2 } = await import("./expert-bridge-EOVHUCJ4.js");
+    const { executeExpert: executeExpert2 } = await import("./expert-bridge-L25WFHQF.js");
     const prompt = [
       "Classify this task into exactly one pipeline template.",
       "Templates: dev (implementation/bug fix/refactor), research (investigate/evaluate/compare),",
@@ -43181,6 +43181,77 @@ function buildScanSummary(total, confirmed, falsePositives, osvCount) {
   return parts.join(", ");
 }
 
+// src/security/quality-gate.ts
+async function runCommandCheck(name, command, args) {
+  const start = Date.now();
+  try {
+    const { execFile: execFile3 } = await import("child_process");
+    const { promisify: promisify3 } = await import("util");
+    const exec2 = promisify3(execFile3);
+    await exec2(command, [...args], { timeout: 12e4 });
+    return {
+      name,
+      verdict: "pass",
+      details: `${name} completed successfully`,
+      durationMs: Date.now() - start
+    };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return {
+      name,
+      verdict: "fail",
+      details: msg.slice(0, 500),
+      durationMs: Date.now() - start
+    };
+  }
+}
+function checkTypeCheck(projectDir) {
+  return () => runCommandCheck("type_check", "npx", ["tsc", "--noEmit", "--project", projectDir]);
+}
+function checkLint(projectDir) {
+  return () => runCommandCheck("lint", "npx", ["eslint", "--max-warnings", "0", projectDir]);
+}
+function checkTests(projectDir) {
+  return () => runCommandCheck("tests", "npx", ["vitest", "run", "--dir", projectDir]);
+}
+function checkBuild() {
+  return () => runCommandCheck("build", "pnpm", ["build"]);
+}
+function aggregateResults2(checks) {
+  let pass = 0;
+  let fail = 0;
+  let skip = 0;
+  for (const c of checks) {
+    if (c.verdict === "pass") pass++;
+    else if (c.verdict === "fail") fail++;
+    else skip++;
+  }
+  return { verdict: fail > 0 ? "fail" : "pass", summary: { pass, fail, skip } };
+}
+function generateFeedback2(checks) {
+  const failures = checks.filter((c) => c.verdict === "fail");
+  if (failures.length === 0) return "All checks passed.";
+  const lines = failures.map((f) => `- ${f.name}: ${f.details}`);
+  return `${String(failures.length)} check(s) failed:
+${lines.join("\n")}`;
+}
+async function runQualityGate(stage, checks, iteration = 1) {
+  const results = [];
+  for (const check of checks) {
+    const result = await check();
+    results.push(result);
+  }
+  const { verdict, summary } = aggregateResults2(results);
+  return {
+    stage,
+    verdict,
+    checks: results,
+    summary,
+    feedback: generateFeedback2(results),
+    iteration
+  };
+}
+
 // src/pipeline/agent-executor.ts
 var logger38 = createLogger({ component: "agent-executor" });
 function emitStageEvent2(stage, status, details) {
@@ -43433,7 +43504,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-Z3BWJLRE.js");
+        const { executeVoting } = await import("./consensus-vote-PGOS5AA6.js");
         const votingResult = await executeVoting(
           {
             proposal: plan.slice(0, 4e3),
@@ -43566,6 +43637,33 @@ Verdict: PASS/NEEDS_WORK/REJECT`
       await postProgress(config, `QA [${task.id}]`, review.verdict);
       return review;
     },
+    qualityGate: async () => {
+      emitStageEvent2("quality-gate", "started");
+      const start = getTimeProvider().now();
+      const target = config.scanTarget ?? process.cwd();
+      await postProgress(config, "QualityGate", `Typecheck/lint/tests on ${target}...`);
+      const result = await runQualityGate("qa", [
+        checkTypeCheck(target),
+        checkLint(target),
+        checkTests(target)
+      ]);
+      const passed = result.verdict !== "fail";
+      const ms = getTimeProvider().now() - start;
+      emitStageEvent2("quality-gate", passed ? "completed" : "failed", { durationMs: ms });
+      recordOutcome({
+        taskId: "quality-gate",
+        category: "code_review",
+        cli: void 0,
+        success: passed,
+        durationMs: ms
+      });
+      await postProgress(
+        config,
+        "QualityGate",
+        passed ? "Passed" : `Gate failed: ${result.feedback}`
+      );
+      return { passed, feedback: result.feedback };
+    },
     securityScan: async () => {
       emitStageEvent2("security", "started");
       const start = getTimeProvider().now();
@@ -43864,7 +43962,13 @@ async function runDevPipelineInner(task, stages, options, sid, prior) {
     logger41.info("Harness mode \u2014 returning tasks for external implementation");
     return buildHarnessResult(planResult, tasks);
   }
-  const result = await runImplSecurityPhase(planResult, tasks, stages, sid);
+  const result = await runImplSecurityPhase(
+    planResult,
+    tasks,
+    stages,
+    sid,
+    options?.qualityGate ?? "off"
+  );
   applyPipelineHindsight(bm, task, sid, result);
   return result;
 }
@@ -43980,10 +44084,21 @@ function buildHarnessResult(planResult, tasks) {
     securityPassed: false
   };
 }
-async function runImplSecurityPhase(planResult, tasks, stages, sid) {
+async function runImplSecurityPhase(planResult, tasks, stages, sid, qualityGateMode) {
   const implResult = await implementQaLoop(tasks, stages);
   if (sid !== void 0)
     saveStageCheckpoint(sid, "implement", { type: "implement", tasks: implResult.completedTasks });
+  const qaGate = await runQualityGateStage(stages, qualityGateMode);
+  if (qualityGateMode === "blocking" && !qaGate.passed) {
+    return {
+      completed: false,
+      plan: planResult.plan,
+      tasks: implResult.completedTasks.length > 0 ? implResult.completedTasks : tasks,
+      voteIterations: planResult.iterations,
+      qaIterations: implResult.totalIterations,
+      securityPassed: false
+    };
+  }
   const security = await withStep(
     { name: "security-scan", kind: "pipeline.stage" },
     async (ctx) => {
@@ -44005,6 +44120,26 @@ async function runImplSecurityPhase(planResult, tasks, stages, sid) {
     securityPassed: security.passed
   };
 }
+async function runQualityGateStage(stages, mode) {
+  if (mode === "off" || stages.qualityGate === void 0) {
+    return { passed: true, feedback: "Quality gate skipped" };
+  }
+  const runGate = stages.qualityGate.bind(stages);
+  return withStep(
+    { name: "quality-gate", kind: "pipeline.stage", attrs: { mode } },
+    async (ctx) => {
+      const r = await runGate();
+      const advisory = mode === "advisory" && !r.passed;
+      ctx.setSummary(r.passed ? "passed" : advisory ? "FAILED (advisory)" : "FAILED");
+      if (advisory) {
+        logger41.warn("Quality gate failed (advisory \u2014 not blocking)", {
+          feedback: r.feedback.slice(0, 200)
+        });
+      }
+      return r;
+    }
+  );
+}
 async function runOrResume(prior, stage, run) {
   if (prior?.research !== void 0 && stage === "research") {
     logger41.info("Resuming from checkpoint", { stage });
@@ -45905,12 +46040,131 @@ function registerCiHealthCheckTool(server, deps) {
   logger55.info("Registered ci_health_check tool");
 }
 
+// src/mcp/tools/quality-gate-tool.ts
+import { statSync as statSync3 } from "fs";
+import { z as z101 } from "zod";
+var QualityCheckSchema = z101.enum(["typecheck", "lint", "tests", "build", "security"]);
+var DEFAULT_CHECKS = ["typecheck", "lint", "tests"];
+var RunQualityGateInputSchema = z101.object({
+  /** Project directory to run checks against. Must resolve inside the repo/cwd root. */
+  projectDir: z101.string().optional().describe(
+    "Project directory to run checks against (default: cwd). Must stay inside the repo root."
+  ),
+  /** Which allowlisted checks to run. */
+  checks: z101.array(QualityCheckSchema).nonempty().default([...DEFAULT_CHECKS]).describe("Allowlisted checks to run (default: ['typecheck','lint','tests'])."),
+  /** 1-based iteration counter, forwarded to the engine for feedback context. */
+  iteration: z101.number().int().min(1).default(1).describe("1-based iteration number (default 1).")
+});
+function validateProjectDir(raw) {
+  const candidate = raw ?? process.cwd();
+  const safe = resolveInsideRoot(candidate);
+  if (safe === null) {
+    return {
+      error: toolStructuredError({
+        errorCategory: "permission",
+        message: `Invalid projectDir: "${candidate}" resolves outside the repository root (path traversal rejected).`
+      })
+    };
+  }
+  let stat5;
+  try {
+    stat5 = statSync3(safe);
+  } catch {
+    return {
+      error: toolStructuredError({
+        errorCategory: "validation",
+        message: `Invalid projectDir: "${candidate}" does not exist.`
+      })
+    };
+  }
+  if (!stat5.isDirectory()) {
+    return {
+      error: toolStructuredError({
+        errorCategory: "validation",
+        message: `Invalid projectDir: "${candidate}" is not a directory.`
+      })
+    };
+  }
+  return { dir: safe };
+}
+function buildCheck(name, projectDir) {
+  switch (name) {
+    case "typecheck":
+      return checkTypeCheck(projectDir);
+    case "lint":
+      return checkLint(projectDir);
+    case "tests":
+      return checkTests(projectDir);
+    case "build":
+      return checkBuild();
+    case "security":
+      return checkSecurityScan(projectDir);
+  }
+}
+async function runQualityGateHandler(args, logger55) {
+  const parsed = RunQualityGateInputSchema.safeParse(args);
+  if (!parsed.success) {
+    return toolStructuredError({
+      errorCategory: "validation",
+      message: `Validation error: ${formatZodError(parsed.error)}`
+    });
+  }
+  const { projectDir, checks, iteration } = parsed.data;
+  const validated = validateProjectDir(projectDir);
+  if ("error" in validated) return validated.error;
+  const checkFns = checks.map((name) => buildCheck(name, validated.dir));
+  logger55.info("Running quality gate", { checks, iteration });
+  try {
+    const result = await runQualityGate("qa", checkFns, iteration);
+    return toolSuccess(JSON.stringify(result, null, 2));
+  } catch (err2) {
+    return toolStructuredError({
+      errorCategory: "internal",
+      message: `Quality gate execution failed: ${err2 instanceof Error ? err2.message : String(err2)}`
+    });
+  }
+}
+var DESCRIPTION2 = "Run the QA quality gate (#1684 engine) against a project directory. Allowlisted checks: typecheck | lint | tests | build | security (default ['typecheck','lint','tests']). Returns the structured { stage, verdict, checks[], summary, feedback } verdict. projectDir must stay inside the repository root; per-check output is capped at 500 chars.";
+function registerRunQualityGateTool(server, deps) {
+  const logger55 = deps.logger ?? createLogger({ tool: "run_quality_gate" });
+  const toolSchema = {
+    projectDir: z101.string().optional().describe(
+      "Project directory to run checks against (default: cwd). Must stay inside the repo root."
+    ),
+    checks: z101.array(QualityCheckSchema).nonempty().optional().describe("Allowlisted checks to run (default: ['typecheck','lint','tests'])."),
+    iteration: z101.number().int().min(1).optional().describe("1-based iteration number (default 1).")
+  };
+  const secureHandler = createSecureHandler(
+    (args) => runQualityGateHandler(args, logger55),
+    {
+      toolName: "run_quality_gate",
+      rateLimiter: deps.rateLimiter,
+      logger: logger55
+    }
+  );
+  const timeoutMs = getToolTimeout("run_quality_gate", deps.security);
+  const wrappedHandler = wrapToolWithTimeout("run_quality_gate", secureHandler, {
+    timeoutMs,
+    logger: logger55
+  });
+  server.registerTool(
+    "run_quality_gate",
+    {
+      description: DESCRIPTION2,
+      inputSchema: toolSchema,
+      annotations: getToolAnnotations("run_quality_gate")
+    },
+    toSdkCallback(wrappedHandler)
+  );
+  logger55.info("Registered run_quality_gate tool");
+}
+
 // src/mcp/tools/verify-audit-chain-tool.ts
 import * as fs12 from "fs/promises";
 import * as path11 from "path";
-import { z as z101 } from "zod";
-var VerifyAuditChainInputSchema = z101.object({
-  logDir: z101.string().min(1).max(512).describe(
+import { z as z102 } from "zod";
+var VerifyAuditChainInputSchema = z102.object({
+  logDir: z102.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."
   )
 });
@@ -45987,7 +46241,7 @@ async function handler2(args, ctx) {
 function registerVerifyAuditChainTool(server, deps) {
   const logger55 = deps.logger ?? createLogger({ tool: "verify_audit_chain" });
   const toolSchema = {
-    logDir: z101.string().min(1).max(512).describe(
+    logDir: z102.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."
     )
   };
@@ -46011,18 +46265,18 @@ function registerVerifyAuditChainTool(server, deps) {
 }
 
 // src/mcp/tools/pipeline-tool.ts
-import { z as z102 } from "zod";
+import { z as z103 } from "zod";
 import * as fs13 from "fs";
 import * as path12 from "path";
-var PipelineInputSchema = z102.object({
+var PipelineInputSchema = z103.object({
   /** The task to execute. */
-  task: z102.string().min(5).max(1e4).describe("Task description \u2014 pipeline template auto-selected based on content"),
+  task: z103.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: z102.string().max(500).optional().describe("Path to a spec file \u2014 content prepended to task for greenfield projects"),
+  specFile: z103.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: z102.string().max(50).optional().describe(`Pipeline template override. Available: ${listTemplateIds().join(", ")}`),
+  template: z103.string().max(50).optional().describe(`Pipeline template override. Available: ${listTemplateIds().join(", ")}`),
   /** Voting strategy for consensus stages. */
-  votingStrategy: z102.enum([
+  votingStrategy: z103.enum([
     "simple_majority",
     "supermajority",
     "unanimous",
@@ -46033,13 +46287,13 @@ var PipelineInputSchema = z102.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: z102.boolean().default(false).describe("Use 3 agents instead of 6 for faster consensus voting"),
+  quickMode: z103.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: z102.number().int().min(3e4).max(6e5).optional().describe("Max time per stage in ms (30000-600000). Default: varies by stage complexity"),
+  timeoutMs: z103.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: z102.boolean().default(false).describe("Stop after vote stage (no implementation)"),
+  dryRun: z103.boolean().default(false).describe("Stop after vote stage (no implementation)"),
   /** TESTS ONLY — 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)")
+  simulateVotes: z103.boolean().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
 });
 function buildOutput2(result) {
   return {
@@ -46141,7 +46395,7 @@ function registerPipelineTool(server, deps) {
 }
 
 // src/mcp/tools/supply-chain-tradeoff-panel.ts
-import { z as z103 } from "zod";
+import { z as z104 } from "zod";
 var DEFAULT_AXES = [
   "build_time_determinism",
   "supply_chain_risk",
@@ -46161,16 +46415,16 @@ var FULL_PANEL = [
   "scope_steward"
 ];
 var QUICK_PANEL = ["architect", "security", "scope_steward"];
-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(
+var SupplyChainTradeoffPanelInputSchema = z104.object({
+  proposal: z104.string().min(1).max(MAX_PROPOSAL_LENGTH).describe('The proposal under tradeoff review (e.g. "Should aegis-boot adopt cargo-nextest?")'),
+  axes: z104.array(z104.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: z103.string().max(MAX_CONTEXT_LENGTH).optional().describe(
+  context: z104.string().max(MAX_CONTEXT_LENGTH).optional().describe(
     "Optional context: relevant repo state, dependency tree, vendor publishing patterns, etc."
   ),
-  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)")
+  quickMode: z104.boolean().optional().default(false).describe("Use 3 voters (architect, security, scope_steward) instead of 7"),
+  simulate: z104.boolean().optional().default(false).describe("Use simulated voters (testing only)")
 });
 function buildTradeoffProposal(input) {
   const axes = input.axes ?? DEFAULT_AXES;
@@ -46676,6 +46930,28 @@ var TOOL_ANNOTATIONS = {
       { category: "implicit", description: "Consumes rate limit quota" }
     ]
   },
+  run_quality_gate: {
+    annotations: {
+      title: "Run Quality Gate",
+      // Spawns build/test toolchains which can write artifacts — not read-only.
+      readOnlyHint: false,
+      destructiveHint: false,
+      // Same checks against the same code yield the same verdict.
+      idempotentHint: true,
+      // build/test/security invoke local toolchains and may reach the network.
+      openWorldHint: true
+    },
+    sideEffects: [
+      {
+        category: "implicit",
+        description: "Spawns local toolchain processes (tsc/eslint/vitest/build) in the target project dir"
+      },
+      {
+        category: "implicit",
+        description: "build/test checks may write build artifacts and coverage output to disk"
+      }
+    ]
+  },
   issue_triage: {
     annotations: {
       title: "Issue Triage",
@@ -47100,7 +47376,8 @@ var REGISTERED_TOOL_NAMES = [
   "run_pipeline",
   "pr_review",
   "supply_chain_tradeoff_panel",
-  "improvement_review"
+  "improvement_review",
+  "run_quality_gate"
 ];
 function registerTools(server, options) {
   const logger55 = options?.logger ?? createMcpLogger({ component: "tools" });
@@ -47235,40 +47512,40 @@ var RiskLevel = /* @__PURE__ */ ((RiskLevel2) => {
 })(RiskLevel || {});
 
 // src/mcp/safety/stpa-schemas.ts
-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()
+import { z as z105 } from "zod";
+var HazardCategorySchema = z105.enum(HazardCategory);
+var HazardSeveritySchema = z105.enum(HazardSeverity);
+var ConstraintPrioritySchema = z105.enum(ConstraintPriority);
+var RiskLevelSchema = z105.enum(RiskLevel);
+var TriggerPatternSchema = z105.object({
+  parameter: z105.string().min(1),
+  matchType: z105.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
+  pattern: z105.string(),
+  reason: z105.string()
 });
-var HazardSchema = z104.object({
-  id: z104.string().min(1),
-  description: z104.string(),
+var HazardSchema = z105.object({
+  id: z105.string().min(1),
+  description: z105.string(),
   category: HazardCategorySchema,
   severity: HazardSeveritySchema,
-  likelihood: z104.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
-  triggerConditions: z104.array(z104.string()),
-  consequences: z104.array(z104.string())
+  likelihood: z105.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
+  triggerConditions: z105.array(z105.string()),
+  consequences: z105.array(z105.string())
 });
-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 UnsafeControlActionSchema = z105.object({
+  id: z105.string().min(1),
+  toolName: z105.string().min(1),
+  type: z105.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
+  description: z105.string(),
+  unsafeContext: z105.string(),
+  relatedHazards: z105.array(z105.string()),
+  triggerPatterns: z105.array(TriggerPatternSchema).optional()
 });
-var SafetyConstraintSchema = z104.object({
-  id: z104.string().min(1),
-  description: z104.string(),
-  mitigates: z104.array(z104.string()),
-  enforcement: z104.enum([
+var SafetyConstraintSchema = z105.object({
+  id: z105.string().min(1),
+  description: z105.string(),
+  mitigates: z105.array(z105.string()),
+  enforcement: z105.enum([
     "prevent",
     "require_confirmation",
     "alert",
@@ -47276,54 +47553,54 @@ var SafetyConstraintSchema = z104.object({
     "rate_limit",
     "require_privilege"
   ]),
-  validationFunction: z104.string().optional(),
+  validationFunction: z105.string().optional(),
   priority: ConstraintPrioritySchema
 });
-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 PropertySchemaSchema = z105.object({
+  type: z105.string(),
+  description: z105.string().optional(),
+  enum: z105.array(z105.unknown()).optional(),
+  pattern: z105.string().optional(),
+  minimum: z105.number().optional(),
+  maximum: z105.number().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 ToolInputSchemaSchema = z105.object({
+  type: z105.string(),
+  properties: z105.record(z105.string(), PropertySchemaSchema).optional(),
+  required: z105.array(z105.string()).optional(),
+  additionalProperties: z105.boolean().optional()
 });
-var ToolDefinitionSchema = z104.object({
-  name: z104.string().min(1),
-  description: z104.string(),
+var ToolDefinitionSchema = z105.object({
+  name: z105.string().min(1),
+  description: z105.string(),
   inputSchema: ToolInputSchemaSchema
 });
-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 AnalysisConfigurationSchema = z105.object({
+  includeLowSeverity: z105.boolean().default(true),
+  generateAllConstraints: z105.boolean().default(true),
+  checkInteractions: z105.boolean().default(true),
+  maxHazardsPerTool: z105.number().int().min(1).max(100).default(50),
+  categories: z105.array(HazardCategorySchema).default([])
 });
-var ConstraintViolationSchema = z104.object({
-  constraintId: z104.string().min(1),
-  constraintDescription: z104.string(),
+var ConstraintViolationSchema = z105.object({
+  constraintId: z105.string().min(1),
+  constraintDescription: z105.string(),
   severity: HazardSeveritySchema,
-  details: z104.string(),
-  remediation: z104.string()
+  details: z105.string(),
+  remediation: z105.string()
 });
-var ValidationWarningSchema = z104.object({
-  code: z104.string().min(1),
-  message: z104.string(),
-  affected: z104.string()
+var ValidationWarningSchema = z105.object({
+  code: z105.string().min(1),
+  message: z105.string(),
+  affected: z105.string()
 });
-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()
+var ValidationResultSchema = z105.object({
+  valid: z105.boolean(),
+  toolName: z105.string().min(1),
+  violations: z105.array(ConstraintViolationSchema),
+  passed: z105.array(z105.string()),
+  warnings: z105.array(ValidationWarningSchema),
+  validatedAt: z105.date()
 });
 
 // src/mcp/safety/stpa-types.ts
@@ -48408,43 +48685,43 @@ var GeminiResponseParser = class {
 };
 
 // src/cli-adapters/router-types.ts
-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)
+import { z as z106 } from "zod";
+var RouterConfigSchema = z106.object({
+  minCapacityThreshold: z106.number().min(0).max(1).default(0.1),
+  preferCostEfficient: z106.boolean().default(false),
+  maxDecisionTimeMs: z106.number().min(1).max(1e3).default(100)
 });
 
 // src/cli-adapters/agreement-cascade-types.ts
-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)
+import { z as z107 } from "zod";
+var AgreementCascadeConfigSchema = z107.object({
+  agreementThreshold: z107.number().min(0.5).max(1).default(0.7),
+  maxStages: z107.number().int().min(1).max(5).default(3),
+  modelTimeoutMs: z107.number().int().min(1e3).max(3e5).default(6e4)
 });
 
 // src/cli-adapters/agreement-cascade-router.ts
 var logger45 = createLogger({ component: "agreement-cascade-router" });
 
 // src/cli-adapters/task-classifier.ts
-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()
+import { z as z108 } from "zod";
+var ClassificationPatternsSchema = z108.object({
+  code: z108.array(z108.string()).readonly(),
+  research: z108.array(z108.string()).readonly(),
+  documentation: z108.array(z108.string()).readonly(),
+  analysis: z108.array(z108.string()).readonly()
 });
 
 // src/cli-adapters/response-cache-types.ts
-import { z as z108 } from "zod";
-var ResponseCacheConfigSchema = z108.object({
-  defaultTTL: z108.number().min(1e3).max(36e5).default(3e5),
+import { z as z109 } from "zod";
+var ResponseCacheConfigSchema = z109.object({
+  defaultTTL: z109.number().min(1e3).max(36e5).default(3e5),
   // 5 minutes
-  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),
+  maxEntries: z109.number().min(10).max(1e5).default(1e3),
+  maxMemoryMB: z109.number().min(1).max(1e3).default(50),
+  cleanupInterval: z109.number().min(1e3).max(6e5).default(6e4),
   // 1 minute
-  enableLogging: z108.boolean().default(false)
+  enableLogging: z109.boolean().default(false)
 });
 
 // src/cli-adapters/response-cache-utils.ts
@@ -48452,12 +48729,12 @@ import { createHash as createHash4 } from "crypto";
 var logger46 = createLogger({ component: "ResponseCacheUtils" });
 
 // src/cli-adapters/unified-routing-types.ts
-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([
+import { z as z110 } from "zod";
+var UnifiedRoutingDecisionSchema = z110.object({
+  selectedCli: z110.string(),
+  confidence: z110.number().min(0).max(1),
+  reason: z110.string(),
+  strategy: z110.enum([
     "composite",
     "quality",
     "budget",
@@ -48469,57 +48746,57 @@ var UnifiedRoutingDecisionSchema = z109.object({
     "linucb",
     "direct"
   ]),
-  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()
+  decisionTimeMs: z110.number().nonnegative(),
+  alternatives: z110.array(z110.string()).readonly(),
+  stagesExecuted: z110.array(z110.string()).readonly(),
+  withinBudget: z110.boolean().optional(),
+  estimatedComplexity: z110.enum(["simple", "moderate", "complex", "expert"]).optional(),
+  estimatedTokens: z110.number().int().positive().optional(),
+  topsisScore: z110.number().optional(),
+  ucbScore: z110.number().optional(),
+  resolvedAtStage: z110.number().int().nonnegative().optional(),
+  consensusReached: z110.boolean().optional(),
+  agreementScore: z110.number().min(0).max(1).optional(),
+  metadata: z110.record(z110.string(), z110.unknown()).optional()
 });
 
 // src/learning/outcome-feedback-types.ts
-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()
+import { z as z111 } from "zod";
+var QualitySignalsSchema = z111.object({
+  testsPass: z111.boolean().optional(),
+  lintErrors: z111.number().int().min(0).optional(),
+  userApproved: z111.boolean().optional(),
+  retryCount: z111.number().int().min(0).default(0),
+  completionRatio: z111.number().min(0).max(1).default(1),
+  validStructure: z111.boolean().optional(),
+  coherenceScore: z111.number().min(0).max(1).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 RoutingDecisionSchema = z111.object({
+  id: z111.uuid(),
+  timestamp: z111.iso.datetime(),
+  query: z111.string(),
+  routerType: z111.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
+  selectedModel: z111.string(),
+  selectedTier: z111.enum(["strong", "weak"]).optional(),
+  armIndex: z111.number().int().min(0).optional(),
+  banditContext: z111.record(z111.string(), z111.unknown()).optional(),
+  queryFeatures: z111.record(z111.string(), z111.unknown()).optional(),
+  ucbScore: z111.number().optional(),
+  confidence: z111.number().min(0).max(1).optional(),
+  traceId: z111.string(),
+  domain: z111.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(),
+var TaskOutcomeSchema = z111.object({
+  routingDecisionId: z111.uuid(),
+  timestamp: z111.iso.datetime(),
+  outcomeClass: z111.enum(["success", "partial", "failure", "timeout", "error"]),
+  success: z111.boolean(),
+  qualityScore: z111.number().min(0).max(1),
+  durationMs: z111.number().min(0),
+  tokenUsage: z111.number().int().min(0),
+  errorMessage: z111.string().optional(),
   qualitySignals: QualitySignalsSchema,
-  traceId: z110.string()
+  traceId: z111.string()
 });
 var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   maxPendingDecisions: 1e3,
@@ -48534,17 +48811,17 @@ var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   targetTokenUsage: 2e3,
   maxHistorySize: 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)
+var FeedbackCollectorConfigSchema = z111.object({
+  maxPendingDecisions: z111.number().int().positive().default(1e3),
+  pendingTimeoutMs: z111.number().positive().default(3e5),
+  enableAutoReward: z111.boolean().default(true),
+  qualityWeight: z111.number().min(0).max(1).default(0.5),
+  speedWeight: z111.number().min(0).max(1).default(0.2),
+  efficiencyWeight: z111.number().min(0).max(1).default(0.2),
+  retryPenalty: z111.number().min(0).max(1).default(0.1),
+  targetDurationMs: z111.number().positive().default(5e3),
+  targetTokenUsage: z111.number().positive().default(2e3),
+  maxHistorySize: z111.number().int().positive().default(1e4)
 });
 
 // src/learning/outcome-feedback-helpers.ts
@@ -50781,6 +51058,7 @@ export {
   registerListJobsTool,
   registerCancelJobTool,
   registerCiHealthCheckTool,
+  registerRunQualityGateTool,
   AuditError,
   AuditCategorySchema,
   AuditSeveritySchema,
@@ -50864,4 +51142,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-DE3J2HYT.js.map
+//# sourceMappingURL=chunk-B364VMMP.js.map