@nathapp/nax 0.73.2 → 0.73.4

package/dist/nax.js

@@ -17283,6 +17283,53 @@ var init_schemas_infra = __esm(() => {
   });
 });
 
+// src/config/schemas-reporters.ts
+var HeadersSchema, ReporterEventSchema, WebhookReporterConfigSchema, OtelReporterConfigSchema, ReportersConfigSchema;
+var init_schemas_reporters = __esm(() => {
+  init_zod();
+  HeadersSchema = exports_external.record(exports_external.string(), exports_external.string()).default({});
+  ReporterEventSchema = exports_external.enum(["onRunStart", "onStoryComplete", "onRunEnd"]);
+  WebhookReporterConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().default(false),
+    url: exports_external.string().url().optional(),
+    headers: HeadersSchema,
+    events: exports_external.array(ReporterEventSchema).optional(),
+    timeoutMs: exports_external.number().int().positive().default(5000)
+  }).default({
+    enabled: false,
+    headers: {},
+    timeoutMs: 5000
+  });
+  OtelReporterConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().default(false),
+    endpoint: exports_external.string().url().optional(),
+    headers: HeadersSchema,
+    serviceName: exports_external.string().default("nax"),
+    timeoutMs: exports_external.number().int().positive().default(5000)
+  }).default({
+    enabled: false,
+    headers: {},
+    serviceName: "nax",
+    timeoutMs: 5000
+  });
+  ReportersConfigSchema = exports_external.object({
+    webhook: WebhookReporterConfigSchema,
+    otel: OtelReporterConfigSchema
+  }).default({
+    webhook: {
+      enabled: false,
+      headers: {},
+      timeoutMs: 5000
+    },
+    otel: {
+      enabled: false,
+      headers: {},
+      serviceName: "nax",
+      timeoutMs: 5000
+    }
+  });
+});
+
 // src/config/schemas-review.ts
 var SemanticReviewConfigSchema, AdversarialReviewConfigSchema, ReviewConfigSchema;
 var init_schemas_review = __esm(() => {
@@ -17369,6 +17416,7 @@ var init_schemas3 = __esm(() => {
   init_schemas_execution();
   init_schemas_infra();
   init_schemas_model();
+  init_schemas_reporters();
   init_schemas_review();
   init_schemas_infra();
   init_schemas_review();
@@ -17739,6 +17787,7 @@ var init_schemas3 = __esm(() => {
       enabled: exports_external.boolean().default(false),
       draft: exports_external.boolean().default(true)
     }).optional().default({ enabled: false, draft: true }),
+    reporters: ReportersConfigSchema,
     profile: exports_external.string().default("default"),
     profileChain: exports_external.array(exports_external.string()).default([])
   }).refine((data) => data.version === 1, {
@@ -24524,16 +24573,24 @@ function buildTestFrameworkHint(testCommand) {
     return "Use Jest (describe/test/expect)";
   return "Use your project's test framework";
 }
+function stripAnsi(output) {
+  return output.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "");
+}
 function detectFramework(output) {
-  if (/^\s*Test Files\s+\d+/m.test(output))
+  const clean = stripAnsi(output);
+  if (/^\s*Test Files\s+\d+/m.test(clean))
     return "vitest";
-  if (/^\s*Tests:\s+\d+/m.test(output))
+  if (/^\s*Tests:\s+\d+/m.test(clean))
     return "jest";
-  if (/={3,}\s+\d+\s+(?:failed|passed).*in\s+[\d.]+s\s*={3,}/m.test(output))
+  if (/={3,}\s+\d+\s+(?:failed|passed).*in\s+[\d.]+s\s*={3,}/m.test(clean))
     return "pytest";
-  if (/^--- (?:FAIL|PASS):/m.test(output) || /^(?:ok|FAIL)\s+\t/m.test(output))
+  if (/^--- (?:FAIL|PASS):/m.test(clean) || /^(?:ok|FAIL)\s+\t/m.test(clean))
     return "go";
-  if (/^\(fail\)\s/m.test(output) || /^bun test/m.test(output) || /[\u2713\u2714\u2717\u2718]/m.test(output))
+  if (/^test result:\s+(?:ok|FAILED)\./m.test(clean) || /panicked at /.test(clean))
+    return "rust";
+  if (/^\s*\d+\s+passing\b/m.test(clean))
+    return "mocha";
+  if (/^\(fail\)\s/m.test(clean) || /^bun test/m.test(clean) || /[\u2713\u2714\u2717\u2718]/m.test(clean))
     return "bun";
   return "unknown";
 }
@@ -24670,21 +24727,125 @@ var init_resolver = __esm(() => {
   };
 });
 
+// src/test-runners/parse-mocha.ts
+function parseMochaOutput(output) {
+  return {
+    passed: matchCount(output, /(\d+)\s+passing\b/),
+    failed: matchCount(output, /(\d+)\s+failing\b/),
+    failures: extractMochaFailures(output)
+  };
+}
+function matchCount(output, re) {
+  const m = output.match(re);
+  return m ? Number.parseInt(m[1], 10) : 0;
+}
+function extractMochaFailures(output) {
+  const failingIdx = output.search(/^\s*\d+\s+failing\b/m);
+  if (failingIdx === -1)
+    return [];
+  const lines = output.slice(failingIdx).split(`
+`);
+  const failures = [];
+  for (let i = 1;i < lines.length; i++) {
+    const header = lines[i].match(/^\s*(\d+)\)\s+(.+)$/);
+    if (!header)
+      continue;
+    const testName = header[2].replace(/:\s*$/, "").trim();
+    let file3 = "unknown";
+    let error48 = "";
+    const stackTrace = [];
+    for (let j = i + 1;j < lines.length; j++) {
+      const line = lines[j];
+      if (/^\s*\d+\)\s+/.test(line))
+        break;
+      const at = line.match(/at\s+.*\(([^)]+):(\d+):(\d+)\)/);
+      if (at) {
+        if (file3 === "unknown")
+          file3 = at[1];
+        if (stackTrace.length < MAX_STACK_LINES)
+          stackTrace.push(`${at[1]}:${at[2]}`);
+        continue;
+      }
+      if (!error48 && line.trim())
+        error48 = line.trim();
+    }
+    failures.push({ file: file3, testName, error: error48 || "Unknown error", stackTrace });
+  }
+  return failures;
+}
+var MAX_STACK_LINES = 5;
+
+// src/test-runners/parse-rust.ts
+function parseRustTestOutput(output) {
+  let passed = 0;
+  let failed = 0;
+  for (const m of output.matchAll(RESULT_LINE_RE)) {
+    passed += Number.parseInt(m[1], 10);
+    failed += Number.parseInt(m[2], 10);
+  }
+  return { passed, failed, failures: extractRustFailures(output) };
+}
+function extractRustFailures(output) {
+  const lines = output.split(`
+`);
+  const failures = [];
+  for (let i = 0;i < lines.length; i++) {
+    const header = lines[i].match(/^---- (\S+) stdout ----$/);
+    if (!header)
+      continue;
+    const testName = header[1];
+    let file3 = "unknown";
+    let error48 = "";
+    const stackTrace = [];
+    for (let j = i + 1;j < lines.length; j++) {
+      const line = lines[j];
+      if (/^---- \S+ stdout ----$/.test(line) || /^test result:/.test(line))
+        break;
+      const panic = line.match(/panicked at ([^:\n]+):(\d+):(?:\d+):/);
+      if (panic) {
+        file3 = panic[1];
+        if (stackTrace.length < MAX_STACK_LINES2)
+          stackTrace.push(`${panic[1]}:${panic[2]}`);
+        continue;
+      }
+      if (!error48 && line.trim() && !line.startsWith("note:"))
+        error48 = line.trim();
+    }
+    failures.push({ file: file3, testName, error: error48 || "Unknown error", stackTrace });
+  }
+  if (failures.length > 0)
+    return failures;
+  for (const m of output.matchAll(FAILED_TEST_LINE_RE)) {
+    failures.push({ file: "unknown", testName: m[1], error: "Unknown error", stackTrace: [] });
+  }
+  return failures;
+}
+var RESULT_LINE_RE, FAILED_TEST_LINE_RE, MAX_STACK_LINES2 = 5;
+var init_parse_rust = __esm(() => {
+  RESULT_LINE_RE = /^test result:\s+(?:ok|FAILED)\.\s+(\d+)\s+passed;\s+(\d+)\s+failed;/gm;
+  FAILED_TEST_LINE_RE = /^test (\S+) \.\.\. FAILED$/gm;
+});
+
 // src/test-runners/parser.ts
 function parseTestOutput(output) {
-  const framework = detectFramework(output);
+  const clean = stripAnsi(output);
+  const framework = detectFramework(clean);
   switch (framework) {
     case "bun":
-      return parseBunOutput(output);
+      return parseBunOutput(clean);
     case "jest":
     case "vitest":
-      return parseJestOutput(output);
+      return parseJestOutput(clean);
     case "pytest":
-      return parsePytestOutput(output);
+      return parsePytestOutput(clean);
     case "go":
-      return parseGoTestOutput(output);
+      return parseGoTestOutput(clean);
+    case "rust":
+      return parseRustTestOutput(clean);
+    case "mocha":
+      return parseMochaOutput(clean);
     default:
-      return parseCommonOutput(output);
+      return parseCommonOutput(clean);
   }
 }
 function parseBunTestOutput(output) {
@@ -25014,11 +25175,12 @@ function analyzeTestExitCode(output, exitCode) {
 }
 var init_parser = __esm(() => {
   init_detector2();
+  init_parse_rust();
 });
 
 // src/test-runners/ac-parser.ts
 function parseTestFailures(output) {
-  const clean = output.replace(ANSI_ESCAPE_PATTERN, "");
+  const clean = stripAnsi(output);
   const framework = detectFramework(clean);
   const failedACs = [];
   const lines = clean.split(`
@@ -25072,10 +25234,8 @@ function parseTestFailures(output) {
   }
   return failedACs;
 }
-var ANSI_ESCAPE_PATTERN;
 var init_ac_parser = __esm(() => {
   init_detector2();
-  ANSI_ESCAPE_PATTERN = new RegExp(`${String.fromCharCode(27)}\\[[0-9;?]*[A-Za-z]`, "g");
 });
 
 // src/utils/git.ts
@@ -25756,6 +25916,8 @@ __export(exports_test_runners, {
   resolveReviewExcludePatterns: () => resolveReviewExcludePatterns,
   parseTestOutput: () => parseTestOutput,
   parseTestFailures: () => parseTestFailures,
+  parseRustTestOutput: () => parseRustTestOutput,
+  parseMochaOutput: () => parseMochaOutput,
   parseBunTestOutput: () => parseBunTestOutput,
   isTestFileByPatterns: () => isTestFileByPatterns,
   isTestFile: () => isTestFile,
@@ -25787,6 +25949,7 @@ var init_test_runners = __esm(() => {
   init_detector2();
   init_resolver();
   init_parser();
+  init_parse_rust();
   init_workspace();
   init_ac_parser();
   init_scoped_selection();
@@ -35651,7 +35814,7 @@ var init_semantic_review = __esm(() => {
       const substantiated = await substantiateSemanticEvidence(sanitized, input.mode, input.workdir, input.story.id, threshold, input.repoRoot);
       const { accepted, dropped } = filterByAcGroundingMinimal(substantiated, input.story.acceptanceCriteria);
       const blocking = accepted.filter((f) => isBlockingSeverity(f.severity, threshold));
-      const passed = parsed.passed && blocking.length === 0;
+      const passed = blocking.length === 0 && (parsed.passed || accepted.length > 0);
       return {
         ...parsed,
         passed,
@@ -38863,9 +39026,10 @@ var init_full_suite_rectify_op = __esm(() => {
 });
 
 // src/operations/full-suite-rectify.ts
-function makeFullSuiteRectifyStrategy(story, config2, sink) {
-  const appliesTo = (finding) => finding.source === "test-runner" && (finding.category === "failed-test" || finding.category === "execution-failed");
+function makeFullSuiteRectifyStrategy(story, config2, sink, hasTestWriterDrainer) {
+  const claimsFailingTest = (finding) => finding.source === "test-runner" && (finding.category === "failed-test" || finding.category === "execution-failed");
   if (sink) {
+    const appliesTo = (finding) => claimsFailingTest(finding) && !(hasTestWriterDrainer === true && sink.mockHandoffs.length > 0);
     return {
       name: "full-suite-rectify",
       appliesTo,
@@ -38893,7 +39057,7 @@ function makeFullSuiteRectifyStrategy(story, config2, sink) {
   }
   return {
     name: "full-suite-rectify",
-    appliesTo,
+    appliesTo: claimsFailingTest,
     fixOp: implementerOp,
     buildInput: (findings) => ({
       story,
@@ -40454,27 +40618,37 @@ function flipWithPairs(pairs, snippet) {
   }
   return results;
 }
-function applyBooleanFlip(snippet) {
-  const seen = new Set;
-  const results = [];
-  if (/\btrue\b/.test(snippet)) {
-    const produced = snippet.replace(/\btrue\b/g, "false");
-    seen.add(produced);
-    results.push(produced);
-  }
-  if (/\bfalse\b/.test(snippet)) {
-    const produced = snippet.replace(/\bfalse\b/g, "true");
-    if (!seen.has(produced))
+function makeBooleanFlip(trueLit, falseLit) {
+  return (snippet) => {
+    const seen = new Set;
+    const results = [];
+    if (new RegExp(`\\b${trueLit}\\b`).test(snippet)) {
+      const produced = snippet.replace(new RegExp(`\\b${trueLit}\\b`, "g"), falseLit);
+      seen.add(produced);
       results.push(produced);
-  }
-  return results;
+    }
+    if (new RegExp(`\\b${falseLit}\\b`).test(snippet)) {
+      const produced = snippet.replace(new RegExp(`\\b${falseLit}\\b`, "g"), trueLit);
+      if (!seen.has(produced))
+        results.push(produced);
+    }
+    return results;
+  };
+}
+function makeOperators(prefix, trueLit, falseLit) {
+  return [
+    { id: `${prefix}:cmp-flip`, apply: (snippet) => flipWithPairs(UNIVERSAL_COMPARISON_PAIRS, snippet) },
+    { id: `${prefix}:cmp-bracket-flip`, apply: applyComparisonBracketFlip },
+    { id: `${prefix}:bool-flip`, apply: makeBooleanFlip(trueLit, falseLit) },
+    { id: `${prefix}:arith-flip`, apply: (snippet) => flipWithPairs(ARITHMETIC_PAIRS, snippet) }
+  ];
 }
 function getOperatorsForLanguage(language) {
   if (!language)
     return [];
   return SUPPORTED_LANGUAGES.get(language) ?? [];
 }
-var TS_COMPARISON_PAIRS, COMPARISON_GT, COMPARISON_LT, TS_COMPARISON_BRACKET_FLIP_ID = "ts:cmp-bracket-flip", TS_COMPARISON_FLIP_ID = "ts:cmp-flip", TS_BOOLEAN_FLIP_ID = "ts:bool-flip", TS_ARITHMETIC_PAIRS, TS_ARITHMETIC_FLIP_ID = "ts:arith-flip", TYPESCRIPT_OPERATORS, PYTHON_OPERATORS, GO_OPERATORS, SUPPORTED_LANGUAGES;
+var TS_COMPARISON_PAIRS, UNIVERSAL_COMPARISON_PAIRS, COMPARISON_GT, COMPARISON_LT, ARITHMETIC_PAIRS, TYPESCRIPT_OPERATORS, PYTHON_OPERATORS, GO_OPERATORS, RUST_OPERATORS, SUPPORTED_LANGUAGES;
 var init_operators = __esm(() => {
   TS_COMPARISON_PAIRS = [
     [/==/g, "!="],
@@ -40484,27 +40658,35 @@ var init_operators = __esm(() => {
     [/>=/g, "<="],
     [/<=/g, ">="]
   ];
+  UNIVERSAL_COMPARISON_PAIRS = [
+    [/==/g, "!="],
+    [/!=/g, "=="],
+    [/>=/g, "<="],
+    [/<=/g, ">="]
+  ];
   COMPARISON_GT = /(?<=\s)>(?!=)(?=\s|$)/g;
   COMPARISON_LT = /(?<=\s)<(?!=)(?=\s)/g;
-  TS_ARITHMETIC_PAIRS = [
+  ARITHMETIC_PAIRS = [
     [/\+/g, "-"],
     [/-/g, "+"],
     [/\*/g, "/"],
     [/\//g, "*"]
   ];
   TYPESCRIPT_OPERATORS = [
-    { id: TS_COMPARISON_FLIP_ID, apply: (snippet) => flipWithPairs(TS_COMPARISON_PAIRS, snippet) },
-    { id: TS_COMPARISON_BRACKET_FLIP_ID, apply: applyComparisonBracketFlip },
-    { id: TS_BOOLEAN_FLIP_ID, apply: applyBooleanFlip },
-    { id: TS_ARITHMETIC_FLIP_ID, apply: (snippet) => flipWithPairs(TS_ARITHMETIC_PAIRS, snippet) }
+    { id: "ts:cmp-flip", apply: (snippet) => flipWithPairs(TS_COMPARISON_PAIRS, snippet) },
+    { id: "ts:cmp-bracket-flip", apply: applyComparisonBracketFlip },
+    { id: "ts:bool-flip", apply: makeBooleanFlip("true", "false") },
+    { id: "ts:arith-flip", apply: (snippet) => flipWithPairs(ARITHMETIC_PAIRS, snippet) }
   ];
-  PYTHON_OPERATORS = [];
-  GO_OPERATORS = [];
+  PYTHON_OPERATORS = makeOperators("py", "True", "False");
+  GO_OPERATORS = makeOperators("go", "true", "false");
+  RUST_OPERATORS = makeOperators("rust", "true", "false");
   SUPPORTED_LANGUAGES = new Map([
     ["typescript", TYPESCRIPT_OPERATORS],
     ["javascript", TYPESCRIPT_OPERATORS],
     ["python", PYTHON_OPERATORS],
-    ["go", GO_OPERATORS]
+    ["go", GO_OPERATORS],
+    ["rust", RUST_OPERATORS]
   ]);
 });
 
@@ -40526,7 +40708,8 @@ function generateMutants(input) {
       const line = lines[i];
       const lineNumber = i + 1;
       const trimmed = line.trim();
-      if (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*"))
+      const commentPrefixes = language === "python" ? ["#"] : ["//", "/*", "*"];
+      if (commentPrefixes.some((prefix) => trimmed.startsWith(prefix)))
         continue;
       for (const operator of operators) {
         for (const replacement of applyOperator(operator, line)) {
@@ -41632,7 +41815,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.73.2",
+    version: "0.73.4",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -41733,8 +41916,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("18a1906c"))
-        return "18a1906c";
+      if (/^[0-9a-f]{6,10}$/.test("ec04b570"))
+        return "ec04b570";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -58811,7 +58994,7 @@ async function buildPlanForStrategy(ctx, story, config2, testStrategy, inputs) {
     const fullSuiteGatePhasePresent = Boolean(inputs.fullSuiteGate) && (isThreeSession || regressionMode === "per-story");
     const verifyScopedPhasePresent = !isThreeSession && Boolean(inputs.verifyScoped);
     if (fullSuiteGatePhasePresent || verifyScopedPhasePresent) {
-      strategies.push(makeFullSuiteRectifyStrategy(story, config2, sink));
+      strategies.push(makeFullSuiteRectifyStrategy(story, config2, sink, isThreeSession));
     }
     if (config2.quality.autofix?.enabled !== false) {
       strategies.push(makeAutofixImplementerStrategy(story, config2, sink, {
@@ -58881,7 +59064,8 @@ async function buildPlanForStrategy(ctx, story, config2, testStrategy, inputs) {
         promptSeverityFloor: "info"
       }));
     }
-    nbStrategies.push(makeFullSuiteRectifyStrategy(story, config2, nbSink));
+    const nbHasTestWriterDrainer = isThreeSession && nbf.scope !== "source";
+    nbStrategies.push(makeFullSuiteRectifyStrategy(story, config2, nbSink, nbHasTestWriterDrainer));
     const nbPostValidate = async (findings, validateCtx) => {
       if (nbSink.testEdits.length === 0 && nbSink.mockHandoffs.length === 0)
         return findings;
@@ -63289,6 +63473,264 @@ var init_curator = __esm(() => {
   };
 });
 
+// src/plugins/builtin/reporter-shared/interpolate.ts
+function interpolateHeaders(headers, env2 = process.env) {
+  const resolved = {};
+  const missing = new Set;
+  for (const [key, value] of Object.entries(headers)) {
+    resolved[key] = value.replace(ENV_PLACEHOLDER, (_match, name) => {
+      const v = env2[name];
+      if (v === undefined) {
+        missing.add(name);
+        return "";
+      }
+      return v;
+    });
+  }
+  return { resolved, missing: [...missing] };
+}
+var ENV_PLACEHOLDER;
+var init_interpolate = __esm(() => {
+  ENV_PLACEHOLDER = /\$\{([A-Z0-9_]+)\}/g;
+});
+
+// src/plugins/builtin/reporter-shared/post-json.ts
+async function postJson(url2, body, opts) {
+  const deps = opts.deps ?? _postJsonDeps;
+  const logger = getSafeLogger();
+  try {
+    const res = await deps.fetch(url2, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...opts.headers },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(opts.timeoutMs)
+    });
+    if (!res.ok) {
+      logger?.warn(opts.stage, "Telemetry POST returned non-2xx", { url: url2, status: res.status });
+      return false;
+    }
+    return true;
+  } catch (err) {
+    logger?.warn(opts.stage, "Telemetry POST failed", { url: url2, error: errorMessage(err) });
+    return false;
+  }
+}
+var _postJsonDeps;
+var init_post_json = __esm(() => {
+  init_logger2();
+  _postJsonDeps = { fetch: globalThis.fetch };
+});
+
+// src/plugins/builtin/reporter-shared/index.ts
+var init_reporter_shared = __esm(() => {
+  init_interpolate();
+  init_post_json();
+});
+
+// src/plugins/builtin/otel-reporter/ids.ts
+function randomHex(bytes) {
+  const arr = new Uint8Array(bytes);
+  crypto.getRandomValues(arr);
+  let out = "";
+  for (const b of arr)
+    out += b.toString(16).padStart(2, "0");
+  return out;
+}
+var newTraceId = () => randomHex(16), newSpanId = () => randomHex(8);
+
+// src/plugins/builtin/otel-reporter/otlp.ts
+function attr(key, value) {
+  return typeof value === "number" ? { key, value: { doubleValue: value } } : { key, value: { stringValue: value } };
+}
+function msToUnixNano(ms) {
+  return (BigInt(Math.round(ms)) * 1000000n).toString();
+}
+function buildTracesPayload(p) {
+  const span = {
+    traceId: p.traceId,
+    spanId: p.spanId,
+    name: "nax.run",
+    kind: 1,
+    startTimeUnixNano: p.startUnixNano,
+    endTimeUnixNano: p.endUnixNano,
+    attributes: [
+      attr("feature", p.feature),
+      attr("runId", p.runId),
+      attr("stories.completed", p.storySummary.completed),
+      attr("stories.failed", p.storySummary.failed),
+      attr("stories.skipped", p.storySummary.skipped),
+      attr("stories.paused", p.storySummary.paused),
+      attr("cost.total", p.totalCost)
+    ],
+    events: p.events,
+    status: { code: p.storySummary.failed > 0 ? 2 : 1 }
+  };
+  return {
+    resourceSpans: [
+      {
+        resource: { attributes: [attr("service.name", p.serviceName)] },
+        scopeSpans: [{ scope: { name: "nax" }, spans: [span] }]
+      }
+    ]
+  };
+}
+function buildMetricsPayload(p) {
+  const statusEntries = Object.entries(p.storySummary).filter(([, n]) => n > 0);
+  const storiesSum = {
+    name: "nax.stories.total",
+    sum: {
+      aggregationTemporality: 2,
+      isMonotonic: true,
+      dataPoints: statusEntries.map(([status, count]) => ({
+        asInt: String(count),
+        timeUnixNano: p.timeUnixNano,
+        attributes: [attr("status", status)]
+      }))
+    }
+  };
+  const gauge = (name, value) => ({
+    name,
+    gauge: { dataPoints: [{ asDouble: value, timeUnixNano: p.timeUnixNano }] }
+  });
+  return {
+    resourceMetrics: [
+      {
+        resource: { attributes: [attr("service.name", p.serviceName)] },
+        scopeMetrics: [
+          {
+            scope: { name: "nax" },
+            metrics: [storiesSum, gauge("nax.run.cost", p.totalCost), gauge("nax.run.duration_ms", p.totalDurationMs)]
+          }
+        ]
+      }
+    ]
+  };
+}
+
+// src/plugins/builtin/otel-reporter/index.ts
+function createOtelReporterPlugin(cfg, deps) {
+  const states = new Map;
+  const base = cfg.endpoint?.replace(/\/$/, "");
+  const flush = async (st, endMs, e) => {
+    if (!base)
+      return;
+    const { resolved, missing } = interpolateHeaders(cfg.headers);
+    if (missing.length > 0) {
+      getSafeLogger()?.warn(STAGE, "Skipping OTLP export \u2014 unresolved env vars", { missing });
+      return;
+    }
+    const startUnixNano = msToUnixNano(st.startMs);
+    const endUnixNano = msToUnixNano(endMs);
+    const traces = buildTracesPayload({
+      serviceName: cfg.serviceName,
+      traceId: st.traceId,
+      spanId: st.spanId,
+      startUnixNano,
+      endUnixNano,
+      feature: st.feature,
+      runId: e.runId,
+      storySummary: e.storySummary,
+      totalCost: e.totalCost,
+      events: st.events
+    });
+    const metrics = buildMetricsPayload({
+      serviceName: cfg.serviceName,
+      runId: e.runId,
+      timeUnixNano: endUnixNano,
+      storySummary: e.storySummary,
+      totalCost: e.totalCost,
+      totalDurationMs: e.totalDurationMs
+    });
+    const opts = { headers: resolved, timeoutMs: cfg.timeoutMs, stage: STAGE, deps };
+    await postJson(`${base}/v1/traces`, traces, opts);
+    await postJson(`${base}/v1/metrics`, metrics, opts);
+  };
+  const reporter = {
+    name: STAGE,
+    async onRunStart(event) {
+      states.set(event.runId, {
+        traceId: newTraceId(),
+        spanId: newSpanId(),
+        startMs: Date.parse(event.startTime),
+        feature: event.feature,
+        events: []
+      });
+    },
+    async onStoryComplete(event) {
+      const st = states.get(event.runId);
+      if (!st)
+        return;
+      st.events.push({
+        timeUnixNano: msToUnixNano(st.startMs + event.runElapsedMs),
+        name: "story.complete",
+        attributes: [
+          attr("storyId", event.storyId),
+          attr("status", event.status),
+          attr("cost", event.cost),
+          attr("tier", event.tier),
+          attr("testStrategy", event.testStrategy)
+        ]
+      });
+    },
+    async onRunEnd(event) {
+      const existing = states.get(event.runId);
+      const startMs = existing?.startMs ?? Date.now() - event.totalDurationMs;
+      const st = existing ?? {
+        traceId: newTraceId(),
+        spanId: newSpanId(),
+        startMs,
+        feature: "",
+        events: []
+      };
+      states.delete(event.runId);
+      await flush(st, startMs + event.totalDurationMs, event);
+    }
+  };
+  return {
+    name: STAGE,
+    version: "1.0.0",
+    provides: ["reporter"],
+    extensions: { reporter }
+  };
+}
+var STAGE = "otel-reporter";
+var init_otel_reporter = __esm(() => {
+  init_logger2();
+  init_reporter_shared();
+});
+
+// src/plugins/builtin/webhook-reporter/index.ts
+function createWebhookReporterPlugin(cfg, deps) {
+  const enabledEvent = (event) => cfg.events === undefined || cfg.events.includes(event);
+  const emit = async (type, data) => {
+    if (!cfg.url || !enabledEvent(type))
+      return;
+    const { resolved, missing } = interpolateHeaders(cfg.headers);
+    if (missing.length > 0) {
+      getSafeLogger()?.warn(STAGE2, "Skipping webhook \u2014 unresolved env vars", { missing });
+      return;
+    }
+    await postJson(cfg.url, { type, emittedAt: new Date().toISOString(), data }, { headers: resolved, timeoutMs: cfg.timeoutMs, stage: STAGE2, deps });
+  };
+  const reporter = {
+    name: STAGE2,
+    onRunStart: (event) => emit("onRunStart", event),
+    onStoryComplete: (event) => emit("onStoryComplete", event),
+    onRunEnd: (event) => emit("onRunEnd", event)
+  };
+  return {
+    name: STAGE2,
+    version: "1.0.0",
+    provides: ["reporter"],
+    extensions: { reporter }
+  };
+}
+var STAGE2 = "webhook-reporter";
+var init_webhook_reporter = __esm(() => {
+  init_logger2();
+  init_reporter_shared();
+});
+
 // src/plugins/plugin-logger.ts
 function createPluginLogger(pluginName) {
   const stage = `plugin:${pluginName}`;
@@ -63644,7 +64086,7 @@ function extractPluginName(pluginPath) {
   }
   return basename12.replace(/\.(ts|js|mjs)$/, "");
 }
-async function loadPlugins(globalDir, projectDir, configPlugins, projectRoot, disabledPlugins, isTestFileFn) {
+async function loadPlugins(globalDir, projectDir, configPlugins, projectRoot, disabledPlugins, isTestFileFn, reporters) {
   const loadedPlugins = [];
   const builtinPostRunActions = [];
   const effectiveProjectRoot = projectRoot || projectDir;
@@ -63688,6 +64130,32 @@ async function loadPlugins(globalDir, projectDir, configPlugins, projectRoot, di
   } else {
     logger?.info("plugins", `Skipping disabled plugin: '${autoRoutePlugin.name}' (built-in)`);
   }
+  const reporterFactories = reporters ? [
+    {
+      name: "webhook-reporter",
+      enabled: reporters.webhook.enabled,
+      make: () => createWebhookReporterPlugin(reporters.webhook)
+    },
+    {
+      name: "otel-reporter",
+      enabled: reporters.otel.enabled,
+      make: () => createOtelReporterPlugin(reporters.otel)
+    }
+  ] : [];
+  for (const { name, enabled: reporterEnabled, make } of reporterFactories) {
+    if (!reporterEnabled)
+      continue;
+    if (disabledSet.has(name)) {
+      logger?.info("plugins", `Skipping disabled plugin: '${name}' (built-in)`);
+      continue;
+    }
+    const plugin = make();
+    if (plugin.setup) {
+      await plugin.setup({}, createPluginLogger(plugin.name));
+    }
+    loadedPlugins.push({ plugin, source: { type: "builtin", path: plugin.name } });
+    pluginNames.add(plugin.name);
+  }
   const globalPlugins = await discoverPlugins(globalDir, isTestFileFn);
   for (const plugin of globalPlugins) {
     const pluginName = extractPluginName(plugin.path);
@@ -63852,6 +64320,8 @@ var init_loader4 = __esm(() => {
   init_auto_pr();
   init_auto_route();
   init_curator();
+  init_otel_reporter();
+  init_webhook_reporter();
   init_plugin_logger();
   init_registry5();
   init_validator();
@@ -64582,44 +65052,210 @@ var init_crash_recovery = __esm(() => {
   init_crash_heartbeat();
 });
 
-// src/acceptance/fix-diagnosis.ts
-function parseImportStatements(content) {
-  const importRegex = /import\s+(?:{[^}]+}|[^;]+)\s+from\s+["']([^"']+)["']/g;
-  const imports = [];
-  const regexMatch = content.matchAll(importRegex);
-  for (const match of regexMatch) {
-    imports.push(match[1]);
+// src/acceptance/import-resolution.ts
+import { resolve as resolve16, sep as sep5 } from "path";
+function languageFromExtension(testFilePath) {
+  if (!testFilePath)
+    return;
+  const dot = testFilePath.lastIndexOf(".");
+  if (dot < 0)
+    return;
+  return EXT_LANGUAGE.get(testFilePath.slice(dot).toLowerCase());
+}
+function isResolvedLanguage(lang) {
+  return lang !== undefined && SUPPORTED.has(lang);
+}
+async function resolveLanguage(opts) {
+  const explicit = opts.language ?? languageFromExtension(opts.testFilePath);
+  if (isResolvedLanguage(explicit))
+    return explicit;
+  const detected = await detectLanguage(opts.packageDir);
+  if (isResolvedLanguage(detected))
+    return detected;
+  return "typescript";
+}
+async function readCapped(relPath, packageDir) {
+  const resolvedPackageDir = resolve16(packageDir);
+  const fullPath = resolve16(resolvedPackageDir, relPath);
+  if (fullPath !== resolvedPackageDir && !fullPath.startsWith(resolvedPackageDir + sep5)) {
+    return null;
+  }
+  try {
+    const text = await Bun.file(fullPath).text();
+    const content = text.split(`
+`).slice(0, MAX_FILE_LINES2).join(`
+`);
+    return { path: relPath, content };
+  } catch {
+    return null;
   }
-  return imports;
 }
-function resolveImportPaths(imports, _workdir) {
-  const resolved = [];
-  for (const imp of imports) {
-    if (imp.startsWith(".")) {
-      resolved.push(imp);
-    }
+function parseTsImports(content) {
+  const specs = [];
+  for (const m of content.matchAll(TS_IMPORT_RE)) {
+    if (m[1].startsWith("."))
+      specs.push(m[1]);
   }
-  return resolved.slice(0, MAX_SOURCE_FILES);
+  return specs;
 }
-async function loadSourceFilesForDiagnosis(testFileContent, workdir) {
-  const imports = parseImportStatements(testFileContent);
-  const relativeImports = resolveImportPaths(imports, workdir);
-  const results = await Promise.all(relativeImports.map((imp) => readSourceFileContent(imp, workdir)));
-  return results.filter((f) => f !== null);
+function tsCandidates(spec) {
+  if (TS_EXTS.some((e) => spec.endsWith(e)))
+    return [spec];
+  const out = [];
+  for (const e of TS_EXTS)
+    out.push(`${spec}${e}`);
+  for (const e of TS_EXTS)
+    out.push(`${spec}/index${e}`);
+  return out;
 }
-async function readSourceFileContent(filePath, workdir) {
+function parsePythonImports(content) {
+  const modules = [];
+  for (const m of content.matchAll(PY_IMPORT_LINE_RE)) {
+    const fromModule = m[1];
+    const importList = m[2];
+    if (fromModule !== undefined) {
+      if (fromModule)
+        modules.push(fromModule);
+    } else if (importList) {
+      for (const part of importList.split(",")) {
+        const mod = part.trim().split(/\s+as\s+/)[0].trim();
+        if (mod)
+          modules.push(mod);
+      }
+    }
+  }
+  return modules;
+}
+function pythonCandidates(module) {
+  const base = module.replace(/\./g, "/");
+  return [`${base}.py`, `${base}/__init__.py`];
+}
+function parseRustUses(content) {
+  const paths = [];
+  for (const m of content.matchAll(RUST_USE_RE))
+    paths.push(m[1]);
+  return paths;
+}
+function rustCandidates(usePath) {
+  const rest = usePath.split("::").slice(1);
+  if (rest.length === 0)
+    return [];
+  const base = `src/${rest.join("/")}`;
+  const candidates = [`${base}.rs`, `${base}/mod.rs`];
+  if (rest.length > 1) {
+    const parent = `src/${rest.slice(0, -1).join("/")}`;
+    candidates.push(`${parent}.rs`, `${parent}/mod.rs`);
+  } else {
+    candidates.push("src/lib.rs");
+  }
+  return candidates;
+}
+function parseGoImports(content) {
+  const paths = [];
+  for (const m of content.matchAll(GO_SINGLE_IMPORT_RE))
+    paths.push(m[1]);
+  for (const block of content.matchAll(GO_IMPORT_BLOCK_RE)) {
+    for (const line of block[1].matchAll(GO_BLOCK_LINE_RE))
+      paths.push(line[1]);
+  }
+  return paths;
+}
+async function readGoModulePrefix(packageDir) {
   try {
-    const fullPath = `${workdir}/${filePath}`;
-    const file3 = await Bun.file(fullPath).text();
-    const lines = file3.split(`
-`).slice(0, MAX_FILE_LINES2);
-    return { path: filePath, content: lines.join(`
-`) };
+    const text = await Bun.file(`${packageDir}/go.mod`).text();
+    const m = text.match(/^\s*module\s+(\S+)/m);
+    return m ? m[1] : null;
   } catch {
     return null;
   }
 }
-var MAX_SOURCE_FILES = 5, MAX_FILE_LINES2 = 500;
+async function resolveGoCandidates(content, packageDir) {
+  const prefix = await readGoModulePrefix(packageDir);
+  if (!prefix)
+    return [];
+  const candidates = [];
+  for (const imp of parseGoImports(content)) {
+    if (imp !== prefix && !imp.startsWith(`${prefix}/`))
+      continue;
+    const relDir = imp === prefix ? "." : imp.slice(prefix.length + 1);
+    try {
+      for (const file3 of new Bun.Glob("*.go").scanSync({ cwd: `${packageDir}/${relDir}`, absolute: false })) {
+        if (file3.endsWith("_test.go"))
+          continue;
+        candidates.push(relDir === "." ? file3 : `${relDir}/${file3}`);
+      }
+    } catch {}
+  }
+  return candidates;
+}
+async function collectCandidates(lang, opts) {
+  switch (lang) {
+    case "typescript":
+    case "javascript":
+      return parseTsImports(opts.testFileContent).flatMap(tsCandidates);
+    case "python":
+      return parsePythonImports(opts.testFileContent).flatMap(pythonCandidates);
+    case "rust":
+      return parseRustUses(opts.testFileContent).flatMap(rustCandidates);
+    case "go":
+      return resolveGoCandidates(opts.testFileContent, opts.packageDir);
+    default:
+      return [];
+  }
+}
+async function readCandidates(candidates, packageDir) {
+  const seen = new Set;
+  const results = [];
+  for (const rel of candidates) {
+    if (results.length >= MAX_SOURCE_FILES)
+      break;
+    if (seen.has(rel))
+      continue;
+    seen.add(rel);
+    const file3 = await readCapped(rel, packageDir);
+    if (file3)
+      results.push(file3);
+  }
+  return results;
+}
+async function resolveSourceFiles(opts) {
+  const lang = await resolveLanguage(opts);
+  const candidates = await collectCandidates(lang, opts);
+  return readCandidates(candidates, opts.packageDir);
+}
+var MAX_SOURCE_FILES = 5, MAX_FILE_LINES2 = 500, SUPPORTED, EXT_LANGUAGE, TS_IMPORT_RE, TS_EXTS, PY_IMPORT_LINE_RE, RUST_USE_RE, GO_SINGLE_IMPORT_RE, GO_IMPORT_BLOCK_RE, GO_BLOCK_LINE_RE;
+var init_import_resolution = __esm(() => {
+  init_project();
+  SUPPORTED = new Set(["typescript", "javascript", "python", "go", "rust"]);
+  EXT_LANGUAGE = new Map([
+    [".ts", "typescript"],
+    [".tsx", "typescript"],
+    [".mts", "typescript"],
+    [".cts", "typescript"],
+    [".js", "javascript"],
+    [".jsx", "javascript"],
+    [".mjs", "javascript"],
+    [".cjs", "javascript"],
+    [".py", "python"],
+    [".go", "go"],
+    [".rs", "rust"]
+  ]);
+  TS_IMPORT_RE = /import\s+(?:{[^}]+}|[^;'"]+)\s+from\s+["']([^"']+)["']/g;
+  TS_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"];
+  PY_IMPORT_LINE_RE = /^\s*(?:from\s+\.*([\w.]*)\s+import\s+|import\s+([\w.]+(?:\s*,\s*[\w.]+)*))/gm;
+  RUST_USE_RE = /^\s*use\s+(crate(?:::\w+)*|(?:super|self)(?:::\w+)?)/gm;
+  GO_SINGLE_IMPORT_RE = /^\s*import\s+"([^"]+)"/gm;
+  GO_IMPORT_BLOCK_RE = /import\s*\(([\s\S]*?)\)/g;
+  GO_BLOCK_LINE_RE = /"([^"]+)"/g;
+});
+
+// src/acceptance/fix-diagnosis.ts
+async function loadSourceFilesForDiagnosis(opts) {
+  return resolveSourceFiles(opts);
+}
+var init_fix_diagnosis = __esm(() => {
+  init_import_resolution();
+});
 
 // src/execution/lifecycle/acceptance-helpers.ts
 import path23 from "path";
@@ -64800,7 +65436,11 @@ async function resolveAcceptanceDiagnosis(opts) {
       confidence: 0.9
     };
   }
-  const sourceFiles = await loadSourceFilesForDiagnosis(diagnosisOpts.testFileContent, diagnosisOpts.workdir);
+  const sourceFiles = await loadSourceFilesForDiagnosis({
+    testFileContent: diagnosisOpts.testFileContent,
+    packageDir: diagnosisOpts.workdir,
+    testFilePath: diagnosisOpts.acceptanceTestPath
+  });
   return await _diagnosisDeps.callOp(fixCallCtx(ctx), acceptanceDiagnoseOp, {
     testOutput: diagnosisOpts.testOutput,
     testFileContent: diagnosisOpts.testFileContent,
@@ -64811,6 +65451,7 @@ async function resolveAcceptanceDiagnosis(opts) {
 }
 var _diagnosisDeps;
 var init_acceptance_fix2 = __esm(() => {
+  init_fix_diagnosis();
   init_errors();
   init_logger2();
   init_operations();
@@ -69317,7 +69958,7 @@ var init_runner_execution = __esm(() => {
 
 // src/execution/status-file.ts
 import { rename as rename2, unlink as unlink3 } from "fs/promises";
-import { resolve as resolve16 } from "path";
+import { resolve as resolve17 } from "path";
 function countProgress(prd) {
   const stories = prd.userStories;
   const passed = stories.filter((s) => s.status === "passed").length;
@@ -69362,7 +70003,7 @@ function buildStatusSnapshot(state) {
   return snapshot;
 }
 async function writeStatusFile(filePath, status) {
-  const resolvedPath = resolve16(filePath);
+  const resolvedPath = resolve17(filePath);
   if (filePath.includes("../") || filePath.includes("..\\")) {
     throw new Error("Invalid status file path: path traversal detected");
   }
@@ -70370,7 +71011,7 @@ async function setupRun(options) {
     const configPlugins = config2.plugins || [];
     const resolvedPatterns = await resolveTestFilePatterns(config2, workdir);
     const isTestFileFn = (filename) => resolvedPatterns.regex.some((re) => re.test(filename));
-    const pluginRegistry = await loadPlugins(globalPluginsDir, projectPluginsDir, configPlugins, workdir, config2.disabledPlugins, isTestFileFn);
+    const pluginRegistry = await loadPlugins(globalPluginsDir, projectPluginsDir, configPlugins, workdir, config2.disabledPlugins, isTestFileFn, config2.reporters);
     clearCache();
     logger?.info("plugins", `Loaded ${pluginRegistry.plugins.length} plugins`, {
       plugins: pluginRegistry.plugins.map((p) => ({ name: p.name, version: p.version, provides: p.provides }))
@@ -71300,14 +71941,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
       actScopeDepth = prevActScopeDepth;
     }
-    function recursivelyFlushAsyncActWork(returnValue, resolve17, reject) {
+    function recursivelyFlushAsyncActWork(returnValue, resolve18, reject) {
       var queue = ReactSharedInternals.actQueue;
       if (queue !== null)
         if (queue.length !== 0)
           try {
             flushActQueue(queue);
             enqueueTask(function() {
-              return recursivelyFlushAsyncActWork(returnValue, resolve17, reject);
+              return recursivelyFlushAsyncActWork(returnValue, resolve18, reject);
             });
             return;
           } catch (error48) {
@@ -71315,7 +71956,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           }
         else
           ReactSharedInternals.actQueue = null;
-      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve17(returnValue);
+      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve18(returnValue);
     }
     function flushActQueue(queue) {
       if (!isFlushing) {
@@ -71491,14 +72132,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
         });
         return {
-          then: function(resolve17, reject) {
+          then: function(resolve18, reject) {
             didAwaitActCall = true;
             thenable.then(function(returnValue) {
               popActScope(prevActQueue, prevActScopeDepth);
               if (prevActScopeDepth === 0) {
                 try {
                   flushActQueue(queue), enqueueTask(function() {
-                    return recursivelyFlushAsyncActWork(returnValue, resolve17, reject);
+                    return recursivelyFlushAsyncActWork(returnValue, resolve18, reject);
                   });
                 } catch (error$0) {
                   ReactSharedInternals.thrownErrors.push(error$0);
@@ -71509,7 +72150,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
                   reject(_thrownError);
                 }
               } else
-                resolve17(returnValue);
+                resolve18(returnValue);
             }, function(error48) {
               popActScope(prevActQueue, prevActScopeDepth);
               0 < ReactSharedInternals.thrownErrors.length ? (error48 = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error48)) : reject(error48);
@@ -71525,11 +72166,11 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       if (0 < ReactSharedInternals.thrownErrors.length)
         throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
       return {
-        then: function(resolve17, reject) {
+        then: function(resolve18, reject) {
           didAwaitActCall = true;
           prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
-            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve17, reject);
-          })) : resolve17(returnValue$jscomp$0);
+            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve18, reject);
+          })) : resolve18(returnValue$jscomp$0);
         }
       };
     };
@@ -74371,8 +75012,8 @@ It can also happen if the client has a browser extension installed which messes
         currentEntangledActionThenable = {
           status: "pending",
           value: undefined,
-          then: function(resolve17) {
-            entangledListeners.push(resolve17);
+          then: function(resolve18) {
+            entangledListeners.push(resolve18);
           }
         };
       }
@@ -74396,8 +75037,8 @@ It can also happen if the client has a browser extension installed which messes
         status: "pending",
         value: null,
         reason: null,
-        then: function(resolve17) {
-          listeners.push(resolve17);
+        then: function(resolve18) {
+          listeners.push(resolve18);
         }
       };
       thenable.then(function() {
@@ -86358,13 +86999,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           return false;
         }
         function utils_getInObject(object2, path31) {
-          return path31.reduce(function(reduced, attr) {
+          return path31.reduce(function(reduced, attr2) {
             if (reduced) {
-              if (utils_hasOwnProperty.call(reduced, attr)) {
-                return reduced[attr];
+              if (utils_hasOwnProperty.call(reduced, attr2)) {
+                return reduced[attr2];
               }
               if (typeof reduced[Symbol.iterator] === "function") {
-                return Array.from(reduced)[attr];
+                return Array.from(reduced)[attr2];
               }
             }
             return null;
@@ -97359,9 +98000,9 @@ The error thrown in the component is:
             getEnvironmentNames
           }, internalMcpFunctions);
         }
-        function decorate(object2, attr, fn) {
-          var old = object2[attr];
-          object2[attr] = function(instance2) {
+        function decorate(object2, attr2, fn) {
+          var old = object2[attr2];
+          object2[attr2] = function(instance2) {
             return fn.call(this, old, arguments);
           };
           return old;
@@ -106460,7 +107101,7 @@ function ansiRegex({ onlyFirst = false } = {}) {
 
 // node_modules/strip-ansi/index.js
 var regex = ansiRegex();
-function stripAnsi(string4) {
+function stripAnsi2(string4) {
   if (typeof string4 !== "string") {
     throw new TypeError(`Expected a \`string\`, got \`${typeof string4}\``);
   }
@@ -106509,7 +107150,7 @@ function stringWidth(string4, options = {}) {
     countAnsiEscapeCodes = false
   } = options;
   if (!countAnsiEscapeCodes) {
-    string4 = stripAnsi(string4);
+    string4 = stripAnsi2(string4);
   }
   if (string4.length === 0) {
     return 0;
@@ -106740,7 +107381,7 @@ var wrapWord = (rows, word, columns) => {
   const characters = [...word];
   let isInsideEscape = false;
   let isInsideLinkEscape = false;
-  let visible = stringWidth(stripAnsi(rows.at(-1)));
+  let visible = stringWidth(stripAnsi2(rows.at(-1)));
   for (const [index, character] of characters.entries()) {
     const characterLength = stringWidth(character);
     if (visible + characterLength <= columns) {
@@ -107026,7 +107667,7 @@ function stringWidth2(input, options = {}) {
   } = options;
   let string4 = input;
   if (!countAnsiEscapeCodes) {
-    string4 = stripAnsi(string4);
+    string4 = stripAnsi2(string4);
   }
   if (string4.length === 0) {
     return 0;
@@ -109906,8 +110547,8 @@ class Ink {
     }
   }
   async waitUntilExit() {
-    this.exitPromise ||= new Promise((resolve17, reject2) => {
-      this.resolveExitPromise = resolve17;
+    this.exitPromise ||= new Promise((resolve18, reject2) => {
+      this.resolveExitPromise = resolve18;
       this.rejectExitPromise = reject2;
     });
     if (!this.beforeExitHandler) {
@@ -112161,7 +112802,7 @@ async function promptForConfirmation(question) {
   if (!process.stdin.isTTY) {
     return true;
   }
-  return new Promise((resolve17) => {
+  return new Promise((resolve18) => {
     process.stdout.write(source_default.bold(`${question} [Y/n] `));
     process.stdin.setRawMode(true);
     process.stdin.resume();
@@ -112174,9 +112815,9 @@ async function promptForConfirmation(question) {
       process.stdout.write(`
 `);
       if (answer === "n") {
-        resolve17(false);
+        resolve18(false);
       } else {
-        resolve17(true);
+        resolve18(true);
       }
     };
     process.stdin.on("data", handler);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nathapp/nax",
-  "version": "0.73.2",
+  "version": "0.73.4",
   "description": "AI Coding Agent Orchestrator — loops until done",
   "type": "module",
   "bin": {