@nathapp/nax 0.48.1 → 0.48.3

package/package.json

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

package/src/agents/acp/spawn-client.ts

@@ -218,7 +218,7 @@ class SpawnAcpSession implements AcpSession {
       this.activeProc = null;
     }
 
-    const cmd = ["acpx", this.agentName, "sessions", "close", this.sessionName];
+    const cmd = ["acpx", "--cwd", this.cwd, this.agentName, "sessions", "close", this.sessionName];
     getSafeLogger()?.debug("acp-adapter", `Closing session: ${this.sessionName}`);
 
     const proc = _spawnClientDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });

package/src/cli/generate.ts

@@ -67,17 +67,19 @@ export async function generateCommand(options: GenerateCommandOptions): Promise<
       return;
     }
 
-    console.log(chalk.blue(`→ Generating CLAUDE.md for ${packages.length} package(s)...`));
+    console.log(chalk.blue(`→ Generating agent files for ${packages.length} package(s)...`));
     let errorCount = 0;
 
     for (const pkgDir of packages) {
-      const result = await generateForPackage(pkgDir, config, dryRun);
-      if (result.error) {
-        console.error(chalk.red(`✗ ${pkgDir}: ${result.error}`));
-        errorCount++;
-      } else {
-        const suffix = dryRun ? " (dry run)" : "";
-        console.log(chalk.green(`✓ ${pkgDir}/${result.outputFile} (${result.content.length} bytes${suffix})`));
+      const results = await generateForPackage(pkgDir, config, dryRun);
+      for (const result of results) {
+        if (result.error) {
+          console.error(chalk.red(`✗ ${pkgDir}: ${result.error}`));
+          errorCount++;
+        } else {
+          const suffix = dryRun ? " (dry run)" : "";
+          console.log(chalk.green(`✓ ${pkgDir}/${result.outputFile} (${result.content.length} bytes${suffix})`));
+        }
       }
     }
 
@@ -94,14 +96,19 @@ export async function generateCommand(options: GenerateCommandOptions): Promise<
     if (dryRun) {
       console.log(chalk.yellow("⚠ Dry run — no files will be written"));
     }
-    console.log(chalk.blue(`→ Generating CLAUDE.md for package: ${options.package}`));
-    const result = await generateForPackage(packageDir, config, dryRun);
-    if (result.error) {
-      console.error(chalk.red(`✗ ${result.error}`));
-      process.exit(1);
+    console.log(chalk.blue(`→ Generating agent files for package: ${options.package}`));
+    const pkgResults = await generateForPackage(packageDir, config, dryRun);
+    let pkgHasError = false;
+    for (const result of pkgResults) {
+      if (result.error) {
+        console.error(chalk.red(`✗ ${result.error}`));
+        pkgHasError = true;
+      } else {
+        const suffix = dryRun ? " (dry run)" : "";
+        console.log(chalk.green(`✓ ${options.package}/${result.outputFile} (${result.content.length} bytes${suffix})`));
+      }
     }
-    const suffix = dryRun ? " (dry run)" : "";
-    console.log(chalk.green(`✓ ${options.package}/${result.outputFile} (${result.content.length} bytes${suffix})`));
+    if (pkgHasError) process.exit(1);
     return;
   }
 
@@ -183,8 +190,8 @@ export async function generateCommand(options: GenerateCommandOptions): Promise<
         console.log(chalk.blue("→ Generating configs for all agents..."));
       }
 
-      const allResults = await generateAll(genOptions, config);
-      const results = agentFilter ? allResults.filter((r) => agentFilter.includes(r.agent as AgentType)) : allResults;
+      // Pass agentFilter to generateAll so only matching agents are written to disk
+      const results = await generateAll(genOptions, config, agentFilter ?? undefined);
 
       let errorCount = 0;
 
@@ -205,22 +212,24 @@ export async function generateCommand(options: GenerateCommandOptions): Promise<
         process.exit(1);
       }
 
-      // Auto-generate per-package CLAUDE.md when packages with nax/context.md are discovered
+      // Auto-generate per-package agent files when packages with nax/context.md are discovered
       const packages = await discoverPackages(workdir);
       if (packages.length > 0) {
         console.log(
-          chalk.blue(`\n→ Discovered ${packages.length} package(s) with nax/context.md — generating CLAUDE.md...`),
+          chalk.blue(`\n→ Discovered ${packages.length} package(s) with nax/context.md — generating agent files...`),
         );
         let pkgErrorCount = 0;
         for (const pkgDir of packages) {
-          const result = await generateForPackage(pkgDir, config, dryRun);
-          if (result.error) {
-            console.error(chalk.red(`✗ ${pkgDir}: ${result.error}`));
-            pkgErrorCount++;
-          } else {
-            const suffix = dryRun ? " (dry run)" : "";
-            const rel = pkgDir.startsWith(workdir) ? pkgDir.slice(workdir.length + 1) : pkgDir;
-            console.log(chalk.green(`✓ ${rel}/${result.outputFile} (${result.content.length} bytes${suffix})`));
+          const pkgResults = await generateForPackage(pkgDir, config, dryRun);
+          for (const result of pkgResults) {
+            if (result.error) {
+              console.error(chalk.red(`✗ ${pkgDir}: ${result.error}`));
+              pkgErrorCount++;
+            } else {
+              const suffix = dryRun ? " (dry run)" : "";
+              const rel = pkgDir.startsWith(workdir) ? pkgDir.slice(workdir.length + 1) : pkgDir;
+              console.log(chalk.green(`✓ ${rel}/${result.outputFile} (${result.content.length} bytes${suffix})`));
+            }
           }
         }
         if (pkgErrorCount > 0) {

package/src/cli/init.ts

@@ -51,7 +51,6 @@ const NAX_GITIGNORE_ENTRIES = [
   "nax/features/*/acceptance-refined.json",
   ".nax-pids",
   ".nax-wt/",
-  "~/",
 ];
 
 /**

package/src/context/generator.ts

@@ -100,15 +100,26 @@ async function generateFor(agent: AgentType, options: GenerateOptions, config: N
 }
 
 /**
- * Generate configs for all agents.
+ * Generate configs for all agents (or a filtered subset).
+ *
+ * @param agentFilter - Optional list of agent names to generate. When provided,
+ *   only those agents are written to disk. When omitted, all agents are generated.
  */
-async function generateAll(options: GenerateOptions, config: NaxConfig): Promise<GenerationResult[]> {
+async function generateAll(
+  options: GenerateOptions,
+  config: NaxConfig,
+  agentFilter?: AgentType[],
+): Promise<GenerationResult[]> {
   // Load context once and share across generators
   const context = await loadContextContent(options, config);
 
   const results: GenerationResult[] = [];
 
-  for (const [agentKey, generator] of Object.entries(GENERATORS) as [AgentType, AgentContextGenerator][]) {
+  const entries = (Object.entries(GENERATORS) as [AgentType, AgentContextGenerator][]).filter(
+    ([agentKey]) => !agentFilter || agentFilter.length === 0 || agentFilter.includes(agentKey),
+  );
+
+  for (const [agentKey, generator] of entries) {
     try {
       const content = generator.generate(context);
       const outputPath = join(options.outputDir, generator.outputFile);
@@ -262,51 +273,70 @@ export async function discoverWorkspacePackages(repoRoot: string): Promise<strin
 }
 
 /**
- * Generate the claude CLAUDE.md for a specific package.
+ * Generate agent config file(s) for a specific package.
+ *
+ * Reads `<packageDir>/nax/context.md` and writes agent files (e.g. CLAUDE.md,
+ * AGENTS.md) into the package directory. Respects `config.generate.agents` — when
+ * set, only generates for those agents; defaults to `["claude"]` when unset.
+ *
+ * Per-package files contain only package-specific content — Claude Code's native
+ * directory hierarchy merges root CLAUDE.md + package CLAUDE.md at runtime.
  *
- * Reads `<packageDir>/nax/context.md` and writes `<packageDir>/CLAUDE.md`.
- * Per-package CLAUDE.md contains only package-specific content — Claude Code's
- * native directory hierarchy merges root CLAUDE.md + package CLAUDE.md at runtime.
+ * Returns one result per generated agent.
  */
 export async function generateForPackage(
   packageDir: string,
   config: NaxConfig,
   dryRun = false,
-): Promise<PackageGenerationResult> {
+): Promise<PackageGenerationResult[]> {
   const contextPath = join(packageDir, "nax", "context.md");
 
   if (!existsSync(contextPath)) {
-    return {
-      packageDir,
-      outputFile: "CLAUDE.md",
-      content: "",
-      written: false,
-      error: `context.md not found: ${contextPath}`,
-    };
+    return [
+      {
+        packageDir,
+        outputFile: "CLAUDE.md",
+        content: "",
+        written: false,
+        error: `context.md not found: ${contextPath}`,
+      },
+    ];
   }
 
-  try {
-    const options: GenerateOptions = {
-      contextPath,
-      outputDir: packageDir,
-      workdir: packageDir,
-      dryRun,
-      autoInject: true,
-    };
-
-    const result = await generateFor("claude", options, config);
-
-    return {
-      packageDir,
-      outputFile: result.outputFile,
-      content: result.content,
-      written: result.written,
-      error: result.error,
-    };
-  } catch (err) {
-    const error = err instanceof Error ? err.message : String(err);
-    return { packageDir, outputFile: "CLAUDE.md", content: "", written: false, error };
+  // Respect config.generate.agents; default to ["claude"] when unset
+  const agentsToGenerate: AgentType[] =
+    config?.generate?.agents && config.generate.agents.length > 0
+      ? (config.generate.agents as AgentType[])
+      : ["claude"];
+
+  const options: GenerateOptions = {
+    contextPath,
+    outputDir: packageDir,
+    workdir: packageDir,
+    dryRun,
+    autoInject: true,
+  };
+
+  const results: PackageGenerationResult[] = [];
+
+  for (const agent of agentsToGenerate) {
+    try {
+      const result = await generateFor(agent, options, config);
+      results.push({
+        packageDir,
+        outputFile: result.outputFile,
+        content: result.content,
+        written: result.written,
+        error: result.error,
+      });
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      const fallbackFile = GENERATORS[agent]?.outputFile ?? `${agent}.md`;
+      results.push({ packageDir, outputFile: fallbackFile, content: "", written: false, error });
+    }
   }
+
+  return results;
 }
 
 export { generateFor, generateAll };

package/src/execution/crash-recovery.ts

@@ -45,6 +45,8 @@ export interface CrashRecoveryContext {
   getTotalStories?: () => number;
   getStoriesCompleted?: () => number;
   emitError?: (reason: string) => void;
+  /** Called during graceful shutdown before process.exit — use to close ACP sessions etc. */
+  onShutdown?: () => Promise<void>;
 }
 
 let handlersInstalled = false;

package/src/execution/crash-signals.ts

@@ -15,6 +15,8 @@ export interface SignalHandlerContext extends RunCompleteContext {
   pidRegistry?: PidRegistry;
   featureDir?: string;
   emitError?: (reason: string) => void;
+  /** Called during graceful shutdown (signal/exception) before process.exit — use to close ACP sessions etc. */
+  onShutdown?: () => Promise<void>;
 }
 
 /**
@@ -46,6 +48,11 @@ function createSignalHandler(ctx: SignalHandlerContext): (signal: NodeJS.Signals
       await ctx.pidRegistry.killAll();
     }
 
+    // Close any open ACP sessions before exiting (prevents orphaned acpx processes)
+    if (ctx.onShutdown) {
+      await ctx.onShutdown().catch(() => {});
+    }
+
     ctx.emitError?.(signal.toLowerCase());
 
     await writeFatalLog(ctx.jsonlFilePath, signal);
@@ -72,6 +79,10 @@ function createUncaughtExceptionHandler(ctx: SignalHandlerContext): (error: Erro
       await ctx.pidRegistry.killAll();
     }
 
+    if (ctx.onShutdown) {
+      await ctx.onShutdown().catch(() => {});
+    }
+
     ctx.emitError?.("uncaughtException");
     await writeFatalLog(ctx.jsonlFilePath, "uncaughtException", error);
     await updateStatusToCrashed(
@@ -102,6 +113,10 @@ function createUnhandledRejectionHandler(ctx: SignalHandlerContext): (reason: un
       await ctx.pidRegistry.killAll();
     }
 
+    if (ctx.onShutdown) {
+      await ctx.onShutdown().catch(() => {});
+    }
+
     ctx.emitError?.("unhandledRejection");
     await writeFatalLog(ctx.jsonlFilePath, "unhandledRejection", error);
     await updateStatusToCrashed(

package/src/execution/lifecycle/run-setup.ts

@@ -130,6 +130,11 @@ export async function setupRun(options: RunSetupOptions): Promise<RunSetupResult
     emitError: (reason: string) => {
       pipelineEventBus.emit({ type: "run:errored", reason, feature: options.feature });
     },
+    // Close open ACP sessions on SIGINT/SIGTERM so acpx processes don't stay alive
+    onShutdown: async () => {
+      const { sweepFeatureSessions } = await import("../../agents/acp/adapter");
+      await sweepFeatureSessions(workdir, feature).catch(() => {});
+    },
   });
 
   // Load PRD (before try block so it's accessible in finally for onRunEnd)

package/src/pipeline/stages/routing.ts

@@ -25,6 +25,7 @@
  * ```
  */
 
+import { join } from "node:path";
 import { getAgent } from "../../agents/registry";
 import type { NaxConfig } from "../../config";
 import { isGreenfieldStory } from "../../context/greenfield";
@@ -140,13 +141,18 @@ export const routingStage: PipelineStage = {
     }
 
     // BUG-010: Greenfield detection — force test-after if no test files exist
+    // MW-011: For monorepo stories, scan the story's package workdir (story.workdir), not the
+    // repo root. Scanning the repo root would find tests in OTHER packages and incorrectly
+    // classify the story as non-greenfield even when the target package has zero tests.
     const greenfieldDetectionEnabled = ctx.config.tdd.greenfieldDetection ?? true;
     if (greenfieldDetectionEnabled && routing.testStrategy.startsWith("three-session-tdd")) {
-      const isGreenfield = await _routingDeps.isGreenfieldStory(ctx.story, ctx.workdir);
+      const greenfieldScanDir = ctx.story.workdir ? join(ctx.workdir, ctx.story.workdir) : ctx.workdir;
+      const isGreenfield = await _routingDeps.isGreenfieldStory(ctx.story, greenfieldScanDir);
       if (isGreenfield) {
         logger.info("routing", "Greenfield detected — forcing test-after strategy", {
           storyId: ctx.story.id,
           originalStrategy: routing.testStrategy,
+          scanDir: greenfieldScanDir,
         });
         routing.testStrategy = "test-after";
         routing.reasoning = `${routing.reasoning} [GREENFIELD OVERRIDE: No test files exist, using test-after instead of TDD]`;

package/src/precheck/checks-git.ts

@@ -40,6 +40,7 @@ const NAX_RUNTIME_PATTERNS = [
   /^.{2} nax\.lock$/,
   /^.{2} nax\/metrics\.json$/,
   /^.{2} nax\/features\/[^/]+\/status\.json$/,
+  /^.{2} nax\/features\/[^/]+\/prd\.json$/,
   /^.{2} nax\/features\/[^/]+\/runs\//,
   /^.{2} nax\/features\/[^/]+\/plan\//,
   /^.{2} nax\/features\/[^/]+\/acp-sessions\.json$/,