jettypod 4.4.67 → 4.4.69

package/jettypod.js

@@ -270,6 +270,7 @@ jettypod work create feature "<title>" --parent=<id>
 jettypod work create chore "<title>" --parent=<id>
 jettypod work start <id>              # Creates worktree branch
 jettypod work merge                   # Merges worktree back to main
+jettypod work cleanup <id>            # Cleanup worktree after merge
 jettypod work tests <feature-id>      # Create test worktree for BDD
 jettypod work tests merge <id>        # Merge tests to main
 jettypod work status <id> cancelled

package/lib/migrations/018-worktrees-merged-status.js

@@ -0,0 +1,148 @@
+/**
+ * Migration: Add 'merged' status to worktrees table
+ *
+ * Purpose: Support separating merge from cleanup - worktrees stay after merge
+ * until explicitly cleaned up. This prevents shell CWD corruption when merge
+ * is run from inside the worktree.
+ *
+ * SQLite doesn't support ALTER CONSTRAINT, so we need to recreate the table.
+ */
+
+module.exports = {
+  id: '018-worktrees-merged-status',
+  description: 'Add merged status to worktrees table for separate cleanup step',
+
+  async up(db) {
+    return new Promise((resolve, reject) => {
+      db.serialize(() => {
+        // 1. Create new table with updated constraint
+        db.run(`
+          CREATE TABLE IF NOT EXISTS worktrees_new (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            work_item_id INTEGER NOT NULL,
+            branch_name TEXT NOT NULL,
+            worktree_path TEXT NOT NULL,
+            status TEXT NOT NULL CHECK(status IN ('active', 'merging', 'merged', 'cleanup_pending', 'corrupted')),
+            created_at TEXT NOT NULL DEFAULT (datetime('now')),
+            updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+            FOREIGN KEY (work_item_id) REFERENCES work_items(id)
+          )
+        `, (err) => {
+          if (err) return reject(err);
+        });
+
+        // 2. Copy data from old table
+        db.run(`
+          INSERT INTO worktrees_new (id, work_item_id, branch_name, worktree_path, status, created_at, updated_at)
+          SELECT id, work_item_id, branch_name, worktree_path, status, created_at, updated_at
+          FROM worktrees
+        `, (err) => {
+          if (err) return reject(err);
+        });
+
+        // 3. Drop old indexes
+        db.run('DROP INDEX IF EXISTS idx_worktrees_work_item_id', (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run('DROP INDEX IF EXISTS idx_worktrees_status', (err) => {
+          if (err) return reject(err);
+        });
+
+        // 4. Drop old table
+        db.run('DROP TABLE worktrees', (err) => {
+          if (err) return reject(err);
+        });
+
+        // 5. Rename new table
+        db.run('ALTER TABLE worktrees_new RENAME TO worktrees', (err) => {
+          if (err) return reject(err);
+        });
+
+        // 6. Recreate indexes
+        db.run(`
+          CREATE INDEX idx_worktrees_work_item_id
+          ON worktrees(work_item_id)
+        `, (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run(`
+          CREATE INDEX idx_worktrees_status
+          ON worktrees(status)
+        `, (err) => {
+          if (err) return reject(err);
+          resolve();
+        });
+      });
+    });
+  },
+
+  async down(db) {
+    // Reverse migration - remove 'merged' status
+    // Any rows with 'merged' status will fail the constraint, so convert them first
+    return new Promise((resolve, reject) => {
+      db.serialize(() => {
+        // Convert any 'merged' status to 'cleanup_pending'
+        db.run(`UPDATE worktrees SET status = 'cleanup_pending' WHERE status = 'merged'`, (err) => {
+          if (err) return reject(err);
+        });
+
+        // Create table without 'merged' in constraint
+        db.run(`
+          CREATE TABLE IF NOT EXISTS worktrees_new (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            work_item_id INTEGER NOT NULL,
+            branch_name TEXT NOT NULL,
+            worktree_path TEXT NOT NULL,
+            status TEXT NOT NULL CHECK(status IN ('active', 'merging', 'cleanup_pending', 'corrupted')),
+            created_at TEXT NOT NULL DEFAULT (datetime('now')),
+            updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+            FOREIGN KEY (work_item_id) REFERENCES work_items(id)
+          )
+        `, (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run(`
+          INSERT INTO worktrees_new (id, work_item_id, branch_name, worktree_path, status, created_at, updated_at)
+          SELECT id, work_item_id, branch_name, worktree_path, status, created_at, updated_at
+          FROM worktrees
+        `, (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run('DROP INDEX IF EXISTS idx_worktrees_work_item_id', (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run('DROP INDEX IF EXISTS idx_worktrees_status', (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run('DROP TABLE worktrees', (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run('ALTER TABLE worktrees_new RENAME TO worktrees', (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run(`
+          CREATE INDEX idx_worktrees_work_item_id
+          ON worktrees(work_item_id)
+        `, (err) => {
+          if (err) return reject(err);
+        });
+
+        db.run(`
+          CREATE INDEX idx_worktrees_status
+          ON worktrees(status)
+        `, (err) => {
+          if (err) return reject(err);
+          resolve();
+        });
+      });
+    });
+  }
+};

package/lib/work-commands/index.js

@@ -1708,12 +1708,15 @@ async function mergeWork(options = {}) {
 
     console.log(`✅ Work item #${currentWork.id} marked as done`);
 
-    // Instruct user to cleanup worktree separately
+    // 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('');
-      console.log('📁 Worktree preserved. To clean up:');
+      console.log('⚠️  CLEANUP REQUIRED - Run these commands NOW:');
+      console.log('');
       console.log(`   cd ${gitRoot}`);
       console.log(`   jettypod work cleanup ${currentWork.id}`);
+      console.log('');
+      console.log('   Worktrees accumulate until cleaned up.');
     }
 
     if (withTransition) {
@@ -2002,12 +2005,15 @@ async function testsMerge(featureId) {
   console.log('');
   console.log(`✅ Test worktree for feature #${featureId} merged successfully`);
 
-  // Instruct user to cleanup worktree separately
+  // Instruct user to cleanup worktree separately - be aggressive so AI doesn't forget
   if (fs.existsSync(worktreePath)) {
     console.log('');
-    console.log('📁 Worktree preserved. To clean up:');
+    console.log('⚠️  CLEANUP REQUIRED - Run these commands NOW:');
+    console.log('');
     console.log(`   cd ${gitRoot}`);
     console.log(`   jettypod work cleanup ${featureId}`);
+    console.log('');
+    console.log('   Worktrees accumulate until cleaned up.');
   }
 
   return Promise.resolve();

package/package.json

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

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

@@ -19,7 +19,7 @@ When this skill is activated, you are helping discover the best approach for a f
 |---------|----------|------|-------|
 | `work implement <feature-id>` | Transition feature to implementation phase | After chores created (Step 8C) | Feature Planning |
 | `work tests start <feature-id>` | Create worktree for test authoring | After transition (Step 8D) | Feature Planning |
-| `cd <main-repo> && work tests merge <feature-id>` | Merge tests to main, cleanup worktree | After tests validated (Step 8D) | Feature Planning |
+| `work tests merge` → `cd` → `work cleanup` | Merge tests to main, then cleanup worktree | After tests validated (Step 8D) | Feature Planning |
 | `work start <chore-id>` | Start implementing a specific chore | After tests merged (Step 8E) | Speed Mode |
 
 **CRITICAL:** All commands are run by **Claude**, not the user. The distinction is:
@@ -738,21 +738,29 @@ sqlite3 .jettypod/work.db "UPDATE work_items SET scenario_file = 'features/${FEA
 
 **Sub-step 5: Merge tests to main**
 
-**⚠️ CRITICAL: The merge will delete the worktree.** Your shell is currently inside it. Chain commands to ensure shell is in main repo BEFORE deletion:
+**Merge and cleanup (3 steps):**
 
 ```bash
-# CRITICAL: cd to main repo AND merge in SAME command
-# This ensures shell is in main repo BEFORE worktree deletion
-cd <main-repo-path> && jettypod work tests merge ${FEATURE_ID}
+# Step 1: Merge tests (can run from worktree - it won't delete it)
+jettypod work tests merge ${FEATURE_ID}
 ```
 
-If you run the merge while your shell is in the worktree, subsequent commands will fail with "No such file or directory".
+```bash
+# Step 2: cd to main repo
+cd <main-repo-path>
+pwd && ls .jettypod  # verify
+```
+
+```bash
+# Step 3: Clean up the worktree (now safe since shell is in main repo)
+jettypod work cleanup ${FEATURE_ID}
+```
 
 This will:
 - Commit changes in the worktree
 - Merge to main
 - Push to remote
-- Clean up the worktree
+- Mark worktree as merged (cleanup is separate)
 
 **🛑 STOP AND CHECK:** Verify merge succeeded:
 - ✅ "Tests merged to main" → Proceed to Step 8E
@@ -922,6 +930,6 @@ Before completing feature planning, ensure:
 - [ ] **Test worktree created** with `work tests start` (Step 8D)
 - [ ] **BDD files written** in worktree (Step 8D)
 - [ ] **BDD infrastructure validated** with dry-run (Step 8D)
-- [ ] **Tests merged to main** with `cd <main-repo> && work tests merge` (Step 8D)
+- [ ] **Tests merged to main** with `work tests merge` → `cd` → `work cleanup` (Step 8D)
 - [ ] First chore started with `work start [chore-id]` (Step 8E)
 - [ ] **Speed-mode skill invoked using Skill tool** (Step 8E)

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

@@ -766,20 +766,22 @@ Added error handling and edge case scenarios for stable mode.
 - Step definitions for validation and error handling"
 ```
 
+**Merge and cleanup (3 steps):**
+
 ```bash
-# CRITICAL: cd to main repo AND merge in SAME command
-# This ensures shell is in main repo BEFORE worktree deletion
-cd <main-repo-path> && jettypod work tests merge <feature-id>
+# Step 1: Merge tests (can run from worktree - it won't delete it)
+jettypod work tests merge <feature-id>
 ```
 
 ```bash
-# MANDATORY: Verify shell is in main repo (run this immediately after merge)
-pwd && ls .jettypod
+# Step 2: cd to main repo
+cd <main-repo-path>
+pwd && ls .jettypod  # verify
 ```
 
-**If you see "No such file or directory" errors:** Your shell CWD was corrupted. Run:
 ```bash
-cd <main-repo-path>
+# Step 3: Clean up the worktree (now safe since shell is in main repo)
+jettypod work cleanup <feature-id>
 ```
 
 **7. Present proposal to user:**
@@ -944,8 +946,9 @@ jettypod work start <chore-id>   # Create worktree and start chore
 **Create test worktree (for writing BDD scenarios):**
 ```bash
 jettypod work tests <feature-id>        # Create worktree for writing tests
-# CRITICAL: cd to main repo BEFORE merge (worktree will be deleted)
-cd <main-repo> && jettypod work tests merge <feature-id>
+jettypod work tests merge <feature-id>  # Merge tests (preserves worktree)
+cd <main-repo>                          # cd to main repo
+jettypod work cleanup <feature-id>      # Clean up worktree
 ```
 
 **Set feature mode (BEFORE creating chores):**