jettypod 4.4.66 → 4.4.68

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
@@ -1294,18 +1295,26 @@ switch (command) {
       }
     } else if (subcommand === 'cleanup') {
       const workCommands = require('./lib/work-commands/index.js');
-      const dryRun = args[0] === '--dry-run';
+      const dryRun = args.includes('--dry-run');
+      // Find numeric arg for specific work item cleanup
+      const workItemId = args.find(a => /^\d+$/.test(a)) ? parseInt(args.find(a => /^\d+$/.test(a))) : null;
 
       try {
-        const results = await workCommands.cleanupWorktrees({ dryRun });
-
-        if (results.cleaned === 0 && results.failed === 0) {
-          console.log(`\n${results.message || 'No worktrees needed cleanup'}`);
+        if (workItemId) {
+          // Clean up specific work item's worktree
+          await workCommands.cleanupWorkItem(workItemId);
         } else {
-          console.log(`\n✓ Cleanup complete:`);
-          console.log(`  Cleaned: ${results.cleaned}`);
-          if (results.failed > 0) {
-            console.log(`  Failed: ${results.failed}`);
+          // Batch cleanup of all orphaned worktrees
+          const results = await workCommands.cleanupWorktrees({ dryRun });
+
+          if (results.cleaned === 0 && results.failed === 0) {
+            console.log(`\n${results.message || 'No worktrees needed cleanup'}`);
+          } else {
+            console.log(`\n✓ Cleanup complete:`);
+            console.log(`  Cleaned: ${results.cleaned}`);
+            if (results.failed > 0) {
+              console.log(`  Failed: ${results.failed}`);
+            }
           }
         }
       } catch (err) {

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

@@ -1130,6 +1130,106 @@ async function cleanupWorktrees(options = {}) {
   return results;
 }
 
+/**
+ * Clean up a specific worktree after merge
+ * Should be run from main repo after cd'ing out of the worktree
+ * @param {number} workItemId - The work item ID to clean up
+ * @returns {Promise<Object>} Result with success status
+ */
+async function cleanupWorkItem(workItemId) {
+  const db = getDb();
+  const gitRoot = getGitRoot();
+
+  // Check we're not inside the worktree being deleted
+  const cwd = process.cwd();
+  if (cwd.includes('.jettypod-work')) {
+    return Promise.reject(new Error(
+      `Cannot cleanup from inside a worktree.\n\n` +
+      `Run this first: cd ${gitRoot}`
+    ));
+  }
+
+  // Find the worktree for this work item
+  const worktree = await new Promise((resolve, reject) => {
+    db.get(
+      `SELECT w.id, w.worktree_path, w.branch_name, w.status, wi.title
+       FROM worktrees w
+       JOIN work_items wi ON w.work_item_id = wi.id
+       WHERE w.work_item_id = ?`,
+      [workItemId],
+      (err, row) => {
+        if (err) return reject(err);
+        resolve(row);
+      }
+    );
+  });
+
+  if (!worktree) {
+    console.log(`No worktree found for work item #${workItemId}`);
+    return { success: true, message: 'No worktree to clean up' };
+  }
+
+  if (worktree.status === 'active') {
+    return Promise.reject(new Error(
+      `Worktree for #${workItemId} is still active.\n` +
+      `Run 'jettypod work merge ${workItemId}' first.`
+    ));
+  }
+
+  console.log(`Cleaning up worktree for #${workItemId}: ${worktree.title}`);
+
+  // Remove git worktree if it exists
+  if (worktree.worktree_path && fs.existsSync(worktree.worktree_path)) {
+    try {
+      execSync(`git worktree remove "${worktree.worktree_path}" --force`, {
+        cwd: gitRoot,
+        stdio: 'pipe'
+      });
+      console.log('✅ Removed worktree directory');
+    } catch (err) {
+      console.log(`⚠️  Failed to remove worktree directory: ${err.message}`);
+    }
+  }
+
+  // Delete the branch if it exists
+  if (worktree.branch_name) {
+    try {
+      execSync(`git branch -d "${worktree.branch_name}"`, {
+        cwd: gitRoot,
+        stdio: 'pipe'
+      });
+      console.log('✅ Deleted branch');
+    } catch (err) {
+      // Branch might not exist or might not be fully merged
+      // Try force delete if regular delete failed
+      try {
+        execSync(`git branch -D "${worktree.branch_name}"`, {
+          cwd: gitRoot,
+          stdio: 'pipe'
+        });
+        console.log('✅ Deleted branch (force)');
+      } catch {
+        console.log(`⚠️  Could not delete branch: ${err.message}`);
+      }
+    }
+  }
+
+  // Delete worktree record from database
+  await new Promise((resolve, reject) => {
+    db.run(
+      `DELETE FROM worktrees WHERE id = ?`,
+      [worktree.id],
+      (err) => {
+        if (err) return reject(err);
+        resolve();
+      }
+    );
+  });
+
+  console.log('✅ Worktree cleaned up');
+  return { success: true };
+}
+
 // Re-export getCurrentWork from shared module for backwards compatibility
 // (used by jettypod.js)
 
@@ -1590,49 +1690,32 @@ async function mergeWork(options = {}) {
       );
     });
 
-    // Clean up worktree if it exists
-    if (worktree && worktree.worktree_path && fs.existsSync(worktree.worktree_path)) {
-      // Check if shell CWD is inside the worktree being deleted
-      const shellCwd = process.cwd();
-      const worktreePath = path.resolve(worktree.worktree_path);
-      const cwdWillBeInvalid = shellCwd.startsWith(worktreePath);
-
-      console.log('Cleaning up worktree...');
-      try {
-        // Remove the git worktree
-        execSync(`git worktree remove "${worktree.worktree_path}" --force`, {
-          cwd: gitRoot,
-          stdio: 'pipe'
-        });
-
-        // Delete worktree record from database
-        await new Promise((resolve, reject) => {
-          db.run(
-            `DELETE FROM worktrees WHERE id = ?`,
-            [worktree.id],
-            (err) => {
-              if (err) return reject(err);
-              resolve();
-            }
-          );
-        });
-
-        console.log('✅ Worktree cleaned up');
-
-        // Warn if shell CWD was inside deleted worktree
-        if (cwdWillBeInvalid) {
-          console.log('');
-          console.log('⚠️  Your shell was inside the deleted worktree.');
-          console.log(`   Run this to fix: cd ${gitRoot}`);
-        }
-      } catch (worktreeErr) {
-        console.warn(`Warning: Failed to clean up worktree: ${worktreeErr.message}`);
-        // Non-fatal - continue with merge success
-      }
+    // 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
+    if (worktree && worktree.worktree_path) {
+      await new Promise((resolve, reject) => {
+        db.run(
+          `UPDATE worktrees SET status = 'merged' WHERE id = ?`,
+          [worktree.id],
+          (err) => {
+            if (err) return reject(err);
+            resolve();
+          }
+        );
+      });
     }
 
     console.log(`✅ Work item #${currentWork.id} marked as done`);
 
+    // Instruct user to cleanup worktree separately
+    if (worktree && worktree.worktree_path && fs.existsSync(worktree.worktree_path)) {
+      console.log('');
+      console.log('📁 Worktree preserved. To clean up:');
+      console.log(`   cd ${gitRoot}`);
+      console.log(`   jettypod work cleanup ${currentWork.id}`);
+    }
+
     if (withTransition) {
       // Hold lock for transition phase (BDD generation)
       // Work is done and worktree is cleaned up, but lock is held so no other merges
@@ -1897,46 +1980,11 @@ async function testsMerge(featureId) {
     console.log('⚠️  Failed to push (non-fatal):', err.message);
   }
 
-  // Clean up the worktree
-  // Check if shell CWD is inside the worktree being deleted
-  const shellCwd = process.cwd();
-  const resolvedWorktreePath = path.resolve(worktreePath);
-  const cwdWillBeInvalid = shellCwd.startsWith(resolvedWorktreePath);
-
-  try {
-    execSync(`git worktree remove "${worktreePath}" --force`, {
-      cwd: gitRoot,
-      encoding: 'utf8',
-      stdio: 'pipe'
-    });
-    console.log('✅ Removed worktree directory');
-
-    // Warn if shell CWD was inside deleted worktree
-    if (cwdWillBeInvalid) {
-      console.log('');
-      console.log('⚠️  Your shell was inside the deleted worktree.');
-      console.log(`   Run this to fix: cd ${gitRoot}`);
-    }
-  } catch (err) {
-    console.log('⚠️  Failed to remove worktree (non-fatal):', err.message);
-  }
-
-  // Delete the test branch
-  try {
-    execSync(`git branch -d ${branchName}`, {
-      cwd: gitRoot,
-      encoding: 'utf8',
-      stdio: 'pipe'
-    });
-    console.log('✅ Deleted test branch');
-  } catch (err) {
-    console.log('⚠️  Failed to delete branch (non-fatal):', err.message);
-  }
-
-  // Delete worktree record from database (cleanup complete)
+  // Mark worktree as merged but DON'T delete it yet
+  // This prevents shell CWD corruption when merge is run from inside the worktree
   await new Promise((resolve, reject) => {
     db.run(
-      `DELETE FROM worktrees WHERE id = ?`,
+      `UPDATE worktrees SET status = 'merged' WHERE id = ?`,
       [worktree.id],
       (err) => {
         if (err) return reject(err);
@@ -1954,6 +2002,14 @@ async function testsMerge(featureId) {
   console.log('');
   console.log(`✅ Test worktree for feature #${featureId} merged successfully`);
 
+  // Instruct user to cleanup worktree separately
+  if (fs.existsSync(worktreePath)) {
+    console.log('');
+    console.log('📁 Worktree preserved. To clean up:');
+    console.log(`   cd ${gitRoot}`);
+    console.log(`   jettypod work cleanup ${featureId}`);
+  }
+
   return Promise.resolve();
 }
 
@@ -1962,6 +2018,7 @@ module.exports = {
   stopWork,
   getCurrentWork,
   cleanupWorktrees,
+  cleanupWorkItem,
   mergeWork,
   testsWork,
   testsMerge

package/package.json

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

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

@@ -373,22 +373,23 @@ git commit -m "chore: [brief description]"
 git push
 ```
 
-**🚨 CRITICAL: Shell CWD Corruption Prevention**
+**Merge and cleanup (3 steps):**
 
-The merge will delete the worktree. You must be in the main repo BEFORE merging.
+```bash
+# Step 1: Merge (can run from worktree - it won't delete it)
+jettypod work merge [chore-id]
+```
 
 ```bash
-# First, cd to the main repo (worktrees are in .jettypod-work/ inside main repo)
+# Step 2: cd to main repo
 cd /path/to/main/repo
-
-# Verify you're in the main repo
-pwd && ls .jettypod
-
-# Then merge (pass the work item ID explicitly)
-jettypod work merge [chore-id]
+pwd && ls .jettypod  # verify
 ```
 
-**Why not `cd $(git rev-parse --show-toplevel)/..`?** Inside a worktree, `--show-toplevel` returns the worktree path, not the main repo. Going `..` from there doesn't reach the main repo.
+```bash
+# Step 3: Clean up the worktree (now safe since shell is in main repo)
+jettypod work cleanup [chore-id]
+```
 
 **Display:**
 

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:
@@ -653,8 +653,10 @@ Write your BDD files to:
   <worktree>/features/email-login.feature
   <worktree>/features/step_definitions/email-login.steps.js
 
-When done, cd to main repo and merge:
-  cd /path/to/main/repo && jettypod work tests merge 42
+When done, merge then cleanup:
+  jettypod work tests merge 42
+  cd /path/to/main/repo
+  jettypod work cleanup 42
 ```
 
 **🛑 STOP AND CHECK:** Verify worktree was created successfully. If you see an error, investigate before continuing.
@@ -736,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
@@ -920,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

@@ -613,28 +613,25 @@ More speed mode chores remain. Starting next chore:
 
 **Merge and start next:**
 
-**🚨 CRITICAL: Shell CWD Corruption Prevention**
-
-The merge will delete the worktree. You must be in the main repo BEFORE merging.
-
 ```bash
 # Commit changes in the worktree
 git add . && git commit -m "feat: [brief description of what was implemented]"
 ```
 
 ```bash
-# cd to the main repo first (worktrees are in .jettypod-work/ inside main repo)
-cd /path/to/main/repo
-
-# Verify you're in the main repo
-pwd && ls .jettypod
-
-# Then merge
+# Step 1: Merge (can run from worktree - it won't delete it)
 jettypod work merge [current-chore-id]
 ```
 
 ```bash
-# Start next chore
+# Step 2: cd to main repo
+cd /path/to/main/repo
+pwd && ls .jettypod  # verify
+```
+
+```bash
+# Step 3: Clean up the worktree, then start next chore
+jettypod work cleanup [current-chore-id]
 jettypod work start [next-chore-id]
 ```
 
@@ -674,29 +671,28 @@ npx cucumber-js <scenario-file-path> --name "User can reach" --format progress
 
 #### Step 7B: Merge Final Speed Chore
 
-**🚨 CRITICAL: Shell CWD Corruption Prevention**
-
-The merge will delete the worktree. You must be in the main repo BEFORE merging.
-
 ```bash
 # Commit changes in the worktree
 git add . && git commit -m "feat: [brief description of what was implemented]"
 ```
 
 ```bash
-# cd to the main repo first (worktrees are in .jettypod-work/ inside main repo)
-cd /path/to/main/repo
-
-# Verify you're in the main repo
-pwd && ls .jettypod
-
-# Then merge with transition flag
+# Step 1: Merge with transition flag (can run from worktree - it won't delete it)
 jettypod work merge [current-chore-id] --with-transition
 ```
 
-**Why not `cd $(git rev-parse --show-toplevel)/..`?** Inside a worktree, `--show-toplevel` returns the worktree path, not the main repo. Going `..` from there doesn't reach the main repo.
+```bash
+# Step 2: cd to main repo
+cd /path/to/main/repo
+pwd && ls .jettypod  # verify
+```
+
+```bash
+# Step 3: Clean up the worktree
+jettypod work cleanup [current-chore-id]
+```
 
-After merge, you are on main branch. Ready to generate stable mode scenarios.
+After cleanup, you are on main branch. Ready to generate stable mode scenarios.
 
 #### Step 7C: Generate and Propose Stable Mode Chores
 
@@ -770,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:**
@@ -948,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):**

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

@@ -572,28 +572,25 @@ More stable mode chores remain. Starting next chore:
 
 **Merge and start next:**
 
-**🚨 CRITICAL: Shell CWD Corruption Prevention**
-
-The merge will delete the worktree. You must be in the main repo BEFORE merging.
-
 ```bash
 # Commit changes in the worktree
 git add . && git commit -m "feat: [brief description of error handling added]"
 ```
 
 ```bash
-# cd to the main repo first (worktrees are in .jettypod-work/ inside main repo)
-cd /path/to/main/repo
-
-# Verify you're in the main repo
-pwd && ls .jettypod
-
-# Then merge
+# Step 1: Merge (can run from worktree - it won't delete it)
 jettypod work merge [current-chore-id]
 ```
 
 ```bash
-# Start next chore
+# Step 2: cd to main repo
+cd /path/to/main/repo
+pwd && ls .jettypod  # verify
+```
+
+```bash
+# Step 3: Clean up the worktree, then start next chore
+jettypod work cleanup [current-chore-id]
 jettypod work start [next-chore-id]
 ```
 
@@ -613,21 +610,24 @@ If the query returns no remaining chores, proceed to Step 7.
 
 **First, merge the final stable chore:**
 
-**🚨 CRITICAL: Shell CWD Corruption Prevention**
-
 ```bash
 git add . && git commit -m "feat: [brief description of error handling added]"
 ```
 
 ```bash
-# cd to the main repo first (worktrees are in .jettypod-work/ inside main repo)
-cd /path/to/main/repo
+# Step 1: Merge (can run from worktree - it won't delete it)
+jettypod work merge [current-chore-id]
+```
 
-# Verify you're in the main repo
-pwd && ls .jettypod
+```bash
+# Step 2: cd to main repo
+cd /path/to/main/repo
+pwd && ls .jettypod  # verify
+```
 
-# Then merge
-jettypod work merge [current-chore-id]
+```bash
+# Step 3: Clean up the worktree
+jettypod work cleanup [current-chore-id]
 ```
 
 **Then check project state:**