jettypod 3.0.1 → 3.0.2

package/.claude/skills/feature-discover/SKILL.md

@@ -186,13 +186,16 @@ Scenario: User successfully logs in with valid credentials
 
 ### Step 7: Propose Speed Mode Chores
 
-**CRITICAL:** After generating BDD scenarios, analyze the codebase and propose technical implementation chores.
+**CRITICAL:** After generating BDD scenarios, analyze the codebase and propose technical implementation chores with rich breadcrumbs for speed mode execution.
 
 **Your analysis should consider:**
 - The BDD scenarios (especially the happy path)
 - Existing codebase structure and patterns
 - Epic's architectural decisions (if any)
 - Tech stack and framework conventions
+- Which scenario steps each chore addresses
+- Similar code patterns to follow
+- Specific step definitions that should pass
 
 **Say to the user:**
 
@@ -205,11 +208,25 @@ Based on the scenario and codebase, here are the chores I recommend for speed mo
 
 **Chore 1: [Technical task title]**
 - Why: [What this accomplishes toward the scenario]
-- Scope: [Specific implementation details]
+- Scenario steps addressed:
+  • [Which Given/When/Then steps this chore makes work]
+- Implementation guidance:
+  • Files to create/modify: [specific paths]
+  • Patterns to follow: [reference existing similar code]
+  • Key functions/components needed: [list]
+- Verification:
+  • Step definitions that should pass: [specific steps from .steps.js]
 
 **Chore 2: [Technical task title]**
 - Why: [What this accomplishes]
-- Scope: [Specific implementation details]
+- Scenario steps addressed:
+  • [Which steps]
+- Implementation guidance:
+  • Files to create/modify: [paths]
+  • Patterns to follow: [references]
+  • Key functions/components needed: [list]
+- Verification:
+  • Step definitions that should pass: [steps]
 
 [etc.]
 
@@ -220,20 +237,58 @@ Sound good? Any adjustments?
 
 **Wait for user confirmation/adjustments.**
 
-**Then create the chores:**
+**Then create the chores with rich descriptions:**
 
 ```javascript
 // For each confirmed chore:
 const { create } = require('./features/work-tracking');
 
-await create('chore', 'Chore Title', 'Description', featureId, 'speed', false);
+const description = `[Technical description]
+
+Scenario steps addressed:
+• [Which Given/When/Then steps this chore makes work]
+
+Implementation guidance:
+• Files to create/modify: [specific paths]
+• Patterns to follow: [reference existing similar code]
+• Key functions/components needed: [list]
+
+Verification:
+• Step definitions that should pass: [specific steps from .steps.js file]`;
+
+await create('chore', 'Chore Title', description, featureId, 'speed', false);
 // Repeat for each chore
 ```
 
+**Example chore description:**
+
+```
+Build login form component with email/password fields
+
+Scenario steps addressed:
+• Given I am on the login page
+• When I enter valid credentials and submit
+
+Implementation guidance:
+• Create: src/components/LoginForm.jsx
+• Follow pattern: src/components/SignupForm.jsx (similar form structure)
+• Key components: EmailInput, PasswordInput, SubmitButton
+• Key functions: handleSubmit(), validateEmailFormat()
+
+Verification:
+• features/step_definitions/login.steps.js - 'I am on the login page' should pass
+• features/step_definitions/login.steps.js - 'I enter valid credentials and submit' should pass
+```
+
 **Report:**
 ```
 ✅ Created X chores for speed mode
 
+Each chore includes:
+• Scenario steps it addresses
+• Implementation guidance with file paths and patterns
+• Step definitions to verify against
+
 Ready to start implementation: jettypod work start [first-chore-id]
 ```
 

package/.claude/skills/speed-mode/SKILL.md

@@ -29,17 +29,18 @@ When this skill is activated, you are helping implement a speed mode chore to ma
 
 ## Implementation Steps
 
-### Step 1: Autonomous Scenario Analysis
+### Step 1: Check for Breadcrumbs and Analyze Scenario
 
 **CRITICAL:** Claude Code executes this autonomously - no user permission needed.
 
 **Your task:**
-1. Get the current work item to find the parent feature's scenario file
-2. Read the scenario file from the database path
-3. Parse the Gherkin format and extract the happy path scenario (first scenario)
-4. Identify what needs to be implemented based on Given/When/Then steps
+1. Get the current work item and read its description for breadcrumbs
+2. If breadcrumbs exist (Scenario steps addressed, Implementation guidance, Verification), use them
+3. If no breadcrumbs, fall back to full autonomous analysis
+4. Read the parent feature's scenario file
+5. Parse the Gherkin and identify what needs to be implemented
 
-**Code to get scenario file:**
+**Code to check for breadcrumbs:**
 
 ```javascript
 const { getCurrentWork } = require('../../lib/current-work');
@@ -49,6 +50,12 @@ const path = require('path');
 
 const currentWork = getCurrentWork();
 
+// Check if description has breadcrumbs from feature-discover
+const hasBreadcrumbs = currentWork.description &&
+  currentWork.description.includes('Scenario steps addressed:') &&
+  currentWork.description.includes('Implementation guidance:') &&
+  currentWork.description.includes('Verification:');
+
 // Get parent feature
 const db = getDb();
 db.get('SELECT * FROM work_items WHERE id = ?', [currentWork.parent_id], (err, feature) => {
@@ -73,7 +80,24 @@ db.get('SELECT * FROM work_items WHERE id = ?', [currentWork.parent_id], (err, f
   - Expected outcomes (Then)
   - Observable changes (And)
 
-**Display to user:**
+**Display to user (with breadcrumbs):**
+
+```
+🚀 Speed Mode: [Chore Title]
+
+Scenario steps addressed:
+[Steps from breadcrumbs]
+
+Implementation guidance:
+[Files, patterns, functions from breadcrumbs]
+
+Verification:
+[Step definitions from breadcrumbs]
+
+Now analyzing codebase to finalize implementation approach...
+```
+
+**Display to user (without breadcrumbs):**
 
 ```
 🚀 Speed Mode: [Feature Name]
@@ -98,9 +122,10 @@ Now analyzing codebase to propose implementation...
 
 **Your task:**
 1. Check for epic architectural decisions
-2. Find relevant existing files
-3. Understand code patterns and conventions
-4. Identify where new code should be added
+2. Use breadcrumbs if available, otherwise discover patterns
+3. Verify/find relevant existing files
+4. Understand code patterns and conventions
+5. Identify where new code should be added
 
 **Check for architectural decisions:**
 
@@ -116,7 +141,14 @@ db.get('SELECT epic_id FROM work_items WHERE id = ?', [currentWork.parent_id], a
 });
 ```
 
-**Find relevant files:**
+**If breadcrumbs exist (from feature-discover):**
+- Parse "Files to create/modify" section - these are your target files
+- Parse "Patterns to follow" section - read these reference files first
+- Parse "Key functions/components needed" - these guide your implementation
+- Verify reference files exist and read them to understand patterns
+- Confirm target file locations make sense in project structure
+
+**If no breadcrumbs (autonomous discovery):**
 - Use Glob tool to find files matching patterns from scenario
   - Example: Scenario mentions "login" → search for `**/*login*.js`, `**/*auth*.js`
 - Use Grep tool to search for keywords from scenario

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jettypod",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "Simplified development mode manager",
   "main": "jettypod.js",
   "bin": {