@nathapp/nax 0.82.2 → 0.82.3

package/dist/nax.js

@@ -2668,7 +2668,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.82.2",
+    version: "0.82.3",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -27035,6 +27035,7 @@ var init_schemas_execution = __esm(() => {
     }).default({ testWriter: "fast", verifier: "fast" }),
     verifierTimeoutSeconds: exports_external.number().int().min(60).max(7200).default(1800),
     testWriterAllowedPaths: exports_external.array(exports_external.string()).optional(),
+    testWriterCommitHooks: exports_external.enum(["skip", "run"]).optional(),
     rollbackOnFailure: exports_external.boolean().optional(),
     greenfieldDetection: exports_external.boolean().optional()
   });
@@ -42044,6 +42045,7 @@ Workflow:
 
 Rules:
 - Stubs are NOT implementations. The implementer in the next session writes real logic.
+- Do not commit. When your session ends, nax commits the files you changed as the RED state.
 - Each test name describes ONE behavior. Use AC IDs in test names when available (e.g. \`it('AC4: throws Division by zero when b === 0')\`).
 - Assert on observable outputs.
 - ${frameworkHint}
@@ -42060,10 +42062,12 @@ Workflow:
 2. Break the work into small tasks before writing: treat each AC as one task and note the test name(s) you will write (success + boundary) and which file they belong in. This per-AC list is your checklist.
 3. Create test files in the location the project uses for tests (project context names it).
 4. For each AC: write at least one test for the success path AND at least one for a boundary/failure path (zero, empty, negative, missing, throws). ACs worded as "throws X" require a test asserting the throw.
-5. Run the new test files. Confirm every test fails with an ASSERTION failure \u2014 NOT an import error, compile error, or runtime crash before assertion. A test that errors before reaching its assertion does not prove the behavior is missing.
+5. Run the new test files. Confirm every test fails with an ASSERTION failure, not an import error or a runtime crash before the assertion. A test that errors before reaching its assertion does not prove the behavior is missing.
 
 Rules:
 - Do NOT create or modify any source files. Read source for types/interfaces only.
+- A type-check error that exists only because the implementer has not yet added a field, parameter or export the acceptance criteria require is the expected RED state. Do not work around it with type casts, type-checker suppression comments, allow-list tags or throwaway type-probe scripts; type each test as the finished code will be.
+- Do not commit. When your session ends, nax commits the files you changed as the RED state.
 - Each test name describes ONE behavior; each test asserts ONE behavior. When the AC has a number or ID, prefix the test name (e.g. \`it('AC4: throws Division by zero when b === 0')\`).
 - Assert on observable outputs (return values, thrown errors, file contents, log output, boundary state). Do not assert on private helpers, internal call counts, or implementation-level mocks unless the AC requires it.
 - ${frameworkHint}
@@ -53377,8 +53381,8 @@ var init_version = __esm(() => {
   NAX_AI_VERSION = CATALOG_VERSION;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("7c21771a"))
-        return "7c21771a";
+      if (/^[0-9a-f]{6,10}$/.test("db5bc9ae"))
+        return "db5bc9ae";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -73089,8 +73093,8 @@ async function getChangedFiles(workdir, fromRef = "HEAD") {
     { stdout: output, stderr, exitCode },
     { stdout: statusOutput, stderr: statusStderr, exitCode: statusExitCode }
   ] = await Promise.all([
-    runGitBounded(["diff", "--name-only", fromRef], workdir),
-    runGitBounded(["status", "--porcelain"], workdir)
+    runGitBounded(["diff", "--name-only", "-z", fromRef], workdir),
+    runGitBounded(["status", "--porcelain", "-z"], workdir)
   ]);
   if (exitCode !== 0) {
     throw new NaxError(`git diff --name-only ${fromRef} failed (exit ${exitCode}): ${stderr.trim()}`, "GIT_DIFF_FAILED", {
@@ -73106,10 +73110,8 @@ async function getChangedFiles(workdir, fromRef = "HEAD") {
       exitCode: statusExitCode
     });
   }
-  const diffFiles = output.trim().split(`
-`).filter(Boolean);
-  const untrackedFiles = statusOutput.split(`
-`).filter((line) => line.startsWith("??")).map((line) => line.slice(2).trim()).filter(Boolean);
+  const diffFiles = output.split("\x00").filter(Boolean);
+  const untrackedFiles = statusOutput.split("\x00").filter((line) => line.startsWith("??")).map((line) => line.slice(3)).filter(Boolean);
   return [...new Set([...diffFiles, ...untrackedFiles])];
 }
 async function getAddedLinesPerFile(workdir, fromRef = "HEAD") {
@@ -76465,20 +76467,7 @@ var init_write_test = __esm(() => {
     stage: "run",
     session: { role: "test-writer", lifetime: "warm" },
     config: tddConfigSelector,
-    tools: [
-      "Read",
-      "Glob",
-      "Grep",
-      "Write",
-      "Edit",
-      "Delete",
-      "Git",
-      "RunCommand",
-      "GitCommit",
-      "Exec",
-      "Bash",
-      "RequestCapability"
-    ],
+    tools: ["Read", "Glob", "Grep", "Write", "Edit", "Delete", "Git", "RunCommand", "Exec", "Bash", "RequestCapability"],
     model: (_input, ctx) => ctx.config.tdd?.sessionTiers?.testWriter,
     keepOpen: (_input, ctx) => shouldKeepSessionOpen(ctx.config, "test-writer"),
     build(input, _ctx) {
@@ -79562,6 +79551,7 @@ var init_config_descriptions = __esm(() => {
     "tdd.sessionTiers.verifier": "Model tier for verifier session",
     "tdd.verifierTimeoutSeconds": "Wall-clock budget for one verifier turn in seconds (default: 1800). Its own knob, not execution.sessionTimeoutSeconds",
     "tdd.testWriterAllowedPaths": "Glob patterns for files test-writer can modify",
+    "tdd.testWriterCommitHooks": 'Git hooks on the RED commit nax makes after the test-writer phase: "skip" (default, --no-verify) | "run"',
     "tdd.rollbackOnFailure": "Rollback git changes when TDD fails",
     "tdd.greenfieldDetection": "Force tdd-simple on projects with no test files",
     constitution: "Constitution settings (core rules and constraints)",
@@ -86408,12 +86398,108 @@ var init_cleanup = __esm(() => {
   };
 });
 
+// src/tdd/red-commit.ts
+function redCommitMessage(storyId) {
+  return `chore(${storyId}): auto-commit after test-writer session (RED)`;
+}
+async function commitRedState(opts, deps = _redCommitDeps) {
+  if (opts.dryRun)
+    return { status: "skipped", reason: "dry-run" };
+  try {
+    return await commitFromRoot(opts, deps);
+  } catch (err) {
+    return { status: "failed", reason: errorMessage(err) };
+  }
+}
+async function commitFromRoot(opts, deps) {
+  const top = await deps.git(["rev-parse", "--show-toplevel"], opts.workdir, RED_COMMIT_GIT_TIMEOUT_MS);
+  if (top.exitCode !== 0)
+    return { status: "failed", reason: `git rev-parse failed: ${top.stderr.trim()}` };
+  const gitRoot = top.stdout.trim();
+  if (isBlocked2(gitRoot, opts))
+    return { status: "skipped", reason: "blocked-worktree" };
+  const changed = await deps.getChangedFiles(opts.workdir, opts.beforeRef);
+  const files = await expandUntrackedDirs(gitRoot, changed, deps);
+  const { kept } = await deps.partitionNaxOwnedPaths(gitRoot, files);
+  if (kept.length === 0)
+    return NOTHING;
+  const addOpts = { pathspecs: kept, timeoutMs: RED_COMMIT_GIT_TIMEOUT_MS };
+  const added = await gitlinkSafeAdd(deps.git, gitRoot, addOpts);
+  if (added.exitCode !== 0)
+    return { status: "failed", reason: `git add failed: ${added.stderr.trim()}` };
+  const staged = await deps.git(["diff", "--cached", "--quiet", "--", ...kept], gitRoot, RED_COMMIT_GIT_TIMEOUT_MS);
+  if (staged.timedOut || staged.exitCode !== 0 && staged.exitCode !== 1) {
+    return { status: "failed", reason: `git diff --cached failed: ${staged.stderr.trim()}` };
+  }
+  if (staged.exitCode === 0)
+    return NOTHING;
+  const noVerify = opts.hooks === "skip" ? ["--no-verify"] : [];
+  const argv = ["commit", "--only", "-m", redCommitMessage(opts.storyId), ...noVerify, "--", ...kept];
+  const committed = await deps.git(argv, gitRoot, RED_COMMIT_GIT_TIMEOUT_MS);
+  if (committed.exitCode !== 0) {
+    const detail = committed.stderr.trim() || `exit ${committed.exitCode}`;
+    return { status: "failed", reason: `git commit failed: ${detail}` };
+  }
+  return { status: "committed", files: kept, hooksSkipped: opts.hooks === "skip" };
+}
+function isBlocked2(gitRoot, opts) {
+  if (!opts.blockedWorktrees?.size)
+    return false;
+  const root = realOrRaw(gitRoot);
+  const blocked = [...opts.blockedWorktrees].filter((tree) => realOrRaw(tree) === root);
+  if (blocked.length === 0)
+    return false;
+  const message = "Refusing to commit the RED state \u2014 working tree may still hold an unreverted mutation";
+  getSafeLogger()?.error("tdd", message, {
+    storyId: opts.storyId,
+    workdir: opts.workdir,
+    blocked,
+    hint: "Check the mutation-check log for the file and line, restore it, then commit manually."
+  });
+  return true;
+}
+async function expandUntrackedDirs(gitRoot, paths, deps) {
+  const out = [];
+  for (const path11 of paths) {
+    if (!path11.endsWith("/")) {
+      out.push(path11);
+      continue;
+    }
+    const args = ["ls-files", "--others", "--exclude-standard", "-z", "--", path11];
+    const listed = await deps.git(args, gitRoot, RED_COMMIT_GIT_TIMEOUT_MS);
+    if (listed.exitCode !== 0) {
+      throw new NaxError(`git ls-files failed: ${listed.stderr.trim()}`, "GIT_LS_FILES_FAILED", {
+        stage: "tdd-red-commit",
+        path: path11
+      });
+    }
+    out.push(...listed.stdout.split("\x00").filter(Boolean));
+  }
+  return out;
+}
+var RED_COMMIT_GIT_TIMEOUT_MS = 30000, _redCommitDeps, NOTHING;
+var init_red_commit = __esm(() => {
+  init_errors();
+  init_logger2();
+  init_tools();
+  init_git();
+  init_realpath();
+  init_isolation2();
+  _redCommitDeps = {
+    git: (args, cwd, timeoutMs) => gitWithTimeout(args, cwd, timeoutMs),
+    getChangedFiles,
+    partitionNaxOwnedPaths
+  };
+  NOTHING = { status: "skipped", reason: "nothing-to-commit" };
+});
+
 // src/tdd/index.ts
 var init_tdd = __esm(() => {
   init_operations();
   init_test_runners();
   init_cleanup();
   init_isolation2();
+  init_red_commit();
   init_rollback();
   init_verdict();
 });
@@ -87137,6 +87223,9 @@ async function runPhase(ctx, slot, phaseCosts, phaseOutputs, isThreeSession = fa
         }
       }
     }
+    if (isTddPhase && opName === "test-writer" && !inRectification && beforeRef && outcome === "passed") {
+      await commitTestWriterRedState(ctx, beforeRef);
+    }
     return output;
   } catch (err) {
     const noDispatch = toNoDispatchCheckResult(opName, err, Date.now() - phaseStartedAt);
@@ -87237,6 +87326,32 @@ function derivePhaseOutcome(output) {
     return "skipped";
   return "failed";
 }
+async function commitTestWriterRedState(ctx, beforeRef) {
+  const config2 = ctx.config ?? ctx.runtime.configLoader.current();
+  const result = await _storyOrchestratorDeps.commitRedState({
+    workdir: ctx.packageDir,
+    beforeRef,
+    storyId: ctx.storyId ?? "story",
+    hooks: config2.tdd?.testWriterCommitHooks ?? "skip",
+    dryRun: ctx.runtime.dryRun,
+    blockedWorktrees: ctx.runtime.dirtyWorktrees
+  });
+  logRedCommit(ctx.storyId, result);
+}
+function logRedCommit(storyId, result) {
+  const logger = getSafeLogger();
+  if (result.status === "committed") {
+    logger?.info("tdd", "RED state committed", {
+      storyId,
+      files: result.files.length,
+      hooksSkipped: result.hooksSkipped
+    });
+  } else if (result.status === "skipped") {
+    logger?.debug("tdd", "RED state commit skipped", { storyId, reason: result.reason });
+  } else {
+    logger?.warn("tdd", "RED state not committed", { storyId, reason: result.reason });
+  }
+}
 function withIncreasingFailuresBail(strategies, enabled, consecutiveIncreases) {
   if (!enabled)
     return strategies;
@@ -87283,6 +87398,7 @@ var init_run_phase = __esm(() => {
     callOp,
     runFixCycle,
     captureGitRef,
+    commitRedState,
     cleanupVerdict,
     prepareSemanticReviewInput,
     prepareAdversarialReviewInput,

package/package.json

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