jettypod 4.4.70 → 4.4.71

package/jettypod.js

@@ -2135,15 +2135,22 @@ switch (command) {
           }
         }
 
-        // Start WebSocket server for real-time updates
+        // Start WebSocket server as background process for real-time updates
         const WS_PORT = 8080;
         const { getDbPath } = require('./lib/database');
-        try {
-          await wsServer.start(WS_PORT, { dbPath: getDbPath() });
-        } catch (err) {
-          // WebSocket server failed to start (port in use?) - continue without it
-          console.log('⚠️  WebSocket server unavailable (real-time updates disabled)');
-        }
+        const wsServerScript = `
+          const wsServer = require('./lib/ws-server');
+          const { getDbPath } = require('./lib/database');
+          wsServer.start(${WS_PORT}, { dbPath: getDbPath() })
+            .catch(() => process.exit(1));
+        `;
+        const wsProcess = spawn('node', ['-e', wsServerScript], {
+          cwd: __dirname,
+          detached: true,
+          stdio: 'ignore',
+          env: { ...process.env, JETTYPOD_PROJECT_PATH: process.cwd() }
+        });
+        wsProcess.unref();
 
         // Start dashboard in background with project path
         console.log('🚀 Starting dashboard...');

package/lib/work-commands/index.js

@@ -1665,20 +1665,10 @@ async function mergeWork(options = {}) {
   
     console.log(`✓ Successfully merged work item #${currentWork.id}`);
 
-    // Mark work item as done
-    console.log('Marking work item as done...');
-    await new Promise((resolve, reject) => {
-      db.run(
-        `UPDATE work_items SET status = 'done', completed_at = datetime('now') WHERE id = ?`,
-        [currentWork.id],
-        (err) => {
-          if (err) return reject(err);
-          resolve();
-        }
-      );
-    });
+    // Check if this is a test worktree (tests/ prefix) - only set scenario_file, don't mark done
+    const isTestWorktree = currentBranch.startsWith('tests/');
 
-    // Get worktree info from database
+    // Get worktree info from database (needed for cleanup message)
     const worktree = await new Promise((resolve, reject) => {
       db.get(
         `SELECT id, worktree_path, branch_name FROM worktrees WHERE work_item_id = ? AND status = 'active'`,
@@ -1690,6 +1680,65 @@ async function mergeWork(options = {}) {
       );
     });
 
+    if (isTestWorktree) {
+      // Test worktree: set scenario_file but don't mark feature as done
+      console.log('📝 Test worktree detected - setting scenario_file only');
+
+      // Find and set scenario_file on the feature
+      try {
+        const addedFiles = execSync(`git diff --name-only --diff-filter=A HEAD~1 HEAD`, {
+          cwd: gitRoot,
+          encoding: 'utf8',
+          stdio: 'pipe'
+        }).trim();
+
+        const featureFiles = addedFiles
+          .split('\n')
+          .filter(f => f.endsWith('.feature') && f.startsWith('features/'));
+
+        if (featureFiles.length > 0) {
+          const scenarioFile = featureFiles[0];
+          await new Promise((resolve, reject) => {
+            db.run(
+              `UPDATE work_items SET scenario_file = ? WHERE id = ?`,
+              [scenarioFile, currentWork.id],
+              (err) => {
+                if (err) return reject(err);
+                resolve();
+              }
+            );
+          });
+          console.log(`✅ Set scenario_file: ${scenarioFile}`);
+        }
+      } catch (err) {
+        console.log('⚠️  Could not auto-detect scenario file:', err.message);
+      }
+
+      console.log(`✅ BDD tests merged for feature #${currentWork.id}`);
+      console.log('   Feature remains in discovery phase - create chores to continue');
+    } else if (currentWork.type !== 'chore') {
+      // Non-test branch for a non-chore - this shouldn't happen
+      return Promise.reject(new Error(
+        `Cannot merge ${currentWork.type} #${currentWork.id} directly.\n\n` +
+        `Only chores can be merged. Features complete when all their chores are done.\n` +
+        `Test worktrees (tests/* branches) merge BDD scenarios without completing the feature.`
+      ));
+    } else {
+      // Chore worktree: mark as done (existing behavior)
+      console.log('Marking chore as done...');
+      await new Promise((resolve, reject) => {
+        db.run(
+          `UPDATE work_items SET status = 'done', completed_at = datetime('now') WHERE id = ?`,
+          [currentWork.id],
+          (err) => {
+            if (err) return reject(err);
+            resolve();
+          }
+        );
+      });
+      console.log(`✅ Chore #${currentWork.id} marked as done`);
+    }
+
     // Mark worktree as merged but DON'T delete it yet
     // This prevents shell CWD corruption when merge is run from inside the worktree
     // User must run `jettypod work cleanup` separately after cd'ing to main repo
@@ -1706,8 +1755,6 @@ async function mergeWork(options = {}) {
       });
     }
 
-    console.log(`✅ Work item #${currentWork.id} marked as done`);
-
     // Instruct user to cleanup worktree separately - be aggressive so AI doesn't forget
     if (worktree && worktree.worktree_path && fs.existsSync(worktree.worktree_path)) {
       console.log('');

package/lib/work-tracking/index.js

@@ -764,6 +764,13 @@ function setBranch(id, branch) {
   });
 }
 
+// Set scenario file
+function setScenario(id, scenarioFile) {
+  db.run(`UPDATE work_items SET scenario_file = ? WHERE id = ?`, [scenarioFile, id], () => {
+    console.log(`Set #${id} scenario_file to ${scenarioFile}`);
+  });
+}
+
 // Set mode
 function setMode(id, mode) {
   return new Promise((resolve, reject) => {
@@ -1584,6 +1591,13 @@ async function main() {
       break;
     }
 
+    case 'set-scenario': {
+      const id = parseInt(args[0]);
+      const file = args[1];
+      setScenario(id, file);
+      break;
+    }
+
     case 'current': {
       if (!args[0]) {
         // No ID provided - show current work
@@ -2426,6 +2440,9 @@ Commands:
   jettypod work set-mode <id> <mode>
     Set mode (speed/discovery/stable/production)
 
+  jettypod work set-scenario <id> <file>
+    Set scenario_file for a feature (e.g., features/my-feature.feature)
+
   jettypod work current <id>
     Set as current work item
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jettypod",
-  "version": "4.4.70",
+  "version": "4.4.71",
   "description": "AI-powered development workflow manager with TDD, BDD, and automatic test generation",
   "main": "jettypod.js",
   "bin": {

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

@@ -0,0 +1,392 @@
+---
+name: bug-mode
+description: Guide implementation of standalone chores with type-appropriate guidance, verification steps, and test handling. Receives enriched context from chore-planning and executes with iteration until verification passes.
+---
+
+# Bug Mode Skill
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  Bug Fix Flow                                                       │
+│                                                                     │
+│  Bug Planning → [BUG MODE] → Done                                   │
+│                 ▲▲▲▲▲▲▲▲▲▲                                          │
+│                 YOU ARE HERE                                        │
+│                                                                     │
+│  Single pass: Covers speed through stable (internal) or             │
+│               through production (external) comprehensively.        │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+## Key Difference from Feature Modes
+
+**Bug fixes do NOT follow speed → stable → production progression.**
+
+- **Features:** Iterative refinement (speed makes it work, stable makes it robust, production makes it scalable)
+- **Bugs:** Single comprehensive fix (fix the root cause properly the first time)
+
+Why? A bug fix should:
+1. Fix the root cause completely
+2. Include proper error handling from the start
+3. Pass the regression test
+4. Be production-ready immediately
+
+---
+
+Guides Claude Code through comprehensive bug fix implementation. Receives context from bug-planning skill (root cause, breadcrumbs, regression test).
+
+## Instructions
+
+When this skill is activated, you are implementing a bug fix chore. The bug-planning skill has already:
+- Identified root cause
+- Created the bug work item and fix chore
+- Written a regression test (currently failing)
+- Started the worktree with `work start`
+
+Your job: Make the regression test pass with a comprehensive fix.
+
+## 🔑 Critical Context
+
+**You are working in an isolated git worktree:**
+- `work start [chore-id]` already created a dedicated worktree
+- All file operations must use **absolute paths** from the worktree
+- The worktree has its own branch - changes are isolated from main
+
+**Worktree path is available in Step 0 output** - use it for all file operations.
+
+---
+
+## 🚨 SHELL CWD RECOVERY
+
+**If ALL bash commands start failing with "Error: Exit code 1" and no output:**
+
+Your shell's working directory was likely inside a worktree that was deleted. The CWD no longer exists.
+
+**Recovery steps:**
+1. Get the main repo path from your session context
+2. Run: `cd <main-repo-path>`
+3. Verify: `pwd && ls .jettypod`
+4. Resume your work
+
+---
+
+## 🛑 PRE-FLIGHT VALIDATION (REQUIRED)
+
+**Before proceeding, validate the worktree exists.**
+
+```bash
+sqlite3 .jettypod/work.db "SELECT wi.id, wi.title, wi.status, wt.worktree_path, wt.branch_name FROM work_items wi LEFT JOIN worktrees wt ON wi.id = wt.work_item_id WHERE wi.status = 'in_progress' AND wi.type = 'chore'"
+```
+
+**Check the result:**
+
+| worktree_path | What it means | Action |
+|---------------|---------------|--------|
+| **Has a path** | ✅ Worktree exists, ready to proceed | Continue to Step 0 |
+| **NULL or empty** | ❌ `work start` was not called | **STOP - run `jettypod work start [chore-id]` first** |
+| **No rows returned** | ❌ No chore is in progress | **STOP - verify the chore exists and run `work start`** |
+
+---
+
+## Implementation Steps
+
+### Step 0: Initialize Bug Mode Context
+
+**Get the current work context:**
+
+```bash
+sqlite3 .jettypod/work.db "SELECT wi.id, wi.title, wi.description, wi.parent_id, parent.title as parent_title, parent.type as parent_type, wt.worktree_path, wt.branch_name FROM work_items wi LEFT JOIN work_items parent ON wi.parent_id = parent.id LEFT JOIN worktrees wt ON wi.id = wt.work_item_id WHERE wi.status = 'in_progress' AND wi.type = 'chore'"
+```
+
+**Verify parent is a bug:**
+- `parent_type` should be `bug`
+- If not, this skill may not be appropriate
+
+**Extract breadcrumbs from chore description:**
+The bug-planning skill embedded implementation guidance:
+- Root cause location (file:line)
+- Fix approach (steps)
+- Files to modify
+- Verification criteria
+
+**Display to user:**
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🐛 BUG MODE: Fixing #[bug-id]
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Chore: [title]
+Bug: #[parent-id] [parent-title]
+Worktree: [worktree_path]
+Branch: [branch_name]
+
+Root Cause:
+[From breadcrumbs - what's broken and where]
+
+Fix Approach:
+[From breadcrumbs - steps to fix]
+
+Establishing RED baseline...
+```
+
+**Proceed to Step 1.**
+
+---
+
+### Step 1: Establish RED Baseline
+
+**Run the regression test to confirm it fails:**
+
+```bash
+# Find the regression test file
+sqlite3 .jettypod/work.db "SELECT id FROM work_items WHERE id = <bug-id>"
+# Look for features/*<bug-id>*.feature or features/*<bug-slug>*.feature
+```
+
+```bash
+# Run the regression test
+npx cucumber-js features/<bug-slug>.feature --format progress
+```
+
+**Confirm RED state:**
+- The regression test should FAIL
+- This proves the bug exists and the test catches it
+
+**Display RED baseline:**
+
+```
+🔴 RED Baseline Confirmed
+
+Regression test: features/<bug-slug>.feature
+Status: FAILING (as expected)
+
+Error:
+[Error message from test]
+
+🎯 Goal: Make the regression test pass with a comprehensive fix
+
+Now implementing fix...
+```
+
+**Proceed to Step 2.**
+
+---
+
+### Step 2: Implement Comprehensive Fix
+
+**CRITICAL:** Bug fixes must be comprehensive from the start.
+
+**Use breadcrumbs to guide implementation:**
+1. Navigate to the root cause location
+2. Understand the surrounding code
+3. Implement the fix following the approach from bug-planning
+4. Add proper error handling (don't just fix the happy path)
+5. Consider edge cases related to the bug
+
+**What "comprehensive" means:**
+
+**INTERNAL projects (project_state = 'internal'):**
+- Fix the root cause
+- Add validation to prevent the bug condition
+- Handle the error gracefully if it somehow occurs
+- Ensure related edge cases are covered
+
+**EXTERNAL projects (project_state = 'external'):**
+- Everything for internal, PLUS:
+- Consider security implications
+- Add logging for debugging
+- Ensure graceful degradation
+- Consider concurrent access if relevant
+
+**Check project state:**
+
+```bash
+sqlite3 .jettypod/work.db "SELECT project_state FROM project_config WHERE id = 1"
+```
+
+**Implement iteratively:**
+
+```
+━━━ Iteration 1 ━━━
+📂 Reading: [file:line from breadcrumbs]
+🔧 Change: [what you're fixing]
+```
+
+**After each change, run the regression test:**
+
+```bash
+npx cucumber-js features/<bug-slug>.feature --format progress
+```
+
+**Track progress:**
+
+```
+━━━ Iteration 2 ━━━
+🧪 Running regression test...
+📊 Status: Still failing
+🔧 Next: [what else needs to change]
+```
+
+**Continue until GREEN:**
+
+```
+🎉 GREEN: Regression test passing!
+
+Fix implemented:
+- [Change 1]
+- [Change 2]
+- [Error handling added]
+
+Now verifying no regressions...
+```
+
+**Proceed to Step 3.**
+
+---
+
+### Step 3: Verify No Regressions
+
+**Run the full test suite to ensure the fix didn't break anything:**
+
+```bash
+# Run all BDD tests
+npx cucumber-js --format progress
+
+# Run unit tests if they exist
+npm test 2>/dev/null || echo "No unit tests configured"
+```
+
+**If regressions found:**
+
+```
+⚠️ Regression Detected
+
+Failing test: [test name]
+Error: [error message]
+
+Investigating...
+```
+
+Fix the regression and re-run tests. Iterate until all tests pass.
+
+**When all tests pass:**
+
+```
+✅ All Tests Passing
+
+- Regression test: ✅ PASS
+- Other BDD tests: ✅ [X] scenarios passing
+- Unit tests: ✅ [Y] tests passing (if applicable)
+
+Ready to commit and merge.
+```
+
+**Proceed to Step 4.**
+
+---
+
+### Step 4: Commit and Merge
+
+**Commit the fix:**
+
+```bash
+git add . && git commit -m "fix: [Brief description of the bug fix]
+
+Root cause: [What was broken]
+Fix: [What was changed]
+
+Closes #<bug-id>
+
+🤖 Generated with [Claude Code](https://claude.com/claude-code)
+
+Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
+```
+
+**Merge (3 steps):**
+
+```bash
+# Step 1: Merge (can run from worktree - it won't delete it)
+jettypod work merge
+```
+
+```bash
+# Step 2: cd to main repo
+cd <main-repo-path>
+pwd && ls .jettypod  # verify
+```
+
+```bash
+# Step 3: Clean up the worktree
+jettypod work cleanup <chore-id>
+```
+
+**Proceed to Step 5.**
+
+---
+
+### Step 5: Mark Bug as Done
+
+**After the fix chore is merged, mark the parent bug as done:**
+
+```bash
+jettypod work status <bug-id> done
+```
+
+**Display completion:**
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ Bug Fix Complete
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🐛 Bug: #[bug-id] [title]
+🔧 Fix: #[chore-id] [title]
+🧪 Regression test: ✅ Passing
+
+What was fixed:
+- Root cause: [brief description]
+- Fix: [what changed]
+- Prevention: [validation/error handling added]
+
+The bug is now fixed and protected by a regression test.
+```
+
+**End bug-mode skill.**
+
+---
+
+## Validation Checklist
+
+Before ending bug-mode skill, ensure:
+- [ ] Regression test was failing (RED baseline confirmed)
+- [ ] Fix implemented comprehensively (not just happy path)
+- [ ] Regression test now passes (GREEN)
+- [ ] No other tests broken (no regressions)
+- [ ] Fix committed with descriptive message
+- [ ] Chore merged to main
+- [ ] Worktree cleaned up
+- [ ] Bug marked as done
+
+---
+
+## Command Reference
+
+**Merge fix (CRITICAL: cd to main repo separately):**
+```bash
+jettypod work merge              # Merge current chore
+```
+
+```bash
+cd <main-repo>                   # Change to main repo
+jettypod work cleanup <id>       # Clean up worktree
+```
+
+**Mark bug complete:**
+```bash
+jettypod work status <bug-id> done
+```
+
+**❌ DO NOT use these to complete chores:**
+- `jettypod work status <chore-id> done`
+- `jettypod work complete <id>`