nexus-agents 2.77.13 → 2.78.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   createGitHubProvider,
   createScmProvider
-} from "./chunk-DSQ5XM4O.js";
+} from "./chunk-FVPYP5DD.js";
 import {
   ALLOWED_COMMANDS,
   ARTIFACT_TYPES,
@@ -518,7 +518,8 @@ import {
   validateWorkflow,
   validateWorkflowDependencies,
   withLogging
-} from "./chunk-GFKGL2GQ.js";
+} from "./chunk-6WBTNZAY.js";
+import "./chunk-AP2FD37C.js";
 import {
   SharedMemoryStore
 } from "./chunk-ED6VQWNG.js";
@@ -526,17 +527,21 @@ import {
   getTokenEnvVars,
   hasToken,
   resolveToken
-} from "./chunk-MGLWPN2I.js";
+} from "./chunk-GONMG4NM.js";
 import "./chunk-X2M7OF27.js";
 import {
   OPENAI_MODELS,
   OPENAI_MODEL_ALIASES,
   OpenAIAdapter,
   createOpenAIAdapter
-} from "./chunk-DIB6V67T.js";
+} from "./chunk-L6SCKLGO.js";
+import {
+  CliCircuitBreakerIntegration,
+  createCliCircuitBreakerIntegration
+} from "./chunk-2YPG6PDG.js";
 import {
   executeExpert
-} from "./chunk-3DH5SLFH.js";
+} from "./chunk-K2QILJG4.js";
 import {
   AgentFindingSchema,
   AgentPerformanceSchema,
@@ -632,7 +637,10 @@ import {
   validateToolInput,
   withModelNotFoundFallback,
   wrapResilientWithFallback
-} from "./chunk-Y2CP4Z5B.js";
+} from "./chunk-SWFJU3W2.js";
+import {
+  PROVIDER_ENV_KEYS
+} from "./chunk-ZVCED4Z4.js";
 import {
   AdapterModelError,
   BaseAdapter,
@@ -656,11 +664,8 @@ import {
   transformStream,
   validateApiKeyPresence,
   withTimeout
-} from "./chunk-IPWCD22D.js";
-import {
-  PROVIDER_ENV_KEYS
-} from "./chunk-7NK7BTWP.js";
-import "./chunk-JN6UWGHH.js";
+} from "./chunk-PLX6FCFC.js";
+import "./chunk-5O6XLBPP.js";
 import {
   AgentActionSchema,
   GitHubReviewer,
@@ -693,11 +698,11 @@ import {
   sanitizeInput,
   validateAgentAction,
   validateCorroboration
-} from "./chunk-ERWXGXV2.js";
+} from "./chunk-6TFTVW77.js";
 import {
   GitHubProvider,
   ScmError
-} from "./chunk-G6ZPVADX.js";
+} from "./chunk-SD76JZBG.js";
 import {
   FALLBACK_SCANNER_DATA,
   buildPlanFromAnalysis,
@@ -705,14 +710,20 @@ import {
   generateSecurityPlan,
   getRegistryManifest,
   resolveScannerData
-} from "./chunk-G2CSKBY5.js";
+} from "./chunk-FJWWSVWB.js";
 import {
   analyzeGitHubRepo,
   analyzeRepo,
   normalizeRepoId
 } from "./chunk-7J7PNOJQ.js";
-import "./chunk-AP2FD37C.js";
 import "./chunk-BQ4YXGGQ.js";
+import {
+  PersistentStrategyDistiller,
+  RulesSnapshotSchema
+} from "./chunk-DNO2INX5.js";
+import {
+  MemoryError
+} from "./chunk-Q5CFPIJ5.js";
 import {
   AppConfigSchema,
   AvailabilityCache,
@@ -738,16 +749,17 @@ import {
   resolveFallback,
   startStdioServer,
   validateNexusEnv
-} from "./chunk-JX6OI4FS.js";
+} from "./chunk-4N33QZLH.js";
 import {
   AvailableModelsCache,
   getDefaultAvailableModelsCache,
   setDefaultAvailableModelsCache
-} from "./chunk-5WHWKY32.js";
+} from "./chunk-KT5FIBWS.js";
 import {
   DEFAULTS
-} from "./chunk-YQMQSJQK.js";
+} from "./chunk-HYU4GZY6.js";
 import "./chunk-NUBSJGQZ.js";
+import "./chunk-633WH2ML.js";
 import {
   BaseCliAdapter,
   CLI_TIMEOUT_PROFILES,
@@ -776,7 +788,8 @@ import {
   isCliAvailable,
   isRetryableError,
   sleep
-} from "./chunk-TDV5ALHY.js";
+} from "./chunk-D6TM2VHX.js";
+import "./chunk-DLXT23AC.js";
 import {
   BUILT_IN_EXPERTS,
   BuiltInExpertTypeSchema,
@@ -786,16 +799,8 @@ import {
   safeValidateExpertConfig,
   validateExpertConfig
 } from "./chunk-ZM4O442V.js";
-import "./chunk-3VWMM6UF.js";
-import {
-  MemoryError
-} from "./chunk-BJ2OMC7P.js";
-import "./chunk-633WH2ML.js";
-import {
-  CliCircuitBreakerIntegration,
-  createCliCircuitBreakerIntegration
-} from "./chunk-6AY5DK4E.js";
-import "./chunk-PWTJGGKB.js";
+import "./chunk-PQHVC4BD.js";
+import "./chunk-3NIPH6UP.js";
 import {
   AgentCapability,
   AgentError,
@@ -866,19 +871,14 @@ import {
   map,
   mapErr,
   ok,
-  registerPersistentDistillerFactory,
   sanitize,
   setDefaultRegistry,
   sigmoidConfidence,
   toError,
   unwrap,
   unwrapOr
-} from "./chunk-3MRM53T4.js";
-import {
-  ensureLearningDir,
-  getRulesFile
-} from "./chunk-I7ORMAO7.js";
-import "./chunk-GOT7OAL5.js";
+} from "./chunk-WDYCIJWN.js";
+import "./chunk-7BMOZJYS.js";
 import "./chunk-UP2VWCW5.js";
 
 // src/adapters/factory.ts
@@ -2822,114 +2822,6 @@ function createOutcomeStorage(config) {
   return new SQLiteOutcomeStorage(config);
 }
 
-// src/learning/strategy-distiller-persistence.ts
-import { writeFileSync, readFileSync as readFileSync2, renameSync, unlinkSync, existsSync as existsSync2 } from "fs";
-import { dirname } from "path";
-import { z as z4 } from "zod";
-var DistilledRuleSchema = z4.object({
-  id: z4.string(),
-  patternType: z4.enum(["failure-rate", "success-rate", "latency-spike"]),
-  cli: z4.enum(CLI_NAMES),
-  category: z4.string(),
-  action: z4.enum(["penalize", "boost", "avoid"]),
-  confidence: z4.number(),
-  observationCount: z4.number(),
-  metric: z4.number(),
-  status: z4.enum(["draft", "active", "promoted", "expired"]),
-  createdAt: z4.number(),
-  updatedAt: z4.number(),
-  tainted: z4.boolean()
-});
-var RulesSnapshotSchema = z4.object({
-  version: z4.literal(1),
-  savedAt: z4.string(),
-  rules: z4.array(DistilledRuleSchema)
-});
-var PersistentStrategyDistiller = class extends StrategyDistiller {
-  filePath;
-  persistLogger;
-  constructor(outcomeStore, persistConfig, logger15, distillerConfig) {
-    super(outcomeStore, logger15, distillerConfig);
-    this.filePath = persistConfig?.filePath ?? getRulesFile();
-    this.persistLogger = logger15 ?? createLogger({ component: "PersistentStrategyDistiller" });
-    const dataDir = persistConfig?.dataDir;
-    ensureLearningDir(dataDir);
-    this.hydrate();
-  }
-  /** Override distill to persist rules after each run. */
-  distill() {
-    super.distill();
-    this.saveSnapshot();
-  }
-  // ==========================================================================
-  // Private
-  // ==========================================================================
-  hydrate() {
-    if (!existsSync2(this.filePath)) {
-      this.persistLogger.debug("No rules file found, starting fresh", {
-        path: this.filePath
-      });
-      return;
-    }
-    try {
-      const content = readFileSync2(this.filePath, "utf-8");
-      const parsed = JSON.parse(content);
-      const result = RulesSnapshotSchema.safeParse(parsed);
-      if (!result.success) {
-        this.persistLogger.warn("Rules file failed validation, starting fresh", {
-          path: this.filePath,
-          error: result.error.message
-        });
-        return;
-      }
-      this.loadRules(result.data.rules);
-      this.persistLogger.info("Hydrated distilled rules from disk", {
-        ruleCount: result.data.rules.length,
-        savedAt: result.data.savedAt,
-        path: this.filePath
-      });
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : String(error);
-      this.persistLogger.warn("Failed to hydrate rules from disk", {
-        error: msg,
-        path: this.filePath
-      });
-    }
-  }
-  saveSnapshot() {
-    const rules = this.getRules();
-    const snapshot = {
-      version: 1,
-      savedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      rules
-    };
-    const tmpPath = this.filePath + ".tmp";
-    try {
-      ensureLearningDir(dirname(this.filePath));
-      writeFileSync(tmpPath, JSON.stringify(snapshot, null, 2), "utf-8");
-      renameSync(tmpPath, this.filePath);
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : String(error);
-      this.persistLogger.warn("Failed to persist rules to disk", {
-        error: msg,
-        path: this.filePath
-      });
-      try {
-        if (existsSync2(tmpPath)) unlinkSync(tmpPath);
-      } catch (cleanupErr) {
-        const msg2 = cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr);
-        this.persistLogger.debug("Failed to clean up temp file during persist", {
-          path: tmpPath,
-          error: msg2
-        });
-      }
-    }
-  }
-};
-registerPersistentDistillerFactory(
-  (outcomeStore, logger15) => new PersistentStrategyDistiller(outcomeStore, void 0, logger15)
-);
-
 // src/learning/ab-test-tracker.ts
 var AbTestTracker = class {
   experiments = /* @__PURE__ */ new Map();
@@ -3272,9 +3164,9 @@ var ExpectedOutcome = {
 };
 
 // src/security/safety-bench/safety-schemas.ts
-import { z as z5 } from "zod";
-var RiskLevelSchema = z5.enum(["low", "medium", "high", "critical"]);
-var SafetyCategoryIdSchema = z5.enum([
+import { z as z4 } from "zod";
+var RiskLevelSchema = z4.enum(["low", "medium", "high", "critical"]);
+var SafetyCategoryIdSchema = z4.enum([
   "harm_physical",
   "harm_emotional",
   "harm_financial",
@@ -3286,8 +3178,8 @@ var SafetyCategoryIdSchema = z5.enum([
   "robustness",
   "risk_awareness"
 ]);
-var CriterionTypeSchema = z5.enum(["binary", "scaled", "threshold", "categorical"]);
-var ExpectedOutcomeSchema = z5.enum([
+var CriterionTypeSchema = z4.enum(["binary", "scaled", "threshold", "categorical"]);
+var ExpectedOutcomeSchema = z4.enum([
   "refuse",
   "caution",
   "clarify",
@@ -3295,35 +3187,35 @@ var ExpectedOutcomeSchema = z5.enum([
   "proceed",
   "detect"
 ]);
-var EvaluationCriterionSchema = z5.object({
-  id: z5.string().min(1).describe("Unique criterion identifier"),
-  name: z5.string().min(1).describe("Human-readable criterion name"),
-  description: z5.string().describe("Detailed description of what the criterion measures"),
+var EvaluationCriterionSchema = z4.object({
+  id: z4.string().min(1).describe("Unique criterion identifier"),
+  name: z4.string().min(1).describe("Human-readable criterion name"),
+  description: z4.string().describe("Detailed description of what the criterion measures"),
   type: CriterionTypeSchema.describe("Type of evaluation"),
-  weight: z5.number().min(0).max(1).describe("Weight factor for scoring"),
-  passThreshold: z5.number().optional().describe("Threshold value for pass"),
-  categories: z5.array(z5.string()).readonly().optional().describe("Categories for categorical type")
+  weight: z4.number().min(0).max(1).describe("Weight factor for scoring"),
+  passThreshold: z4.number().optional().describe("Threshold value for pass"),
+  categories: z4.array(z4.string()).readonly().optional().describe("Categories for categorical type")
 });
-var SafetyTestCaseSchema = z5.object({
-  id: z5.string().min(1).describe("Unique test case identifier"),
-  name: z5.string().min(1).describe("Test case name"),
-  description: z5.string().describe("Detailed description of the test scenario"),
-  input: z5.string().describe("Input prompt or scenario for the agent"),
+var SafetyTestCaseSchema = z4.object({
+  id: z4.string().min(1).describe("Unique test case identifier"),
+  name: z4.string().min(1).describe("Test case name"),
+  description: z4.string().describe("Detailed description of the test scenario"),
+  input: z4.string().describe("Input prompt or scenario for the agent"),
   expectedOutcome: ExpectedOutcomeSchema.describe("Expected safe behavior outcome"),
   riskLevel: RiskLevelSchema.describe("Risk level of the scenario"),
-  tags: z5.array(z5.string()).readonly().describe("Tags for filtering and grouping"),
-  context: z5.string().optional().describe("Additional context or environment setup")
+  tags: z4.array(z4.string()).readonly().describe("Tags for filtering and grouping"),
+  context: z4.string().optional().describe("Additional context or environment setup")
 });
-var SafetyCategorySchema = z5.object({
+var SafetyCategorySchema = z4.object({
   id: SafetyCategoryIdSchema.describe("Unique category identifier"),
-  name: z5.string().min(1).describe("Human-readable category name"),
-  description: z5.string().describe("Detailed description of the category"),
+  name: z4.string().min(1).describe("Human-readable category name"),
+  description: z4.string().describe("Detailed description of the category"),
   defaultRiskLevel: RiskLevelSchema.describe("Default risk level for violations"),
   parentId: SafetyCategoryIdSchema.optional().describe("Parent category ID"),
-  criteria: z5.array(EvaluationCriterionSchema).readonly().describe("Evaluation criteria"),
-  exampleTestCases: z5.array(SafetyTestCaseSchema).readonly().describe("Example test cases"),
-  failureModes: z5.array(z5.string()).readonly().describe("Common failure modes"),
-  mitigationStrategies: z5.array(z5.string()).readonly().describe("Mitigation strategies")
+  criteria: z4.array(EvaluationCriterionSchema).readonly().describe("Evaluation criteria"),
+  exampleTestCases: z4.array(SafetyTestCaseSchema).readonly().describe("Example test cases"),
+  failureModes: z4.array(z4.string()).readonly().describe("Common failure modes"),
+  mitigationStrategies: z4.array(z4.string()).readonly().describe("Mitigation strategies")
 });
 
 // src/security/safety-bench/safety-category-definitions.ts
@@ -4131,16 +4023,16 @@ function getSafetyTaxonomySummary() {
 }
 
 // src/security/firewall/firewall-types.ts
-import { z as z7 } from "zod";
-var FirewallStagesSchema = z7.object({
-  sanitization: z7.boolean().default(true),
-  trustClassification: z7.boolean().default(true),
-  reputationAssessment: z7.boolean().default(false),
-  policyEnforcement: z7.boolean().default(true),
-  corroboration: z7.boolean().default(false),
-  audit: z7.boolean().default(true)
+import { z as z6 } from "zod";
+var FirewallStagesSchema = z6.object({
+  sanitization: z6.boolean().default(true),
+  trustClassification: z6.boolean().default(true),
+  reputationAssessment: z6.boolean().default(false),
+  policyEnforcement: z6.boolean().default(true),
+  corroboration: z6.boolean().default(false),
+  audit: z6.boolean().default(true)
 });
-var FirewallConfigSchema = z7.object({
+var FirewallConfigSchema = z6.object({
   stages: FirewallStagesSchema.default(() => ({
     sanitization: true,
     trustClassification: true,
@@ -4149,22 +4041,22 @@ var FirewallConfigSchema = z7.object({
     corroboration: false,
     audit: true
   })),
-  allowlistedMaintainers: z7.array(z7.string().min(1)).default([]),
-  maxInputLength: z7.number().int().positive().default(5e4),
-  context: z7.object({
-    hasWriteAccess: z7.boolean().default(false),
-    hasSecretAccess: z7.boolean().default(false)
+  allowlistedMaintainers: z6.array(z6.string().min(1)).default([]),
+  maxInputLength: z6.number().int().positive().default(5e4),
+  context: z6.object({
+    hasWriteAccess: z6.boolean().default(false),
+    hasSecretAccess: z6.boolean().default(false)
   }).default(() => ({
     hasWriteAccess: false,
     hasSecretAccess: false
   }))
 });
-var ATLDataSchema = z7.object({
-  tier: z7.enum(["1", "2", "3", "4"]),
-  source: z7.string().min(1),
-  user: z7.string().min(1),
-  sanitized: z7.boolean(),
-  rep: z7.number().min(0).max(1).optional()
+var ATLDataSchema = z6.object({
+  tier: z6.enum(["1", "2", "3", "4"]),
+  source: z6.string().min(1),
+  user: z6.string().min(1),
+  sanitized: z6.boolean(),
+  rep: z6.number().min(0).max(1).optional()
 });
 
 // src/security/firewall/agent-trust-labels.ts
@@ -4399,28 +4291,28 @@ function createPassthroughClassification(meta) {
 }
 
 // src/security/firewall/github-adapter.ts
-import { z as z8 } from "zod";
-var GitHubIssueSchema = z8.object({
-  type: z8.literal("issue"),
-  username: z8.string().min(1),
-  authorAssociation: z8.string().min(1),
-  title: z8.string().default(""),
-  body: z8.string().default("")
+import { z as z7 } from "zod";
+var GitHubIssueSchema = z7.object({
+  type: z7.literal("issue"),
+  username: z7.string().min(1),
+  authorAssociation: z7.string().min(1),
+  title: z7.string().default(""),
+  body: z7.string().default("")
 });
-var GitHubCommentSchema = z8.object({
-  type: z8.literal("comment"),
-  username: z8.string().min(1),
-  authorAssociation: z8.string().min(1),
-  body: z8.string().default("")
+var GitHubCommentSchema = z7.object({
+  type: z7.literal("comment"),
+  username: z7.string().min(1),
+  authorAssociation: z7.string().min(1),
+  body: z7.string().default("")
 });
-var GitHubPRSchema = z8.object({
-  type: z8.literal("pull_request"),
-  username: z8.string().min(1),
-  authorAssociation: z8.string().min(1),
-  title: z8.string().default(""),
-  body: z8.string().default("")
+var GitHubPRSchema = z7.object({
+  type: z7.literal("pull_request"),
+  username: z7.string().min(1),
+  authorAssociation: z7.string().min(1),
+  title: z7.string().default(""),
+  body: z7.string().default("")
 });
-var GitHubInputSchema = z8.discriminatedUnion("type", [
+var GitHubInputSchema = z7.discriminatedUnion("type", [
   GitHubIssueSchema,
   GitHubCommentSchema,
   GitHubPRSchema
@@ -4463,46 +4355,46 @@ function createGitHubAdapter() {
 }
 
 // src/orchestration/spec-parser-types.ts
-import { z as z9 } from "zod";
-var IssueReferenceSchema = z9.object({
+import { z as z8 } from "zod";
+var IssueReferenceSchema = z8.object({
   /** Issue/PR number */
-  number: z9.number().int().positive(),
+  number: z8.number().int().positive(),
   /** Raw text (e.g., "#123") */
-  raw: z9.string()
+  raw: z8.string()
 });
-var FileReferenceSchema = z9.object({
+var FileReferenceSchema = z8.object({
   /** File path (e.g., "src/foo.ts") */
-  path: z9.string(),
+  path: z8.string(),
   /** Optional line number */
-  line: z9.number().int().positive().optional()
+  line: z8.number().int().positive().optional()
 });
-var TechStackSchema = z9.object({
+var TechStackSchema = z8.object({
   /** Programming language */
-  language: z9.string().optional(),
+  language: z8.string().optional(),
   /** Framework or library */
-  framework: z9.string().optional(),
+  framework: z8.string().optional(),
   /** Package manager */
-  packageManager: z9.string().optional()
+  packageManager: z8.string().optional()
 });
-var ParsedSpecSchema = z9.object({
+var ParsedSpecSchema = z8.object({
   /** Spec title (from first H1 or H2 heading) */
-  title: z9.string().min(1),
+  title: z8.string().min(1),
   /** Overview/description text */
-  overview: z9.string(),
+  overview: z8.string(),
   /** List of requirements */
-  requirements: z9.array(z9.string()),
+  requirements: z8.array(z8.string()),
   /** Acceptance criteria (checklist items) */
-  acceptanceCriteria: z9.array(z9.string()),
+  acceptanceCriteria: z8.array(z8.string()),
   /** Constraints or limitations */
-  constraints: z9.array(z9.string()),
+  constraints: z8.array(z8.string()),
   /** Issue/PR references found in the spec */
-  issueReferences: z9.array(IssueReferenceSchema),
+  issueReferences: z8.array(IssueReferenceSchema),
   /** File path references found in the spec */
-  fileReferences: z9.array(FileReferenceSchema),
+  fileReferences: z8.array(FileReferenceSchema),
   /** Sections that were missing from the spec */
-  missingSections: z9.array(z9.string()),
+  missingSections: z8.array(z8.string()),
   /** Raw markdown source */
-  rawMarkdown: z9.string(),
+  rawMarkdown: z8.string(),
   /** Inferred technology stack */
   techStack: TechStackSchema.optional()
 });
@@ -4518,138 +4410,138 @@ var KNOWN_SECTIONS = [
 ];
 
 // src/orchestration/spec-decomposer-types.ts
-import { z as z10 } from "zod";
-var SubtaskTypeSchema = z10.enum(["code", "test", "docs", "config", "refactor"]);
-var ComplexityLevelSchema = z10.enum(["simple", "moderate", "complex", "expert"]);
-var SubtaskNodeSchema = z10.object({
+import { z as z9 } from "zod";
+var SubtaskTypeSchema = z9.enum(["code", "test", "docs", "config", "refactor"]);
+var ComplexityLevelSchema = z9.enum(["simple", "moderate", "complex", "expert"]);
+var SubtaskNodeSchema = z9.object({
   /** Unique identifier for this subtask */
-  id: z10.string().min(1),
+  id: z9.string().min(1),
   /** Human-readable description of what this subtask does */
-  description: z10.string().min(1),
+  description: z9.string().min(1),
   /** The type of work */
   type: SubtaskTypeSchema,
   /** Estimated complexity */
   complexity: ComplexityLevelSchema,
   /** Required capabilities for the executing agent */
-  capabilities: z10.array(z10.string()),
+  capabilities: z9.array(z9.string()),
   /** IDs of subtasks this depends on */
-  dependsOn: z10.array(z10.string()),
+  dependsOn: z9.array(z9.string()),
   /** Source requirement text that generated this subtask */
-  sourceRequirement: z10.string().optional()
+  sourceRequirement: z9.string().optional()
 });
-var DagEdgeSchema = z10.object({
+var DagEdgeSchema = z9.object({
   /** Source subtask ID */
-  from: z10.string().min(1),
+  from: z9.string().min(1),
   /** Target subtask ID */
-  to: z10.string().min(1)
+  to: z9.string().min(1)
 });
-var TaskDagSchema = z10.object({
+var TaskDagSchema = z9.object({
   /** All subtask nodes */
-  nodes: z10.array(SubtaskNodeSchema),
+  nodes: z9.array(SubtaskNodeSchema),
   /** Dependency edges (from must complete before to) */
-  edges: z10.array(DagEdgeSchema),
+  edges: z9.array(DagEdgeSchema),
   /** Subtask IDs that can execute in parallel (no dependencies) */
-  roots: z10.array(z10.string()),
+  roots: z9.array(z9.string()),
   /** Total estimated complexity across all subtasks */
   totalComplexity: ComplexityLevelSchema,
   /** Source spec title for traceability */
-  specTitle: z10.string()
+  specTitle: z9.string()
 });
 
 // src/orchestration/scenario-validator-types.ts
-import { z as z11 } from "zod";
-var CriterionResultSchema = z11.object({
+import { z as z10 } from "zod";
+var CriterionResultSchema = z10.object({
   /** The original acceptance criterion text */
-  criterion: z11.string(),
+  criterion: z10.string(),
   /** Whether this criterion was satisfied */
-  met: z11.boolean(),
+  met: z10.boolean(),
   /** Which result(s) matched this criterion */
-  matchedResults: z11.array(z11.string())
+  matchedResults: z10.array(z10.string())
 });
-var ScenarioResultSchema = z11.object({
+var ScenarioResultSchema = z10.object({
   /** Satisfaction score from 0 (none met) to 1 (all met) */
-  satisfaction: z11.number().min(0).max(1),
+  satisfaction: z10.number().min(0).max(1),
   /** Total acceptance criteria count */
-  totalCriteria: z11.number().int().nonnegative(),
+  totalCriteria: z10.number().int().nonnegative(),
   /** Number of criteria met */
-  metCount: z11.number().int().nonnegative(),
+  metCount: z10.number().int().nonnegative(),
   /** Per-criterion results */
-  criteria: z11.array(CriterionResultSchema),
+  criteria: z10.array(CriterionResultSchema),
   /** Whether all criteria are met */
-  allMet: z11.boolean()
+  allMet: z10.boolean()
 });
 
 // src/orchestration/parallel-exploration-types.ts
-import { z as z12 } from "zod";
-var ParallelExplorationConfigSchema = z12.object({
+import { z as z11 } from "zod";
+var ParallelExplorationConfigSchema = z11.object({
   /** Max CLIs to dispatch to in parallel (default: 3) */
-  maxParallelClis: z12.number().int().min(1).max(4).default(3),
+  maxParallelClis: z11.number().int().min(1).max(4).default(3),
   /** Timeout per CLI invocation in ms (default: explorationMs from centralized timeouts). */
-  perCliTimeoutMs: z12.number().int().min(1e3).max(3e5).default(PER_CLI_TASK_TIMEOUTS.explorationMs),
+  perCliTimeoutMs: z11.number().int().min(1e3).max(3e5).default(PER_CLI_TASK_TIMEOUTS.explorationMs),
   /** Maximum output chars per CLI response (default: 8000, raised from 4k for exploration depth). */
-  maxOutputCharsPerCli: z12.number().int().min(100).max(2e4).default(8e3)
+  maxOutputCharsPerCli: z11.number().int().min(100).max(2e4).default(8e3)
 });
 
 // src/orchestration/triangulated-review-types.ts
-import { z as z13 } from "zod";
-var TriangulatedReviewConfigSchema = z13.object({
+import { z as z12 } from "zod";
+var TriangulatedReviewConfigSchema = z12.object({
   /** Max CLIs to dispatch to (default: 3). */
-  maxClis: z13.number().int().min(1).max(4).default(3),
+  maxClis: z12.number().int().min(1).max(4).default(3),
   /** Per-CLI timeout in ms (default from config/timeouts.ts, Issue #984). */
-  perCliTimeoutMs: z13.number().int().min(PER_CLI_TASK_TIMEOUTS.minMs).max(PER_CLI_TASK_TIMEOUTS.maxMs).default(PER_CLI_TASK_TIMEOUTS.defaultMs),
+  perCliTimeoutMs: z12.number().int().min(PER_CLI_TASK_TIMEOUTS.minMs).max(PER_CLI_TASK_TIMEOUTS.maxMs).default(PER_CLI_TASK_TIMEOUTS.defaultMs),
   /** Max chars per CLI response (default: 8000). */
-  maxOutputCharsPerCli: z13.number().int().min(100).max(3e4).default(8e3),
+  maxOutputCharsPerCli: z12.number().int().min(100).max(3e4).default(8e3),
   /** Line proximity for dedup: findings within N lines are considered same (default: 5). */
-  lineProximity: z13.number().int().min(0).max(50).default(5)
+  lineProximity: z12.number().int().min(0).max(50).default(5)
 });
 
 // src/orchestration/triangulated-review.ts
 var moduleLogger = createLogger({ component: "triangulated-review" });
 
 // src/orchestration/consensus-plan-types.ts
-import { z as z14 } from "zod";
-var PlanStepSchema = z14.object({
+import { z as z13 } from "zod";
+var PlanStepSchema = z13.object({
   /** Step description. */
-  description: z14.string(),
+  description: z13.string(),
   /** Estimated complexity: low, medium, high. */
-  complexity: z14.enum(["low", "medium", "high"]).default("medium"),
+  complexity: z13.enum(["low", "medium", "high"]).default("medium"),
   /** Dependencies on other step indices. */
-  dependencies: z14.array(z14.number().int().min(0)).default([])
+  dependencies: z13.array(z13.number().int().min(0)).default([])
 });
-var PlanRiskSchema = z14.object({
+var PlanRiskSchema = z13.object({
   /** Risk description. */
-  description: z14.string(),
+  description: z13.string(),
   /** Impact level. */
-  impact: z14.enum(["low", "medium", "high"]).default("medium"),
+  impact: z13.enum(["low", "medium", "high"]).default("medium"),
   /** Mitigation strategy. */
-  mitigation: z14.string().default("")
+  mitigation: z13.string().default("")
 });
-var ConsensusPlanConfigSchema = z14.object({
+var ConsensusPlanConfigSchema = z13.object({
   /** Max CLIs to dispatch to (default: 3). */
-  maxClis: z14.number().int().min(1).max(4).default(3),
+  maxClis: z13.number().int().min(1).max(4).default(3),
   /** Per-CLI timeout in ms (default from config/timeouts.ts, Issue #984). */
-  perCliTimeoutMs: z14.number().int().min(PER_CLI_TASK_TIMEOUTS.minMs).max(PER_CLI_TASK_TIMEOUTS.maxMs).default(PER_CLI_TASK_TIMEOUTS.defaultMs),
+  perCliTimeoutMs: z13.number().int().min(PER_CLI_TASK_TIMEOUTS.minMs).max(PER_CLI_TASK_TIMEOUTS.maxMs).default(PER_CLI_TASK_TIMEOUTS.defaultMs),
   /** Max chars per CLI response (default: 8000). */
-  maxOutputCharsPerCli: z14.number().int().min(100).max(3e4).default(8e3)
+  maxOutputCharsPerCli: z13.number().int().min(100).max(3e4).default(8e3)
 });
 
 // src/orchestration/consensus-plan.ts
 var moduleLogger2 = createLogger({ component: "consensus-plan" });
 
 // src/agents/observability/orchestration-observer-types.ts
-import { z as z15 } from "zod";
-var AgentStateSchema = z15.enum(["idle", "thinking", "executing", "waiting", "error"]);
-var OrchestrationObserverConfigSchema = z15.object({
+import { z as z14 } from "zod";
+var AgentStateSchema = z14.enum(["idle", "thinking", "executing", "waiting", "error"]);
+var OrchestrationObserverConfigSchema = z14.object({
   /** Maximum routing decisions to retain in history */
-  maxRoutingHistory: z15.number().positive().optional().default(100),
+  maxRoutingHistory: z14.number().positive().optional().default(100),
   /** Maximum session metrics to retain */
-  maxSessionHistory: z15.number().positive().optional().default(50),
+  maxSessionHistory: z14.number().positive().optional().default(50),
   /** Metrics update interval in ms */
-  metricsUpdateIntervalMs: z15.number().positive().optional().default(5e3),
+  metricsUpdateIntervalMs: z14.number().positive().optional().default(5e3),
   /** Enable detailed event logging */
-  verboseLogging: z15.boolean().optional().default(false),
+  verboseLogging: z14.boolean().optional().default(false),
   /** Token cost rates per model (USD per 1K tokens) */
-  tokenCostRates: z15.record(z15.string(), z15.number().nonnegative()).optional().default({
+  tokenCostRates: z14.record(z14.string(), z14.number().nonnegative()).optional().default({
     claude: 0.015,
     gemini: 1e-3,
     codex: 0.01
@@ -5896,45 +5788,45 @@ function normalizeCli(cli) {
 }
 
 // src/pipeline/trace-schema.ts
-import { z as z16 } from "zod";
-var ExecutionTraceEntrySchema = z16.object({
+import { z as z15 } from "zod";
+var ExecutionTraceEntrySchema = z15.object({
   /** Unix timestamp (ms). */
-  timestamp: z16.number(),
+  timestamp: z15.number(),
   /** Run identifier (typically TaskContract.id). */
-  runId: z16.string().min(1),
+  runId: z15.string().min(1),
   /** Pipeline event type that produced this trace entry. */
-  eventType: z16.string().min(1),
+  eventType: z15.string().min(1),
   /** Execution ID for pipeline correlation. */
-  executionId: z16.string().optional(),
+  executionId: z15.string().optional(),
   /** Graph node or stage that produced this event. */
-  nodeId: z16.string().optional(),
+  nodeId: z15.string().optional(),
   /** Agent that executed this step. */
-  agentId: z16.string().optional(),
+  agentId: z15.string().optional(),
   /** Model used for this step. */
-  modelId: z16.string().optional(),
+  modelId: z15.string().optional(),
   /** Agent role (e.g., code_expert, security_expert). */
-  role: z16.string().optional(),
+  role: z15.string().optional(),
   /** Duration in milliseconds. */
-  durationMs: z16.number().optional(),
+  durationMs: z15.number().optional(),
   /** Human-readable model selection reasoning. */
-  reasoning: z16.string().optional(),
+  reasoning: z15.string().optional(),
   /** Routing decision path (stage:result pairs). */
-  decisionPath: z16.array(z16.string()).optional(),
+  decisionPath: z15.array(z15.string()).optional(),
   /** Error classification. */
-  errorTaxonomy: z16.enum(["retriable", "fatal"]).optional(),
+  errorTaxonomy: z15.enum(["retriable", "fatal"]).optional(),
   /** Error message if this is a failure event. */
-  error: z16.string().optional(),
+  error: z15.string().optional(),
   /** Wave number (1-based) for wave dispatch events. */
-  waveNumber: z16.number().optional(),
+  waveNumber: z15.number().optional(),
   /** Total waves in the dispatch plan. */
-  totalWaves: z16.number().optional(),
+  totalWaves: z15.number().optional(),
   /** Number of workers in this wave. */
-  workerCount: z16.number().optional()
+  workerCount: z15.number().optional()
 });
 
 // src/security/quality-gate-types.ts
-import { z as z17 } from "zod";
-var PipelineStageSchema = z17.enum([
+import { z as z16 } from "zod";
+var PipelineStageSchema = z16.enum([
   "research",
   "plan",
   "vote",
@@ -5943,16 +5835,16 @@ var PipelineStageSchema = z17.enum([
   "qa",
   "ship"
 ]);
-var GateVerdictSchema = z17.enum(["pass", "fail", "skip"]);
-var GateCheckResultSchema = z17.object({
+var GateVerdictSchema = z16.enum(["pass", "fail", "skip"]);
+var GateCheckResultSchema = z16.object({
   /** Name of the check (e.g., 'tests_pass', 'lint_clean'). */
-  name: z17.string().min(1),
+  name: z16.string().min(1),
   /** Pass/fail/skip verdict. */
   verdict: GateVerdictSchema,
   /** Human-readable details. */
-  details: z17.string().max(500),
+  details: z16.string().max(500),
   /** Duration of the check in ms. */
-  durationMs: z17.number().nonnegative().optional()
+  durationMs: z16.number().nonnegative().optional()
 });
 
 // src/pipeline/quality-pipeline.ts
@@ -6090,7 +5982,7 @@ function buildVotingInput(plan, config) {
 }
 async function executeSingleVote(plan, config, log) {
   try {
-    const { executeVoting } = await import("./consensus-vote-MUQ4HPIF.js");
+    const { executeVoting } = await import("./consensus-vote-ESFPGEJE.js");
     const input = buildVotingInput(plan, config);
     const result = await executeVoting(input, log);
     return parseVotingResult(result);