jettypod 4.4.10 → 4.4.11

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

@@ -13,11 +13,23 @@ description: Guide implementation of speed mode chores with autonomous code anal
 │                      ▲▲▲▲▲▲▲▲▲▲▲                                     │
 │                      YOU ARE HERE                                    │
 │                                                                      │
-│  Next: After implementation, this skill generates stable mode        │
-│        chores and elevates the feature to stable mode.               │
+│  Next: After ALL speed chores complete, this skill generates         │
+│        stable mode chores and IMMEDIATELY invokes stable-mode skill. │
 └─────────────────────────────────────────────────────────────────────┘
 ```
 
+## 🛑 CRITICAL HANDOFF REQUIREMENT
+
+**After completing ALL speed mode chores, you MUST:**
+1. Generate stable mode BDD scenarios and step definitions
+2. Create stable mode chores
+3. Set feature mode to stable
+4. **IMMEDIATELY invoke stable-mode using the Skill tool**
+
+**🛑 STOP GATE:** DO NOT end this skill without invoking stable-mode. Speed mode is ONLY a checkpoint - features are INCOMPLETE without stable mode.
+
+---
+
 Guides Claude Code through speed mode implementation with autonomous analysis and execution. Users confirm approach but Claude Code writes the code.
 
 ## Instructions
@@ -51,6 +63,28 @@ When this skill is activated, you are helping implement a speed mode chore to ma
 
 **User Profile:** May not know how to code - Claude Code does the implementation autonomously.
 
+<details>
+<summary><strong>📋 Speed Mode Constraints (click to expand)</strong></summary>
+
+**What to implement:**
+- ALL scoped functionality - required features AND optional features from all success scenarios
+- Multiple valid workflows if the feature supports them
+- Success variations (different outcomes that are all correct)
+
+**What NOT to implement:**
+- ❌ Error handling (try/catch, validation, edge cases)
+- ❌ Input validation (null checks, type checks, range validation)
+- ❌ Error messages for failures
+- ❌ Edge case handling (empty arrays, boundary values, race conditions)
+
+**Code organization:**
+- Single file when possible - keep it simple
+- Inline code over separate modules initially
+- Use real infrastructure (actual database/storage from your tech stack, not mocks)
+- Focus: Make. All. Features. Work. (all success paths)
+
+</details>
+
 ---
 
 ## 🧪 Unit Testing in Speed Mode - True TDD
@@ -75,7 +109,9 @@ When this skill is activated, you are helping implement a speed mode chore to ma
 - Follow project conventions: `test/`, `__tests__/`, or `*.test.js` alongside code
 - Check existing test files for patterns
 
-**Example of TDD iteration:**
+<details>
+<summary><strong>📋 TDD Example (click to expand)</strong></summary>
+
 ```javascript
 // Iteration 1: BDD step "Given a user exists" is failing
 
@@ -112,30 +148,30 @@ test('createUser throws error for invalid email', () => {
 });
 ```
 
-<details>
-<summary><strong>📋 Speed Mode Constraints (click to expand)</strong></summary>
+</details>
 
-**What to implement:**
-- ALL scoped functionality - required features AND optional features from all success scenarios
-- Multiple valid workflows if the feature supports them
-- Success variations (different outcomes that are all correct)
+---
 
-**What NOT to implement:**
-- ❌ Error handling (try/catch, validation, edge cases)
-- ❌ Input validation (null checks, type checks, range validation)
-- ❌ Error messages for failures
-- ❌ Edge case handling (empty arrays, boundary values, race conditions)
+## Quick Reference: Async Boundaries
 
-**Code organization:**
-- Single file when possible - keep it simple
-- Inline code over separate modules initially
-- Use real infrastructure (actual database/storage from your tech stack, not mocks)
-- Focus: Make. All. Features. Work. (all success paths)
+**Where Claude Code MUST wait for user confirmation:**
 
-</details>
+| Step | Location | Why |
+|------|----------|-----|
+| Step 3A | Before implementing (conditional) | User confirms implementation approach - only if ambiguous |
+| Step 7B | Before creating stable chores | User confirms proposed stable mode chores - always |
+
+**Where Claude Code executes autonomously:**
+- Steps 0-2: Initialize, analyze scenarios, analyze codebase
+- Step 3: Decision to skip/ask confirmation
+- Steps 4-5: RED baseline, RED→GREEN→REFACTOR loop
+- Step 6: Route to next chore OR transition to Step 7
+- Step 7 (after confirmation): Create chores, commit, set mode, invoke stable-mode
 
 ---
 
+## Implementation Steps
+
 ### Step 0: Initialize Speed Mode Context
 
 **You are now in speed mode,** implementing a chore to make success scenarios pass.
@@ -165,57 +201,6 @@ Analyzing BDD scenarios to determine implementation approach...
 
 ---
 
-## Quick Reference: Async Boundaries
-
-**Where Claude Code MUST wait for user confirmation:**
-
-| Phase | Location | Why | Condition |
-|-------|----------|-----|-----------|
-| Step 3A | Before implementing (conditional) | User confirms implementation approach | Only if approach is ambiguous or multiple valid paths |
-| Step 6 Phase 2 | Before creating stable chores | User confirms proposed stable mode chores | Always |
-
-**Where Claude Code executes autonomously:**
-- Step 0: Initialize context
-- Step 1: Scenario analysis and breadcrumb check
-- Step 2: Codebase analysis
-- Step 3: Decision to skip/ask for confirmation
-- Step 4: Establish RED baseline
-- Step 5: RED→GREEN→REFACTOR loop (true TDD)
-- Step 6 Phase 1: Generate stable mode scenarios/steps
-- Step 6 Phases 3-5: Create chores and invoke stable-mode skill
-
----
-
-## ⚠️ CRITICAL: Speed Mode Workflow Requirements
-
-**DO NOT mark features as complete after speed mode implementation.**
-
-Speed mode is ONLY a checkpoint to prove functionality works. Features are INCOMPLETE without stable mode chores that add:
-- Error handling and validation
-- Edge case coverage
-- Comprehensive testing
-- User-friendly error messages
-
-**Required workflow after speed mode implementation:**
-
-1. ✅ **Complete ALL speed mode chores** - Implement all success scenarios (required + optional features)
-2. ✅ **Elevate to stable mode** - Use `jettypod work set-mode <feature-id> stable` to auto-generate stable mode chores
-3. ✅ **Implement stable mode chores** - Add error handling and edge cases
-4. ❌ **NEVER mark feature complete in speed mode** - This bypasses critical quality gates
-
-**If you attempt to mark a feature complete while in speed mode, the system will block you with an error.**
-
-The validation will require you to:
-- Elevate to stable mode: `jettypod work set-mode <feature-id> stable`
-- This will automatically analyze the implementation and generate appropriate stable mode chores
-- Or explicitly skip (not recommended): `jettypod work set-mode <feature-id> stable --force`
-
-**Remember:** Speed mode makes it work (all success scenarios). Stable mode makes it robust (handles failures).
-
----
-
-## Implementation Steps
-
 ### Step 1: Check for Breadcrumbs and Analyze Scenario
 
 **CRITICAL:** Claude Code executes this autonomously - no user permission needed.
@@ -230,7 +215,6 @@ The validation will require you to:
 **To get current work and check for breadcrumbs:**
 
 ```bash
-# Get current work item with description and parent feature's scenario_file
 sqlite3 .jettypod/work.db "SELECT wi.id, wi.title, wi.description, wi.parent_id, parent.title as parent_title, parent.scenario_file FROM work_items wi LEFT JOIN work_items parent ON wi.parent_id = parent.id WHERE wi.status = 'in_progress' AND wi.type = 'chore'"
 ```
 
@@ -485,7 +469,7 @@ Now implementing...
 
 **Then REFACTOR (quick pass, 5 min max):**
 - Extract duplicated code
-- Rename unclear variables  
+- Rename unclear variables
 - Simplify complex expressions
 - Remove dead code
 
@@ -514,32 +498,23 @@ Now implementing...
 
 ---
 
-**CRITICAL: Check if ALL speed mode chores are complete. Stable mode transition happens ONLY after all speed chores are done.**
-
-<!-- ┌─────────────────────────────────────────────────────────────────────────┐
-     │ 🔍 COMPLETION CHECK: Speed Chores                                      │
-     │                                                                         │
-     │ Progress Tracking:                                                      │
-     │ • Query: Count incomplete speed chores for feature                     │
-     │ • Display: "X speed mode chores remaining" or "All complete"           │
-     │ • Action: Generate stable scenarios/steps/chores if all complete       │
-     │                                                                         │
-     │ Return Point:                                                           │
-     │ • CHECKPOINT_CHORE_COUNT: Known incomplete count from last check       │
-     │ • If session interrupted, re-query to get current count                │
-     └─────────────────────────────────────────────────────────────────────────┘ -->
+### Step 6: Route After Chore Completion
+
+**CRITICAL: After GREEN, check if more speed chores remain.**
 
 **Check for incomplete speed chores:**
 
 ```bash
-# Get current work to find parent feature ID
-sqlite3 .jettypod/work.db "SELECT wi.parent_id FROM work_items wi WHERE wi.status = 'in_progress'"
+# Get current work to find parent feature ID and current chore ID
+sqlite3 .jettypod/work.db "SELECT wi.id, wi.parent_id FROM work_items wi WHERE wi.status = 'in_progress'"
 
-# Get list of remaining speed chores (excluding current chore)
+# Count remaining speed chores (excluding current)
 sqlite3 .jettypod/work.db "SELECT id, title FROM work_items WHERE parent_id = <feature-id> AND type = 'chore' AND mode = 'speed' AND status != 'done' AND id != <current-chore-id> ORDER BY created_at LIMIT 1"
 ```
 
-**If speed chores remain, display and start next chore:**
+---
+
+**Route A: More speed chores remain → Start next chore**
 
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -552,237 +527,89 @@ More speed mode chores remain. Starting next chore:
 #[next-chore-id]: [next-chore-title]
 ```
 
-**Then immediately merge current chore and start next:**
+**Merge and start next:**
 
 ```bash
 # Commit changes in the worktree
 git add . && git commit -m "feat: [brief description of what was implemented]"
 
-# Merge current chore - this automatically marks it as done
+# Merge current chore (handles push, merge, cleanup)
 jettypod work merge
 
 # Start next speed chore
 jettypod work start [next-chore-id]
 ```
 
-**CRITICAL: Use ONLY `jettypod work merge` to complete chores.**
-- ❌ DO NOT use `jettypod work status <id> done`
-- ❌ DO NOT use `jettypod work complete <id>`
-- ❌ DO NOT use `jettypod work set-mode <id> done`
-- ✅ ONLY use `jettypod work merge`
-
-The merge command handles everything: pushes branch, merges to main, marks chore done, cleans up worktree.
-
 The speed-mode skill will automatically re-invoke for the next chore.
 
-**If all speed chores are done (count = 0), continue to Step 6 below.**
-
 ---
 
-### Step 6: Transition to Stable Mode (After All Speed Chores Complete)
+**Route B: All speed chores complete → Transition to Step 7**
+
+If the query returns no remaining chores, proceed to Step 7.
 
-**⚡ ASYNC BOUNDARY - Must wait for user to confirm proposed scenarios/chores**
+---
 
-**CRITICAL:** This step ONLY runs after ALL speed chores are complete. This is the transition from speed mode to stable mode.
+### Step 7: Transition to Stable Mode
 
-**Workflow: Merge last chore → Generate scenarios → Generate step definitions → Propose chores → Commit BDD files → Create chores → Set mode to stable → Invoke stable-mode skill**
+**🛑 CRITICAL: This step ONLY runs after ALL speed chores are complete.**
 
-#### Phase 1: Merge Final Speed Chore
+This is the transition from speed mode to stable mode. Follow these phases in order.
 
-**Complete the current (final) speed chore:**
+#### Step 7A: Merge Final Speed Chore
 
 ```bash
 # Commit changes in the worktree
 git add . && git commit -m "feat: [brief description of what was implemented]"
 
-# Merge to main with lock held for transition phase
-# This prevents race conditions when multiple instances generate BDD files simultaneously
+# Merge with transition lock (prevents race conditions during BDD generation)
 jettypod work merge --with-transition
 ```
 
-<details>
-<summary>💡 Why --with-transition? (click to expand)</summary>
-
-The `--with-transition` flag holds the merge lock through the entire BDD generation phase (Phases 2-6).
+After merge, you are on main branch. Ready to generate stable mode scenarios.
 
-**Without this flag:**
-- Instance A merges → generates BDD → appends to step_definitions/auth.steps.js
-- Instance B merges → generates BDD → appends to step_definitions/auth.steps.js (CONFLICT!)
-- Second write can overwrite first write, losing step definitions
+#### Step 7B: Generate and Propose Stable Mode Chores
 
-**With this flag:**
-- Instance A acquires lock → merges → generates BDD → commits → releases lock
-- Instance B waits → acquires lock → merges → generates BDD → commits → releases lock
-- No conflicts, all step definitions preserved
-
-You'll release the lock in Phase 6 after committing BDD files.
-</details>
+**⚡ ASYNC BOUNDARY - Must wait for user confirmation**
 
-**CRITICAL: Use ONLY `jettypod work merge` to complete chores.**
-- ❌ DO NOT use `jettypod work status <id> done`
-- ❌ DO NOT use `jettypod work complete <id>`
-- ❌ DO NOT use `jettypod work set-mode <id> done`
-- ✅ ONLY use `jettypod work merge`
-
-After merge, you are now on main branch. Ready to generate stable mode scenarios.
-
-#### Phase 2: Generate Stable Mode BDD Scenarios
-
-**Your task:** Create BDD scenarios for error handling, edge cases, and validation.
-
-**Read the feature's existing scenario file:**
+**1. Read the feature's scenario file and analyze for stable mode needs:**
 
 ```bash
-# Find the feature's scenario file
-sqlite3 .jettypod/work.db "SELECT id, title FROM work_items WHERE id = <feature-id>"
-# Look for: features/bdd/<epic-slug>/<feature-slug>.feature
+sqlite3 .jettypod/work.db "SELECT id, title, scenario_file FROM work_items WHERE id = <feature-id>"
 ```
 
-**Analysis checklist for new scenarios:**
-
-1. **Error scenarios** - What can go wrong?
-   - Invalid user input (wrong types, out of range, malformed data)
-   - Missing required parameters
-   - System errors (file not found, network errors, database errors)
-   - Permission/authorization failures
-
-2. **Edge case scenarios** - Boundary conditions
-   - Empty inputs (empty strings, empty arrays, null values)
-   - Maximum values (large numbers, long strings, many items)
-   - Minimum values (zero, negative numbers)
-   - Special characters and Unicode
-
-3. **State consistency scenarios** - Data integrity
-   - Concurrent operations (race conditions)
-   - Partial failures (transaction rollbacks)
-   - State transitions (invalid state changes)
-
-**Generate stable scenarios and append to feature file:**
-
-```gherkin
-Scenario: Handle missing required parameter
-  Given the system is initialized
-  When I call the function with missing "name" parameter
-  Then it should throw a validation error
-  And the error message should be "Parameter 'name' is required"
-
-Scenario: Handle empty input
-  Given the system is initialized
-  When I provide an empty string as input
-  Then it should return an appropriate error
-  And the error code should be "INVALID_INPUT"
-
-Scenario: Handle maximum boundary value
-  Given the system is initialized
-  When I provide the maximum allowed value
-  Then it should process successfully
-  And return the expected result
-```
+**2. Generate stable mode BDD scenarios** covering:
+- **Error scenarios** - Invalid input, missing params, system errors, permission failures
+- **Edge cases** - Empty inputs, boundary values, special characters
+- **State consistency** - Concurrent ops, partial failures, invalid state transitions
 
-**Append scenarios to the feature file** (don't overwrite existing speed scenarios):
+**3. Append scenarios to the feature file:**
 
 ```bash
-# Append to existing .feature file
-cat >> features/bdd/<epic-slug>/<feature-slug>.feature << 'EOF'
+cat >> <scenario-file-path> << 'EOF'
 
 # Stable Mode Scenarios - Error Handling and Edge Cases
 
-Scenario: [Title]
+Scenario: [Error scenario title]
   Given [context]
-  When [action]
-  Then [expected behavior]
+  When [error condition]
+  Then [expected error handling]
 
-Scenario: [Title]
+Scenario: [Edge case title]
   Given [context]
-  When [action]
+  When [edge case input]
   Then [expected behavior]
 EOF
 ```
 
-#### Phase 3: Generate Stable Mode Step Definitions
-
-**Your task:** Create step definition files for the new stable scenarios.
+**4. Create step definitions** at `features/step_definitions/<feature-slug>-stable.steps.js`
 
-**Identify new step definitions needed:**
+**5. Present proposal to user:**
 
-1. Read the stable scenarios you just created
-2. Extract unique Given/When/Then steps
-3. Check if step definitions already exist in `features/bdd/<epic-slug>/steps/`
-4. Create new step definition files for missing steps
-
-**Generate step definition files:**
-
-```javascript
-// features/bdd/<epic-slug>/steps/<feature-slug>-stable.steps.js
-
-const { Given, When, Then } = require('@cucumber/cucumber');
-const { expect } = require('chai');
-
-// Error handling steps
-When('I call the function with missing {string} parameter', async function(paramName) {
-  try {
-    // Implementation that calls function without parameter
-    this.error = null;
-  } catch (err) {
-    this.error = err;
-  }
-});
-
-Then('it should throw a validation error', function() {
-  expect(this.error).to.exist;
-  expect(this.error.name).to.equal('ValidationError');
-});
-
-Then('the error message should be {string}', function(expectedMessage) {
-  expect(this.error.message).to.equal(expectedMessage);
-});
-
-// Edge case steps
-When('I provide an empty string as input', async function() {
-  this.result = await this.functionUnderTest('');
-});
-
-When('I provide the maximum allowed value', async function() {
-  this.result = await this.functionUnderTest(Number.MAX_SAFE_INTEGER);
-});
 ```
-
-**Create step definition files:**
-
-```bash
-# Create the step definition file
-touch features/bdd/<epic-slug>/steps/<feature-slug>-stable.steps.js
-# Write the step definitions to the file
-```
-
-#### Phase 4: Analyze Implementation and Propose Stable Mode Chores
-
-**Your task:** Based on the stable scenarios and step definitions, identify what needs to be implemented.
-
-**Analysis checklist:**
-
-1. **Error handling gaps**
-   - What validation needs to be added?
-   - What error types need to be thrown?
-   - What error messages need to be user-friendly?
-
-2. **Edge case handling**
-   - What boundary checks are needed?
-   - What null/undefined checks are missing?
-   - What type validation is needed?
-
-3. **Code that needs refactoring**
-   - What needs better structure for error handling?
-   - What needs logging/debugging support?
-   - What needs better separation of concerns?
-
-**Present your analysis:**
-
-```
-📋 Stable Mode Chores Proposal
+📋 Stable Mode Transition
 
 I've generated [N] stable mode scenarios covering error handling and edge cases.
-I've created step definitions for these scenarios.
 
 Here are the chores needed to make these scenarios pass:
 
@@ -796,96 +623,61 @@ Here are the chores needed to make these scenarios pass:
 - Scope: [What specifically needs to be done]
 - Scenarios: [Which BDD scenarios this addresses]
 
-**Chore 3: [Title]**
-- Why: [What gap this fills]
-- Scope: [What specifically needs to be done]
-- Scenarios: [Which BDD scenarios this addresses]
-
-These chores will make all stable mode scenarios pass with proper error handling and edge case coverage.
-
 Sound good? I'll create these chores once you confirm.
 ```
 
-**WAIT for user confirmation or adjustments.**
-
-If user adjusts: revise chores and confirm again.
-
-#### Phase 5: Create Chores Autonomously
-
-**CRITICAL:** After user confirms, create chores programmatically - no additional permission needed.
-
-**Code to create chores:**
-
-```javascript
-const { create } = require('./features/work-tracking');
-const { getCurrentWork } = require('./lib/current-work');
+**⚡ WAIT for user confirmation or adjustments.**
 
-(async () => {
-  const currentWork = await getCurrentWork();
-  const featureId = currentWork.parent_id; // Parent feature
+#### Step 7C: Create Chores and Complete Transition
 
-  // For each confirmed chore:
-  await create('chore', 'Chore Title', 'Description', featureId, 'stable', false);
-})();
-```
+**After user confirms, execute autonomously:**
 
-**Display results:**
-
-```
-✅ Created [N] stable mode chores
+**1. Create stable mode chores:**
 
-Chores created:
-• #[ID]: [Title]
-• #[ID]: [Title]
-• #[ID]: [Title]
+```bash
+jettypod work create chore "[Chore title]" "[Description with scenarios addressed]" --parent=<feature-id> --mode=stable
 ```
 
-#### Phase 6: Commit Stable Mode Scenarios and Steps to Main
+Repeat for each confirmed chore.
 
-**CRITICAL: Commit the BDD files to main BEFORE starting stable chores.**
+**2. Commit BDD files to main:**
 
 ```bash
-# You're currently on main after merging the last speed chore
-# Commit the stable mode scenarios and step definitions
 git add features/
 git commit -m "test: Add stable mode BDD scenarios and step definitions
 
-Added error handling and edge case scenarios for stable mode implementation.
-
+Added error handling and edge case scenarios for stable mode.
 - [N] new stable mode scenarios
-- Step definitions for validation, error handling, and edge cases"
+- Step definitions for validation and error handling"
 
-# Push to remote
 git push
-
-# Release the merge lock (held since Phase 1)
-jettypod work merge --release-lock
 ```
 
-This ensures stable mode BDD files are in main and will be present in stable chore worktrees.
-
-The merge lock is now released - other instances can proceed with their transitions.
+**3. Release merge lock:**
 
-#### Phase 7: Set Feature Mode to Stable
+```bash
+jettypod work merge --release-lock
+```
 
-**Set the feature mode:**
+**4. Set feature mode to stable:**
 
 ```bash
 jettypod work set-mode <feature-id> stable
 ```
 
-#### Phase 8: Invoke Stable Mode Skill
+#### Step 7D: Invoke Stable Mode Skill
 
-**CRITICAL: Immediately transition to stable-mode skill to start implementing stable chores.**
+**🛑 CRITICAL HANDOFF - You MUST invoke stable-mode using the Skill tool.**
+
+**Display completion message:**
 
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 🎯 Speed Mode Complete! Transitioning to Stable Mode
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-⚠️  CRITICAL: Speed mode is ONLY a checkpoint to prove functionality works.
-The feature is INCOMPLETE without stable mode - error handling, validation,
-edge cases, and comprehensive testing are ALL required.
+⚠️  CRITICAL: Speed mode is ONLY a checkpoint.
+The feature is INCOMPLETE without stable mode.
 
 What we accomplished:
 ✅ All speed mode chores complete
@@ -894,23 +686,13 @@ What we accomplished:
 ✅ Created [N] stable mode chores
 ✅ Feature mode set to stable
 
-🚀 NEVER leave a feature in speed mode.
-Stable mode adds:
-  • Comprehensive error handling and user-friendly error messages
-  • Input validation (null checks, type checks, range validation)
-  • Edge case handling (empty arrays, boundary values, race conditions)
-  • State consistency and data integrity
-  • All BDD scenarios passing (success scenarios + error/edge cases)
-
-**Next step:** I'm now invoking the stable-mode skill to start implementing the first stable chore.
+🚀 Now invoking stable-mode skill...
 ```
 
-**Invoke the stable-mode skill:**
-
-Use the Skill tool to automatically transition to stable mode implementation:
+**Invoke stable-mode:**
 
 ```
-Skill tool with skill="stable-mode"
+Use the Skill tool with skill: "stable-mode"
 ```
 
 The stable-mode skill will:
@@ -920,3 +702,44 @@ The stable-mode skill will:
 
 **End speed-mode skill.**
 
+---
+
+## Validation Checklist
+
+Before ending speed-mode skill, ensure:
+- [ ] All speed mode chores complete (GREEN on all success scenarios)
+- [ ] Stable mode BDD scenarios generated and committed
+- [ ] Step definitions created for stable scenarios
+- [ ] Stable mode chores created
+- [ ] Feature mode set to stable
+- [ ] **stable-mode skill invoked using Skill tool**
+
+---
+
+## Command Reference
+
+**Complete chores:**
+```bash
+jettypod work merge              # Merge current chore to main
+jettypod work merge --with-transition  # Hold lock for transition phase
+jettypod work merge --release-lock     # Release held lock
+```
+
+**Start chores:**
+```bash
+jettypod work start <chore-id>   # Create worktree and start chore
+```
+
+**Create chores:**
+```bash
+jettypod work create chore "<title>" "<description>" --parent=<feature-id> --mode=stable
+```
+
+**Set feature mode:**
+```bash
+jettypod work set-mode <feature-id> stable
+```
+
+**❌ DO NOT use these to complete chores:**
+- `jettypod work status <id> done`
+- `jettypod work complete <id>`