@nathapp/nax 0.67.16 → 0.67.18

package/dist/nax.js

@@ -29750,11 +29750,14 @@ function buildStorySection(story) {
 function buildVerdictSection(story) {
   return `# Verdict Instructions
 
-## Write Verdict File
+## Write Verdict File and Emit JSON in Final Reply
 
-After completing your verification, you **MUST** write a verdict file at the **project root**:
+After completing your verification, you **MUST** do BOTH of the following:
 
-**File:** \`.nax-verifier-verdict.json\`
+1. Write the verdict file at the **project root**: \`.nax-verifier-verdict.json\`
+2. Emit the same verdict JSON as the FINAL content of your reply \u2014 no prose
+   before or after, no markdown fences. Your reply must end with a closing
+   brace \`}\` on its own line. The orchestrator parses your reply as JSON.
 
 Set \`approved: true\` when ALL of these conditions are met:
 - All story-scoped tests pass (the orchestrator already attempted the full-suite gate \u2014 you only need to verify the story's own tests)
@@ -29778,7 +29781,7 @@ Set \`approved: false\` when ANY of these conditions are true:
 - \`fixes\` \u2014 keep this empty; the verifier must not apply code or test fixes
 - \`reasoning\` \u2014 brief summary of your overall assessment
 
-When done, do not commit code changes. Only write the verdict file.`;
+When done, do not commit code changes. Write the verdict file, then end your reply with the JSON object.`;
 }
 
 // src/prompts/sections/conventions.ts
@@ -30164,6 +30167,24 @@ class TddPromptBuilder {
     const isolation = role === "test-writer" ? opts.lite ? "lite" : "strict" : undefined;
     return TddPromptBuilder.for(role, { variant, isolation }).withLoader(workdir, config2).story(story).context(opts.contextMarkdown).v2FeatureContext(opts.contextBundle?.pushMarkdown).featureContext(opts.contextBundle ? undefined : opts.featureContextMarkdown).constitution(opts.constitution).testCommand(config2.quality?.commands?.test).hermeticConfig(config2.quality?.testing).build();
   }
+  static verdictRetry() {
+    return `Your previous reply could not be parsed as a valid VerifierVerdict JSON object.
+` + `Re-emit the verdict as the FINAL content of your reply.
+` + `Output ONLY the JSON object \u2014 no markdown fences, no explanation, no prose.
+` + `The reply must start with { and end with } on its own line.
+` + "Required top-level fields: version, approved, tests, testModifications, acceptanceCriteria, quality, fixes, reasoning.";
+  }
+  static verdictRetryCondensed() {
+    return `Your previous reply was truncated and could not be parsed as valid JSON.
+` + `Re-emit a CONDENSED verdict that omits the acceptanceCriteria.criteria[] entries:
+` + `- Keep acceptanceCriteria.allMet (boolean) but use criteria=[] (empty array).
+` + `- Keep quality.issues=[] and fixes=[] empty.
+` + `- Set testModifications.reasoning to a single sentence.
+` + `- Set reasoning to a single sentence.
+` + `Output ONLY the JSON object \u2014 no markdown fences, no prose.
+` + `Schema (minimal):
+` + `{"version":1,"approved":boolean,"tests":{"allPassing":boolean,"passCount":number,"failCount":number},"testModifications":{"detected":boolean,"files":[],"legitimate":boolean,"reasoning":"..."},"acceptanceCriteria":{"allMet":boolean,"criteria":[]},"quality":{"rating":"good"|"acceptable"|"poor","issues":[]},"fixes":[],"reasoning":"..."}`;
+  }
   s(id, content) {
     return { id, content, overridable: false };
   }
@@ -31013,6 +31034,7 @@ Severity guide:
 - If you cannot quote an exact excerpt that proves your point, downgrade the finding to \`"unverifiable"\` rather than fabricating a quote.
 
 **AC-grounding rule \u2014 required for every "error" finding:**
+- Do NOT write an \`acQuote\` that does not appear verbatim in the listed AC text. If you cannot find an exact verbatim match, set severity to \`warning\` \u2014 never approximate, paraphrase, or synthesise a quote. A finding dropped for a fabricated quote wastes a review cycle and is worse than a correctly classified \`warning\`.
 - \`acQuote\` must be a verbatim substring of one AC bullet (from the Acceptance Criteria above) that names or constrains the exact **symbol** you are flagging \u2014 not merely the file the symbol lives in.
 - \`acIndex\` is the 1-based position of that AC bullet in the list.
 - Copy \`acQuote\` **exactly** from the AC text, including any backticks, asterisks, or punctuation. Do not paraphrase, strip formatting, or rewrite.
@@ -32776,6 +32798,7 @@ function recordAdversarialAudit(opts) {
     looksLikeFail: opts.looksLikeFail,
     failOpen: opts.failOpen,
     passed: opts.passed,
+    passReason: opts.passReason,
     blockingThreshold: opts.blockingThreshold,
     result: opts.result,
     advisoryFindings: opts.advisoryFindings,
@@ -33109,6 +33132,46 @@ ${formatFindings(blockingFindings)}` : "Adversarial review failed (no findings)"
     };
   }
   if (!opResult.passed && acDropped.length > 0) {
+    const allHallucinated = acDropped.every((d) => d.code === "ac_quote_not_substring");
+    if (allHallucinated) {
+      const demotedFindings = toAdversarialReviewFindings(acDropped.map((d) => ({ ...d.finding, severity: "warning", acQuote: undefined, acIndex: undefined })));
+      const existingAdvisory = advisoryFindings.length > 0 ? toAdversarialReviewFindings(advisoryFindings) : [];
+      const allAdvisory = [...existingAdvisory, ...demotedFindings];
+      logger?.warn("review", "Adversarial review passed: all blocking findings discarded as hallucinated AC quotes", {
+        storyId: story.id,
+        durationMs,
+        droppedCount: acDropped.length,
+        drops: acDropped.map((d) => ({ file: d.finding.file, issue: d.finding.issue }))
+      });
+      recordAdversarialAudit({
+        runtime,
+        workdir,
+        projectDir,
+        storyId: story.id,
+        featureName,
+        parsed: true,
+        failOpen: false,
+        passed: true,
+        passReason: "ac_quote_not_substring_demoted",
+        blockingThreshold: threshold,
+        result: { passed: true, findings: [] },
+        advisoryFindings: allAdvisory.length > 0 ? allAdvisory : undefined,
+        diffAvailable,
+        adversarialDropAnalysis,
+        adversarialAcceptAnalysis: []
+      });
+      return {
+        check: "adversarial",
+        success: true,
+        passReason: "ac_quote_not_substring_demoted",
+        command: "",
+        exitCode: 0,
+        output: `Adversarial review passed: ${acDropped.length} blocking finding(s) demoted to advisory \u2014 all cited AC quotes were fabricated and could not be validated.`,
+        durationMs,
+        advisoryFindings: allAdvisory.length > 0 ? allAdvisory : undefined,
+        cost: llmCost
+      };
+    }
     logger?.warn("review", "Adversarial review fail-closed: blocking findings dropped as ungrounded", {
       storyId: story.id,
       durationMs,
@@ -36874,6 +36937,29 @@ var init_verdict = __esm(() => {
 });
 
 // src/operations/verify.ts
+function parseVerdictFromStdout(output, _input, _ctx) {
+  if (!output || !output.trim()) {
+    throw new ParseValidationError("verifier produced no stdout");
+  }
+  const raw = tryParseLLMJson(output);
+  if (!raw || typeof raw !== "object") {
+    throw new ParseValidationError("verifier stdout is not a JSON object");
+  }
+  const verdict = isValidVerdict(raw) ? raw : coerceVerdict(raw);
+  if (!verdict) {
+    throw new ParseValidationError("verifier stdout JSON missing required VerifierVerdict fields");
+  }
+  const categorization = categorizeVerdict(verdict, verdict.tests.allPassing === true);
+  return {
+    success: categorization.success,
+    filesChanged: [],
+    estimatedCostUsd: 0,
+    durationMs: 0,
+    output,
+    ...categorization.failureCategory && { failureCategory: categorization.failureCategory },
+    ...categorization.reviewReason && { reviewReason: categorization.reviewReason }
+  };
+}
 async function runVerifierIsolation(beforeRef, ctx) {
   if (!beforeRef)
     return;
@@ -36882,16 +36968,31 @@ async function runVerifierIsolation(beforeRef, ctx) {
 }
 var verifierOp;
 var init_verify = __esm(() => {
+  init_retry();
   init_config();
+  init_tdd_builder();
   init_isolation();
   init_verdict();
-  init__session_output();
   verifierOp = {
     kind: "run",
     name: "verifier",
     stage: "verify",
     session: { role: "verifier", lifetime: "fresh" },
     config: tddConfigSelector,
+    retry: makeParseRetryStrategy({
+      validate: (parsed) => {
+        if (!parsed || typeof parsed !== "object")
+          return false;
+        const r = parsed;
+        return isValidVerdict(r) || coerceVerdict(r) !== null;
+      },
+      reviewerKind: "verifier",
+      maxAttempts: 2,
+      prompts: {
+        invalid: () => TddPromptBuilder.verdictRetry(),
+        truncated: () => TddPromptBuilder.verdictRetryCondensed()
+      }
+    }),
     build(input, _ctx) {
       if (input.promptMarkdown?.trim()) {
         return {
@@ -36908,13 +37009,8 @@ var init_verify = __esm(() => {
         }
       };
     },
-    parse(output, _input, _ctx) {
-      const envelope = parseSessionJsonOutput(output);
-      return { ...envelope, estimatedCostUsd: 0, durationMs: 0 };
-    },
+    parse: parseVerdictFromStdout,
     async verify(parsed, input, ctx) {
-      if (!parsed.success)
-        return null;
       const isolation = await runVerifierIsolation(input.beforeRef, ctx);
       return isolation ? { ...parsed, isolation } : parsed;
     },
@@ -36922,20 +37018,28 @@ var init_verify = __esm(() => {
       const packageDir = verifyCtx.packageView.packageDir;
       try {
         const verdict = await readVerdict(packageDir);
-        if (!verdict)
-          return null;
-        const testsAllPassing = verdict.tests.allPassing === true;
-        const categorization = categorizeVerdict(verdict, testsAllPassing);
-        const isolation = await runVerifierIsolation(input.beforeRef, verifyCtx);
+        if (verdict) {
+          const testsAllPassing = verdict.tests.allPassing === true;
+          const categorization = categorizeVerdict(verdict, testsAllPassing);
+          const isolation = await runVerifierIsolation(input.beforeRef, verifyCtx);
+          return {
+            success: categorization.success,
+            filesChanged: [],
+            estimatedCostUsd: 0,
+            durationMs: 0,
+            output: "",
+            ...categorization.failureCategory && { failureCategory: categorization.failureCategory },
+            ...categorization.reviewReason && { reviewReason: categorization.reviewReason },
+            ...isolation && { isolation }
+          };
+        }
         return {
-          success: categorization.success,
+          success: false,
           filesChanged: [],
           estimatedCostUsd: 0,
           durationMs: 0,
           output: "",
-          ...categorization.failureCategory && { failureCategory: categorization.failureCategory },
-          ...categorization.reviewReason && { reviewReason: categorization.reviewReason },
-          ...isolation && { isolation }
+          reviewReason: "verifier produced unparseable verdict in stdout after retries and no usable verdict file on disk"
         };
       } finally {
         await cleanupVerdict(packageDir);
@@ -52779,10 +52883,13 @@ async function refreshReviewInputForDispatch(opName, input) {
     return fallback;
   }
 }
-function formatPhaseResultMessage(opName, success2) {
+function formatPhaseResultMessage(opName, success2, stage) {
   if (opName === "greenfield-gate") {
     return success2 ? "Greenfield-gate: pre-existing tests detected (not greenfield) \u2014 proceeding with normal TDD" : "Greenfield-gate: no pre-existing tests \u2014 greenfield run, pausing TDD test-writer";
   }
+  if (stage === "rectification") {
+    return `Rectification strategy completed: ${opName}`;
+  }
   return success2 ? `Phase passed: ${opName}` : `Phase failed: ${opName}`;
 }
 function isSlot(value) {
@@ -52975,7 +53082,7 @@ function logUnifiedReviewPhaseStart(storyId, opName) {
     logger?.info("review", "Running adversarial check", { storyId });
   }
 }
-function logDeterministicPhaseOutcome(storyId, opName, output, durationMs, isTddPhase) {
+function logDeterministicPhaseOutcome(storyId, opName, output, durationMs, isTddPhase, stage) {
   if (isTddPhase)
     return;
   if (opName === "semantic-review" || opName === "adversarial-review")
@@ -52992,7 +53099,11 @@ function logDeterministicPhaseOutcome(storyId, opName, output, durationMs, isTdd
     data.findingsCount = findingsCount;
   if (status !== undefined)
     data.status = status;
-  const message = formatPhaseResultMessage(opName, success2);
+  const message = formatPhaseResultMessage(opName, success2, stage);
+  if (stage === "rectification") {
+    logger?.info("story-orchestrator", message, data);
+    return;
+  }
   if (success2) {
     logger?.info("story-orchestrator", message, data);
   } else {
@@ -53069,7 +53180,7 @@ async function runPhase(ctx, slot, phaseCosts, phaseOutputs, isThreeSession = fa
     phaseOutputs[opName] = output;
     emitReviewDecision(ctx, opName, output);
     logUnifiedReviewPhaseResult(ctx.storyId, opName, output);
-    logDeterministicPhaseOutcome(ctx.storyId, opName, output, Date.now() - phaseStartedAt, isTddPhase);
+    logDeterministicPhaseOutcome(ctx.storyId, opName, output, Date.now() - phaseStartedAt, isTddPhase, slot.op.stage);
     if (isTddPhase) {
       const durationMs = Date.now() - phaseStartedAt;
       logger?.info("tdd", `Session complete: ${opName}`, {
@@ -53205,14 +53316,7 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs) {
       storyId: ctx.storyId
     });
   }
-  const exhaustedReasons = new Set([
-    "max-attempts-total",
-    "max-attempts-per-strategy",
-    "bail-when",
-    "no-strategy",
-    "agent-gave-up"
-  ]);
-  if (exhaustedReasons.has(cycleResult.exitReason) && cycleResult.finalFindings.length > 0) {
+  if (EXHAUSTED_EXIT_REASONS.has(cycleResult.exitReason) && cycleResult.finalFindings.length > 0) {
     return { rectificationExhausted: true, unfixedFindings: cycleResult.finalFindings };
   }
   return {};
@@ -53260,6 +53364,7 @@ class ExecutionPlan {
     }
     const rectResult = await runRectification(this.ctx, this.state, phaseCosts, phaseOutputs);
     if (this.state.rectification && !rectResult.rectificationExhausted) {
+      let resumeRectifyUsed = false;
       for (const phase of collectOrderedPhases(this.state)) {
         const name = phase.slot.op.name;
         if (name in phaseOutputs && phasePassed(name, phaseOutputs[name], this.ctx.storyId)) {
@@ -53276,10 +53381,27 @@ class ExecutionPlan {
           throw error48;
         }
         if (!phasePassed(name, phaseOutputs[name], this.ctx.storyId)) {
+          if (!resumeRectifyUsed) {
+            resumeRectifyUsed = true;
+            logger?.info("story-orchestrator", "Phase failed in post-rectification resume \u2014 invoking second rectification pass", { storyId: this.ctx.storyId, phase: name, source: "post-rectification-resume" });
+            const secondRect = await runRectification(this.ctx, this.state, phaseCosts, phaseOutputs);
+            if (secondRect.rectificationExhausted) {
+              logger?.warn("story-orchestrator", "Second rectification pass exhausted \u2014 terminal failure", {
+                storyId: this.ctx.storyId,
+                phase: name,
+                source: "post-rectification-resume"
+              });
+              break;
+            }
+            if (phasePassed(name, phaseOutputs[name], this.ctx.storyId)) {
+              continue;
+            }
+          }
           logger?.warn("story-orchestrator", "Terminal phase failure (post-rectification resume \u2014 bypasses rectification)", {
             storyId: this.ctx.storyId,
             phase: name,
-            source: "post-rectification-resume"
+            source: "post-rectification-resume",
+            secondRectifyUsed: resumeRectifyUsed
           });
           break;
         }
@@ -53384,7 +53506,7 @@ class StoryOrchestratorBuilder {
     return new ExecutionPlan(ctx, { ...this.state }, opts.isThreeSession ?? false);
   }
 }
-var _storyOrchestratorDeps, TDD_OP_NAMES, STRICT_VERDICT_PHASE_NAMES, CANONICAL_ORDER, PHASE_KIND_TO_STATE_KEY, STRATEGY_TO_REVALIDATION_PHASES;
+var _storyOrchestratorDeps, EXHAUSTED_EXIT_REASONS, TDD_OP_NAMES, STRICT_VERDICT_PHASE_NAMES, CANONICAL_ORDER, PHASE_KIND_TO_STATE_KEY, STRATEGY_TO_REVALIDATION_PHASES;
 var init_story_orchestrator = __esm(() => {
   init_errors();
   init_findings();
@@ -53400,6 +53522,13 @@ var init_story_orchestrator = __esm(() => {
     prepareSemanticReviewInput,
     prepareAdversarialReviewInput
   };
+  EXHAUSTED_EXIT_REASONS = new Set([
+    "max-attempts-total",
+    "max-attempts-per-strategy",
+    "bail-when",
+    "no-strategy",
+    "agent-gave-up"
+  ]);
   TDD_OP_NAMES = new Set(["test-writer", "implementer", "verifier"]);
   STRICT_VERDICT_PHASE_NAMES = new Set([
     fullSuiteGateOp.name,
@@ -53435,23 +53564,8 @@ var init_story_orchestrator = __esm(() => {
   STRATEGY_TO_REVALIDATION_PHASES = {
     "mechanical-lintfix": ["lint-check"],
     "mechanical-formatfix": ["lint-check"],
-    "autofix-implementer": [
-      "lint-check",
-      "typecheck-check",
-      "full-suite-gate",
-      "verifier",
-      "verify-scoped",
-      "semantic-review",
-      "adversarial-review"
-    ],
-    "autofix-test-writer": [
-      "lint-check",
-      "typecheck-check",
-      "full-suite-gate",
-      "verifier",
-      "verify-scoped",
-      "adversarial-review"
-    ],
+    "autofix-implementer": ["lint-check", "typecheck-check", "full-suite-gate", "semantic-review", "adversarial-review"],
+    "autofix-test-writer": ["lint-check", "typecheck-check", "full-suite-gate", "adversarial-review"],
     "full-suite-rectify": [
       "lint-check",
       "typecheck-check",
@@ -53799,7 +53913,7 @@ function routeTddFailure(failureCategory, isLiteMode, ctx, reviewReason, failure
     }
     return { action: "escalate", reason: buildReason("isolation-violation") };
   }
-  if (failureCategory === "session-failure" || failureCategory === "tests-failing" || failureCategory === "full-suite-gate-exhausted" || failureCategory === "verifier-rejected") {
+  if (failureCategory === "session-failure" || failureCategory === "tests-failing" || failureCategory === "full-suite-gate-exhausted" || failureCategory === "verifier-rejected" || failureCategory === "runtime-crash") {
     return { action: "escalate", reason: buildReason(failureCategory) };
   }
   if (failureCategory === "greenfield-no-tests") {
@@ -53948,7 +54062,7 @@ function extractPauseReason(phaseOutputs) {
   }
   return;
 }
-function deriveTddFailureCategory(phaseOutputs) {
+function deriveTddFailureCategory(phaseOutputs, unfixedFindings) {
   const testWriterOutput = phaseOutputs[testWriterOp.name];
   if (testWriterOutput?.success === false) {
     return "session-failure";
@@ -53965,6 +54079,18 @@ function deriveTddFailureCategory(phaseOutputs) {
     return "tests-failing";
   }
   const verifierPassed = verifierOutput?.success === true;
+  if (!verifierPassed && unfixedFindings && unfixedFindings.length > 0) {
+    const rectOutput = phaseOutputs.rectification;
+    if (rectOutput?.exitReason && EXHAUSTED_EXIT_REASONS.has(rectOutput.exitReason) && unfixedFindings.some((f) => f.source === "test-runner")) {
+      return "full-suite-gate-exhausted";
+    }
+  }
+  if (!verifierPassed) {
+    const rectOutputCrash = phaseOutputs.rectification;
+    if (rectOutputCrash?.exitReason === "validator-error") {
+      return "runtime-crash";
+    }
+  }
   if (!verifierPassed) {
     const gateOutput = phaseOutputs[fullSuiteGateOp.name];
     if (gateOutput && (gateOutput.success === false || gateOutput.passed === false)) {
@@ -53997,7 +54123,6 @@ async function applyPostRunInspection(ctx, planResult, opts) {
     ...capturedTokenUsage ? { tokenUsage: capturedTokenUsage } : {}
   };
   ctx.agentResult = agentResult;
-  ctx.agentSwapCount = 0;
   const fullSuiteGateOutput = planResult.phaseOutputs[fullSuiteGateOp.name];
   if (fullSuiteGateOutput?.passed) {
     ctx.fullSuiteGatePassed = true;
@@ -54068,7 +54193,7 @@ async function applyPostRunInspection(ctx, planResult, opts) {
     }
   }
   const pauseReason = extractPauseReason(planResult.phaseOutputs);
-  const failureCategory = isTdd && !planResult.success ? deriveTddFailureCategory(planResult.phaseOutputs) : undefined;
+  const failureCategory = isTdd && !planResult.success ? deriveTddFailureCategory(planResult.phaseOutputs, planResult.unfixedFindings) : undefined;
   if (isTdd && !planResult.success && !failureCategory) {
     const phaseSignals = {};
     for (const [name, output] of Object.entries(planResult.phaseOutputs)) {
@@ -54287,6 +54412,7 @@ var init_post_run = __esm(() => {
   init_scratch_writer();
   init_rollback();
   init_git();
+  init_story_orchestrator();
   _postRunDeps = {
     detectMergeConflict,
     checkMergeConflict,
@@ -54297,9 +54423,10 @@ var init_post_run = __esm(() => {
 });
 
 // src/pipeline/stages/execution.ts
-var executionStage, _executionDeps;
+var RUNTIME_CRASH_CODES, executionStage, _executionDeps;
 var init_execution = __esm(() => {
   init_agents();
+  init_errors();
   init_build_plan_for_strategy();
   init_plan_inputs();
   init_post_run();
@@ -54307,6 +54434,7 @@ var init_execution = __esm(() => {
   init_logger2();
   init_git();
   init_execution_helpers();
+  RUNTIME_CRASH_CODES = new Set(["CALL_OP_NO_OUTPUT", "CALL_OP_MAX_RETRIES"]);
   executionStage = {
     name: "execution",
     enabled: () => true,
@@ -54365,10 +54493,15 @@ var init_execution = __esm(() => {
       } : null;
       const initialRef = tddMode ? await _executionDeps.captureGitRef(ctx.workdir) ?? "HEAD" : null;
       const inputs = await _executionDeps.assemblePlanInputsFromCtx(ctx);
-      const plan = await buildPlanForStrategy(callCtx, ctx.story, ctx.config, ctx.routing.testStrategy, inputs);
+      const plan = await _executionDeps.buildPlanForStrategy(callCtx, ctx.story, ctx.config, ctx.routing.testStrategy, inputs);
       let planResult;
       try {
         planResult = await plan.run();
+      } catch (err) {
+        if (err instanceof NaxError && RUNTIME_CRASH_CODES.has(err.code)) {
+          ctx.tddFailureCategory = "runtime-crash";
+        }
+        throw err;
       } finally {
         unsubscribe();
       }
@@ -54390,6 +54523,7 @@ var init_execution = __esm(() => {
     validateAgentForTier,
     captureGitRef,
     assemblePlanInputsFromCtx,
+    buildPlanForStrategy,
     applyPostRunInspection,
     decideStageAction
   };
@@ -57809,7 +57943,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.67.16",
+    version: "0.67.18",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -57904,8 +58038,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("215c9e93"))
-        return "215c9e93";
+      if (/^[0-9a-f]{6,10}$/.test("cc7adcea"))
+        return "cc7adcea";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {

package/package.json

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