@accelerationguy/accel 1.0.0

package/modules/drive/src/workflows/configure-special-flows.md

@@ -0,0 +1,283 @@
+<purpose>
+Configure specialized skill integrations for a Drive project. Discovers available skills, prompts user to select applicable ones, maps skills to work types, and generates .drive/SPECIAL-FLOWS.md.
+</purpose>
+
+<when_to_use>
+- During init when user has specialized skills/commands
+- Ad-hoc via `/drive:flows` command
+- When adding new skills to an existing project
+- When amending existing SPECIAL-FLOWS.md
+</when_to_use>
+
+<loop_context>
+N/A - This is a utility workflow, not a loop phase.
+Can be run at any time without affecting PLAN/APPLY/UNIFY state.
+</loop_context>
+
+<required_reading>
+@.drive/PROJECT.md (project context)
+@.drive/SPECIAL-FLOWS.md (if exists, for amendment)
+</required_reading>
+
+<references>
+@src/references/specialized-workflow-integration.md
+@src/templates/SPECIAL-FLOWS.md
+</references>
+
+<process>
+
+<step name="check_existing" priority="first">
+1. Check if .drive/SPECIAL-FLOWS.md exists:
+   ```bash
+   ls .drive/SPECIAL-FLOWS.md 2>/dev/null
+   ```
+2. If exists:
+   ```
+   Existing SPECIAL-FLOWS.md found.
+
+   [1] Amend (add new skills)
+   [2] Replace (start fresh)
+   [3] View current configuration
+   ```
+   Wait for user response before proceeding.
+3. If not exists: proceed with fresh creation
+</step>
+
+<step name="discover_available_skills">
+1. Scan for available skills:
+   ```bash
+   ls ~/.claude/commands/ 2>/dev/null | head -20
+   ```
+
+2. Present categorized list to user:
+   ```
+   Available skills in your environment:
+
+   Commands:
+   - /revops-expert
+   - /frontend-design
+   - /site-launcher-wp
+   - /content-manager
+   [... etc]
+
+   Which skills apply to this project?
+   (Enter comma-separated names, or "none" to skip)
+
+   Example: revops-expert, frontend-design
+   ```
+
+3. Wait for user response. Store as `selected_skills`.
+4. If "none" or empty: skip to end with minimal SPECIAL-FLOWS.md
+</step>
+
+<step name="map_skills_to_work_types">
+For each selected skill, gather mapping:
+
+```
+Configuring: /{{skill_name}}
+
+1. What type of work triggers this skill?
+   (Example: "Persuasion copy", "UI components", "Database changes")
+
+   Work type:
+```
+Wait for response. Store as `work_type`.
+
+```
+2. Is this skill required or optional?
+   - required: Gap logged if not used
+   - optional: Informational only
+
+   [1] Required (Recommended)
+   [2] Optional
+```
+Wait for response. Store as `priority`.
+
+```
+3. When should this skill be invoked?
+   (Example: "Before writing headlines", "When creating HTML")
+
+   Trigger:
+```
+Wait for response. Store as `trigger`.
+
+Repeat for each selected skill.
+</step>
+
+<step name="check_phase_overrides">
+```
+Do any phases need additional skills beyond the defaults?
+(Example: Phase 3 might need a specific framework skill)
+
+[1] Yes, configure phase overrides
+[2] No, defaults are sufficient
+```
+
+**If "1" or "yes":**
+```
+Phase number (e.g., 3):
+```
+Wait for response.
+
+```
+Additional skill for this phase:
+```
+Wait for response.
+
+```
+Why is this needed for this phase?
+```
+Wait for response.
+
+Repeat or ask "Add another phase override? [y/n]"
+</step>
+
+<step name="identify_templates_assets">
+```
+Do you have reference templates or assets for this project?
+(HTML templates, external docs, reference materials)
+
+[1] Yes, add templates/assets
+[2] No, skip this section
+```
+
+**If "1" or "yes":**
+```
+Asset type (e.g., "Hero template", "API docs"):
+```
+Wait for response.
+
+```
+Location (file path or URL):
+```
+Wait for response.
+
+```
+When is this used?
+```
+Wait for response.
+
+Repeat or ask "Add another asset? [y/n]"
+</step>
+
+<step name="generate_output">
+1. Create .drive/SPECIAL-FLOWS.md using template:
+   - Replace all {{placeholders}} with gathered data
+   - Populate tables with skill mappings
+   - Set timestamp to current date/time
+
+2. Update PROJECT.md with quick reference section:
+   ```markdown
+   ## Specialized Flows
+
+   See: .drive/SPECIAL-FLOWS.md
+
+   Quick Reference:
+   - /skill1 → Work type 1
+   - /skill2 → Work type 2
+   ```
+
+3. Display confirmation:
+   ```
+   ════════════════════════════════════════
+   SPECIAL-FLOWS CONFIGURED
+   ════════════════════════════════════════
+
+   Created: .drive/SPECIAL-FLOWS.md
+
+   Skills configured:
+   - /skill1 (required) → Work type 1
+   - /skill2 (optional) → Work type 2
+
+   Phase overrides: [N configured / None]
+   Templates/assets: [N configured / None]
+
+   ────────────────────────────────────────
+   Verification will occur during UNIFY.
+   Run /drive:flows audit to check current phase.
+   ────────────────────────────────────────
+   ```
+</step>
+
+</process>
+
+<subcommand name="add">
+Quick add a single skill without full configuration:
+
+1. Ask for skill name
+2. Ask for work type
+3. Ask for priority (required/optional)
+4. Ask for trigger
+5. Append to existing SPECIAL-FLOWS.md table
+6. Confirm addition
+</subcommand>
+
+<subcommand name="audit">
+Check current phase against declared flows:
+
+1. Read .drive/SPECIAL-FLOWS.md
+2. Read .drive/STATE.md for current phase
+3. Check ROADMAP.md for phase skill requirements
+4. Display:
+   ```
+   SKILL AUDIT - Phase {{N}}
+
+   Required for this phase:
+   - /skill1 (project-level)
+   - /skill2 (phase override)
+
+   Check invocations before UNIFY.
+   ```
+</subcommand>
+
+<subcommand name="list">
+Display current configuration:
+
+1. Read .drive/SPECIAL-FLOWS.md
+2. Display formatted summary:
+   ```
+   SPECIAL-FLOWS CONFIGURATION
+
+   Project-Level Skills:
+   - /skill1 (required) → Work type 1
+   - /skill2 (optional) → Work type 2
+
+   Phase Overrides:
+   - Phase 3: /skill3
+
+   Templates/Assets: 2 configured
+   ```
+</subcommand>
+
+<output>
+- `.drive/SPECIAL-FLOWS.md` created or updated
+- `.drive/PROJECT.md` updated with quick reference
+- User informed of configuration
+</output>
+
+<error_handling>
+**No .claude/commands/ directory:**
+```
+No skills directory found at ~/.claude/commands/
+Add skills to your Claude Code configuration first.
+
+You can still manually specify skill names.
+Enter skill names (comma-separated) or "skip":
+```
+
+**Existing SPECIAL-FLOWS.md and user chooses amend:**
+- Read existing configuration
+- Preserve existing entries
+- Add new entries from this session
+- Update timestamp
+
+**No .drive/ directory:**
+```
+Drive not initialized in this project.
+Run /drive:init first, or create .drive/ manually.
+```
+
+**User provides invalid skill name:**
+- Warn but proceed (skill may exist elsewhere)
+- Note: "Skill not found in ~/.claude/commands/ but adding anyway"
+</error_handling>

package/modules/drive/src/workflows/consider-issues.md

@@ -0,0 +1,172 @@
+<purpose>
+Review all open issues with current codebase context. Categorize as resolved, urgent, natural-fit, or can-wait. Offer triage actions. Prevents issue pile-up by closing the loop on deferred work.
+</purpose>
+
+<when_to_use>
+- Before milestone completion (clean up before release)
+- Periodically during active development
+- When planning new phase (check for natural fits)
+- After significant refactoring (issues may be resolved)
+</when_to_use>
+
+<process>
+
+<step name="find_issues">
+**Locate all issue files:**
+
+1. Check for global issues:
+   ```bash
+   ls .drive/ISSUES.md 2>/dev/null
+   ```
+
+2. Check for phase-scoped UAT files:
+   ```bash
+   find .drive/phases -name "*-UAT.md" -type f 2>/dev/null
+   ```
+
+3. If no issue files found:
+   ```
+   No issues to review.
+
+   Issue files are created by:
+   - Deferred enhancements during development → .drive/ISSUES.md
+   - UAT testing findings → .drive/phases/XX-name/{plan}-UAT.md
+
+   All clear - continue with current work.
+   ```
+   Exit workflow.
+</step>
+
+<step name="parse_issues">
+**Parse all open issues:**
+
+From ISSUES.md "## Open Issues" section:
+- ISS number (ISS-001, ISS-002, etc.)
+- Brief description
+- Discovered phase/date
+- Type (Bug/Enhancement/Technical Debt/UX)
+- Effort estimate
+
+From UAT files:
+- UAT number (UAT-001, UAT-002, etc.)
+- Severity (Blocker/Major/Minor/Cosmetic)
+- Related AC
+- Description
+
+Build consolidated list with source file reference.
+</step>
+
+<step name="analyze_each">
+**For each open issue, analyze against codebase:**
+
+1. **Check if still relevant:**
+   - Search for related code/files mentioned
+   - If code no longer exists or significantly refactored → likely resolved
+
+2. **Check if accidentally resolved:**
+   - Look for changes that may have addressed this
+   - Check if enhancement was implemented as part of other work
+
+3. **Assess current urgency:**
+   - Blocking upcoming phases?
+   - Pain point in recent work?
+   - Affecting actively-touched code?
+
+4. **Check natural fit:**
+   - Aligns with upcoming phase in roadmap?
+   - Would touch same files as current work?
+
+**Categorize:**
+- **Resolved** - Can be closed (code changed, no longer applicable)
+- **Urgent** - Should address before continuing (blocking/problematic)
+- **Natural fit** - Good candidate for upcoming phase X
+- **Can wait** - Keep deferred, no change in status
+</step>
+
+<step name="report">
+**Present categorized report:**
+
+```
+# Issue Review
+
+**Analyzed:** [N] open issues
+**Date:** [today]
+
+## Resolved (can close)
+
+### ISS-XXX: [description]
+**Reason:** [Why resolved - code changed, implemented elsewhere]
+**Evidence:** [What you found]
+
+---
+
+## Urgent (should address now)
+
+### UAT-XXX: [description]
+**Why urgent:** [What changed - blocking, causing problems]
+**Recommendation:** Insert plan or add to current phase
+**Effort:** [Quick/Medium/Substantial]
+
+---
+
+## Natural Fit for Upcoming Work
+
+### ISS-XXX: [description]
+**Fits with:** Phase [X] - [phase name]
+**Reason:** [Same files, same subsystem]
+
+---
+
+## Can Wait (no change)
+
+[List issue IDs with brief status]
+```
+</step>
+
+<step name="offer_actions">
+**Offer actions based on findings:**
+
+Use AskUserQuestion with relevant options:
+
+**If resolved issues exist:**
+- "Close resolved" - Move to closed section
+- "Review each first" - Show details before closing
+
+**If urgent issues exist:**
+- "Insert urgent phase" - Create decimal phase (e.g., 10.3)
+- "Add to current plan" - Include in next plan
+- "Defer anyway" - Keep as-is
+
+**If natural fits exist:**
+- "Note for phase" - Update issue with suggested phase
+- "Keep as-is" - No annotation needed
+
+**Always include:**
+- "Done for now" - Exit without changes
+</step>
+
+<step name="execute_actions">
+**Execute selected actions:**
+
+**Closing resolved issues:**
+1. Move from "## Open Issues" to "## Closed Issues"
+2. Add resolution note with date and reason
+3. Update STATE.md deferred issues count
+
+**Inserting urgent phase:**
+- Suggest command: `/drive:plan 10.3 Address urgent issues [list]`
+
+**Noting for phase:**
+- Update issue entry with "Suggested: Phase [X]"
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] All issue files discovered
+- [ ] All open issues parsed
+- [ ] Each issue analyzed against codebase
+- [ ] Each issue categorized with reasoning
+- [ ] Actions offered based on findings
+- [ ] Files updated if actions taken
+</success_criteria>

package/modules/drive/src/workflows/create-milestone.md

@@ -0,0 +1,268 @@
+<purpose>
+Define a new milestone in the project. Creates milestone structure in ROADMAP.md, initializes phase directories, and updates project state. Uses MILESTONE-CONTEXT.md handoff if available from discuss-milestone.
+</purpose>
+
+<when_to_use>
+- User explicitly requests new milestone
+- Triggered after /drive:discuss-milestone (reads context)
+- Project completed previous milestone, needs next
+- Starting fresh project milestone planning
+</when_to_use>
+
+<loop_context>
+N/A - This is a milestone setup workflow, not a loop phase.
+After create-milestone, project is ready for first phase PLAN.
+</loop_context>
+
+<required_reading>
+@.drive/STATE.md
+@.drive/ROADMAP.md
+@.drive/MILESTONE-CONTEXT.md (if exists)
+</required_reading>
+
+<references>
+@src/templates/ROADMAP.md (milestone section format)
+@src/templates/milestone-context.md (handoff structure)
+</references>
+
+<process>
+
+<step name="load_context" priority="first">
+1. Check for MILESTONE-CONTEXT.md:
+   ```bash
+   cat .drive/MILESTONE-CONTEXT.md 2>/dev/null
+   ```
+
+2. **If found:**
+   - Display: "Loading context from discuss-milestone..."
+   - Parse: Features, Scope, Phase Mapping, Constraints
+   - Store for use in subsequent steps
+   - Skip to step 4 (update_roadmap)
+
+3. **If not found:**
+   - Display: "No discussion context found. Let's define the milestone."
+   - Proceed to step 2 (get_milestone_info)
+</step>
+
+<step name="get_milestone_info">
+**Only if no MILESTONE-CONTEXT.md exists.**
+
+Ask ONE question at a time:
+
+**Question 1: Milestone name/version**
+```
+What version/name for this milestone?
+
+Example: "v0.3 Roadmap Management" or "v1.0 Production Release"
+```
+Wait for response. Store as `milestone_name`.
+
+**Question 2: Theme**
+```
+What's the focus of this milestone? (1 sentence)
+```
+Wait for response. Store as `milestone_theme`.
+</step>
+
+<step name="identify_phases">
+**Only if no MILESTONE-CONTEXT.md exists.**
+
+Ask about phases:
+
+```
+What phases will this milestone include?
+
+(Example: "Templates, Workflows, Commands" or "3 phases for auth, dashboard, deployment")
+```
+
+Wait for response. Parse into phase list.
+
+For each phase, derive:
+- Phase number (next available from ROADMAP.md)
+- Phase name
+- Brief description
+</step>
+
+<step name="update_roadmap">
+Read current ROADMAP.md and update:
+
+1. **Add milestone header section:**
+   ```markdown
+   ## Current Milestone
+   **{milestone_name}** ({version})
+   Status: 🚧 In Progress
+   Phases: 0 of {phase_count} complete
+   ```
+
+2. **Add phases to table:**
+   ```markdown
+   | Phase | Name | Plans | Status | Completed |
+   |-------|------|-------|--------|-----------|
+   | {N} | {name} | TBD | Not started | - |
+   ```
+
+3. **Add phase details section:**
+   ```markdown
+   ### Phase {N}: {name}
+
+   Focus: {description}
+   Plans: TBD (defined during /drive:plan)
+   ```
+
+4. **Update footer timestamp**
+</step>
+
+<step name="create_phase_directories">
+For each phase in the new milestone:
+
+```bash
+mkdir -p .drive/phases/{NN}-{name-slug}
+```
+
+Where:
+- `NN` = zero-padded phase number
+- `name-slug` = lowercase, hyphenated phase name
+</step>
+
+<step name="update_state">
+Update STATE.md:
+
+1. **Current Position:**
+   ```markdown
+   ## Current Position
+
+   Milestone: {milestone_name}
+   Phase: {first_phase_number} of {total} ({first_phase_name})
+   Plan: Not started
+   Status: Ready to plan
+   Last activity: {timestamp} — Milestone created
+   ```
+
+2. **Progress:**
+   ```markdown
+   Progress:
+   - {milestone_name}: [░░░░░░░░░░] 0%
+   ```
+
+3. **Loop Position:**
+   ```markdown
+   ## Loop Position
+
+   Current loop state:
+   ```
+   PLAN ──▶ APPLY ──▶ UNIFY
+     ○        ○        ○     [Ready for first PLAN]
+   ```
+   ```
+
+4. **Session Continuity:**
+   ```markdown
+   ## Session Continuity
+
+   Last session: {timestamp}
+   Stopped at: Milestone created, ready to plan
+   Next action: /drive:plan for Phase {first_phase_number}
+   Resume file: .drive/ROADMAP.md
+   ```
+</step>
+
+<step name="sync_paul_json">
+**Sync satellite manifest (drive.json):**
+
+1. Check if `.drive/drive.json` exists:
+   ```bash
+   ls .drive/drive.json 2>/dev/null
+   ```
+2. If not found: skip silently (pre-v1.1 project)
+3. If found: read current drive.json and update:
+   - `milestone.name` → new milestone name
+   - `milestone.version` → new milestone version
+   - `milestone.status` → "in_progress"
+   - `version` → new milestone version string
+   - `phase.number` → first phase number
+   - `phase.name` → first phase name
+   - `phase.status` → "not_started"
+   - `loop.plan` → null
+   - `loop.position` → "IDLE"
+   - `timestamps.updated_at` → current ISO timestamp
+4. Write updated drive.json back
+</step>
+
+<step name="cleanup_context">
+**If MILESTONE-CONTEXT.md existed:**
+
+Delete the handoff file:
+```bash
+rm .drive/MILESTONE-CONTEXT.md
+```
+
+Display: "Cleaned up milestone context handoff."
+
+**Note:** This file is temporary — its job is done once milestone is created.
+</step>
+
+<step name="offer_next">
+Display completion with ONE next action:
+
+```
+════════════════════════════════════════
+MILESTONE CREATED
+════════════════════════════════════════
+
+Milestone: {milestone_name}
+Theme: {milestone_theme}
+Phases: {phase_count}
+
+Created:
+  .drive/phases/{phase-1-slug}/     ✓
+  .drive/phases/{phase-2-slug}/     ✓
+  .drive/phases/{phase-N-slug}/     ✓
+
+ROADMAP.md updated ✓
+STATE.md updated ✓
+
+────────────────────────────────────────
+▶ NEXT: /drive:plan
+  Begin planning Phase {first_phase_number}: {first_phase_name}
+────────────────────────────────────────
+
+Type "yes" to proceed, or ask questions first.
+```
+
+**Do NOT suggest multiple next steps.** ONE action only.
+</step>
+
+</process>
+
+<output>
+- ROADMAP.md updated with new milestone section
+- Phase directories created in .drive/phases/
+- STATE.md updated with new position
+- MILESTONE-CONTEXT.md deleted (if existed)
+- Clear routing to /drive:plan
+</output>
+
+<success_criteria>
+- [ ] MILESTONE-CONTEXT.md loaded if exists
+- [ ] User prompted only if no context exists
+- [ ] ROADMAP.md has new milestone section
+- [ ] Phase directories created
+- [ ] STATE.md reflects new milestone position
+- [ ] MILESTONE-CONTEXT.md cleaned up
+- [ ] Single next action offered
+</success_criteria>
+
+<error_handling>
+**MILESTONE-CONTEXT.md malformed:**
+- Report parsing error
+- Fall back to manual questions
+- Clean up malformed file
+
+**Phase directory exists:**
+- Check if empty → proceed
+- If has content → warn about overwrite, ask to confirm
+
+**ROADMAP.md missing:**
+- Create basic structure
+- Or route to /drive:init if project not initialized
+</error_handling>