organic-growth 3.1.0 → 3.3.0

package/README.md

@@ -2,7 +2,7 @@
 
 [![Test](https://github.com/lab71tech/organic-growth/actions/workflows/test.yml/badge.svg)](https://github.com/lab71tech/organic-growth/actions/workflows/test.yml) [![GitHub Release](https://img.shields.io/github/v/release/lab71tech/organic-growth)](https://github.com/lab71tech/organic-growth/releases)
 
-Claude Code setup for incremental software development.
+Claude Code, opencode, and Codex setup for incremental software development.
 
 Grow features in natural stages, where each stage delivers a complete, working system.
 
@@ -21,24 +21,40 @@ bunx organic-growth
 # Or with npx:
 npx organic-growth
 
+# Install for opencode:
+bunx organic-growth --opencode
+
+# Install for Codex:
+bunx organic-growth --codex
+# Or:
+bunx organic-growth --target codex
+
 # With a product DNA document:
 bunx organic-growth docs/my-product-spec.md
 
 # Force overwrite existing files:
 bunx organic-growth --force
+
+# Upgrade managed files (preserves CLAUDE.md, .mcp.json, etc.):
+bunx organic-growth --upgrade
+
+# Upgrade Codex templates explicitly:
+bunx organic-growth --upgrade --codex
 ```
 
-This installs `CLAUDE.md` at your project root and a `.claude/` directory with agents and commands. No runtime dependencies.
+Default install creates `CLAUDE.md` and `.claude/` for Claude Code. `--opencode` installs `AGENTS.md` and `.opencode/`. `--codex` installs `AGENTS.md` and `.codex/`. No runtime dependencies.
 
 ## What You Get
 
+### Claude Code (default)
+
 ```
 CLAUDE.md                           # Project context template + growth philosophy
 .claude/
 ├── agents/
 │   └── gardener.md                 # Plans, implements, and validates growth stages
 ├── commands/
-│   ├── seed.md                     # /seed     — bootstrap new project
+│   ├── seed.md                     # /seed     — plant the seed (new or existing project)
 │   ├── grow.md                     # /grow     — plan a new feature
 │   ├── map.md                      # /map      — view or adjust growth map
 │   ├── next.md                     # /next     — implement next stage
@@ -55,15 +71,50 @@ CLAUDE.md                           # Project context template + growth philosop
 └── growth/                         # One growth plan per feature
 ```
 
+### opencode
+
+```
+AGENTS.md                           # Project context template + growth philosophy
+.opencode/
+├── agents/
+│   └── gardener.md
+├── commands/
+│   ├── seed.md
+│   ├── grow.md
+│   ├── map.md
+│   ├── next.md
+│   ├── next-automatic.md
+│   ├── replan.md
+│   └── review.md
+└── ...
+```
+
+### Codex
+
+```
+AGENTS.md                           # Project context template + growth philosophy
+.codex/
+└── prompts/
+    ├── seed.md
+    ├── grow.md
+    ├── map.md
+    ├── next.md
+    ├── next-automatic.md
+    ├── replan.md
+    └── review.md
+```
+
 Growth plan files (`.organic-growth/growth/*.md`) use plant-themed visual markers -- seedlings for pending stages, trees for completed ones, vines between sections -- so you can tell at a glance where a feature stands.
 
 A **post-stage test** hook and a **post-stage review** hook run automatically after every stage commit, in order:
 
-1. **Test hook** — runs your test suite (discovered from the `**Test:**` field in CLAUDE.md) and injects pass/fail results into the conversation. On failure, tells Claude to fix before continuing.
+1. **Test hook** — runs your test suite (discovered from the `**Test:**` field in `CLAUDE.md`) and injects pass/fail results into the conversation. On failure, tells Claude to fix before continuing.
 2. **Review hook** — captures the commit diff and injects it as review context, giving the gardener agent an immediate second look at what changed.
 
 Tests run first so failures are caught before the review. This makes the quality gate deterministic — tests always run after stage commits, regardless of whether the agent remembers to.
 
+Codex support uses prompt files in `.codex/prompts/`. Launch Codex with `CODEX_HOME=.codex codex` to use the repo-local Organic Growth prompts. Claude-style post-stage hooks are not currently installed for Codex. Upgrade auto-detects the installed target when the repo contains only one managed config tree, but the explicit form `npx organic-growth --upgrade --codex` is also supported.
+
 ## Workflow
 
 ```bash
@@ -92,7 +143,7 @@ Tests run first so failures are caught before the review. This makes the quality
 - **Rolling plan:** 3-5 stages ahead, re-evaluate every 3
 - **Two-layer quality:** [properties](#property-based-planning) before code, deterministic tools after every stage, LLM review on demand
 - **Context hygiene:** fresh session every 3 stages
-- **Product context required:** fill in CLAUDE.md or provide a DNA document
+- **Product context required:** fill in `CLAUDE.md` or `AGENTS.md`, or provide a DNA document
 
 ## Property-Based Planning
 
@@ -106,19 +157,20 @@ Properties are not test cases or user stories. A test says "when I do X, Y happe
                      count decreases by exactly one" [invariant]
 ```
 
-**Why this matters for LLM-assisted development:** When Claude generates a stage, you review 3-5 properties instead of a 300-line diff. If the properties are right, the code is constrained to be right. The review shifts from "is this code correct?" to "are these rules complete?"
+**Why this matters for LLM-assisted development:** When your coding agent generates a stage, you review 3-5 properties instead of a 300-line diff. If the properties are right, the code is constrained to be right. The review shifts from "is this code correct?" to "are these rules complete?"
 
 Properties **accumulate** across stages. Stage 3 must still satisfy the properties from stages 1 and 2. They are permanent commitments, not checkboxes to discard. This is what prevents regressions as the feature grows.
 
-The gardener agent handles the full property format — categories, failure analysis, dependency tracking. See the [example growth plan](docs/example-growth-plan.md) for what this looks like in practice.
+The gardener agent handles the full property format — categories, failure analysis, dependency tracking. See the [example growth plan](.organic-growth/example-growth-plan.md) for what this looks like in practice.
 
 ## After Install
 
-1. Edit `CLAUDE.md` — fill in the Product section (or run `/seed`)
+1. Edit `CLAUDE.md` or `AGENTS.md` — fill in the Product section (or run `/seed`)
 2. Fill in Quality Tools section with your project's lint/test commands
-3. Start building with `/grow`
+3. For Codex, launch with `CODEX_HOME=.codex codex`
+4. Start building with `/grow`
 
-See the [example growth plan](docs/example-growth-plan.md) to see properties, stages, and accumulation in action.
+See the [example growth plan](.organic-growth/example-growth-plan.md) to see properties, stages, and accumulation in action.
 
 ## Releases
 

package/bin/cli.mjs

@@ -18,6 +18,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const TEMPLATES_DIR = join(__dirname, '..', 'templates');
 const TEMPLATES_OPENCODE_DIR = join(__dirname, '..', 'templates-opencode');
+const TEMPLATES_CODEX_DIR = join(__dirname, '..', 'templates-codex');
 const TARGET_DIR = process.cwd();
 
 const RESET = '\x1b[0m';
@@ -120,19 +121,87 @@ function readVersion() {
   return pkg.version;
 }
 
+const TARGETS = {
+  claude: {
+    label: 'Claude Code',
+    templatesDir: TEMPLATES_DIR,
+    contextFile: 'CLAUDE.md',
+    userFiles: ['CLAUDE.md', '.mcp.json'],
+  },
+  opencode: {
+    label: 'opencode',
+    templatesDir: TEMPLATES_OPENCODE_DIR,
+    contextFile: 'AGENTS.md',
+    userFiles: ['AGENTS.md', 'opencode.json'],
+  },
+  codex: {
+    label: 'Codex',
+    templatesDir: TEMPLATES_CODEX_DIR,
+    contextFile: 'AGENTS.md',
+    userFiles: ['AGENTS.md'],
+  }
+};
+
+function detectInstalledTarget(targetDir) {
+  const installedTargets = [];
+
+  if (existsSync(join(targetDir, '.claude'))) installedTargets.push('claude');
+  if (existsSync(join(targetDir, '.opencode'))) installedTargets.push('opencode');
+  if (existsSync(join(targetDir, '.codex'))) installedTargets.push('codex');
+
+  if (installedTargets.length > 1) {
+    console.error(`Error: multiple managed target directories found (${installedTargets.join(', ')}). Re-run with --target, --opencode, or --codex.`);
+    process.exit(1);
+  }
+
+  return installedTargets[0] || null;
+}
+
+function parseTarget(args, targetDir, upgrade) {
+  const explicitTargetIndex = args.findIndex(arg => arg === '--target');
+  const explicitTarget = explicitTargetIndex >= 0 ? args[explicitTargetIndex + 1] : null;
+  const isOpencode = args.includes('--opencode');
+  const isCodex = args.includes('--codex');
+
+  if (explicitTargetIndex >= 0 && !explicitTarget) {
+    console.error(`Error: missing value for --target. Expected one of: ${Object.keys(TARGETS).join(', ')}.`);
+    process.exit(1);
+  }
+
+  if (explicitTarget && !TARGETS[explicitTarget]) {
+    console.error(`Error: unknown target "${explicitTarget}". Expected one of: ${Object.keys(TARGETS).join(', ')}.`);
+    process.exit(1);
+  }
+
+  const selected = [explicitTarget, isOpencode ? 'opencode' : null, isCodex ? 'codex' : null].filter(Boolean);
+  if (selected.length > 1) {
+    console.error('Error: choose only one install target. Use either --target, --opencode, or --codex.');
+    process.exit(1);
+  }
+
+  if (selected.length === 0 && upgrade) {
+    return detectInstalledTarget(targetDir) || 'claude';
+  }
+
+  return selected[0] || 'claude';
+}
+
 function printHelp() {
   log('');
-  log(`${GREEN}🌱 Organic Growth${RESET} — Claude Code + opencode setup for incremental development`);
+  log(`${GREEN}🌱 Organic Growth${RESET} — Claude Code, opencode, and Codex setup for incremental development`);
   log('');
   log(`${CYAN}Usage:${RESET}`);
   log(`  npx organic-growth [options] [dna-file.md]`);
   log('');
   log(`${CYAN}Options:${RESET}`);
   log(`  -f, --force     Overwrite existing files without prompting`);
+  log(`      --upgrade   Update managed files while preserving user customizations`);
   log(`      --migrate   Move legacy docs/growth and docs/product-dna.md to .organic-growth/`);
   log(`  -h, --help      Show this help message`);
   log(`  -v, --version   Show version number`);
+  log(`      --target    Install templates for claude, opencode, or codex`);
   log(`      --opencode  Install opencode templates (AGENTS.md + .opencode/)`);
+  log(`      --codex     Install Codex templates (AGENTS.md + .codex/)`);
   log('');
   log(`${CYAN}Arguments:${RESET}`);
   log(`  dna-file.md     Path to a product DNA document to copy into .organic-growth/`);
@@ -140,7 +209,10 @@ function printHelp() {
   log(`${CYAN}Examples:${RESET}`);
   log(`  npx organic-growth                  Install Claude Code templates`);
   log(`  npx organic-growth --opencode       Install opencode templates`);
+  log(`  npx organic-growth --codex          Install Codex templates`);
+  log(`  npx organic-growth --target codex   Install Codex templates`);
   log(`  npx organic-growth --force          Install templates (overwrite existing)`);
+  log(`  npx organic-growth --upgrade         Update managed files, keep user customizations`);
   log(`  npx organic-growth --migrate        Migrate legacy docs/ state into .organic-growth/`);
   log(`  npx organic-growth spec.md          Install templates + copy DNA document`);
   log('');
@@ -160,126 +232,213 @@ async function install() {
   }
 
   const force = args.includes('--force') || args.includes('-f');
+  const upgrade = args.includes('--upgrade');
   const migrate = args.includes('--migrate');
-  const isOpencode = args.includes('--opencode');
+  const target = parseTarget(args, TARGET_DIR, upgrade);
+  const targetConfig = TARGETS[target];
   const dna = args.find(a => !a.startsWith('-') && a.endsWith('.md'));
 
+  // --upgrade and --force are mutually exclusive
+  if (upgrade && force) {
+    console.error('Error: --upgrade and --force are mutually exclusive. Use --upgrade to update managed files while preserving user customizations, or --force to overwrite everything.');
+    process.exit(1);
+  }
+
+  // User-customized files that --upgrade should never overwrite or create
+  const USER_FILES = new Set(targetConfig.userFiles);
+
+  function isUserFile(filePath) {
+    // Check if the file's basename (top-level name) is in the user files set
+    return USER_FILES.has(filePath);
+  }
+
   log('');
-  if (isOpencode) {
-    log(`${GREEN}🌱 Organic Growth${RESET} — opencode setup for incremental development`);
+  if (upgrade) {
+    log(`${GREEN}🌱 Organic Growth${RESET} — upgrading managed files`);
   } else {
-    log(`${GREEN}🌱 Organic Growth${RESET} — Claude Code setup for incremental development`);
+    log(`${GREEN}🌱 Organic Growth${RESET} — ${targetConfig.label} setup for incremental development`);
   }
   log('');
 
-  const templatesDir = isOpencode ? TEMPLATES_OPENCODE_DIR : TEMPLATES_DIR;
-  const files = getAllFiles(templatesDir);
-  const created = [];
-  const skipped = [];
+  if (upgrade) {
+    // Read existing version for display
+    const versionFilePath = join(TARGET_DIR, '.organic-growth', '.version');
+    const fromVersion = existsSync(versionFilePath)
+      ? readFileSync(versionFilePath, 'utf8').trim()
+      : 'unknown';
+    const toVersion = readVersion();
 
-  for (const file of files) {
-    const src = join(templatesDir, file);
-    const dest = join(TARGET_DIR, file);
-    const destDir = dirname(dest);
+    const templatesDir = targetConfig.templatesDir;
+    const files = getAllFiles(templatesDir);
+    const updated = [];
+    const skippedUser = [];
 
-    if (!existsSync(destDir)) {
-      mkdirSync(destDir, { recursive: true });
-    }
+    for (const file of files) {
+      const src = join(templatesDir, file);
+      const dest = join(TARGET_DIR, file);
+      const destDir = dirname(dest);
 
-    if (existsSync(dest) && !force) {
-      if (!process.stdin.isTTY) {
-        skipped.push(file);
+      if (isUserFile(file)) {
+        // User-customized files: skip if they exist, don't create if missing
+        if (existsSync(dest)) {
+          skippedUser.push(file);
+        }
+        // If it doesn't exist, we intentionally do NOT create it (P8)
         continue;
       }
-      const answer = await ask(`${YELLOW}!${RESET} ${file} already exists. Overwrite? [y/N] `);
-      if (answer !== 'y' && answer !== 'yes') {
-        skipped.push(file);
-        continue;
+
+      // Managed file: overwrite (or create if new)
+      if (!existsSync(destDir)) {
+        mkdirSync(destDir, { recursive: true });
       }
+      copyFileSync(src, dest);
+      updated.push(file);
     }
 
-    copyFileSync(src, dest);
-    created.push(file);
-  }
+    // Display upgrade results
+    info(`Upgrading from ${CYAN}${fromVersion}${RESET} to ${CYAN}${toVersion}${RESET}`);
+    log('');
 
-  // Create .organic-growth/growth/ directory
-  const growthDir = join(TARGET_DIR, '.organic-growth', 'growth');
-  if (!existsSync(growthDir)) {
-    mkdirSync(growthDir, { recursive: true });
-    created.push('.organic-growth/growth/');
-  }
+    if (updated.length > 0) {
+      log(`${GREEN}Updated:${RESET}`);
+      for (const f of updated) {
+        log(`  ${DIM}${f}${RESET}`);
+      }
+    }
+    if (skippedUser.length > 0) {
+      log(`${YELLOW}Skipped (user customized):${RESET}`);
+      for (const f of skippedUser) {
+        log(`  ${DIM}${f}${RESET}`);
+      }
+    }
 
-  // Handle DNA document
-  if (dna) {
-    const dnaSource = resolve(TARGET_DIR, dna);
-    if (existsSync(dnaSource)) {
-      const dnaDest = join(TARGET_DIR, '.organic-growth', 'product-dna.md');
-      mkdirSync(dirname(dnaDest), { recursive: true });
-      copyFileSync(dnaSource, dnaDest);
-      success(`Product DNA copied from ${dna}`);
-    } else {
-      warn(`DNA file not found: ${dna}`);
+    // Write version file after all managed files are updated
+    const ogDir = join(TARGET_DIR, '.organic-growth');
+    if (!existsSync(ogDir)) {
+      mkdirSync(ogDir, { recursive: true });
     }
-  }
+    writeFileSync(join(ogDir, '.version'), toVersion);
 
-  if (migrate) {
-    const migrated = migrateLegacyState(TARGET_DIR);
-    if (migrated.length > 0) {
-      log('');
-      log(`${GREEN}Migrated:${RESET}`);
-      for (const step of migrated) {
-        log(`  ${DIM}${step}${RESET}`);
+    log('');
+    log(`${GREEN}Done!${RESET} ${updated.length} updated, ${skippedUser.length} skipped.`);
+    log('');
+  } else {
+    // Normal install flow
+    const templatesDir = targetConfig.templatesDir;
+    const files = getAllFiles(templatesDir);
+    const created = [];
+    const skipped = [];
+
+    for (const file of files) {
+      const src = join(templatesDir, file);
+      const dest = join(TARGET_DIR, file);
+      const destDir = dirname(dest);
+
+      if (!existsSync(destDir)) {
+        mkdirSync(destDir, { recursive: true });
       }
-    } else {
-      info('No legacy docs/ state found to migrate');
-    }
-  }
 
-  log('');
-  if (created.length > 0) {
-    log(`${GREEN}Installed:${RESET}`);
-    for (const f of created) {
-      log(`  ${DIM}${f}${RESET}`);
+      if (existsSync(dest) && !force) {
+        if (!process.stdin.isTTY) {
+          skipped.push(file);
+          continue;
+        }
+        const answer = await ask(`${YELLOW}!${RESET} ${file} already exists. Overwrite? [y/N] `);
+        if (answer !== 'y' && answer !== 'yes') {
+          skipped.push(file);
+          continue;
+        }
+      }
+
+      copyFileSync(src, dest);
+      created.push(file);
     }
-  }
-  if (skipped.length > 0) {
-    log(`${YELLOW}Skipped (already exist):${RESET}`);
-    for (const f of skipped) {
-      log(`  ${DIM}${f}${RESET}`);
+
+    // Create .organic-growth/growth/ directory
+    const growthDir = join(TARGET_DIR, '.organic-growth', 'growth');
+    if (!existsSync(growthDir)) {
+      mkdirSync(growthDir, { recursive: true });
+      created.push('.organic-growth/growth/');
     }
-  }
 
-  log('');
-  log(`${GREEN}Done!${RESET} Next steps:`);
-  log('');
-  if (isOpencode) {
+    // Handle DNA document
     if (dna) {
-      info(`Run ${CYAN}/seed .organic-growth/product-dna.md${RESET} to bootstrap from your DNA document`);
-    } else {
-      info(`Run ${CYAN}/seed${RESET} to bootstrap a new project (interview mode)`);
-      info(`Or: ${CYAN}/seed path/to/product-doc.md${RESET} if you have a product document`);
+      const dnaSource = resolve(TARGET_DIR, dna);
+      if (existsSync(dnaSource)) {
+        const dnaDest = join(TARGET_DIR, '.organic-growth', 'product-dna.md');
+        mkdirSync(dirname(dnaDest), { recursive: true });
+        copyFileSync(dnaSource, dnaDest);
+        success(`Product DNA copied from ${dna}`);
+      } else {
+        warn(`DNA file not found: ${dna}`);
+      }
     }
-    info(`Edit ${CYAN}AGENTS.md${RESET} to fill in your tech stack and quality tools`);
-  } else {
+
+    if (migrate) {
+      const migrated = migrateLegacyState(TARGET_DIR);
+      if (migrated.length > 0) {
+        log('');
+        log(`${GREEN}Migrated:${RESET}`);
+        for (const step of migrated) {
+          log(`  ${DIM}${step}${RESET}`);
+        }
+      } else {
+        info('No legacy docs/ state found to migrate');
+      }
+    }
+
+    log('');
+    if (created.length > 0) {
+      log(`${GREEN}Installed:${RESET}`);
+      for (const f of created) {
+        log(`  ${DIM}${f}${RESET}`);
+      }
+    }
+    if (skipped.length > 0) {
+      log(`${YELLOW}Skipped (already exist):${RESET}`);
+      for (const f of skipped) {
+        log(`  ${DIM}${f}${RESET}`);
+      }
+    }
+
+    // Write version file after all templates and DNA are handled
+    const versionFilePath = join(TARGET_DIR, '.organic-growth', '.version');
+    const ogDir = dirname(versionFilePath);
+    if (!existsSync(ogDir)) {
+      mkdirSync(ogDir, { recursive: true });
+    }
+    writeFileSync(versionFilePath, readVersion());
+
+    log('');
+    log(`${GREEN}Done!${RESET} Next steps:`);
+    log('');
     if (dna) {
       info(`Run ${CYAN}/seed .organic-growth/product-dna.md${RESET} to bootstrap from your DNA document`);
     } else {
       info(`Run ${CYAN}/seed${RESET} to bootstrap a new project (interview mode)`);
       info(`Or: ${CYAN}/seed path/to/product-doc.md${RESET} if you have a product document`);
     }
-    info(`Edit ${CYAN}CLAUDE.md${RESET} to fill in your tech stack and quality tools`);
-  }
-  log('');
-  log(`${DIM}Commands available after setup:${RESET}`);
-  log(`  ${CYAN}/seed${RESET}    — bootstrap project (interview or DNA document)`);
-  log(`  ${CYAN}/grow${RESET}    — plan and start a new feature`);
-  log(`  ${CYAN}/map${RESET}     — view or adjust the system growth map`);
-  log(`  ${CYAN}/next${RESET}    — implement the next growth stage`);
-  log(`  ${CYAN}/next-automatic${RESET} — run multiple stages automatically`);
-  log(`  ${CYAN}/replan${RESET}  — re-evaluate when things change`);
-  log(`  ${CYAN}/review${RESET}  — deep quality review of recent stages`);
+    info(`Edit ${CYAN}${targetConfig.contextFile}${RESET} to fill in your tech stack and quality tools`);
+    if (target === 'codex') {
+      info(`Launch Codex with ${CYAN}CODEX_HOME=.codex codex${RESET} so the installed prompts are used for this repo`);
+    }
+    log('');
+    log(`${DIM}Commands available after setup:${RESET}`);
+    log(`  ${CYAN}/seed${RESET}    — bootstrap project (interview or DNA document)`);
+    log(`  ${CYAN}/grow${RESET}    — plan and start a new feature`);
+    log(`  ${CYAN}/map${RESET}     — view or adjust the system growth map`);
+    log(`  ${CYAN}/next${RESET}    — implement the next growth stage`);
+    log(`  ${CYAN}/next-automatic${RESET} — run multiple stages automatically`);
+    log(`  ${CYAN}/replan${RESET}  — re-evaluate when things change`);
+    log(`  ${CYAN}/review${RESET}  — deep quality review of recent stages`);
 
-  log('');
+    log('');
+    const upgradeHint = target === 'claude'
+      ? 'npx organic-growth --upgrade'
+      : `npx organic-growth --upgrade --${target}`;
+    log(`${DIM}To upgrade later: ${upgradeHint}${RESET}`);
+    log('');
+  }
 }
 
 install().catch(err => {

package/package.json

@@ -1,18 +1,21 @@
 {
   "name": "organic-growth",
-  "version": "3.1.0",
-  "description": "Claude Code and opencode setup for incremental software development — grow features in natural stages",
+  "version": "3.3.0",
+  "description": "Claude Code, opencode, and Codex setup for incremental software development — grow features in natural stages",
   "bin": {
     "organic-growth": "bin/cli.mjs"
   },
   "files": [
     "bin/",
     "templates/",
-    "templates-opencode/"
+    "templates-opencode/",
+    "templates-codex/"
   ],
   "keywords": [
     "claude-code",
     "opencode",
+    "codex",
+    "openai",
     "ai",
     "agents",
     "agile",

package/templates/.claude/commands/seed.md

@@ -1,13 +1,39 @@
 ---
-description: Bootstrap a new project — from DNA document or interview
+description: Plant the seed for a project — from DNA document or interview
 ---
 
-Plant the seed for a new project.
+Plant the seed for a project.
 
-0. Scan project root for existing code (`src/`, `package.json`, `build.gradle`, `README.md`, etc.).
-   If code already exists:
-   - Read README/build files to auto-fill Tech Stack
-   - Discover quality commands (build, lint, test)
+0. **Detect existing project.**
+   Scan project root for existing code (`src/`, `lib/`, `app/`, `package.json`, `build.gradle`, `Cargo.toml`, `go.mod`, `pyproject.toml`, `pom.xml`, `README.md`, etc.).
+
+   - If code or build files already exist → **EXISTING = true**
+   - If the project root is empty or contains only config files → **EXISTING = false**
+
+   When EXISTING = true, scan these files and extract the noted information:
+
+   **Auto-discovery checklist:**
+   - `package.json` → scripts (build, test, lint, start), engines, dependencies and devDependencies for stack detection (e.g., react, express, typescript)
+   - `build.gradle` / `build.gradle.kts` → plugins (java, kotlin, spring-boot), tasks (test, check, ktlintCheck), dependencies for framework detection
+   - `pyproject.toml` → build-system, project.scripts, dependencies, optional-dependencies, tool sections (pytest, ruff, mypy, black)
+   - `Cargo.toml` → edition, dependencies, dev-dependencies, workspace members, features
+   - `go.mod` → go version, module path, require directives for framework detection (gin, echo, fiber)
+   - `pom.xml` → plugins, parent (spring-boot-starter-parent), dependencies, build configuration
+   - `Makefile` → target names (build, test, lint, check, fmt, run) and the commands they execute
+   - `README.md` → project description, setup/install instructions, usage examples for product context
+   - `.github/workflows/*.yml` → build/test/lint commands used in CI steps, language versions in matrix
+   - `.gitlab-ci.yml` → build/test/lint commands used in CI stages, image versions
+
+   From the discovered files, populate the **Quality Tools** section of CLAUDE.md with the exact commands for:
+   - **Build:** (e.g., `npm run build`, `./gradlew build`, `cargo build`)
+   - **Lint:** (e.g., `npm run lint`, `./gradlew ktlintCheck`, `cargo clippy`)
+   - **Type check:** (e.g., `tsc --noEmit`, or N/A)
+   - **Test:** (e.g., `npm test`, `./gradlew test`, `cargo test`)
+   - **Smoke:** (e.g., `npm start`, `./gradlew bootRun`, or a health endpoint)
+
+   Present the discovered tech stack and quality tools to the user for confirmation before writing them.
+
+   Also:
    - Adjust interview: skip "what tech stack?" and "what are you building?"
    - Ask instead: "what change do you want to make?" and "any constraints?"
    - Check recent git commits and ask whether to follow existing commit convention
@@ -24,7 +50,22 @@ Plant the seed for a new project.
    - If Business Rules are missing, ask: "Any rules that must ALWAYS hold?"
    - Confirm with the user: "Here's what I extracted. Anything to adjust?"
 
-   **Path B — No DNA:**
+   **Path B1 — Existing project, no DNA (EXISTING = true):**
+   - Present what you discovered in Step 0 to the user:
+     "Here's what I discovered about your project:" followed by a summary of
+     the tech stack, quality tools, and any product context from README.md.
+   - Ask the user to confirm or adjust what was discovered.
+   - Then ask only gap-filling questions ONE AT A TIME (skip any already
+     answered by the discoveries):
+     - What core problem does this project solve?
+     - What business rules must ALWAYS be true?
+     - What are the current priorities? (e.g., new feature, refactor, stabilize)
+     - Any hard constraints? (performance, compliance, deployment, backwards compatibility)
+   - Generate `.organic-growth/product-dna.md` using the structured template.
+     Leave missing sections as `<!-- to be filled -->`.
+   - Fill in CLAUDE.md Product section from discoveries + answers.
+
+   **Path B2 — Greenfield, no DNA (EXISTING = false):**
    - Before the interview, briefly consider what this project could be:
      what kind of system, likely domain risks, and which questions matter most.
      Do not create separate brainstorming artifacts.
@@ -49,7 +90,13 @@ Plant the seed for a new project.
 3. Check if CLAUDE.md already has a filled Product section.
    If yes, ask: "Product context already exists. Overwrite or update?"
 
-4. Generate `.organic-growth/growth/project-bootstrap.md` — the first growth plan:
+4. **Growth plan generation (greenfield only).**
+
+   If EXISTING = true → **skip this step entirely.** Do NOT generate
+   `project-bootstrap.md`. Existing projects do not need bootstrap stages —
+   the user will run `/grow` to plan their first feature against the existing codebase.
+
+   If EXISTING = false → generate `.organic-growth/growth/project-bootstrap.md` — the first growth plan:
    - Stage 1: Initialize project (build tool, dependencies, empty build passes)
    - Stage 2: Hello World endpoint/page (proves stack works end-to-end)
    - Stage 3: First domain concept with hardcoded data
@@ -57,7 +104,12 @@ Plant the seed for a new project.
    - Stage 5: First real behavior with real data
    - Include `Capabilities:` tags in the plan header
 
-5. If the project has 4+ distinct capabilities (from DNA/interview),
+5. **Growth map generation (greenfield only).**
+
+   If EXISTING = true → **skip this step entirely.** Do NOT generate
+   `growth-map.md`. There is no bootstrap plan to map.
+
+   If EXISTING = false → if the project has 4+ distinct capabilities (from DNA/interview),
    generate `.organic-growth/growth-map.md` draft:
    - Organize sequence into Walking Skeleton and what follows
    - Add short "Why This Order"
@@ -65,6 +117,12 @@ Plant the seed for a new project.
    - Present as aspirational, not a commitment
 
 6. Present a summary of what was created:
+
+   If EXISTING = true:
+   - Product DNA (`.organic-growth/product-dna.md`)
+   - CLAUDE.md Product/Tech Stack/Priorities sections
+
+   If EXISTING = false:
    - Product DNA (`.organic-growth/product-dna.md`)
    - CLAUDE.md Product/Tech Stack/Priorities sections
    - Growth plan (`.organic-growth/growth/project-bootstrap.md`)
@@ -79,7 +137,14 @@ Plant the seed for a new project.
    - Do NOT create src/, lib/, app/, or any implementation directories.
    - Do NOT commit anything beyond the seed files created above.
 
-   The ONLY files you create are:
+   If EXISTING = true, the ONLY files you create are:
+   - `.organic-growth/product-dna.md`
+   - `CLAUDE.md` (fill in Product/Tech Stack/Priorities sections)
+
+   Say exactly:
+   "Seed planted. Run `/grow` when you're ready to plan your first feature."
+
+   If EXISTING = false, the ONLY files you create are:
    - `.organic-growth/product-dna.md`
    - `.organic-growth/growth/project-bootstrap.md`
    - `.organic-growth/growth-map.md` (if applicable)

package/templates-codex/.codex/prompts/grow.md

@@ -0,0 +1,53 @@
+---
+description: Plan and start growing a new feature from seed
+---
+
+Grow a new feature using the Organic Growth approach.
+
+1. Read `AGENTS.md` first.
+   - If the Product section is still placeholders or empty, stop and tell the user to run `/seed` first.
+
+2. Read `.organic-growth/product-dna.md` and `.organic-growth/growth-map.md` if they exist.
+   - Treat business rules and completed capabilities as constraints.
+   - Search `.organic-growth/growth/` for related plans by capability tag when needed.
+
+3. Explore the current codebase so the plan reflects reality, not assumptions.
+
+4. Briefly reason through the problem space for `$ARGUMENTS`:
+   - 2-3 possible approaches
+   - riskiest assumption
+   - likely failure points
+   Keep this internal. Do not create separate artifacts.
+
+5. Ask the user 2-3 clarifying questions at most.
+   Focus on acceptance criteria, constraints, and the riskiest part.
+
+6. Create `.organic-growth/growth/<feature-name>.md` with:
+   - `Status: 🌱 Growing`
+   - 3-7 capability tags
+   - a one-paragraph Seed section
+   - 3-5 concrete stages
+   - a short horizon
+   - a Growth Log section
+
+7. For every concrete stage, define properties before implementation hints.
+   Consider invariants, state transitions, roundtrips, and boundaries.
+   Properties must express domain rules, not implementation details.
+
+8. Self-check the plan before presenting it:
+   - completeness
+   - independence from implementation
+   - property accumulation across stages
+   - boundary coverage where meaningful
+
+9. If `.organic-growth/growth-map.md` exists, update it:
+   - mark matching capabilities as `🌱`
+   - add the plan link
+   - insert new capabilities in the best-fit section when missing
+
+10. Present the plan for review.
+    Focus the user on reviewing properties, not implementation hints.
+
+11. Stop after the plan is approved.
+    Do not implement stage 1.
+    Say exactly: `Plan ready. Run /next when you're ready to grow stage 1.`

package/templates-codex/.codex/prompts/map.md

@@ -0,0 +1,22 @@
+---
+description: View or update the growth map — your system's big picture
+---
+
+Show or adjust the growth map.
+
+1. If `.organic-growth/growth-map.md` does not exist:
+   - Check whether `AGENTS.md` or `.organic-growth/product-dna.md` has enough context to draft one.
+   - If yes, generate a draft and present it for review.
+   - If no, tell the user to run `/seed` first or describe the system.
+
+2. If the map exists and `$ARGUMENTS` is empty:
+   - show the current map
+   - summarize statuses as `🌳 complete | 🌱 growing | ⬜ planned | 💡 candidates`
+   - suggest the next capability based on sequence and dependencies
+
+3. If `$ARGUMENTS` requests a change:
+   - update the map
+   - verify the new order still makes sense given completed plans and dependencies
+   - explain the reasoning behind the change
+
+Input: $ARGUMENTS

package/templates-codex/.codex/prompts/next-automatic.md

@@ -0,0 +1,30 @@
+---
+description: Run multiple growth stages automatically from the active plan
+---
+
+Run multiple growth stages in sequence. Stop on the first failure.
+
+1. Find the active growth plan in `.organic-growth/growth/`.
+   If no plan exists, tell the user to run `/grow` first and stop.
+
+2. Count the remaining concrete stages marked with `🌱`.
+
+3. Parse `$ARGUMENTS`.
+   - If it is a positive integer, use it as the maximum number of stages to run.
+   - If it is empty, run all remaining concrete stages.
+   - Otherwise, tell the user the argument must be a positive integer and stop.
+
+4. For each stage:
+   - re-read `AGENTS.md` and the growth plan from disk
+   - identify the first remaining `🌱` stage
+   - execute the full `/next` workflow for exactly that stage
+   - re-read the plan and verify the stage changed from `🌱` to `🌳`
+   - if verification fails, stop immediately
+
+5. After the loop, report:
+   - stages attempted
+   - stages completed
+   - first failure, if any
+   - whether all requested stages completed
+
+6. If 3 or more stages completed, suggest running `/review` and starting a fresh Codex session.

package/templates-codex/.codex/prompts/next.md

@@ -0,0 +1,49 @@
+---
+description: Grow the next stage from the current growth plan
+---
+
+Continue growing: implement the next stage from the active growth plan.
+
+1. Read `AGENTS.md`, the active growth plan in `.organic-growth/growth/`, and any related completed plans.
+
+2. Find the next `🌱` stage.
+   - If no plan exists, tell the user to run `/grow` first.
+   - If all stages are complete, say so and suggest what might grow next.
+
+3. If this is stage 3, 6, 9, or later, re-evaluate the remaining stages before implementing.
+   Update the plan if reality has changed.
+
+4. Implement only this stage.
+   - Treat the stage properties as acceptance criteria.
+   - Write or update tests first so each property is encoded explicitly.
+   - Then write the minimum code needed to pass the new and inherited properties.
+
+5. Run the quality gate and fix failures within the same stage:
+   - Build
+   - Lint
+   - Type check
+   - Full test suite
+   - Smoke check
+
+6. Self-review before committing:
+   - this stage only
+   - no work smuggled in from future stages
+   - earlier properties still hold
+   - implementation still matches the properties
+
+7. Update project state files.
+   - Mark the stage as `🌳` in the growth plan.
+   - Add a Growth Log entry for this stage.
+   - Update `.organic-growth/growth-map.md` if it exists.
+   - Add new domain concepts to `.organic-growth/product-dna.md` if introduced.
+   - Update `README.md` to reflect the current working system.
+   - Update `AGENTS.md` Current state when the milestone meaningfully changed.
+
+8. Commit with:
+   ```
+   feat(scope): stage N — <what grew>
+
+   Growth plan: .organic-growth/growth/<feature>.md
+   ```
+
+9. Report what grew, what properties were verified, what commands you ran, and what should happen next.

package/templates-codex/.codex/prompts/replan.md

@@ -0,0 +1,23 @@
+---
+description: Re-evaluate the growth plan when reality changes
+---
+
+Something changed. Re-evaluate the active growth plan from current state.
+
+1. Find the active plan in `.organic-growth/growth/`.
+   If no active plan exists, tell the user to run `/grow` first.
+
+2. Read `AGENTS.md`, the active growth plan, related completed plans, and the current codebase.
+
+3. Use `$ARGUMENTS` as the reason for replanning.
+   If no reason is given, ask: `What changed?`
+
+4. Preserve completed stages unless there is an explicit reason to invalidate them.
+   If a previous property must be broken, record it in `Breaks:` with the reason.
+
+5. Rewrite only the remaining stages and horizon so they reflect current reality.
+   Keep properties first, implementation hints second.
+
+6. Update `.organic-growth/growth-map.md` if the capability ordering or dependencies changed.
+
+7. Present the updated plan and explain the delta from the previous one.

package/templates-codex/.codex/prompts/review.md

@@ -0,0 +1,64 @@
+---
+description: Deep quality review of recent growth stages (fresh context, no implementation bias)
+---
+
+Review code quality of recent stages. Run this after several stages
+or before merging — it provides a second opinion with zero bias from
+the implementation session.
+
+1. Determine scope:
+   - If $ARGUMENTS contains a number (e.g., `/review 3`): review last N stages
+   - If $ARGUMENTS contains a feature name: review that feature's stages
+   - Default: review all stages since last review (or last 5, whichever is smaller)
+
+2. Read the growth plan to understand intent of each reviewed stage.
+
+3. For each stage in scope, examine the git diff and review for:
+
+   **Correctness:**
+   - Does the code actually do what the stage intended?
+   - Are there logic errors, off-by-one, null cases?
+   - Do the tests test the right thing? (not just "test exists")
+
+   **Consistency:**
+   - Does new code follow the same patterns as existing code?
+   - Naming conventions, error handling style, project structure
+   - If `.organic-growth/product-dna.md` exists: do domain terms match?
+
+   **Simplicity:**
+   - Is anything over-engineered for the current stage?
+   - Code that belongs in future stages?
+   - Unnecessary abstractions or premature optimization?
+
+   **Security basics:**
+   - SQL injection, XSS, hardcoded secrets
+   - Auth/authz gaps if relevant
+   - Input validation
+
+   **Test quality:**
+   - Do tests break if the feature is removed? (vs always-green tests)
+   - Are edge cases covered?
+   - Test readability — can someone understand intent from the test?
+
+4. Output a review report:
+
+   ```
+   ## Review: <feature> — stages N-M
+
+   ### 🟢 Good
+   - <what's well done — be specific>
+
+   ### 🟡 Suggestions
+   - <improvements, not blockers>
+   - <file:line — what to consider>
+
+   ### 🔴 Issues
+   - <things that should be fixed before continuing>
+   - <file:line — what's wrong and why>
+
+   ### Verdict: ✅ Continue / ⚠️ Fix before next stage / 🔴 Stop and address
+   ```
+
+5. If there are 🔴 Issues, offer to fix them now.
+
+Scope: $ARGUMENTS

package/templates-codex/.codex/prompts/seed.md

@@ -0,0 +1,70 @@
+---
+description: Plant the seed for a project — from DNA document or interview
+---
+
+Plant the seed for a project.
+
+0. Detect whether this is an existing project.
+   Scan project root for existing code (`src/`, `lib/`, `app/`, `package.json`, `build.gradle`, `Cargo.toml`, `go.mod`, `pyproject.toml`, `pom.xml`, `README.md`, etc.).
+
+   - If code or build files already exist -> `EXISTING = true`
+   - If the project root is empty or contains only config files -> `EXISTING = false`
+
+   When `EXISTING = true`, inspect the repo and extract:
+   - build, lint, typecheck, test, and smoke commands
+   - major frameworks and language/runtime versions
+   - product context from `README.md`, docs, or recent commits
+
+   Populate the Quality Tools section of `AGENTS.md` with exact commands.
+   Present the discovered stack and tools to the user for confirmation before writing them.
+
+1. Check for a product DNA document from `$ARGUMENTS` or `.organic-growth/product-dna.md`.
+
+   Path A — DNA exists:
+   - Read it.
+   - Distill it into the Product section of `AGENTS.md`.
+   - Normalize it into `.organic-growth/product-dna.md`.
+   - Fill `AGENTS.md` Product, Tech Stack, and Priorities sections from the DNA plus the project scan from Step 0.
+   - Populate the Quality Tools section with exact build, lint, typecheck, test, and smoke commands discovered from the repo.
+   - If the DNA omits stack or priority details, ask only the minimum follow-up needed to avoid placeholders.
+   - If business rules are missing, ask: "Any rules that must ALWAYS hold?"
+   - Confirm the extracted summary with the user.
+
+   Path B1 — existing project, no DNA:
+   - Present discovered project context first.
+   - Ask only gap-filling questions, one at a time:
+     - What core problem does this project solve?
+     - What business rules must ALWAYS be true?
+     - What are the current priorities?
+     - Any hard constraints?
+   - Generate `.organic-growth/product-dna.md` using the structured template.
+   - Fill `AGENTS.md` Product, Tech Stack, and Priorities sections from discoveries plus answers.
+
+   Path B2 — greenfield, no DNA:
+   - Ask one question at a time:
+     - What are you building?
+     - Who is it for?
+     - What core problem does it solve?
+     - What tech stack do you want?
+     - Any hard constraints?
+     - What matters most right now?
+     - What user roles exist?
+     - What business rules must ALWAYS be true?
+     - What is the main process flow?
+   - Generate `.organic-growth/product-dna.md`.
+   - Fill `AGENTS.md` Product, Tech Stack, and Priorities sections.
+
+2. In all paths, leave `AGENTS.md` with concrete Product, Tech Stack, Priorities, and Quality Tools entries, not placeholders.
+
+3. If `AGENTS.md` already has real product context, ask whether to overwrite or update it.
+
+4. For greenfield projects only, generate `.organic-growth/growth/project-bootstrap.md` with 3-5 concrete stages and a short horizon.
+   Follow the greenfield pattern in `AGENTS.md`.
+
+5. For greenfield projects only, generate `.organic-growth/growth-map.md` if the product has at least 4 distinct capabilities.
+
+6. Present a summary of what was created.
+
+7. Finish with exactly one of:
+   - Existing project: `Seed planted. Run /grow when you're ready to plan your first feature.`
+   - Greenfield project: `Seed planted. Review the files above, then run /next when you're ready to grow stage 1.`

package/templates-codex/AGENTS.md

@@ -0,0 +1,118 @@
+# Project Context
+
+## Product (THE SEED — fill this in)
+
+<!-- Without this section, the agent grows weeds. Be brief but specific. -->
+<!-- If you have a full product document, put it in .organic-growth/product-dna.md -->
+<!-- This section is the distilled version — what the agent sees always. -->
+<!-- The DNA document is read only during planning (/grow, /replan). -->
+
+**What:** [One sentence. What is this product?]
+**For whom:** [Who uses it? What's their context?]
+**Core problem:** [What pain does it solve?]
+**Key domain concepts:** [3-7 terms that someone new needs to understand]
+**Current state:** [Greenfield / MVP exists / Production system]
+**Full DNA:** [.organic-growth/product-dna.md if exists, otherwise "N/A"]
+
+## Tech Stack (THE SOIL — auto-discovered, but document the non-obvious)
+
+<!-- Codex reads your build files. Only add what it CAN'T discover. -->
+
+- [Any non-standard commands, e.g.: `./gradlew test --profile staging`]
+- [Unusual conventions, e.g.: "endpoint names in Polish"]
+- [Hard constraints, e.g.: "no Lombok", "Flyway not Liquibase"]
+
+### Quality tools (fill in for your project)
+
+<!-- Organic Growth runs these after every stage. List the exact commands. -->
+
+- **Build:** [e.g.: `./gradlew build` or `npm run build`]
+- **Lint:** [e.g.: `./gradlew ktlintCheck` or `npm run lint`]
+- **Type check:** [e.g.: `tsc --noEmit` or N/A for dynamic languages]
+- **Test:** [e.g.: `./gradlew test` or `npm test`]
+- **Smoke:** [e.g.: `curl http://localhost:8080/health` or `npm run dev` + check]
+
+## Priorities (LIGHT & WATER — what matters now)
+
+<!-- This changes. Update it when priorities shift. -->
+
+- [e.g.: "MVP speed over production polish"]
+- [e.g.: "Must work offline first"]
+- [e.g.: "Security is non-negotiable, even for MVP"]
+
+---
+
+# Development Philosophy: Organic Growth
+
+Every feature is grown in stages from seed to maturity.
+Each stage produces a complete, working system — not a partial one.
+A seedling is a whole plant, not 10% of a tree.
+
+## Growth Rules
+
+1. **One stage = one intent = one commit**
+   - Each stage has a single purpose
+   - Each stage defines properties (rules that must be true) before implementation
+   - Properties become tests — write tests first, then code to pass them
+   - Each stage is committed separately with a clear message
+   - The app builds, tests pass, and runs after every stage
+
+2. **Rolling plan: 3-5 stages ahead**
+   - Never plan more than 5 concrete stages ahead
+   - Keep a rough outline of what comes after, but expect it to change
+   - Re-evaluate the plan every 3 stages or when something unexpected happens
+   - Update `.organic-growth/growth/<feature>.md` after every stage
+
+3. **Vertical, not horizontal**
+   - Each stage touches all layers needed (API + service + DB + test)
+   - No "build all the backend first, then the frontend"
+   - Early stages can return hardcoded values — that's natural
+   - Growth: hardcoded -> configurable -> dynamic -> optimized
+
+4. **Context hygiene**
+   - Start a fresh Codex session every 3 stages
+   - The growth plan in `.organic-growth/growth/` is the continuity mechanism
+   - Relaunch Codex with `CODEX_HOME=.codex codex` before continuing if context gets stale
+
+5. **Quality gate after every stage**
+   - Build must pass
+   - Linter must pass (zero new warnings)
+   - Type check must pass (if applicable)
+   - ALL tests must pass (not just new ones)
+   - App must start (health check / smoke test)
+   - Fix all failures within the stage — don't carry debt forward
+
+6. **Deep review on demand**
+   - Run `/review` after every 3-5 stages or before merging
+   - Reviews run with fresh context (no implementation bias)
+   - Check: correctness, consistency, simplicity, security, test quality
+   - Fix 🔴 issues before continuing growth
+
+## Growth Stage Patterns
+
+For **greenfield** projects, first stages always follow this pattern:
+1. Empty project with passing build
+2. Hello World endpoint/page (proves the stack works end-to-end)
+3. First real domain concept with hardcoded data
+4. Persistence (database, migration, repository)
+5. First real behavior with real data
+
+For **existing** projects, first stages are:
+1. The simplest possible version of the new behavior (even hardcoded)
+2. Connect it to existing data/services
+3. Add the real logic incrementally
+
+## Commit Convention
+
+```
+feat(scope): stage N — <what grew>
+
+Growth plan: .organic-growth/growth/<feature>.md
+```
+
+## Growth Plan Location
+
+All plans live in `.organic-growth/growth/<feature-name>.md`.
+Product DNA lives in `.organic-growth/product-dna.md`.
+Growth map lives in `.organic-growth/growth-map.md` (if exists).
+Prompt files live in `.codex/prompts/` and are used when you launch Codex with `CODEX_HOME=.codex codex`.

package/templates-opencode/.opencode/commands/seed.md

@@ -1,13 +1,39 @@
 ---
-description: Bootstrap a new project — from DNA document or interview
+description: Plant the seed for a project — from DNA document or interview
 ---
 
-Plant the seed for a new project.
+Plant the seed for a project.
 
-0. Scan project root for existing code (`src/`, `package.json`, `build.gradle`, `README.md`, etc.).
-   If code already exists:
-   - Read README/build files to auto-fill Tech Stack
-   - Discover quality commands (build, lint, test)
+0. **Detect existing project.**
+   Scan project root for existing code (`src/`, `lib/`, `app/`, `package.json`, `build.gradle`, `Cargo.toml`, `go.mod`, `pyproject.toml`, `pom.xml`, `README.md`, etc.).
+
+   - If code or build files already exist → **EXISTING = true**
+   - If the project root is empty or contains only config files → **EXISTING = false**
+
+   When EXISTING = true, scan these files and extract the noted information:
+
+   **Auto-discovery checklist:**
+   - `package.json` → scripts (build, test, lint, start), engines, dependencies and devDependencies for stack detection (e.g., react, express, typescript)
+   - `build.gradle` / `build.gradle.kts` → plugins (java, kotlin, spring-boot), tasks (test, check, ktlintCheck), dependencies for framework detection
+   - `pyproject.toml` → build-system, project.scripts, dependencies, optional-dependencies, tool sections (pytest, ruff, mypy, black)
+   - `Cargo.toml` → edition, dependencies, dev-dependencies, workspace members, features
+   - `go.mod` → go version, module path, require directives for framework detection (gin, echo, fiber)
+   - `pom.xml` → plugins, parent (spring-boot-starter-parent), dependencies, build configuration
+   - `Makefile` → target names (build, test, lint, check, fmt, run) and the commands they execute
+   - `README.md` → project description, setup/install instructions, usage examples for product context
+   - `.github/workflows/*.yml` → build/test/lint commands used in CI steps, language versions in matrix
+   - `.gitlab-ci.yml` → build/test/lint commands used in CI stages, image versions
+
+   From the discovered files, populate the **Quality Tools** section of AGENTS.md with the exact commands for:
+   - **Build:** (e.g., `npm run build`, `./gradlew build`, `cargo build`)
+   - **Lint:** (e.g., `npm run lint`, `./gradlew ktlintCheck`, `cargo clippy`)
+   - **Type check:** (e.g., `tsc --noEmit`, or N/A)
+   - **Test:** (e.g., `npm test`, `./gradlew test`, `cargo test`)
+   - **Smoke:** (e.g., `npm start`, `./gradlew bootRun`, or a health endpoint)
+
+   Present the discovered tech stack and quality tools to the user for confirmation before writing them.
+
+   Also:
    - Adjust interview: skip "what tech stack?" and "what are you building?"
    - Ask instead: "what change do you want to make?" and "any constraints?"
    - Check recent git commits and ask whether to follow existing commit convention
@@ -24,7 +50,22 @@ Plant the seed for a new project.
    - If Business Rules are missing, ask: "Any rules that must ALWAYS hold?"
    - Confirm with the user: "Here's what I extracted. Anything to adjust?"
 
-   **Path B — No DNA:**
+   **Path B1 — Existing project, no DNA (EXISTING = true):**
+   - Present what you discovered in Step 0 to the user:
+     "Here's what I discovered about your project:" followed by a summary of
+     the tech stack, quality tools, and any product context from README.md.
+   - Ask the user to confirm or adjust what was discovered.
+   - Then ask only gap-filling questions ONE AT A TIME (skip any already
+     answered by the discoveries):
+     - What core problem does this project solve?
+     - What business rules must ALWAYS be true?
+     - What are the current priorities? (e.g., new feature, refactor, stabilize)
+     - Any hard constraints? (performance, compliance, deployment, backwards compatibility)
+   - Generate `.organic-growth/product-dna.md` using the structured template.
+     Leave missing sections as `<!-- to be filled -->`.
+   - Fill in AGENTS.md Product section from discoveries + answers.
+
+   **Path B2 — Greenfield, no DNA (EXISTING = false):**
    - Before the interview, briefly consider what this project could be:
      what kind of system, likely domain risks, and which questions matter most.
      Do not create separate brainstorming artifacts.
@@ -49,7 +90,13 @@ Plant the seed for a new project.
 3. Check if AGENTS.md already has a filled Product section.
    If yes, ask: "Product context already exists. Overwrite or update?"
 
-4. Generate `.organic-growth/growth/project-bootstrap.md` — the first growth plan:
+4. **Growth plan generation (greenfield only).**
+
+   If EXISTING = true → **skip this step entirely.** Do NOT generate
+   `project-bootstrap.md`. Existing projects do not need bootstrap stages —
+   the user will run `/grow` to plan their first feature against the existing codebase.
+
+   If EXISTING = false → generate `.organic-growth/growth/project-bootstrap.md` — the first growth plan:
    - Stage 1: Initialize project (build tool, dependencies, empty build passes)
    - Stage 2: Hello World endpoint/page (proves stack works end-to-end)
    - Stage 3: First domain concept with hardcoded data
@@ -57,7 +104,12 @@ Plant the seed for a new project.
    - Stage 5: First real behavior with real data
    - Include `Capabilities:` tags in the plan header
 
-5. If the project has 4+ distinct capabilities (from DNA/interview),
+5. **Growth map generation (greenfield only).**
+
+   If EXISTING = true → **skip this step entirely.** Do NOT generate
+   `growth-map.md`. There is no bootstrap plan to map.
+
+   If EXISTING = false → if the project has 4+ distinct capabilities (from DNA/interview),
    generate `.organic-growth/growth-map.md` draft:
    - Organize sequence into Walking Skeleton and what follows
    - Add short "Why This Order"
@@ -65,6 +117,12 @@ Plant the seed for a new project.
    - Present as aspirational, not a commitment
 
 6. Present a summary of what was created:
+
+   If EXISTING = true:
+   - Product DNA (`.organic-growth/product-dna.md`)
+   - AGENTS.md Product/Tech Stack/Priorities sections
+
+   If EXISTING = false:
    - Product DNA (`.organic-growth/product-dna.md`)
    - AGENTS.md Product/Tech Stack/Priorities sections
    - Growth plan (`.organic-growth/growth/project-bootstrap.md`)
@@ -79,7 +137,14 @@ Plant the seed for a new project.
    - Do NOT create src/, lib/, app/, or any implementation directories.
    - Do NOT commit anything beyond the seed files created above.
 
-   The ONLY files you create are:
+   If EXISTING = true, the ONLY files you create are:
+   - `.organic-growth/product-dna.md`
+   - `AGENTS.md` (fill in Product/Tech Stack/Priorities sections)
+
+   Say exactly:
+   "Seed planted. Run `/grow` when you're ready to plan your first feature."
+
+   If EXISTING = false, the ONLY files you create are:
    - `.organic-growth/product-dna.md`
    - `.organic-growth/growth/project-bootstrap.md`
    - `.organic-growth/growth-map.md` (if applicable)