jettypod 4.4.0 → 4.4.2

package/skills-templates/chore-planning/SKILL.md

@@ -0,0 +1,229 @@
+---
+name: chore-planning
+description: Guide standalone chore planning with automatic type classification, taxonomy guidance loading, and routing to chore-mode for execution. Use when user starts a standalone chore (chore with no parent feature), mentions planning a chore, or says "help me with this chore".
+---
+
+# Chore Planning Skill
+
+Guides Claude through standalone chore planning including automatic type classification, loading type-specific guidance from the taxonomy, building enriched context, and routing to chore-mode for execution.
+
+## Instructions
+
+When this skill is activated, you are helping plan a standalone chore (one without a parent feature). Follow this structured approach:
+
+### Step 1: Understand the Chore Context
+
+You'll receive context about:
+- Chore title and description
+- Project context
+- No parent feature (standalone chores don't have features)
+
+Display:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔧 Planning Standalone Chore
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+**Chore:** [Title]
+**Description:** [Description if provided]
+
+Analyzing chore type...
+```
+
+### Step 2: Classify Chore Type
+
+**CRITICAL:** Use the chore-classifier to determine the chore type automatically.
+
+**Execute this code:**
+
+```javascript
+const { classifyChoreType, classifyWithConfidence } = require('./lib/chore-classifier');
+
+const choreTitle = '[chore title]';
+const choreDescription = '[chore description or empty string]';
+
+const classification = classifyWithConfidence(choreTitle, choreDescription);
+console.log('Classification:', JSON.stringify(classification, null, 2));
+```
+
+Display the classification result:
+
+```
+**Type Classification:** [type] (confidence: [high/medium/low])
+```
+
+**If confidence is low:**
+```
+⚠️ Low confidence classification. The chore might be:
+- [type] - because [reason based on keywords found]
+- [alternative type] - if [alternative interpretation]
+
+Proceeding with [type]. Let me know if this should be different.
+```
+
+### Step 3: Load Taxonomy Guidance
+
+**Execute this code to load type-specific guidance:**
+
+```javascript
+const { getGuidance } = require('./lib/chore-taxonomy');
+
+const guidance = getGuidance('[classified-type]');
+console.log('Guidance:', JSON.stringify(guidance, null, 2));
+```
+
+Display the guidance:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+📋 [Type] Chore Guidance
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+**Scope Considerations:**
+[List each scope item from guidance]
+
+**Verification Criteria:**
+[List each verification item from guidance]
+
+**Test Handling:**
+- Tests required: [yes/no]
+- Approach: [testHandling.approach]
+```
+
+### Step 4: Build Enriched Context
+
+Combine all information into a structured context object:
+
+```javascript
+const choreContext = {
+  chore: {
+    id: [chore-id],
+    title: '[title]',
+    description: '[description]',
+    type: 'chore',
+    parent_id: null  // standalone
+  },
+  classification: {
+    type: '[classified-type]',
+    confidence: '[high/medium/low]'
+  },
+  guidance: {
+    scope: [...],
+    verification: [...],
+    testHandling: {
+      required: true/false,
+      approach: '...'
+    }
+  }
+};
+```
+
+### Step 5: Analyze Codebase Impact
+
+Based on the chore type and guidance, analyze what needs to be done:
+
+**For REFACTOR chores:**
+- Identify the code being restructured
+- Find all callers/dependents
+- List affected test files
+
+**For DEPENDENCY chores:**
+- Check current version
+- Review changelog for breaking changes
+- Identify affected code
+
+**For CLEANUP chores:**
+- Find all references to code being removed
+- Verify nothing depends on it
+- List files to modify
+
+**For TOOLING chores:**
+- Check current tool configuration
+- Identify affected workflows
+- Review CI/CD impacts
+
+Display analysis:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔍 Impact Analysis
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+**Files to modify:**
+[List of files]
+
+**Tests to run:**
+[List of test files/patterns]
+
+**Verification steps:**
+[Specific steps based on guidance]
+```
+
+### Step 6: Create Implementation Plan
+
+Based on the analysis, create a focused plan:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+📝 Implementation Plan
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+**Step 1:** [First action]
+**Step 2:** [Second action]
+...
+
+**Verification:**
+1. [First check from guidance]
+2. [Second check from guidance]
+...
+
+Ready to proceed?
+```
+
+### Step 7: Route to Chore Mode
+
+**WAIT for user confirmation.**
+
+When user confirms (responds with "yes", "proceed", "let's go", etc.):
+
+**Invoke the chore-mode skill using the Skill tool:**
+
+```
+Use the Skill tool with skill: "chore-mode"
+```
+
+The chore-mode skill will:
+1. Create a worktree for the chore
+2. Execute the implementation plan
+3. Run verification steps
+4. Merge when complete
+
+**End chore-planning skill after invoking chore-mode.**
+
+## Key Principles
+
+1. **Automatic classification** - AI determines chore type from title/description
+2. **Taxonomy-driven guidance** - Load specific guidance for each chore type
+3. **Context enrichment** - Build complete context before execution
+4. **Impact analysis** - Understand what the chore affects
+5. **Verification-focused** - Use type-specific verification criteria
+6. **Seamless handoff** - Route to chore-mode with full context
+
+## Chore Type Quick Reference
+
+| Type | Keywords | Test Handling |
+|------|----------|---------------|
+| refactor | refactor, restructure, extract, rename | Run all tests, don't modify assertions |
+| dependency | update, upgrade, bump, migrate | Run full suite, check for deprecations |
+| cleanup | remove, delete, unused, legacy | Verify no references, run affected tests |
+| tooling | ci, build, lint, config | Run affected pipelines |
+
+## Validation
+
+Before routing to chore-mode, ensure:
+- [ ] Chore type classified
+- [ ] Taxonomy guidance loaded
+- [ ] Impact analysis complete
+- [ ] Implementation plan created
+- [ ] User confirmed ready to proceed

package/skills-templates/epic-planning/SKILL.md

@@ -159,13 +159,21 @@ Once features are defined and architectural decision is made (if needed):
 
 #### Step 6A: Create Features
 
-Use the Bash tool to create each feature:
+**CRITICAL:** You MUST pass the `--parent=<epic-id>` flag with the actual numeric epic ID. Without this, features won't appear under the epic in the backlog tree.
+
+Use the Bash tool to create each feature. Replace `<EPIC_ID>` with the actual epic ID number:
 
 ```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.
+// CORRECT - uses actual numeric epic ID:
+node jettypod.js work create feature "Live cursor tracking" "Track cursor positions in real-time" --parent=5
+
+// WRONG - missing parent flag (feature won't be under epic):
+node jettypod.js work create feature "Live cursor tracking" "Track cursor positions in real-time"
+```
+
+For each feature, execute:
+```bash
+node jettypod.js work create feature "<Title>" "<Description>" --parent=<EPIC_ID>
 ```
 
 Display to user as you create each one:
@@ -203,23 +211,114 @@ node jettypod.js work epic-implement [epic-id] \
 
 **DO NOT display this as example text. EXECUTE IT using the Bash tool.**
 
-After execution succeeds, verify the decision was recorded and display:
+After execution succeeds, display:
 
 ```
 ✅ Architectural decision recorded
+```
+
+Then proceed to Step 7.
+
+### Step 7: Route to Next Planning Skill
+
+After features/chores are created (and architectural decision recorded if applicable), route to the appropriate planning skill.
+
+#### Step 7A: Query Created Items
+
+Query the database to find what was just created under this epic:
+
+```bash
+sqlite3 .jettypod/work.db "SELECT id, title, type FROM work_items WHERE parent_id = <EPIC_ID> ORDER BY id"
+```
+
+#### Step 7B: Display and Recommend
 
+Display what was created and recommend which item to plan first:
+
+```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 🎯 Epic Planning Complete!
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-Features created: [count]
-Architectural decision: Recorded
+Created under this epic:
+  ✨ Feature #[id]: [title]
+  ✨ Feature #[id]: [title]
+  🔧 Chore #[id]: [title]  (if any chores were created)
+
+💡 Recommendation: Start with [Feature/Chore] #[id] ([title])
+   [Reason - e.g., "It's foundational - other items may depend on it."]
 
-**Next step:** Plan your first feature
-Run: jettypod work discover [feature-id]
-Or talk to Claude Code: "Let's do feature discovery for #[feature-id]"
+Plan this one now? [yes / pick different / done for now]
 ```
 
+**Recommendation logic:**
+- If features exist, recommend the first feature (features are typically foundational)
+- If only chores exist, recommend the first chore
+- Provide brief reasoning for the recommendation
+
+**WAIT for user response.**
+
+#### Step 7C: Route on Confirmation
+
+Based on user response:
+
+**If user confirms (says "yes", "let's go", "proceed", etc.):**
+
+Determine the skill to invoke based on item type:
+- **Feature** → invoke `feature-planning`
+- **Chore** → invoke `chore-planning`
+
+**IMMEDIATELY invoke the appropriate skill using the Skill tool:**
+
+```
+Use the Skill tool with skill: "feature-planning"
+```
+or
+```
+Use the Skill tool with skill: "chore-planning"
+```
+
+**If user picks different item (says "pick different", "different one", "let me choose", etc.):**
+
+Display a numbered list of all created items:
+
+```
+Which item would you like to plan?
+
+1. ✨ Feature #[id]: [title]
+2. ✨ Feature #[id]: [title]
+3. 🔧 Chore #[id]: [title]
+
+Enter the number of your choice:
+```
+
+**WAIT for user to enter a number.**
+
+After user selects (e.g., "2" or "number 2"):
+1. Look up the item from the list
+2. Determine the skill based on item type:
+   - **Feature** → invoke `feature-planning`
+   - **Chore** → invoke `chore-planning`
+3. **IMMEDIATELY invoke the appropriate skill using the Skill tool**
+
+**If user says "done for now" (or "later", "not now", "skip", "no thanks", etc.):**
+
+Display with actual IDs from the created items:
+```
+No problem! When you're ready to continue, you can plan any of these:
+
+Features:
+  • "Let's do feature discovery for #10" (User registration)
+  • "Let's do feature discovery for #11" (Password reset)
+
+Chores:
+  • "Help me plan chore #12" (Update CI config)
+
+Or run: jettypod backlog to see all items.
+```
+
+**Do NOT invoke any skill. End epic-planning skill.**
+
 ## Key Principles
 
 1. **Feature brainstorming is always required** - Don't skip this even if architectural decision is clear
@@ -227,8 +326,9 @@ Or talk to Claude Code: "Let's do feature discovery for #[feature-id]"
 3. **Always suggest exactly 3 options** when architectural decision needed - Simple/Conservative, Balanced, Advanced
 4. **Be specific about features** - Each feature should be user-facing capability
 5. **Use the Approach Suggestion template** - Pros, Cons, Technical Impact format
-6. **Suggest next step** - Always end with clear guidance on what to do next
+6. **Route to next skill** - After creating items, recommend one and invoke the appropriate planning skill
 7. **Use jettypod commands** - Create features using jettypod CLI, record decisions with epic-implement
+8. **Skill handoff** - Invoke `feature-planning` for features, `chore-planning` for chores
 
 ## Example: Epic with Architectural Decision
 
@@ -289,9 +389,11 @@ Epic: "User Management"
 
 ## Validation
 
-Before completing epic discovery, ensure:
-- [ ] At least 2-3 features identified
+Before completing epic planning, ensure:
+- [ ] At least 2-3 features/chores identified
 - [ ] Features are user-facing capabilities (not technical tasks)
+- [ ] Chores (if any) are standalone work items for this epic
 - [ ] Architectural decision documented if needed
-- [ ] Features created in database
-- [ ] User knows next step .jettypod work discover [feature-id])
+- [ ] All items created in database with correct parent_id
+- [ ] Recommended next item to plan
+- [ ] Routed to feature-planning or chore-planning (or user declined)