@accelerationguy/accel 1.0.0

package/modules/forge/terminal.svg

@@ -0,0 +1,70 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 740 480" width="740" height="480">
+  <!-- Window shadow -->
+  <rect x="4" y="8" width="736" height="472" rx="12" fill="rgba(0,0,0,0.4)"/>
+
+  <!-- Window background -->
+  <rect width="736" height="472" rx="12" fill="#13131f"/>
+
+  <!-- Title bar -->
+  <rect width="736" height="40" rx="12" fill="#1e1e30"/>
+  <rect y="28" width="736" height="12" fill="#1e1e30"/>
+
+  <!-- Traffic lights -->
+  <circle cx="24" cy="20" r="7" fill="#ff5f57"/>
+  <circle cx="48" cy="20" r="7" fill="#febc2e"/>
+  <circle cx="72" cy="20" r="7" fill="#28c840"/>
+
+  <!-- Terminal label -->
+  <text x="368" y="25" text-anchor="middle" font-family="'SF Mono','Fira Code','Courier New',monospace" font-size="12" fill="#4a4a6a">Terminal</text>
+
+  <!-- Prompt line -->
+  <text x="24" y="68" font-family="'SF Mono','Fira Code','Courier New',monospace" font-size="13">
+    <tspan fill="#4a4a6a">~ $ </tspan><tspan fill="#c0c0d8">/forge</tspan>
+  </text>
+
+  <!-- Forge logo - cyan -->
+  <text x="24" y="96"  fill="#67d4f0" font-family="'SF Mono','Fira Code','Courier New',monospace" font-size="11" xml:space="preserve"> ███████╗██╗  ██╗██╗██╗     ██╗     ███████╗███╗   ███╗██╗████████╗██╗  ██╗</text>
+  <text x="24" y="111" fill="#67d4f0" font-family="'SF Mono','Fira Code','Courier New',monospace" font-size="11" xml:space="preserve"> ██╔════╝██║ ██╔╝██║██║     ██║     ██╔════╝████╗ ████║██║╚══██╔══╝██║  ██║</text>
+  <text x="24" y="126" fill="#4dc4e0" font-family="'SF Mono','Fira Code','Courier New',monospace" font-size="11" xml:space="preserve"> ███████╗█████╔╝ ██║██║     ██║     ███████╗██╔████╔██║██║   ██║   ███████║</text>
+  <text x="24" y="141" fill="#4dc4e0" font-family="'SF Mono','Fira Code','Courier New',monospace" font-size="11" xml:space="preserve"> ╚════██║██╔═██╗ ██║██║     ██║     ╚════██║██║╚██╔╝██║██║   ██║   ██╔══██║</text>
+  <text x="24" y="156" fill="#36b0cc" font-family="'SF Mono','Fira Code','Courier New',monospace" font-size="11" xml:space="preserve"> ███████║██║  ██╗██║███████╗███████╗███████║██║ ╚═╝ ██║██║   ██║   ██║  ██║</text>
+  <text x="24" y="171" fill="#36b0cc" font-family="'SF Mono','Fira Code','Courier New',monospace" font-size="11" xml:space="preserve"> ╚══════╝╚═╝  ╚═╝╚═╝╚══════╝╚══════╝╚══════╝╚═╝     ╚═╝╚═╝   ╚═╝   ╚═╝  ╚═╝</text>
+
+  <!-- Name + version -->
+  <text x="24" y="197" font-family="'SF Mono','Fira Code','Courier New',monospace" font-size="13">
+    <tspan fill="#67d4f0" font-weight="bold">Forge</tspan><tspan fill="#4a4a6a"> v0.1.0</tspan>
+  </text>
+  <text x="24" y="214" fill="#7b8cde" font-family="'SF Mono','Fira Code','Courier New',monospace" font-size="13">Build consistent Claude Code skills</text>
+
+  <!-- Divider -->
+  <line x1="24" y1="228" x2="712" y2="228" stroke="#1e1e30" stroke-width="1.5"/>
+
+  <!-- Greeting -->
+  <text x="24" y="248" fill="#67d4f0" font-family="'SF Mono','Fira Code','Courier New',monospace" font-size="13">Forge loaded.</text>
+
+  <!-- Commands -->
+  <text x="24" y="273" font-family="'SF Mono','Fira Code','Courier New',monospace" font-size="13">
+    <tspan fill="#c0c0d8">  -</tspan><tspan fill="#67d4f0"> Discover</tspan>
+    <tspan fill="#4a4a6a">  — Guided interview to design a new skill</tspan>
+  </text>
+  <text x="24" y="290" font-family="'SF Mono','Fira Code','Courier New',monospace" font-size="13">
+    <tspan fill="#c0c0d8">  -</tspan><tspan fill="#67d4f0"> Scaffold</tspan>
+    <tspan fill="#4a4a6a">  — Generate compliant directory from spec</tspan>
+  </text>
+  <text x="24" y="307" font-family="'SF Mono','Fira Code','Courier New',monospace" font-size="13">
+    <tspan fill="#c0c0d8">  -</tspan><tspan fill="#67d4f0"> Distill</tspan>
+    <tspan fill="#4a4a6a">   — Transform source material into chunks</tspan>
+  </text>
+  <text x="24" y="324" font-family="'SF Mono','Fira Code','Courier New',monospace" font-size="13">
+    <tspan fill="#c0c0d8">  -</tspan><tspan fill="#67d4f0"> Audit</tspan>
+    <tspan fill="#4a4a6a">     — Check skill compliance against specs</tspan>
+  </text>
+
+  <!-- Prompt -->
+  <text x="24" y="358" fill="#c0c0d8" font-family="'SF Mono','Fira Code','Courier New',monospace" font-size="13">What are you building?</text>
+
+  <!-- Cursor -->
+  <text x="24" y="395" font-family="'SF Mono','Fira Code','Courier New',monospace" font-size="13">
+    <tspan fill="#4a4a6a">~ $ </tspan><tspan fill="#67d4f0">▊</tspan>
+  </text>
+</svg>

package/modules/ignition/README.md

@@ -0,0 +1,245 @@
+<div align="center">
+  <img src="terminal.svg" alt="Ignition terminal" width="740"/>
+</div>
+
+<div align="center">
+
+[![Claude Code](https://img.shields.io/badge/Claude%20Code-compatible-8b5cf6?style=flat-square)](https://claude.ai/code)
+[![License](https://img.shields.io/badge/license-MIT-blue?style=flat-square)](LICENSE)
+
+**Your AI project incubator.**<br/>
+Take raw ideas through type-aware guided exploration and produce structured plans ready for building.
+
+</div>
+
+---
+
+## Contents
+
+- [What Ignition Does](#what-ignition-does)
+- [Commands](#commands)
+- [Project Types](#project-types)
+- [How It Works](#how-it-works)
+- [Architecture](#architecture)
+- [The Drive Connection](#the-drive-connection--ideation-to-managed-build)
+- [Ecosystem](#ecosystem)
+- [Install](#install)
+
+---
+
+## Ecosystem
+
+Ignition is part of a broader Claude Code extension ecosystem:
+
+| System | What It Does | Link |
+|--------|-------------|------|
+| **Radar** | Multi-agent codebase auditing — diagnosis + controlled evolution | [GitHub](https://github.com/accelerationguy/radar) |
+| **Momentum** | Builder's Automated State Engine — workspace lifecycle, health tracking, drift prevention | [GitHub](https://github.com/accelerationguy/base) |
+| **Vector** | Context Augmentation & Reinforcement Layer — dynamic rules loaded JIT by intent | [GitHub](https://github.com/accelerationguy/vector) |
+| **Drive** | Project orchestration — Plan, Apply, Unify Loop | [GitHub](https://github.com/accelerationguy/drive) |
+| **Ignition** | Typed project incubator — guided ideation through graduation into buildable projects | You are here |
+| **Forge** | Skill builder — standardized syntax specs + guided workflows for Claude Code skills | [GitHub](https://github.com/accelerationguy/forge) |
+| **CC Strategic AI** | Skool community — courses, community, live support | [Skool](https://accelerationguy.com) |
+
+---
+
+## What Ignition Does
+
+You have an idea. Maybe it's an app, a workflow, a client site, a utility, or a content campaign. Before you start building, you need to answer the right questions — and the right questions depend on what type of project it is.
+
+Ignition is a typed project incubator for Claude Code. It guides you through collaborative exploration shaped by your project type, produces a structured PLANNING.md, and graduates mature plans into buildable project directories. If you use Drive, it can initialize a managed build from your plan without re-asking questions you already answered.
+
+**The coach, not the interrogator.** Ignition brainstorms alongside you, offers suggestions when you're stuck, and pushes toward decisions when it's time. It doesn't fire questions at you — it thinks with you.
+
+---
+
+## Commands
+
+| Command | What It Does |
+|---------|-------------|
+| `/ignition` | Start a guided ideation session (default) |
+| `/ignition graduate` | Move completed ideation to `apps/` with git repo and synthesized README |
+| `/ignition launch` | Graduate + initialize Drive for managed build (one command) |
+| `/ignition status` | Show all projects in the ideation pipeline |
+| `/ignition add-type` | Create a custom project type for Ignition's data layer |
+
+---
+
+## Project Types
+
+Ignition ships with 5 default types. Each type shapes the conversation differently:
+
+| Type | Rigor | Sections | What It's For |
+|------|-------|----------|---------------|
+| **Application** | Deep | 10 | Software with UI, data model, API, deployment |
+| **Workflow** | Standard | 8 | Claude Code commands, hooks, Vector domains, skills |
+| **Client** | Standard | 7 | Client websites — business context, conversion, content |
+| **Utility** | Tight | 6 | Small tools, scripts, single-purpose — resists expansion |
+| **Campaign** | Creative | 7 | Content, marketing, launches — timeline-driven |
+
+**Rigor adapts behavior:**
+- **Tight** — Move fast, resist scope creep, done in one session
+- **Standard** — Balanced exploration with clear boundaries
+- **Deep** — Thorough, architecture matters, don't rush
+- **Creative** — Loose and generative, but always anchored to a measurable goal
+
+Types are composable. Run `/ignition add-type` to create your own — just drop files in `data/{type}/` and it works immediately. No code changes needed.
+
+---
+
+## How It Works
+
+```
+  /ignition                          /ignition graduate              /ignition launch
+    │                                  │                          │
+    ▼                                  ▼                          ▼
+ Select type ──▶ Guided ──▶ PLANNING.md ──▶ apps/{name}/ ──▶ .drive/ init
+ (or discover)   ideation    (populated)     git + README      (headless)
+    │                │
+    ▼                ▼
+ Load data/     Coach persona
+ {type}/        adapts rigor
+```
+
+1. **Type first.** Ignition determines your project type before anything else. Type shapes everything downstream.
+2. **Guided exploration.** Conversation sections load from `data/{type}/guide.md`. Each section has prompts (what to explore) and suggestions (what to offer when you're stuck).
+3. **PLANNING.md output.** When you're ready, Ignition populates a type-specific template and writes it to `projects/{name}/`.
+4. **Graduate.** Moves the project to `apps/{name}/` with git init, a synthesized README, and workspace tracking updates.
+5. **Launch (optional).** Wraps graduation + headless Drive init. Your PLANNING.md is rich enough that Drive derives its structure without re-asking questions.
+
+---
+
+## Architecture
+
+```
+ignition/
+├── ignition.md                         Entry point (Forge-compliant)
+├── tasks/
+│   ├── ideate.md                   Type-first guided ideation
+│   ├── graduate.md                 Project graduation to apps/
+│   ├── launch.md                   Graduate + Drive init wrapper
+│   ├── status.md                   Pipeline visibility
+│   └── add-type.md                 User-extensible type system
+├── data/                           Composable per-type data
+│   ├── application/
+│   │   ├── guide.md                Conversation sections (Explore + Suggest)
+│   │   ├── config.md               Rigor, demeanor, required sections
+│   │   └── skill-loadout.md        Ecosystem tool recommendations
+│   ├── workflow/                   Same structure
+│   ├── client/                     Same structure
+│   ├── utility/                    Same structure
+│   └── campaign/                   Same structure
+├── templates/
+│   ├── planning-application.md     PLANNING.md output template
+│   ├── planning-workflow.md
+│   ├── planning-client.md
+│   ├── planning-utility.md
+│   └── planning-campaign.md
+├── checklists/
+│   └── planning-quality.md         Quality gate for graduation
+├── terminal.svg                    Hero image
+└── README.md                       You are here
+```
+
+**The key design decision:** Type-specific content lives in `data/{type}/` files, not hardcoded in task files. This means:
+- Adding a new type = dropping 3 files in a new `data/` directory
+- No task file modifications needed
+- The ideate task loads type content dynamically after selection
+
+---
+
+## The Drive Connection — Ideation to Managed Build
+
+This is where Ignition pays off. The entire ideation flow is designed so that the PLANNING.md it produces contains everything [Drive](https://github.com/accelerationguy/drive) needs to set up a structured build — milestones, phases, tech stack, architecture decisions, phase breakdowns — without asking you anything twice.
+
+### The Problem
+
+Starting a Drive project from scratch means answering a series of setup questions: What's the project? What's the stack? What are the milestones? What are the phases? If you've already thought through all of this during ideation, repeating it during project setup is friction that kills momentum.
+
+### How Ignition Solves It
+
+`/ignition launch` runs the full graduation flow and then initializes Drive with **headless context**:
+
+1. Ignition produces a rich PLANNING.md during ideation (type-aware, quality-gated)
+2. `/ignition launch` graduates the project to `apps/{name}/` with git
+3. Drive reads the PLANNING.md and derives its entire project structure from it
+4. Drive proposes milestones, phases, and tech stack — you review and approve
+5. You're immediately ready to run `/drive:plan` for Phase 1
+
+**No re-asking.** Drive doesn't ask "What's this project?" or "What's the tech stack?" — those answers are already in the PLANNING.md that Ignition produced. The only interaction is approving the proposed structure.
+
+### What Makes the PLANNING.md Drive-Ready
+
+Ignition's quality gate (`checklists/planning-quality.md`) specifically checks for Drive-readiness:
+
+- Phase breakdown with independently shippable milestones
+- Each phase has build/test/outcome defined
+- Tech stack decisions resolved (not "TBD")
+- Design decisions documented with rationale
+- Enough detail that Drive can derive structure without questions
+
+### Without Drive
+
+Don't use Drive? `/ignition graduate` works standalone — you get a clean `apps/{name}/` directory with git and a synthesized README. Build however you want. Drive is additive, not required.
+
+---
+
+## Ecosystem
+
+Ignition works standalone but integrates with the broader toolkit:
+
+| Tool | How Ignition Uses It |
+|------|-----------------|
+| **Drive** | `/ignition launch` initializes Drive with headless context from PLANNING.md — zero-friction handoff from ideation to managed build |
+| **Momentum** | Graduate updates ACTIVE.md for workspace-level project tracking |
+| **Forge** | Ignition was built with Forge — compliant entry point + tasks |
+| **Radar** | Recommended post-build audit for application-type projects |
+
+All integrations are additive. Ignition works without any of them installed.
+
+---
+
+## Install
+
+```bash
+npm i -g @accel/ignition
+```
+
+One command. Installs the skill to `~/.claude/commands/ignition/` — available in every workspace.
+
+```bash
+# Global install (default) — available everywhere
+npm i -g @accel/ignition
+
+# Install to current project only
+npm i -g @accel/ignition -- --local
+
+# Custom Claude config directory
+npm i -g @accel/ignition -- --config-dir /path/to/.claude
+```
+
+Then open Claude Code and type `/ignition` to start.
+
+### What Gets Installed
+
+```
+~/.claude/commands/ignition/
+├── ignition.md              Entry point (routing + persona)
+├── tasks/               5 task files
+├── data/                15 type-specific data files (5 types × 3 files)
+├── templates/           5 PLANNING.md output templates
+└── checklists/          Planning quality gate
+```
+
+No hooks, no MCP servers, no workspace data. Ignition is pure markdown — zero runtime dependencies.
+
+### Requirements
+
+- [Claude Code](https://claude.ai/code)
+- Node.js >= 16 (for install script only — Ignition itself has no runtime deps)
+
+---
+
+## License
+
+MIT — [Acceleration Guy](https://github.com/accelerationguy)

package/modules/ignition/bin/install.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Colors
+const green = '\x1b[32m';
+const cyan = '\x1b[36m';
+const yellow = '\x1b[33m';
+const dim = '\x1b[2m';
+const reset = '\x1b[0m';
+
+// Get version from package.json
+const pkg = require('../package.json');
+
+const banner = `
+${green}  ███████╗███████╗███████╗██████╗
+  ██╔════╝██╔════╝██╔════╝██╔══██╗
+  ███████╗█████╗  █████╗  ██║  ██║
+  ╚════██║██╔══╝  ██╔══╝  ██║  ██║
+  ███████║███████╗███████╗██████╔╝
+  ╚══════╝╚══════╝╚══════╝╚═════╝${reset}
+
+  Ignition ${dim}v${pkg.version}${reset}
+  Structured Evaluation & Engineering Design
+`;
+
+// Parse args
+const args = process.argv.slice(2);
+const hasHelp = args.includes('--help') || args.includes('-h');
+const hasLocal = args.includes('--local') || args.includes('-l');
+
+// Parse --config-dir argument
+function parseConfigDirArg() {
+  const idx = args.findIndex(arg => arg === '--config-dir' || arg === '-c');
+  if (idx !== -1) {
+    const nextArg = args[idx + 1];
+    if (!nextArg || nextArg.startsWith('-')) {
+      console.error(`  ${yellow}--config-dir requires a path argument${reset}`);
+      process.exit(1);
+    }
+    return nextArg;
+  }
+  const configDirArg = args.find(arg => arg.startsWith('--config-dir=') || arg.startsWith('-c='));
+  if (configDirArg) {
+    return configDirArg.split('=')[1];
+  }
+  return null;
+}
+
+/**
+ * Expand ~ to home directory
+ */
+function expandTilde(filePath) {
+  if (filePath && filePath.startsWith('~/')) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+
+/**
+ * Recursively copy directory, skipping .drive/, .git/, node_modules/, bin/
+ */
+function copyDir(srcDir, destDir, skipDirs = []) {
+  fs.mkdirSync(destDir, { recursive: true });
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (skipDirs.includes(entry.name)) continue;
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath, skipDirs);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Count files recursively
+ */
+function countFiles(dir, ext) {
+  let count = 0;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      count += countFiles(fullPath, ext);
+    } else if (!ext || entry.name.endsWith(ext)) {
+      count++;
+    }
+  }
+  return count;
+}
+
+console.log(banner);
+
+// Show help
+if (hasHelp) {
+  console.log(`  ${yellow}Usage:${reset} npx @accel/ignition [options]
+
+  ${yellow}Options:${reset}
+    ${cyan}-l, --local${reset}              Install to ./.claude/commands/ instead of global
+    ${cyan}-c, --config-dir <path>${reset}  Specify custom Claude config directory
+    ${cyan}-h, --help${reset}               Show this help message
+
+  ${yellow}Examples:${reset}
+    ${dim}# Install globally (default) — available in all workspaces${reset}
+    npx @accel/ignition
+
+    ${dim}# Install to current project only${reset}
+    npx @accel/ignition --local
+
+  ${yellow}What gets installed:${reset}
+    ${cyan}commands/ignition/${reset}
+      ignition.md              Entry point (routing + persona)
+      tasks/               5 task files (ideate, graduate, launch, status, add-type)
+      data/                15 type-specific data files (5 types x 3 files)
+      templates/           5 PLANNING.md output templates
+      checklists/          Planning quality gate
+`);
+  process.exit(0);
+}
+
+// Determine install target
+const explicitConfigDir = parseConfigDirArg();
+const configDir = expandTilde(explicitConfigDir) || expandTilde(process.env.CLAUDE_CONFIG_DIR);
+const globalDir = configDir || path.join(os.homedir(), '.claude');
+const claudeDir = hasLocal ? path.join(process.cwd(), '.claude') : globalDir;
+const seedDest = path.join(claudeDir, 'commands', 'ignition');
+
+const locationLabel = hasLocal
+  ? seedDest.replace(process.cwd(), '.')
+  : seedDest.replace(os.homedir(), '~');
+
+// Check if already installed
+if (fs.existsSync(seedDest)) {
+  console.log(`  ${yellow}Existing installation found at ${locationLabel}${reset}`);
+  console.log(`  Updating...`);
+  fs.rmSync(seedDest, { recursive: true, force: true });
+}
+
+console.log(`  Installing to ${cyan}${locationLabel}${reset}\n`);
+
+// Copy skill files
+const src = path.join(__dirname, '..');
+
+// Copy entry point
+fs.mkdirSync(seedDest, { recursive: true });
+fs.copyFileSync(path.join(src, 'ignition.md'), path.join(seedDest, 'ignition.md'));
+console.log(`  ${green}+${reset} ignition.md ${dim}(entry point)${reset}`);
+
+// Copy tasks
+const tasksSrc = path.join(src, 'tasks');
+const tasksDest = path.join(seedDest, 'tasks');
+copyDir(tasksSrc, tasksDest);
+const taskCount = countFiles(tasksSrc, '.md');
+console.log(`  ${green}+${reset} tasks/ ${dim}(${taskCount} task files)${reset}`);
+
+// Copy data
+const dataSrc = path.join(src, 'data');
+const dataDest = path.join(seedDest, 'data');
+copyDir(dataSrc, dataDest);
+const dataCount = countFiles(dataSrc, '.md');
+const typeCount = fs.readdirSync(dataSrc, { withFileTypes: true }).filter(e => e.isDirectory()).length;
+console.log(`  ${green}+${reset} data/ ${dim}(${typeCount} types, ${dataCount} files)${reset}`);
+
+// Copy templates
+const templatesSrc = path.join(src, 'templates');
+const templatesDest = path.join(seedDest, 'templates');
+copyDir(templatesSrc, templatesDest);
+const templateCount = countFiles(templatesSrc, '.md');
+console.log(`  ${green}+${reset} templates/ ${dim}(${templateCount} planning templates)${reset}`);
+
+// Copy checklists
+const checklistsSrc = path.join(src, 'checklists');
+const checklistsDest = path.join(seedDest, 'checklists');
+copyDir(checklistsSrc, checklistsDest);
+console.log(`  ${green}+${reset} checklists/ ${dim}(planning quality gate)${reset}`);
+
+console.log(`
+  ${green}Done!${reset} Open Claude Code and type ${cyan}/ignition${reset} to start.
+`);

package/modules/ignition/checklists/planning-quality.md

@@ -0,0 +1,55 @@
+# Planning Quality Checklist
+
+Quality gate for `/ignition graduate` and `/ignition launch`. Determines if a PLANNING.md is rich enough for clean graduation and headless Drive initialization.
+
+## Universal Checks (All Types)
+
+- [ ] **Type metadata** present in header (Application, Workflow, Client, Utility, Campaign, or custom)
+- [ ] **Problem statement** is specific — names the problem, the audience, and why it matters
+- [ ] **Design decisions** documented — at least 1 resolved decision with rationale
+- [ ] **Open questions** section exists (even if "None")
+- [ ] **Next actions** defined — at least 1 concrete next step
+- [ ] **Skill Loadout** noted — which ecosystem tools apply to this build
+
+## Type-Specific Checks
+
+Reference `data/{type}/config.md` for the authority on required vs optional sections.
+
+- [ ] **All required sections** (per config.md) have substantive content — not just headers or placeholders
+- [ ] **Optional sections** either covered or explicitly marked as N/A
+- [ ] **Section depth matches rigor** — tight types (utility) can be brief; deep types (application) need thorough coverage
+
+### Quick Reference
+
+| Type | Required Sections | Rigor |
+|------|------------------|-------|
+| Application | 8 of 10 | deep — thorough coverage expected |
+| Workflow | 6 of 8 | standard — balanced |
+| Client | 6 of 7 | standard — business-focused |
+| Utility | 6 of 6 | tight — all required, but brief |
+| Campaign | 6 of 7 | creative — can be loose, but measurable goal required |
+
+## Drive-Readiness Checks (for /ignition launch)
+
+These are only required if the user intends to run `/ignition launch` (graduate + Drive init). Skip for `/ignition graduate` alone.
+
+- [ ] **Phase breakdown** exists with independently shippable milestones
+- [ ] **Each phase** has build, testable, and outcome defined
+- [ ] **Tech stack decisions** are resolved — no critical "TBD" items
+- [ ] **Enough detail** that Drive can derive milestones, phases, and structure without re-asking questions
+
+## Assessment
+
+| Result | Criteria | Action |
+|--------|----------|--------|
+| **Pass** | All universal checks + all required type-specific sections | Proceed with graduation |
+| **Warn** | Missing optional sections or thin content in some areas | Note gaps, ask user if they want to flesh out or proceed |
+| **Fail** | Missing required sections or no problem statement | Recommend returning to `/ignition` to complete ideation |
+
+## Usage
+
+This checklist is referenced by:
+- `tasks/graduate.md` — step `quality_check` (before creating app directory)
+- `tasks/launch.md` — inherited via graduate delegation
+
+It is NOT a scorecard with numbers. It's a qualitative assessment that the coach persona uses to decide whether to warn the user or proceed.

package/modules/ignition/data/application/config.md

@@ -0,0 +1,21 @@
+# Application — Configuration
+
+| Setting | Value |
+|---------|-------|
+| Rigor | deep |
+| Demeanor | Thorough and architectural — explore trade-offs, push for clarity on data model and deployment before moving on. Applications have the highest complexity ceiling, so don't rush. |
+| Sections | 10 |
+
+## Required Sections
+- Problem Statement
+- Tech Stack
+- Data Model
+- API Surface
+- Deployment Strategy
+- Security Considerations
+- UI/UX Needs
+- Phase Breakdown
+
+## Optional Sections
+- Integration Points
+- Skill Loadout

package/modules/ignition/data/application/guide.md

@@ -0,0 +1,51 @@
+# Application — Conversation Guide
+
+## Section 1: Problem Statement
+**Explore:** What does this solve? Who's it for — just you, a team, the public? Why build it instead of buying something off the shelf? What's the pain point that makes this worth the effort?
+**Suggest:** If the user is vague, try: "What's the one thing a user would do in their first 5 minutes?" If they're solving their own problem, that's valid — note it as "dogfooding" and move on.
+**Depth:** required
+
+## Section 2: Tech Stack
+**Explore:** Do you have a stack in mind, or are you exploring? What's the deployment target — local, cloud, edge? Any constraints from the team or existing infrastructure? Why this stack over alternatives?
+**Suggest:** For solo builders: Next.js + SQLite is fast to ship. For teams: consider what everyone knows. If they mention unfamiliar tech, suggest `/drive:discover` for research before committing.
+**Depth:** required
+
+## Section 3: Data Model
+**Explore:** What are the core things this app tracks? How do they relate to each other? What's the most important entity — the one everything else connects to?
+**Suggest:** Start with 3-5 entities max. Draw the relationships: "A User has many X, each X belongs to one Y." If it's getting complex, suggest starting with the minimum viable schema and evolving.
+**Depth:** required
+
+## Section 4: API Surface
+**Explore:** What endpoints does this need? Is there auth? Internal-only or public API? REST, GraphQL, or tRPC? What's the most critical endpoint — the one that delivers core value?
+**Suggest:** For MVPs: REST is fastest to build. Auth: start with JWT or session-based, don't over-engineer. If they need real-time: consider SSE over WebSockets for simplicity.
+**Depth:** required
+
+## Section 5: Deployment Strategy
+**Explore:** Where does this run? Local dev setup, staging, production — what's the plan for each? Docker or bare metal? CI/CD pipeline needed?
+**Suggest:** For solo projects: Railway or Vercel for zero-config deploys. For Docker: suggest a compose file early. If they need a database: managed > self-hosted for MVPs.
+**Depth:** required
+
+## Section 6: Security Considerations
+**Explore:** What's the auth model? What data is sensitive? Any compliance requirements (HIPAA, SOC2, GDPR)? What are the OWASP risks specific to THIS app?
+**Suggest:** At minimum: input validation, parameterized queries, CSRF protection, rate limiting. If handling PII: encryption at rest. Don't over-engineer security for internal tools.
+**Depth:** required
+
+## Section 7: UI/UX Needs
+**Explore:** What does the user see? Key views/pages? Design system or freestyle? Mobile-responsive needed? Any real-time UI requirements (dashboards, notifications)?
+**Suggest:** For MVPs: Tailwind + shadcn/ui gets you 80% there. If they have design ideas, suggest ui-ux-pro-max for implementation. If not, suggest starting with a wireframe conversation.
+**Depth:** required
+
+## Section 8: Integration Points
+**Explore:** What external systems does this talk to? APIs, webhooks, MCP servers, third-party services? What happens if an integration is down?
+**Suggest:** List each integration with: what data flows, which direction, what auth is needed. For MCP servers: check if one already exists in the workspace before building new.
+**Depth:** optional
+
+## Section 9: Phase Breakdown
+**Explore:** What's the minimum slice that proves the concept? What comes after that? Can you ship something useful in 3-5 phases? What's the "it works" moment for each phase?
+**Suggest:** Phase 1 should be the smallest thing that delivers value. Each phase should be independently testable. If they're planning more than 7 phases, the scope might be too big.
+**Depth:** required
+
+## Section 10: Skill Loadout
+**Explore:** Which ecosystem tools make sense for this build? Need code quality scanning? UI design help? Structured development workflow?
+**Suggest:** Load skill-loadout.md recommendations. For most applications: Drive (required for managed build), Radar (recommended post-build audit), ui-ux-pro-max (if frontend-heavy).
+**Depth:** optional

package/modules/ignition/data/application/skill-loadout.md

@@ -0,0 +1,11 @@
+# Application — Skill Loadout
+
+## Recommended Tools
+
+| Tool | Priority | Why |
+|------|----------|-----|
+| Drive | required | Structured milestones and phases for managed build — applications are too complex for ad-hoc development |
+| Radar | recommended | Post-build security and quality audit — catches OWASP issues, scalability gaps |
+| ui-ux-pro-max | recommended | Frontend design system, component patterns, responsive layouts — if the app has a UI |
+| sonarqube | optional | Continuous code quality scanning — useful for larger codebases or team projects |
+| use-railway | optional | If deploying to Railway — handles project creation, env vars, domains |

package/modules/ignition/data/campaign/config.md

@@ -0,0 +1,18 @@
+# Campaign — Configuration
+
+| Setting | Value |
+|---------|-------|
+| Rigor | creative |
+| Demeanor | Loose and generative — let ideas flow, explore angles, brainstorm freely. But always anchor back to the measurable goal. Campaigns are timeline-driven, not architecture-driven. |
+| Sections | 7 |
+
+## Required Sections
+- Strategy & Goal
+- Audience
+- Deliverables List
+- Channels & Platforms
+- Timeline
+- Success Metrics
+
+## Optional Sections
+- Skill Loadout