jettypod 3.0.2 → 4.0.0

package/.claude/PROTECT_SKILLS.md

@@ -1,8 +1,8 @@
 # ⚠️ CRITICAL: Skills Directory Protection
 
 The `.claude/skills/` directory contains essential skill files:
-- epic-discover
-- feature-discover
+- epic-planning
+- feature-planning
 - speed-mode
 - stable-mode
 

package/.claude/skills/{epic-discover → epic-planning}/SKILL.md

@@ -1,9 +1,9 @@
 ---
-name: epic-discover
+name: epic-planning
 description: Guide epic planning with feature brainstorming and optional architectural decision prototyping. Use when user asks to plan an epic, mentions planning features for an epic, says "help me plan epic", or when they just created an epic and want to break it down into features.
 ---
 
-# Epic Discovery Skill
+# Epic Planning Skill
 
 Guides Claude through comprehensive epic planning including feature identification and architectural decisions.
 
@@ -18,13 +18,20 @@ You'll receive context about the epic being planned. Review:
 - Project context
 - Any parent context
 
-### Step 2: Check Existing Decisions
+### Step 2: Check Existing Features and Decisions
 
-**CRITICAL:** Before suggesting approaches, check if architectural decisions already exist for this epic:
+**CRITICAL:** Before suggesting features or approaches, check what already exists:
 
-```javascript
-const { getDecisionsForEpic } = require('../../lib/decisions-helpers');
-const epicDecisions = await getDecisionsForEpic(epicId);
+**Check for existing features:**
+```bash
+node jettypod.js backlog | grep -A 20 "Epic Name"
+```
+
+If features already exist, acknowledge them and skip to Step 4 (Architectural Decision).
+
+**Check for existing decisions:**
+```bash
+node -e "const { showDecisionsForEpic } = require('./features/decisions/index.js'); showDecisionsForEpic(epicId)"
 ```
 
 If decisions exist, present them to the user:
@@ -48,7 +55,7 @@ Only proceed with suggesting new architectural options if:
 - User confirms decisions need to be revisited, OR
 - User identifies new aspects to decide
 
-### Step 3: Brainstorm Features
+### Step 3: Brainstorm Features (Skip if Features Already Exist)
 
 Based on the epic's purpose, suggest features that belong in this epic:
 
@@ -148,37 +155,65 @@ Then record their decision.
 
 Once features are defined and architectural decision is made (if needed):
 
-```
-I'll create these features now:
+**CRITICAL: You must EXECUTE commands using the Bash tool. Do NOT just display them as text.**
 
-[Run commands to create features]
+#### Step 6A: Create Features
 
-jettypod work create feature "[Feature 1]" "[Description]" --parent=[epic-id]
-jettypod work create feature "[Feature 2]" "[Description]" --parent=[epic-id]
-...
+Use the Bash tool to create each feature:
 
-[If architectural decision was made, confirm rationale first]
+```javascript
+// For each feature, use Bash tool to execute:
+node jettypod.js work create feature "[Feature 1]" "[Description]" --parent=[epic-id]
+node jettypod.js work create feature "[Feature 2]" "[Description]" --parent=[epic-id]
+// etc.
+```
 
-**Propose the rationale to the user:**
+Display to user as you create each one:
+```
+Creating features...
+✅ Created Feature #123: [Feature 1]
+✅ Created Feature #456: [Feature 2]
+```
 
-"I'm going to record this architectural decision:
+#### Step 6B: Record Architectural Decision (if applicable)
+
+If an architectural decision was made, propose the rationale to the user:
+
+```
+I'm going to record this architectural decision:
 
 Aspect: Architecture
 Decision: [architectural approach chosen]
 Rationale: [why this approach was selected]
 
-Does this rationale capture why you chose this approach? (You can edit it if needed)"
+Does this rationale capture why you chose this approach? (You can edit it if needed)
+```
 
-WAIT for user to confirm or provide edited rationale.
+**WAIT for user to confirm or provide edited rationale.**
 
-**Then record with final rationale:**
+**CRITICAL: After user confirms, use Bash tool to EXECUTE the epic-implement command:**
 
-jettypod work epic-implement [epic-id] \
+```javascript
+// Use Bash tool to execute:
+node jettypod.js work epic-implement [epic-id] \
   --aspect="Architecture" \
   --decision="[architectural approach chosen]" \
   --rationale="[user's confirmed/edited rationale]"
+```
+
+**DO NOT display this as example text. EXECUTE IT using the Bash tool.**
+
+After execution succeeds, verify the decision was recorded and display:
+
+```
+✅ Architectural decision recorded
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🎯 Epic Planning Complete!
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-✅ Epic planning complete!
+Features created: [count]
+Architectural decision: Recorded
 
 **Next step:** Plan your first feature
 Run: jettypod work discover [feature-id]

package/.claude/skills/{feature-discover → feature-planning}/SKILL.md

@@ -1,11 +1,11 @@
 ---
-name: feature-discover
-description: Guide feature discovery with UX approach exploration and BDD scenario generation. Use when user asks to plan a feature, mentions designing/implementing a feature, says "help me plan feature", or wants to explore UX approaches for a specific feature.
+name: feature-planning
+description: Guide feature planning with UX approach exploration and BDD scenario generation. Use when user asks to plan a feature, mentions designing/implementing a feature, says "help me plan feature", or wants to explore UX approaches for a specific feature.
 ---
 
-# Feature Discovery Skill
+# Feature Planning Skill
 
-Guides Claude through feature discovery including UX approach exploration, optional prototyping, and BDD scenario generation.
+Guides Claude through feature planning including UX approach exploration, optional prototyping, and BDD scenario generation.
 
 ## Instructions
 
@@ -294,39 +294,55 @@ Ready to start implementation: jettypod work start [first-chore-id]
 
 ### Step 8: Transition to Implementation
 
-Complete the discovery phase:
+Complete the discovery phase by transitioning the feature from discovery to implementation.
 
-```
-I'll archive the prototypes and transition to implementation.
+**CRITICAL: You must EXECUTE the transition command using the Bash tool. Do NOT just display it as text.**
+
+#### Step 8A: Propose Rationale
 
-First, let me propose the rationale:
+Display to user:
 
-"I'm going to record this decision:
+```
+I'm going to record this decision:
 
-Winner: prototypes/[winner-file] (or approach name if no prototypes)
+Winner: [approach name or prototypes/winner-file]
 Rationale: [Why this approach was chosen]
 
-Does this rationale capture why you chose this approach? (You can edit it if needed)"
+Does this rationale capture why you chose this approach? (You can edit it if needed)
 ```
 
-WAIT for user to confirm or provide edited rationale.
+**WAIT for user to confirm or provide edited rationale.**
 
-**Then record with final rationale:**
+#### Step 8B: Execute Transition
 
-```
-jettypod work implement [feature-id] \
-  --winner="prototypes/[winner-file]" \
+**CRITICAL: After user confirms, use Bash tool to EXECUTE the work implement command:**
+
+```javascript
+// Use Bash tool to execute:
+node jettypod.js work implement [feature-id] \
+  --winner="[approach-name or prototypes/winner-file]" \
   --rationale="[user's confirmed/edited rationale]"
+```
+
+**DO NOT display this as example text. EXECUTE IT using the Bash tool.**
+
+After execution succeeds, verify the feature transitioned to implementation phase and display:
+
+```
+✅ Feature transitioned to implementation phase
 
-✅ Feature discovery complete!
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🎯 Feature Discovery Complete!
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-📋 BDD scenarios written: features/[feature-slug].feature
-💾 Scenario file tracked in database
+📋 BDD scenarios: features/[feature-slug].feature
+🧪 Step definitions: features/step_definitions/[feature-slug].steps.js
+✅ Feature phase: Implementation
+🚀 Feature mode: Speed
 
-**Next step:** Start implementing
-Run: jettypod work start [feature-id]
+**Next step:** Start implementing the first chore
+Run: jettypod work start [first-chore-id]
 
-The feature is now in implementation phase (speed mode).
 Build code that passes the happy path scenarios we just wrote.
 ```
 

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

@@ -50,7 +50,7 @@ const path = require('path');
 
 const currentWork = getCurrentWork();
 
-// Check if description has breadcrumbs from feature-discover
+// Check if description has breadcrumbs from feature-planning
 const hasBreadcrumbs = currentWork.description &&
   currentWork.description.includes('Scenario steps addressed:') &&
   currentWork.description.includes('Implementation guidance:') &&
@@ -141,7 +141,7 @@ db.get('SELECT epic_id FROM work_items WHERE id = ?', [currentWork.parent_id], a
 });
 ```
 
-**If breadcrumbs exist (from feature-discover):**
+**If breadcrumbs exist (from feature-planning):**
 - 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
@@ -376,20 +376,91 @@ Chores created:
 • #[ID]: [Title]
 • #[ID]: [Title]
 • #[ID]: [Title]
+```
+
+#### Phase 4: Auto-Elevate to Stable Mode (If All Speed Chores Done)
+
+**CRITICAL: Check if ALL speed mode chores are complete. If yes, auto-elevate to stable mode.**
+
+```javascript
+// Check if all speed chores for this feature are done
+const { getDb } = require('../../lib/database');
+const { getCurrentWork } = require('../../lib/current-work');
+
+const currentWork = getCurrentWork();
+const featureId = currentWork.parent_id;
 
+const db = getDb();
+db.get(`
+  SELECT COUNT(*) as incomplete_count
+  FROM work_items
+  WHERE parent_id = ?
+    AND type = 'chore'
+    AND mode = 'speed'
+    AND status != 'done'
+`, [featureId], async (err, result) => {
+  if (err) {
+    console.error('Error checking speed chores:', err.message);
+    db.close();
+    return;
+  }
+
+  if (result.incomplete_count === 0) {
+    // All speed chores done - auto-elevate to stable
+    console.log('\n✅ All speed mode chores complete!');
+    console.log('Auto-elevating feature to stable mode...\n');
+
+    // Use Bash tool to execute elevation
+    // DO NOT display as text - EXECUTE IT
+  } else {
+    console.log(`\n📋 ${result.incomplete_count} speed mode chores remaining`);
+  }
+
+  db.close();
+});
+```
+
+**If all speed chores are done, use Bash tool to EXECUTE elevation:**
+
+```javascript
+// Use Bash tool to execute:
+node jettypod.js work elevate [feature-id] stable
+```
+
+**DO NOT display this as example text. EXECUTE IT using the Bash tool.**
+
+After execution, display:
+
+```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🎯 Speed Mode Complete!
+🎯 Speed Mode Complete! Feature Elevated to Stable Mode
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 What we accomplished:
 ✅ Happy path scenario passes
-✅ Stable mode chores ready
+✅ All speed mode chores complete
+✅ Feature elevated to stable mode
+✅ Stable mode chores created and ready
+
+**Next step:** Start the first stable mode chore
+  jettypod work start [first-stable-chore-id]
+```
+
+**If speed chores remain, display:**
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🎯 Speed Mode Chore Complete!
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+What we accomplished:
+✅ Happy path scenario passes for this chore
+✅ Stable mode chores created
 
-Next step: Elevate to stable mode
-  jettypod work elevate [feature-id] stable
+Remaining speed mode chores: [count]
 
-Then start the first stable mode chore:
-  jettypod work start [chore-id]
+**Next step:** Continue with next speed mode chore
+  jettypod work start [next-speed-chore-id]
 ```
 
 **Mark current chore as done and end skill.**

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

@@ -578,12 +578,94 @@ Implementation complete:
 • Error handling: ✅ Comprehensive
 • Validation: ✅ Complete
 • All scenarios: ✅ Passing
+```
+
+### Step 4: Check for Stable Mode Completion and Auto-Elevate
+
+**CRITICAL: After completing a stable mode chore, check if ALL stable chores are done. If yes, trigger production chore generation or elevate to production mode.**
+
+```javascript
+// Check if all stable chores for this feature are done
+const { getDb } = require('../../lib/database');
+const { getCurrentWork } = require('../../lib/current-work');
+
+const currentWork = getCurrentWork();
+const featureId = currentWork.parent_id;
+
+const db = getDb();
+db.get(`
+  SELECT COUNT(*) as incomplete_count
+  FROM work_items
+  WHERE parent_id = ?
+    AND type = 'chore'
+    AND mode = 'stable'
+    AND status != 'done'
+`, [featureId], async (err, result) => {
+  if (err) {
+    console.error('Error checking stable chores:', err.message);
+    db.close();
+    return;
+  }
+
+  if (result.incomplete_count === 0) {
+    // All stable chores done!
+    console.log('\n✅ ALL STABLE MODE CHORES COMPLETE!');
+    console.log('Checking project state for production chore generation...\n');
+
+    // NOTE: The production chore generation logic is now handled by
+    // features/work-commands/index.js in the stopWork() function
+    // when a stable mode chore is marked as done.
+    //
+    // This will trigger automatically - no action needed here.
+    // The system will:
+    // 1. Analyze implementation files
+    // 2. Propose production chores
+    // 3. Ask for confirmation
+    // 4. Create production chores
+    // 5. Elevate feature to production mode
+  } else {
+    console.log(`\n📋 ${result.incomplete_count} stable mode chores remaining`);
+  }
+
+  db.close();
+});
+```
+
+**Display based on completion status:**
+
+**If all stable chores done:**
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🎯 Stable Mode Complete!
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
+What we accomplished:
+✅ All BDD scenarios passing (happy path + error handling + edge cases)
+✅ Comprehensive error handling
+✅ Input validation
+✅ All stable mode chores complete
+
+The system will now analyze the implementation and propose production chores.
+This happens automatically via the work tracking system.
+```
+
+**If stable chores remain:**
+
+```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 🎯 Stable Mode Chore Complete!
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-This chore is done. Continue with remaining stable mode chores or elevate to production mode when all are complete.
+What we accomplished:
+✅ Scenario passes with proper error handling
+✅ Input validation added
+✅ Edge cases handled
+
+Remaining stable mode chores: [count]
+
+**Next step:** Continue with next stable mode chore
+  jettypod work start [next-stable-chore-id]
 ```
 
 **Mark current chore as done and end skill.**