create-sdd-project 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FiveGuays
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,204 @@
+# SDD DevFlow
+
+**Spec-Driven Development workflow template for AI-assisted coding.**
+
+A development methodology designed for Claude Code and Gemini that combines specialized AI agents, workflow orchestration with human checkpoints, and institutional memory. Built for creating robust, maintainable, and scalable TypeScript projects.
+
+## What is SDD?
+
+SDD DevFlow combines three proven practices:
+
+1. **Spec-Driven Development** — Write specifications before code. Specs are the contract between planning and implementation.
+2. **Test-Driven Development** — Red-Green-Refactor cycle for every feature. Tests define expected behavior before implementation.
+3. **Human-in-the-Loop** — Strategic checkpoints (spec, ticket, plan, commit, merge) with configurable autonomy levels that reduce human intervention as trust increases.
+
+## What's Inside
+
+### 9 Specialized Agents
+
+| Agent | Role | Step |
+|-------|------|------|
+| `spec-creator` | Draft/update specifications | 0 |
+| `backend-planner` / `frontend-planner` | Create implementation plans | 2 |
+| `backend-developer` / `frontend-developer` | TDD implementation | 3 |
+| `production-code-validator` | Pre-commit quality scan | 4 |
+| `code-review-specialist` | Pre-merge code review | 5 |
+| `qa-engineer` | Edge cases, spec verification | 5 |
+| `database-architect` | Schema design, optimization | Any |
+
+### Workflow (Steps 0–6)
+
+```
+0. SPEC      → spec-creator drafts specs        → Spec Approval (Std/Cplx)
+1. SETUP     → Branch, ticket, sprint tracker    → Ticket Approval (Std/Cplx)
+2. PLAN      → Planner creates implementation plan → Plan Approval (Std/Cplx)
+3. IMPLEMENT → Developer agent, TDD
+4. FINALIZE  → Tests/lint/build, validator       → Commit Approval
+5. REVIEW    → PR, code review, QA              → Merge Approval
+6. COMPLETE  → Clean up, update tracker
+```
+
+**Step flow by complexity:**
+- **Simple**: 1 → 3 → 4 → 5 → 6
+- **Standard**: 0 → 1 → 2 → 3 → 4 → 5 (+QA) → 6
+- **Complex**: 0 → 1 (+ADR) → 2 → 3 → 4 → 5 (+QA) → 6
+
+### 3 Complexity Tiers
+
+| Tier | Spec | Ticket | Plan | QA |
+|------|:----:|:------:|:----:|:--:|
+| Simple | Skip | Skip | Skip | Skip |
+| Standard | Yes | Yes | Yes | Yes |
+| Complex | Yes | Yes + ADR | Yes | Yes |
+
+### 4 Autonomy Levels
+
+Control how many human approval checkpoints are active:
+
+| Level | Name | Human Checkpoints | Best For |
+|-------|------|-------------------|----------|
+| L1 | Full Control | All 5 | First sprint, learning SDD |
+| L2 | Trusted | Plan + Merge | Normal development **(default)** |
+| L3 | Autopilot | Merge only | Well-defined, repetitive tasks |
+| L4 | Full Auto | None (CI/CD gates only) | Bulk simple tasks |
+
+Quality gates (tests, lint, build, validators) **always run** regardless of level.
+
+### Branching Strategy
+
+Configurable per-project in `key_facts.md`:
+
+- **GitHub Flow** (default): `main` + `feature/*` + `hotfix/*`. Best for MVPs.
+- **GitFlow** (scaled): `main` + `develop` + `feature/*` + `release/*` + `hotfix/*`. For larger projects.
+
+### Project Memory
+
+Tracks institutional knowledge across sessions in `docs/project_notes/`:
+
+- **sprint-X-tracker.md** — Sprint progress + Active Session (context recovery after compaction)
+- **bugs.md** — Bug log with solutions and prevention notes
+- **decisions.md** — Architectural Decision Records (ADRs)
+- **key_facts.md** — Project configuration, ports, URLs, branching strategy
+
+### Automated Hooks (Claude Code)
+
+- **Quick Scan** — After developer agents finish, a fast grep-based scan (~2s, no API calls) checks for debug code, secrets, and TODOs. Critical issues block; warnings pass through.
+- **Compaction Recovery** — After context compaction, injects a reminder to read the sprint tracker for context recovery.
+- **Notifications** — Personal notification hooks (macOS/Linux) in `.claude/settings.local.json`.
+
+### Multi-Tool Support
+
+- **Claude Code**: Full support with agents, skills, hooks, and settings (`.claude/`)
+- **Gemini**: Adapted agent format (`.gemini/`), same methodology via `ai-specs/specs/`
+- **Other tools**: `AGENTS.md` provides universal instructions readable by 21+ AI coding tools
+
+## Quick Start
+
+### 1. Copy the template
+
+```bash
+cp -r template/ /path/to/your-project/
+```
+
+### 2. Configure for your project
+
+Look for `<!-- CONFIG: ... -->` comments in these files:
+
+| File | What to configure |
+|------|-------------------|
+| `CLAUDE.md` / `GEMINI.md` | Autonomy level (1-4) |
+| `ai-specs/specs/backend-standards.mdc` | Backend tech stack |
+| `ai-specs/specs/frontend-standards.mdc` | Frontend tech stack |
+| `docs/project_notes/key_facts.md` | Project name, ports, URLs, branching strategy |
+| `docs/specs/api-spec.yaml` | Server URLs |
+| `AGENTS.md` | Monorepo layout |
+
+### 3. Initialize and start
+
+```
+init sprint 0
+start task B0.1
+```
+
+The workflow skill will guide you through each step with checkpoints based on your autonomy level.
+
+## Template Structure
+
+```
+project/
+├── AGENTS.md                            # Universal AI instructions (all tools)
+├── CLAUDE.md                            # Claude Code config (autonomy, recovery)
+├── GEMINI.md                            # Gemini config (autonomy)
+├── .env.example                         # Environment variables template
+├── .gitignore                           # Git ignore with secrets protection
+│
+├── .claude/
+│   ├── agents/                          # 9 specialized agents
+│   ├── skills/
+│   │   ├── development-workflow/        # Main task workflow (Steps 0-6)
+│   │   │   └── references/              # Templates, guides, examples
+│   │   ├── bug-workflow/                # Bug triage and resolution
+│   │   └── project-memory/              # Memory system setup
+│   ├── hooks/quick-scan.sh              # Post-developer quality scan
+│   ├── settings.json                    # Shared hooks (git-tracked)
+│   └── settings.local.json              # Personal hooks (gitignored)
+│
+├── .gemini/
+│   ├── agents/                          # 9 agents (Gemini format)
+│   ├── settings.json                    # Gemini configuration
+│   └── styles/default.md               # Response style
+│
+├── ai-specs/specs/
+│   ├── base-standards.mdc              # Constitution + methodology
+│   ├── backend-standards.mdc           # Backend patterns (DDD, Express, Prisma)
+│   ├── frontend-standards.mdc          # Frontend patterns (Next.js, Tailwind, Radix)
+│   └── documentation-standards.mdc     # Documentation update rules
+│
+└── docs/
+    ├── project_notes/                   # Project memory
+    │   ├── sprint-0-tracker.md          # Sprint tracker template
+    │   ├── key_facts.md                 # Project configuration
+    │   ├── bugs.md                      # Bug log
+    │   └── decisions.md                 # ADRs
+    ├── specs/
+    │   ├── api-spec.yaml                # OpenAPI spec (backend)
+    │   └── ui-components.md             # Component spec (frontend)
+    └── tickets/                         # Task tickets (generated by workflow)
+```
+
+## Default Tech Stack
+
+The template defaults to (configurable via `<!-- CONFIG -->` comments):
+
+- **Backend**: Node.js + Express + Prisma + PostgreSQL
+- **Frontend**: Next.js (App Router) + Tailwind CSS + Radix UI + Zustand
+- **Shared Types**: Zod schemas in `shared/` workspace → `z.infer<>` for TypeScript types
+- **Testing**: Jest (unit) + Playwright (e2e)
+- **Methodology**: TDD + DDD + Spec-Driven Development
+
+## Constitution (Immutable Principles)
+
+These 6 principles apply to ALL tasks, ALL agents, ALL complexity levels:
+
+1. **Spec First** — No implementation without an approved specification
+2. **Small Tasks** — Work in baby steps, one at a time
+3. **Test-Driven Development** — Write tests before implementation
+4. **Type Safety** — Strict TypeScript, no `any`, runtime validation with Zod
+5. **English Only** — All code, comments, docs, commits, and tickets in English
+6. **Reuse Over Recreate** — Always check existing code before proposing new files
+
+## Prerequisites
+
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code) and/or [Gemini](https://gemini.google.com/)
+- Node.js 18+
+- `jq` (for quick-scan hook): `brew install jq` (macOS) or `apt install jq` (Linux)
+
+## Roadmap
+
+- **Agent Teams**: Parallel execution of independent tasks (waiting for Claude Code Agent Teams to stabilize)
+- **PM Agent + L5 Autonomous**: AI-driven sprint orchestration with human review at sprint boundaries
+- **Setup Script + npx**: Interactive installer (`npx create-sdd-project`) for automated setup
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const { runWizard, buildDefaultConfig } = require('../lib/wizard');
+const { generate } = require('../lib/generator');
+
+const args = process.argv.slice(2);
+const projectName = args.find((a) => !a.startsWith('-'));
+const useDefaults = args.includes('--yes') || args.includes('-y');
+
+async function main() {
+  let config;
+
+  if (useDefaults) {
+    if (!projectName) {
+      console.error('Error: Project name required with --yes flag.');
+      console.error('Usage: create-sdd-project <project-name> --yes');
+      process.exit(1);
+    }
+    config = buildDefaultConfig(projectName);
+    console.log(`\nCreating SDD DevFlow project with defaults in ./${projectName}...\n`);
+  } else {
+    config = await runWizard(projectName);
+    console.log(`\nCreating SDD DevFlow project in ${config.projectDir}...\n`);
+  }
+
+  // Check if destination already exists
+  if (fs.existsSync(config.projectDir)) {
+    const entries = fs.readdirSync(config.projectDir);
+    if (entries.length > 0) {
+      console.error(`Error: Directory ${config.projectDir} is not empty.`);
+      console.error('Please choose a different directory or remove existing files.');
+      process.exit(1);
+    }
+  }
+
+  generate(config);
+}
+
+main().catch((err) => {
+  console.error('\nError:', err.message);
+  process.exit(1);
+});

package/lib/config.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const DEFAULTS = {
+  projectName: '',
+  projectDir: '',
+  description: '',
+  businessContext: '',
+  projectType: 'fullstack', // 'fullstack' | 'backend' | 'frontend'
+  backendStack: 'express-prisma-pg',
+  frontendStack: 'nextjs-tailwind-radix',
+  aiTools: 'both', // 'both' | 'claude' | 'gemini'
+  autonomyLevel: 2,
+  branching: 'github-flow',
+  backendPort: 3010,
+  frontendPort: 3000,
+  dbPort: 5432,
+};
+
+const PROJECT_TYPES = [
+  { key: 'fullstack', label: 'Backend + Frontend (monorepo)', default: true },
+  { key: 'backend', label: 'Backend only' },
+  { key: 'frontend', label: 'Frontend only' },
+];
+
+const BACKEND_STACKS = [
+  {
+    key: 'express-prisma-pg',
+    label: 'Node.js + Express + Prisma + PostgreSQL',
+    default: true,
+    db: 'PostgreSQL',
+    orm: 'Prisma',
+    framework: 'Express',
+    runtime: 'Node.js',
+    dbPort: 5432,
+    databaseUrl: 'postgresql://user:password@localhost:5432/dbname',
+    needsStandardsUpdate: false,
+  },
+  {
+    key: 'express-mongo-mongoose',
+    label: 'Node.js + Express + MongoDB + Mongoose',
+    db: 'MongoDB',
+    orm: 'Mongoose',
+    framework: 'Express',
+    runtime: 'Node.js',
+    dbPort: 27017,
+    databaseUrl: 'mongodb://localhost:27017/dbname',
+    needsStandardsUpdate: true,
+  },
+  {
+    key: 'custom',
+    label: 'Custom (enter your own)',
+    needsStandardsUpdate: true,
+  },
+];
+
+const FRONTEND_STACKS = [
+  {
+    key: 'nextjs-tailwind-radix',
+    label: 'Next.js + Tailwind CSS + Radix UI + Zustand',
+    default: true,
+    framework: 'Next.js (App Router)',
+    styling: 'Tailwind CSS',
+    components: 'Radix UI',
+    state: 'Zustand',
+    needsStandardsUpdate: false,
+  },
+  {
+    key: 'custom',
+    label: 'Custom (enter your own)',
+    needsStandardsUpdate: true,
+  },
+];
+
+const AI_TOOLS = [
+  { key: 'both', label: 'Claude Code + Gemini', default: true },
+  { key: 'claude', label: 'Claude Code only' },
+  { key: 'gemini', label: 'Gemini only' },
+];
+
+const AUTONOMY_LEVELS = [
+  { level: 1, name: 'Full Control', desc: 'Human approves every checkpoint (first sprint, learning SDD)' },
+  { level: 2, name: 'Trusted', desc: 'Human reviews plans + merges only (default, normal development)', default: true },
+  { level: 3, name: 'Autopilot', desc: 'Human only approves merges (well-defined, repetitive tasks)' },
+  { level: 4, name: 'Full Auto', desc: 'No human checkpoints, CI/CD gates only (bulk simple tasks)' },
+];
+
+const BRANCHING_STRATEGIES = [
+  { key: 'github-flow', label: 'GitHub Flow', desc: 'main + feature branches (recommended for MVPs)', default: true },
+  { key: 'gitflow', label: 'GitFlow', desc: 'main + develop + feature/release/hotfix branches (larger projects)' },
+];
+
+// Agent files categorized by scope
+const FRONTEND_AGENTS = ['frontend-developer.md', 'frontend-planner.md'];
+const BACKEND_AGENTS = ['backend-developer.md', 'backend-planner.md', 'database-architect.md'];
+
+module.exports = {
+  DEFAULTS,
+  PROJECT_TYPES,
+  BACKEND_STACKS,
+  FRONTEND_STACKS,
+  AI_TOOLS,
+  AUTONOMY_LEVELS,
+  BRANCHING_STRATEGIES,
+  FRONTEND_AGENTS,
+  BACKEND_AGENTS,
+};

package/lib/generator.js

@@ -0,0 +1,313 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const {
+  BACKEND_STACKS,
+  FRONTEND_STACKS,
+  AUTONOMY_LEVELS,
+  FRONTEND_AGENTS,
+  BACKEND_AGENTS,
+} = require('./config');
+
+function generate(config) {
+  const templateDir = path.join(__dirname, '..', 'template');
+  const dest = config.projectDir;
+
+  // 1. Copy entire template
+  step('Copying template files');
+  fs.cpSync(templateDir, dest, { recursive: true });
+
+  // 2. Configure key_facts.md
+  step(`Configuring project: ${config.projectName}`);
+  updateKeyFacts(dest, config);
+
+  // 3. Update tech stack references
+  if (config.projectType !== 'frontend') {
+    const bPreset = config.backendPreset || BACKEND_STACKS[0];
+    step(`Setting backend: ${bPreset.label || config.customBackend || 'Custom'}`);
+    updateBackendConfig(dest, config);
+  }
+  if (config.projectType !== 'backend') {
+    const fPreset = config.frontendPreset || FRONTEND_STACKS[0];
+    step(`Setting frontend: ${fPreset.label || config.customFrontend || 'Custom'}`);
+  }
+
+  // 4. Set autonomy level
+  step(`Setting autonomy level: L${config.autonomyLevel} (${config.autonomyName})`);
+  updateAutonomy(dest, config);
+
+  // 5. Set branching strategy
+  step(`Setting branching: ${config.branching}`);
+  updateBranching(dest, config);
+
+  // 6. Set sprint dates
+  step('Setting sprint dates to today');
+  updateSprintDates(dest);
+
+  // 7. Remove agents/specs based on project type
+  if (config.projectType === 'backend') {
+    step('Removing frontend agents (backend only)');
+    removeFrontendFiles(dest, config);
+  } else if (config.projectType === 'frontend') {
+    step('Removing backend agents (frontend only)');
+    removeBackendFiles(dest, config);
+  }
+
+  // 8. Remove AI tool config if single tool selected
+  if (config.aiTools === 'claude') {
+    step('Removing Gemini config (Claude only)');
+    fs.rmSync(path.join(dest, '.gemini'), { recursive: true, force: true });
+    safeDelete(path.join(dest, 'GEMINI.md'));
+  } else if (config.aiTools === 'gemini') {
+    step('Removing Claude config (Gemini only)');
+    fs.rmSync(path.join(dest, '.claude'), { recursive: true, force: true });
+    safeDelete(path.join(dest, 'CLAUDE.md'));
+  }
+
+  // Show notes
+  const notes = collectNotes(config);
+  if (notes.length > 0) {
+    console.log('');
+    notes.forEach((n) => console.log(`  📝 ${n}`));
+  }
+
+  // Done
+  console.log(`\nDone! Next steps:`);
+  console.log(`  cd ${path.relative(process.cwd(), dest)}`);
+  console.log(`  git init && git add -A && git commit -m "chore: initialize SDD DevFlow project"`);
+  console.log(`  # Open in your AI coding tool and run: init sprint 0\n`);
+}
+
+// --- Helpers ---
+
+function step(msg) {
+  console.log(`  ✓ ${msg}`);
+}
+
+function safeDelete(filePath) {
+  try {
+    fs.unlinkSync(filePath);
+  } catch {
+    // ignore if not found
+  }
+}
+
+function replaceInFile(filePath, replacements) {
+  if (!fs.existsSync(filePath)) return;
+  let content = fs.readFileSync(filePath, 'utf8');
+  for (const [search, replace] of replacements) {
+    if (search instanceof RegExp) {
+      content = content.replace(search, replace);
+    } else {
+      content = content.split(search).join(replace);
+    }
+  }
+  fs.writeFileSync(filePath, content, 'utf8');
+}
+
+function updateKeyFacts(dest, config) {
+  const file = path.join(dest, 'docs', 'project_notes', 'key_facts.md');
+  const bPreset = config.backendPreset || BACKEND_STACKS[0];
+  const fPreset = config.frontendPreset || FRONTEND_STACKS[0];
+
+  const replacements = [
+    ['[Your project name]', config.projectName],
+  ];
+
+  // Branching
+  // The template has: github-flow <!-- Options: ... -->
+  replacements.push([
+    /github-flow <!-- Options:.*?-->/,
+    `${config.branching} <!-- Options: github-flow | gitflow — See .claude/skills/development-workflow/references/branching-strategy.md -->`,
+  ]);
+
+  // Technology Stack
+  if (config.projectType !== 'frontend' && bPreset.key !== 'custom') {
+    replacements.push(['[Framework, runtime, version]', `${bPreset.framework}, ${bPreset.runtime}`]);
+    replacements.push(['[Type, host, port]', `${bPreset.db}, localhost, ${bPreset.dbPort}`]);
+    replacements.push(['[Name, version]', bPreset.orm]);
+  } else if (config.projectType !== 'frontend' && config.customBackend) {
+    replacements.push(['[Framework, runtime, version]', config.customBackend]);
+  }
+
+  if (config.projectType !== 'backend' && fPreset.key !== 'custom') {
+    replacements.push(['[Framework, version]', `${fPreset.framework}, ${fPreset.styling}, ${fPreset.components}, ${fPreset.state}`]);
+  } else if (config.projectType !== 'backend' && config.customFrontend) {
+    replacements.push(['[Framework, version]', config.customFrontend]);
+  }
+
+  // Ports
+  if (config.projectType !== 'frontend') {
+    replacements.push(['[e.g., 3010]', String(config.backendPort)]);
+    replacements.push(['[e.g., 5432]', bPreset.key !== 'custom' ? String(bPreset.dbPort) : '[e.g., 5432]']);
+    replacements.push(['[e.g., http://localhost:3010/api]', `http://localhost:${config.backendPort}/api`]);
+  }
+  if (config.projectType !== 'backend') {
+    replacements.push(['[e.g., 3000]', String(config.frontendPort || 3000)]);
+  }
+
+  replaceInFile(file, replacements);
+
+  // Add business context section if provided
+  if (config.businessContext) {
+    let content = fs.readFileSync(file, 'utf8');
+    const contextSection = `\n## Project Information\n\n${config.businessContext}\n`;
+    // Insert before ## Technology Stack
+    content = content.replace('## Technology Stack', `${contextSection}\n## Technology Stack`);
+    // Add description if provided
+    if (config.description) {
+      content = content.replace(
+        `- **Project Name**: ${config.projectName}`,
+        `- **Project Name**: ${config.projectName}\n- **Description**: ${config.description}`
+      );
+    }
+    fs.writeFileSync(file, content, 'utf8');
+  } else if (config.description) {
+    replaceInFile(file, [
+      [`- **Project Name**: ${config.projectName}`, `- **Project Name**: ${config.projectName}\n- **Description**: ${config.description}`],
+    ]);
+  }
+}
+
+function updateBackendConfig(dest, config) {
+  const bPreset = config.backendPreset || BACKEND_STACKS[0];
+
+  // .env.example
+  const envFile = path.join(dest, '.env.example');
+  const replacements = [];
+
+  if (config.backendPort !== 3010) {
+    replacements.push(['PORT=3010', `PORT=${config.backendPort}`]);
+    replacements.push([
+      'NEXT_PUBLIC_API_URL=http://localhost:3010/api',
+      `NEXT_PUBLIC_API_URL=http://localhost:${config.backendPort}/api`,
+    ]);
+  }
+
+  if (bPreset.databaseUrl) {
+    replacements.push([
+      'DATABASE_URL=postgresql://user:password@localhost:5432/dbname',
+      `DATABASE_URL=${bPreset.databaseUrl}`,
+    ]);
+  }
+
+  if (replacements.length > 0) {
+    replaceInFile(envFile, replacements);
+  }
+
+  // api-spec.yaml
+  const apiSpec = path.join(dest, 'docs', 'specs', 'api-spec.yaml');
+  const apiReplacements = [
+    ['title: Project API', `title: ${config.projectName} API`],
+  ];
+  if (config.backendPort !== 3010) {
+    apiReplacements.push([
+      'http://localhost:3010/api',
+      `http://localhost:${config.backendPort}/api`,
+    ]);
+  }
+  replaceInFile(apiSpec, apiReplacements);
+}
+
+function updateAutonomy(dest, config) {
+  const levelInfo = AUTONOMY_LEVELS.find((l) => l.level === config.autonomyLevel);
+  const newLine = `**Autonomy Level: ${config.autonomyLevel} (${levelInfo.name})**`;
+
+  // CLAUDE.md
+  replaceInFile(path.join(dest, 'CLAUDE.md'), [
+    [/\*\*Autonomy Level: \d+ \([^)]+\)\*\*/, newLine],
+  ]);
+
+  // GEMINI.md
+  replaceInFile(path.join(dest, 'GEMINI.md'), [
+    [/\*\*Autonomy Level: \d+ \([^)]+\)\*\*/, newLine],
+  ]);
+}
+
+function updateBranching(dest, config) {
+  // key_facts.md is already handled in updateKeyFacts
+  // Nothing else to update — branching is read from key_facts.md at runtime
+}
+
+function updateSprintDates(dest) {
+  const file = path.join(dest, 'docs', 'project_notes', 'sprint-0-tracker.md');
+  const today = new Date().toISOString().split('T')[0];
+  // Calculate 2-week sprint end
+  const endDate = new Date();
+  endDate.setDate(endDate.getDate() + 14);
+  const end = endDate.toISOString().split('T')[0];
+
+  replaceInFile(file, [
+    [/\[YYYY-MM-DD\] to \[YYYY-MM-DD\]/, `${today} to ${end}`],
+  ]);
+}
+
+function removeFrontendFiles(dest, config) {
+  // Remove frontend agents
+  for (const agent of FRONTEND_AGENTS) {
+    safeDelete(path.join(dest, '.claude', 'agents', agent));
+    safeDelete(path.join(dest, '.gemini', 'agents', agent));
+  }
+  // Remove frontend spec
+  safeDelete(path.join(dest, 'docs', 'specs', 'ui-components.md'));
+
+  // Remove frontend from .env.example
+  replaceInFile(path.join(dest, '.env.example'), [
+    [/\n# Frontend\nNEXT_PUBLIC_API_URL=.*\n/, '\n'],
+  ]);
+
+  // Remove frontend from AGENTS.md project structure
+  replaceInFile(path.join(dest, 'AGENTS.md'), [
+    ['├── frontend/    ← Frontend (has its own package.json)\n', ''],
+  ]);
+
+  // Remove frontend tasks from sprint tracker
+  const trackerFile = path.join(dest, 'docs', 'project_notes', 'sprint-0-tracker.md');
+  replaceInFile(trackerFile, [
+    [/\n### Frontend\n\n\|.*\n\|.*\n\|.*\n/, '\n'],
+  ]);
+}
+
+function removeBackendFiles(dest, config) {
+  // Remove backend agents + database-architect
+  for (const agent of BACKEND_AGENTS) {
+    safeDelete(path.join(dest, '.claude', 'agents', agent));
+    safeDelete(path.join(dest, '.gemini', 'agents', agent));
+  }
+  // Remove backend spec
+  safeDelete(path.join(dest, 'docs', 'specs', 'api-spec.yaml'));
+
+  // Remove backend from .env.example
+  replaceInFile(path.join(dest, '.env.example'), [
+    [/# Backend\nNODE_ENV=.*\nPORT=.*\nDATABASE_URL=.*\n\n/, ''],
+  ]);
+
+  // Remove backend from AGENTS.md project structure
+  replaceInFile(path.join(dest, 'AGENTS.md'), [
+    ['├── backend/     ← Backend (has its own package.json)\n', ''],
+  ]);
+
+  // Remove backend tasks from sprint tracker
+  const trackerFile = path.join(dest, 'docs', 'project_notes', 'sprint-0-tracker.md');
+  replaceInFile(trackerFile, [
+    [/\n### Backend\n\n\|.*\n\|.*\n\|.*\n/, '\n'],
+  ]);
+}
+
+function collectNotes(config) {
+  const notes = [];
+  const bPreset = config.backendPreset;
+  const fPreset = config.frontendPreset;
+
+  if (bPreset && bPreset.needsStandardsUpdate) {
+    notes.push('Update ai-specs/specs/backend-standards.mdc with your backend stack patterns.');
+  }
+  if (fPreset && fPreset.needsStandardsUpdate) {
+    notes.push('Update ai-specs/specs/frontend-standards.mdc with your frontend stack patterns.');
+  }
+
+  return notes;
+}
+
+module.exports = { generate };