jettypod 4.4.116 → 4.4.120

package/lib/update-command/index.js

@@ -1,7 +1,3 @@
-const { execSync } = require('child_process');
-const https = require('https');
-const fs = require('fs');
-const path = require('path');
 const packageJson = require('../../package.json');
 
 /**
@@ -12,184 +8,22 @@ function getCurrentVersion() {
   return packageJson.version;
 }
 
-/**
- * Check npm registry for latest version
- * @returns {Promise<string>} Latest version from npm
- */
-function getLatestVersion() {
-  return new Promise((resolve, reject) => {
-    const packageName = packageJson.name;
-    const url = `https://registry.npmjs.org/${packageName}/latest`;
-
-    const request = https.get(url, (res) => {
-      let data = '';
-
-      if (res.statusCode !== 200) {
-        reject(new Error(`HTTP ${res.statusCode}`));
-        return;
-      }
-
-      res.on('data', (chunk) => {
-        data += chunk;
-      });
-
-      res.on('end', () => {
-        try {
-          const json = JSON.parse(data);
-          if (!json.version) {
-            reject(new Error('No version found in npm response'));
-            return;
-          }
-          resolve(json.version);
-        } catch (err) {
-          reject(new Error(`Invalid JSON response: ${err.message}`));
-        }
-      });
-    });
-
-    // Set timeout for network request (30 seconds)
-    request.setTimeout(30000, () => {
-      request.destroy();
-      reject(new Error('Request timeout - network too slow'));
-    });
-
-    request.on('error', (err) => {
-      // Provide specific error messages for common network errors
-      if (err.code === 'ENOTFOUND') {
-        reject(new Error('network error - DNS lookup failed (check internet connection)'));
-      } else if (err.code === 'ETIMEDOUT' || err.code === 'ESOCKETTIMEDOUT') {
-        reject(new Error('network error - connection timeout'));
-      } else if (err.code === 'ECONNREFUSED') {
-        reject(new Error('network error - connection refused'));
-      } else if (err.code === 'ECONNRESET') {
-        reject(new Error('network error - connection reset'));
-      } else {
-        reject(err);
-      }
-    });
-  });
-}
-
-/**
- * Update jettypod to latest version using npm
- * @param {string} version - Version to update to (default: latest)
- * @returns {boolean} True if update succeeded
- */
-function updateJettyPod(version = 'latest') {
-  const packageName = packageJson.name;
-  try {
-    console.log(`📦 Installing jettypod@${version}...`);
-
-    // Use npm to update globally
-    execSync(`npm install -g ${packageName}@${version}`, {
-      stdio: 'inherit'
-    });
-
-    // Clear dashboard .next folder to force rebuild with new assets
-    try {
-      const globalRoot = execSync('npm root -g', { encoding: 'utf-8' }).trim();
-      const dashboardNextPath = path.join(globalRoot, 'jettypod', 'apps', 'dashboard', '.next');
-      if (fs.existsSync(dashboardNextPath)) {
-        fs.rmSync(dashboardNextPath, { recursive: true, force: true });
-        console.log('🧹 Cleared dashboard cache');
-      }
-    } catch {
-      // Non-fatal - dashboard will still work, just might use old cache
-    }
-
-    return true;
-  } catch (err) {
-    console.log('');
-    console.error(`❌ Update failed`);
-    console.log('');
-
-    // Provide specific error messages for common failures
-    const errorOutput = err.stderr ? err.stderr.toString() : '';
-
-    if (err.message.includes('EACCES') || err.message.includes('EPERM') ||
-        errorOutput.includes('EACCES') || errorOutput.includes('EPERM')) {
-      console.error('Permission denied - try running with sudo:');
-      console.log(`  sudo npm install -g ${packageName}@${version}`);
-      console.log('');
-      console.error('Or configure npm to use a different directory:');
-      console.log('  mkdir ~/.npm-global');
-      console.log('  npm config set prefix ~/.npm-global');
-      console.log('  export PATH=~/.npm-global/bin:$PATH');
-    } else if (errorOutput.includes('ENOSPC')) {
-      console.error('Not enough disk space to install update');
-      console.log('Free up disk space and try again');
-    } else if (errorOutput.includes('404') || errorOutput.includes('E404')) {
-      console.error(`Version ${version} not found in npm registry`);
-    } else if (errorOutput.includes('network') || errorOutput.includes('ETIMEDOUT') ||
-               errorOutput.includes('ENOTFOUND')) {
-      console.error('Network error during npm install');
-      console.log('Check your internet connection and try again');
-    } else {
-      console.error(`Error details: ${err.message}`);
-    }
-
-    console.log('');
-    console.error('Manual update:');
-    console.log(`  npm install -g ${packageName}@${version}`);
-
-    return false;
-  }
-}
-
 /**
  * Run the update command
- * @param {Object} options - Optional dependencies for testing
- * @param {Function} options.getCurrentVersion - Function to get current version
- * @param {Function} options.getLatestVersion - Function to get latest version
- * @param {Function} options.updateJettyPod - Function to update jettypod
+ * The JettyPod app is the single distribution point — CLI updates ship with app updates.
  */
-async function runUpdate(options = {}) {
-  const _getCurrentVersion = options.getCurrentVersion || getCurrentVersion;
-  const _getLatestVersion = options.getLatestVersion || getLatestVersion;
-  const _updateJettyPod = options.updateJettyPod || updateJettyPod;
-
-  console.log('🔍 Checking for updates...');
-
-  const currentVersion = _getCurrentVersion();
-  console.log(`Current version: ${currentVersion}`);
-
-  let latestVersion;
-  try {
-    latestVersion = await _getLatestVersion();
-  } catch (err) {
-    console.log(`Cannot check for updates: ${err.message}`);
-    console.log('');
-    console.log('You can still manually update with:');
-    console.log(`  npm install -g ${packageJson.name}@latest`);
-    return false;
-  }
-
-  console.log(`Latest version: ${latestVersion}`);
+async function runUpdate() {
+  const currentVersion = getCurrentVersion();
+  console.log(`JettyPod v${currentVersion}`);
   console.log('');
-
-  if (currentVersion === latestVersion) {
-    console.log(`Already on latest version: ${latestVersion}`);
-    return true;
-  }
-
-  console.log(`New version available: ${latestVersion} (current: ${currentVersion})`);
+  console.log('The CLI is bundled with the JettyPod app.');
+  console.log('Updates are delivered automatically through the app.');
   console.log('');
-
-  const success = _updateJettyPod(latestVersion);
-
-  if (success) {
-    console.log('');
-    console.log(`✅ JettyPod updated to ${latestVersion}`);
-    console.log('');
-    return true;
-  }
-
-  return false;
+  console.log('To check for app updates: open JettyPod and it will auto-update.');
+  return true;
 }
 
 module.exports = {
   runUpdate,
-  getCurrentVersion,
-  getLatestVersion,
-  updateJettyPod
+  getCurrentVersion
 };

package/lib/work-commands/index.js

@@ -1148,9 +1148,12 @@ async function cleanupWorktrees(options = {}) {
  * 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
+ * @param {Object} [options] - Cleanup options
+ * @param {boolean} [options.force] - Force cleanup even if worktree is still active (skips merge requirement)
  * @returns {Promise<Object>} Result with success status
  */
-async function cleanupWorkItem(workItemId) {
+async function cleanupWorkItem(workItemId, options = {}) {
+  const { force = false } = options;
   const db = getDb();
   const gitRoot = getGitRoot();
 
@@ -1183,13 +1186,89 @@ async function cleanupWorkItem(workItemId) {
     return { success: true, message: 'No worktree to clean up' };
   }
 
-  if (worktree.status === 'active') {
+  if (worktree.status === 'active' && !force) {
     return Promise.reject(new Error(
       `Worktree for #${workItemId} is still active.\n` +
-      `Run 'jettypod work merge ${workItemId}' first.`
+      `Run 'jettypod work merge ${workItemId}' first, or use --force to skip merge.`
     ));
   }
 
+  // Force cleanup of active worktree — warn about unmerged work
+  if (worktree.status === 'active' && force) {
+    const warnings = [];
+
+    // Check for uncommitted changes in the worktree
+    if (worktree.worktree_path && fs.existsSync(worktree.worktree_path)) {
+      try {
+        const dirtyFiles = execSync('git status --porcelain', {
+          cwd: worktree.worktree_path,
+          stdio: 'pipe'
+        }).toString().trim();
+        if (dirtyFiles) {
+          const fileCount = dirtyFiles.split('\n').length;
+          warnings.push(`${fileCount} uncommitted change${fileCount !== 1 ? 's' : ''}`);
+        }
+      } catch {
+        // Worktree may be in a bad state — not a blocker for force cleanup
+      }
+    }
+
+    // Check for unmerged commits on the branch
+    if (worktree.branch_name) {
+      try {
+        const unmergedLog = execSync(`git log main..${worktree.branch_name} --oneline`, {
+          cwd: gitRoot,
+          stdio: 'pipe'
+        }).toString().trim();
+        if (unmergedLog) {
+          const commitCount = unmergedLog.split('\n').length;
+          warnings.push(`${commitCount} unmerged commit${commitCount !== 1 ? 's' : ''}`);
+        }
+      } catch {
+        // Branch may not exist or may not have diverged — not a blocker
+      }
+    }
+
+    // Display warnings and prompt for confirmation
+    console.log(`\n⚠️  Force cleanup of active worktree for #${workItemId}: ${worktree.title}\n`);
+    if (warnings.length > 0) {
+      console.log(`   This worktree has ${warnings.join(' and ')}.\n   This data will be lost and cannot be recovered easily.\n`);
+    } else {
+      console.log(`   No unmerged commits or uncommitted changes detected.\n`);
+    }
+
+    // Interactive confirmation
+    const confirmed = await new Promise((resolve) => {
+      const readline = require('readline');
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      rl.question('Proceed with force cleanup? (y/N): ', (answer) => {
+        rl.close();
+        resolve(answer.trim().toLowerCase() === 'y');
+      });
+    });
+
+    if (!confirmed) {
+      console.log('Cancelled.');
+      return { success: false, message: 'Force cleanup cancelled by user' };
+    }
+
+    // Update work item status to cancelled
+    await new Promise((resolve, reject) => {
+      db.run(
+        `UPDATE work_items SET status = 'cancelled' WHERE id = ?`,
+        [workItemId],
+        (err) => {
+          if (err) return reject(err);
+          resolve();
+        }
+      );
+    });
+    console.log(`📋 Work item #${workItemId} marked as cancelled`);
+  }
+
   console.log(`Cleaning up worktree for #${workItemId}: ${worktree.title}`);
 
   // Remove git worktree if it exists
@@ -1561,6 +1640,8 @@ async function mergeWork(options = {}) {
     // and should never block branch switching
     const generatedFilesForReset = [
       'cucumber-results.json',
+      'cucumber-results.ndjson',
+      '@rerun.txt',
       'package-lock.json',
       'yarn.lock',
       'pnpm-lock.yaml'
@@ -1700,6 +1781,8 @@ async function mergeWork(options = {}) {
         // Check if all conflicts are in generated files that can be auto-resolved
         const generatedFiles = [
           'cucumber-results.json',
+          'cucumber-results.ndjson',
+          '@rerun.txt',
           'package-lock.json',
           'yarn.lock',
           'pnpm-lock.yaml'
@@ -1902,20 +1985,50 @@ async function mergeWork(options = {}) {
         `Test worktrees (tests/* branches) merge BDD scenarios without completing the feature.`
       ));
     } else {
-      // Chore or bug worktree: mark as done
-      console.log(`Marking ${currentWork.type} as done...`);
-      const completedAt = new Date().toISOString();
-      await new Promise((resolve, reject) => {
-        db.run(
-          `UPDATE work_items SET status = 'done', completed_at = ? WHERE id = ?`,
-          [completedAt, currentWork.id],
-          (err) => {
+      // Chore or bug worktree
+      // Check if this is a standalone kanban-visible item (no parent or parent is epic)
+      let isStandalone = !currentWork.parent_id;
+      if (!isStandalone && currentWork.parent_id) {
+        const parentItem = await new Promise((resolve, reject) => {
+          db.get('SELECT type FROM work_items WHERE id = ?', [currentWork.parent_id], (err, row) => {
             if (err) return reject(err);
-            resolve();
-          }
-        );
-      });
-      console.log(`✅ ${currentWork.type.charAt(0).toUpperCase() + currentWork.type.slice(1)} #${currentWork.id} marked as done`);
+            resolve(row);
+          });
+        });
+        isStandalone = parentItem && parentItem.type === 'epic';
+      }
+
+      if (isStandalone) {
+        // Standalone item: set ready_for_review instead of marking done
+        // Keep status as in_progress so it stays in the In Flight column
+        // User accepts/rejects via the kanban board
+        await new Promise((resolve, reject) => {
+          db.run(
+            `UPDATE work_items SET ready_for_review = 1 WHERE id = ?`,
+            [currentWork.id],
+            (err) => {
+              if (err) return reject(err);
+              resolve();
+            }
+          );
+        });
+        console.log(`✅ ${currentWork.type.charAt(0).toUpperCase() + currentWork.type.slice(1)} #${currentWork.id} ready for review`);
+      } else {
+        // Chore/bug under a feature: mark as done (feature handles the accept flow)
+        console.log(`Marking ${currentWork.type} as done...`);
+        const completedAt = new Date().toISOString();
+        await new Promise((resolve, reject) => {
+          db.run(
+            `UPDATE work_items SET status = 'done', completed_at = ? WHERE id = ?`,
+            [completedAt, currentWork.id],
+            (err) => {
+              if (err) return reject(err);
+              resolve();
+            }
+          );
+        });
+        console.log(`✅ ${currentWork.type.charAt(0).toUpperCase() + currentWork.type.slice(1)} #${currentWork.id} marked as done`);
+      }
     }
 
     // Mark worktree as merged but DON'T delete it yet

package/lib/work-tracking/index.js

@@ -256,6 +256,22 @@ function create(type, title, description = '', parentId = null, mode = null, nee
     }
 
     function continueWithValidatedParent(epicId) {
+      // Read current plan from auth.json for usage tracking
+      let planAtCreation = null;
+      try {
+        const os = require('os');
+        const path = require('path');
+        const fs = require('fs');
+        const authPath = path.join(os.homedir(), 'Library', 'Application Support', 'jettypod', 'auth.json');
+        if (fs.existsSync(authPath)) {
+          const authData = JSON.parse(fs.readFileSync(authPath, 'utf8'));
+          planAtCreation = authData?.user?.plan || 'free';
+        } else {
+          planAtCreation = 'free';
+        }
+      } catch {
+        planAtCreation = 'free';
+      }
 
       // Only features have modes - they start with mode=NULL (no mode until implementation starts)
       // Epics, chores, and bugs don't have modes (always NULL)
@@ -282,8 +298,8 @@ function create(type, title, description = '', parentId = null, mode = null, nee
       // Set phase for features (discovery when mode=NULL, implementation when mode is set, NULL for everything else)
       const phase = type === 'feature' ? (mode ? 'implementation' : 'discovery') : null;
 
-      const sql = `INSERT INTO work_items (type, title, description, parent_id, epic_id, mode, needs_discovery, phase, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`;
-      db.run(sql, [type, title, description, parentId, epicId, mode, needsDiscovery ? 1 : 0, phase, 'backlog'], function(err) {
+      const sql = `INSERT INTO work_items (type, title, description, parent_id, epic_id, mode, needs_discovery, phase, status, plan_at_creation) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
+      db.run(sql, [type, title, description, parentId, epicId, mode, needsDiscovery ? 1 : 0, phase, 'backlog', planAtCreation], function(err) {
         if (err) {
           return reject(err);
         }
@@ -776,31 +792,19 @@ function updateStatus(id, status) {
               return resolve();
             }
 
-            // Auto-close epics when all children are done
+            // Items under epics: set ready_for_review and keep in_progress for accept/reject
             if (parent.type === 'epic') {
-              // Check if all children of this epic are done
-              db.all(
-                'SELECT id, status FROM work_items WHERE parent_id = ?',
-                [parent.id],
-                (err, children) => {
+              // Set ready_for_review on the item and revert to in_progress
+              db.run(
+                'UPDATE work_items SET ready_for_review = 1, status = ?, completed_at = NULL WHERE id = ?',
+                ['in_progress', item.id],
+                (err) => {
                   if (err) {
-                    return resolve();
-                  }
-
-                  const allDone = children.every(child => child.status === 'done');
-                  if (allDone) {
-                    const epicCompletedAt = new Date().toISOString();
-                    db.run('UPDATE work_items SET status = ?, completed_at = ? WHERE id = ?', ['done', epicCompletedAt, parent.id], (err) => {
-                      if (err) {
-                        console.error(`Failed to auto-close epic: ${err.message}`);
-                      } else {
-                        console.log(`✓ Epic #${parent.id} also completed (all children done)`);
-                      }
-                      resolve();
-                    });
+                    console.error(`Failed to set ready_for_review: ${err.message}`);
                   } else {
-                    resolve();
+                    console.log(`✓ Work item #${item.id} ready for review`);
                   }
+                  resolve();
                 }
               );
             }
@@ -838,12 +842,12 @@ function updateStatus(id, status) {
                     }
 
                     if (featureComplete) {
-                      const featureCompletedAt = new Date().toISOString();
-                      db.run('UPDATE work_items SET status = ?, completed_at = ? WHERE id = ?', ['done', featureCompletedAt, parent.id], (err) => {
+                      // Set ready_for_review instead of auto-closing — let user accept/reject
+                      db.run('UPDATE work_items SET ready_for_review = 1 WHERE id = ?', [parent.id], (err) => {
                         if (err) {
-                          console.error(`Failed to auto-close feature: ${err.message}`);
+                          console.error(`Failed to set ready_for_review: ${err.message}`);
                         } else {
-                          console.log(`✓ Feature #${parent.id} completed (all ${featureMode} mode chores done)`);
+                          console.log(`✓ Feature #${parent.id} ready for review (all ${featureMode} mode chores done)`);
                         }
                         resolve();
                       });
@@ -860,6 +864,21 @@ function updateStatus(id, status) {
               resolve();
             }
           });
+        } else if (status === 'done' && !item.parent_id) {
+          // Standalone item (no parent) marked done via CLI
+          // Set ready_for_review and revert to in_progress so user can accept/reject via kanban
+          db.run(
+            'UPDATE work_items SET ready_for_review = 1, status = ?, completed_at = NULL WHERE id = ?',
+            ['in_progress', item.id],
+            (err) => {
+              if (err) {
+                console.error(`Failed to set ready_for_review: ${err.message}`);
+              } else {
+                console.log(`✓ Work item #${item.id} ready for review`);
+              }
+              resolve();
+            }
+          );
         } else {
           resolve();
         }
@@ -1165,25 +1184,46 @@ async function main() {
 
   switch(command) {
     case 'create': {
-      const type = args[0];
-      const title = args[1];
-      const desc = args[2] || '';
+      // Support --from=<file> for truncation-safe creation via JSON file
+      const fromArg = args.find(a => a.startsWith('--from='));
+      let type, title, desc, parentId, mode, needsDiscovery;
 
-      let parentId = null;
-      let mode = null;
-      let needsDiscovery = false;
-
-      args.forEach(arg => {
-        if (arg.startsWith('--parent=')) {
-          parentId = parseInt(arg.split('=')[1]);
-        }
-        if (arg.startsWith('--mode=')) {
-          mode = arg.split('=')[1];
-        }
-        if (arg === '--needs-discovery') {
-          needsDiscovery = true;
+      if (fromArg) {
+        const fs = require('fs');
+        const filePath = fromArg.split('=').slice(1).join('=');
+        try {
+          const raw = fs.readFileSync(filePath, 'utf8');
+          const data = JSON.parse(raw);
+          type = data.type;
+          title = data.title;
+          desc = data.description || '';
+          parentId = data.parent ? parseInt(data.parent) : null;
+          mode = data.mode || null;
+          needsDiscovery = !!data.needsDiscovery;
+        } catch (e) {
+          console.error(`Error reading --from file: ${e.message}`);
+          process.exit(1);
         }
-      });
+      } else {
+        type = args[0];
+        title = args[1];
+        desc = args[2] || '';
+        parentId = null;
+        mode = null;
+        needsDiscovery = false;
+
+        args.forEach(arg => {
+          if (arg.startsWith('--parent=')) {
+            parentId = parseInt(arg.split('=')[1]);
+          }
+          if (arg.startsWith('--mode=')) {
+            mode = arg.split('=')[1];
+          }
+          if (arg === '--needs-discovery') {
+            needsDiscovery = true;
+          }
+        });
+      }
 
       try {
         const newId = await create(type, title, desc, parentId, mode, needsDiscovery);
@@ -1258,7 +1298,7 @@ async function main() {
             LEFT JOIN work_items p ON w.parent_id = p.id
             LEFT JOIN work_items e ON w.epic_id = e.id
             WHERE w.status = 'in_progress'
-            ORDER BY w.id ASC
+            ORDER BY w.ready_for_review DESC, w.id ASC
           `, [], (err, rows) => {
             if (err) return reject(err);
             resolve(rows || []);
@@ -1502,7 +1542,7 @@ async function main() {
               LEFT JOIN work_items p ON w.parent_id = p.id
               LEFT JOIN work_items e ON w.epic_id = e.id
               WHERE w.status = 'in_progress'
-              ORDER BY w.id ASC
+              ORDER BY w.ready_for_review DESC, w.id ASC
             `, [], (err, rows) => {
               if (err) return reject(err);
               resolve(rows || []);

package/lib/worktree-diagnostics.js

@@ -99,7 +99,7 @@ async function runDiagnostics(db, repoPath, options = {}) {
           count: reconcileResults.staleDbEntries.length,
           message: `Found ${reconcileResults.staleDbEntries.length} database entries with missing filesystem directories`,
           details: reconcileResults.staleDbEntries,
-          recommendation: 'Run reconciliation with cleanup=true to mark as corrupted'
+          recommendation: 'Run reconciliation with cleanup=true to mark as cleaned'
         });
       }
 
@@ -192,23 +192,23 @@ async function runDiagnostics(db, repoPath, options = {}) {
 async function checkDatabaseIntegrity(db) {
   const issues = [];
 
-  // Check for corrupted worktrees
-  const corruptedCount = await new Promise((resolve, reject) => {
-    db.get('SELECT COUNT(*) as count FROM worktrees WHERE status = ?', ['corrupted'], (err, row) => {
+  // Check for cleaned worktrees (terminal state — informational only)
+  const cleanedCount = await new Promise((resolve, reject) => {
+    db.get('SELECT COUNT(*) as count FROM worktrees WHERE status = ?', ['cleaned'], (err, row) => {
       if (err) reject(err);
       else resolve(row.count);
     });
   });
 
-  if (corruptedCount > 0) {
+  if (cleanedCount > 0) {
     issues.push({
       severity: SEVERITY.INFO,
       category: 'database',
-      type: 'corrupted_worktrees',
-      count: corruptedCount,
-      message: `Found ${corruptedCount} corrupted worktree(s) in database`,
-      details: { count: corruptedCount },
-      recommendation: 'These worktrees can be safely cleaned up or ignored'
+      type: 'cleaned_worktrees',
+      count: cleanedCount,
+      message: `Found ${cleanedCount} cleaned worktree(s) in database`,
+      details: { count: cleanedCount },
+      recommendation: 'These are historical records — no action needed'
     });
   }
 
@@ -232,7 +232,7 @@ async function checkDatabaseIntegrity(db) {
       count: orphanedWorktrees.length,
       message: `Found ${orphanedWorktrees.length} worktree(s) with missing work items`,
       details: orphanedWorktrees,
-      recommendation: 'Mark these worktrees as corrupted'
+      recommendation: 'Mark these worktrees as cleaned'
     });
   }
 
@@ -265,7 +265,7 @@ async function checkFilesystemHealth(db, repoPath) {
         type: 'missing_worktree_directory',
         message: `Active worktree directory missing: ${worktreePath}`,
         details: { worktree },
-        recommendation: 'Mark worktree as corrupted and recreate if needed'
+        recommendation: 'Mark worktree as cleaned and recreate if needed'
       });
       continue;
     }
@@ -293,7 +293,7 @@ async function checkFilesystemHealth(db, repoPath) {
         type: 'permission_issue',
         message: `Cannot read/write worktree directory: ${worktreePath}`,
         details: { worktree, error: err.message },
-        recommendation: 'Fix directory permissions or mark worktree as corrupted'
+        recommendation: 'Fix directory permissions or mark worktree as cleaned'
       });
     }
   }
@@ -344,11 +344,11 @@ function generateRecommendations(report) {
     });
   }
 
-  if (report.issues.some(i => i.type === 'corrupted_worktrees')) {
+  if (report.issues.some(i => i.type === 'cleaned_worktrees')) {
     recommendations.push({
       priority: 'low',
-      action: 'Clean up corrupted worktree entries from database',
-      reason: 'Keeping database clean improves query performance'
+      action: 'Cleaned worktree entries are historical records',
+      reason: 'No action needed — these are part of the audit trail'
     });
   }
 

package/lib/worktree-facade.js

@@ -117,7 +117,7 @@ async function startWork(workItem, options = {}) {
 /**
  * Stop work on a work item with graceful degradation
  *
- * Attempts to cleanup worktree. If that fails, marks as corrupted and continues.
+ * Attempts to cleanup worktree. If that fails, marks as cleaned and continues.
  *
  * @param {number} worktreeId - Worktree ID (can be null if working in main)
  * @param {Object} options - Optional configuration