@nathapp/nax 0.31.0 → 0.32.0

package/dist/nax.js

@@ -18540,7 +18540,7 @@ function determineTestStrategy(complexity, title, _description, tags = []) {
     return "three-session-tdd";
   }
   if (complexity === "simple")
-    return "test-after";
+    return "tdd-simple";
   return "three-session-tdd-lite";
 }
 function complexityToModelTier(complexity, context) {
@@ -18609,8 +18609,8 @@ var init_keyword = __esm(() => {
       const modelTier = complexityToModelTier(complexity, context);
       const testStrategy = determineTestStrategy(complexity, title, description, tags);
       const reasons = [];
+      const text = [title, description, ...tags].join(" ").toLowerCase();
       if (testStrategy === "three-session-tdd") {
-        const text = [title, description, ...tags].join(" ").toLowerCase();
         if (SECURITY_KEYWORDS.some((kw) => text.includes(kw)))
           reasons.push("security-critical");
         if (PUBLIC_API_KEYWORDS.some((kw) => text.includes(kw)))
@@ -18618,11 +18618,21 @@ var init_keyword = __esm(() => {
         if (complexity === "complex" || complexity === "expert")
           reasons.push(`complexity:${complexity}`);
       }
+      let reasoning = "";
+      if (testStrategy === "three-session-tdd") {
+        reasoning = reasons.length > 0 ? `three-session-tdd: ${reasons.join(", ")}` : `three-session-tdd: ${complexity} task`;
+      } else if (testStrategy === "three-session-tdd-lite") {
+        reasoning = `three-session-tdd-lite: simple task (${complexity})`;
+      } else if (testStrategy === "tdd-simple") {
+        reasoning = `tdd-simple: simple task (${complexity})`;
+      } else {
+        reasoning = `${testStrategy}: ${complexity} task`;
+      }
       return {
         complexity,
         modelTier,
         testStrategy,
-        reasoning: reasons.length > 0 ? `three-session-tdd: ${reasons.join(", ")}` : `three-session-tdd-lite: simple task (${complexity})`
+        reasoning
       };
     }
   };
@@ -18901,10 +18911,18 @@ Tags: ${tags.join(", ")}
 - balanced: Standard features, moderate logic, straightforward tests. 30-90 min.
 - powerful: Complex architecture, security-critical, multi-file refactors, novel algorithms. >90 min.
 
+## Test Strategies (derived from complexity)
+Your complexity classification will determine the execution strategy:
+- simple \u2192 tdd-simple: Single-session TDD (agent writes tests first, then implements)
+- medium \u2192 three-session-tdd-lite: Multi-session with lite isolation
+- complex/expert \u2192 three-session-tdd: Strict multi-session TDD isolation
+- test-after: Reserved for non-TDD work (refactors, deletions, config-only changes)
+
 ## Rules
 - Default to the CHEAPEST tier that will succeed.
 - Simple barrel exports, re-exports, or index files are ALWAYS simple + fast.
 - A story touching many files doesn't automatically mean complex \u2014 copy-paste refactors are simple.
+- If the story is pure refactoring/deletion with no new behavior, consider it "simple" for tdd-simple strategy.
 
 Respond with ONLY this JSON (no markdown, no explanation):
 {"complexity":"simple|medium|complex|expert","modelTier":"fast|balanced|powerful","reasoning":"<one line>"}`;
@@ -18931,10 +18949,18 @@ ${storyBlocks}
 - balanced: Standard features, moderate logic, straightforward tests. 30-90 min.
 - powerful: Complex architecture, security-critical, multi-file refactors, novel algorithms. >90 min.
 
+## Test Strategies (derived from complexity)
+Your complexity classification will determine the execution strategy:
+- simple \u2192 tdd-simple: Single-session TDD (agent writes tests first, then implements)
+- medium \u2192 three-session-tdd-lite: Multi-session with lite isolation
+- complex/expert \u2192 three-session-tdd: Strict multi-session TDD isolation
+- test-after: Reserved for non-TDD work (refactors, deletions, config-only changes)
+
 ## Rules
 - Default to the CHEAPEST tier that will succeed.
 - Simple barrel exports, re-exports, or index files are ALWAYS simple + fast.
 - A story touching many files doesn't automatically mean complex \u2014 copy-paste refactors are simple.
+- If the story is pure refactoring/deletion with no new behavior, consider it "simple" for tdd-simple strategy.
 
 Respond with ONLY a JSON array (no markdown, no explanation):
 [{"id":"US-001","complexity":"simple|medium|complex|expert","modelTier":"fast|balanced|powerful","reasoning":"<one line>"}]`;
@@ -19360,7 +19386,7 @@ function determineTestStrategy2(complexity, title, description, tags = [], tddSt
     return hasLiteTag ? "three-session-tdd-lite" : "three-session-tdd";
   }
   if (complexity === "simple")
-    return "test-after";
+    return "tdd-simple";
   return "three-session-tdd-lite";
 }
 function complexityToModelTier2(complexity, config2) {
@@ -19505,7 +19531,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.31.0",
+    version: "0.32.0",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -19567,8 +19593,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("6b2cc85"))
-        return "6b2cc85";
+      if (/^[0-9a-f]{6,10}$/.test("76e82f7"))
+        return "76e82f7";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -23719,7 +23745,10 @@ ${TEST_FILTER_RULE}`;
   if (role === "verifier") {
     return `${header}isolation scope: Read-only inspection. Review all test results, implementation code, and acceptance criteria compliance. You MAY write a verdict file (.nax-verifier-verdict.json) and apply legitimate fixes if needed.${footer}`;
   }
-  return `${header}isolation scope: Create test files in test/ directory, then implement source code in src/ to make tests pass. Both directories are in scope for this session.${footer}`;
+  if (role === "single-session") {
+    return `${header}isolation scope: Create test files in test/ directory, then implement source code in src/ to make tests pass. Both directories are in scope for this session.${footer}`;
+  }
+  return `${header}isolation scope: You may modify both src/ and test/ files. Write failing tests FIRST, then implement to make them pass.`;
 }
 var TEST_FILTER_RULE;
 var init_isolation2 = __esm(() => {
@@ -23783,7 +23812,8 @@ function buildRoleTaskSection(roleOrVariant, variant) {
 ` + `- Write a detailed verdict with reasoning
 ` + "- Goal: provide comprehensive verification and quality assurance";
   }
-  return `# Role: Single-Session
+  if (role === "single-session") {
+    return `# Role: Single-Session
 
 ` + `Your task: Write tests AND implement the feature in a single focused session.
 
@@ -23794,6 +23824,18 @@ function buildRoleTaskSection(roleOrVariant, variant) {
 ` + `- Run tests frequently throughout implementation
 ` + `- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
 ` + "- Goal: all tests passing, all changes committed, full story complete";
+  }
+  return `# Role: TDD-Simple
+
+` + `Your task: Write failing tests FIRST, then implement to make them pass.
+
+` + `Instructions:
+` + `- RED phase: Write failing tests FIRST for the acceptance criteria
+` + `- RED phase: Run the tests to confirm they fail
+` + `- GREEN phase: Implement the minimum code to make tests pass
+` + `- REFACTOR phase: Refactor while keeping tests green
+` + `- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
+` + "- Goal: all tests passing, feature complete, all changes committed";
 }
 
 // src/prompts/sections/story.ts
@@ -24001,6 +24043,7 @@ async function runTddSession(role, agent, story, config2, workdir, modelTier, be
   if (!result.success && result.pid) {
     await cleanupProcessTree(result.pid);
   }
+  await autoCommitIfDirty(workdir, role, story.id);
   let isolation;
   if (!skipIsolation) {
     if (role === "test-writer") {
@@ -24047,6 +24090,38 @@ async function runTddSession(role, agent, story, config2, workdir, modelTier, be
     estimatedCost: result.estimatedCost
   };
 }
+async function autoCommitIfDirty(workdir, role, storyId) {
+  const logger = getLogger();
+  try {
+    const statusProc = Bun.spawn(["git", "status", "--porcelain"], {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const statusOutput = await new Response(statusProc.stdout).text();
+    await statusProc.exited;
+    if (!statusOutput.trim())
+      return;
+    logger.warn("tdd", `Agent did not commit after ${role} session \u2014 auto-committing`, {
+      role,
+      storyId,
+      dirtyFiles: statusOutput.trim().split(`
+`).length
+    });
+    const addProc = Bun.spawn(["git", "add", "-A"], {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    await addProc.exited;
+    const commitProc = Bun.spawn(["git", "commit", "-m", `chore(${storyId}): auto-commit after ${role} session`], {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    await commitProc.exited;
+  } catch {}
+}
 var init_session_runner = __esm(() => {
   init_config();
   init_logger2();
@@ -24497,6 +24572,34 @@ function routeTddFailure(failureCategory, isLiteMode, ctx, reviewReason) {
     reason: reviewReason || "Three-session TDD requires review"
   };
 }
+async function autoCommitIfDirty2(workdir, role, storyId) {
+  try {
+    const statusProc = Bun.spawn(["git", "status", "--porcelain"], {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const statusOutput = await new Response(statusProc.stdout).text();
+    await statusProc.exited;
+    if (!statusOutput.trim())
+      return;
+    const logger = getLogger();
+    logger.warn("execution", `Agent did not commit after ${role} session \u2014 auto-committing`, {
+      role,
+      storyId,
+      dirtyFiles: statusOutput.trim().split(`
+`).length
+    });
+    const addProc = Bun.spawn(["git", "add", "-A"], { cwd: workdir, stdout: "pipe", stderr: "pipe" });
+    await addProc.exited;
+    const commitProc = Bun.spawn(["git", "commit", "-m", `chore(${storyId}): auto-commit after ${role} session`], {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    await commitProc.exited;
+  } catch {}
+}
 var executionStage, _executionDeps;
 var init_execution = __esm(() => {
   init_agents();
@@ -24578,6 +24681,7 @@ var init_execution = __esm(() => {
         dangerouslySkipPermissions: ctx.config.execution.dangerouslySkipPermissions
       });
       ctx.agentResult = result;
+      await autoCommitIfDirty2(ctx.workdir, "single-session", ctx.story.id);
       const combinedOutput = (result.output ?? "") + (result.stderr ?? "");
       if (_executionDeps.detectMergeConflict(combinedOutput) && ctx.interaction && isTriggerEnabled("merge-conflict", ctx.config)) {
         const shouldProceed = await _executionDeps.checkMergeConflict({ featureName: ctx.prd.feature, storyId: ctx.story.id }, ctx.config, ctx.interaction);
@@ -24924,19 +25028,20 @@ var init_prompt = __esm(() => {
       if (isBatch) {
         prompt = buildBatchPrompt2(ctx.stories, ctx.contextMarkdown, ctx.constitution);
       } else {
-        const builder = PromptBuilder.for("single-session").withLoader(ctx.workdir, ctx.config).story(ctx.story).context(ctx.contextMarkdown).constitution(ctx.constitution?.content);
+        const role = ctx.routing.testStrategy === "tdd-simple" ? "tdd-simple" : "single-session";
+        const builder = PromptBuilder.for(role).withLoader(ctx.workdir, ctx.config).story(ctx.story).context(ctx.contextMarkdown).constitution(ctx.constitution?.content);
         prompt = await builder.build();
       }
       ctx.prompt = prompt;
       if (isBatch) {
         logger.info("prompt", "Batch session prepared", {
           storyCount: ctx.stories.length,
-          testStrategy: "test-after"
+          testStrategy: ctx.routing.testStrategy
         });
       } else {
         logger.info("prompt", "Single session prepared", {
           storyId: ctx.story.id,
-          testStrategy: "test-after"
+          testStrategy: ctx.routing.testStrategy
         });
       }
       return { action: "continue" };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nathapp/nax",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "description": "AI Coding Agent Orchestrator \u2014 loops until done",
   "type": "module",
   "bin": {

package/src/cli/prompts.ts

@@ -273,11 +273,14 @@ const TEMPLATE_HEADER = `<!--
 /**
  * Execute the `nax prompts --init` command.
  *
- * Creates nax/templates/ and writes 4 default role-body template files.
+ * Creates nax/templates/ and writes 4 default role-body template files
+ * (test-writer, implementer, verifier, single-session).
  * Auto-wires prompts.overrides in nax.config.json if the file exists and overrides are not already set.
  * Returns the list of file paths written. Returns empty array if files
  * already exist and force is not set.
  *
+ * Note: tdd-simple role is supported in the prompt system but not auto-generated as a template.
+ *
  * @param options - Command options
  * @returns Array of file paths written
  */

package/src/config/types.ts

@@ -6,7 +6,7 @@
  */
 
 export type Complexity = "simple" | "medium" | "complex" | "expert";
-export type TestStrategy = "test-after" | "three-session-tdd" | "three-session-tdd-lite";
+export type TestStrategy = "test-after" | "tdd-simple" | "three-session-tdd" | "three-session-tdd-lite";
 export type TddStrategy = "auto" | "strict" | "lite" | "off";
 
 export interface EscalationEntry {
@@ -409,7 +409,7 @@ export interface RoutingConfig {
 
 /** Prompt overrides config (PB-003) */
 export interface PromptsConfig {
-  overrides?: Partial<Record<"test-writer" | "implementer" | "verifier" | "single-session", string>>;
+  overrides?: Partial<Record<"test-writer" | "implementer" | "verifier" | "single-session" | "tdd-simple", string>>;
 }
 
 /** Full nax configuration */

package/src/pipeline/stages/execution.ts

@@ -199,6 +199,9 @@ export const executionStage: PipelineStage = {
 
     ctx.agentResult = result;
 
+    // BUG-058: Auto-commit if agent left uncommitted changes (single-session/test-after)
+    await autoCommitIfDirty(ctx.workdir, "single-session", ctx.story.id);
+
     // merge-conflict trigger: detect CONFLICT markers in agent output
     const combinedOutput = (result.output ?? "") + (result.stderr ?? "");
     if (
@@ -267,3 +270,40 @@ export const _executionDeps = {
   isAmbiguousOutput,
   checkStoryAmbiguity,
 };
+
+/**
+ * BUG-058: Auto-commit safety net for single-session/test-after.
+ * Mirrors the same function in tdd/session-runner.ts for three-session TDD.
+ */
+async function autoCommitIfDirty(workdir: string, role: string, storyId: string): Promise<void> {
+  try {
+    const statusProc = Bun.spawn(["git", "status", "--porcelain"], {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const statusOutput = await new Response(statusProc.stdout).text();
+    await statusProc.exited;
+
+    if (!statusOutput.trim()) return;
+
+    const logger = getLogger();
+    logger.warn("execution", `Agent did not commit after ${role} session — auto-committing`, {
+      role,
+      storyId,
+      dirtyFiles: statusOutput.trim().split("\n").length,
+    });
+
+    const addProc = Bun.spawn(["git", "add", "-A"], { cwd: workdir, stdout: "pipe", stderr: "pipe" });
+    await addProc.exited;
+
+    const commitProc = Bun.spawn(["git", "commit", "-m", `chore(${storyId}): auto-commit after ${role} session`], {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    await commitProc.exited;
+  } catch {
+    // Silently ignore — auto-commit is best-effort
+  }
+}

package/src/pipeline/stages/prompt.ts

@@ -39,7 +39,8 @@ export const promptStage: PipelineStage = {
     if (isBatch) {
       prompt = buildBatchPrompt(ctx.stories, ctx.contextMarkdown, ctx.constitution);
     } else {
-      const builder = PromptBuilder.for("single-session")
+      const role = ctx.routing.testStrategy === "tdd-simple" ? "tdd-simple" : "single-session";
+      const builder = PromptBuilder.for(role)
         .withLoader(ctx.workdir, ctx.config)
         .story(ctx.story)
         .context(ctx.contextMarkdown)
@@ -52,12 +53,12 @@ export const promptStage: PipelineStage = {
     if (isBatch) {
       logger.info("prompt", "Batch session prepared", {
         storyCount: ctx.stories.length,
-        testStrategy: "test-after",
+        testStrategy: ctx.routing.testStrategy,
       });
     } else {
       logger.info("prompt", "Single session prepared", {
         storyId: ctx.story.id,
-        testStrategy: "test-after",
+        testStrategy: ctx.routing.testStrategy,
       });
     }
 

package/src/pipeline/types.ts

@@ -26,7 +26,7 @@ export interface RoutingResult {
   /** Selected model tier */
   modelTier: "fast" | "balanced" | "powerful";
   /** Test strategy */
-  testStrategy: "test-after" | "three-session-tdd" | "three-session-tdd-lite";
+  testStrategy: "test-after" | "tdd-simple" | "three-session-tdd" | "three-session-tdd-lite";
   /** Reasoning for the classification */
   reasoning: string;
   /** Estimated cost for this story */

package/src/prompts/sections/isolation.ts

@@ -1,11 +1,12 @@
 /**
  * Isolation Rules Section
  *
- * Generates isolation rules for all 4 roles:
+ * Generates isolation rules for all 5 roles:
  * - test-writer: Strict/Lite modes for test-first TDD
  * - implementer: Implement source while respecting test integrity
  * - verifier: Read-only inspection
  * - single-session: Both test/ and src/ modification allowed
+ * - tdd-simple: Both test/ and src/ modification allowed (no isolation)
  *
  * Backwards compatible: also accepts old API (mode only)
  * - buildIsolationSection("strict") → test-writer, strict
@@ -18,7 +19,7 @@ const TEST_FILTER_RULE =
   "— full suite output will flood your context window and cause failures.";
 
 export function buildIsolationSection(
-  roleOrMode: "implementer" | "test-writer" | "verifier" | "single-session" | "strict" | "lite",
+  roleOrMode: "implementer" | "test-writer" | "verifier" | "single-session" | "tdd-simple" | "strict" | "lite",
   mode?: "strict" | "lite",
 ): string {
   // Old API support: buildIsolationSection("strict") or buildIsolationSection("lite")
@@ -26,7 +27,7 @@ export function buildIsolationSection(
     return buildIsolationSection("test-writer", roleOrMode);
   }
 
-  const role = roleOrMode as "implementer" | "test-writer" | "verifier" | "single-session";
+  const role = roleOrMode as "implementer" | "test-writer" | "verifier" | "single-session" | "tdd-simple";
 
   const header = "# Isolation Rules\n\n";
   const footer = `\n\n${TEST_FILTER_RULE}`;
@@ -49,6 +50,10 @@ export function buildIsolationSection(
     return `${header}isolation scope: Read-only inspection. Review all test results, implementation code, and acceptance criteria compliance. You MAY write a verdict file (.nax-verifier-verdict.json) and apply legitimate fixes if needed.${footer}`;
   }
 
-  // single-session role
-  return `${header}isolation scope: Create test files in test/ directory, then implement source code in src/ to make tests pass. Both directories are in scope for this session.${footer}`;
+  if (role === "single-session") {
+    return `${header}isolation scope: Create test files in test/ directory, then implement source code in src/ to make tests pass. Both directories are in scope for this session.${footer}`;
+  }
+
+  // tdd-simple role — no isolation restrictions (no footer needed)
+  return `${header}isolation scope: You may modify both src/ and test/ files. Write failing tests FIRST, then implement to make them pass.`;
 }

package/src/prompts/sections/role-task.ts

@@ -1,11 +1,12 @@
 /**
  * Role-Task Section
  *
- * Generates role definition for all 4 roles in nax prompt orchestration:
+ * Generates role definition for all 5 roles in nax prompt orchestration:
  * - implementer: Make failing tests pass (standard/lite variants)
  * - test-writer: Write tests first (RED phase)
  * - verifier: Review and verify implementation
  * - single-session: Write tests AND implement in one session
+ * - tdd-simple: Write failing tests FIRST, then implement in one session
  *
  * Backwards compatible: also accepts old API (variant only)
  * - buildRoleTaskSection("standard") → implementer, standard
@@ -13,7 +14,7 @@
  */
 
 export function buildRoleTaskSection(
-  roleOrVariant: "implementer" | "test-writer" | "verifier" | "single-session" | "standard" | "lite",
+  roleOrVariant: "implementer" | "test-writer" | "verifier" | "single-session" | "tdd-simple" | "standard" | "lite",
   variant?: "standard" | "lite",
 ): string {
   // Old API support: buildRoleTaskSection("standard") or buildRoleTaskSection("lite")
@@ -21,7 +22,7 @@ export function buildRoleTaskSection(
     return buildRoleTaskSection("implementer", roleOrVariant);
   }
 
-  const role = roleOrVariant as "implementer" | "test-writer" | "verifier" | "single-session";
+  const role = roleOrVariant as "implementer" | "test-writer" | "verifier" | "single-session" | "tdd-simple";
 
   if (role === "implementer") {
     const v = variant ?? "standard";
@@ -79,16 +80,30 @@ export function buildRoleTaskSection(
     );
   }
 
-  // single-session role
+  if (role === "single-session") {
+    return (
+      "# Role: Single-Session\n\n" +
+      "Your task: Write tests AND implement the feature in a single focused session.\n\n" +
+      "Instructions:\n" +
+      "- Phase 1: Write comprehensive tests (test/ directory)\n" +
+      "- Phase 2: Implement to make all tests pass (src/ directory)\n" +
+      "- Use Bun test (describe/test/expect)\n" +
+      "- Run tests frequently throughout implementation\n" +
+      "- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'\n" +
+      "- Goal: all tests passing, all changes committed, full story complete"
+    );
+  }
+
+  // tdd-simple role — test-driven development in one session
   return (
-    "# Role: Single-Session\n\n" +
-    "Your task: Write tests AND implement the feature in a single focused session.\n\n" +
+    "# Role: TDD-Simple\n\n" +
+    "Your task: Write failing tests FIRST, then implement to make them pass.\n\n" +
     "Instructions:\n" +
-    "- Phase 1: Write comprehensive tests (test/ directory)\n" +
-    "- Phase 2: Implement to make all tests pass (src/ directory)\n" +
-    "- Use Bun test (describe/test/expect)\n" +
-    "- Run tests frequently throughout implementation\n" +
+    "- RED phase: Write failing tests FIRST for the acceptance criteria\n" +
+    "- RED phase: Run the tests to confirm they fail\n" +
+    "- GREEN phase: Implement the minimum code to make tests pass\n" +
+    "- REFACTOR phase: Refactor while keeping tests green\n" +
     "- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'\n" +
-    "- Goal: all tests passing, all changes committed, full story complete"
+    "- Goal: all tests passing, feature complete, all changes committed"
   );
 }

package/src/prompts/types.ts

@@ -5,7 +5,7 @@
  */
 
 /** Role determining which default template body to use */
-export type PromptRole = "test-writer" | "implementer" | "verifier" | "single-session";
+export type PromptRole = "test-writer" | "implementer" | "verifier" | "single-session" | "tdd-simple";
 
 /** A single section of a composed prompt */
 export interface PromptSection {

package/src/routing/router.ts

@@ -201,8 +201,8 @@ export function determineTestStrategy(
     return hasLiteTag ? "three-session-tdd-lite" : "three-session-tdd";
   }
 
-  // BUG-045: simple → test-after (low overhead), medium → tdd-lite (sweet spot)
-  if (complexity === "simple") return "test-after";
+  // TS-001: simple → tdd-simple (TDD discipline, 1 session), medium → tdd-lite (3 sessions)
+  if (complexity === "simple") return "tdd-simple";
   return "three-session-tdd-lite";
 }
 

package/src/routing/strategies/keyword.ts

@@ -117,8 +117,8 @@ function determineTestStrategy(
     return "three-session-tdd";
   }
 
-  // BUG-045: simple → test-after (low overhead), medium → tdd-lite (sweet spot)
-  if (complexity === "simple") return "test-after";
+  // TS-001: simple → tdd-simple (TDD discipline, 1 session), medium → tdd-lite (3 sessions)
+  if (complexity === "simple") return "tdd-simple";
   return "three-session-tdd-lite";
 }
 
@@ -150,21 +150,31 @@ export const keywordStrategy: RoutingStrategy = {
     const testStrategy = determineTestStrategy(complexity, title, description, tags);
 
     const reasons: string[] = [];
+    const text = [title, description, ...tags].join(" ").toLowerCase();
+
     if (testStrategy === "three-session-tdd") {
-      const text = [title, description, ...tags].join(" ").toLowerCase();
       if (SECURITY_KEYWORDS.some((kw) => text.includes(kw))) reasons.push("security-critical");
       if (PUBLIC_API_KEYWORDS.some((kw) => text.includes(kw))) reasons.push("public-api");
       if (complexity === "complex" || complexity === "expert") reasons.push(`complexity:${complexity}`);
     }
 
+    let reasoning = "";
+    if (testStrategy === "three-session-tdd") {
+      reasoning =
+        reasons.length > 0 ? `three-session-tdd: ${reasons.join(", ")}` : `three-session-tdd: ${complexity} task`;
+    } else if (testStrategy === "three-session-tdd-lite") {
+      reasoning = `three-session-tdd-lite: simple task (${complexity})`;
+    } else if (testStrategy === "tdd-simple") {
+      reasoning = `tdd-simple: simple task (${complexity})`;
+    } else {
+      reasoning = `${testStrategy}: ${complexity} task`;
+    }
+
     return {
       complexity,
       modelTier,
       testStrategy,
-      reasoning:
-        reasons.length > 0
-          ? `three-session-tdd: ${reasons.join(", ")}`
-          : `three-session-tdd-lite: simple task (${complexity})`,
+      reasoning,
     };
   },
 };

package/src/routing/strategies/llm-prompts.ts

@@ -35,10 +35,18 @@ Tags: ${tags.join(", ")}
 - balanced: Standard features, moderate logic, straightforward tests. 30-90 min.
 - powerful: Complex architecture, security-critical, multi-file refactors, novel algorithms. >90 min.
 
+## Test Strategies (derived from complexity)
+Your complexity classification will determine the execution strategy:
+- simple → tdd-simple: Single-session TDD (agent writes tests first, then implements)
+- medium → three-session-tdd-lite: Multi-session with lite isolation
+- complex/expert → three-session-tdd: Strict multi-session TDD isolation
+- test-after: Reserved for non-TDD work (refactors, deletions, config-only changes)
+
 ## Rules
 - Default to the CHEAPEST tier that will succeed.
 - Simple barrel exports, re-exports, or index files are ALWAYS simple + fast.
 - A story touching many files doesn't automatically mean complex — copy-paste refactors are simple.
+- If the story is pure refactoring/deletion with no new behavior, consider it "simple" for tdd-simple strategy.
 
 Respond with ONLY this JSON (no markdown, no explanation):
 {"complexity":"simple|medium|complex|expert","modelTier":"fast|balanced|powerful","reasoning":"<one line>"}`;
@@ -73,10 +81,18 @@ ${storyBlocks}
 - balanced: Standard features, moderate logic, straightforward tests. 30-90 min.
 - powerful: Complex architecture, security-critical, multi-file refactors, novel algorithms. >90 min.
 
+## Test Strategies (derived from complexity)
+Your complexity classification will determine the execution strategy:
+- simple → tdd-simple: Single-session TDD (agent writes tests first, then implements)
+- medium → three-session-tdd-lite: Multi-session with lite isolation
+- complex/expert → three-session-tdd: Strict multi-session TDD isolation
+- test-after: Reserved for non-TDD work (refactors, deletions, config-only changes)
+
 ## Rules
 - Default to the CHEAPEST tier that will succeed.
 - Simple barrel exports, re-exports, or index files are ALWAYS simple + fast.
 - A story touching many files doesn't automatically mean complex — copy-paste refactors are simple.
+- If the story is pure refactoring/deletion with no new behavior, consider it "simple" for tdd-simple strategy.
 
 Respond with ONLY a JSON array (no markdown, no explanation):
 [{"id":"US-001","complexity":"simple|medium|complex|expert","modelTier":"fast|balanced|powerful","reasoning":"<one line>"}]`;

package/src/tdd/session-runner.ts

@@ -129,6 +129,9 @@ export async function runTddSession(
     await cleanupProcessTree(result.pid);
   }
 
+  // BUG-058: Auto-commit if agent left uncommitted changes
+  await autoCommitIfDirty(workdir, role, story.id);
+
   // Check isolation based on role and skipIsolation flag.
   let isolation: IsolationCheck | undefined;
   if (!skipIsolation) {
@@ -181,3 +184,51 @@ export async function runTddSession(
     estimatedCost: result.estimatedCost,
   };
 }
+
+/**
+ * BUG-058: Auto-commit safety net.
+ *
+ * If the agent left uncommitted changes, stage and commit them automatically.
+ * This prevents the review stage from failing with "uncommitted changes" errors.
+ * Only triggers when the agent forgot — if tree is clean, this is a no-op.
+ */
+async function autoCommitIfDirty(workdir: string, role: string, storyId: string): Promise<void> {
+  const logger = getLogger();
+
+  // Check if working tree is dirty
+  try {
+    const statusProc = Bun.spawn(["git", "status", "--porcelain"], {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const statusOutput = await new Response(statusProc.stdout).text();
+    await statusProc.exited;
+
+    if (!statusOutput.trim()) return; // Clean tree, nothing to do
+
+    logger.warn("tdd", `Agent did not commit after ${role} session — auto-committing`, {
+      role,
+      storyId,
+      dirtyFiles: statusOutput.trim().split("\n").length,
+    });
+
+    // Stage all changes
+    const addProc = Bun.spawn(["git", "add", "-A"], {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    await addProc.exited;
+
+    // Commit with descriptive message
+    const commitProc = Bun.spawn(["git", "commit", "-m", `chore(${storyId}): auto-commit after ${role} session`], {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    await commitProc.exited;
+  } catch {
+    // Silently ignore — auto-commit is best-effort
+  }
+}