@pennyfarthing/core 10.4.0 → 11.0.0

package/pennyfarthing-dist/workflows/quick-spec/steps/step-01-understand.md

@@ -0,0 +1,193 @@
+---
+name: 'step-01-understand'
+description: 'Analyze the requirement delta between current state and what user wants to build'
+
+nextStepFile: './step-02-investigate.md'
+skipToStepFile: './step-03-generate.md'
+templateFile: '../tech-spec-template.md'
+wipFile: '{implementation_artifacts}/tech-spec-wip.md'
+---
+
+<purpose>Define the technical requirement delta and scope through conversational discovery. Perform surface-level code scans to verify the delta. Reserve deep investigation for Step 2.</purpose>
+
+<instructions>Check for WIP, greet user, orient scan of codebase, ask informed questions, capture core understanding, initialize WIP file, present checkpoint menu.</instructions>
+
+<output>Initialized WIP file at {wipFile} with problem statement, solution, scope, and stepsCompleted: [1].</output>
+
+# Step 1: Analyze Requirement Delta
+
+**Progress: Step 1 of 4** - Next: Deep Investigation
+
+## RULES:
+
+- MUST NOT skip steps.
+- MUST NOT optimize sequence.
+- MUST follow exact instructions.
+- MUST NOT look ahead to future steps.
+
+## CONTEXT:
+
+- Variables from `workflow.yaml` are available in memory.
+- Focus: Define the technical requirement delta and scope.
+- Investigation: Perform surface-level code scans ONLY to verify the delta. Reserve deep dives into implementation consequences for Step 2.
+- Objective: Establish a verifiable delta between current state and target state.
+
+## SEQUENCE OF INSTRUCTIONS
+
+### 0. Check for Work in Progress
+
+a) **Before anything else, check if `{wipFile}` exists:**
+
+b) **IF WIP FILE EXISTS:**
+
+1. Read the frontmatter and extract: `title`, `slug`, `stepsCompleted`
+2. Calculate progress: `lastStep = max(stepsCompleted)`
+3. Present to user:
+
+```
+Found a tech-spec in progress:
+
+**{title}** - Step {lastStep} of 4 complete
+
+Is this what you're here to continue?
+
+[Y] Yes, pick up where I left off
+[N] No, archive it and start something new
+```
+
+4. **HALT and wait for user selection.**
+
+a) **Menu Handling:**
+
+- **[Y] Continue existing:**
+  - Jump directly to the appropriate step based on `stepsCompleted`:
+    - `[1]` → Load `{nextStepFile}` (Step 2)
+    - `[1, 2]` → Load `{skipToStepFile}` (Step 3)
+    - `[1, 2, 3]` → Load `./step-04-review.md` (Step 4)
+- **[N] Archive and start fresh:**
+  - Rename `{wipFile}` to `{implementation_artifacts}/tech-spec-{slug}-archived-{date}.md`
+
+### 1. Greet and Ask for Initial Request
+
+a) **Greet the user briefly:**
+
+"What are we building today?"
+
+b) **Get their initial description.** Don't ask detailed questions yet - just understand enough to know where to look.
+
+### 2. Quick Orient Scan
+
+a) **Before asking detailed questions, do a rapid scan to understand the landscape:**
+
+b) **Check for existing context docs:**
+
+- Check `{implementation_artifacts}` and `{planning_artifacts}` for planning documents (PRD, architecture, epics, research)
+- Check for `**/project-context.md` - if it exists, skim for patterns and conventions
+- Check for any existing stories or specs related to user's request
+
+c) **If user mentioned specific code/features, do a quick scan:**
+
+- Search for relevant files/classes/functions they mentioned
+- Skim the structure (don't deep-dive yet - that's Step 2)
+- Note: tech stack, obvious patterns, file locations
+
+d) **Build mental model:**
+
+- What's the likely landscape for this feature?
+- What's the likely scope based on what you found?
+- What questions do you NOW have, informed by the code?
+
+**This scan should take < 30 seconds. Just enough to ask smart questions.**
+
+### 3. Ask Informed Questions
+
+a) **Now ask clarifying questions - but make them INFORMED by what you found:**
+
+Instead of generic questions like "What's the scope?", ask specific ones like:
+- "`AuthService` handles validation in the controller - should the new field follow that pattern or move it to a dedicated validator?"
+- "`NavigationSidebar` component uses local state for the 'collapsed' toggle - should we stick with that or move it to the global store?"
+- "The epics doc mentions X - is this related?"
+
+b) **If no existing code is found:**
+
+- Ask about intended architecture, patterns, constraints
+- Ask what similar systems they'd like to emulate
+
+### 4. Capture Core Understanding
+
+a) **From the conversation, extract and confirm:**
+
+- **Title**: A clear, concise name for this work
+- **Slug**: URL-safe version of title (lowercase, hyphens, no spaces)
+- **Problem Statement**: What problem are we solving?
+- **Solution**: High-level approach (1-2 sentences)
+- **In Scope**: What's included
+- **Out of Scope**: What's explicitly NOT included
+
+b) **Ask the user to confirm the captured understanding before proceeding.**
+
+### 5. Initialize WIP File
+
+a) **Create the tech-spec WIP file:**
+
+1. Copy template from `{templateFile}`
+2. Write to `{wipFile}`
+3. Update frontmatter with captured values:
+   ```yaml
+   ---
+   title: '{title}'
+   slug: '{slug}'
+   created: '{date}'
+   status: 'in-progress'
+   stepsCompleted: [1]
+   tech_stack: []
+   files_to_modify: []
+   code_patterns: []
+   test_patterns: []
+   ---
+   ```
+4. Fill in Overview section with Problem Statement, Solution, and Scope
+5. Fill in Context for Development section with any technical preferences or constraints gathered during informed discovery.
+6. Write the file
+
+b) **Report to user:**
+
+"Created: `{wipFile}`
+
+**Captured:**
+
+- Title: {title}
+- Problem: {problem_statement_summary}
+- Scope: {scope_summary}"
+
+### 6. Present Checkpoint Menu
+
+a) **Display menu:**
+
+Display: "**Select:** [P] Party Mode [C] Continue to Deep Investigation (Step 2 of 4)"
+
+b) **HALT and wait for user selection.**
+
+#### Menu Handling Logic:
+
+- IF P: Execute party mode with current tech-spec content, process collaborative insights, ask user "Accept changes? (y/n)", if yes update WIP file then redisplay menu, if no keep original then redisplay menu
+- IF C: Verify `{wipFile}` has `stepsCompleted: [1]`, then read fully and follow: `{nextStepFile}`
+- IF Any other comments or queries: respond helpfully then redisplay menu
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+- After P execution, return to this menu
+
+---
+
+## REQUIRED OUTPUTS:
+
+- MUST initialize WIP file with captured metadata.
+
+## VERIFICATION CHECKLIST:
+
+- [ ] WIP check performed FIRST before any greeting.
+- [ ] `{wipFile}` created with correct frontmatter, Overview, Context for Development, and `stepsCompleted: [1]`.
+- [ ] User selected [C] to continue.

package/pennyfarthing-dist/workflows/quick-spec/steps/step-02-investigate.md

@@ -0,0 +1,148 @@
+---
+name: 'step-02-investigate'
+description: 'Map technical constraints and anchor points within the codebase'
+
+nextStepFile: './step-03-generate.md'
+wipFile: '{implementation_artifacts}/tech-spec-wip.md'
+---
+
+<purpose>Map the problem statement to specific anchor points in the codebase. Identify exact files to touch, classes/patterns to extend, and technical constraints.</purpose>
+
+<instructions>Load WIP state, investigate codebase deeply, document technical context (stack, patterns, files, tests), update WIP file, present checkpoint menu.</instructions>
+
+<output>Updated WIP file with technical context, files_to_modify, code_patterns, test_patterns, and stepsCompleted: [1, 2].</output>
+
+# Step 2: Map Technical Constraints & Anchor Points
+
+**Progress: Step 2 of 4** - Next: Generate Plan
+
+## RULES:
+
+- MUST NOT skip steps.
+- MUST NOT optimize sequence.
+- MUST follow exact instructions.
+- MUST NOT generate the full spec yet (that's Step 3).
+
+## CONTEXT:
+
+- Requires `{wipFile}` from Step 1 with the "Problem Statement" defined.
+- Focus: Map the problem statement to specific anchor points in the codebase.
+- Output: Exact files to touch, classes/patterns to extend, and technical constraints identified.
+- Objective: Provide the implementation-ready ground truth for the plan.
+
+## SEQUENCE OF INSTRUCTIONS
+
+### 1. Load Current State
+
+**Read `{wipFile}` and extract:**
+
+- Problem statement and scope from Overview section
+- Any context gathered in Step 1
+
+### 2. Execute Investigation Path
+
+**Universal Code Investigation:**
+
+_Isolate deep exploration in sub-agents/tasks where available. Return distilled summaries only to prevent context snowballing._
+
+a) **Build on Step 1's Quick Scan**
+
+Review what was found in Step 1's orient scan. Then ask:
+
+"Based on my quick look, I see [files/patterns found]. Are there other files or directories I should investigate deeply?"
+
+b) **Read and Analyze Code**
+
+For each file/directory provided:
+
+- Read the complete file(s)
+- Identify patterns, conventions, coding style
+- Note dependencies and imports
+- Find related test files
+
+**If NO relevant code is found (Clean Slate):**
+
+- Identify the target directory where the feature should live.
+- Scan parent directories for architectural context.
+- Identify standard project utilities or boilerplate that SHOULD be used.
+- Document this as "Confirmed Clean Slate" - establishing that no legacy constraints exist.
+
+
+c) **Document Technical Context**
+
+Capture and confirm with user:
+
+- **Tech Stack**: Languages, frameworks, libraries
+- **Code Patterns**: Architecture patterns, naming conventions, file structure
+- **Files to Modify/Create**: Specific files that will need changes or new files to be created
+- **Test Patterns**: How tests are structured, test frameworks used
+
+d) **Look for project-context.md**
+
+If `**/project-context.md` exists and wasn't loaded in Step 1:
+
+- Load it now
+- Extract patterns and conventions
+- Note any rules that must be followed
+
+### 3. Update WIP File
+
+**Update `{wipFile}` frontmatter:**
+
+```yaml
+---
+# ... existing frontmatter ...
+stepsCompleted: [1, 2]
+tech_stack: ['{captured_tech_stack}']
+files_to_modify: ['{captured_files}']
+code_patterns: ['{captured_patterns}']
+test_patterns: ['{captured_test_patterns}']
+---
+```
+
+**Update the Context for Development section:**
+
+Fill in:
+
+- Codebase Patterns (from investigation)
+- Files to Reference table (files reviewed)
+- Technical Decisions (any decisions made during investigation)
+
+**Report to user:**
+
+"**Context Gathered:**
+
+- Tech Stack: {tech_stack_summary}
+- Files to Modify: {files_count} files identified
+- Patterns: {patterns_summary}
+- Tests: {test_patterns_summary}"
+
+### 4. Present Checkpoint Menu
+
+Display: "**Select:** [P] Party Mode [C] Continue to Generate Spec (Step 3 of 4)"
+
+**HALT and wait for user selection.**
+
+#### Menu Handling Logic:
+
+- IF P: Execute party mode with current tech-spec content, process collaborative insights, ask user "Accept changes? (y/n)", if yes update WIP file then redisplay menu, if no keep original then redisplay menu
+- IF C: Verify frontmatter updated with `stepsCompleted: [1, 2]`, then read fully and follow: `{nextStepFile}`
+- IF Any other comments or queries: respond helpfully then redisplay menu
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+- After P execution, return to this menu
+
+---
+
+## REQUIRED OUTPUTS:
+
+- MUST document technical context (stack, patterns, files identified).
+- MUST update `{wipFile}` with functional context.
+
+## VERIFICATION CHECKLIST:
+
+- [ ] Technical mapping performed and documented.
+- [ ] `stepsCompleted: [1, 2]` set in frontmatter.

package/pennyfarthing-dist/workflows/quick-spec/steps/step-03-generate.md

@@ -0,0 +1,141 @@
+---
+name: 'step-03-generate'
+description: 'Build the implementation plan based on the technical mapping of constraints'
+
+nextStepFile: './step-04-review.md'
+wipFile: '{implementation_artifacts}/tech-spec-wip.md'
+---
+
+<purpose>Create the implementation sequence that addresses the requirement delta using the captured technical context. Produce actionable, ordered tasks with acceptance criteria.</purpose>
+
+<instructions>Load WIP state, generate implementation tasks ordered by dependency, create Given/When/Then acceptance criteria, fill remaining sections (dependencies, testing, notes), write complete spec, proceed to review.</instructions>
+
+<output>Complete tech-spec with implementation plan, acceptance criteria, and status set to 'review'. stepsCompleted: [1, 2, 3].</output>
+
+# Step 3: Generate Implementation Plan
+
+**Progress: Step 3 of 4** - Next: Review & Finalize
+
+## RULES:
+
+- MUST NOT skip steps.
+- MUST NOT optimize sequence.
+- MUST follow exact instructions.
+- MUST NOT implement anything - just document.
+
+## CONTEXT:
+
+- Requires `{wipFile}` with defined "Overview" and "Context for Development" sections.
+- Focus: Create the implementation sequence that addresses the requirement delta using the captured technical context.
+- Output: Implementation-ready tasks with specific files and instructions.
+
+## READY FOR DEVELOPMENT STANDARD:
+
+A specification is considered "Ready for Development" ONLY if it meets the following:
+
+- **Actionable**: Every task has a clear file path and specific action.
+- **Logical**: Tasks are ordered by dependency (lowest level first).
+- **Testable**: All ACs follow Given/When/Then and cover happy path and edge cases.
+- **Complete**: All investigation results from Step 2 are inlined; no placeholders or "TBD".
+- **Self-Contained**: A fresh agent can implement the feature without reading the workflow history.
+
+## SEQUENCE OF INSTRUCTIONS
+
+### 1. Load Current State
+
+**Read `{wipFile}` completely and extract:**
+
+- All frontmatter values
+- Overview section (Problem, Solution, Scope)
+- Context for Development section (Patterns, Files, Decisions)
+
+### 2. Generate Implementation Plan
+
+Generate specific implementation tasks:
+
+a) **Task Breakdown**
+
+- Each task should be a discrete, completable unit of work
+- Tasks should be ordered logically (dependencies first)
+- Include the specific files to modify in each task
+- Be explicit about what changes to make
+
+b) **Task Format**
+
+```markdown
+- [ ] Task N: Clear action description
+  - File: `path/to/file.ext`
+  - Action: Specific change to make
+  - Notes: Any implementation details
+```
+
+### 3. Generate Acceptance Criteria
+
+**Create testable acceptance criteria:**
+
+Each AC should follow Given/When/Then format:
+
+```markdown
+- [ ] AC N: Given [precondition], when [action], then [expected result]
+```
+
+**Ensure ACs cover:**
+
+- Happy path functionality
+- Error handling
+- Edge cases (if relevant)
+- Integration points (if relevant)
+
+### 4. Complete Additional Context
+
+**Fill in remaining sections:**
+
+a) **Dependencies**
+
+- External libraries or services needed
+- Other tasks or features this depends on
+- API or data dependencies
+
+b) **Testing Strategy**
+
+- Unit tests needed
+- Integration tests needed
+- Manual testing steps
+
+c) **Notes**
+
+- High-risk items from pre-mortem analysis
+- Known limitations
+- Future considerations (out of scope but worth noting)
+
+### 5. Write Complete Spec
+
+a) **Update `{wipFile}` with all generated content:**
+
+- Ensure all template sections are filled in
+- No placeholder text remaining
+- All frontmatter values current
+- Update status to 'review' (NOT 'ready-for-dev' - that happens after user review in Step 4)
+
+b) **Update frontmatter:**
+
+```yaml
+---
+# ... existing values ...
+status: 'review'
+stepsCompleted: [1, 2, 3]
+---
+```
+
+c) **Read fully and follow: `{nextStepFile}` (Step 4)**
+
+## REQUIRED OUTPUTS:
+
+- Tasks MUST be specific, actionable, ordered logically, with files to modify.
+- ACs MUST be testable, using Given/When/Then format.
+- Status MUST be updated to 'review'.
+
+## VERIFICATION CHECKLIST:
+
+- [ ] `stepsCompleted: [1, 2, 3]` set in frontmatter.
+- [ ] Spec meets the **READY FOR DEVELOPMENT** standard.

package/pennyfarthing-dist/workflows/quick-spec/steps/step-04-review.md

@@ -0,0 +1,192 @@
+---
+name: 'step-04-review'
+description: 'Review and finalize the tech-spec'
+
+wipFile: '{implementation_artifacts}/tech-spec-wip.md'
+quick_dev_workflow: '{project_root}/.pennyfarthing/workflows/quick-dev/workflow.yaml'
+---
+
+<purpose>Present complete spec for user review, iterate on feedback, finalize to ready-for-dev status, and provide clear next-step guidance.</purpose>
+
+<instructions>Present complete spec, handle review feedback, finalize when approved (rename file, update status), present final menu with adversarial review and dev options.</instructions>
+
+<output>Finalized tech-spec at {implementation_artifacts}/tech-spec-{slug}.md with status 'ready-for-dev' and stepsCompleted: [1, 2, 3, 4].</output>
+
+# Step 4: Review & Finalize
+
+**Progress: Step 4 of 4** - Final Step
+
+## RULES:
+
+- MUST NOT skip steps.
+- MUST NOT optimize sequence.
+- MUST follow exact instructions.
+
+## CONTEXT:
+
+- Requires `{wipFile}` from Step 3.
+- MUST present COMPLETE spec content. Iterate until user is satisfied.
+
+## READY FOR DEVELOPMENT STANDARD:
+
+A specification is considered "Ready for Development" ONLY if it meets the following:
+
+- **Actionable**: Every task has a clear file path and specific action.
+- **Logical**: Tasks are ordered by dependency (lowest level first).
+- **Testable**: All ACs follow Given/When/Then and cover happy path and edge cases.
+- **Complete**: All investigation results from Step 2 are inlined; no placeholders or "TBD".
+- **Self-Contained**: A fresh agent can implement the feature without reading the workflow history.
+
+## SEQUENCE OF INSTRUCTIONS
+
+### 1. Load and Present Complete Spec
+
+**Read `{wipFile}` completely and extract `slug` from frontmatter for later use.**
+
+**Present to user:**
+
+"Here's your complete tech-spec. Please review:"
+
+[Display the complete spec content - all sections]
+
+"**Quick Summary:**
+
+- {task_count} tasks to implement
+- {ac_count} acceptance criteria to verify
+- {files_count} files to modify"
+
+**Present review menu:**
+
+Display: "**Select:** [C] Continue [E] Edit [Q] Questions [P] Party Mode"
+
+**HALT and wait for user selection.**
+
+#### Menu Handling Logic:
+
+- IF C: Proceed to Section 3 (Finalize the Spec)
+- IF E: Proceed to Section 2 (Handle Review Feedback), then return here and redisplay menu
+- IF Q: Answer questions, then redisplay this menu
+- IF P: Execute party mode with current spec content, process collaborative insights, ask user "Accept changes? (y/n)", if yes update spec then redisplay menu, if no keep original then redisplay menu
+- IF Any other comments or queries: respond helpfully then redisplay menu
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to finalize when user selects 'C'
+- After other menu items execution, return to this menu
+
+### 2. Handle Review Feedback
+
+a) **If user requests changes:**
+
+- Make the requested edits to `{wipFile}`
+- Re-present the affected sections
+- Ask if there are more changes
+- Loop until user is satisfied
+
+b) **If the spec does NOT meet the "Ready for Development" standard:**
+
+- Point out the missing/weak sections (e.g., non-actionable tasks, missing ACs).
+- Propose specific improvements to reach the standard.
+- Make the edits once the user agrees.
+
+c) **If user has questions:**
+
+- Answer questions about the spec
+- Clarify any confusing sections
+- Make clarifying edits if needed
+
+### 3. Finalize the Spec
+
+**When user confirms the spec is good AND it meets the "Ready for Development" standard:**
+
+a) Update `{wipFile}` frontmatter:
+
+   ```yaml
+   ---
+   # ... existing values ...
+   status: 'ready-for-dev'
+   stepsCompleted: [1, 2, 3, 4]
+   ---
+   ```
+
+b) **Rename WIP file to final filename:**
+   - Using the `slug` extracted in Section 1
+   - Rename `{wipFile}` → `{implementation_artifacts}/tech-spec-{slug}.md`
+   - Store this as `finalFile` for use in menus below
+
+### 4. Present Final Menu
+
+a) **Display completion message and menu:**
+
+```
+**Tech-Spec Complete!**
+
+Saved to: {finalFile}
+
+---
+
+**Next Steps:**
+
+[R] Adversarial Review - critique of the spec (recommended)
+[B] Begin Development - start implementing now (not recommended)
+[D] Done - exit workflow
+[P] Party Mode - get expert feedback before dev
+
+---
+
+Once you are fully satisfied with the spec (ideally after **Adversarial Review**),
+it is recommended to run implementation in a FRESH CONTEXT for best results.
+
+Copy this prompt to start dev:
+
+quick-dev {finalFile}
+
+This ensures the dev agent has clean context focused solely on implementation.
+```
+
+b) **HALT and wait for user selection.**
+
+#### Menu Handling Logic:
+
+- IF R: Execute adversarial review — review the spec critically, looking for gaps, ambiguities, missing edge cases, untestable requirements, and implementation risks. Present findings numbered (F1, F2, ...) ordered by severity with columns: ID, Severity, Validity, Description. Return to this menu.
+- IF B: Read the entire workflow file at `{quick_dev_workflow}` and follow the instructions with the final spec file (warn: fresh context is better)
+- IF D: Exit workflow - display final confirmation and path to spec
+- IF P: Execute party mode with current spec content, process collaborative insights, ask user "Accept changes? (y/n)", if yes update spec then redisplay menu, if no keep original then redisplay menu
+- IF Any other comments or queries: respond helpfully then redisplay menu
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- After P or R execution, return to this menu
+
+### 5. Exit Workflow
+
+**When user selects [D]:**
+
+"**All done!** Your tech-spec is ready at:
+
+`{finalFile}`
+
+When you're ready to implement, run:
+
+```
+quick-dev {finalFile}
+```
+
+Ship it!"
+
+---
+
+## REQUIRED OUTPUTS:
+
+- MUST update status to 'ready-for-dev'.
+- MUST rename file to `tech-spec-{slug}.md`.
+- MUST provide clear next-step guidance and recommend fresh context for dev.
+
+## VERIFICATION CHECKLIST:
+
+- [ ] Complete spec presented for review.
+- [ ] Requested changes implemented.
+- [ ] Spec verified against **READY FOR DEVELOPMENT** standard.
+- [ ] `stepsCompleted: [1, 2, 3, 4]` set and file renamed.