@accelerationguy/accel 1.0.0

package/modules/ignition/tasks/graduate.md

@@ -0,0 +1,182 @@
+<purpose>
+Graduate a completed ideation from projects/{name}/ into apps/{name}/ with its own git repo, type-aware README, and workspace tracking updates.
+</purpose>
+
+<user-story>
+As a builder with a completed PLANNING.md, I want to graduate my project into a proper app directory with git and a synthesized README, so that I can start building without manual setup.
+</user-story>
+
+<when-to-use>
+- Ideation is complete and PLANNING.md exists in projects/{name}/
+- Ready to move from planning to building
+- Want a clean app directory with git repo and project brief
+</when-to-use>
+
+<context>
+@ignition.md
+@checklists/planning-quality.md (quality gate — loaded before graduation)
+</context>
+
+<steps>
+
+<step name="validate_input" priority="first">
+## Validate Project
+
+Check `$ARGUMENTS` for a project name.
+
+**If no argument provided:**
+Scan `projects/` for directories containing PLANNING.md. List them:
+
+> "Available projects ready for graduation:"
+> - {name} ({type from PLANNING.md})
+> - {name} ({type})
+>
+> "Which one? Or provide a name."
+
+Wait for response.
+
+**If argument provided:**
+1. Confirm `projects/{name}/PLANNING.md` exists — if not: "No PLANNING.md found at `projects/{name}/`. Run `/ignition` to create one first."
+2. Confirm `apps/{name}/` does NOT exist — if it does: "`apps/{name}/` already exists. This project was already graduated."
+3. If either check fails, stop.
+</step>
+
+<step name="quality_check">
+## Quality Gate
+
+Read `projects/{name}/PLANNING.md` and extract:
+- **Type** metadata field (application, workflow, client, utility, campaign)
+- Overall content depth
+
+Reference `checklists/planning-quality.md` to assess whether the PLANNING.md is rich enough for a clean graduation and potential headless Drive init.
+
+<if condition="Type metadata is missing">
+Infer type from content, or ask: "I can't find a Type field in this PLANNING.md. What type of project is this? (application, workflow, client, utility, campaign)"
+
+Wait for response.
+</if>
+
+<if condition="PLANNING.md appears too thin">
+Warn the user:
+
+> "This PLANNING.md looks light — it may not have enough detail for a strong README or future Drive init. Want to go back to `/ignition` to flesh it out, or graduate as-is?"
+
+Wait for response. If user wants to proceed, continue. If not, exit with suggestion to run `/ignition`.
+</if>
+</step>
+
+<step name="create_app_directory">
+## Create App Directory
+
+1. Create the app directory:
+   ```bash
+   mkdir -p apps/{name}
+   ```
+
+2. Initialize git repo:
+   ```bash
+   cd apps/{name}
+   git init -b main
+   ```
+</step>
+
+<step name="synthesize_readme">
+## Synthesize README
+
+Read `projects/{name}/PLANNING.md` fully. Generate `apps/{name}/README.md` by **synthesizing** (not copying) a clean project brief.
+
+**Common sections (all types):**
+- Title and one-line description
+- Type, Skill Loadout, Quality Gates metadata
+- Overview — concise summary of what and why
+- Design Decisions — resolved decisions (numbered)
+- Implementation Phases — phase breakdown (or "N/A" for small projects)
+- Open Questions — unresolved items
+- References
+
+**Type-specific sections to add:**
+
+| Type | Additional Sections |
+|------|-------------------|
+| Application | Stack, Deploy, Data Model, API Surface, Architecture, UI/UX |
+| Workflow | Scope Definition, Integration Map, Interaction Design, Output Artifacts |
+| Client | Client name, Business Context, Conversion Strategy, Timeline, Tech Approach |
+| Utility | Location, Interface (invocation/input/output), Done Criteria |
+| Campaign | Goal, Deliverables List, Timeline, Success Metrics |
+
+**Synthesis guidelines:**
+- Remove brainstorming artifacts, iteration history, abandoned ideas
+- Keep all resolved design decisions
+- Keep technical architecture details
+- Keep implementation phases
+- Preserve tables and structured data (information-dense)
+- Preserve Type and Skill Loadout metadata — Drive uses this for configuration
+- The README should be comprehensive enough to run `/drive:init` against
+
+Present the generated README to the user:
+
+> "Here's the README I synthesized from your PLANNING.md. Take a look — anything to adjust?"
+
+Wait for response.
+
+<if condition="user requests changes">
+Apply edits and re-present until approved.
+</if>
+</step>
+
+<step name="finalize">
+## Finalize Graduation
+
+1. **Write README.md** to `apps/{name}/README.md`
+
+2. **Initial commit:**
+   ```bash
+   cd apps/{name}
+   git add README.md
+   git commit -m "Initial commit: project brief from graduation"
+   ```
+
+3. **Update ACTIVE.md** — find the project entry and update:
+   - Location: `apps/{name}/`
+   - Status: `Graduated — ready for /drive:init`
+   - If no entry exists, ask user which section to add it under
+
+4. **Note graduation in PLANNING.md** — append to `projects/{name}/PLANNING.md`:
+   ```
+   ---
+   **Graduated:** {today's date}
+   **Location:** `apps/{name}/`
+   **README:** `apps/{name}/README.md`
+   ```
+
+5. **Report:**
+   ```
+   Graduated: projects/{name}/ → apps/{name}/
+   README: apps/{name}/README.md
+   Git: Initialized with initial commit
+
+   Next steps:
+   - `/drive:init` in apps/{name}/ to start a managed build
+   - `/ignition launch {name}` does this automatically (graduate + Drive init)
+   ```
+</step>
+
+</steps>
+
+<output>
+- `apps/{name}/` — new app directory with git repo
+- `apps/{name}/README.md` — type-aware synthesized project brief
+- Updated `ACTIVE.md` entry
+- Graduation note appended to `projects/{name}/PLANNING.md`
+</output>
+
+<acceptance-criteria>
+- [ ] Input validated: PLANNING.md exists, apps/ doesn't
+- [ ] Quality gate checked before graduation
+- [ ] Type extracted from PLANNING.md metadata
+- [ ] README synthesized with type-specific sections (not copied verbatim)
+- [ ] Git repo initialized with initial commit
+- [ ] ACTIVE.md updated with graduated location
+- [ ] Graduation date noted in original PLANNING.md
+- [ ] Wait points present at key decisions (quality warning, README review)
+</acceptance-criteria>

package/modules/ignition/tasks/ideate.md

@@ -0,0 +1,221 @@
+<purpose>
+Guide a user through type-aware collaborative ideation, producing a populated PLANNING.md document ready for graduation or Drive-managed build.
+</purpose>
+
+<user-story>
+As a builder with a raw idea, I want guided exploration shaped by my project type, so that I produce a structured PLANNING.md without missing critical design decisions.
+</user-story>
+
+<when-to-use>
+- Starting a new project and need to shape the idea before building
+- Have a vague concept that needs structure and scoping
+- Want type-specific guidance (app vs utility vs campaign needs different depth)
+- Ready to produce a PLANNING.md for `/ignition graduate` or `/ignition launch`
+</when-to-use>
+
+<context>
+@ignition.md
+@data/{type}/guide.md (loaded after type selection)
+@data/{type}/config.md (loaded after type selection)
+@data/{type}/skill-loadout.md (loaded during skill loadout step)
+@templates/planning-{type}.md (loaded during output generation)
+@checklists/planning-quality.md (referenced as quality gate before output)
+</context>
+
+<steps>
+
+<step name="determine_type" priority="first">
+## Determine Project Type
+
+Check `$ARGUMENTS` for a type match:
+
+| Input | Type |
+|-------|------|
+| `application`, `app` | application |
+| `workflow` | workflow |
+| `client` | client |
+| `utility`, `tool` | utility |
+| `campaign`, `content` | campaign |
+
+**If match found:** Confirm with user — "Sounds like an **{type}** project. That right?"
+
+**If no match or empty:** Ask the user to describe what they're building in a sentence or two. Then suggest the best-fit type with reasoning:
+
+> "Based on what you described, this sounds like a **{type}** project — {one-line reason}. Does that fit?"
+
+Use these signals to route:
+
+| Type | Signals |
+|------|---------|
+| Application | Has UI, data model, API, deployment — software people use |
+| Workflow | Commands, hooks, Vector domains, templates — Claude Code tooling |
+| Client | Website for a client — business context, conversion, content |
+| Utility | Small tool, script, single-purpose — resists expansion |
+| Campaign | Content, marketing, launches — timeline-driven, not code-driven |
+
+Wait for response before proceeding.
+</step>
+
+<step name="get_project_name">
+## Get Project Name
+
+Ask for a project name — lowercase, hyphenated. This becomes the directory name under `projects/`.
+
+Check if `projects/{name}/` already exists:
+- **If exists:** "There's already a `projects/{name}/` directory. Want to continue that existing ideation, or pick a different name?"
+- **If new:** Create `projects/{name}/` directory.
+
+Wait for response.
+</step>
+
+<step name="load_type_context">
+## Load Type Context
+
+Read the composable data files for the selected type:
+
+1. Read `data/{type}/guide.md` — conversation sections for this type
+2. Read `data/{type}/config.md` — rigor level, demeanor, required vs optional sections
+
+**Adopt the coach persona for the rest of this session:**
+
+You are a project coach. Brainstorm alongside the user — offer concrete suggestions when they're stuck, push toward decisions when it's time, let ideas breathe when they need space. You are NOT an interrogator firing questions. You're a thinking partner who happens to know the ecosystem.
+
+Adapt your approach based on config.md:
+- **Tight rigor** (utilities): Move fast, resist scope creep, keep it small
+- **Standard rigor** (workflows, clients): Balanced exploration, clear boundaries
+- **Deep rigor** (applications): Thorough exploration, architecture matters
+- **Creative rigor** (campaigns): Loose, generative, timeline-focused
+</step>
+
+<step name="guided_conversation">
+## Guided Exploration
+
+Work through the sections defined in `data/{type}/guide.md`. These are conversation prompts, not a questionnaire.
+
+**Rules of engagement:**
+- Present 1-2 related sections at a time, not all at once
+- Adapt based on discussion flow — skip sections the user has already addressed naturally
+- Circle back to sections that need more depth
+- Offer concrete suggestions: "For this type of app, most teams use X because..." or "Given your audience, you might consider Y"
+- If the user is stuck, propose a direction: "Here's one way this could work: ..."
+- If the user is going too broad, gently constrain: "That's ambitious — what's the minimum slice that proves the concept?"
+
+**Section groups (from guide.md):**
+
+Work through the guide sections in logical groups. After presenting each group and discussing:
+
+Wait for response.
+
+Continue until all required sections (per config.md) are covered, or the user signals they're ready to wrap up.
+
+<if condition="user signals readiness before all sections covered">
+Check config.md for required vs optional sections. If required sections are missing, note them: "We haven't covered {section} yet — that's usually important for {type} projects. Want to hit that quickly, or skip it?"
+</if>
+</step>
+
+<step name="skill_loadout">
+## Skill Loadout
+
+Read `data/{type}/skill-loadout.md` for recommended ecosystem tools.
+
+Present the recommended skills for this project type:
+
+> "For a **{type}** project, these tools from the ecosystem are worth considering:"
+> - {skill 1} — {why}
+> - {skill 2} — {why}
+
+Ask if any resonate or if they want to note specific tools for the build phase.
+
+Wait for response.
+</step>
+
+<step name="generate_planning">
+## Generate PLANNING.md
+
+When the user is ready (all sections covered or user signals completion):
+
+1. Read `templates/planning-{type}.md` for output structure
+2. Reference `checklists/planning-quality.md` — verify the content is rich enough for headless Drive init
+3. Populate the template with content from the conversation
+4. Write to `projects/{name}/PLANNING.md`
+5. Fill in the metadata block (Type, Skill Loadout, Quality Gates)
+
+Present the completed PLANNING.md to the user for review.
+
+> "Here's the PLANNING.md I've drafted from our conversation. Take a look — anything to adjust before we lock it in?"
+
+Wait for response.
+
+<if condition="user requests changes">
+Apply edits and re-present. Repeat until user approves.
+</if>
+</step>
+
+<step name="update_tracking">
+## Update Tracking & Report
+
+After user approves the PLANNING.md:
+
+1. Update `.accel/momentum/ACTIVE.md` (if Momentum is present) with a new entry:
+   ```
+   ### {Project Name}
+   - **Location:** `projects/{name}/`
+   - **Type:** {type}
+   - **Status:** Ideation complete — ready for `/ignition graduate`
+   - **Next:** `/ignition graduate {name}` or `/ignition launch {name}`
+   ```
+
+2. **Emit a `plan-created` event** so other modules (Drive, Momentum) can react:
+   Write a JSON file to `~/.accel/events/` with this structure:
+   ```json
+   {
+     "_producer": "ignition",
+     "source": "ignition",
+     "type": "plan-created",
+     "payload": {
+       "path": "projects/{name}/PLANNING.md",
+       "projectType": "{type}",
+       "title": "{Project Name}"
+     },
+     "timestamp": "<ISO 8601>"
+   }
+   ```
+   Filename format: `{timestamp}-{seq}-ignition-plan-created.json`
+
+   If Python is available, use the shared event bus:
+   ```python
+   import sys; sys.path.insert(0, '<workspace>/.accel/../shared/events')
+   from event_bus import emit_plan_created
+   emit_plan_created('projects/{name}/PLANNING.md', '{type}', '{Project Name}')
+   ```
+
+3. Report completion:
+   ```
+   Created: projects/{name}/PLANNING.md ({type} template)
+   Updated: ACTIVE.md
+   Emitted: plan-created event to ~/.accel/events/
+
+   Next steps:
+   - `/ignition graduate {name}` — move to apps/ with git init
+   - `/ignition launch {name}` — graduate + initialize Drive for managed build
+   ```
+</step>
+
+</steps>
+
+<output>
+- `projects/{name}/PLANNING.md` — populated type-specific planning document
+- `ACTIVE.md` entry (if Momentum present)
+- Location: `projects/{name}/`
+</output>
+
+<acceptance-criteria>
+- [ ] Type determined before any substantive ideation begins
+- [ ] Type-specific data files loaded and used to shape conversation
+- [ ] Conversation is collaborative (coach), not interrogative (questionnaire)
+- [ ] Wait points present at every user input boundary
+- [ ] Existing project detection prevents silent overwrites
+- [ ] PLANNING.md generated from type-specific template
+- [ ] Planning quality checklist referenced before output
+- [ ] ACTIVE.md updated with new project entry
+</acceptance-criteria>

package/modules/ignition/tasks/launch.md

@@ -0,0 +1,137 @@
+<purpose>
+Graduate a project and initialize Drive in one step — the "easy button" from ideation to managed build.
+</purpose>
+
+<user-story>
+As a builder ready to start building, I want to graduate my project and set up Drive in a single command, so that I don't have to run separate graduation and initialization steps.
+</user-story>
+
+<when-to-use>
+- Ideation is complete and you want to start building immediately
+- You want Drive-managed development (structured phases, plans, progress tracking)
+- You prefer one command over running `/ignition graduate` then `/drive:init` separately
+</when-to-use>
+
+<context>
+@ignition.md
+@tasks/graduate.md (delegation target — launch wraps this flow)
+</context>
+
+<steps>
+
+<step name="run_graduation" priority="first">
+## Run Graduation
+
+Execute the full graduation flow from `tasks/graduate.md` first.
+
+All validation, quality checks, README synthesis, git init, and tracking updates happen there. Do NOT duplicate that logic here — delegate entirely.
+
+Pass `$ARGUMENTS` through as the project name.
+
+After graduation completes successfully, proceed to Drive integration below.
+
+<if condition="graduation fails or user exits during graduate flow">
+Stop here. Do not proceed to Drive integration. The graduate task handles its own error reporting.
+</if>
+</step>
+
+<step name="offer_paul">
+## Offer Drive Integration
+
+After graduation is complete, ask the user:
+
+> "Project graduated to `apps/{name}/`. Want to initialize Drive for a managed build?"
+>
+> Drive gives you structured milestones, phases, plans, and progress tracking. Your PLANNING.md has enough detail to set up Drive without re-answering questions.
+>
+> **Yes** — initialize Drive now
+> **No** — just the graduation is fine (you can run `/drive:init` later)
+
+Wait for response.
+
+<if condition="user declines">
+Report graduation-only result:
+
+> "Graduated: `apps/{name}/`"
+> "Run `/drive:init` in `apps/{name}/` if you change your mind."
+
+Exit.
+</if>
+</step>
+
+<step name="check_paul_availability">
+## Check Drive Availability
+
+Check if the Drive framework is installed:
+```bash
+ls ~/.claude/drive-framework/ 2>/dev/null
+```
+
+<if condition="drive-framework directory exists">
+Drive is available. Proceed to headless init.
+</if>
+
+<if condition="drive-framework directory not found">
+Inform the user:
+
+> "Drive isn't installed globally yet. It needs to be at `~/.claude/drive-framework/`."
+>
+> "Want to install it now? I can help set it up, or you can run `/drive:init` later after installing."
+
+Wait for response.
+
+If user wants to install: guide them through installation (this is environment-specific — provide the standard setup steps).
+If user declines: exit gracefully with graduation-only result.
+</if>
+</step>
+
+<step name="headless_paul_init">
+## Headless Drive Init
+
+Run `/drive:init` in the graduated `apps/{name}/` directory with headless context:
+
+1. Read `apps/{name}/README.md` (synthesized from PLANNING.md during graduation)
+2. Also read the original `projects/{name}/PLANNING.md` for full depth
+
+Pass this context to Drive init with the instruction:
+
+> "Use the PLANNING.md and README.md as the project brief. Derive milestones, phases, and project structure from them. Do NOT re-ask questions that Ignition already answered during ideation — the answers are in these documents. Propose the project structure and ask for approval."
+
+Drive will propose a structure (milestones, phases, tech stack). The user reviews and approves — headless means no redundant questions, NOT no approval.
+
+Wait for response (user approves or adjusts Drive's proposed structure).
+</step>
+
+<step name="report_completion">
+## Report Completion
+
+After Drive initialization is approved:
+
+```
+Launched: {name}
+Location: apps/{name}/
+Drive: Initialized with {milestone} — {N} phases
+
+Your project is ready for managed development.
+Run /drive:plan to start Phase 1.
+```
+</step>
+
+</steps>
+
+<output>
+- Everything from tasks/graduate.md (app directory, git repo, README, tracking)
+- `.drive/` directory in `apps/{name}/` (PROJECT.md, ROADMAP.md, STATE.md)
+- Project ready for `/drive:plan`
+</output>
+
+<acceptance-criteria>
+- [ ] Delegates to tasks/graduate.md without duplicating logic
+- [ ] Asks user about Drive (not filesystem scan for decision)
+- [ ] Checks Drive framework availability before attempting init
+- [ ] Prompts installation if Drive not found
+- [ ] Headless Drive init passes PLANNING.md as context
+- [ ] User still approves Drive's proposed structure
+- [ ] Graceful exit if user declines Drive at any point
+- [ ] Wait points at Drive offer and structure approval
+</acceptance-criteria>

package/modules/ignition/tasks/status.md

@@ -0,0 +1,71 @@
+<purpose>
+Show the project ideation pipeline — what's in projects/, what's ready to graduate, and what's already been graduated.
+</purpose>
+
+<user-story>
+As a builder with multiple ideas in progress, I want to see which projects are in ideation, which are ready to graduate, and which have already moved to apps/, so that I can decide what to work on next.
+</user-story>
+
+<when-to-use>
+- Want to see all projects in the pipeline
+- Deciding which ideation to continue or graduate
+- Checking if a project has already been graduated
+</when-to-use>
+
+<steps>
+
+<step name="scan_projects" priority="first">
+## Scan Pipeline
+
+Scan `projects/` for directories containing `PLANNING.md`. For each project found, extract:
+
+1. **Name** — directory name
+2. **Type** — read Type metadata from PLANNING.md header
+3. **Created** — file creation date of PLANNING.md
+4. **Graduated** — check if PLANNING.md contains a `**Graduated:**` line at the bottom
+
+Also check `apps/` for directories that match project names — these are graduated projects.
+
+If `projects/` doesn't exist or is empty: "No projects in the pipeline. Run `/ignition` to start one."
+</step>
+
+<step name="display_pipeline">
+## Display Pipeline
+
+Present results as a formatted table:
+
+```
+Project Pipeline
+═══════════════════════════════════════════════════
+Name              Type            Status
+───────────────────────────────────────────────────
+{name}            {type}          Ready for /ignition graduate
+{name}            {type}          Graduated → apps/{name}/
+{name}            {type}          In progress (no Type yet)
+═══════════════════════════════════════════════════
+{N} projects | {M} ready to graduate | {K} graduated
+```
+
+**Status logic:**
+- Has Type + content depth → "Ready for /ignition graduate"
+- Has graduation note → "Graduated → apps/{name}/"
+- Missing Type or very thin → "In progress"
+
+If any projects are ready to graduate, suggest: "Run `/ignition graduate {name}` to move to apps/."
+</step>
+
+</steps>
+
+<output>
+- Formatted pipeline table displayed to user
+- No files created or modified (read-only)
+</output>
+
+<acceptance-criteria>
+- [ ] Scans projects/ for directories with PLANNING.md
+- [ ] Extracts name, type, and graduation status per project
+- [ ] Displays formatted pipeline table
+- [ ] Identifies graduated projects (checks for graduation note)
+- [ ] Read-only — does not modify any files
+- [ ] Handles empty pipeline gracefully
+</acceptance-criteria>