nexus-agents 8.5.0 → 8.6.0

package/dist/index.js

@@ -553,7 +553,7 @@ import {
   withLogging,
   withRetry,
   withRetryWrapper
-} from "./chunk-YCY6QINI.js";
+} from "./chunk-6UWWVTQH.js";
 import {
   FALLBACK_SCANNER_DATA,
   buildPlanFromAnalysis,
@@ -568,13 +568,25 @@ import {
   normalizeRepoId
 } from "./chunk-DGWT7DXX.js";
 import "./chunk-64GMIUM5.js";
+import {
+  AST_RULE_LANGUAGES,
+  AST_RULE_SEVERITIES,
+  DEFAULT_AST_QA_LIMIT,
+  MAX_AST_QA_LIMIT,
+  MAX_FILES_SCANNED,
+  collectAstQaFindings,
+  ensurePolyglotLangs,
+  getBuiltInAstRulesPath,
+  loadRules,
+  runAstQaRules
+} from "./chunk-WZZQI774.js";
 import "./chunk-BYUVLVN7.js";
 import {
   closeServer,
   connectTransport,
   createServer,
   startStdioServer
-} from "./chunk-2DRZS743.js";
+} from "./chunk-QMUXBHKO.js";
 import {
   OPENAI_MODELS,
   OPENAI_MODEL_ALIASES,
@@ -632,7 +644,7 @@ import {
   generateProposalId,
   parseAgentPairKey,
   registerConsensusVoteTool
-} from "./chunk-3SKIHGZV.js";
+} from "./chunk-SNWGBSQ7.js";
 import "./chunk-FECYCZZR.js";
 import {
   allOf
@@ -685,7 +697,7 @@ import {
 import {
   ImprovementReviewInputSchema,
   registerImprovementReviewTool
-} from "./chunk-PBWVYWJ3.js";
+} from "./chunk-ZIZVA5OL.js";
 import {
   AgentPerformanceSchema,
   ConsensusAlgorithmSchema,
@@ -721,10 +733,10 @@ import {
   toolSuccess,
   toolSuccessStructured,
   validateToolInput
-} from "./chunk-VXKWGJ36.js";
+} from "./chunk-I33FKHUF.js";
 import {
   VERSION
-} from "./chunk-KIQLNY6S.js";
+} from "./chunk-4OILK4VD.js";
 import {
   AuditTrail,
   MAX_STRIPPED_ELEMENTS_PER_EVENT,
@@ -2583,14 +2595,14 @@ import { z as z5 } from "zod";
 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) {
+function resolveFirewallPolicyMode(env = process.env, logger11) {
   return resolveEnvMode(
     env[FIREWALL_POLICY_ENV_VAR],
     FirewallPolicyModeSchema,
     DEFAULT_FIREWALL_POLICY_MODE,
     FIREWALL_POLICY_ENV_VAR,
     {
-      ...logger12 !== void 0 ? { logger: logger12 } : {},
+      ...logger11 !== void 0 ? { logger: logger11 } : {},
       // An explicit-but-invalid value lands on `audit`, NOT on the unset
       // default `off`. Unset means "the operator has not opted in" and `off` is
       // right for it; a typo means "the operator opted in and mistyped how",
@@ -3070,271 +3082,47 @@ function createGitHubAdapter() {
   };
 }
 
-// src/security/ast-rule-runner.ts
-import { existsSync } from "node:fs";
-import { readdir, readFile, stat } from "node:fs/promises";
-import { dirname, extname, join, relative, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
-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 z8 } from "zod";
-var polyglotLangsRegistered = false;
-function ensurePolyglotLangs() {
-  if (polyglotLangsRegistered) return;
-  registerDynamicLanguage({ python: pythonLangRegistration, go: goLangRegistration });
-  polyglotLangsRegistered = true;
-}
-var AST_RULE_LANGUAGES = ["python", "go"];
-var AST_RULE_SEVERITIES = ["error", "warning", "info"];
-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;
-var MAX_AST_QA_LIMIT = 2e3;
-var AST_QA_MAX_DEPTH = 24;
-var MAX_FILES_SCANNED = 5e3;
-var logger4 = createLogger({ component: "ast-rule-runner" });
-async function loadRules(dir) {
-  let entries;
-  try {
-    entries = (await readdir(dir)).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml")).sort();
-  } catch (caught) {
-    const e = caught instanceof Error ? caught : new Error(String(caught));
-    throw new ValidationError(`ast-rule-runner: cannot read rules dir ${dir}: ${e.message}`, {
-      cause: e
-    });
-  }
-  const rules = [];
-  for (const file of entries) {
-    const path = join(dir, file);
-    const raw = await readFile(path, "utf8");
-    let parsed;
-    try {
-      parsed = parseYaml(raw);
-    } catch (caught) {
-      const e = caught instanceof Error ? caught : new Error(String(caught));
-      throw new ValidationError(`ast-rule-runner: malformed YAML in ${path}: ${e.message}`, {
-        cause: e
-      });
-    }
-    const result = RuleFileSchema.safeParse(parsed);
-    if (!result.success) {
-      throw new ValidationError(
-        `ast-rule-runner: invalid rule file ${path}: ${formatZodError(result.error)}`
-      );
-    }
-    rules.push(result.data);
-  }
-  return rules;
-}
-function getBuiltInAstRulesPath() {
-  const currentFile = fileURLToPath(import.meta.url);
-  const currentDir = dirname(currentFile);
-  if (currentFile.includes(`${sep}dist${sep}`) || currentFile.endsWith(`${sep}dist`)) {
-    const distIndex = currentFile.lastIndexOf(`${sep}dist${sep}`);
-    if (distIndex !== -1) {
-      const distDir = currentFile.substring(0, distIndex + 5);
-      const bundledPath = join(distDir, "security", "ast-rules");
-      if (existsSync(bundledPath)) return bundledPath;
-    }
-  }
-  const possiblePaths = [
-    join(currentDir, "ast-rules"),
-    // Unbundled: sibling of this file in src/security/
-    join(currentDir, "security", "ast-rules"),
-    // Bundled chunk: dist/security sibling
-    join(dirname(currentDir), "security", "ast-rules")
-  ];
-  for (const path of possiblePaths) {
-    if (existsSync(path)) return path;
-  }
-  return join(currentDir, "ast-rules");
-}
-function resolveWithinCwd(target) {
-  const resolved = resolve(target);
-  const cwdRoot = resolve(".");
-  if (resolved !== cwdRoot && !resolved.startsWith(cwdRoot + sep)) {
-    return { error: `Path traversal denied: scope must be within ${cwdRoot}` };
-  }
-  return { resolved };
-}
-var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", ".git"]);
-var POLYGLOT_EXT_TO_LANG = {
-  ".py": "python",
-  ".go": "go"
-};
-function inferRuleLang(file) {
-  return POLYGLOT_EXT_TO_LANG[extname(file).toLowerCase()] ?? null;
-}
-async function findPolyglotFiles(dir, maxDepth) {
-  if (maxDepth <= 0) return [];
-  const out = [];
-  let entries;
-  try {
-    entries = await readdir(dir, { withFileTypes: true });
-  } catch (caught) {
-    const e = caught instanceof Error ? caught : new Error(String(caught));
-    logger4.warn(`ast-rule-runner: skipped unreadable directory ${dir}: ${e.message}`);
-    return out;
-  }
-  for (const entry of entries) {
-    const fullPath = join(dir, entry.name);
-    if (entry.isDirectory() && !SKIP_DIRS.has(entry.name)) {
-      out.push(...await findPolyglotFiles(fullPath, maxDepth - 1));
-    } else if (entry.isFile() && inferRuleLang(entry.name) !== null) {
-      out.push(fullPath);
-    }
-  }
-  return out;
-}
-function langToParseArg(lang) {
-  ensurePolyglotLangs();
-  return lang;
-}
-function scanFile(src, lang, applicable, budget) {
-  const { rel, limit, alreadyFound } = budget;
-  const root = parse(langToParseArg(lang), src).root();
-  const lines = src.split("\n");
-  const findings = [];
-  let total = 0;
-  for (const rule of applicable) {
-    const config = { rule: rule.rule };
-    for (const node of root.findAll(config)) {
-      total += 1;
-      if (alreadyFound + findings.length < limit) {
-        const { start } = node.range();
-        const rawLine = lines[start.line] ?? node.text();
-        findings.push({
-          ruleId: rule.id,
-          severity: rule.severity,
-          message: rule.message,
-          file: rel,
-          line: start.line + 1,
-          column: start.column + 1,
-          snippet: rawLine.trim().slice(0, MAX_SNIPPET_CHARS)
-        });
-      }
-    }
-  }
-  return { findings, total };
-}
-async function assertScanRootIsDirectory(resolved) {
-  let rootStat;
-  try {
-    rootStat = await stat(resolved);
-  } catch (caught) {
-    const e = caught instanceof Error ? caught : new Error(String(caught));
-    throw new ValidationError(`ast-rule-runner: cannot read targetDir ${resolved}: ${e.message}`, {
-      cause: e
-    });
-  }
-  if (!rootStat.isDirectory()) {
-    throw new ValidationError(
-      `ast-rule-runner: targetDir must be a directory, got a non-directory path: ${resolved}`
-    );
-  }
-}
-async function resolveScanFiles(root) {
-  const discovered = await findPolyglotFiles(root, AST_QA_MAX_DEPTH);
-  const files = discovered.slice(0, MAX_FILES_SCANNED);
-  const filesSkipped = discovered.length - files.length;
-  const filesTruncated = filesSkipped > 0;
-  if (filesTruncated) {
-    logger4.warn(
-      `ast-rule-runner: ${String(filesSkipped)} file(s) NOT scanned \u2014 file cap ${String(MAX_FILES_SCANNED)} exceeded (discovered=${String(discovered.length)}). Scan is PARTIAL; do not treat findings as exhaustive.`
-    );
-  }
-  return { files, filesSkipped, filesTruncated };
-}
-async function collectAstQaFindings(opts) {
-  const guard = resolveWithinCwd(opts.targetDir);
-  if ("error" in guard) {
-    throw new SecurityError(guard.error);
-  }
-  await assertScanRootIsDirectory(guard.resolved);
-  const rulesDir = opts.rulesDir ?? getBuiltInAstRulesPath();
-  const rules = await loadRules(rulesDir);
-  const limit = Math.min(Math.max(opts.limit ?? DEFAULT_AST_QA_LIMIT, 1), MAX_AST_QA_LIMIT);
-  const { files, filesSkipped, filesTruncated } = await resolveScanFiles(guard.resolved);
-  const findings = [];
-  let total = 0;
-  for (const file of files) {
-    const lang = inferRuleLang(file);
-    if (lang === null) continue;
-    const applicable = rules.filter((r) => r.language === lang);
-    if (applicable.length === 0) continue;
-    let src;
-    try {
-      src = await readFile(file, "utf8");
-    } catch {
-      logger4.warn(`ast-rule-runner: skipped unreadable file ${file}`);
-      continue;
-    }
-    const rel = relative(guard.resolved, file) || file;
-    const scanned = scanFile(src, lang, applicable, { rel, limit, alreadyFound: findings.length });
-    findings.push(...scanned.findings);
-    total += scanned.total;
-  }
-  if (total > findings.length) {
-    logger4.warn(
-      `ast-rule-runner: ${String(total - findings.length)} finding(s) omitted beyond limit=${String(limit)} (total=${String(total)})`
-    );
-  }
-  return { findings, total, limit, filesScanned: files.length, filesSkipped, filesTruncated };
-}
-async function runAstQaRules(opts) {
-  const { findings } = await collectAstQaFindings(opts);
-  return findings;
-}
-
 // 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()
 });
@@ -3350,136 +3138,136 @@ 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),
   /**
    * Per-model cost rate override, USD per 1,000 tokens (#5180).
    *
@@ -3498,13 +3286,13 @@ var OrchestrationObserverConfigSchema = z15.object({
    * defect this replaces. An operator who wants the old figures can keep their
    * existing scalar config and get byte-identical results.
    */
-  tokenCostRates: z15.record(
-    z15.string(),
-    z15.union([
-      z15.number().nonnegative(),
-      z15.object({
-        input: z15.number().nonnegative(),
-        output: z15.number().nonnegative()
+  tokenCostRates: z14.record(
+    z14.string(),
+    z14.union([
+      z14.number().nonnegative(),
+      z14.object({
+        input: z14.number().nonnegative(),
+        output: z14.number().nonnegative()
       })
     ])
   ).optional().default({})
@@ -3733,7 +3521,7 @@ var DEFAULT_BENCHMARK_CONFIG = {
 
 // src/benchmarks/benchmark-runner.ts
 import { cpus, totalmem, platform, arch } from "node:os";
-var logger5 = createLogger({ component: "benchmark-runner" });
+var logger4 = createLogger({ component: "benchmark-runner" });
 var LatencySampler = class {
   samples = [];
   startTimes = /* @__PURE__ */ new Map();
@@ -3829,11 +3617,11 @@ async function runOperationBenchmark(operation, datasetSize, fn, config = {}) {
   const startTime = getTimeProvider().now();
   const startMemory = process.memoryUsage().heapUsed;
   let peakMemory = startMemory;
-  logger5.debug("Running warmup", { operation, iterations: cfg.warmupIterations });
+  logger4.debug("Running warmup", { operation, iterations: cfg.warmupIterations });
   for (let i = 0; i < cfg.warmupIterations; i++) {
     await fn();
   }
-  logger5.debug("Running measurements", { operation, iterations: cfg.measurementIterations });
+  logger4.debug("Running measurements", { operation, iterations: cfg.measurementIterations });
   for (let i = 0; i < cfg.measurementIterations; i++) {
     const id = `op-${String(i)}`;
     sampler.start(id);
@@ -3968,7 +3756,7 @@ ${"=".repeat(60)}`);
 }
 
 // src/benchmarks/memory-benchmarks.ts
-var logger6 = createLogger({ component: "memory-benchmarks" });
+var logger5 = createLogger({ component: "memory-benchmarks" });
 var DEFAULT_MEMORY_BENCHMARK_CONFIG = {
   ...DEFAULT_BENCHMARK_CONFIG,
   contentSizeBytes: 1024,
@@ -4076,9 +3864,9 @@ async function benchmarkPrune(backend, data, config) {
 async function runMemoryBenchmarks(backend, name, config = {}) {
   const cfg = { ...DEFAULT_MEMORY_BENCHMARK_CONFIG, ...config };
   const operations = [];
-  logger6.info("Starting memory benchmarks", { name, sizes: cfg.datasetSizes });
+  logger5.info("Starting memory benchmarks", { name, sizes: cfg.datasetSizes });
   for (const size of cfg.datasetSizes) {
-    logger6.info("Running benchmarks for dataset size", { size });
+    logger5.info("Running benchmarks for dataset size", { size });
     const data = generateTestData(size, cfg);
     try {
       const futureDate = new Date(getTimeProvider().now() + 365 * 24 * 60 * 60 * 1e3);
@@ -4092,7 +3880,7 @@ async function runMemoryBenchmarks(backend, name, config = {}) {
   }
   const environment = getBenchmarkEnvironment();
   const summary = createBenchmarkSummary(operations, cfg);
-  logger6.info("Benchmarks complete", {
+  logger5.info("Benchmarks complete", {
     name,
     passed: summary.passed,
     avgP95: summary.avgP95Latency,
@@ -4138,7 +3926,7 @@ function compareBenchmarks(baseline, current) {
 }
 
 // src/benchmarks/token-benchmark.ts
-var logger7 = createLogger({ component: "token-benchmark" });
+var logger6 = createLogger({ component: "token-benchmark" });
 var CHARS_PER_TOKEN = 4;
 function estimateTokens2(text) {
   return Math.ceil(text.length / CHARS_PER_TOKEN);
@@ -4156,7 +3944,7 @@ async function runTokenBenchmark(backend, config = {}) {
   const cfg = { ...DEFAULT_MEMORY_BENCHMARK_CONFIG, ...config };
   const results = [];
   for (const size of cfg.datasetSizes) {
-    logger7.info("Running token benchmark", { size });
+    logger6.info("Running token benchmark", { size });
     const data = generateTestData(size, cfg);
     for (const entry of data.entries) {
       await backend.store(entry.key, entry.content, {
@@ -4189,15 +3977,15 @@ async function runTokenBenchmark(backend, config = {}) {
 }
 
 // src/benchmarks/consolidation-benchmark.ts
-var logger8 = createLogger({ component: "consolidation-benchmark" });
+var logger7 = createLogger({ component: "consolidation-benchmark" });
 async function runConsolidationBenchmark(operations, config = {}) {
   const cfg = { ...DEFAULT_MEMORY_BENCHMARK_CONFIG, ...config };
   const benchmarks = [];
-  logger8.info("Starting consolidation benchmarks", {
+  logger7.info("Starting consolidation benchmarks", {
     operationCount: operations.length
   });
   for (const op of operations) {
-    logger8.info("Benchmarking consolidation operation", { name: op.name });
+    logger7.info("Benchmarking consolidation operation", { name: op.name });
     const benchmark = await runOperationBenchmark(
       op.name,
       0,
@@ -4312,7 +4100,7 @@ function formatBenchmarkReport(report) {
 }
 
 // src/benchmarks/adapter-latency-benchmark.ts
-var logger9 = createLogger({ component: "adapter-latency-benchmark" });
+var logger8 = createLogger({ component: "adapter-latency-benchmark" });
 var DEFAULT_ADAPTER_LATENCY_CONFIG = {
   warmupIterations: 3,
   measurementIterations: 10,
@@ -4362,7 +4150,7 @@ async function benchmarkScenario(adapter, scenario, config) {
   const errors = [];
   let successCount = 0;
   let failureCount = 0;
-  logger9.info("Benchmarking scenario", {
+  logger8.info("Benchmarking scenario", {
     adapter: adapter.name,
     scenario: scenario.name,
     warmup: config.warmupIterations,
@@ -4729,45 +4517,45 @@ function matchesArtifactFilter(artifact, filter) {
 }
 
 // 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",
@@ -4776,20 +4564,20 @@ 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
-var logger10 = createLogger({ component: "quality-pipeline" });
+var logger9 = createLogger({ component: "quality-pipeline" });
 
 // src/pipeline/iterative-consensus.ts
 var defaultLogger = createLogger({ component: "iterative-consensus" });
@@ -4890,7 +4678,7 @@ function buildVotingInput(plan, config) {
 }
 async function executeSingleVote(plan, config, log) {
   try {
-    const { executeVoting } = await import("./consensus-vote-ETFQMPDA.js");
+    const { executeVoting } = await import("./consensus-vote-222ZEN5J.js");
     const input = buildVotingInput(plan, config);
     const result = await executeVoting(input, log);
     return parseVotingResult(result);
@@ -4923,7 +4711,7 @@ function parseVotingResult(result) {
 }
 
 // src/replay/replay-executor.ts
-var logger11 = createLogger({ component: "ReplayExecutor" });
+var logger10 = createLogger({ component: "ReplayExecutor" });
 export {
   ALLOWED_COMMANDS,
   ARTIFACT_TYPES,