nexus-agents 8.0.1 → 8.1.2

package/dist/index.js

@@ -553,7 +553,7 @@ import {
   withLogging,
   withRetry,
   withRetryWrapper
-} from "./chunk-GHIHBN4J.js";
+} from "./chunk-P7L7DX4C.js";
 import {
   FALLBACK_SCANNER_DATA,
   buildPlanFromAnalysis,
@@ -574,7 +574,7 @@ import {
   connectTransport,
   createServer,
   startStdioServer
-} from "./chunk-RB3X45G5.js";
+} from "./chunk-77IF6K22.js";
 import {
   OPENAI_MODELS,
   OPENAI_MODEL_ALIASES,
@@ -632,7 +632,7 @@ import {
   generateProposalId,
   parseAgentPairKey,
   registerConsensusVoteTool
-} from "./chunk-VMMMRHCW.js";
+} from "./chunk-A7HYUZC6.js";
 import "./chunk-6LDUEA4I.js";
 import {
   allOf
@@ -678,12 +678,13 @@ import {
   TrustTierSchema,
   assessReputation,
   reconcileTrustTier,
+  resolveEnvMode,
   sanitizeInput
 } from "./chunk-HS43MFL4.js";
 import {
   ImprovementReviewInputSchema,
   registerImprovementReviewTool
-} from "./chunk-4VZ5GK5B.js";
+} from "./chunk-J4J4RCYI.js";
 import {
   AgentPerformanceSchema,
   ConsensusAlgorithmSchema,
@@ -719,10 +720,10 @@ import {
   toolSuccess,
   toolSuccessStructured,
   validateToolInput
-} from "./chunk-INNWBLE4.js";
+} from "./chunk-7ERFJWJN.js";
 import {
   VERSION
-} from "./chunk-227USJYZ.js";
+} from "./chunk-UI3CP2V2.js";
 import {
   AuditTrail,
   MAX_STRIPPED_ELEMENTS_PER_EVENT,
@@ -2576,17 +2577,32 @@ function getSafetyTaxonomySummary() {
   };
 }
 
-// src/security/firewall/firewall-types.ts
+// src/security/firewall/firewall-policy-mode.ts
 import { z as z5 } from "zod";
-var FirewallStagesSchema = z5.object({
-  sanitization: z5.boolean().default(true),
-  trustClassification: z5.boolean().default(true),
-  reputationAssessment: z5.boolean().default(false),
-  policyEnforcement: z5.boolean().default(true),
-  corroboration: z5.boolean().default(false),
-  audit: z5.boolean().default(true)
+var FirewallPolicyModeSchema = z5.enum(["off", "audit", "enforce"]);
+var DEFAULT_FIREWALL_POLICY_MODE = "off";
+var FIREWALL_POLICY_ENV_VAR = "NEXUS_FIREWALL_POLICY";
+function resolveFirewallPolicyMode(env = process.env, logger12) {
+  return resolveEnvMode(
+    env[FIREWALL_POLICY_ENV_VAR],
+    FirewallPolicyModeSchema,
+    DEFAULT_FIREWALL_POLICY_MODE,
+    FIREWALL_POLICY_ENV_VAR,
+    ...logger12 !== void 0 ? [logger12] : []
+  );
+}
+
+// src/security/firewall/firewall-types.ts
+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 = z5.object({
+var FirewallConfigSchema = z6.object({
   stages: FirewallStagesSchema.default(() => ({
     sanitization: true,
     trustClassification: true,
@@ -2595,22 +2611,22 @@ var FirewallConfigSchema = z5.object({
     corroboration: false,
     audit: true
   })),
-  allowlistedMaintainers: z5.array(z5.string().min(1)).default([]),
-  maxInputLength: z5.number().int().positive().default(5e4),
-  context: z5.object({
-    hasWriteAccess: z5.boolean().default(false),
-    hasSecretAccess: z5.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 = z5.object({
-  tier: z5.enum(["1", "2", "3", "4"]),
-  source: z5.string().min(1),
-  user: z5.string().min(1),
-  sanitized: z5.boolean(),
-  rep: z5.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
@@ -2684,6 +2700,8 @@ var HostileInputFirewall = class {
   reputationCache;
   auditTrail;
   context;
+  /** #5382 rollout gate; resolved once at construction, not per call. */
+  policyMode;
   constructor(config) {
     const validated = FirewallConfigSchema.parse({
       stages: config.stages,
@@ -2700,6 +2718,7 @@ var HostileInputFirewall = class {
       config.auditLogger !== void 0 ? createDurableAuditSink(config.auditLogger) : void 0
     );
     this.context = validated.context;
+    this.policyMode = config.policyMode ?? resolveFirewallPolicyMode(config.env ?? process.env);
   }
   /**
    * Processes untrusted input through the firewall pipeline.
@@ -2728,6 +2747,9 @@ var HostileInputFirewall = class {
         rule: ruleOfTwoViolation.rule
       });
     }
+    const blocking = ruleOfTwoViolation?.severity === "block";
+    const refusal = this.refuseIfEnforcing(ruleOfTwoViolation, meta, effectiveTrustTier);
+    if (refusal !== void 0) return err(refusal);
     const auditEvents = this.auditTrail.query().map((e) => ({ id: e.id, type: e.type }));
     return ok({
       sanitized,
@@ -2736,10 +2758,42 @@ var HostileInputFirewall = class {
       effectiveTrustTier,
       atl,
       ...ruleOfTwoViolation !== void 0 ? { ruleOfTwoViolation } : {},
+      policyMode: this.policyMode,
+      // Reached only when we did NOT refuse, so this is "audit mode saw
+      // something enforce would have stopped". Under `off` it stays false: the
+      // signal is already on `ruleOfTwoViolation`, and reporting a would-be
+      // refusal for a mode that has not opted in would overstate the gate.
+      wouldRefuse: blocking && this.policyMode === "audit",
       auditEvents,
       durationMs: Date.now() - start
     });
   }
+  /**
+   * The fail-closed half of the #5382 gate: under `enforce`, a blocking policy
+   * violation refuses the input instead of riding along as a signal on an
+   * `ok()` result that a caller checking only `result.ok` walks straight past.
+   *
+   * This gates the RESPONSE to a violation, never its detection. It cannot
+   * manufacture a refusal where the `policyEnforcement` stage never ran, and it
+   * cannot refuse a non-blocking (`warn`) violation — so `enforce` is not a
+   * kill switch, and an allowlisted maintainer stays served.
+   *
+   * @returns the refusal, or `undefined` when the input passes or the mode has
+   *          not opted in.
+   */
+  refuseIfEnforcing(violation, meta, effectiveTrustTier) {
+    if (violation?.severity !== "block" || this.policyMode !== "enforce") return void 0;
+    logger3.warn("Firewall REFUSED input under enforce mode", {
+      user: meta.username,
+      effectiveTrustTier,
+      rule: violation.rule
+    });
+    return {
+      code: "POLICY_REFUSED",
+      message: `Refused by firewall policy: ${violation.rule} \u2014 ${violation.message}`,
+      stage: "policy"
+    };
+  }
   /** Returns the internal audit trail for inspection. */
   getAuditTrail() {
     return this.auditTrail;
@@ -2861,28 +2915,28 @@ function createPassthroughClassification(meta) {
 }
 
 // src/security/firewall/github-adapter.ts
-import { z as z6 } from "zod";
-var GitHubIssueSchema = z6.object({
-  type: z6.literal("issue"),
-  username: z6.string().min(1),
-  authorAssociation: z6.string().min(1),
-  title: z6.string().default(""),
-  body: z6.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 = z6.object({
-  type: z6.literal("comment"),
-  username: z6.string().min(1),
-  authorAssociation: z6.string().min(1),
-  body: z6.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 = z6.object({
-  type: z6.literal("pull_request"),
-  username: z6.string().min(1),
-  authorAssociation: z6.string().min(1),
-  title: z6.string().default(""),
-  body: z6.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 = z6.discriminatedUnion("type", [
+var GitHubInputSchema = z7.discriminatedUnion("type", [
   GitHubIssueSchema,
   GitHubCommentSchema,
   GitHubPRSchema
@@ -2933,7 +2987,7 @@ import { parse, registerDynamicLanguage } from "@ast-grep/napi";
 import goLangRegistration from "@ast-grep/lang-go";
 import pythonLangRegistration from "@ast-grep/lang-python";
 import { parse as parseYaml } from "yaml";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var polyglotLangsRegistered = false;
 function ensurePolyglotLangs() {
   if (polyglotLangsRegistered) return;
@@ -2942,12 +2996,12 @@ function ensurePolyglotLangs() {
 }
 var AST_RULE_LANGUAGES = ["python", "go"];
 var AST_RULE_SEVERITIES = ["error", "warning", "info"];
-var RuleFileSchema = z7.object({
-  id: z7.string().min(1),
-  language: z7.enum(AST_RULE_LANGUAGES),
-  severity: z7.enum(AST_RULE_SEVERITIES),
-  message: z7.string().min(1),
-  rule: z7.record(z7.string(), z7.unknown())
+var RuleFileSchema = z8.object({
+  id: z8.string().min(1),
+  language: z8.enum(AST_RULE_LANGUAGES),
+  severity: z8.enum(AST_RULE_SEVERITIES),
+  message: z8.string().min(1),
+  rule: z8.record(z8.string(), z8.unknown())
 });
 var MAX_SNIPPET_CHARS = 200;
 var DEFAULT_AST_QA_LIMIT = 200;
@@ -3149,46 +3203,46 @@ async function runAstQaRules(opts) {
 }
 
 // src/orchestration/spec-parser-types.ts
-import { z as z8 } from "zod";
-var IssueReferenceSchema = z8.object({
+import { z as z9 } from "zod";
+var IssueReferenceSchema = z9.object({
   /** Issue/PR number */
-  number: z8.number().int().positive(),
+  number: z9.number().int().positive(),
   /** Raw text (e.g., "#123") */
-  raw: z8.string()
+  raw: z9.string()
 });
-var FileReferenceSchema = z8.object({
+var FileReferenceSchema = z9.object({
   /** File path (e.g., "src/foo.ts") */
-  path: z8.string(),
+  path: z9.string(),
   /** Optional line number */
-  line: z8.number().int().positive().optional()
+  line: z9.number().int().positive().optional()
 });
-var TechStackSchema = z8.object({
+var TechStackSchema = z9.object({
   /** Programming language */
-  language: z8.string().optional(),
+  language: z9.string().optional(),
   /** Framework or library */
-  framework: z8.string().optional(),
+  framework: z9.string().optional(),
   /** Package manager */
-  packageManager: z8.string().optional()
+  packageManager: z9.string().optional()
 });
-var ParsedSpecSchema = z8.object({
+var ParsedSpecSchema = z9.object({
   /** Spec title (from first H1 or H2 heading) */
-  title: z8.string().min(1),
+  title: z9.string().min(1),
   /** Overview/description text */
-  overview: z8.string(),
+  overview: z9.string(),
   /** List of requirements */
-  requirements: z8.array(z8.string()),
+  requirements: z9.array(z9.string()),
   /** Acceptance criteria (checklist items) */
-  acceptanceCriteria: z8.array(z8.string()),
+  acceptanceCriteria: z9.array(z9.string()),
   /** Constraints or limitations */
-  constraints: z8.array(z8.string()),
+  constraints: z9.array(z9.string()),
   /** Issue/PR references found in the spec */
-  issueReferences: z8.array(IssueReferenceSchema),
+  issueReferences: z9.array(IssueReferenceSchema),
   /** File path references found in the spec */
-  fileReferences: z8.array(FileReferenceSchema),
+  fileReferences: z9.array(FileReferenceSchema),
   /** Sections that were missing from the spec */
-  missingSections: z8.array(z8.string()),
+  missingSections: z9.array(z9.string()),
   /** Raw markdown source */
-  rawMarkdown: z8.string(),
+  rawMarkdown: z9.string(),
   /** Inferred technology stack */
   techStack: TechStackSchema.optional()
 });
@@ -3204,136 +3258,136 @@ var KNOWN_SECTIONS = [
 ];
 
 // src/orchestration/spec-decomposer-types.ts
-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({
+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({
   /** Unique identifier for this subtask */
-  id: z9.string().min(1),
+  id: z10.string().min(1),
   /** Human-readable description of what this subtask does */
-  description: z9.string().min(1),
+  description: z10.string().min(1),
   /** The type of work */
   type: SubtaskTypeSchema,
   /** Estimated complexity */
   complexity: ComplexityLevelSchema,
   /** Required capabilities for the executing agent */
-  capabilities: z9.array(z9.string()),
+  capabilities: z10.array(z10.string()),
   /** IDs of subtasks this depends on */
-  dependsOn: z9.array(z9.string()),
+  dependsOn: z10.array(z10.string()),
   /** Source requirement text that generated this subtask */
-  sourceRequirement: z9.string().optional()
+  sourceRequirement: z10.string().optional()
 });
-var DagEdgeSchema = z9.object({
+var DagEdgeSchema = z10.object({
   /** Source subtask ID */
-  from: z9.string().min(1),
+  from: z10.string().min(1),
   /** Target subtask ID */
-  to: z9.string().min(1)
+  to: z10.string().min(1)
 });
-var TaskDagSchema = z9.object({
+var TaskDagSchema = z10.object({
   /** All subtask nodes */
-  nodes: z9.array(SubtaskNodeSchema),
+  nodes: z10.array(SubtaskNodeSchema),
   /** Dependency edges (from must complete before to) */
-  edges: z9.array(DagEdgeSchema),
+  edges: z10.array(DagEdgeSchema),
   /** Subtask IDs that can execute in parallel (no dependencies) */
-  roots: z9.array(z9.string()),
+  roots: z10.array(z10.string()),
   /** Total estimated complexity across all subtasks */
   totalComplexity: ComplexityLevelSchema,
   /** Source spec title for traceability */
-  specTitle: z9.string()
+  specTitle: z10.string()
 });
 
 // src/orchestration/scenario-validator-types.ts
-import { z as z10 } from "zod";
-var CriterionResultSchema = z10.object({
+import { z as z11 } from "zod";
+var CriterionResultSchema = z11.object({
   /** The original acceptance criterion text */
-  criterion: z10.string(),
+  criterion: z11.string(),
   /** Whether this criterion was satisfied */
-  met: z10.boolean(),
+  met: z11.boolean(),
   /** Which result(s) matched this criterion */
-  matchedResults: z10.array(z10.string())
+  matchedResults: z11.array(z11.string())
 });
-var ScenarioResultSchema = z10.object({
+var ScenarioResultSchema = z11.object({
   /** Satisfaction score from 0 (none met) to 1 (all met) */
-  satisfaction: z10.number().min(0).max(1),
+  satisfaction: z11.number().min(0).max(1),
   /** Total acceptance criteria count */
-  totalCriteria: z10.number().int().nonnegative(),
+  totalCriteria: z11.number().int().nonnegative(),
   /** Number of criteria met */
-  metCount: z10.number().int().nonnegative(),
+  metCount: z11.number().int().nonnegative(),
   /** Per-criterion results */
-  criteria: z10.array(CriterionResultSchema),
+  criteria: z11.array(CriterionResultSchema),
   /** Whether all criteria are met */
-  allMet: z10.boolean()
+  allMet: z11.boolean()
 });
 
 // src/orchestration/parallel-exploration-types.ts
-import { z as z11 } from "zod";
-var ParallelExplorationConfigSchema = z11.object({
+import { z as z12 } from "zod";
+var ParallelExplorationConfigSchema = z12.object({
   /** Max CLIs to dispatch to in parallel (default: 3) */
-  maxParallelClis: z11.number().int().min(1).max(4).default(3),
+  maxParallelClis: z12.number().int().min(1).max(4).default(3),
   /** Timeout per CLI invocation in ms (default: explorationMs from centralized timeouts). */
-  perCliTimeoutMs: z11.number().int().min(1e3).max(3e5).default(PER_CLI_TASK_TIMEOUTS.explorationMs),
+  perCliTimeoutMs: z12.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: z11.number().int().min(100).max(2e4).default(8e3)
+  maxOutputCharsPerCli: z12.number().int().min(100).max(2e4).default(8e3)
 });
 
 // src/orchestration/triangulated-review-types.ts
-import { z as z12 } from "zod";
-var TriangulatedReviewConfigSchema = z12.object({
+import { z as z13 } from "zod";
+var TriangulatedReviewConfigSchema = z13.object({
   /** Max CLIs to dispatch to (default: 3). */
-  maxClis: z12.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: z12.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: z12.number().int().min(100).max(3e4).default(8e3),
+  maxOutputCharsPerCli: z13.number().int().min(100).max(3e4).default(8e3),
   /** Line proximity for dedup: findings within N lines are considered same (default: 5). */
-  lineProximity: z12.number().int().min(0).max(50).default(5)
+  lineProximity: z13.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 z13 } from "zod";
-var PlanStepSchema = z13.object({
+import { z as z14 } from "zod";
+var PlanStepSchema = z14.object({
   /** Step description. */
-  description: z13.string(),
+  description: z14.string(),
   /** Estimated complexity: low, medium, high. */
-  complexity: z13.enum(["low", "medium", "high"]).default("medium"),
+  complexity: z14.enum(["low", "medium", "high"]).default("medium"),
   /** Dependencies on other step indices. */
-  dependencies: z13.array(z13.number().int().min(0)).default([])
+  dependencies: z14.array(z14.number().int().min(0)).default([])
 });
-var PlanRiskSchema = z13.object({
+var PlanRiskSchema = z14.object({
   /** Risk description. */
-  description: z13.string(),
+  description: z14.string(),
   /** Impact level. */
-  impact: z13.enum(["low", "medium", "high"]).default("medium"),
+  impact: z14.enum(["low", "medium", "high"]).default("medium"),
   /** Mitigation strategy. */
-  mitigation: z13.string().default("")
+  mitigation: z14.string().default("")
 });
-var ConsensusPlanConfigSchema = z13.object({
+var ConsensusPlanConfigSchema = z14.object({
   /** Max CLIs to dispatch to (default: 3). */
-  maxClis: z13.number().int().min(1).max(4).default(3),
+  maxClis: z14.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: z14.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: z14.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 z14 } from "zod";
-var AgentStateSchema = z14.enum(["idle", "thinking", "executing", "waiting", "error"]);
-var OrchestrationObserverConfigSchema = z14.object({
+import { z as z15 } from "zod";
+var AgentStateSchema = z15.enum(["idle", "thinking", "executing", "waiting", "error"]);
+var OrchestrationObserverConfigSchema = z15.object({
   /** Maximum routing decisions to retain in history */
-  maxRoutingHistory: z14.number().positive().optional().default(100),
+  maxRoutingHistory: z15.number().positive().optional().default(100),
   /** Maximum session metrics to retain */
-  maxSessionHistory: z14.number().positive().optional().default(50),
+  maxSessionHistory: z15.number().positive().optional().default(50),
   /** Metrics update interval in ms */
-  metricsUpdateIntervalMs: z14.number().positive().optional().default(5e3),
+  metricsUpdateIntervalMs: z15.number().positive().optional().default(5e3),
   /** Enable detailed event logging */
-  verboseLogging: z14.boolean().optional().default(false),
+  verboseLogging: z15.boolean().optional().default(false),
   /**
    * Per-model cost rate override, USD per 1,000 tokens (#5180).
    *
@@ -3352,13 +3406,13 @@ var OrchestrationObserverConfigSchema = z14.object({
    * defect this replaces. An operator who wants the old figures can keep their
    * existing scalar config and get byte-identical results.
    */
-  tokenCostRates: z14.record(
-    z14.string(),
-    z14.union([
-      z14.number().nonnegative(),
-      z14.object({
-        input: z14.number().nonnegative(),
-        output: z14.number().nonnegative()
+  tokenCostRates: z15.record(
+    z15.string(),
+    z15.union([
+      z15.number().nonnegative(),
+      z15.object({
+        input: z15.number().nonnegative(),
+        output: z15.number().nonnegative()
       })
     ])
   ).optional().default({})
@@ -4583,45 +4637,45 @@ function matchesArtifactFilter(artifact, filter) {
 }
 
 // src/pipeline/trace-schema.ts
-import { z as z15 } from "zod";
-var ExecutionTraceEntrySchema = z15.object({
+import { z as z16 } from "zod";
+var ExecutionTraceEntrySchema = z16.object({
   /** Unix timestamp (ms). */
-  timestamp: z15.number(),
+  timestamp: z16.number(),
   /** Run identifier (typically TaskContract.id). */
-  runId: z15.string().min(1),
+  runId: z16.string().min(1),
   /** Pipeline event type that produced this trace entry. */
-  eventType: z15.string().min(1),
+  eventType: z16.string().min(1),
   /** Execution ID for pipeline correlation. */
-  executionId: z15.string().optional(),
+  executionId: z16.string().optional(),
   /** Graph node or stage that produced this event. */
-  nodeId: z15.string().optional(),
+  nodeId: z16.string().optional(),
   /** Agent that executed this step. */
-  agentId: z15.string().optional(),
+  agentId: z16.string().optional(),
   /** Model used for this step. */
-  modelId: z15.string().optional(),
+  modelId: z16.string().optional(),
   /** Agent role (e.g., code_expert, security_expert). */
-  role: z15.string().optional(),
+  role: z16.string().optional(),
   /** Duration in milliseconds. */
-  durationMs: z15.number().optional(),
+  durationMs: z16.number().optional(),
   /** Human-readable model selection reasoning. */
-  reasoning: z15.string().optional(),
+  reasoning: z16.string().optional(),
   /** Routing decision path (stage:result pairs). */
-  decisionPath: z15.array(z15.string()).optional(),
+  decisionPath: z16.array(z16.string()).optional(),
   /** Error classification. */
-  errorTaxonomy: z15.enum(["retriable", "fatal"]).optional(),
+  errorTaxonomy: z16.enum(["retriable", "fatal"]).optional(),
   /** Error message if this is a failure event. */
-  error: z15.string().optional(),
+  error: z16.string().optional(),
   /** Wave number (1-based) for wave dispatch events. */
-  waveNumber: z15.number().optional(),
+  waveNumber: z16.number().optional(),
   /** Total waves in the dispatch plan. */
-  totalWaves: z15.number().optional(),
+  totalWaves: z16.number().optional(),
   /** Number of workers in this wave. */
-  workerCount: z15.number().optional()
+  workerCount: z16.number().optional()
 });
 
 // src/security/quality-gate-types.ts
-import { z as z16 } from "zod";
-var PipelineStageSchema = z16.enum([
+import { z as z17 } from "zod";
+var PipelineStageSchema = z17.enum([
   "research",
   "plan",
   "vote",
@@ -4630,16 +4684,16 @@ var PipelineStageSchema = z16.enum([
   "qa",
   "ship"
 ]);
-var GateVerdictSchema = z16.enum(["pass", "fail", "skip"]);
-var GateCheckResultSchema = z16.object({
+var GateVerdictSchema = z17.enum(["pass", "fail", "skip"]);
+var GateCheckResultSchema = z17.object({
   /** Name of the check (e.g., 'tests_pass', 'lint_clean'). */
-  name: z16.string().min(1),
+  name: z17.string().min(1),
   /** Pass/fail/skip verdict. */
   verdict: GateVerdictSchema,
   /** Human-readable details. */
-  details: z16.string().max(500),
+  details: z17.string().max(500),
   /** Duration of the check in ms. */
-  durationMs: z16.number().nonnegative().optional()
+  durationMs: z17.number().nonnegative().optional()
 });
 
 // src/pipeline/quality-pipeline.ts
@@ -4744,7 +4798,7 @@ function buildVotingInput(plan, config) {
 }
 async function executeSingleVote(plan, config, log) {
   try {
-    const { executeVoting } = await import("./consensus-vote-6MHOJFIA.js");
+    const { executeVoting } = await import("./consensus-vote-YEL2IXAO.js");
     const input = buildVotingInput(plan, config);
     const result = await executeVoting(input, log);
     return parseVotingResult(result);
@@ -4906,6 +4960,7 @@ export {
   DEFAULT_EXECUTION_TIME_MS,
   DEFAULT_FEEDBACK_COLLECTOR_CONFIG,
   DEFAULT_FEEDBACK_INTEGRATION_CONFIG,
+  DEFAULT_FIREWALL_POLICY_MODE,
   DEFAULT_FOREST_CONFIG,
   DEFAULT_HIGHER_ORDER_CONFIG,
   DEFAULT_MAX_RETRIES,
@@ -4969,6 +5024,7 @@ export {
   ExplorationEventTypeSchema,
   ExtractSymbolsInputSchema,
   FALLBACK_SCANNER_DATA,
+  FIREWALL_POLICY_ENV_VAR,
   FactoryError,
   FailurePatternSchema,
   FeedbackCollectorConfigSchema,
@@ -4977,6 +5033,7 @@ export {
   FileAuditStorage,
   FileReferenceSchema,
   FindingVoteSchema,
+  FirewallPolicyModeSchema,
   ForestConfigSchema,
   ForestPruningStrategySchema,
   ForestResultSchema,
@@ -5657,6 +5714,7 @@ export {
   resetRegistry,
   resolveExpression,
   resolveFallback,
+  resolveFirewallPolicyMode,
   resolveInput,
   resolvePipelineDeps,
   resolveScannerData,