@nathapp/nax 0.46.3 → 0.48.0

package/dist/nax.js

@@ -20695,6 +20695,24 @@ var init_json_file = __esm(() => {
   init_logger2();
 });
 
+// src/config/merge.ts
+function mergePackageConfig(root, packageOverride) {
+  const packageCommands = packageOverride.quality?.commands;
+  if (!packageCommands) {
+    return root;
+  }
+  return {
+    ...root,
+    quality: {
+      ...root.quality,
+      commands: {
+        ...root.quality.commands,
+        ...packageCommands
+      }
+    }
+  };
+}
+
 // src/config/merger.ts
 function deepMergeConfig(base, override) {
   const result = { ...base };
@@ -20853,7 +20871,7 @@ var init_paths = () => {};
 
 // src/config/loader.ts
 import { existsSync as existsSync5 } from "fs";
-import { join as join7, resolve as resolve5 } from "path";
+import { dirname as dirname2, join as join7, resolve as resolve5 } from "path";
 function globalConfigPath() {
   return join7(globalConfigDir(), "config.json");
 }
@@ -20924,6 +20942,20 @@ ${errors3.join(`
   }
   return result.data;
 }
+async function loadConfigForWorkdir(rootConfigPath, packageDir) {
+  const rootNaxDir = dirname2(rootConfigPath);
+  const rootConfig = await loadConfig(rootNaxDir);
+  if (!packageDir) {
+    return rootConfig;
+  }
+  const repoRoot = dirname2(rootNaxDir);
+  const packageConfigPath = join7(repoRoot, packageDir, "nax", "config.json");
+  const packageOverride = await loadJsonFile(packageConfigPath, "config");
+  if (!packageOverride) {
+    return rootConfig;
+  }
+  return mergePackageConfig(rootConfig, packageOverride);
+}
 var init_loader2 = __esm(() => {
   init_logger2();
   init_json_file();
@@ -22178,7 +22210,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.46.3",
+    version: "0.48.0",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -22251,8 +22283,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("37f8759"))
-        return "37f8759";
+      if (/^[0-9a-f]{6,10}$/.test("3188738"))
+        return "3188738";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -24444,7 +24476,7 @@ async function getChangedFiles(workdir, baseRef) {
 }
 
 class ReviewOrchestrator {
-  async review(reviewConfig, workdir, executionConfig, plugins, storyGitRef) {
+  async review(reviewConfig, workdir, executionConfig, plugins, storyGitRef, scopePrefix) {
     const logger = getSafeLogger();
     const builtIn = await runReview(reviewConfig, workdir, executionConfig);
     if (!builtIn.success) {
@@ -24459,13 +24491,14 @@ class ReviewOrchestrator {
       if (reviewers.length > 0) {
         const baseRef = storyGitRef ?? executionConfig?.storyGitRef;
         const changedFiles = await getChangedFiles(workdir, baseRef);
+        const scopedFiles = scopePrefix ? changedFiles.filter((f) => f === scopePrefix || f.startsWith(`${scopePrefix}/`)) : changedFiles;
         const pluginResults = [];
         for (const reviewer of reviewers) {
           logger?.info("review", `Running plugin reviewer: ${reviewer.name}`, {
-            changedFiles: changedFiles.length
+            changedFiles: scopedFiles.length
           });
           try {
-            const result = await reviewer.check(workdir, changedFiles);
+            const result = await reviewer.check(workdir, scopedFiles);
             logger?.info("review", `Plugin reviewer result: ${reviewer.name}`, {
               passed: result.passed,
               exitCode: result.exitCode,
@@ -24521,6 +24554,7 @@ __export(exports_review, {
   reviewStage: () => reviewStage,
   _reviewDeps: () => _reviewDeps
 });
+import { join as join17 } from "path";
 var reviewStage, _reviewDeps;
 var init_review = __esm(() => {
   init_triggers();
@@ -24532,7 +24566,8 @@ var init_review = __esm(() => {
     async execute(ctx) {
       const logger = getLogger();
       logger.info("review", "Running review phase", { storyId: ctx.story.id });
-      const result = await reviewOrchestrator.review(ctx.config.review, ctx.workdir, ctx.config.execution, ctx.plugins, ctx.storyGitRef);
+      const effectiveWorkdir = ctx.story.workdir ? join17(ctx.workdir, ctx.story.workdir) : ctx.workdir;
+      const result = await reviewOrchestrator.review(ctx.config.review, effectiveWorkdir, ctx.config.execution, ctx.plugins, ctx.storyGitRef, ctx.story.workdir);
       ctx.reviewResult = result.builtIn;
       if (!result.success) {
         const allFindings = result.builtIn.pluginReviewers?.flatMap((pr) => pr.findings ?? []) ?? [];
@@ -24743,10 +24778,10 @@ var init_autofix = __esm(() => {
 
 // src/execution/progress.ts
 import { mkdirSync as mkdirSync2 } from "fs";
-import { join as join15 } from "path";
+import { join as join18 } from "path";
 async function appendProgress(featureDir, storyId, status, message) {
   mkdirSync2(featureDir, { recursive: true });
-  const progressPath = join15(featureDir, "progress.txt");
+  const progressPath = join18(featureDir, "progress.txt");
   const timestamp = new Date().toISOString();
   const entry = `[${timestamp}] ${storyId} \u2014 ${status.toUpperCase()} \u2014 ${message}
 `;
@@ -24829,8 +24864,8 @@ function estimateTokens(text) {
 }
 
 // src/constitution/loader.ts
-import { existsSync as existsSync13 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { join as join19 } from "path";
 function truncateToTokens(text, maxTokens) {
   const maxChars = maxTokens * 3;
   if (text.length <= maxChars) {
@@ -24852,8 +24887,8 @@ async function loadConstitution(projectDir, config2) {
   }
   let combinedContent = "";
   if (!config2.skipGlobal) {
-    const globalPath = join16(globalConfigDir(), config2.path);
-    if (existsSync13(globalPath)) {
+    const globalPath = join19(globalConfigDir(), config2.path);
+    if (existsSync15(globalPath)) {
       const validatedPath = validateFilePath(globalPath, globalConfigDir());
       const globalFile = Bun.file(validatedPath);
       const globalContent = await globalFile.text();
@@ -24862,8 +24897,8 @@ async function loadConstitution(projectDir, config2) {
       }
     }
   }
-  const projectPath = join16(projectDir, config2.path);
-  if (existsSync13(projectPath)) {
+  const projectPath = join19(projectDir, config2.path);
+  if (existsSync15(projectPath)) {
     const validatedPath = validateFilePath(projectPath, projectDir);
     const projectFile = Bun.file(validatedPath);
     const projectContent = await projectFile.text();
@@ -24910,7 +24945,7 @@ var init_constitution = __esm(() => {
 });
 
 // src/pipeline/stages/constitution.ts
-import { dirname as dirname2 } from "path";
+import { dirname as dirname3 } from "path";
 var constitutionStage;
 var init_constitution2 = __esm(() => {
   init_constitution();
@@ -24920,7 +24955,7 @@ var init_constitution2 = __esm(() => {
     enabled: (ctx) => ctx.config.constitution.enabled,
     async execute(ctx) {
       const logger = getLogger();
-      const ngentDir = ctx.featureDir ? dirname2(dirname2(ctx.featureDir)) : `${ctx.workdir}/nax`;
+      const ngentDir = ctx.featureDir ? dirname3(dirname3(ctx.featureDir)) : `${ctx.workdir}/nax`;
       const result = await loadConstitution(ngentDir, ctx.config.constitution);
       if (result) {
         ctx.constitution = result;
@@ -25680,7 +25715,14 @@ function hookCtx(feature, opts) {
     ...opts
   };
 }
-async function buildStoryContextFull(prd, story, config2) {
+async function loadPackageContextMd(packageWorkdir) {
+  const contextPath = `${packageWorkdir}/nax/context.md`;
+  const file2 = Bun.file(contextPath);
+  if (!await file2.exists())
+    return null;
+  return file2.text();
+}
+async function buildStoryContextFull(prd, story, config2, packageWorkdir) {
   try {
     const storyContext = {
       prd,
@@ -25694,10 +25736,22 @@ async function buildStoryContextFull(prd, story, config2) {
       availableForContext: CONTEXT_MAX_TOKENS - CONTEXT_RESERVED_TOKENS
     };
     const built = await buildContext(storyContext, budget);
-    if (built.elements.length === 0) {
+    let packageSection = "";
+    if (packageWorkdir) {
+      const pkgContent = await loadPackageContextMd(packageWorkdir);
+      if (pkgContent) {
+        packageSection = `
+---
+
+${pkgContent.trim()}`;
+      }
+    }
+    if (built.elements.length === 0 && !packageSection) {
       return;
     }
-    return { markdown: formatContextAsMarkdown(built), builtContext: built };
+    const baseMarkdown = built.elements.length > 0 ? formatContextAsMarkdown(built) : "";
+    const markdown = packageSection ? `${baseMarkdown}${packageSection}` : baseMarkdown;
+    return { markdown, builtContext: built };
   } catch (error48) {
     const logger = getSafeLogger2();
     logger?.warn("context", "Context builder failed", {
@@ -25815,6 +25869,7 @@ var init_helpers = __esm(() => {
 });
 
 // src/pipeline/stages/context.ts
+import { join as join20 } from "path";
 var contextStage;
 var init_context2 = __esm(() => {
   init_helpers();
@@ -25824,7 +25879,8 @@ var init_context2 = __esm(() => {
     enabled: () => true,
     async execute(ctx) {
       const logger = getLogger();
-      const result = await buildStoryContextFull(ctx.prd, ctx.story, ctx.config);
+      const packageWorkdir = ctx.story.workdir ? join20(ctx.workdir, ctx.story.workdir) : undefined;
+      const result = await buildStoryContextFull(ctx.prd, ctx.story, ctx.config, packageWorkdir);
       if (result) {
         ctx.contextMarkdown = result.markdown;
         ctx.builtContext = result.builtContext;
@@ -25955,14 +26011,14 @@ var init_isolation = __esm(() => {
 
 // src/context/greenfield.ts
 import { readdir } from "fs/promises";
-import { join as join17 } from "path";
+import { join as join21 } from "path";
 async function scanForTestFiles(dir, testPattern, isRootCall = true) {
   const results = [];
   const ignoreDirs = new Set(["node_modules", "dist", "build", ".next", ".git"]);
   try {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join17(dir, entry.name);
+      const fullPath = join21(dir, entry.name);
       if (entry.isDirectory()) {
         if (ignoreDirs.has(entry.name))
           continue;
@@ -26373,14 +26429,14 @@ function parseTestOutput(output, exitCode) {
 }
 
 // src/verification/runners.ts
-import { existsSync as existsSync14 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { join as join22 } from "path";
 async function verifyAssets(workingDirectory, expectedFiles) {
   if (!expectedFiles || expectedFiles.length === 0)
     return { success: true, missingFiles: [] };
   const missingFiles = [];
   for (const file2 of expectedFiles) {
-    if (!existsSync14(join18(workingDirectory, file2)))
+    if (!existsSync16(join22(workingDirectory, file2)))
       missingFiles.push(file2);
   }
   if (missingFiles.length > 0) {
@@ -27065,13 +27121,13 @@ var exports_loader = {};
 __export(exports_loader, {
   loadOverride: () => loadOverride
 });
-import { join as join19 } from "path";
+import { join as join23 } from "path";
 async function loadOverride(role, workdir, config2) {
   const overridePath = config2.prompts?.overrides?.[role];
   if (!overridePath) {
     return null;
   }
-  const absolutePath = join19(workdir, overridePath);
+  const absolutePath = join23(workdir, overridePath);
   const file2 = Bun.file(absolutePath);
   if (!await file2.exists()) {
     return null;
@@ -27719,8 +27775,8 @@ async function runThreeSessionTdd(options) {
     let hasPreExistingTests = false;
     try {
       hasPreExistingTests = !await isGreenfieldStory(story, workdir, testPatternGlob);
-      const { existsSync: existsSync15 } = await import("fs");
-      if (!existsSync15(workdir)) {
+      const { existsSync: existsSync17 } = await import("fs");
+      if (!existsSync17(workdir)) {
         hasPreExistingTests = false;
       }
     } catch {
@@ -27892,6 +27948,17 @@ var init_tdd = __esm(() => {
 });
 
 // src/pipeline/stages/execution.ts
+import { existsSync as existsSync17 } from "fs";
+import { join as join24 } from "path";
+function resolveStoryWorkdir(repoRoot, storyWorkdir) {
+  if (!storyWorkdir)
+    return repoRoot;
+  const resolved = join24(repoRoot, storyWorkdir);
+  if (!existsSync17(resolved)) {
+    throw new Error(`[execution] story.workdir "${storyWorkdir}" does not exist at "${resolved}"`);
+  }
+  return resolved;
+}
 function isAmbiguousOutput(output) {
   if (!output)
     return false;
@@ -27948,11 +28015,12 @@ var init_execution2 = __esm(() => {
           storyId: ctx.story.id,
           lite: isLiteMode
         });
+        const effectiveWorkdir = _executionDeps.resolveStoryWorkdir(ctx.workdir, ctx.story.workdir);
         const tddResult = await runThreeSessionTdd({
           agent,
           story: ctx.story,
           config: ctx.config,
-          workdir: ctx.workdir,
+          workdir: effectiveWorkdir,
           modelTier: ctx.routing.modelTier,
           featureName: ctx.prd.feature,
           contextMarkdown: ctx.contextMarkdown,
@@ -28018,9 +28086,10 @@ Category: ${tddResult.failureCategory ?? "unknown"}`,
           supportedTiers: agent.capabilities.supportedTiers
         });
       }
+      const storyWorkdir = _executionDeps.resolveStoryWorkdir(ctx.workdir, ctx.story.workdir);
       const result = await agent.run({
         prompt: ctx.prompt,
-        workdir: ctx.workdir,
+        workdir: storyWorkdir,
         modelTier: ctx.routing.modelTier,
         modelDef: resolveModel(ctx.config.models[ctx.routing.modelTier]),
         timeoutSeconds: ctx.config.execution.sessionTimeoutSeconds,
@@ -28061,7 +28130,7 @@ Category: ${tddResult.failureCategory ?? "unknown"}`,
         })()
       });
       ctx.agentResult = result;
-      await autoCommitIfDirty(ctx.workdir, "execution", "single-session", ctx.story.id);
+      await autoCommitIfDirty(storyWorkdir, "execution", "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);
@@ -28102,7 +28171,8 @@ Category: ${tddResult.failureCategory ?? "unknown"}`,
     detectMergeConflict,
     checkMergeConflict,
     isAmbiguousOutput,
-    checkStoryAmbiguity
+    checkStoryAmbiguity,
+    resolveStoryWorkdir
   };
 });
 
@@ -29021,7 +29091,7 @@ function buildSmartTestCommand(testFiles, baseCommand) {
   const newParts = [...beforePath, ...testFiles, ...afterPath];
   return newParts.join(" ");
 }
-async function getChangedSourceFiles(workdir, baseRef) {
+async function getChangedSourceFiles(workdir, baseRef, packagePrefix) {
   try {
     const ref = baseRef ?? "HEAD~1";
     const { stdout, exitCode } = await gitWithTimeout(["diff", "--name-only", ref], workdir);
@@ -29029,7 +29099,8 @@ async function getChangedSourceFiles(workdir, baseRef) {
       return [];
     const lines = stdout.trim().split(`
 `).filter(Boolean);
-    return lines.filter((f) => f.startsWith("src/") && f.endsWith(".ts"));
+    const srcPrefix = packagePrefix ? `${packagePrefix}/src/` : "src/";
+    return lines.filter((f) => f.startsWith(srcPrefix) && f.endsWith(".ts"));
   } catch {
     return [];
   }
@@ -29463,6 +29534,7 @@ var init_crash_detector = __esm(() => {
 });
 
 // src/pipeline/stages/verify.ts
+import { join as join25 } from "path";
 function coerceSmartTestRunner(val) {
   if (val === undefined || val === true)
     return DEFAULT_SMART_RUNNER_CONFIG2;
@@ -29478,6 +29550,7 @@ function buildScopedCommand2(testFiles, baseCommand, testScopedTemplate) {
 }
 var DEFAULT_SMART_RUNNER_CONFIG2, verifyStage, _verifyDeps;
 var init_verify = __esm(() => {
+  init_loader2();
   init_logger2();
   init_crash_detector();
   init_runners();
@@ -29493,24 +29566,26 @@ var init_verify = __esm(() => {
     skipReason: () => "not needed (full-suite gate already passed)",
     async execute(ctx) {
       const logger = getLogger();
-      if (!ctx.config.quality.requireTests) {
+      const effectiveConfig = ctx.story.workdir ? await _verifyDeps.loadConfigForWorkdir(join25(ctx.workdir, "nax", "config.json"), ctx.story.workdir) : ctx.config;
+      if (!effectiveConfig.quality.requireTests) {
         logger.debug("verify", "Skipping verification (quality.requireTests = false)", { storyId: ctx.story.id });
         return { action: "continue" };
       }
-      const testCommand = ctx.config.review?.commands?.test ?? ctx.config.quality.commands.test;
-      const testScopedTemplate = ctx.config.quality.commands.testScoped;
+      const testCommand = effectiveConfig.review?.commands?.test ?? effectiveConfig.quality.commands.test;
+      const testScopedTemplate = effectiveConfig.quality.commands.testScoped;
       if (!testCommand) {
         logger.debug("verify", "Skipping verification (no test command configured)", { storyId: ctx.story.id });
         return { action: "continue" };
       }
       logger.info("verify", "Running verification", { storyId: ctx.story.id });
+      const effectiveWorkdir = ctx.story.workdir ? join25(ctx.workdir, ctx.story.workdir) : ctx.workdir;
       let effectiveCommand = testCommand;
       let isFullSuite = true;
       const smartRunnerConfig = coerceSmartTestRunner(ctx.config.execution.smartTestRunner);
       const regressionMode = ctx.config.execution.regressionGate?.mode ?? "deferred";
       if (smartRunnerConfig.enabled) {
-        const sourceFiles = await _smartRunnerDeps.getChangedSourceFiles(ctx.workdir, ctx.storyGitRef);
-        const pass1Files = await _smartRunnerDeps.mapSourceToTests(sourceFiles, ctx.workdir);
+        const sourceFiles = await _smartRunnerDeps.getChangedSourceFiles(effectiveWorkdir, ctx.storyGitRef, ctx.story.workdir);
+        const pass1Files = await _smartRunnerDeps.mapSourceToTests(sourceFiles, effectiveWorkdir);
         if (pass1Files.length > 0) {
           logger.info("verify", `[smart-runner] Pass 1: path convention matched ${pass1Files.length} test files`, {
             storyId: ctx.story.id
@@ -29518,7 +29593,7 @@ var init_verify = __esm(() => {
           effectiveCommand = buildScopedCommand2(pass1Files, testCommand, testScopedTemplate);
           isFullSuite = false;
         } else if (smartRunnerConfig.fallback === "import-grep") {
-          const pass2Files = await _smartRunnerDeps.importGrepFallback(sourceFiles, ctx.workdir, smartRunnerConfig.testFilePatterns);
+          const pass2Files = await _smartRunnerDeps.importGrepFallback(sourceFiles, effectiveWorkdir, smartRunnerConfig.testFilePatterns);
           if (pass2Files.length > 0) {
             logger.info("verify", `[smart-runner] Pass 2: import-grep matched ${pass2Files.length} test files`, {
               storyId: ctx.story.id
@@ -29544,7 +29619,7 @@ var init_verify = __esm(() => {
         command: effectiveCommand
       });
       const result = await _verifyDeps.regression({
-        workdir: ctx.workdir,
+        workdir: effectiveWorkdir,
         command: effectiveCommand,
         timeoutSeconds: ctx.config.execution.verificationTimeoutSeconds,
         acceptOnTimeout: ctx.config.execution.regressionGate?.acceptOnTimeout ?? true
@@ -29589,7 +29664,8 @@ var init_verify = __esm(() => {
     }
   };
   _verifyDeps = {
-    regression
+    regression,
+    loadConfigForWorkdir
   };
 });
 
@@ -29664,6 +29740,299 @@ var init_stages = __esm(() => {
   preRunPipeline = [acceptanceSetupStage];
 });
 
+// src/cli/init-context.ts
+var exports_init_context = {};
+__export(exports_init_context, {
+  scanProject: () => scanProject,
+  initPackage: () => initPackage,
+  initContext: () => initContext,
+  generatePackageContextTemplate: () => generatePackageContextTemplate,
+  generateContextTemplate: () => generateContextTemplate,
+  _deps: () => _deps6
+});
+import { existsSync as existsSync20 } from "fs";
+import { mkdir } from "fs/promises";
+import { basename, join as join29 } from "path";
+async function findFiles(dir, maxFiles = 200) {
+  try {
+    const proc = Bun.spawnSync([
+      "find",
+      dir,
+      "-type",
+      "f",
+      "-not",
+      "-path",
+      "*/node_modules/*",
+      "-not",
+      "-path",
+      "*/.git/*",
+      "-not",
+      "-path",
+      "*/dist/*"
+    ], { stdio: ["pipe", "pipe", "pipe"] });
+    if (proc.success) {
+      const output = new TextDecoder().decode(proc.stdout);
+      const files = output.trim().split(`
+`).filter((f) => f.length > 0).map((f) => f.replace(`${dir}/`, "")).slice(0, maxFiles);
+      return files;
+    }
+  } catch {}
+  return [];
+}
+async function readPackageManifest(projectRoot) {
+  const packageJsonPath = join29(projectRoot, "package.json");
+  if (!existsSync20(packageJsonPath)) {
+    return null;
+  }
+  try {
+    const content = await Bun.file(packageJsonPath).text();
+    const manifest = JSON.parse(content);
+    return {
+      name: manifest.name,
+      description: manifest.description,
+      scripts: manifest.scripts,
+      dependencies: manifest.dependencies
+    };
+  } catch {
+    return null;
+  }
+}
+async function readReadmeSnippet(projectRoot) {
+  const readmePath = join29(projectRoot, "README.md");
+  if (!existsSync20(readmePath)) {
+    return null;
+  }
+  try {
+    const content = await Bun.file(readmePath).text();
+    const lines = content.split(`
+`);
+    return lines.slice(0, 100).join(`
+`);
+  } catch {
+    return null;
+  }
+}
+async function detectEntryPoints(projectRoot) {
+  const candidates = ["src/index.ts", "src/main.ts", "main.go", "src/lib.rs"];
+  const found = [];
+  for (const candidate of candidates) {
+    const path12 = join29(projectRoot, candidate);
+    if (existsSync20(path12)) {
+      found.push(candidate);
+    }
+  }
+  return found;
+}
+async function detectConfigFiles(projectRoot) {
+  const candidates = ["tsconfig.json", "biome.json", "turbo.json", ".env.example"];
+  const found = [];
+  for (const candidate of candidates) {
+    const path12 = join29(projectRoot, candidate);
+    if (existsSync20(path12)) {
+      found.push(candidate);
+    }
+  }
+  return found;
+}
+async function scanProject(projectRoot) {
+  const fileTree = await findFiles(projectRoot, 200);
+  const packageManifest = await readPackageManifest(projectRoot);
+  const readmeSnippet = await readReadmeSnippet(projectRoot);
+  const entryPoints = await detectEntryPoints(projectRoot);
+  const configFiles = await detectConfigFiles(projectRoot);
+  const projectName = packageManifest?.name || basename(projectRoot);
+  return {
+    projectName,
+    fileTree,
+    packageManifest,
+    readmeSnippet,
+    entryPoints,
+    configFiles
+  };
+}
+function generateContextTemplate(scan) {
+  const lines = [];
+  lines.push(`# ${scan.projectName}
+`);
+  if (scan.packageManifest?.description) {
+    lines.push(`${scan.packageManifest.description}
+`);
+  } else {
+    lines.push(`<!-- TODO: Add project description -->
+`);
+  }
+  if (scan.entryPoints.length > 0) {
+    lines.push(`## Entry Points
+`);
+    for (const ep of scan.entryPoints) {
+      lines.push(`- ${ep}`);
+    }
+    lines.push("");
+  } else {
+    lines.push(`## Entry Points
+`);
+    lines.push(`<!-- TODO: Document entry points -->
+`);
+  }
+  if (scan.fileTree.length > 0) {
+    lines.push(`## Project Structure
+`);
+    lines.push("```");
+    for (const file2 of scan.fileTree.slice(0, 20)) {
+      lines.push(file2);
+    }
+    if (scan.fileTree.length > 20) {
+      lines.push(`... and ${scan.fileTree.length - 20} more files`);
+    }
+    lines.push("```\n");
+  } else {
+    lines.push(`## Project Structure
+`);
+    lines.push(`<!-- TODO: Document project structure -->
+`);
+  }
+  if (scan.configFiles.length > 0) {
+    lines.push(`## Configuration Files
+`);
+    for (const cf of scan.configFiles) {
+      lines.push(`- ${cf}`);
+    }
+    lines.push("");
+  } else {
+    lines.push(`## Configuration Files
+`);
+    lines.push(`<!-- TODO: Document configuration files -->
+`);
+  }
+  if (scan.packageManifest?.scripts) {
+    const hasScripts = Object.keys(scan.packageManifest.scripts).length > 0;
+    if (hasScripts) {
+      lines.push(`## Scripts
+`);
+      for (const [name, command] of Object.entries(scan.packageManifest.scripts)) {
+        lines.push(`- **${name}**: \`${command}\``);
+      }
+      lines.push("");
+    }
+  }
+  if (scan.packageManifest?.dependencies) {
+    const deps = Object.keys(scan.packageManifest.dependencies);
+    if (deps.length > 0) {
+      lines.push(`## Dependencies
+`);
+      lines.push(`<!-- TODO: Document key dependencies and their purpose -->
+`);
+    }
+  }
+  lines.push(`## Development Guidelines
+`);
+  lines.push(`<!-- TODO: Document development guidelines and conventions -->
+`);
+  return `${lines.join(`
+`).trim()}
+`;
+}
+async function generateContextWithLLM(scan) {
+  const logger = getLogger();
+  const scanSummary = `
+Project: ${scan.projectName}
+Entry Points: ${scan.entryPoints.join(", ") || "None detected"}
+Config Files: ${scan.configFiles.join(", ") || "None detected"}
+Total Files: ${scan.fileTree.length}
+Description: ${scan.packageManifest?.description || "Not provided"}
+`;
+  const prompt = `
+You are a technical documentation expert. Generate a concise, well-structured context.md file for a software project based on this scan:
+
+${scanSummary}
+
+The context.md should include:
+1. Project overview (name, purpose, key technologies)
+2. Entry points and main modules
+3. Key dependencies and why they're used
+4. Development setup and common commands
+5. Architecture overview (brief)
+6. Development guidelines
+
+Keep it under 2000 tokens. Use markdown formatting. Be specific to the detected stack and structure.
+`;
+  try {
+    const result = await _deps6.callLLM(prompt);
+    logger.info("init", "Generated context.md with LLM");
+    return result;
+  } catch (err) {
+    logger.warn("init", `LLM context generation failed, falling back to template: ${err instanceof Error ? err.message : String(err)}`);
+    return generateContextTemplate(scan);
+  }
+}
+function generatePackageContextTemplate(packagePath) {
+  const packageName = packagePath.split("/").pop() ?? packagePath;
+  return `# ${packageName} \u2014 Context
+
+<!-- Package-specific conventions. Root context.md provides shared rules. -->
+
+## Tech Stack
+
+<!-- TODO: Document this package's tech stack -->
+
+## Commands
+
+| Command | Purpose |
+|:--------|:--------|
+| \`bun test\` | Unit tests |
+
+## Development Guidelines
+
+<!-- TODO: Document package-specific guidelines -->
+`;
+}
+async function initPackage(repoRoot, packagePath, force = false) {
+  const logger = getLogger();
+  const packageDir = join29(repoRoot, packagePath);
+  const naxDir = join29(packageDir, "nax");
+  const contextPath = join29(naxDir, "context.md");
+  if (existsSync20(contextPath) && !force) {
+    logger.info("init", "Package context.md already exists (use --force to overwrite)", { path: contextPath });
+    return;
+  }
+  if (!existsSync20(naxDir)) {
+    await mkdir(naxDir, { recursive: true });
+  }
+  const content = generatePackageContextTemplate(packagePath);
+  await Bun.write(contextPath, content);
+  logger.info("init", "Created package context.md", { path: contextPath });
+}
+async function initContext(projectRoot, options = {}) {
+  const logger = getLogger();
+  const naxDir = join29(projectRoot, "nax");
+  const contextPath = join29(naxDir, "context.md");
+  if (existsSync20(contextPath) && !options.force) {
+    logger.info("init", "context.md already exists, skipping (use --force to overwrite)", { path: contextPath });
+    return;
+  }
+  if (!existsSync20(naxDir)) {
+    await mkdir(naxDir, { recursive: true });
+  }
+  const scan = await scanProject(projectRoot);
+  let content;
+  if (options.ai) {
+    content = await generateContextWithLLM(scan);
+  } else {
+    content = generateContextTemplate(scan);
+  }
+  await Bun.write(contextPath, content);
+  logger.info("init", "Generated nax/context.md template from project scan", { path: contextPath });
+}
+var _deps6;
+var init_init_context = __esm(() => {
+  init_logger2();
+  _deps6 = {
+    callLLM: async (_prompt) => {
+      throw new Error("callLLM not implemented");
+    }
+  };
+});
+
 // src/plugins/plugin-logger.ts
 function createPluginLogger(pluginName) {
   const stage = `plugin:${pluginName}`;
@@ -29980,11 +30349,11 @@ function getSafeLogger6() {
   return getSafeLogger();
 }
 function extractPluginName(pluginPath) {
-  const basename2 = path12.basename(pluginPath);
-  if (basename2 === "index.ts" || basename2 === "index.js" || basename2 === "index.mjs") {
+  const basename3 = path12.basename(pluginPath);
+  if (basename3 === "index.ts" || basename3 === "index.js" || basename3 === "index.mjs") {
     return path12.basename(path12.dirname(pluginPath));
   }
-  return basename2.replace(/\.(ts|js|mjs)$/, "");
+  return basename3.replace(/\.(ts|js|mjs)$/, "");
 }
 async function loadPlugins(globalDir, projectDir, configPlugins, projectRoot, disabledPlugins) {
   const loadedPlugins = [];
@@ -30155,7 +30524,7 @@ var init_loader5 = __esm(() => {
 });
 
 // src/precheck/checks-git.ts
-import { existsSync as existsSync25, statSync as statSync2 } from "fs";
+import { existsSync as existsSync27, statSync as statSync2 } from "fs";
 async function checkGitRepoExists(workdir) {
   const proc = Bun.spawn(["git", "rev-parse", "--git-dir"], {
     cwd: workdir,
@@ -30166,7 +30535,7 @@ async function checkGitRepoExists(workdir) {
   let passed = exitCode === 0;
   if (!passed) {
     const gitDir = `${workdir}/.git`;
-    if (existsSync25(gitDir)) {
+    if (existsSync27(gitDir)) {
       const stats = statSync2(gitDir);
       passed = stats.isDirectory();
     }
@@ -30238,10 +30607,10 @@ var init_checks_git = __esm(() => {
 });
 
 // src/precheck/checks-config.ts
-import { existsSync as existsSync26, statSync as statSync3 } from "fs";
+import { existsSync as existsSync28, statSync as statSync3 } from "fs";
 async function checkStaleLock(workdir) {
   const lockPath = `${workdir}/nax.lock`;
-  const exists = existsSync26(lockPath);
+  const exists = existsSync28(lockPath);
   if (!exists) {
     return {
       name: "no-stale-lock",
@@ -30326,7 +30695,7 @@ var init_checks_config = () => {};
 async function checkAgentCLI(config2) {
   const agent = config2.execution?.agent || "claude";
   try {
-    const proc = _deps7.spawn([agent, "--version"], {
+    const proc = _deps8.spawn([agent, "--version"], {
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -30347,15 +30716,15 @@ async function checkAgentCLI(config2) {
     };
   }
 }
-var _deps7;
+var _deps8;
 var init_checks_cli = __esm(() => {
-  _deps7 = {
+  _deps8 = {
     spawn: Bun.spawn
   };
 });
 
 // src/precheck/checks-system.ts
-import { existsSync as existsSync27, statSync as statSync4 } from "fs";
+import { existsSync as existsSync29, statSync as statSync4 } from "fs";
 async function checkDependenciesInstalled(workdir) {
   const depPaths = [
     { path: "node_modules" },
@@ -30367,7 +30736,7 @@ async function checkDependenciesInstalled(workdir) {
   const found = [];
   for (const { path: path14 } of depPaths) {
     const fullPath = `${workdir}/${path14}`;
-    if (existsSync27(fullPath)) {
+    if (existsSync29(fullPath)) {
       const stats = statSync4(fullPath);
       if (stats.isDirectory()) {
         found.push(path14);
@@ -30387,102 +30756,51 @@ async function checkTestCommand(config2) {
   if (!testCommand || testCommand === null) {
     return {
       name: "test-command-works",
-      tier: "blocker",
+      tier: "warning",
       passed: true,
-      message: "Test command not configured (skipped)"
-    };
-  }
-  const parts = testCommand.split(" ");
-  const [cmd, ...args] = parts;
-  try {
-    const proc = Bun.spawn([cmd, ...args, "--help"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const exitCode = await proc.exited;
-    const passed = exitCode === 0;
-    return {
-      name: "test-command-works",
-      tier: "blocker",
-      passed,
-      message: passed ? "Test command is available" : `Test command failed: ${testCommand}`
-    };
-  } catch {
-    return {
-      name: "test-command-works",
-      tier: "blocker",
-      passed: false,
-      message: `Test command failed: ${testCommand}`
+      message: "Test command not configured (will use default: bun test)"
     };
   }
+  return {
+    name: "test-command-works",
+    tier: "warning",
+    passed: true,
+    message: `Test command configured: ${testCommand}`
+  };
 }
 async function checkLintCommand(config2) {
   const lintCommand = config2.execution.lintCommand;
   if (!lintCommand || lintCommand === null) {
     return {
       name: "lint-command-works",
-      tier: "blocker",
+      tier: "warning",
       passed: true,
       message: "Lint command not configured (skipped)"
     };
   }
-  const parts = lintCommand.split(" ");
-  const [cmd, ...args] = parts;
-  try {
-    const proc = Bun.spawn([cmd, ...args, "--help"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const exitCode = await proc.exited;
-    const passed = exitCode === 0;
-    return {
-      name: "lint-command-works",
-      tier: "blocker",
-      passed,
-      message: passed ? "Lint command is available" : `Lint command failed: ${lintCommand}`
-    };
-  } catch {
-    return {
-      name: "lint-command-works",
-      tier: "blocker",
-      passed: false,
-      message: `Lint command failed: ${lintCommand}`
-    };
-  }
+  return {
+    name: "lint-command-works",
+    tier: "warning",
+    passed: true,
+    message: `Lint command configured: ${lintCommand}`
+  };
 }
 async function checkTypecheckCommand(config2) {
   const typecheckCommand = config2.execution.typecheckCommand;
   if (!typecheckCommand || typecheckCommand === null) {
     return {
       name: "typecheck-command-works",
-      tier: "blocker",
+      tier: "warning",
       passed: true,
       message: "Typecheck command not configured (skipped)"
     };
   }
-  const parts = typecheckCommand.split(" ");
-  const [cmd, ...args] = parts;
-  try {
-    const proc = Bun.spawn([cmd, ...args, "--help"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const exitCode = await proc.exited;
-    const passed = exitCode === 0;
-    return {
-      name: "typecheck-command-works",
-      tier: "blocker",
-      passed,
-      message: passed ? `Typecheck command is available: ${typecheckCommand}` : `Typecheck command failed: ${typecheckCommand}`
-    };
-  } catch {
-    return {
-      name: "typecheck-command-works",
-      tier: "blocker",
-      passed: false,
-      message: `Typecheck command failed: ${typecheckCommand}`
-    };
-  }
+  return {
+    name: "typecheck-command-works",
+    tier: "warning",
+    passed: true,
+    message: `Typecheck command configured: ${typecheckCommand}`
+  };
 }
 var init_checks_system = () => {};
 
@@ -30495,11 +30813,11 @@ var init_checks_blockers = __esm(() => {
 });
 
 // src/precheck/checks-warnings.ts
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 import { isAbsolute as isAbsolute6 } from "path";
 async function checkClaudeMdExists(workdir) {
   const claudeMdPath = `${workdir}/CLAUDE.md`;
-  const passed = existsSync28(claudeMdPath);
+  const passed = existsSync30(claudeMdPath);
   return {
     name: "claude-md-exists",
     tier: "warning",
@@ -30579,7 +30897,7 @@ async function hasPackageScript(workdir, name) {
 }
 async function checkGitignoreCoversNax(workdir) {
   const gitignorePath = `${workdir}/.gitignore`;
-  const exists = existsSync28(gitignorePath);
+  const exists = existsSync30(gitignorePath);
   if (!exists) {
     return {
       name: "gitignore-covers-nax",
@@ -30614,7 +30932,7 @@ async function checkPromptOverrideFiles(config2, workdir) {
   const checks3 = [];
   for (const [role, relativePath] of Object.entries(config2.prompts.overrides)) {
     const resolvedPath = `${workdir}/${relativePath}`;
-    const exists = existsSync28(resolvedPath);
+    const exists = existsSync30(resolvedPath);
     if (!exists) {
       checks3.push({
         name: `prompt-override-${role}`,
@@ -30994,19 +31312,19 @@ var init_precheck = __esm(() => {
 });
 
 // src/hooks/runner.ts
-import { join as join37 } from "path";
+import { join as join42 } from "path";
 async function loadHooksConfig(projectDir, globalDir) {
   let globalHooks = { hooks: {} };
   let projectHooks = { hooks: {} };
   let skipGlobal = false;
-  const projectPath = join37(projectDir, "hooks.json");
+  const projectPath = join42(projectDir, "hooks.json");
   const projectData = await loadJsonFile(projectPath, "hooks");
   if (projectData) {
     projectHooks = projectData;
     skipGlobal = projectData.skipGlobal ?? false;
   }
   if (!skipGlobal && globalDir) {
-    const globalPath = join37(globalDir, "hooks.json");
+    const globalPath = join42(globalDir, "hooks.json");
     const globalData = await loadJsonFile(globalPath, "hooks");
     if (globalData) {
       globalHooks = globalData;
@@ -32028,13 +32346,13 @@ var exports_manager = {};
 __export(exports_manager, {
   WorktreeManager: () => WorktreeManager
 });
-import { existsSync as existsSync30, symlinkSync } from "fs";
-import { join as join38 } from "path";
+import { existsSync as existsSync32, symlinkSync } from "fs";
+import { join as join43 } from "path";
 
 class WorktreeManager {
   async create(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join38(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join43(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const proc = Bun.spawn(["git", "worktree", "add", worktreePath, "-b", branchName], {
@@ -32059,9 +32377,9 @@ class WorktreeManager {
       }
       throw new Error(`Failed to create worktree: ${String(error48)}`);
     }
-    const nodeModulesSource = join38(projectRoot, "node_modules");
-    if (existsSync30(nodeModulesSource)) {
-      const nodeModulesTarget = join38(worktreePath, "node_modules");
+    const nodeModulesSource = join43(projectRoot, "node_modules");
+    if (existsSync32(nodeModulesSource)) {
+      const nodeModulesTarget = join43(worktreePath, "node_modules");
       try {
         symlinkSync(nodeModulesSource, nodeModulesTarget, "dir");
       } catch (error48) {
@@ -32069,9 +32387,9 @@ class WorktreeManager {
         throw new Error(`Failed to symlink node_modules: ${errorMessage(error48)}`);
       }
     }
-    const envSource = join38(projectRoot, ".env");
-    if (existsSync30(envSource)) {
-      const envTarget = join38(worktreePath, ".env");
+    const envSource = join43(projectRoot, ".env");
+    if (existsSync32(envSource)) {
+      const envTarget = join43(worktreePath, ".env");
       try {
         symlinkSync(envSource, envTarget, "file");
       } catch (error48) {
@@ -32082,7 +32400,7 @@ class WorktreeManager {
   }
   async remove(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join38(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join43(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const proc = Bun.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
@@ -32472,7 +32790,7 @@ var init_parallel_worker = __esm(() => {
 
 // src/execution/parallel-coordinator.ts
 import os3 from "os";
-import { join as join39 } from "path";
+import { join as join44 } from "path";
 function groupStoriesByDependencies(stories) {
   const batches = [];
   const processed = new Set;
@@ -32550,7 +32868,7 @@ async function executeParallel(stories, prdPath, projectRoot, config2, hooks, pl
     };
     const worktreePaths = new Map;
     for (const story of batch) {
-      const worktreePath = join39(projectRoot, ".nax-wt", story.id);
+      const worktreePath = join44(projectRoot, ".nax-wt", story.id);
       try {
         await worktreeManager.create(projectRoot, story.id);
         worktreePaths.set(story.id, worktreePath);
@@ -32599,7 +32917,7 @@ async function executeParallel(stories, prdPath, projectRoot, config2, hooks, pl
           });
           logger?.warn("parallel", "Worktree preserved for manual conflict resolution", {
             storyId: mergeResult.storyId,
-            worktreePath: join39(projectRoot, ".nax-wt", mergeResult.storyId)
+            worktreePath: join44(projectRoot, ".nax-wt", mergeResult.storyId)
           });
         }
       }
@@ -33056,20 +33374,20 @@ var init_parallel_executor = __esm(() => {
 });
 
 // src/pipeline/subscribers/events-writer.ts
-import { appendFile as appendFile2, mkdir } from "fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir2 } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { basename as basename3, join as join40 } from "path";
+import { basename as basename4, join as join45 } from "path";
 function wireEventsWriter(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
-  const project = basename3(workdir);
-  const eventsDir = join40(homedir7(), ".nax", "events", project);
-  const eventsFile = join40(eventsDir, "events.jsonl");
+  const project = basename4(workdir);
+  const eventsDir = join45(homedir7(), ".nax", "events", project);
+  const eventsFile = join45(eventsDir, "events.jsonl");
   let dirReady = false;
   const write = (line) => {
     (async () => {
       try {
         if (!dirReady) {
-          await mkdir(eventsDir, { recursive: true });
+          await mkdir2(eventsDir, { recursive: true });
           dirReady = true;
         }
         await appendFile2(eventsFile, `${JSON.stringify(line)}
@@ -33221,25 +33539,25 @@ var init_interaction2 = __esm(() => {
 });
 
 // src/pipeline/subscribers/registry.ts
-import { mkdir as mkdir2, writeFile } from "fs/promises";
+import { mkdir as mkdir3, writeFile } from "fs/promises";
 import { homedir as homedir8 } from "os";
-import { basename as basename4, join as join41 } from "path";
+import { basename as basename5, join as join46 } from "path";
 function wireRegistry(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
-  const project = basename4(workdir);
-  const runDir = join41(homedir8(), ".nax", "runs", `${project}-${feature}-${runId}`);
-  const metaFile = join41(runDir, "meta.json");
+  const project = basename5(workdir);
+  const runDir = join46(homedir8(), ".nax", "runs", `${project}-${feature}-${runId}`);
+  const metaFile = join46(runDir, "meta.json");
   const unsub = bus.on("run:started", (_ev) => {
     (async () => {
       try {
-        await mkdir2(runDir, { recursive: true });
+        await mkdir3(runDir, { recursive: true });
         const meta3 = {
           runId,
           project,
           feature,
           workdir,
-          statusPath: join41(workdir, "nax", "features", feature, "status.json"),
-          eventsDir: join41(workdir, "nax", "features", feature, "runs"),
+          statusPath: join46(workdir, "nax", "features", feature, "status.json"),
+          eventsDir: join46(workdir, "nax", "features", feature, "runs"),
           registeredAt: new Date().toISOString()
         };
         await writeFile(metaFile, JSON.stringify(meta3, null, 2));
@@ -34235,7 +34553,7 @@ async function writeStatusFile(filePath, status) {
 var init_status_file = () => {};
 
 // src/execution/status-writer.ts
-import { join as join42 } from "path";
+import { join as join47 } from "path";
 
 class StatusWriter {
   statusFile;
@@ -34303,7 +34621,7 @@ class StatusWriter {
     if (!this._prd)
       return;
     const safeLogger = getSafeLogger();
-    const featureStatusPath = join42(featureDir, "status.json");
+    const featureStatusPath = join47(featureDir, "status.json");
     try {
       const base = this.getSnapshot(totalCost, iterations);
       if (!base) {
@@ -65626,9 +65944,9 @@ var require_jsx_dev_runtime = __commonJS((exports, module) => {
 
 // bin/nax.ts
 init_source();
-import { existsSync as existsSync32, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync6 } from "fs";
 import { homedir as homedir10 } from "os";
-import { join as join43 } from "path";
+import { join as join48 } from "path";
 
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -66113,10 +66431,528 @@ async function generateAcceptanceTestsForFeature(specContent, featureName, featu
 }
 // src/cli/plan.ts
 init_registry();
-import { existsSync as existsSync9 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { join as join12 } from "path";
 import { createInterface } from "readline";
 init_test_strategy();
+
+// src/context/generator.ts
+init_path_security2();
+import { existsSync as existsSync10, readFileSync } from "fs";
+import { join as join11 } from "path";
+
+// src/context/injector.ts
+import { existsSync as existsSync9 } from "fs";
+import { join as join10 } from "path";
+var NOTABLE_NODE_DEPS = [
+  "@nestjs",
+  "express",
+  "fastify",
+  "koa",
+  "hono",
+  "next",
+  "nuxt",
+  "react",
+  "vue",
+  "svelte",
+  "solid",
+  "prisma",
+  "typeorm",
+  "mongoose",
+  "drizzle",
+  "sequelize",
+  "jest",
+  "vitest",
+  "mocha",
+  "bun",
+  "zod",
+  "typescript",
+  "graphql",
+  "trpc",
+  "bull",
+  "ioredis"
+];
+async function detectNode(workdir) {
+  const pkgPath = join10(workdir, "package.json");
+  if (!existsSync9(pkgPath))
+    return null;
+  try {
+    const file2 = Bun.file(pkgPath);
+    const pkg = await file2.json();
+    const allDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+    const notable = [
+      ...new Set(Object.keys(allDeps).filter((dep) => NOTABLE_NODE_DEPS.some((kw) => dep === kw || dep.startsWith(`${kw}/`) || dep.includes(kw))))
+    ].slice(0, 10);
+    const lang = pkg.devDependencies?.typescript || pkg.dependencies?.typescript ? "TypeScript" : "JavaScript";
+    return { name: pkg.name, lang, dependencies: notable };
+  } catch {
+    return null;
+  }
+}
+async function detectGo(workdir) {
+  const goMod = join10(workdir, "go.mod");
+  if (!existsSync9(goMod))
+    return null;
+  try {
+    const content = await Bun.file(goMod).text();
+    const moduleMatch = content.match(/^module\s+(\S+)/m);
+    const name = moduleMatch?.[1];
+    const requires = [];
+    const requireBlock = content.match(/require\s*\(([^)]+)\)/s)?.[1] ?? "";
+    for (const line of requireBlock.split(`
+`)) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("//") && !trimmed.includes("// indirect")) {
+        const dep = trimmed.split(/\s+/)[0];
+        if (dep)
+          requires.push(dep.split("/").slice(-1)[0]);
+      }
+    }
+    return { name, lang: "Go", dependencies: requires.slice(0, 10) };
+  } catch {
+    return null;
+  }
+}
+async function detectRust(workdir) {
+  const cargoPath = join10(workdir, "Cargo.toml");
+  if (!existsSync9(cargoPath))
+    return null;
+  try {
+    const content = await Bun.file(cargoPath).text();
+    const nameMatch = content.match(/^\[package\][^[]*name\s*=\s*"([^"]+)"/ms);
+    const name = nameMatch?.[1];
+    const depsSection = content.match(/^\[dependencies\]([^[]*)/ms)?.[1] ?? "";
+    const deps = depsSection.split(`
+`).map((l) => l.split("=")[0].trim()).filter((l) => l && !l.startsWith("#")).slice(0, 10);
+    return { name, lang: "Rust", dependencies: deps };
+  } catch {
+    return null;
+  }
+}
+async function detectPython(workdir) {
+  const pyproject = join10(workdir, "pyproject.toml");
+  const requirements = join10(workdir, "requirements.txt");
+  if (!existsSync9(pyproject) && !existsSync9(requirements))
+    return null;
+  try {
+    if (existsSync9(pyproject)) {
+      const content = await Bun.file(pyproject).text();
+      const nameMatch = content.match(/^\s*name\s*=\s*"([^"]+)"/m);
+      const depsSection = content.match(/^\[project\][^[]*dependencies\s*=\s*\[([^\]]*)\]/ms)?.[1] ?? "";
+      const deps = depsSection.split(",").map((d) => d.trim().replace(/["'\s>=<!^~].*/g, "")).filter(Boolean).slice(0, 10);
+      return { name: nameMatch?.[1], lang: "Python", dependencies: deps };
+    }
+    const lines = (await Bun.file(requirements).text()).split(`
+`).map((l) => l.split(/[>=<!]/)[0].trim()).filter((l) => l && !l.startsWith("#")).slice(0, 10);
+    return { lang: "Python", dependencies: lines };
+  } catch {
+    return null;
+  }
+}
+async function detectPhp(workdir) {
+  const composerPath = join10(workdir, "composer.json");
+  if (!existsSync9(composerPath))
+    return null;
+  try {
+    const file2 = Bun.file(composerPath);
+    const composer = await file2.json();
+    const deps = Object.keys({ ...composer.require ?? {}, ...composer["require-dev"] ?? {} }).filter((d) => d !== "php").map((d) => d.split("/").pop() ?? d).slice(0, 10);
+    return { name: composer.name, lang: "PHP", dependencies: deps };
+  } catch {
+    return null;
+  }
+}
+async function detectRuby(workdir) {
+  const gemfile = join10(workdir, "Gemfile");
+  if (!existsSync9(gemfile))
+    return null;
+  try {
+    const content = await Bun.file(gemfile).text();
+    const gems = [...content.matchAll(/^\s*gem\s+['"]([^'"]+)['"]/gm)].map((m) => m[1]).slice(0, 10);
+    return { lang: "Ruby", dependencies: gems };
+  } catch {
+    return null;
+  }
+}
+async function detectJvm(workdir) {
+  const pom = join10(workdir, "pom.xml");
+  const gradle = join10(workdir, "build.gradle");
+  const gradleKts = join10(workdir, "build.gradle.kts");
+  if (!existsSync9(pom) && !existsSync9(gradle) && !existsSync9(gradleKts))
+    return null;
+  try {
+    if (existsSync9(pom)) {
+      const content2 = await Bun.file(pom).text();
+      const nameMatch = content2.match(/<artifactId>([^<]+)<\/artifactId>/);
+      const deps2 = [...content2.matchAll(/<artifactId>([^<]+)<\/artifactId>/g)].map((m) => m[1]).filter((d) => d !== nameMatch?.[1]).slice(0, 10);
+      const lang2 = existsSync9(join10(workdir, "src/main/kotlin")) ? "Kotlin" : "Java";
+      return { name: nameMatch?.[1], lang: lang2, dependencies: deps2 };
+    }
+    const gradleFile = existsSync9(gradleKts) ? gradleKts : gradle;
+    const content = await Bun.file(gradleFile).text();
+    const lang = gradleFile.endsWith(".kts") ? "Kotlin" : "Java";
+    const deps = [...content.matchAll(/implementation[^'"]*['"]([^:'"]+:[^:'"]+)[^'"]*['"]/g)].map((m) => m[1].split(":").pop() ?? m[1]).slice(0, 10);
+    return { lang, dependencies: deps };
+  } catch {
+    return null;
+  }
+}
+async function buildProjectMetadata(workdir, config2) {
+  const detected = await detectGo(workdir) ?? await detectRust(workdir) ?? await detectPython(workdir) ?? await detectPhp(workdir) ?? await detectRuby(workdir) ?? await detectJvm(workdir) ?? await detectNode(workdir);
+  return {
+    name: detected?.name,
+    language: detected?.lang,
+    dependencies: detected?.dependencies ?? [],
+    testCommand: config2.execution?.testCommand ?? undefined,
+    lintCommand: config2.execution?.lintCommand ?? undefined,
+    typecheckCommand: config2.execution?.typecheckCommand ?? undefined
+  };
+}
+function formatMetadataSection(metadata) {
+  const lines = ["## Project Metadata", "", "> Auto-injected by `nax generate`", ""];
+  if (metadata.name) {
+    lines.push(`**Project:** \`${metadata.name}\``);
+    lines.push("");
+  }
+  if (metadata.language) {
+    lines.push(`**Language:** ${metadata.language}`);
+    lines.push("");
+  }
+  if (metadata.dependencies.length > 0) {
+    lines.push(`**Key dependencies:** ${metadata.dependencies.join(", ")}`);
+    lines.push("");
+  }
+  const commands = [];
+  if (metadata.testCommand)
+    commands.push(`test: \`${metadata.testCommand}\``);
+  if (metadata.lintCommand)
+    commands.push(`lint: \`${metadata.lintCommand}\``);
+  if (metadata.typecheckCommand)
+    commands.push(`typecheck: \`${metadata.typecheckCommand}\``);
+  if (commands.length > 0) {
+    lines.push(`**Commands:** ${commands.join(" | ")}`);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  return lines.join(`
+`);
+}
+
+// src/context/generators/aider.ts
+function generateAiderConfig(context) {
+  const header = `# Aider Configuration
+# Auto-generated from nax/context.md \u2014 run \`nax generate\` to regenerate.
+# DO NOT EDIT MANUALLY
+
+# Project instructions
+instructions: |
+`;
+  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
+  const combined = metaSection + context.markdown;
+  const indented = combined.split(`
+`).map((line) => `  ${line}`).join(`
+`);
+  return `${header}${indented}
+`;
+}
+var aiderGenerator = {
+  name: "aider",
+  outputFile: ".aider.conf.yml",
+  generate: generateAiderConfig
+};
+
+// src/context/generators/claude.ts
+function generateClaudeConfig(context) {
+  const header = `# Project Context
+
+This file is auto-generated from \`nax/context.md\`.
+DO NOT EDIT MANUALLY \u2014 run \`nax generate\` to regenerate.
+
+---
+
+`;
+  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
+  return header + metaSection + context.markdown;
+}
+var claudeGenerator = {
+  name: "claude",
+  outputFile: "CLAUDE.md",
+  generate: generateClaudeConfig
+};
+
+// src/context/generators/codex.ts
+function generateCodexConfig(context) {
+  const header = `# Codex Instructions
+
+This file is auto-generated from \`nax/context.md\`.
+DO NOT EDIT MANUALLY \u2014 run \`nax generate\` to regenerate.
+
+---
+
+`;
+  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
+  return header + metaSection + context.markdown;
+}
+var codexGenerator = {
+  name: "codex",
+  outputFile: "codex.md",
+  generate: generateCodexConfig
+};
+
+// src/context/generators/cursor.ts
+function generateCursorRules(context) {
+  const header = `# Project Rules
+
+Auto-generated from nax/context.md \u2014 run \`nax generate\` to regenerate.
+DO NOT EDIT MANUALLY
+
+---
+
+`;
+  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
+  return header + metaSection + context.markdown;
+}
+var cursorGenerator = {
+  name: "cursor",
+  outputFile: ".cursorrules",
+  generate: generateCursorRules
+};
+
+// src/context/generators/gemini.ts
+function generateGeminiConfig(context) {
+  const header = `# Gemini CLI Context
+
+This file is auto-generated from \`nax/context.md\`.
+DO NOT EDIT MANUALLY \u2014 run \`nax generate\` to regenerate.
+
+---
+
+`;
+  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
+  return header + metaSection + context.markdown;
+}
+var geminiGenerator = {
+  name: "gemini",
+  outputFile: "GEMINI.md",
+  generate: generateGeminiConfig
+};
+
+// src/context/generators/opencode.ts
+function generateOpencodeConfig(context) {
+  const header = `# Agent Instructions
+
+This file is auto-generated from \`nax/context.md\`.
+DO NOT EDIT MANUALLY \u2014 run \`nax generate\` to regenerate.
+
+These instructions apply to all AI coding agents in this project.
+
+---
+
+`;
+  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
+  return header + metaSection + context.markdown;
+}
+var opencodeGenerator = {
+  name: "opencode",
+  outputFile: "AGENTS.md",
+  generate: generateOpencodeConfig
+};
+
+// src/context/generators/windsurf.ts
+function generateWindsurfRules(context) {
+  const header = `# Windsurf Project Rules
+
+Auto-generated from nax/context.md \u2014 run \`nax generate\` to regenerate.
+DO NOT EDIT MANUALLY
+
+---
+
+`;
+  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
+  return header + metaSection + context.markdown;
+}
+var windsurfGenerator = {
+  name: "windsurf",
+  outputFile: ".windsurfrules",
+  generate: generateWindsurfRules
+};
+
+// src/context/generator.ts
+var GENERATORS = {
+  claude: claudeGenerator,
+  codex: codexGenerator,
+  opencode: opencodeGenerator,
+  cursor: cursorGenerator,
+  windsurf: windsurfGenerator,
+  aider: aiderGenerator,
+  gemini: geminiGenerator
+};
+async function loadContextContent(options, config2) {
+  if (!existsSync10(options.contextPath)) {
+    throw new Error(`Context file not found: ${options.contextPath}`);
+  }
+  const file2 = Bun.file(options.contextPath);
+  const markdown = await file2.text();
+  const autoInject = options.autoInject ?? true;
+  const metadata = autoInject ? await buildProjectMetadata(options.workdir, config2) : undefined;
+  return { markdown, metadata };
+}
+async function generateFor(agent, options, config2) {
+  const generator = GENERATORS[agent];
+  if (!generator) {
+    return { agent, outputFile: "", content: "", written: false, error: `Unknown agent: ${agent}` };
+  }
+  try {
+    const context = await loadContextContent(options, config2);
+    const content = generator.generate(context);
+    const outputPath = join11(options.outputDir, generator.outputFile);
+    validateFilePath(outputPath, options.outputDir);
+    if (!options.dryRun) {
+      await Bun.write(outputPath, content);
+    }
+    return { agent, outputFile: generator.outputFile, content, written: !options.dryRun };
+  } catch (err) {
+    const error48 = err instanceof Error ? err.message : String(err);
+    return { agent, outputFile: generator.outputFile, content: "", written: false, error: error48 };
+  }
+}
+async function generateAll(options, config2) {
+  const context = await loadContextContent(options, config2);
+  const results = [];
+  for (const [agentKey, generator] of Object.entries(GENERATORS)) {
+    try {
+      const content = generator.generate(context);
+      const outputPath = join11(options.outputDir, generator.outputFile);
+      validateFilePath(outputPath, options.outputDir);
+      if (!options.dryRun) {
+        await Bun.write(outputPath, content);
+      }
+      results.push({ agent: agentKey, outputFile: generator.outputFile, content, written: !options.dryRun });
+    } catch (err) {
+      const error48 = err instanceof Error ? err.message : String(err);
+      results.push({ agent: agentKey, outputFile: generator.outputFile, content: "", written: false, error: error48 });
+    }
+  }
+  return results;
+}
+async function discoverPackages(repoRoot) {
+  const packages = [];
+  const seen = new Set;
+  for (const pattern of ["*/nax/context.md", "*/*/nax/context.md"]) {
+    const glob = new Bun.Glob(pattern);
+    for await (const match of glob.scan(repoRoot)) {
+      const pkgRelative = match.replace(/\/nax\/context\.md$/, "");
+      const pkgAbsolute = join11(repoRoot, pkgRelative);
+      if (!seen.has(pkgAbsolute)) {
+        seen.add(pkgAbsolute);
+        packages.push(pkgAbsolute);
+      }
+    }
+  }
+  return packages;
+}
+async function discoverWorkspacePackages(repoRoot) {
+  const existing = await discoverPackages(repoRoot);
+  if (existing.length > 0) {
+    return existing.map((p) => p.replace(`${repoRoot}/`, ""));
+  }
+  const seen = new Set;
+  const results = [];
+  async function resolveGlobs(patterns) {
+    for (const pattern of patterns) {
+      if (pattern.startsWith("!"))
+        continue;
+      const base = pattern.replace(/\/+$/, "");
+      const pkgPattern = base.endsWith("*") ? `${base}/package.json` : `${base}/*/package.json`;
+      const g = new Bun.Glob(pkgPattern);
+      for await (const match of g.scan(repoRoot)) {
+        const rel = match.replace(/\/package\.json$/, "");
+        if (!seen.has(rel)) {
+          seen.add(rel);
+          results.push(rel);
+        }
+      }
+    }
+  }
+  const turboPath = join11(repoRoot, "turbo.json");
+  if (existsSync10(turboPath)) {
+    try {
+      const turbo = JSON.parse(readFileSync(turboPath, "utf-8"));
+      if (Array.isArray(turbo.packages)) {
+        await resolveGlobs(turbo.packages);
+      }
+    } catch {}
+  }
+  const pkgPath = join11(repoRoot, "package.json");
+  if (existsSync10(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      const ws = pkg.workspaces;
+      const patterns = Array.isArray(ws) ? ws : Array.isArray(ws?.packages) ? ws.packages : [];
+      if (patterns.length > 0)
+        await resolveGlobs(patterns);
+    } catch {}
+  }
+  const pnpmPath = join11(repoRoot, "pnpm-workspace.yaml");
+  if (existsSync10(pnpmPath)) {
+    try {
+      const raw = readFileSync(pnpmPath, "utf-8");
+      const lines = raw.split(`
+`);
+      let inPackages = false;
+      const patterns = [];
+      for (const line of lines) {
+        if (/^packages\s*:/.test(line)) {
+          inPackages = true;
+          continue;
+        }
+        if (inPackages && /^\s+-\s+/.test(line)) {
+          patterns.push(line.replace(/^\s+-\s+['"]?/, "").replace(/['"]?\s*$/, ""));
+        } else if (inPackages && !/^\s/.test(line)) {
+          break;
+        }
+      }
+      if (patterns.length > 0)
+        await resolveGlobs(patterns);
+    } catch {}
+  }
+  return results.sort();
+}
+async function generateForPackage(packageDir, config2, dryRun = false) {
+  const contextPath = join11(packageDir, "nax", "context.md");
+  if (!existsSync10(contextPath)) {
+    return {
+      packageDir,
+      outputFile: "CLAUDE.md",
+      content: "",
+      written: false,
+      error: `context.md not found: ${contextPath}`
+    };
+  }
+  try {
+    const options = {
+      contextPath,
+      outputDir: packageDir,
+      workdir: packageDir,
+      dryRun,
+      autoInject: true
+    };
+    const result = await generateFor("claude", options, config2);
+    return {
+      packageDir,
+      outputFile: result.outputFile,
+      content: result.content,
+      written: result.written,
+      error: result.error
+    };
+  } catch (err) {
+    const error48 = err instanceof Error ? err.message : String(err);
+    return { packageDir, outputFile: "CLAUDE.md", content: "", written: false, error: error48 };
+  }
+}
+
+// src/cli/plan.ts
 init_pid_registry();
 init_logger2();
 
@@ -66202,6 +67038,20 @@ function validateStory(raw, index, allIds) {
   }
   const rawTags = s.tags;
   const tags = Array.isArray(rawTags) ? rawTags : [];
+  const rawWorkdir = s.workdir;
+  let workdir;
+  if (rawWorkdir !== undefined && rawWorkdir !== null) {
+    if (typeof rawWorkdir !== "string") {
+      throw new Error(`[schema] story[${index}].workdir must be a string`);
+    }
+    if (rawWorkdir.startsWith("/")) {
+      throw new Error(`[schema] story[${index}].workdir must be relative (no leading /): "${rawWorkdir}"`);
+    }
+    if (rawWorkdir.includes("..")) {
+      throw new Error(`[schema] story[${index}].workdir must not contain '..': "${rawWorkdir}"`);
+    }
+    workdir = rawWorkdir;
+  }
   return {
     id,
     title: title.trim(),
@@ -66217,7 +67067,8 @@ function validateStory(raw, index, allIds) {
       complexity,
       testStrategy,
       reasoning: "validated from LLM output"
-    }
+    },
+    ...workdir !== undefined ? { workdir } : {}
   };
 }
 function parseRawString(text) {
@@ -66268,36 +67119,47 @@ var _deps2 = {
   writeFile: (path, content) => Bun.write(path, content).then(() => {}),
   scanCodebase: (workdir) => scanCodebase(workdir),
   getAgent: (name, cfg) => cfg ? createAgentRegistry(cfg).getAgent(name) : getAgent(name),
-  readPackageJson: (workdir) => Bun.file(join10(workdir, "package.json")).json().catch(() => null),
+  readPackageJson: (workdir) => Bun.file(join12(workdir, "package.json")).json().catch(() => null),
   spawnSync: (cmd, opts) => {
     const result = Bun.spawnSync(cmd, opts ? { cwd: opts.cwd } : {});
     return { stdout: result.stdout, exitCode: result.exitCode };
   },
   mkdirp: (path) => Bun.spawn(["mkdir", "-p", path]).exited.then(() => {}),
-  existsSync: (path) => existsSync9(path)
+  existsSync: (path) => existsSync11(path),
+  discoverWorkspacePackages: (repoRoot) => discoverWorkspacePackages(repoRoot),
+  readPackageJsonAt: (path) => Bun.file(path).json().catch(() => null),
+  createInteractionBridge: () => createCliInteractionBridge()
 };
 async function planCommand(workdir, config2, options) {
-  const naxDir = join10(workdir, "nax");
-  if (!existsSync9(naxDir)) {
+  const naxDir = join12(workdir, "nax");
+  if (!existsSync11(naxDir)) {
     throw new Error(`nax directory not found. Run 'nax init' first in ${workdir}`);
   }
   const logger = getLogger();
   logger?.info("plan", "Reading spec", { from: options.from });
   const specContent = await _deps2.readFile(options.from);
   logger?.info("plan", "Scanning codebase...");
-  const scan = await _deps2.scanCodebase(workdir);
+  const [scan, discoveredPackages, pkg] = await Promise.all([
+    _deps2.scanCodebase(workdir),
+    _deps2.discoverWorkspacePackages(workdir),
+    _deps2.readPackageJson(workdir)
+  ]);
   const codebaseContext = buildCodebaseContext2(scan);
-  const pkg = await _deps2.readPackageJson(workdir);
+  const relativePackages = discoveredPackages.map((p) => p.startsWith("/") ? p.replace(`${workdir}/`, "") : p);
+  const packageDetails = relativePackages.length > 0 ? await Promise.all(relativePackages.map(async (rel) => {
+    const pkgJson = await _deps2.readPackageJsonAt(join12(workdir, rel, "package.json"));
+    return buildPackageSummary(rel, pkgJson);
+  })) : [];
   const projectName = detectProjectName(workdir, pkg);
   const branchName = options.branch ?? `feat/${options.feature}`;
-  const outputDir = join10(naxDir, "features", options.feature);
-  const outputPath = join10(outputDir, "prd.json");
+  const outputDir = join12(naxDir, "features", options.feature);
+  const outputPath = join12(outputDir, "prd.json");
   await _deps2.mkdirp(outputDir);
   const agentName = config2?.autoMode?.defaultAgent ?? "claude";
   const timeoutSeconds = config2?.execution?.sessionTimeoutSeconds ?? 600;
   let rawResponse;
   if (options.auto) {
-    const prompt = buildPlanningPrompt(specContent, codebaseContext);
+    const prompt = buildPlanningPrompt(specContent, codebaseContext, undefined, relativePackages, packageDetails);
     const cliAdapter = _deps2.getAgent(agentName);
     if (!cliAdapter)
       throw new Error(`[plan] No agent adapter found for '${agentName}'`);
@@ -66309,11 +67171,11 @@ async function planCommand(workdir, config2, options) {
       }
     } catch {}
   } else {
-    const prompt = buildPlanningPrompt(specContent, codebaseContext, outputPath);
+    const prompt = buildPlanningPrompt(specContent, codebaseContext, outputPath, relativePackages, packageDetails);
     const adapter = _deps2.getAgent(agentName, config2);
     if (!adapter)
       throw new Error(`[plan] No agent adapter found for '${agentName}'`);
-    const interactionBridge = createCliInteractionBridge();
+    const interactionBridge = _deps2.createInteractionBridge();
     const pidRegistry = new PidRegistry(workdir);
     const resolvedPerm = resolvePermissions(config2, "plan");
     const resolvedModel = config2?.plan?.model ?? "balanced";
@@ -66391,6 +67253,66 @@ function detectProjectName(workdir, pkg) {
   }
   return "unknown";
 }
+var FRAMEWORK_PATTERNS = [
+  [/\bnext\b/, "Next.js"],
+  [/\bnuxt\b/, "Nuxt"],
+  [/\bremix\b/, "Remix"],
+  [/\bexpress\b/, "Express"],
+  [/\bfastify\b/, "Fastify"],
+  [/\bhono\b/, "Hono"],
+  [/\bnestjs|@nestjs\b/, "NestJS"],
+  [/\breact\b/, "React"],
+  [/\bvue\b/, "Vue"],
+  [/\bsvelte\b/, "Svelte"],
+  [/\bastro\b/, "Astro"],
+  [/\belectron\b/, "Electron"]
+];
+var TEST_RUNNER_PATTERNS = [
+  [/\bvitest\b/, "vitest"],
+  [/\bjest\b/, "jest"],
+  [/\bmocha\b/, "mocha"],
+  [/\bava\b/, "ava"]
+];
+var KEY_DEP_PATTERNS = [
+  [/\bprisma\b/, "prisma"],
+  [/\bdrizzle-orm\b/, "drizzle"],
+  [/\btypeorm\b/, "typeorm"],
+  [/\bmongoose\b/, "mongoose"],
+  [/\bsqlite\b|better-sqlite/, "sqlite"],
+  [/\bstripe\b/, "stripe"],
+  [/\bgraphql\b/, "graphql"],
+  [/\btrpc\b/, "tRPC"],
+  [/\bzod\b/, "zod"],
+  [/\btailwind\b/, "tailwind"]
+];
+function buildPackageSummary(rel, pkg) {
+  const name = typeof pkg?.name === "string" ? pkg.name : rel;
+  const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+  const depNames = Object.keys(allDeps).join(" ");
+  const scripts = pkg?.scripts ?? {};
+  const testScript = scripts.test ?? "";
+  const runtime = testScript.includes("bun ") ? "bun" : testScript.includes("node ") ? "node" : "unknown";
+  const framework = FRAMEWORK_PATTERNS.find(([re]) => re.test(depNames))?.[1] ?? "";
+  const testRunner = TEST_RUNNER_PATTERNS.find(([re]) => re.test(depNames))?.[1] ?? (testScript.includes("bun test") ? "bun:test" : "");
+  const keyDeps = KEY_DEP_PATTERNS.filter(([re]) => re.test(depNames)).map(([, label]) => label);
+  return { path: rel, name, runtime, framework, testRunner, keyDeps };
+}
+function buildPackageDetailsSection(details) {
+  if (details.length === 0)
+    return "";
+  const rows = details.map((d) => {
+    const stack = [d.framework, d.testRunner, ...d.keyDeps].filter(Boolean).join(", ") || "\u2014";
+    return `| \`${d.path}\` | ${d.name} | ${stack} |`;
+  });
+  return `
+## Package Tech Stacks
+
+| Path | Package | Stack |
+|:-----|:--------|:------|
+${rows.join(`
+`)}
+`;
+}
 function buildCodebaseContext2(scan) {
   const sections = [];
   sections.push(`## Codebase Structure
@@ -66417,7 +67339,19 @@ function buildCodebaseContext2(scan) {
   return sections.join(`
 `);
 }
-function buildPlanningPrompt(specContent, codebaseContext, outputFilePath) {
+function buildPlanningPrompt(specContent, codebaseContext, outputFilePath, packages, packageDetails) {
+  const isMonorepo = packages && packages.length > 0;
+  const packageDetailsSection = packageDetails && packageDetails.length > 0 ? buildPackageDetailsSection(packageDetails) : "";
+  const monorepoHint = isMonorepo ? `
+## Monorepo Context
+
+This is a monorepo. Detected packages:
+${packages.map((p) => `- ${p}`).join(`
+`)}
+${packageDetailsSection}
+For each user story, set the "workdir" field to the relevant package path (e.g. "packages/api"). Stories that span the root should omit "workdir".` : "";
+  const workdirField = isMonorepo ? `
+      "workdir": "string \u2014 optional, relative path to package (e.g. \\"packages/api\\"). Omit for root-level stories.",` : "";
   return `You are a senior software architect generating a product requirements document (PRD) as JSON.
 
 ## Spec
@@ -66426,7 +67360,7 @@ ${specContent}
 
 ## Codebase Context
 
-${codebaseContext}
+${codebaseContext}${monorepoHint}
 
 ## Output Schema
 
@@ -66445,7 +67379,7 @@ Generate a JSON object with this exact structure (no markdown, no explanation \u
       "description": "string \u2014 detailed description of the story",
       "acceptanceCriteria": ["string \u2014 each AC line"],
       "tags": ["string \u2014 routing tags, e.g. feature, security, api"],
-      "dependencies": ["string \u2014 story IDs this story depends on"],
+      "dependencies": ["string \u2014 story IDs this story depends on"],${workdirField}
       "status": "pending",
       "passes": false,
       "routing": {
@@ -66615,14 +67549,14 @@ async function displayModelEfficiency(workdir) {
 }
 // src/cli/status-features.ts
 init_source();
-import { existsSync as existsSync11, readdirSync as readdirSync3 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync3 } from "fs";
+import { join as join15 } from "path";
 
 // src/commands/common.ts
 init_path_security2();
 init_errors3();
-import { existsSync as existsSync10, readdirSync as readdirSync2, realpathSync as realpathSync3 } from "fs";
-import { join as join11, resolve as resolve6 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync2, realpathSync as realpathSync3 } from "fs";
+import { join as join13, resolve as resolve6 } from "path";
 function resolveProject(options = {}) {
   const { dir, feature } = options;
   let projectRoot;
@@ -66630,37 +67564,37 @@ function resolveProject(options = {}) {
   let configPath;
   if (dir) {
     projectRoot = realpathSync3(resolve6(dir));
-    naxDir = join11(projectRoot, "nax");
-    if (!existsSync10(naxDir)) {
+    naxDir = join13(projectRoot, "nax");
+    if (!existsSync12(naxDir)) {
       throw new NaxError(`Directory does not contain a nax project: ${projectRoot}
 Expected to find: ${naxDir}`, "NAX_DIR_NOT_FOUND", { projectRoot, naxDir });
     }
-    configPath = join11(naxDir, "config.json");
-    if (!existsSync10(configPath)) {
+    configPath = join13(naxDir, "config.json");
+    if (!existsSync12(configPath)) {
       throw new NaxError(`nax directory found but config.json is missing: ${naxDir}
 Expected to find: ${configPath}`, "CONFIG_NOT_FOUND", { naxDir, configPath });
     }
   } else {
     const found = findProjectRoot(process.cwd());
     if (!found) {
-      const cwdNaxDir = join11(process.cwd(), "nax");
-      if (existsSync10(cwdNaxDir)) {
-        const cwdConfigPath = join11(cwdNaxDir, "config.json");
+      const cwdNaxDir = join13(process.cwd(), "nax");
+      if (existsSync12(cwdNaxDir)) {
+        const cwdConfigPath = join13(cwdNaxDir, "config.json");
         throw new NaxError(`nax directory found but config.json is missing: ${cwdNaxDir}
 Expected to find: ${cwdConfigPath}`, "CONFIG_NOT_FOUND", { naxDir: cwdNaxDir, configPath: cwdConfigPath });
       }
       throw new NaxError("No nax project found. Run this command from within a nax project directory, or use -d flag to specify the project path.", "PROJECT_NOT_FOUND", { cwd: process.cwd() });
     }
     projectRoot = found;
-    naxDir = join11(projectRoot, "nax");
-    configPath = join11(naxDir, "config.json");
+    naxDir = join13(projectRoot, "nax");
+    configPath = join13(naxDir, "config.json");
   }
   let featureDir;
   if (feature) {
-    const featuresDir = join11(naxDir, "features");
-    featureDir = join11(featuresDir, feature);
-    if (!existsSync10(featureDir)) {
-      const availableFeatures = existsSync10(featuresDir) ? readdirSync2(featuresDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name) : [];
+    const featuresDir = join13(naxDir, "features");
+    featureDir = join13(featuresDir, feature);
+    if (!existsSync12(featureDir)) {
+      const availableFeatures = existsSync12(featuresDir) ? readdirSync2(featuresDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name) : [];
       const availableMsg = availableFeatures.length > 0 ? `
 
 Available features:
@@ -66685,12 +67619,12 @@ function findProjectRoot(startDir) {
   let current = resolve6(startDir);
   let depth = 0;
   while (depth < MAX_DIRECTORY_DEPTH) {
-    const naxDir = join11(current, "nax");
-    const configPath = join11(naxDir, "config.json");
-    if (existsSync10(configPath)) {
+    const naxDir = join13(current, "nax");
+    const configPath = join13(naxDir, "config.json");
+    if (existsSync12(configPath)) {
       return realpathSync3(current);
     }
-    const parent = join11(current, "..");
+    const parent = join13(current, "..");
     if (parent === current) {
       break;
     }
@@ -66712,8 +67646,8 @@ function isPidAlive(pid) {
   }
 }
 async function loadStatusFile(featureDir) {
-  const statusPath = join13(featureDir, "status.json");
-  if (!existsSync11(statusPath)) {
+  const statusPath = join15(featureDir, "status.json");
+  if (!existsSync13(statusPath)) {
     return null;
   }
   try {
@@ -66724,8 +67658,8 @@ async function loadStatusFile(featureDir) {
   }
 }
 async function loadProjectStatusFile(projectDir) {
-  const statusPath = join13(projectDir, "nax", "status.json");
-  if (!existsSync11(statusPath)) {
+  const statusPath = join15(projectDir, "nax", "status.json");
+  if (!existsSync13(statusPath)) {
     return null;
   }
   try {
@@ -66736,8 +67670,8 @@ async function loadProjectStatusFile(projectDir) {
   }
 }
 async function getFeatureSummary(featureName, featureDir) {
-  const prdPath = join13(featureDir, "prd.json");
-  if (!existsSync11(prdPath)) {
+  const prdPath = join15(featureDir, "prd.json");
+  if (!existsSync13(prdPath)) {
     return {
       name: featureName,
       done: 0,
@@ -66779,8 +67713,8 @@ async function getFeatureSummary(featureName, featureDir) {
       };
     }
   }
-  const runsDir = join13(featureDir, "runs");
-  if (existsSync11(runsDir)) {
+  const runsDir = join15(featureDir, "runs");
+  if (existsSync13(runsDir)) {
     const runs = readdirSync3(runsDir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".jsonl") && e.name !== "latest.jsonl").map((e) => e.name).sort().reverse();
     if (runs.length > 0) {
       const latestRun = runs[0].replace(".jsonl", "");
@@ -66790,8 +67724,8 @@ async function getFeatureSummary(featureName, featureDir) {
   return summary;
 }
 async function displayAllFeatures(projectDir) {
-  const featuresDir = join13(projectDir, "nax", "features");
-  if (!existsSync11(featuresDir)) {
+  const featuresDir = join15(projectDir, "nax", "features");
+  if (!existsSync13(featuresDir)) {
     console.log(source_default.dim("No features found."));
     return;
   }
@@ -66831,7 +67765,7 @@ async function displayAllFeatures(projectDir) {
       console.log();
     }
   }
-  const summaries = await Promise.all(features.map((name) => getFeatureSummary(name, join13(featuresDir, name))));
+  const summaries = await Promise.all(features.map((name) => getFeatureSummary(name, join15(featuresDir, name))));
   console.log(source_default.bold(`\uD83D\uDCCA Features
 `));
   const header = `  ${"Feature".padEnd(25)} ${"Done".padEnd(6)} ${"Failed".padEnd(8)} ${"Pending".padEnd(9)} ${"Last Run".padEnd(22)} ${"Cost".padEnd(10)} Status`;
@@ -66857,8 +67791,8 @@ async function displayAllFeatures(projectDir) {
   console.log();
 }
 async function displayFeatureDetails(featureName, featureDir) {
-  const prdPath = join13(featureDir, "prd.json");
-  if (!existsSync11(prdPath)) {
+  const prdPath = join15(featureDir, "prd.json");
+  if (!existsSync13(prdPath)) {
     console.log(source_default.bold(`
 \uD83D\uDCCA ${featureName}
 `));
@@ -66978,8 +67912,8 @@ async function displayFeatureStatus(options = {}) {
 // src/cli/runs.ts
 init_errors3();
 init_logger2();
-import { existsSync as existsSync12, readdirSync as readdirSync4 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync4 } from "fs";
+import { join as join16 } from "path";
 async function parseRunLog(logPath) {
   const logger = getLogger();
   try {
@@ -66995,8 +67929,8 @@ async function parseRunLog(logPath) {
 async function runsListCommand(options) {
   const logger = getLogger();
   const { feature, workdir } = options;
-  const runsDir = join14(workdir, "nax", "features", feature, "runs");
-  if (!existsSync12(runsDir)) {
+  const runsDir = join16(workdir, "nax", "features", feature, "runs");
+  if (!existsSync14(runsDir)) {
     logger.info("cli", "No runs found for feature", { feature, hint: `Directory not found: ${runsDir}` });
     return;
   }
@@ -67007,7 +67941,7 @@ async function runsListCommand(options) {
   }
   logger.info("cli", `Runs for ${feature}`, { count: files.length });
   for (const file2 of files.sort().reverse()) {
-    const logPath = join14(runsDir, file2);
+    const logPath = join16(runsDir, file2);
     const entries = await parseRunLog(logPath);
     const startEvent = entries.find((e) => e.message === "run.start");
     const completeEvent = entries.find((e) => e.message === "run.complete");
@@ -67033,8 +67967,8 @@ async function runsListCommand(options) {
 async function runsShowCommand(options) {
   const logger = getLogger();
   const { runId, feature, workdir } = options;
-  const logPath = join14(workdir, "nax", "features", feature, "runs", `${runId}.jsonl`);
-  if (!existsSync12(logPath)) {
+  const logPath = join16(workdir, "nax", "features", feature, "runs", `${runId}.jsonl`);
+  if (!existsSync14(logPath)) {
     logger.error("cli", "Run not found", { runId, feature, logPath });
     throw new NaxError("Run not found", "RUN_NOT_FOUND", { runId, feature, logPath });
   }
@@ -67071,8 +68005,8 @@ async function runsShowCommand(options) {
 }
 // src/cli/prompts-main.ts
 init_logger2();
-import { existsSync as existsSync15, mkdirSync as mkdirSync3 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync3 } from "fs";
+import { join as join27 } from "path";
 
 // src/pipeline/index.ts
 init_runner();
@@ -67108,7 +68042,7 @@ init_prd();
 
 // src/cli/prompts-tdd.ts
 init_prompts2();
-import { join as join20 } from "path";
+import { join as join26 } from "path";
 async function handleThreeSessionTddPrompts(story, ctx, outputDir, logger) {
   const [testWriterPrompt, implementerPrompt, verifierPrompt] = await Promise.all([
     PromptBuilder.for("test-writer", { isolation: "strict" }).withLoader(ctx.workdir, ctx.config).story(story).context(ctx.contextMarkdown).constitution(ctx.constitution?.content).testCommand(ctx.config.quality?.commands?.test).build(),
@@ -67127,7 +68061,7 @@ ${frontmatter}---
 
 ${session.prompt}`;
     if (outputDir) {
-      const promptFile = join20(outputDir, `${story.id}.${session.role}.md`);
+      const promptFile = join26(outputDir, `${story.id}.${session.role}.md`);
       await Bun.write(promptFile, fullOutput);
       logger.info("cli", "Written TDD prompt file", {
         storyId: story.id,
@@ -67143,7 +68077,7 @@ ${"=".repeat(80)}`);
     }
   }
   if (outputDir && ctx.contextMarkdown) {
-    const contextFile = join20(outputDir, `${story.id}.context.md`);
+    const contextFile = join26(outputDir, `${story.id}.context.md`);
     const frontmatter = buildFrontmatter(story, ctx);
     const contextOutput = `---
 ${frontmatter}---
@@ -67157,13 +68091,13 @@ ${ctx.contextMarkdown}`;
 async function promptsCommand(options) {
   const logger = getLogger();
   const { feature, workdir, config: config2, storyId, outputDir } = options;
-  const naxDir = join21(workdir, "nax");
-  if (!existsSync15(naxDir)) {
+  const naxDir = join27(workdir, "nax");
+  if (!existsSync18(naxDir)) {
     throw new Error(`nax directory not found. Run 'nax init' first in ${workdir}`);
   }
-  const featureDir = join21(naxDir, "features", feature);
-  const prdPath = join21(featureDir, "prd.json");
-  if (!existsSync15(prdPath)) {
+  const featureDir = join27(naxDir, "features", feature);
+  const prdPath = join27(featureDir, "prd.json");
+  if (!existsSync18(prdPath)) {
     throw new Error(`Feature "${feature}" not found or missing prd.json`);
   }
   const prd = await loadPRD(prdPath);
@@ -67222,10 +68156,10 @@ ${frontmatter}---
 
 ${ctx.prompt}`;
     if (outputDir) {
-      const promptFile = join21(outputDir, `${story.id}.prompt.md`);
+      const promptFile = join27(outputDir, `${story.id}.prompt.md`);
       await Bun.write(promptFile, fullOutput);
       if (ctx.contextMarkdown) {
-        const contextFile = join21(outputDir, `${story.id}.context.md`);
+        const contextFile = join27(outputDir, `${story.id}.context.md`);
         const contextOutput = `---
 ${frontmatter}---
 
@@ -67288,8 +68222,8 @@ function buildFrontmatter(story, ctx, role) {
 `;
 }
 // src/cli/prompts-init.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync4 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync4 } from "fs";
+import { join as join28 } from "path";
 var TEMPLATE_ROLES = [
   { file: "test-writer.md", role: "test-writer" },
   { file: "implementer.md", role: "implementer", variant: "standard" },
@@ -67313,9 +68247,9 @@ var TEMPLATE_HEADER = `<!--
 `;
 async function promptsInitCommand(options) {
   const { workdir, force = false, autoWireConfig = true } = options;
-  const templatesDir = join22(workdir, "nax", "templates");
+  const templatesDir = join28(workdir, "nax", "templates");
   mkdirSync4(templatesDir, { recursive: true });
-  const existingFiles = TEMPLATE_ROLES.map((t) => t.file).filter((f) => existsSync16(join22(templatesDir, f)));
+  const existingFiles = TEMPLATE_ROLES.map((t) => t.file).filter((f) => existsSync19(join28(templatesDir, f)));
   if (existingFiles.length > 0 && !force) {
     console.warn(`[WARN] nax/templates/ already contains files: ${existingFiles.join(", ")}. No files overwritten.
        Pass --force to overwrite existing templates.`);
@@ -67323,7 +68257,7 @@ async function promptsInitCommand(options) {
   }
   const written = [];
   for (const template of TEMPLATE_ROLES) {
-    const filePath = join22(templatesDir, template.file);
+    const filePath = join28(templatesDir, template.file);
     const roleBody = template.role === "implementer" ? buildRoleTaskSection(template.role, template.variant) : buildRoleTaskSection(template.role);
     const content = TEMPLATE_HEADER + roleBody;
     await Bun.write(filePath, content);
@@ -67339,8 +68273,8 @@ async function promptsInitCommand(options) {
   return written;
 }
 async function autoWirePromptsConfig(workdir) {
-  const configPath = join22(workdir, "nax.config.json");
-  if (!existsSync16(configPath)) {
+  const configPath = join28(workdir, "nax.config.json");
+  if (!existsSync19(configPath)) {
     const exampleConfig = JSON.stringify({
       prompts: {
         overrides: {
@@ -67435,9 +68369,7 @@ async function exportPromptCommand(options) {
 // src/cli/init.ts
 init_paths();
 init_logger2();
-
-// src/cli/init-context.ts
-init_logger2();
+init_init_context();
 // src/cli/plugins.ts
 init_loader5();
 import * as os2 from "os";
@@ -67505,8 +68437,8 @@ function pad(str, width) {
 init_config();
 init_logger2();
 init_prd();
-import { existsSync as existsSync17, readdirSync as readdirSync5 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync21, readdirSync as readdirSync5 } from "fs";
+import { join as join32 } from "path";
 
 // src/cli/diagnose-analysis.ts
 function detectFailurePattern(story, prd, status) {
@@ -67705,8 +68637,8 @@ function isProcessAlive2(pid) {
   }
 }
 async function loadStatusFile2(workdir) {
-  const statusPath = join25(workdir, "nax", "status.json");
-  if (!existsSync17(statusPath))
+  const statusPath = join32(workdir, "nax", "status.json");
+  if (!existsSync21(statusPath))
     return null;
   try {
     return await Bun.file(statusPath).json();
@@ -67733,7 +68665,7 @@ async function countCommitsSince(workdir, since) {
   }
 }
 async function checkLock(workdir) {
-  const lockFile = Bun.file(join25(workdir, "nax.lock"));
+  const lockFile = Bun.file(join32(workdir, "nax.lock"));
   if (!await lockFile.exists())
     return { lockPresent: false };
   try {
@@ -67751,8 +68683,8 @@ async function diagnoseCommand(options = {}) {
   const logger = getLogger();
   const workdir = options.workdir ?? process.cwd();
   const naxSubdir = findProjectDir(workdir);
-  let projectDir = naxSubdir ? join25(naxSubdir, "..") : null;
-  if (!projectDir && existsSync17(join25(workdir, "nax"))) {
+  let projectDir = naxSubdir ? join32(naxSubdir, "..") : null;
+  if (!projectDir && existsSync21(join32(workdir, "nax"))) {
     projectDir = workdir;
   }
   if (!projectDir)
@@ -67763,8 +68695,8 @@ async function diagnoseCommand(options = {}) {
     if (status2) {
       feature = status2.run.feature;
     } else {
-      const featuresDir = join25(projectDir, "nax", "features");
-      if (!existsSync17(featuresDir))
+      const featuresDir = join32(projectDir, "nax", "features");
+      if (!existsSync21(featuresDir))
         throw new Error("No features found in project");
       const features = readdirSync5(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
       if (features.length === 0)
@@ -67773,9 +68705,9 @@ async function diagnoseCommand(options = {}) {
       logger.info("diagnose", "No feature specified, using first found", { feature });
     }
   }
-  const featureDir = join25(projectDir, "nax", "features", feature);
-  const prdPath = join25(featureDir, "prd.json");
-  if (!existsSync17(prdPath))
+  const featureDir = join32(projectDir, "nax", "features", feature);
+  const prdPath = join32(featureDir, "prd.json");
+  if (!existsSync21(prdPath))
     throw new Error(`Feature not found: ${feature}`);
   const prd = await loadPRD(prdPath);
   const status = await loadStatusFile2(projectDir);
@@ -67816,419 +68748,66 @@ init_interaction();
 // src/cli/generate.ts
 init_source();
 init_loader2();
-import { existsSync as existsSync20 } from "fs";
-import { join as join28 } from "path";
-
-// src/context/generator.ts
-init_path_security2();
-import { existsSync as existsSync19 } from "fs";
-import { join as join27 } from "path";
-
-// src/context/injector.ts
-import { existsSync as existsSync18 } from "fs";
-import { join as join26 } from "path";
-var NOTABLE_NODE_DEPS = [
-  "@nestjs",
-  "express",
-  "fastify",
-  "koa",
-  "hono",
-  "next",
-  "nuxt",
-  "react",
-  "vue",
-  "svelte",
-  "solid",
-  "prisma",
-  "typeorm",
-  "mongoose",
-  "drizzle",
-  "sequelize",
-  "jest",
-  "vitest",
-  "mocha",
-  "bun",
-  "zod",
-  "typescript",
-  "graphql",
-  "trpc",
-  "bull",
-  "ioredis"
-];
-async function detectNode(workdir) {
-  const pkgPath = join26(workdir, "package.json");
-  if (!existsSync18(pkgPath))
-    return null;
+import { existsSync as existsSync22 } from "fs";
+import { join as join33 } from "path";
+var VALID_AGENTS = ["claude", "codex", "opencode", "cursor", "windsurf", "aider", "gemini"];
+async function generateCommand(options) {
+  const workdir = process.cwd();
+  const dryRun = options.dryRun ?? false;
+  let config2;
   try {
-    const file2 = Bun.file(pkgPath);
-    const pkg = await file2.json();
-    const allDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
-    const notable = [
-      ...new Set(Object.keys(allDeps).filter((dep) => NOTABLE_NODE_DEPS.some((kw) => dep === kw || dep.startsWith(`${kw}/`) || dep.includes(kw))))
-    ].slice(0, 10);
-    const lang = pkg.devDependencies?.typescript || pkg.dependencies?.typescript ? "TypeScript" : "JavaScript";
-    return { name: pkg.name, lang, dependencies: notable };
+    config2 = await loadConfig(workdir);
   } catch {
-    return null;
+    config2 = {};
   }
-}
-async function detectGo(workdir) {
-  const goMod = join26(workdir, "go.mod");
-  if (!existsSync18(goMod))
-    return null;
-  try {
-    const content = await Bun.file(goMod).text();
-    const moduleMatch = content.match(/^module\s+(\S+)/m);
-    const name = moduleMatch?.[1];
-    const requires = [];
-    const requireBlock = content.match(/require\s*\(([^)]+)\)/s)?.[1] ?? "";
-    for (const line of requireBlock.split(`
-`)) {
-      const trimmed = line.trim();
-      if (trimmed && !trimmed.startsWith("//") && !trimmed.includes("// indirect")) {
-        const dep = trimmed.split(/\s+/)[0];
-        if (dep)
-          requires.push(dep.split("/").slice(-1)[0]);
-      }
+  if (options.allPackages) {
+    if (dryRun) {
+      console.log(source_default.yellow("\u26A0 Dry run \u2014 no files will be written"));
     }
-    return { name, lang: "Go", dependencies: requires.slice(0, 10) };
-  } catch {
-    return null;
-  }
-}
-async function detectRust(workdir) {
-  const cargoPath = join26(workdir, "Cargo.toml");
-  if (!existsSync18(cargoPath))
-    return null;
-  try {
-    const content = await Bun.file(cargoPath).text();
-    const nameMatch = content.match(/^\[package\][^[]*name\s*=\s*"([^"]+)"/ms);
-    const name = nameMatch?.[1];
-    const depsSection = content.match(/^\[dependencies\]([^[]*)/ms)?.[1] ?? "";
-    const deps = depsSection.split(`
-`).map((l) => l.split("=")[0].trim()).filter((l) => l && !l.startsWith("#")).slice(0, 10);
-    return { name, lang: "Rust", dependencies: deps };
-  } catch {
-    return null;
-  }
-}
-async function detectPython(workdir) {
-  const pyproject = join26(workdir, "pyproject.toml");
-  const requirements = join26(workdir, "requirements.txt");
-  if (!existsSync18(pyproject) && !existsSync18(requirements))
-    return null;
-  try {
-    if (existsSync18(pyproject)) {
-      const content = await Bun.file(pyproject).text();
-      const nameMatch = content.match(/^\s*name\s*=\s*"([^"]+)"/m);
-      const depsSection = content.match(/^\[project\][^[]*dependencies\s*=\s*\[([^\]]*)\]/ms)?.[1] ?? "";
-      const deps = depsSection.split(",").map((d) => d.trim().replace(/["'\s>=<!^~].*/g, "")).filter(Boolean).slice(0, 10);
-      return { name: nameMatch?.[1], lang: "Python", dependencies: deps };
+    console.log(source_default.blue("\u2192 Discovering packages with nax/context.md..."));
+    const packages = await discoverPackages(workdir);
+    if (packages.length === 0) {
+      console.log(source_default.yellow("  No packages found (no */nax/context.md or */*/nax/context.md)"));
+      return;
     }
-    const lines = (await Bun.file(requirements).text()).split(`
-`).map((l) => l.split(/[>=<!]/)[0].trim()).filter((l) => l && !l.startsWith("#")).slice(0, 10);
-    return { lang: "Python", dependencies: lines };
-  } catch {
-    return null;
-  }
-}
-async function detectPhp(workdir) {
-  const composerPath = join26(workdir, "composer.json");
-  if (!existsSync18(composerPath))
-    return null;
-  try {
-    const file2 = Bun.file(composerPath);
-    const composer = await file2.json();
-    const deps = Object.keys({ ...composer.require ?? {}, ...composer["require-dev"] ?? {} }).filter((d) => d !== "php").map((d) => d.split("/").pop() ?? d).slice(0, 10);
-    return { name: composer.name, lang: "PHP", dependencies: deps };
-  } catch {
-    return null;
-  }
-}
-async function detectRuby(workdir) {
-  const gemfile = join26(workdir, "Gemfile");
-  if (!existsSync18(gemfile))
-    return null;
-  try {
-    const content = await Bun.file(gemfile).text();
-    const gems = [...content.matchAll(/^\s*gem\s+['"]([^'"]+)['"]/gm)].map((m) => m[1]).slice(0, 10);
-    return { lang: "Ruby", dependencies: gems };
-  } catch {
-    return null;
-  }
-}
-async function detectJvm(workdir) {
-  const pom = join26(workdir, "pom.xml");
-  const gradle = join26(workdir, "build.gradle");
-  const gradleKts = join26(workdir, "build.gradle.kts");
-  if (!existsSync18(pom) && !existsSync18(gradle) && !existsSync18(gradleKts))
-    return null;
-  try {
-    if (existsSync18(pom)) {
-      const content2 = await Bun.file(pom).text();
-      const nameMatch = content2.match(/<artifactId>([^<]+)<\/artifactId>/);
-      const deps2 = [...content2.matchAll(/<artifactId>([^<]+)<\/artifactId>/g)].map((m) => m[1]).filter((d) => d !== nameMatch?.[1]).slice(0, 10);
-      const lang2 = existsSync18(join26(workdir, "src/main/kotlin")) ? "Kotlin" : "Java";
-      return { name: nameMatch?.[1], lang: lang2, dependencies: deps2 };
+    console.log(source_default.blue(`\u2192 Generating CLAUDE.md for ${packages.length} package(s)...`));
+    let errorCount = 0;
+    for (const pkgDir of packages) {
+      const result = await generateForPackage(pkgDir, config2, dryRun);
+      if (result.error) {
+        console.error(source_default.red(`\u2717 ${pkgDir}: ${result.error}`));
+        errorCount++;
+      } else {
+        const suffix = dryRun ? " (dry run)" : "";
+        console.log(source_default.green(`\u2713 ${pkgDir}/${result.outputFile} (${result.content.length} bytes${suffix})`));
+      }
     }
-    const gradleFile = existsSync18(gradleKts) ? gradleKts : gradle;
-    const content = await Bun.file(gradleFile).text();
-    const lang = gradleFile.endsWith(".kts") ? "Kotlin" : "Java";
-    const deps = [...content.matchAll(/implementation[^'"]*['"]([^:'"]+:[^:'"]+)[^'"]*['"]/g)].map((m) => m[1].split(":").pop() ?? m[1]).slice(0, 10);
-    return { lang, dependencies: deps };
-  } catch {
-    return null;
-  }
-}
-async function buildProjectMetadata(workdir, config2) {
-  const detected = await detectGo(workdir) ?? await detectRust(workdir) ?? await detectPython(workdir) ?? await detectPhp(workdir) ?? await detectRuby(workdir) ?? await detectJvm(workdir) ?? await detectNode(workdir);
-  return {
-    name: detected?.name,
-    language: detected?.lang,
-    dependencies: detected?.dependencies ?? [],
-    testCommand: config2.execution?.testCommand ?? undefined,
-    lintCommand: config2.execution?.lintCommand ?? undefined,
-    typecheckCommand: config2.execution?.typecheckCommand ?? undefined
-  };
-}
-function formatMetadataSection(metadata) {
-  const lines = ["## Project Metadata", "", "> Auto-injected by `nax generate`", ""];
-  if (metadata.name) {
-    lines.push(`**Project:** \`${metadata.name}\``);
-    lines.push("");
-  }
-  if (metadata.language) {
-    lines.push(`**Language:** ${metadata.language}`);
-    lines.push("");
-  }
-  if (metadata.dependencies.length > 0) {
-    lines.push(`**Key dependencies:** ${metadata.dependencies.join(", ")}`);
-    lines.push("");
-  }
-  const commands = [];
-  if (metadata.testCommand)
-    commands.push(`test: \`${metadata.testCommand}\``);
-  if (metadata.lintCommand)
-    commands.push(`lint: \`${metadata.lintCommand}\``);
-  if (metadata.typecheckCommand)
-    commands.push(`typecheck: \`${metadata.typecheckCommand}\``);
-  if (commands.length > 0) {
-    lines.push(`**Commands:** ${commands.join(" | ")}`);
-    lines.push("");
-  }
-  lines.push("---");
-  lines.push("");
-  return lines.join(`
-`);
-}
-
-// src/context/generators/aider.ts
-function generateAiderConfig(context) {
-  const header = `# Aider Configuration
-# Auto-generated from nax/context.md \u2014 run \`nax generate\` to regenerate.
-# DO NOT EDIT MANUALLY
-
-# Project instructions
-instructions: |
-`;
-  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
-  const combined = metaSection + context.markdown;
-  const indented = combined.split(`
-`).map((line) => `  ${line}`).join(`
-`);
-  return `${header}${indented}
-`;
-}
-var aiderGenerator = {
-  name: "aider",
-  outputFile: ".aider.conf.yml",
-  generate: generateAiderConfig
-};
-
-// src/context/generators/claude.ts
-function generateClaudeConfig(context) {
-  const header = `# Project Context
-
-This file is auto-generated from \`nax/context.md\`.
-DO NOT EDIT MANUALLY \u2014 run \`nax generate\` to regenerate.
-
----
-
-`;
-  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
-  return header + metaSection + context.markdown;
-}
-var claudeGenerator = {
-  name: "claude",
-  outputFile: "CLAUDE.md",
-  generate: generateClaudeConfig
-};
-
-// src/context/generators/codex.ts
-function generateCodexConfig(context) {
-  const header = `# Codex Instructions
-
-This file is auto-generated from \`nax/context.md\`.
-DO NOT EDIT MANUALLY \u2014 run \`nax generate\` to regenerate.
-
----
-
-`;
-  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
-  return header + metaSection + context.markdown;
-}
-var codexGenerator = {
-  name: "codex",
-  outputFile: "codex.md",
-  generate: generateCodexConfig
-};
-
-// src/context/generators/cursor.ts
-function generateCursorRules(context) {
-  const header = `# Project Rules
-
-Auto-generated from nax/context.md \u2014 run \`nax generate\` to regenerate.
-DO NOT EDIT MANUALLY
-
----
-
-`;
-  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
-  return header + metaSection + context.markdown;
-}
-var cursorGenerator = {
-  name: "cursor",
-  outputFile: ".cursorrules",
-  generate: generateCursorRules
-};
-
-// src/context/generators/gemini.ts
-function generateGeminiConfig(context) {
-  const header = `# Gemini CLI Context
-
-This file is auto-generated from \`nax/context.md\`.
-DO NOT EDIT MANUALLY \u2014 run \`nax generate\` to regenerate.
-
----
-
-`;
-  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
-  return header + metaSection + context.markdown;
-}
-var geminiGenerator = {
-  name: "gemini",
-  outputFile: "GEMINI.md",
-  generate: generateGeminiConfig
-};
-
-// src/context/generators/opencode.ts
-function generateOpencodeConfig(context) {
-  const header = `# Agent Instructions
-
-This file is auto-generated from \`nax/context.md\`.
-DO NOT EDIT MANUALLY \u2014 run \`nax generate\` to regenerate.
-
-These instructions apply to all AI coding agents in this project.
-
----
-
-`;
-  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
-  return header + metaSection + context.markdown;
-}
-var opencodeGenerator = {
-  name: "opencode",
-  outputFile: "AGENTS.md",
-  generate: generateOpencodeConfig
-};
-
-// src/context/generators/windsurf.ts
-function generateWindsurfRules(context) {
-  const header = `# Windsurf Project Rules
-
-Auto-generated from nax/context.md \u2014 run \`nax generate\` to regenerate.
-DO NOT EDIT MANUALLY
-
----
-
-`;
-  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
-  return header + metaSection + context.markdown;
-}
-var windsurfGenerator = {
-  name: "windsurf",
-  outputFile: ".windsurfrules",
-  generate: generateWindsurfRules
-};
-
-// src/context/generator.ts
-var GENERATORS = {
-  claude: claudeGenerator,
-  codex: codexGenerator,
-  opencode: opencodeGenerator,
-  cursor: cursorGenerator,
-  windsurf: windsurfGenerator,
-  aider: aiderGenerator,
-  gemini: geminiGenerator
-};
-async function loadContextContent(options, config2) {
-  if (!existsSync19(options.contextPath)) {
-    throw new Error(`Context file not found: ${options.contextPath}`);
-  }
-  const file2 = Bun.file(options.contextPath);
-  const markdown = await file2.text();
-  const autoInject = options.autoInject ?? true;
-  const metadata = autoInject ? await buildProjectMetadata(options.workdir, config2) : undefined;
-  return { markdown, metadata };
-}
-async function generateFor(agent, options, config2) {
-  const generator = GENERATORS[agent];
-  if (!generator) {
-    return { agent, outputFile: "", content: "", written: false, error: `Unknown agent: ${agent}` };
-  }
-  try {
-    const context = await loadContextContent(options, config2);
-    const content = generator.generate(context);
-    const outputPath = join27(options.outputDir, generator.outputFile);
-    validateFilePath(outputPath, options.outputDir);
-    if (!options.dryRun) {
-      await Bun.write(outputPath, content);
+    if (errorCount > 0) {
+      console.error(source_default.red(`
+\u2717 ${errorCount} generation(s) failed`));
+      process.exit(1);
     }
-    return { agent, outputFile: generator.outputFile, content, written: !options.dryRun };
-  } catch (err) {
-    const error48 = err instanceof Error ? err.message : String(err);
-    return { agent, outputFile: generator.outputFile, content: "", written: false, error: error48 };
+    return;
   }
-}
-async function generateAll(options, config2) {
-  const context = await loadContextContent(options, config2);
-  const results = [];
-  for (const [agentKey, generator] of Object.entries(GENERATORS)) {
-    try {
-      const content = generator.generate(context);
-      const outputPath = join27(options.outputDir, generator.outputFile);
-      validateFilePath(outputPath, options.outputDir);
-      if (!options.dryRun) {
-        await Bun.write(outputPath, content);
-      }
-      results.push({ agent: agentKey, outputFile: generator.outputFile, content, written: !options.dryRun });
-    } catch (err) {
-      const error48 = err instanceof Error ? err.message : String(err);
-      results.push({ agent: agentKey, outputFile: generator.outputFile, content: "", written: false, error: error48 });
+  if (options.package) {
+    const packageDir = join33(workdir, options.package);
+    if (dryRun) {
+      console.log(source_default.yellow("\u26A0 Dry run \u2014 no files will be written"));
     }
+    console.log(source_default.blue(`\u2192 Generating CLAUDE.md for package: ${options.package}`));
+    const result = await generateForPackage(packageDir, config2, dryRun);
+    if (result.error) {
+      console.error(source_default.red(`\u2717 ${result.error}`));
+      process.exit(1);
+    }
+    const suffix = dryRun ? " (dry run)" : "";
+    console.log(source_default.green(`\u2713 ${options.package}/${result.outputFile} (${result.content.length} bytes${suffix})`));
+    return;
   }
-  return results;
-}
-
-// src/cli/generate.ts
-var VALID_AGENTS = ["claude", "codex", "opencode", "cursor", "windsurf", "aider", "gemini"];
-async function generateCommand(options) {
-  const workdir = process.cwd();
-  const contextPath = options.context ? join28(workdir, options.context) : join28(workdir, "nax/context.md");
-  const outputDir = options.output ? join28(workdir, options.output) : workdir;
+  const contextPath = options.context ? join33(workdir, options.context) : join33(workdir, "nax/context.md");
+  const outputDir = options.output ? join33(workdir, options.output) : workdir;
   const autoInject = !options.noAutoInject;
-  const dryRun = options.dryRun ?? false;
-  if (!existsSync20(contextPath)) {
+  if (!existsSync22(contextPath)) {
     console.error(source_default.red(`\u2717 Context file not found: ${contextPath}`));
     console.error(source_default.yellow("  Create nax/context.md first, or run `nax init` to scaffold it."));
     process.exit(1);
@@ -68245,12 +68824,6 @@ async function generateCommand(options) {
   if (autoInject) {
     console.log(source_default.dim("  Auto-injecting project metadata..."));
   }
-  let config2;
-  try {
-    config2 = await loadConfig(workdir);
-  } catch {
-    config2 = {};
-  }
   const genOptions = {
     contextPath,
     outputDir,
@@ -68270,8 +68843,15 @@ async function generateCommand(options) {
       const suffix = dryRun ? " (dry run)" : "";
       console.log(source_default.green(`\u2713 ${agent} \u2192 ${result.outputFile} (${result.content.length} bytes${suffix})`));
     } else {
-      console.log(source_default.blue("\u2192 Generating configs for all agents..."));
-      const results = await generateAll(genOptions, config2);
+      const configAgents = config2?.generate?.agents;
+      const agentFilter = configAgents && configAgents.length > 0 ? configAgents : null;
+      if (agentFilter) {
+        console.log(source_default.blue(`\u2192 Generating configs for: ${agentFilter.join(", ")} (from config)...`));
+      } else {
+        console.log(source_default.blue("\u2192 Generating configs for all agents..."));
+      }
+      const allResults = await generateAll(genOptions, config2);
+      const results = agentFilter ? allResults.filter((r) => agentFilter.includes(r.agent)) : allResults;
       let errorCount = 0;
       for (const result of results) {
         if (result.error) {
@@ -68300,8 +68880,8 @@ async function generateCommand(options) {
 }
 // src/cli/config-display.ts
 init_loader2();
-import { existsSync as existsSync22 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { join as join35 } from "path";
 
 // src/cli/config-descriptions.ts
 var FIELD_DESCRIPTIONS = {
@@ -68509,10 +69089,10 @@ function deepEqual(a, b) {
 // src/cli/config-get.ts
 init_defaults();
 init_loader2();
-import { existsSync as existsSync21 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync23 } from "fs";
+import { join as join34 } from "path";
 async function loadConfigFile(path14) {
-  if (!existsSync21(path14))
+  if (!existsSync23(path14))
     return null;
   try {
     return await Bun.file(path14).json();
@@ -68532,7 +69112,7 @@ async function loadProjectConfig() {
   const projectDir = findProjectDir();
   if (!projectDir)
     return null;
-  const projectPath = join29(projectDir, "config.json");
+  const projectPath = join34(projectDir, "config.json");
   return await loadConfigFile(projectPath);
 }
 
@@ -68592,14 +69172,14 @@ async function configCommand(config2, options = {}) {
 function determineConfigSources() {
   const globalPath = globalConfigPath();
   const projectDir = findProjectDir();
-  const projectPath = projectDir ? join30(projectDir, "config.json") : null;
+  const projectPath = projectDir ? join35(projectDir, "config.json") : null;
   return {
     global: fileExists(globalPath) ? globalPath : null,
     project: projectPath && fileExists(projectPath) ? projectPath : null
   };
 }
 function fileExists(path14) {
-  return existsSync22(path14);
+  return existsSync24(path14);
 }
 function displayConfigWithDescriptions(obj, path14, sources, indent = 0) {
   const indentStr = "  ".repeat(indent);
@@ -68771,25 +69351,25 @@ async function diagnose(options) {
 }
 
 // src/commands/logs.ts
-import { existsSync as existsSync24 } from "fs";
-import { join as join33 } from "path";
+import { existsSync as existsSync26 } from "fs";
+import { join as join38 } from "path";
 
 // src/commands/logs-formatter.ts
 init_source();
 init_formatter();
 import { readdirSync as readdirSync7 } from "fs";
-import { join as join32 } from "path";
+import { join as join37 } from "path";
 
 // src/commands/logs-reader.ts
-import { existsSync as existsSync23, readdirSync as readdirSync6 } from "fs";
+import { existsSync as existsSync25, readdirSync as readdirSync6 } from "fs";
 import { readdir as readdir3 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { join as join31 } from "path";
-var _deps6 = {
-  getRunsDir: () => process.env.NAX_RUNS_DIR ?? join31(homedir5(), ".nax", "runs")
+import { join as join36 } from "path";
+var _deps7 = {
+  getRunsDir: () => process.env.NAX_RUNS_DIR ?? join36(homedir5(), ".nax", "runs")
 };
 async function resolveRunFileFromRegistry(runId) {
-  const runsDir = _deps6.getRunsDir();
+  const runsDir = _deps7.getRunsDir();
   let entries;
   try {
     entries = await readdir3(runsDir);
@@ -68798,7 +69378,7 @@ async function resolveRunFileFromRegistry(runId) {
   }
   let matched = null;
   for (const entry of entries) {
-    const metaPath = join31(runsDir, entry, "meta.json");
+    const metaPath = join36(runsDir, entry, "meta.json");
     try {
       const meta3 = await Bun.file(metaPath).json();
       if (meta3.runId === runId || meta3.runId.startsWith(runId)) {
@@ -68810,7 +69390,7 @@ async function resolveRunFileFromRegistry(runId) {
   if (!matched) {
     throw new Error(`Run not found in registry: ${runId}`);
   }
-  if (!existsSync23(matched.eventsDir)) {
+  if (!existsSync25(matched.eventsDir)) {
     console.log(`Log directory unavailable for run: ${runId}`);
     return null;
   }
@@ -68820,14 +69400,14 @@ async function resolveRunFileFromRegistry(runId) {
     return null;
   }
   const specificFile = files.find((f) => f === `${matched.runId}.jsonl`);
-  return join31(matched.eventsDir, specificFile ?? files[0]);
+  return join36(matched.eventsDir, specificFile ?? files[0]);
 }
 async function selectRunFile(runsDir) {
   const files = readdirSync6(runsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
   if (files.length === 0) {
     return null;
   }
-  return join31(runsDir, files[0]);
+  return join36(runsDir, files[0]);
 }
 async function extractRunSummary(filePath) {
   const file2 = Bun.file(filePath);
@@ -68912,7 +69492,7 @@ Runs:
   console.log(source_default.gray("  Timestamp            Stories  Duration  Cost      Status"));
   console.log(source_default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   for (const file2 of files) {
-    const filePath = join32(runsDir, file2);
+    const filePath = join37(runsDir, file2);
     const summary = await extractRunSummary(filePath);
     const timestamp = file2.replace(".jsonl", "");
     const stories = summary ? `${summary.passed}/${summary.total}` : "?/?";
@@ -69037,7 +69617,7 @@ async function logsCommand(options) {
     return;
   }
   const resolved = resolveProject({ dir: options.dir });
-  const naxDir = join33(resolved.projectDir, "nax");
+  const naxDir = join38(resolved.projectDir, "nax");
   const configPath = resolved.configPath;
   const configFile = Bun.file(configPath);
   const config2 = await configFile.json();
@@ -69045,9 +69625,9 @@ async function logsCommand(options) {
   if (!featureName) {
     throw new Error("No feature specified in config.json");
   }
-  const featureDir = join33(naxDir, "features", featureName);
-  const runsDir = join33(featureDir, "runs");
-  if (!existsSync24(runsDir)) {
+  const featureDir = join38(naxDir, "features", featureName);
+  const runsDir = join38(featureDir, "runs");
+  if (!existsSync26(runsDir)) {
     throw new Error(`No runs directory found for feature: ${featureName}`);
   }
   if (options.list) {
@@ -69070,8 +69650,8 @@ init_source();
 init_config();
 init_prd();
 init_precheck();
-import { existsSync as existsSync29 } from "fs";
-import { join as join34 } from "path";
+import { existsSync as existsSync31 } from "fs";
+import { join as join39 } from "path";
 async function precheckCommand(options) {
   const resolved = resolveProject({
     dir: options.dir,
@@ -69087,14 +69667,14 @@ async function precheckCommand(options) {
       process.exit(1);
     }
   }
-  const naxDir = join34(resolved.projectDir, "nax");
-  const featureDir = join34(naxDir, "features", featureName);
-  const prdPath = join34(featureDir, "prd.json");
-  if (!existsSync29(featureDir)) {
+  const naxDir = join39(resolved.projectDir, "nax");
+  const featureDir = join39(naxDir, "features", featureName);
+  const prdPath = join39(featureDir, "prd.json");
+  if (!existsSync31(featureDir)) {
     console.error(source_default.red(`Feature not found: ${featureName}`));
     process.exit(1);
   }
-  if (!existsSync29(prdPath)) {
+  if (!existsSync31(prdPath)) {
     console.error(source_default.red(`Missing prd.json for feature: ${featureName}`));
     console.error(source_default.dim(`Run: nax plan -f ${featureName} --from spec.md --auto`));
     process.exit(EXIT_CODES.INVALID_PRD);
@@ -69113,10 +69693,10 @@ async function precheckCommand(options) {
 init_source();
 import { readdir as readdir4 } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { join as join35 } from "path";
+import { join as join40 } from "path";
 var DEFAULT_LIMIT = 20;
-var _deps8 = {
-  getRunsDir: () => join35(homedir6(), ".nax", "runs")
+var _deps9 = {
+  getRunsDir: () => join40(homedir6(), ".nax", "runs")
 };
 function formatDuration3(ms) {
   if (ms <= 0)
@@ -69158,7 +69738,7 @@ function pad3(str, width) {
   return str + " ".repeat(padding);
 }
 async function runsCommand(options = {}) {
-  const runsDir = _deps8.getRunsDir();
+  const runsDir = _deps9.getRunsDir();
   let entries;
   try {
     entries = await readdir4(runsDir);
@@ -69168,7 +69748,7 @@ async function runsCommand(options = {}) {
   }
   const rows = [];
   for (const entry of entries) {
-    const metaPath = join35(runsDir, entry, "meta.json");
+    const metaPath = join40(runsDir, entry, "meta.json");
     let meta3;
     try {
       meta3 = await Bun.file(metaPath).json();
@@ -69245,7 +69825,7 @@ async function runsCommand(options = {}) {
 
 // src/commands/unlock.ts
 init_source();
-import { join as join36 } from "path";
+import { join as join41 } from "path";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -69260,7 +69840,7 @@ function formatLockAge(ageMs) {
 }
 async function unlockCommand(options) {
   const workdir = options.dir ?? process.cwd();
-  const lockPath = join36(workdir, "nax.lock");
+  const lockPath = join41(workdir, "nax.lock");
   const lockFile = Bun.file(lockPath);
   const exists = await lockFile.exists();
   if (!exists) {
@@ -77072,7 +77652,7 @@ async function promptForConfirmation(question) {
     process.stdin.on("data", handler);
   });
 }
-program2.command("init").description("Initialize nax in the current project").option("-d, --dir <path>", "Project directory", process.cwd()).option("-f, --force", "Force overwrite existing files", false).action(async (options) => {
+program2.command("init").description("Initialize nax in the current project").option("-d, --dir <path>", "Project directory", process.cwd()).option("-f, --force", "Force overwrite existing files", false).option("--package <dir>", "Scaffold per-package nax/context.md (e.g. packages/api)").action(async (options) => {
   let workdir;
   try {
     workdir = validateDirectory(options.dir);
@@ -77080,15 +77660,30 @@ program2.command("init").description("Initialize nax in the current project").op
     console.error(source_default.red(`Invalid directory: ${err.message}`));
     process.exit(1);
   }
-  const naxDir = join43(workdir, "nax");
-  if (existsSync32(naxDir) && !options.force) {
+  if (options.package) {
+    const { initPackage: initPkg } = await Promise.resolve().then(() => (init_init_context(), exports_init_context));
+    try {
+      await initPkg(workdir, options.package, options.force);
+      console.log(source_default.green(`
+[OK] Package scaffold created.`));
+      console.log(source_default.dim(`  Created: ${options.package}/nax/context.md`));
+      console.log(source_default.dim(`
+Next: nax generate --package ${options.package}`));
+    } catch (err) {
+      console.error(source_default.red(`Error: ${err.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+  const naxDir = join48(workdir, "nax");
+  if (existsSync34(naxDir) && !options.force) {
     console.log(source_default.yellow("nax already initialized. Use --force to overwrite."));
     return;
   }
-  mkdirSync6(join43(naxDir, "features"), { recursive: true });
-  mkdirSync6(join43(naxDir, "hooks"), { recursive: true });
-  await Bun.write(join43(naxDir, "config.json"), JSON.stringify(DEFAULT_CONFIG, null, 2));
-  await Bun.write(join43(naxDir, "hooks.json"), JSON.stringify({
+  mkdirSync6(join48(naxDir, "features"), { recursive: true });
+  mkdirSync6(join48(naxDir, "hooks"), { recursive: true });
+  await Bun.write(join48(naxDir, "config.json"), JSON.stringify(DEFAULT_CONFIG, null, 2));
+  await Bun.write(join48(naxDir, "hooks.json"), JSON.stringify({
     hooks: {
       "on-start": { command: 'echo "nax started: $NAX_FEATURE"', enabled: false },
       "on-complete": { command: 'echo "nax complete: $NAX_FEATURE"', enabled: false },
@@ -77096,12 +77691,12 @@ program2.command("init").description("Initialize nax in the current project").op
       "on-error": { command: 'echo "nax error: $NAX_REASON"', enabled: false }
     }
   }, null, 2));
-  await Bun.write(join43(naxDir, ".gitignore"), `# nax temp files
+  await Bun.write(join48(naxDir, ".gitignore"), `# nax temp files
 *.tmp
 .paused.json
 .nax-verifier-verdict.json
 `);
-  await Bun.write(join43(naxDir, "context.md"), `# Project Context
+  await Bun.write(join48(naxDir, "context.md"), `# Project Context
 
 This document defines coding standards, architectural decisions, and forbidden patterns for this project.
 Run \`nax generate\` to regenerate agent config files (CLAUDE.md, AGENTS.md, .cursorrules, etc.) from this file.
@@ -77198,7 +77793,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     console.error(source_default.red("Error: --plan requires --from <spec-path>"));
     process.exit(1);
   }
-  if (options.from && !existsSync32(options.from)) {
+  if (options.from && !existsSync34(options.from)) {
     console.error(source_default.red(`Error: File not found: ${options.from} (required with --plan)`));
     process.exit(1);
   }
@@ -77227,10 +77822,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join43(naxDir, "features", options.feature);
-  const prdPath = join43(featureDir, "prd.json");
+  const featureDir = join48(naxDir, "features", options.feature);
+  const prdPath = join48(featureDir, "prd.json");
   if (options.plan && options.from) {
-    if (existsSync32(prdPath) && !options.force) {
+    if (existsSync34(prdPath) && !options.force) {
       console.error(source_default.red(`Error: prd.json already exists for feature "${options.feature}".`));
       console.error(source_default.dim("   Use --force to overwrite, or run without --plan to use the existing PRD."));
       process.exit(1);
@@ -77250,10 +77845,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
       }
     }
     try {
-      const planLogDir = join43(featureDir, "plan");
+      const planLogDir = join48(featureDir, "plan");
       mkdirSync6(planLogDir, { recursive: true });
       const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-      const planLogPath = join43(planLogDir, `${planLogId}.jsonl`);
+      const planLogPath = join48(planLogDir, `${planLogId}.jsonl`);
       initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
       console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
       console.log(source_default.dim("   [Planning phase: generating PRD from spec]"));
@@ -77286,15 +77881,15 @@ program2.command("run").description("Run the orchestration loop for a feature").
       process.exit(1);
     }
   }
-  if (!existsSync32(prdPath)) {
+  if (!existsSync34(prdPath)) {
     console.error(source_default.red(`Feature "${options.feature}" not found or missing prd.json`));
     process.exit(1);
   }
   resetLogger();
-  const runsDir = join43(featureDir, "runs");
+  const runsDir = join48(featureDir, "runs");
   mkdirSync6(runsDir, { recursive: true });
   const runId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const logFilePath = join43(runsDir, `${runId}.jsonl`);
+  const logFilePath = join48(runsDir, `${runId}.jsonl`);
   const isTTY = process.stdout.isTTY ?? false;
   const headlessFlag = options.headless ?? false;
   const headlessEnv = process.env.NAX_HEADLESS === "1";
@@ -77310,7 +77905,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     config2.autoMode.defaultAgent = options.agent;
   }
   config2.execution.maxIterations = Number.parseInt(options.maxIterations, 10);
-  const globalNaxDir = join43(homedir10(), ".nax");
+  const globalNaxDir = join48(homedir10(), ".nax");
   const hooks = await loadHooksConfig(naxDir, globalNaxDir);
   const eventEmitter = new PipelineEventEmitter;
   let tuiInstance;
@@ -77333,7 +77928,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
   } else {
     console.log(source_default.dim("   [Headless mode \u2014 pipe output]"));
   }
-  const statusFilePath = join43(workdir, "nax", "status.json");
+  const statusFilePath = join48(workdir, "nax", "status.json");
   let parallel;
   if (options.parallel !== undefined) {
     parallel = Number.parseInt(options.parallel, 10);
@@ -77359,9 +77954,9 @@ program2.command("run").description("Run the orchestration loop for a feature").
     headless: useHeadless,
     skipPrecheck: options.skipPrecheck ?? false
   });
-  const latestSymlink = join43(runsDir, "latest.jsonl");
+  const latestSymlink = join48(runsDir, "latest.jsonl");
   try {
-    if (existsSync32(latestSymlink)) {
+    if (existsSync34(latestSymlink)) {
       Bun.spawnSync(["rm", latestSymlink]);
     }
     Bun.spawnSync(["ln", "-s", `${runId}.jsonl`, latestSymlink], {
@@ -77397,9 +77992,9 @@ features.command("create <name>").description("Create a new feature").option("-d
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join43(naxDir, "features", name);
+  const featureDir = join48(naxDir, "features", name);
   mkdirSync6(featureDir, { recursive: true });
-  await Bun.write(join43(featureDir, "spec.md"), `# Feature: ${name}
+  await Bun.write(join48(featureDir, "spec.md"), `# Feature: ${name}
 
 ## Overview
 
@@ -77407,7 +78002,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 
 ## Acceptance Criteria
 `);
-  await Bun.write(join43(featureDir, "plan.md"), `# Plan: ${name}
+  await Bun.write(join48(featureDir, "plan.md"), `# Plan: ${name}
 
 ## Architecture
 
@@ -77415,7 +78010,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 
 ## Dependencies
 `);
-  await Bun.write(join43(featureDir, "tasks.md"), `# Tasks: ${name}
+  await Bun.write(join48(featureDir, "tasks.md"), `# Tasks: ${name}
 
 ## US-001: [Title]
 
@@ -77424,7 +78019,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 ### Acceptance Criteria
 - [ ] Criterion 1
 `);
-  await Bun.write(join43(featureDir, "progress.txt"), `# Progress: ${name}
+  await Bun.write(join48(featureDir, "progress.txt"), `# Progress: ${name}
 
 Created: ${new Date().toISOString()}
 
@@ -77452,8 +78047,8 @@ features.command("list").description("List all features").option("-d, --dir <pat
     console.error(source_default.red("nax not initialized."));
     process.exit(1);
   }
-  const featuresDir = join43(naxDir, "features");
-  if (!existsSync32(featuresDir)) {
+  const featuresDir = join48(naxDir, "features");
+  if (!existsSync34(featuresDir)) {
     console.log(source_default.dim("No features yet."));
     return;
   }
@@ -77467,8 +78062,8 @@ features.command("list").description("List all features").option("-d, --dir <pat
 Features:
 `));
   for (const name of entries) {
-    const prdPath = join43(featuresDir, name, "prd.json");
-    if (existsSync32(prdPath)) {
+    const prdPath = join48(featuresDir, name, "prd.json");
+    if (existsSync34(prdPath)) {
       const prd = await loadPRD(prdPath);
       const c = countStories(prd);
       console.log(`  ${name} \u2014 ${c.passed}/${c.total} stories done`);
@@ -77498,10 +78093,10 @@ Use: nax plan -f <feature> --from <spec>`));
     process.exit(1);
   }
   const config2 = await loadConfig(workdir);
-  const featureLogDir = join43(naxDir, "features", options.feature, "plan");
+  const featureLogDir = join48(naxDir, "features", options.feature, "plan");
   mkdirSync6(featureLogDir, { recursive: true });
   const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const planLogPath = join43(featureLogDir, `${planLogId}.jsonl`);
+  const planLogPath = join48(featureLogDir, `${planLogId}.jsonl`);
   initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
   console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
   try {
@@ -77538,8 +78133,8 @@ program2.command("analyze").description("(deprecated) Parse spec.md into prd.jso
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join43(naxDir, "features", options.feature);
-  if (!existsSync32(featureDir)) {
+  const featureDir = join48(naxDir, "features", options.feature);
+  if (!existsSync34(featureDir)) {
     console.error(source_default.red(`Feature "${options.feature}" not found.`));
     process.exit(1);
   }
@@ -77554,7 +78149,7 @@ program2.command("analyze").description("(deprecated) Parse spec.md into prd.jso
       specPath: options.from,
       reclassify: options.reclassify
     });
-    const prdPath = join43(featureDir, "prd.json");
+    const prdPath = join48(featureDir, "prd.json");
     await Bun.write(prdPath, JSON.stringify(prd, null, 2));
     const c = countStories(prd);
     console.log(source_default.green(`
@@ -77782,14 +78377,16 @@ program2.command("prompts").description("Assemble or initialize prompts").option
     process.exit(1);
   }
 });
-program2.command("generate").description("Generate agent config files (CLAUDE.md, AGENTS.md, etc.) from nax/context.md").option("-c, --context <path>", "Context file path (default: nax/context.md)").option("-o, --output <dir>", "Output directory (default: project root)").option("-a, --agent <name>", "Specific agent (claude|opencode|cursor|windsurf|aider)").option("--dry-run", "Preview without writing files", false).option("--no-auto-inject", "Disable auto-injection of project metadata").action(async (options) => {
+program2.command("generate").description("Generate agent config files (CLAUDE.md, AGENTS.md, etc.) from nax/context.md").option("-c, --context <path>", "Context file path (default: nax/context.md)").option("-o, --output <dir>", "Output directory (default: project root)").option("-a, --agent <name>", "Specific agent (claude|opencode|cursor|windsurf|aider)").option("--dry-run", "Preview without writing files", false).option("--no-auto-inject", "Disable auto-injection of project metadata").option("--package <dir>", "Generate CLAUDE.md for a specific package (e.g. packages/api)").option("--all-packages", "Generate CLAUDE.md for all discovered packages", false).action(async (options) => {
   try {
     await generateCommand({
       context: options.context,
       output: options.output,
       agent: options.agent,
       dryRun: options.dryRun,
-      noAutoInject: !options.autoInject
+      noAutoInject: !options.autoInject,
+      package: options.package,
+      allPackages: options.allPackages
     });
   } catch (err) {
     console.error(source_default.red(`Error: ${err.message}`));