jettypod 4.4.19 → 4.4.22

package/lib/work-tracking/index.js

@@ -0,0 +1,2396 @@
+#!/usr/bin/env node
+
+// Speed Mode implementation - ship in 2 hours!
+// Just the essentials from our prototype
+
+const sqlite3 = require('sqlite3').verbose();
+const { getDb, closeDb, dbPath, waitForMigrations } = require('../../lib/database');
+const { getCurrentWork } = require('../../lib/current-work');
+const { TYPE_EMOJIS, STATUS_EMOJIS } = require('../../lib/constants');
+const { wrapText, getTerminalWidth, getVisualWidth } = require('../../lib/text-wrapper');
+
+const db = getDb();
+
+/**
+ * Find epic by traversing parent_id chain
+ * @param {number} itemId - Work item ID to start from
+ * @returns {Promise<Object|null>} Epic work item or null
+ */
+function findEpic(itemId) {
+  return new Promise((resolve, reject) => {
+    function traverse(currentId) {
+      if (!currentId) {
+        return resolve(null);
+      }
+
+      db.get('SELECT id, type, title, parent_id FROM work_items WHERE id = ?', [currentId], (err, item) => {
+        if (err) {
+          return reject(new Error(`Failed to find epic: ${err.message}`));
+        }
+        if (!item) {
+          return resolve(null);
+        }
+        if (item.type === 'epic') {
+          return resolve({ id: item.id, title: item.title });
+        }
+        traverse(item.parent_id);
+      });
+    }
+
+    traverse(itemId);
+  });
+}
+
+// Create work item
+function create(type, title, description = '', parentId = null, mode = null, needsDiscovery = false) {
+  return new Promise((resolve, reject) => {
+    // Validate project discovery is not blocking work creation
+    if (type === 'epic' || type === 'feature') {
+      const config = require('../../lib/config');
+      const currentConfig = config.read();
+      const discovery = currentConfig.project_discovery;
+
+      if (discovery && discovery.status === 'in_progress') {
+        return reject(new Error(`Cannot create ${type}s while project discovery is in progress.\n\nProject discovery must be completed first.\n\nComplete discovery with:\n  jettypod project discover complete --winner=<path> --rationale="<reason>"\n\nOr talk to Claude Code to continue the discovery conversation.`));
+      }
+    }
+
+    // Validate needs_discovery flag is only used for epics
+    if (needsDiscovery && type !== 'epic') {
+      return reject(new Error(`The --needs-discovery flag can only be used with epic work items`));
+    }
+
+    // Continue with creation (no blocking validation for epic discovery)
+    // The needs_discovery flag is informational only - trust users to decide when ready
+    continueCreate();
+
+    function continueCreate() {
+      // Chores don't have modes - they inherit context from their parent feature
+      if (type === 'chore') {
+        if (mode) {
+          return reject(new Error(`Chores do not have modes. Chores inherit the workflow context from their parent feature.\n\nTo create a chore: jettypod work create chore "title" "description" --parent=<feature-id>`));
+        }
+
+        // Standalone chores (no parent) are allowed - skip parent validation
+        if (!parentId) {
+          return continueWithValidatedParent(null);
+        }
+
+        // Check parent's mode and phase
+        db.get('SELECT id, title, type, mode, phase, epic_id FROM work_items WHERE id = ?', [parentId], (err, parent) => {
+          if (err) {
+            return reject(new Error(`Failed to validate parent: ${err.message}`));
+          }
+
+          if (!parent) {
+            return reject(new Error(`Parent feature #${parentId} not found`));
+          }
+
+          if (parent.type !== 'feature' && parent.type !== 'epic') {
+            return reject(new Error(`Chores can only be created under features or epics. Parent #${parentId} is a ${parent.type}`));
+          }
+
+          // For chores under features, validate mode exists
+          // Chores under epics are standalone and don't require mode
+          if (parent.type === 'feature' && !parent.mode) {
+            return reject(new Error(
+              `Cannot create chore for feature without a mode.\n\n` +
+              `Feature #${parent.id} "${parent.title}"\n` +
+              `  Phase: ${parent.phase || 'not set'}\n` +
+              `  Mode: ${parent.mode || 'not set'}\n` +
+              `  Scenario file: ${parent.scenario_file || 'not set'}\n\n` +
+              `Chores can only be created after the feature has transitioned to implementation\n` +
+              `with a mode (speed/stable/production).\n\n` +
+              `To fix this, run:\n` +
+              `  jettypod work implement ${parent.id} --scenario-file="features/[feature].feature" --winner="..." --rationale="..."`
+            ));
+          }
+
+          // ═══════════════════════════════════════════════════════════════════
+          // SPEED-MODE WORKFLOW GUARD
+          // ═══════════════════════════════════════════════════════════════════
+          // Block manual chore creation during active speed-mode workflow.
+          // Speed-mode auto-generates stable chores - manual creation bypasses the skill.
+          //
+          // Guard Logic: ONLY block when ALL conditions are true:
+          //   1. mode === 'speed'  (feature is in speed mode)
+          //   2. phase === 'implementation'  (skill is actively running)
+          //   3. chores already exist  (initial chores have been created)
+          //
+          // Edge Case Matrix:
+          // ┌─────────────┬─────────────────┬─────────────────┬─────────────────┐
+          // │ mode        │ phase=impl      │ phase=other     │ phase=null      │
+          // ├─────────────┼─────────────────┼─────────────────┼─────────────────┤
+          // │ speed       │ BLOCKED*        │ ALLOWED         │ ALLOWED         │
+          // │ stable      │ ALLOWED         │ ALLOWED         │ ALLOWED         │
+          // │ production  │ ALLOWED         │ ALLOWED         │ ALLOWED         │
+          // │ null        │ (caught earlier by "no mode" check)                 │
+          // └─────────────┴─────────────────┴─────────────────┴─────────────────┘
+          // * Only blocked if a chore has been STARTED (status != 'todo')
+          //   This allows feature-planning to create ALL chores after scenarios
+          //
+          // Why this logic:
+          // - speed + implementation + chore started = active skill workflow
+          // - speed + implementation + all chores todo = initial setup from feature-planning
+          // - speed + other phase = skill paused or not started (manual ok)
+          // - stable/production = designed for manual chore creation
+          // ═══════════════════════════════════════════════════════════════════
+          if (parent.mode === 'speed' && parent.phase === 'implementation') {
+            // Check if any chore has been STARTED (status = 'in_progress' or 'done')
+            // This allows feature-planning to create ALL chores after scenarios
+            // Note: Chores start with status 'backlog' or 'todo', which are NOT "started"
+            db.get(
+              `SELECT COUNT(*) as count FROM work_items WHERE parent_id = ? AND type = ? AND status IN ('in_progress', 'done')`,
+              [parent.id, 'chore'],
+              (err, result) => {
+                if (err) {
+                  return reject(new Error(`Failed to check started chores: ${err.message}`));
+                }
+
+                const startedChores = result ? result.count : 0;
+
+                if (startedChores > 0) {
+                  // A chore has been started - block manual creation
+                  return reject(new Error(
+                    `Cannot manually create chores while speed-mode implementation is in progress.\n\n` +
+                    `Feature #${parent.id} "${parent.title}" has chores being worked on.\n` +
+                    `Speed-mode will auto-generate stable chores when the happy path is complete.\n\n` +
+                    `Next steps:\n` +
+                    `  1. Complete the current speed-mode chores\n` +
+                    `  2. Run: jettypod work status ${parent.id} to see progress\n` +
+                    `  3. Speed-mode will transition to stable and generate chores automatically\n\n` +
+                    `If you need to bypass this (not recommended):\n` +
+                    `  jettypod work elevate ${parent.id} stable`
+                  ));
+                }
+
+                // No chores started yet - allow creation (feature-planning phase)
+                mode = null;
+                // Derive epic_id from parent feature
+                const derivedEpicId = parent.epic_id;
+                continueWithValidatedParent(derivedEpicId);
+              }
+            );
+            return; // Wait for async chore check
+          }
+
+          // Parent is valid, continue with creation
+          mode = null; // Explicitly set to null for chores
+          // Derive epic_id: if parent is epic, use parent.id; if parent is feature, use parent.epic_id
+          const derivedEpicId = parent.type === 'epic' ? parent.id : parent.epic_id;
+          continueWithValidatedParent(derivedEpicId);
+        });
+
+        return; // Wait for async validation
+      }
+
+      // For non-chores (features, epics), derive epic_id if there's a parent
+      if (parentId && (type === 'feature' || type === 'bug')) {
+        // Features/bugs with parent - look up parent to derive epic_id
+        db.get('SELECT id, type, epic_id FROM work_items WHERE id = ?', [parentId], (err, parent) => {
+          if (err) {
+            return reject(new Error(`Failed to look up parent: ${err.message}`));
+          }
+          if (!parent) {
+            return reject(new Error(`Parent #${parentId} not found`));
+          }
+          // Parent should be an epic for features
+          const derivedEpicId = parent.type === 'epic' ? parent.id : parent.epic_id;
+          continueWithValidatedParent(derivedEpicId);
+        });
+        return;
+      }
+
+      // For epics or items without parent, no epic_id
+      continueWithValidatedParent(null);
+    }
+
+    function continueWithValidatedParent(epicId) {
+
+      // Only features have modes - they start with mode=NULL (no mode until implementation starts)
+      // Epics, chores, and bugs don't have modes (always NULL)
+      if (type === 'feature' && !mode) {
+        mode = null;
+      }
+
+      // Bugs should never have modes - always NULL
+      if (type === 'bug') {
+        if (mode) {
+          return reject(new Error('Bugs cannot have modes. Only features have modes (speed/stable/production).'));
+        }
+        mode = null;
+      }
+
+      // Validate mode value if provided (only for features)
+      if (mode && type === 'feature') {
+        const validModes = ['speed', 'stable', 'production'];
+        if (!validModes.includes(mode)) {
+          return reject(new Error(`Invalid mode: ${mode}. Must be one of: ${validModes.join(', ')}`));
+        }
+      }
+
+      // 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) {
+        if (err) {
+          return reject(err);
+        }
+        const newId = this.lastID;
+        const discoveryIndicator = needsDiscovery ? ' (needs discovery)' : '';
+        console.log(`Created ${type} #${newId}: ${title}${discoveryIndicator}`);
+        resolve(newId);
+      });
+    }
+  });
+}
+
+/**
+ * Determine if an item should be hidden in internal projects
+ * Rules:
+ * - Features with mode='production' are hidden
+ * - Chores whose parent feature has mode='production' are hidden (handled by tree filtering)
+ * - Epics are never hidden (they're containers)
+ *
+ * @param {Object} item - Work item to check
+ * @returns {boolean} True if item should be hidden
+ */
+function isProductionModeItem(item) {
+  // Validate input
+  if (!item || typeof item !== 'object') {
+    return false;
+  }
+
+  // Only features can have production mode
+  if (item.type === 'feature' && item.mode === 'production') {
+    return true;
+  }
+
+  // Epics are containers - never hide them
+  // Chores don't have modes - their visibility is determined by their parent
+  return false;
+}
+
+/**
+ * Recursively filter out production mode features and their children
+ * Smart filtering: only removes items if they're production mode features
+ * Maintains tree integrity: removes entire branches when feature is production
+ *
+ * @param {Array} items - Items to filter
+ * @param {Object} itemsById - Lookup map of all items
+ * @returns {Array} Filtered items
+ */
+function filterProductionItems(items, itemsById) {
+  // Validate input
+  if (!Array.isArray(items)) {
+    return [];
+  }
+
+  return items.filter(item => {
+    // Skip invalid items
+    if (!item || typeof item !== 'object') {
+      return false;
+    }
+
+    // Check if this item should be hidden
+    const shouldHide = isProductionModeItem(item);
+
+    if (shouldHide) {
+      return false; // Hide this item and all its children
+    }
+
+    // Item is not production - keep it and recursively filter its children
+    if (item.children && Array.isArray(item.children) && item.children.length > 0) {
+      item.children = filterProductionItems(item.children, itemsById);
+    }
+
+    return true;
+  });
+}
+
+/**
+ * Get all work items as hierarchical tree structure
+ * @param {boolean} includeCompleted - Include done/cancelled items (default: false)
+ * @param {boolean} showAll - Show all items including production (bypasses internal/external filtering)
+ * @returns {Promise<Array>} Root work items with nested children
+ * @throws {Error} If database query fails
+ */
+function getTree(includeCompleted = false, showAll = false) {
+  return new Promise((resolve, reject) => {
+    const whereClause = includeCompleted ? '' : "WHERE (status NOT IN ('done', 'cancelled') OR status IS NULL)";
+    db.all(`SELECT * FROM work_items ${whereClause} ORDER BY parent_id, id`, [], (err, rows) => {
+      if (err) {
+        return reject(new Error(`Failed to fetch work items: ${err.message}`));
+      }
+
+      if (!rows || rows.length === 0) {
+        return resolve([]);
+      }
+
+      const itemsById = {};
+      const rootItems = [];
+
+      try {
+        // Build lookup
+        rows.forEach(item => {
+          itemsById[item.id] = item;
+          item.children = [];
+        });
+
+        // Build tree
+        rows.forEach(item => {
+          if (item.parent_id && itemsById[item.parent_id]) {
+            itemsById[item.parent_id].children.push(item);
+          } else if (!item.parent_id) {
+            rootItems.push(item);
+          }
+        });
+
+        // Apply production filtering if internal project and not showing all
+        let filteredItems = rootItems;
+        try {
+          const config = require('../../lib/config');
+          const projectConfig = config.read();
+          const isInternal = projectConfig.project_state === 'internal';
+
+          if (isInternal && !showAll) {
+            filteredItems = filterProductionItems(rootItems, itemsById);
+          }
+        } catch (err) {
+          // If config reading fails, don't filter (safer to show everything)
+          // Log warning but continue
+          console.warn(`Warning: Failed to read config for production filtering: ${err.message}`);
+        }
+
+        resolve(filteredItems);
+      } catch (err) {
+        reject(new Error(`Failed to build backlog: ${err.message}`));
+      }
+    });
+  });
+}
+
+/**
+ * Print work items tree to console with visual hierarchy
+ * @param {Array} items - Work items to print
+ * @param {string} prefix - Indentation prefix for nested items
+ * @param {boolean} isRootLevel - Whether we're at the root level
+ * @param {Set} expandedIds - Set of item IDs to show expanded (null = all collapsed, 'all' = all expanded)
+ * @throws {Error} If items is not an array
+ */
+function printTree(items, prefix = '', isRootLevel = true, expandedIds = null) {
+  if (!Array.isArray(items)) {
+    throw new Error('Items must be an array');
+  }
+
+  items.forEach((item, index) => {
+    if (!item || typeof item !== 'object') {
+      console.warn(`Skipping invalid item at index ${index}`);
+      return;
+    }
+
+    const isLast = index === items.length - 1;
+    const emoji = TYPE_EMOJIS[item.type] || '📋';
+
+    // Show mode indicator only when mode is set
+    let modeIndicator = '';
+    if (item.mode) {
+      modeIndicator = ` [${item.mode}]`;
+    }
+
+    // Determine if this item should be expanded
+    const isExpanded = expandedIds === 'all' || (expandedIds && expandedIds.has(item.id));
+    const hasChildren = item.children && item.children.length > 0;
+    const expandIndicator = hasChildren ? (isExpanded ? ' ⊖' : ' ⊕') : '';
+    const childCount = hasChildren ? ` (${item.children.length} ${item.type === 'epic' ? 'features' : item.type === 'feature' ? 'chores' : 'items'})` : '';
+
+    // Root level items have no connectors
+    if (isRootLevel) {
+      const titlePrefix = `${emoji} [#${item.id}] `;
+      const titleText = `${item.title}${modeIndicator}${childCount}${expandIndicator}`;
+      // Calculate actual visual width of emoji + space to find bracket position
+      const visualBracketPos = getVisualWidth(emoji + ' ');
+      const termWidth = getTerminalWidth();
+      const prefixVisualWidth = getVisualWidth(titlePrefix);
+      const maxTextWidth = termWidth - prefixVisualWidth;
+      const wrappedTitle = wrapText(titleText, maxTextWidth, 0);
+
+      console.log(titlePrefix + wrappedTitle[0]);
+      // Continuation lines align with the opening bracket
+      const continuationPrefix = (hasChildren ? '│' : ' ') + ' '.repeat(visualBracketPos - 1);
+      for (let i = 1; i < wrappedTitle.length; i++) {
+        console.log(continuationPrefix + wrappedTitle[i]);
+      }
+
+      if (isExpanded && item.description) {
+        const descLabel = 'Description: "';
+        const descText = item.description + '"';
+        const maxDescWidth = termWidth - getVisualWidth(continuationPrefix) - getVisualWidth(descLabel);
+        const wrappedDesc = wrapText(descText, maxDescWidth, 0);
+
+        console.log(continuationPrefix + descLabel + wrappedDesc[0]);
+        for (let i = 1; i < wrappedDesc.length; i++) {
+          console.log(continuationPrefix + wrappedDesc[i]);
+        }
+      }
+      if (isExpanded && item.status && item.type !== 'epic') {
+        console.log(`${continuationPrefix}Status: ${item.status}${item.mode ? ` | Mode: ${item.mode}` : ''}`);
+      }
+    } else {
+      // Nested items get tree connectors
+      const connector = isLast ? '└── ' : '├── ';
+      const treePrefix = prefix + (isLast ? '    ' : '│   ');
+      const titlePrefix = `${prefix}${connector}${emoji} [#${item.id}] `;
+      const titleText = `${item.title}${modeIndicator}${childCount}${expandIndicator}`;
+      const termWidth = getTerminalWidth();
+
+      // Calculate actual visual width to find bracket position
+      const visualBracketPos = getVisualWidth(`${prefix}${connector}${emoji} `);
+      const prefixVisualWidth = getVisualWidth(titlePrefix);
+      const maxTextWidth = termWidth - prefixVisualWidth;
+      const wrappedTitle = wrapText(titleText, maxTextWidth, 0);
+
+      console.log(titlePrefix + wrappedTitle[0]);
+      // Continuation lines align with the opening bracket
+      const continuationPrefix = (treePrefix.substring(0, 1)) + ' '.repeat(visualBracketPos - 1);
+      for (let i = 1; i < wrappedTitle.length; i++) {
+        console.log(continuationPrefix + wrappedTitle[i]);
+      }
+
+      if (isExpanded && item.description) {
+        const descLabel = 'Description: "';
+        const descText = item.description + '"';
+        const maxDescWidth = termWidth - getVisualWidth(continuationPrefix) - getVisualWidth(descLabel);
+        const wrappedDesc = wrapText(descText, maxDescWidth, 0);
+
+        console.log(continuationPrefix + descLabel + wrappedDesc[0]);
+        for (let i = 1; i < wrappedDesc.length; i++) {
+          console.log(continuationPrefix + wrappedDesc[i]);
+        }
+      }
+      if (isExpanded && item.status && item.type !== 'epic') {
+        console.log(`${continuationPrefix}Status: ${item.status}${item.mode ? ` | Mode: ${item.mode}` : ''}`);
+      }
+    }
+
+    // Always show children - expansion only controls extra details
+    if (hasChildren) {
+      const newPrefix = isRootLevel ? '' : (prefix + (isLast ? '    ' : '│   '));
+      printTree(item.children, newPrefix, false, expandedIds);
+    }
+  });
+}
+
+// Update status
+function updateStatus(id, status) {
+  return new Promise((resolve, reject) => {
+    // First get the work item to check its parent
+    db.get('SELECT id, parent_id FROM work_items WHERE id = ?', [id], (err, item) => {
+      if (err) {
+        console.error(`Error: ${err.message}`);
+        return reject(err);
+      }
+
+      if (!item) {
+        console.log(`Work item #${id} not found`);
+        return resolve();
+      }
+
+      // Update the status and completed_at if marking as done
+      const completedAt = status === 'done' ? new Date().toISOString() : null;
+      const sql = status === 'done'
+        ? `UPDATE work_items SET status = ?, completed_at = ? WHERE id = ?`
+        : `UPDATE work_items SET status = ? WHERE id = ?`;
+      const params = status === 'done' ? [status, completedAt, id] : [status, id];
+
+      db.run(sql, params, async (err) => {
+        if (err) {
+          console.error(`Error: ${err.message}`);
+          return reject(err);
+        }
+
+        console.log(`Updated #${id} status to ${status}`);
+
+        // If status is 'done', merge and cleanup associated worktree
+        if (status === 'done') {
+          try {
+            const worktree = await new Promise((res, rej) => {
+              db.get('SELECT id, worktree_path, branch_name FROM worktrees WHERE work_item_id = ? AND status = ?', [id, 'active'], (err, row) => {
+                if (err) rej(err);
+                else res(row);
+              });
+            });
+
+            if (worktree) {
+              const { execSync } = require('child_process');
+              const { getGitRoot } = require('../../lib/git-root');
+              const { isGitRepo } = require('../../lib/git');
+              const gitRoot = getGitRoot();
+
+              // CRITICAL: Merge to main BEFORE cleanup
+              if (isGitRepo()) {
+                try {
+                  // Test merge to detect conflicts (without actually merging)
+                  const mergeResult = execSync(`git merge --no-commit --no-ff ${worktree.branch_name}`, {
+                    cwd: gitRoot,
+                    encoding: 'utf8',
+                    stdio: 'pipe'
+                  });
+
+                  // Use smart conflict detection to check if we have true conflicts
+                  const { checkForConflicts } = require('../../lib/smart-conflict-detection');
+                  const conflictCheck = checkForConflicts(gitRoot);
+
+                  if (conflictCheck.hasConflicts) {
+                    // True conflicts detected - abort and preserve
+                    try {
+                      execSync('git merge --abort', { cwd: gitRoot, stdio: 'pipe' });
+                    } catch (abortErr) {
+                      // Ignore abort errors
+                    }
+                    console.warn(`⚠️  Cannot merge worktree branch "${worktree.branch_name}" - conflicts detected`);
+                    console.warn(`   Conflicts in: ${conflictCheck.conflictFiles.join(', ')}`);
+                    console.warn(`   Worktree preserved for manual resolution`);
+                    throw new Error('Merge conflicts - worktree preserved');
+                  }
+
+                  // No conflicts - auto-commit if there are uncommitted changes
+                  if (conflictCheck.status.trim() !== '') {
+                    try {
+                      execSync('git add .', { cwd: gitRoot, stdio: 'pipe' });
+                      execSync(`git commit -m "Merge work item #${id}"`, {
+                        cwd: gitRoot,
+                        stdio: 'pipe'
+                      });
+                      console.log(`✓ Merged branch "${worktree.branch_name}" to main`);
+                    } catch (commitErr) {
+                      // Failed to commit - abort the merge
+                      console.warn(`Warning: Failed to commit merge: ${commitErr.message}`);
+                      try {
+                        execSync('git merge --abort', { cwd: gitRoot, stdio: 'pipe' });
+                      } catch (abortErr) {
+                        // Ignore abort errors
+                      }
+                      throw new Error('Merge commit failed - worktree preserved');
+                    }
+                  } else {
+                    // Merge completed with no changes (fast-forward or already merged)
+                    console.log(`✓ Merged branch "${worktree.branch_name}" to main (no changes)`);
+                  }
+                } catch (mergeErr) {
+                  // Check if this is our controlled error or an unexpected git error
+                  if (mergeErr.message === 'Merge conflicts - worktree preserved' ||
+                      mergeErr.message === 'Merge commit failed - worktree preserved') {
+                    throw mergeErr;
+                  }
+
+                  // Unexpected merge error - abort and preserve worktree
+                  try {
+                    execSync('git merge --abort', { cwd: gitRoot, stdio: 'pipe' });
+                  } catch (abortErr) {
+                    // Ignore abort errors
+                  }
+                  console.warn(`⚠️  Cannot merge worktree branch "${worktree.branch_name}" - merge failed`);
+                  console.warn(`   Error: ${mergeErr.message}`);
+                  console.warn(`   Worktree preserved for manual resolution`);
+                  throw new Error('Merge failed - worktree preserved');
+                }
+              }
+
+              // Only cleanup after successful merge
+              const worktreeFacade = require('../../lib/worktree-facade');
+              const cleanupResult = await worktreeFacade.stopWork(worktree.id, {
+                repoPath: gitRoot,
+                db: db,
+                deleteBranch: true
+              });
+
+              if (cleanupResult.success) {
+                console.log(`✓ Cleaned up worktree for #${id}`);
+              } else {
+                // CRITICAL: Cleanup failures must be fatal - do not swallow errors
+                // Orphaned worktrees prevent recreation and cause confusion
+                const userMsg = cleanupResult.error?.userMessage || cleanupResult.error?.message;
+                console.error(`\n❌ Failed to cleanup worktree for #${id}: ${userMsg || 'Unknown error'}`);
+                console.error('This may leave orphaned worktree files.');
+                console.error('Please manually cleanup before continuing.\n');
+                throw new Error(`Cleanup failed: ${userMsg || 'Unknown error'}`);
+              }
+            }
+          } catch (cleanupErr) {
+            // CRITICAL: Cleanup failures must be fatal - do not swallow errors
+            console.error(`\n❌ Failed to cleanup worktree for #${id}: ${cleanupErr.message}`);
+            console.error('This may leave orphaned worktree files.');
+            console.error('Please manually cleanup before continuing.\n');
+            throw cleanupErr;
+          }
+        }
+
+        // If status is 'done', check if this is the current work item and cleanup current work state
+        if (status === 'done') {
+          const { getCurrentWork, clearCurrentWork } = require('../../lib/current-work');
+          const currentWork = getCurrentWork();
+
+          if (currentWork && currentWork.id === id) {
+            try {
+              clearCurrentWork();
+              console.log('✓ Cleared current work state');
+            } catch (clearErr) {
+              console.warn(`Warning: Failed to clear current work: ${clearErr.message}`);
+            }
+
+            // Also remove <current_work> block from CLAUDE.md
+            const fs = require('fs');
+            const path = require('path');
+            const claudeMdPath = path.join(process.cwd(), 'CLAUDE.md');
+
+            if (fs.existsSync(claudeMdPath)) {
+              try {
+                let content = fs.readFileSync(claudeMdPath, 'utf-8');
+                content = content.replace(/<current_work>[\s\S]*?<\/current_work>\n*/g, '');
+                fs.writeFileSync(claudeMdPath, content);
+                console.log('✓ Removed current work from CLAUDE.md');
+              } catch (claudeErr) {
+                console.warn(`Warning: Failed to update CLAUDE.md: ${claudeErr.message}`);
+              }
+            }
+          }
+        }
+
+        // If status is 'done' and item has a parent, check if we should auto-close the parent
+        if (status === 'done' && item.parent_id) {
+          db.get('SELECT id, type, mode FROM work_items WHERE id = ?', [item.parent_id], (err, parent) => {
+            if (err || !parent) {
+              return resolve();
+            }
+
+            // Auto-close epics when all children are done
+            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) => {
+                  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();
+                    });
+                  } else {
+                    resolve();
+                  }
+                }
+              );
+            }
+            // Auto-close features when all chores are done AND mode progression is complete
+            else if (parent.type === 'feature') {
+              // Check if all chores of this feature are done
+              db.all(
+                'SELECT id, status FROM work_items WHERE parent_id = ? AND type = ?',
+                [parent.id, 'chore'],
+                (err, chores) => {
+                  if (err || !chores || chores.length === 0) {
+                    return resolve();
+                  }
+
+                  const allChoresDone = chores.every(chore => chore.status === 'done');
+                  if (!allChoresDone) {
+                    return resolve();
+                  }
+
+                  // All chores done - check if feature should be marked done based on mode progression
+                  // Get project state to determine required modes
+                  db.get('SELECT project_state FROM project_config WHERE id = 1', [], (err, config) => {
+                    const projectState = (config && config.project_state) || 'internal';
+                    const featureMode = parent.mode || 'speed';
+
+                    // Determine if feature is complete based on project state and mode
+                    let featureComplete = false;
+
+                    if (projectState === 'internal') {
+                      // Internal: complete after stable mode
+                      featureComplete = (featureMode === 'stable');
+                    } else if (projectState === 'external') {
+                      // External: complete after production mode
+                      featureComplete = (featureMode === 'production');
+                    }
+
+                    if (featureComplete) {
+                      const featureCompletedAt = new Date().toISOString();
+                      db.run('UPDATE work_items SET status = ?, completed_at = ? WHERE id = ?', ['done', featureCompletedAt, parent.id], (err) => {
+                        if (err) {
+                          console.error(`Failed to auto-close feature: ${err.message}`);
+                        } else {
+                          console.log(`✓ Feature #${parent.id} completed (all ${featureMode} mode chores done)`);
+                        }
+                        resolve();
+                      });
+                    } else {
+                      // Feature not complete yet - needs more modes
+                      const nextMode = featureMode === 'speed' ? 'stable' : 'production';
+                      console.log(`✓ All ${featureMode} mode chores done. Feature #${parent.id} ready for ${nextMode} mode.`);
+                      resolve();
+                    }
+                  });
+                }
+              );
+            } else {
+              resolve();
+            }
+          });
+        } else {
+          resolve();
+        }
+      });
+    });
+  });
+}
+
+// Set branch
+function setBranch(id, branch) {
+  db.run(`UPDATE work_items SET branch_name = ? WHERE id = ?`, [branch, id], () => {
+    console.log(`Set #${id} branch to ${branch}`);
+  });
+}
+
+// Set mode
+function setMode(id, mode) {
+  return new Promise((resolve, reject) => {
+    const { getCurrentWork } = require('../../lib/current-work');
+    const { updateCurrentWork } = require('../../lib/claudemd');
+
+    // Validate mode
+    const validModes = ['speed', 'stable', 'production'];
+    if (mode && !validModes.includes(mode)) {
+      const error = new Error(`Invalid mode: ${mode}. Must be one of: ${validModes.join(', ')}`);
+      console.error(`Error: ${error.message}`);
+      reject(error);
+      return;
+    }
+
+    // Check if work item is an epic - epics don't have modes
+    db.get(`SELECT type FROM work_items WHERE id = ?`, [id], (err, row) => {
+      if (err) {
+        console.error(`Error: ${err.message}`);
+        reject(err);
+        return;
+      }
+
+      if (!row) {
+        console.error(`Error: Work item #${id} not found`);
+        resolve();
+        return;
+      }
+
+      if (row.type === 'epic') {
+        const error = new Error('Epics do not have modes. Only features have modes.');
+        console.error(`Error: ${error.message}`);
+        reject(error);
+        return;
+      }
+
+      if (row.type === 'chore') {
+        const error = new Error('Chores do not have modes. Chores inherit the workflow context from their parent feature.');
+        console.error(`Error: ${error.message}`);
+        reject(error);
+        return;
+      }
+
+      if (row.type === 'bug') {
+        const error = new Error('Bugs do not have modes. Only features have modes (speed/stable/production).');
+        console.error(`Error: ${error.message}`);
+        reject(error);
+        return;
+      }
+
+      // Update database
+      db.serialize(() => {
+        db.run(`UPDATE work_items SET mode = ? WHERE id = ?`, [mode, id], async (err) => {
+          if (err) {
+            console.error(`Error: ${err.message}`);
+            reject(err);
+            return;
+          }
+
+          console.log(`Set #${id} mode to ${mode}`);
+
+          // If this is the current work item, update session file
+          const currentWork = await getCurrentWork();
+          if (currentWork && currentWork.id === id) {
+            // Get updated work item to pass to updateCurrentWork
+            db.get(`
+              SELECT w.*,
+                     p.title as parent_title, p.id as parent_id
+              FROM work_items w
+              LEFT JOIN work_items p ON w.parent_id = p.id
+              WHERE w.id = ?
+            `, [id], async (err, workItem) => {
+              if (err || !workItem) {
+                resolve();
+                return;
+              }
+
+              // Add epic info
+              const epic = await findEpic(workItem.id);
+              workItem.epic_id = epic ? epic.id : null;
+              workItem.epic_title = epic ? epic.title : null;
+
+              // Update CLAUDE.md with new mode
+              // Epics don't have mode lines in CLAUDE.md, pass null
+              const modeForClaudeMd = workItem.type === 'epic' ? null : mode;
+              updateCurrentWork(workItem, modeForClaudeMd);
+              console.log('📝 CLAUDE.md updated');
+              resolve();
+            });
+          } else {
+            resolve();
+          }
+        });
+      });
+    }); // Close outer db.get for epic check
+  });
+}
+
+// Set current work item
+function setCurrent(id) {
+  const { setCurrentWork } = require('../../lib/current-work');
+  const { updateCurrentWork } = require('../../lib/claudemd');
+
+  db.run(`UPDATE work_items SET current = 0`, [], () => {
+    db.get(`
+      SELECT w.*,
+             p.title as parent_title, p.id as parent_id, p.type as parent_type
+      FROM work_items w
+      LEFT JOIN work_items p ON w.parent_id = p.id
+      WHERE w.id = ?
+    `, [id], async (err, workItem) => {
+      if (err || !workItem) {
+        console.log(`Work item #${id} not found`);
+        return;
+      }
+
+      // Find epic by traversing parent chain
+      const epic = await findEpic(workItem.id);
+
+      db.run(`UPDATE work_items SET current = 1 WHERE id = ?`, [id], () => {
+        // Create current work file
+        const currentWork = {
+          id: workItem.id,
+          title: workItem.title,
+          type: workItem.type,
+          status: workItem.status,
+          mode: workItem.mode,
+          parent_id: workItem.parent_id,
+          parent_title: workItem.parent_title,
+          parent_type: workItem.parent_type,
+          epic_id: epic ? epic.id : null,
+          epic_title: epic ? epic.title : null,
+          description: workItem.description
+        };
+
+        setCurrentWork(currentWork);
+        updateCurrentWork(currentWork, workItem.mode);
+
+        console.log(`Set #${id} as current work`);
+      });
+    });
+  });
+}
+
+// Re-export getCurrentWork from shared module for backwards compatibility
+// (used by jettypod.js)
+
+// Show single work item details
+function showItem(id) {
+  return new Promise(async (resolve) => {
+    db.get(`
+      SELECT w.*,
+             p.title as parent_title
+      FROM work_items w
+      LEFT JOIN work_items p ON w.parent_id = p.id
+      WHERE w.id = ?
+    `, [id], async (err, row) => {
+      if (err || !row) {
+        console.log(`Work item #${id} not found`);
+        resolve(null);
+      } else {
+        const epic = await findEpic(row.id);
+
+        console.log(`\n#${row.id} ${row.title}`);
+        console.log(`Type: ${row.type}`);
+        console.log(`Status: ${row.status}`);
+        if (row.mode) console.log(`Mode: ${row.mode}`);
+        if (row.branch_name) console.log(`Branch: ${row.branch_name}`);
+        if (row.parent_title) console.log(`Parent: #${row.parent_id} ${row.parent_title}`);
+        if (epic) console.log(`Epic: #${epic.id} ${epic.title}`);
+
+        // Display prototype tracking information
+        if (row.prototype_files) {
+          try {
+            const prototypeFiles = JSON.parse(row.prototype_files);
+            if (prototypeFiles && prototypeFiles.length > 0) {
+              console.log(`\n🔬 Prototypes: ${prototypeFiles.join(', ')}`);
+            }
+          } catch (e) {
+            // Invalid JSON, skip
+          }
+        }
+        if (row.discovery_winner) {
+          console.log(`✅ Winner: ${row.discovery_winner}`);
+        }
+
+        // Display epic discovery information
+        if (row.type === 'epic' && row.needs_discovery) {
+          // Query all discovery decisions for this epic
+          db.all(
+            `SELECT * FROM discovery_decisions WHERE work_item_id = ? ORDER BY created_at`,
+            [row.id],
+            (err, decisions) => {
+              if (err) {
+                console.error(`Error fetching decisions: ${err.message}`);
+              }
+
+              if (decisions && decisions.length > 0) {
+                console.log(`\n🏛  Discovery Decisions:`);
+                decisions.forEach((d) => {
+                  console.log(`\n   ${d.aspect}:`);
+                  console.log(`   Decision: ${d.decision}`);
+                  console.log(`   Rationale: ${d.rationale}`);
+                });
+                console.log(`\n   💡 Add more decisions: jettypod work epic-implement ${row.id} --aspect="<type>" --decision="<approach>" --rationale="<why>"`);
+              } else {
+                console.log(`\n⚠️  DISCOVERY REQUIRED: This epic needs architectural decisions`);
+                console.log(``);
+                console.log(`   💬 Talk to Claude Code: "Let's do epic discovery for #${row.id}"`);
+                console.log(`   Or run: jettypod work epic-planning ${row.id}`);
+                console.log(``);
+                console.log(`   Claude Code will guide you through:`);
+                console.log(`   • Suggesting 3 architectural options`);
+                console.log(`   • Building prototypes`);
+                console.log(`   • Recording your decisions`);
+              }
+
+              if (row.description) console.log(`\nDescription: ${row.description}`);
+              resolve(row);
+            }
+          );
+        } else {
+          if (row.description) console.log(`\nDescription: ${row.description}`);
+          resolve(row);
+        }
+      }
+    });
+  });
+}
+
+// Epic overview
+function epicOverview(epicId) {
+  return new Promise(async (resolve) => {
+    db.all('SELECT * FROM work_items', [], async (err, rows) => {
+      if (err) {
+        console.error(err);
+        return resolve();
+      }
+
+      // Filter items that belong to this epic
+      const epicItems = [];
+      for (const row of rows) {
+        const epic = await findEpic(row.id);
+        if ((epic && epic.id === epicId) || row.id === epicId) {
+          epicItems.push(row);
+        }
+      }
+
+      console.log(`\nEpic #${epicId} Overview:`);
+
+      const byType = {};
+      const byStatus = {};
+
+      epicItems.forEach(row => {
+        if (!byType[row.type]) byType[row.type] = 0;
+        byType[row.type]++;
+
+        if (!byStatus[row.status]) byStatus[row.status] = 0;
+        byStatus[row.status]++;
+      });
+
+      console.log('\nBy Type:');
+      Object.entries(byType).forEach(([type, count]) => {
+        console.log(`  ${type}: ${count}`);
+      });
+
+      console.log('\nBy Status:');
+      Object.entries(byStatus).forEach(([status, count]) => {
+        console.log(`  ${status}: ${count}`);
+      });
+
+      resolve();
+    });
+  });
+}
+
+// Main CLI handler
+async function main() {
+  const command = process.argv[2];
+  const args = process.argv.slice(3);
+
+  switch(command) {
+    case 'create': {
+      const type = args[0];
+      const title = args[1];
+      const desc = args[2] || '';
+
+      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;
+        }
+      });
+
+      try {
+        const newId = await create(type, title, desc, parentId, mode, needsDiscovery);
+
+        // Prompt for epic discovery after epic creation
+        if (type === 'epic') {
+          console.log('');
+          console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+          console.log('🎯 Plan this epic now?');
+          console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+          console.log('');
+          console.log('Ask Claude Code:');
+          console.log(`  "Help me plan epic #${newId}"`);
+          console.log('');
+          console.log('Claude will help you:');
+          console.log('  • Brainstorm features for this epic');
+          console.log('  • Identify architectural decisions (if needed)');
+          console.log('  • Create features automatically');
+          console.log('');
+          console.log('Or run: jettypod work epic-planning ' + newId);
+          console.log('');
+          console.log('💡 You can also plan later when ready');
+        }
+
+        // Check if creating feature under an unplanned epic
+        if (type === 'feature' && parentId) {
+          db.get(`SELECT * FROM work_items WHERE id = ?`, [parentId], (err, parent) => {
+            if (!err && parent && parent.type === 'epic') {
+              // Check if epic has any features already
+              db.get(`SELECT COUNT(*) as count FROM work_items WHERE parent_id = ? AND type = 'feature'`, [parentId], (err, result) => {
+                if (!err && result.count === 1) {
+                  // This is the first feature - suggest planning the epic
+                  console.log('');
+                  console.log('💡 Tip: Consider planning this epic first');
+                  console.log('');
+                  console.log('Ask Claude Code:');
+                  console.log(`  "Help me plan epic #${parentId}"`);
+                  console.log('');
+                  console.log(`Or run: jettypod work epic-planning ${parentId}`);
+                }
+              });
+            }
+          });
+        }
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+      break;
+    }
+
+    case 'tree': {
+      try {
+        // Wait for migrations to complete before running queries
+        await waitForMigrations();
+
+        // Parse expand flags
+        let expandedIds = null; // null = collapsed by default
+        const expandArg = process.argv.find(arg => arg.startsWith('--expand'));
+
+        if (expandArg === '--expand-all') {
+          expandedIds = 'all';
+        } else if (expandArg && expandArg.includes('=')) {
+          const idsStr = expandArg.split('=')[1];
+          const ids = idsStr.split(',').map(id => parseInt(id.trim())).filter(id => !isNaN(id));
+          expandedIds = new Set(ids);
+        }
+
+        // Query for ALL in_progress items
+        const activeItems = await new Promise((resolve, reject) => {
+          db.all(`
+            SELECT w.id, w.title, w.type, w.status,
+                   p.title as parent_title, p.id as parent_id, p.type as parent_type,
+                   e.title as epic_title, e.id as epic_id
+            FROM work_items w
+            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
+          `, [], (err, rows) => {
+            if (err) return reject(err);
+            resolve(rows || []);
+          });
+        });
+
+        // Show active work at top if exists
+        if (activeItems.length > 0) {
+          console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+          console.log('🎯  ACTIVE WORK');
+          console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+          activeItems.forEach((item, index) => {
+            const emoji = TYPE_EMOJIS[item.type] || '📋';
+            console.log(`${emoji} [#${item.id}] ${item.title}`);
+            // Show epic if parent is the epic, otherwise show parent
+            if (item.epic_title && item.epic_id !== item.id && item.parent_id === item.epic_id) {
+              console.log(`└─ Epic: 🎯 #${item.epic_id} ${item.epic_title}`);
+            } else if (item.parent_title) {
+              const parentEmoji = TYPE_EMOJIS[item.parent_type] || '📋';
+              console.log(`└─ Part of: ${parentEmoji} #${item.parent_id} ${item.parent_title}`);
+            } else if (item.epic_title && item.epic_id !== item.id) {
+              console.log(`└─ Epic: 🎯 #${item.epic_id} ${item.epic_title}`);
+            }
+
+            // Add spacing between items except after last one
+            if (index < activeItems.length - 1) {
+              console.log('');
+            }
+          });
+
+          console.log('');
+        }
+
+        // Show recently completed items
+        const recentlyCompleted = await new Promise((resolve, reject) => {
+          db.all(`
+            SELECT w.id, w.title, w.type, w.mode,
+                   p.title as parent_title, p.id as parent_id, p.type as parent_type
+            FROM work_items w
+            LEFT JOIN work_items p ON w.parent_id = p.id
+            WHERE w.status = 'done'
+            ORDER BY w.id DESC
+            LIMIT 3
+          `, [], async (err, rows) => {
+            if (err) reject(err);
+            else {
+              // Add epic info to each item
+              for (const row of rows || []) {
+                const epic = await findEpic(row.id);
+                row.epic_id = epic ? epic.id : null;
+                row.epic_title = epic ? epic.title : null;
+              }
+              resolve(rows || []);
+            }
+          });
+        });
+
+        if (recentlyCompleted.length > 0) {
+          console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+          console.log('✅  RECENTLY COMPLETED');
+          console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+          recentlyCompleted.forEach(item => {
+            const emoji = TYPE_EMOJIS[item.type] || '📋';
+            let modeIndicator = '';
+            if (item.mode) {
+              modeIndicator = ` [${item.mode}]`;
+            }
+
+            // Wrap the title text properly
+            const titlePrefix = `${emoji} [${item.id}] `;
+            const titleText = `${item.title}${modeIndicator}`;
+            const visualBracketPos = getVisualWidth(emoji + ' ');
+            const termWidth = getTerminalWidth();
+            const prefixVisualWidth = getVisualWidth(titlePrefix);
+            const maxTextWidth = termWidth - prefixVisualWidth;
+            const wrappedTitle = wrapText(titleText, maxTextWidth, 0);
+
+            console.log(titlePrefix + wrappedTitle[0]);
+            // Continuation lines align with the opening bracket
+            const continuationPrefix = ' '.repeat(visualBracketPos);
+            for (let i = 1; i < wrappedTitle.length; i++) {
+              console.log(continuationPrefix + wrappedTitle[i]);
+            }
+
+            // Wrap parent/epic lines too
+            if (item.epic_title && item.epic_id !== item.id && item.parent_id === item.epic_id) {
+              const parentPrefix = '   └─ ';
+              const parentText = `Epic: 🎯 #${item.epic_id} ${item.epic_title}`;
+              const parentPrefixWidth = getVisualWidth(parentPrefix);
+              const maxParentWidth = termWidth - parentPrefixWidth;
+              const wrappedParent = wrapText(parentText, maxParentWidth, 0);
+              console.log(parentPrefix + wrappedParent[0]);
+              const parentContinuation = '      ';
+              for (let i = 1; i < wrappedParent.length; i++) {
+                console.log(parentContinuation + wrappedParent[i]);
+              }
+            } else if (item.parent_title) {
+              const parentEmoji = TYPE_EMOJIS[item.parent_type] || '📋';
+              const parentPrefix = '   └─ ';
+              const parentText = `Part of: ${parentEmoji} #${item.parent_id} ${item.parent_title}`;
+              const parentPrefixWidth = getVisualWidth(parentPrefix);
+              const maxParentWidth = termWidth - parentPrefixWidth;
+              const wrappedParent = wrapText(parentText, maxParentWidth, 0);
+              console.log(parentPrefix + wrappedParent[0]);
+              const parentContinuation = '      ';
+              for (let i = 1; i < wrappedParent.length; i++) {
+                console.log(parentContinuation + wrappedParent[i]);
+              }
+            } else if (item.epic_title && item.epic_id !== item.id) {
+              const parentPrefix = '   └─ ';
+              const parentText = `Epic: 🎯 #${item.epic_id} ${item.epic_title}`;
+              const parentPrefixWidth = getVisualWidth(parentPrefix);
+              const maxParentWidth = termWidth - parentPrefixWidth;
+              const wrappedParent = wrapText(parentText, maxParentWidth, 0);
+              console.log(parentPrefix + wrappedParent[0]);
+              const parentContinuation = '      ';
+              for (let i = 1; i < wrappedParent.length; i++) {
+                console.log(parentContinuation + wrappedParent[i]);
+              }
+            }
+          });
+          console.log('');
+        }
+
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('📋  BACKLOG');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        const items = await getTree();
+
+        // Default: expand all epics unless user specified expand flags
+        if (expandedIds === null) {
+          expandedIds = new Set();
+          items.forEach(item => {
+            if (item.type === 'epic') {
+              expandedIds.add(item.id);
+            }
+          });
+        }
+
+        printTree(items, '', true, expandedIds);
+
+        // Show legend and commands
+        console.log('');
+        console.log('Legend: ⊕ = collapsed  ⊖ = expanded');
+        console.log('');
+        console.log('Commands:');
+        console.log('  jettypod backlog --expand=1           Show details for item #1');
+        console.log('  jettypod backlog --expand=1,2,3       Show details for multiple items');
+        console.log('  jettypod backlog --expand-all         Show all details');
+        console.log('  jettypod backlog                      Collapse all (default)');
+        console.log('');
+      } catch (err) {
+        console.error(`Error displaying backlog: ${err.message}`);
+        process.exit(1);
+      }
+      break;
+    }
+
+    case 'backlog': {
+      try {
+        // Wait for migrations to complete before running queries
+        await waitForMigrations();
+
+        const filter = args[0]; // undefined, 'all', or 'completed'
+
+        // Check for --all flag (bypasses production filtering)
+        const showAll = args.includes('--all');
+
+        // For 'all' and 'completed' filters, use old simple display
+        if (filter === 'all' || filter === 'completed') {
+          let items;
+          if (filter === 'all') {
+            items = await getTree(true, true); // includeCompleted=true, showAll=true
+          } else {
+            items = await new Promise((resolve, reject) => {
+              db.all(`SELECT * FROM work_items WHERE status IN ('done', 'cancelled') ORDER BY parent_id, id`, [], (err, rows) => {
+                if (err) {
+                  return reject(new Error(`Failed to fetch completed items: ${err.message}`));
+                }
+
+                if (!rows || rows.length === 0) {
+                  return resolve([]);
+                }
+
+                const itemsById = {};
+                const rootItems = [];
+
+                rows.forEach(item => {
+                  itemsById[item.id] = item;
+                  item.children = [];
+                });
+
+                rows.forEach(item => {
+                  if (item.parent_id && itemsById[item.parent_id]) {
+                    itemsById[item.parent_id].children.push(item);
+                  } else if (!item.parent_id) {
+                    rootItems.push(item);
+                  }
+                });
+
+                resolve(rootItems);
+              });
+            });
+          }
+
+          if (items.length === 0) {
+            console.log('No items found.');
+          } else {
+            const expandedIds = new Set();
+            items.forEach(item => {
+              if (item.type === 'epic') {
+                expandedIds.add(item.id);
+              }
+            });
+            printTree(items, '', true, expandedIds);
+          }
+          console.log('');
+        } else {
+          // Default: show three-section view (active work, recently completed, backlog)
+
+          // Parse expand flags
+          let expandedIds = null; // null = collapsed by default
+          const expandArg = process.argv.find(arg => arg.startsWith('--expand'));
+
+          if (expandArg === '--expand-all') {
+            expandedIds = 'all';
+          } else if (expandArg && expandArg.includes('=')) {
+            const idsStr = expandArg.split('=')[1];
+            const ids = idsStr.split(',').map(id => parseInt(id.trim())).filter(id => !isNaN(id));
+            expandedIds = new Set(ids);
+          }
+
+          // Query for ALL in_progress items
+          const activeItems = await new Promise((resolve, reject) => {
+            db.all(`
+              SELECT w.id, w.title, w.type, w.status,
+                     p.title as parent_title, p.id as parent_id, p.type as parent_type,
+                     e.title as epic_title, e.id as epic_id
+              FROM work_items w
+              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
+            `, [], (err, rows) => {
+              if (err) return reject(err);
+              resolve(rows || []);
+            });
+          });
+
+          // Show active work at top if exists
+          if (activeItems.length > 0) {
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            console.log('🎯  ACTIVE WORK');
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+            activeItems.forEach((item, index) => {
+              const emoji = TYPE_EMOJIS[item.type] || '📋';
+              console.log(`${emoji} [#${item.id}] ${item.title}`);
+              // Show epic if parent is the epic, otherwise show parent
+              if (item.epic_title && item.epic_id !== item.id && item.parent_id === item.epic_id) {
+                console.log(`└─ Epic: 🎯 #${item.epic_id} ${item.epic_title}`);
+              } else if (item.parent_title) {
+                const parentEmoji = TYPE_EMOJIS[item.parent_type] || '📋';
+                console.log(`└─ Part of: ${parentEmoji} #${item.parent_id} ${item.parent_title}`);
+              } else if (item.epic_title && item.epic_id !== item.epic_id) {
+                console.log(`└─ Epic: 🎯 #${item.epic_id} ${item.epic_title}`);
+              }
+
+              // Add spacing between items except after last one
+              if (index < activeItems.length - 1) {
+                console.log('');
+              }
+            });
+
+            console.log('');
+          }
+
+          // Show recently completed items
+          const recentlyCompleted = await new Promise((resolve, reject) => {
+            db.all(`
+              SELECT w.id, w.title, w.type, w.mode,
+                     p.title as parent_title, p.id as parent_id, p.type as parent_type
+              FROM work_items w
+              LEFT JOIN work_items p ON w.parent_id = p.id
+              WHERE w.status = 'done'
+              ORDER BY w.completed_at DESC, w.id DESC
+              LIMIT 3
+            `, [], async (err, rows) => {
+              if (err) reject(err);
+              else {
+                // Add epic info to each item
+                for (const row of rows || []) {
+                  const epic = await findEpic(row.id);
+                  if (epic) {
+                    row.epic_id = epic.id;
+                    row.epic_title = epic.title;
+                  }
+                }
+                resolve(rows || []);
+              }
+            });
+          });
+
+          if (recentlyCompleted.length > 0) {
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            console.log('✅  RECENTLY COMPLETED');
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            recentlyCompleted.forEach(item => {
+              const emoji = TYPE_EMOJIS[item.type] || '📋';
+              let modeIndicator = '';
+              if (item.mode) {
+                modeIndicator = ` [${item.mode}]`;
+              }
+
+              // Wrap the title text properly
+              const titlePrefix = `${emoji} [${item.id}] `;
+              const titleText = `${item.title}${modeIndicator}`;
+              const visualBracketPos = getVisualWidth(emoji + ' ');
+              const termWidth = getTerminalWidth();
+              const prefixVisualWidth = getVisualWidth(titlePrefix);
+              const maxTextWidth = termWidth - prefixVisualWidth;
+              const wrappedTitle = wrapText(titleText, maxTextWidth, 0);
+
+              console.log(titlePrefix + wrappedTitle[0]);
+              // Continuation lines align with the opening bracket
+              const continuationPrefix = ' '.repeat(visualBracketPos);
+              for (let i = 1; i < wrappedTitle.length; i++) {
+                console.log(continuationPrefix + wrappedTitle[i]);
+              }
+
+              // Wrap parent/epic lines too
+              if (item.epic_title && item.epic_id !== item.id && item.parent_id === item.epic_id) {
+                const parentPrefix = '   └─ ';
+                const parentText = `Epic: 🎯 #${item.epic_id} ${item.epic_title}`;
+                const parentPrefixWidth = getVisualWidth(parentPrefix);
+                const maxParentWidth = termWidth - parentPrefixWidth;
+                const wrappedParent = wrapText(parentText, maxParentWidth, 0);
+                console.log(parentPrefix + wrappedParent[0]);
+                const parentContinuation = '      ';
+                for (let i = 1; i < wrappedParent.length; i++) {
+                  console.log(parentContinuation + wrappedParent[i]);
+                }
+              } else if (item.parent_title) {
+                const parentEmoji = TYPE_EMOJIS[item.parent_type] || '📋';
+                const parentPrefix = '   └─ ';
+                const parentText = `Part of: ${parentEmoji} #${item.parent_id} ${item.parent_title}`;
+                const parentPrefixWidth = getVisualWidth(parentPrefix);
+                const maxParentWidth = termWidth - parentPrefixWidth;
+                const wrappedParent = wrapText(parentText, maxParentWidth, 0);
+                console.log(parentPrefix + wrappedParent[0]);
+                const parentContinuation = '      ';
+                for (let i = 1; i < wrappedParent.length; i++) {
+                  console.log(parentContinuation + wrappedParent[i]);
+                }
+              } else if (item.epic_title && item.epic_id !== item.id) {
+                const parentPrefix = '   └─ ';
+                const parentText = `Epic: 🎯 #${item.epic_id} ${item.epic_title}`;
+                const parentPrefixWidth = getVisualWidth(parentPrefix);
+                const maxParentWidth = termWidth - parentPrefixWidth;
+                const wrappedParent = wrapText(parentText, maxParentWidth, 0);
+                console.log(parentPrefix + wrappedParent[0]);
+                const parentContinuation = '      ';
+                for (let i = 1; i < wrappedParent.length; i++) {
+                  console.log(parentContinuation + wrappedParent[i]);
+                }
+              }
+            });
+            console.log('');
+          }
+
+          console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+          console.log('📋  BACKLOG');
+          console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+          const items = await getTree(false, showAll);
+
+          printTree(items, '', true, expandedIds);
+
+          // Show legend and commands
+          console.log('');
+          console.log('Legend: ⊕ = collapsed  ⊖ = expanded');
+          console.log('');
+          console.log('Commands:');
+          console.log('  jettypod backlog --expand=1           Show details for item #1');
+          console.log('  jettypod backlog --expand=1,2,3       Show details for multiple items');
+          console.log('  jettypod backlog --expand-all         Show all details');
+          console.log('  jettypod backlog                      Collapse all (default)');
+          console.log('');
+        }
+      } catch (err) {
+        console.error(`Error displaying backlog: ${err.message}`);
+        process.exit(1);
+      }
+      break;
+    }
+
+    case 'status': {
+      const id = parseInt(args[0]);
+      const status = args[1];
+      try {
+        await updateStatus(id, status);
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+      break;
+    }
+
+    case 'set-branch': {
+      const id = parseInt(args[0]);
+      const branch = args[1];
+      setBranch(id, branch);
+      break;
+    }
+
+    case 'set-mode': {
+      const id = parseInt(args[0]);
+      const mode = args[1];
+      await setMode(id, mode);
+      break;
+    }
+
+    case 'current': {
+      if (!args[0]) {
+        // No ID provided - show current work
+        const currentWork = await getCurrentWork();
+        if (!currentWork) {
+          console.log('No active work');
+          console.log('');
+          console.log('Start work on an item: jettypod work start <id>');
+        } else {
+          const emoji = TYPE_EMOJIS[currentWork.type] || '📋';
+          console.log(`${emoji} Current work: [#${currentWork.id}] ${currentWork.title}`);
+          console.log(`   Type: ${currentWork.type}`);
+          console.log(`   Status: ${currentWork.status}`);
+          if (currentWork.parent_title) {
+            const parentEmoji = TYPE_EMOJIS['feature'] || '✨';
+            console.log(`   Parent: ${parentEmoji} [#${currentWork.parent_id}] ${currentWork.parent_title}`);
+          }
+          if (currentWork.epic_title) {
+            console.log(`   Epic: 🎯 [#${currentWork.epic_id}] ${currentWork.epic_title}`);
+          }
+        }
+      } else {
+        // ID provided - set current work
+        const id = parseInt(args[0]);
+        setCurrent(id);
+      }
+      break;
+    }
+
+    case 'show': {
+      if (!args[0]) {
+        console.error('Error: Work item ID is required');
+        console.log('');
+        console.log('Usage: jettypod work show <id>');
+        console.log('');
+        console.log('Example:');
+        console.log('  jettypod work show 5');
+        console.log('');
+        console.log('💡 Tip: Use `jettypod backlog` to see all work items');
+        process.exit(1);
+      }
+
+      const id = parseInt(args[0]);
+      if (isNaN(id)) {
+        console.error(`Error: Invalid work item ID: ${args[0]}`);
+        console.log('ID must be a number');
+        process.exit(1);
+      }
+
+      await showItem(id);
+      break;
+    }
+
+    case 'describe': {
+      const id = parseInt(args[0]);
+      const description = args.slice(1).join(' ');
+
+      db.run(`UPDATE work_items SET description = ? WHERE id = ?`, [description, id], (err) => {
+        if (err) {
+          console.error(`Error: ${err.message}`);
+          process.exit(1);
+        }
+        console.log(`Updated #${id} description`);
+      });
+      break;
+    }
+
+    case 'epic': {
+      const epicId = parseInt(args[0]);
+      await epicOverview(epicId);
+      break;
+    }
+
+    case 'completed': {
+      db.all(`
+        SELECT w.*,
+               p.title as parent_title, p.type as parent_type
+        FROM work_items w
+        LEFT JOIN work_items p ON w.parent_id = p.id
+        WHERE w.status = 'done'
+        ORDER BY w.id DESC
+      `, [], async (err, rows) => {
+        if (err) {
+          console.error(`Error fetching completed items: ${err.message}`);
+          process.exit(1);
+        }
+
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('✅  COMPLETED WORK');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+        if (!rows || rows.length === 0) {
+          console.log('No completed work items');
+          console.log('');
+        } else {
+          // Add epic info to each item
+          for (const row of rows) {
+            const epic = await findEpic(row.id);
+            row.epic_id = epic ? epic.id : null;
+            row.epic_title = epic ? epic.title : null;
+          }
+
+          // Group by mode
+          const byMode = {
+            speed: [],
+            stable: [],
+            production: [],
+            other: []
+          };
+
+          rows.forEach(item => {
+            if (item.mode === 'speed') byMode.speed.push(item);
+            else if (item.mode === 'stable') byMode.stable.push(item);
+            else if (item.mode === 'production') byMode.production.push(item);
+            else byMode.other.push(item);
+          });
+
+          // Display Speed Mode section
+          if (byMode.speed.length > 0) {
+            console.log('\n⚡ SPEED MODE');
+            byMode.speed.forEach(item => {
+              const emoji = TYPE_EMOJIS[item.type] || '📋';
+              console.log(`${emoji} [#${item.id}] ${item.title}`);
+              // Show epic if parent is the epic, otherwise show parent
+              if (item.epic_title && item.epic_id !== item.id && item.parent_id === item.epic_id) {
+                console.log(`   └─ Epic: 🎯 #${item.epic_id} ${item.epic_title}`);
+              } else if (item.parent_title) {
+                const parentEmoji = TYPE_EMOJIS[item.parent_type] || '📋';
+                console.log(`   └─ Part of: ${parentEmoji} #${item.parent_id} ${item.parent_title}`);
+              } else if (item.epic_title && item.epic_id !== item.id) {
+                console.log(`   └─ Epic: 🎯 #${item.epic_id} ${item.epic_title}`);
+              }
+            });
+          }
+
+          // Display Stable Mode section
+          if (byMode.stable.length > 0) {
+            console.log('\n🔒 STABLE MODE');
+            byMode.stable.forEach(item => {
+              const emoji = TYPE_EMOJIS[item.type] || '📋';
+              console.log(`${emoji} [#${item.id}] ${item.title}`);
+              // Show epic if parent is the epic, otherwise show parent
+              if (item.epic_title && item.epic_id !== item.id && item.parent_id === item.epic_id) {
+                console.log(`   └─ Epic: 🎯 #${item.epic_id} ${item.epic_title}`);
+              } else if (item.parent_title) {
+                const parentEmoji = TYPE_EMOJIS[item.parent_type] || '📋';
+                console.log(`   └─ Part of: ${parentEmoji} #${item.parent_id} ${item.parent_title}`);
+              } else if (item.epic_title && item.epic_id !== item.id) {
+                console.log(`   └─ Epic: 🎯 #${item.epic_id} ${item.epic_title}`);
+              }
+            });
+          }
+
+          // Display Production Mode section
+          if (byMode.production.length > 0) {
+            console.log('\n🚀 PRODUCTION MODE');
+            byMode.production.forEach(item => {
+              const emoji = TYPE_EMOJIS[item.type] || '📋';
+              console.log(`${emoji} [#${item.id}] ${item.title}`);
+              // Show epic if parent is the epic, otherwise show parent
+              if (item.epic_title && item.epic_id !== item.id && item.parent_id === item.epic_id) {
+                console.log(`   └─ Epic: 🎯 #${item.epic_id} ${item.epic_title}`);
+              } else if (item.parent_title) {
+                const parentEmoji = TYPE_EMOJIS[item.parent_type] || '📋';
+                console.log(`   └─ Part of: ${parentEmoji} #${item.parent_id} ${item.parent_title}`);
+              } else if (item.epic_title && item.epic_id !== item.id) {
+                console.log(`   └─ Epic: 🎯 #${item.epic_id} ${item.epic_title}`);
+              }
+            });
+          }
+
+          // Display Other/Untagged section
+          if (byMode.other.length > 0) {
+            console.log('\n📦 OTHER');
+            byMode.other.forEach(item => {
+              const emoji = TYPE_EMOJIS[item.type] || '📋';
+              const modeIndicator = item.mode ? ` [${item.mode}]` : '';
+              console.log(`${emoji} [#${item.id}] ${item.title}${modeIndicator}`);
+              // Show epic if parent is the epic, otherwise show parent
+              if (item.epic_title && item.epic_id !== item.id && item.parent_id === item.epic_id) {
+                console.log(`   └─ Epic: 🎯 #${item.epic_id} ${item.epic_title}`);
+              } else if (item.parent_title) {
+                const parentEmoji = TYPE_EMOJIS[item.parent_type] || '📋';
+                console.log(`   └─ Part of: ${parentEmoji} #${item.parent_id} ${item.parent_title}`);
+              } else if (item.epic_title && item.epic_id !== item.id) {
+                console.log(`   └─ Epic: 🎯 #${item.epic_id} ${item.epic_title}`);
+              }
+            });
+          }
+
+          console.log('');
+        }
+      });
+      break;
+    }
+
+    case 'epic-planning': {
+      const epicId = parseInt(args[0]);
+
+      if (!epicId || isNaN(epicId)) {
+        console.error('Error: Epic ID is required');
+        console.log('Usage: jettypod work epic-planning <epic-id>');
+        process.exit(1);
+      }
+
+      db.get(`SELECT * FROM work_items WHERE id = ?`, [epicId], (err, epic) => {
+        if (err) {
+          console.error(`Error: ${err.message}`);
+          process.exit(1);
+        }
+
+        if (!epic) {
+          console.error(`Error: Epic #${epicId} not found`);
+          process.exit(1);
+        }
+
+        if (epic.type !== 'epic') {
+          console.error(`Error: Work item #${epicId} is not an epic (type: ${epic.type})`);
+          process.exit(1);
+        }
+
+        if (!epic.needs_discovery) {
+          console.error(`Error: Epic #${epicId} does not need discovery (needs_discovery=false)`);
+          console.log('');
+          console.log('Create epics with --needs-discovery flag if architectural decisions needed:');
+          console.log('  jettypod work create epic "Epic Title" "Description" --needs-discovery');
+          process.exit(1);
+        }
+
+        // Check if any decisions have been recorded
+        db.all(
+          `SELECT * FROM discovery_decisions WHERE work_item_id = ?`,
+          [epicId],
+          (err, decisions) => {
+            if (err) {
+              console.error(`Error: ${err.message}`);
+              process.exit(1);
+            }
+
+            if (decisions && decisions.length > 0) {
+              console.log(`📋 Epic #${epicId} discovery decisions:`);
+              console.log('');
+              decisions.forEach((d) => {
+                console.log(`  ${d.aspect}: ${d.decision}`);
+                console.log(`  Rationale: ${d.rationale}`);
+                console.log('');
+              });
+              console.log('💡 You can add more decisions for different aspects:');
+              console.log(`   jettypod work epic-implement ${epicId} --aspect="<type>" --decision="<approach>" --rationale="<why>"`);
+              return;
+            }
+
+            console.log(`🔍 Starting epic discovery for #${epicId}: ${epic.title}`);
+            console.log('');
+            console.log(`Description: ${epic.description || 'No description'}`);
+            console.log('');
+            console.log('────────────────────────────────────────────────────');
+            console.log('Epic Discovery Context (for Claude Code):');
+            console.log('────────────────────────────────────────────────────');
+            console.log(`Epic ID: ${epicId}`);
+            console.log(`Title: ${epic.title}`);
+            console.log(`Description: ${epic.description || 'Not provided'}`);
+            console.log('Needs Discovery: true');
+            console.log('');
+            console.log('💬 Now ask Claude Code:');
+            console.log(`   "Help me with epic discovery for #${epicId}"`);
+            console.log('');
+            console.log('Claude will use the epic-planning skill to guide you through:');
+            console.log('  1. Feature brainstorming');
+            console.log('  2. Architectural decisions (if needed)');
+            console.log('  3. Prototype validation (optional)');
+            console.log('  4. Feature creation');
+            console.log('');
+            console.log('📋 The skill is at: .claude/skills/epic-planning/SKILL.md');
+          }
+        );
+      });
+      break;
+    }
+
+    case 'epic-implement': {
+      const epicId = parseInt(args[0]);
+
+      if (!epicId || isNaN(epicId)) {
+        console.error('Error: Epic ID is required');
+        console.log('Usage: jettypod work epic-implement <epic-id> --aspect="<type>" --decision="<approach>" --rationale="<why>"');
+        process.exit(1);
+      }
+
+      // Parse --aspect, --decision, --rationale, and --prototypes flags
+      const aspectIndex = args.findIndex(a => a.startsWith('--aspect='));
+      const decisionIndex = args.findIndex(a => a.startsWith('--decision='));
+      const rationaleIndex = args.findIndex(a => a.startsWith('--rationale='));
+      const prototypesIndex = args.findIndex(a => a.startsWith('--prototypes='));
+
+      if (aspectIndex === -1 || decisionIndex === -1 || rationaleIndex === -1) {
+        console.error('Error: --aspect, --decision, and --rationale are all required');
+        console.log('');
+        console.log('Usage: jettypod work epic-implement <epic-id> --aspect="<type>" --decision="<approach>" --rationale="<why>" [--prototypes="file1,file2"]');
+        console.log('');
+        console.log('Example:');
+        console.log('  jettypod work epic-implement 5 \\');
+        console.log('    --aspect="Architecture" \\');
+        console.log('    --decision="WebSockets with Socket.io" \\');
+        console.log('    --rationale="Bidirectional real-time updates needed, Socket.io provides fallbacks" \\');
+        console.log('    --prototypes="prototypes/websockets.js,prototypes/sse.js"');
+        console.log('');
+        console.log('Common aspects: Architecture, Design Pattern, State Management, API Design, Testing Strategy');
+        process.exit(1);
+      }
+
+      const aspect = args[aspectIndex].split('=')[1].replace(/^["']|["']$/g, '');
+      const decision = args[decisionIndex].split('=')[1].replace(/^["']|["']$/g, '');
+      const rationale = args[rationaleIndex].split('=').slice(1).join('=').replace(/^["']|["']$/g, '');
+      const prototypes = prototypesIndex !== -1
+        ? args[prototypesIndex].split('=')[1].replace(/^["']|["']$/g, '').split(',').map(p => p.trim())
+        : [];
+
+      // Validate inputs
+      if (!aspect || !decision || !rationale) {
+        console.error('Error: --aspect, --decision, and --rationale must all have values');
+        process.exit(1);
+      }
+
+      if (aspect.trim().length === 0 || rationale.trim().length === 0) {
+        console.error('Error: --aspect and --rationale cannot be empty or whitespace only');
+        console.log('');
+        console.log('Provide meaningful values for the decision aspect and rationale.');
+        process.exit(1);
+      }
+
+      // Get and validate epic
+      db.get(`SELECT * FROM work_items WHERE id = ?`, [epicId], (err, epic) => {
+        if (err) {
+          console.error(`Error: ${err.message}`);
+          process.exit(1);
+        }
+
+        if (!epic) {
+          console.error(`Error: Epic #${epicId} not found`);
+          process.exit(1);
+        }
+
+        if (epic.type !== 'epic') {
+          console.error(`Error: Work item #${epicId} is not an epic (type: ${epic.type})`);
+          process.exit(1);
+        }
+
+        if (!epic.needs_discovery) {
+          console.error(`Error: Epic #${epicId} does not need discovery (needs_discovery=false)`);
+          process.exit(1);
+        }
+
+        // Check if this aspect already has a decision
+        db.get(
+          `SELECT * FROM discovery_decisions WHERE work_item_id = ? AND aspect = ?`,
+          [epicId, aspect],
+          (err, existingDecision) => {
+            if (err) {
+              console.error(`Error: ${err.message}`);
+              process.exit(1);
+            }
+
+            if (existingDecision) {
+              console.error(`Error: Epic #${epicId} already has a decision for aspect "${aspect}"`);
+              console.log('');
+              console.log(`Current decision: ${existingDecision.decision}`);
+              console.log(`Rationale: ${existingDecision.rationale}`);
+              console.log('');
+              console.log('Use a different aspect name or update the database directly to change this decision.');
+              process.exit(1);
+            }
+
+            // Insert new discovery decision
+            db.run(
+              `INSERT INTO discovery_decisions (work_item_id, aspect, decision, rationale)
+               VALUES (?, ?, ?, ?)`,
+              [epicId, aspect, decision, rationale],
+              (err) => {
+                if (err) {
+                  console.error(`Error: ${err.message}`);
+                  process.exit(1);
+                }
+
+                // Update work_items with prototype tracking if provided
+                if (prototypes.length > 0) {
+                  db.run(
+                    `UPDATE work_items SET prototype_files = ?, discovery_winner = ? WHERE id = ?`,
+                    [JSON.stringify(prototypes), decision, epicId],
+                    (err) => {
+                      if (err) {
+                        console.warn(`⚠️  Could not save prototypes: ${err.message}`);
+                      }
+                    }
+                  );
+                }
+
+                console.log(`✅ Epic #${epicId} discovery decision recorded!`);
+                console.log('');
+                console.log(`Aspect: ${aspect}`);
+                console.log(`Decision: ${decision}`);
+                console.log(`Rationale: ${rationale}`);
+                if (prototypes.length > 0) {
+                  console.log(`Prototypes: ${prototypes.join(', ')}`);
+                }
+                console.log('');
+                console.log('📝 Architectural decision recorded');
+                console.log('');
+
+                // Generate DECISIONS.md
+                (async () => {
+                  try {
+                    const { generateDecisionsFile } = require('../../lib/decisions-generator');
+                    await generateDecisionsFile();
+                    console.log('📋 DECISIONS.md updated');
+                    console.log('');
+                  } catch (err) {
+                    console.warn('⚠️  Could not generate DECISIONS.md:', err.message);
+                    console.log('');
+                  }
+
+                  console.log('You can add more decisions for other aspects:');
+                  console.log(`  jettypod work epic-implement ${epicId} --aspect="<type>" --decision="<approach>" --rationale="<why>"`);
+                  console.log('');
+                  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+                  console.log('✨ Next Step: Create Features');
+                  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+                  console.log('');
+                  console.log('Create features for this epic:');
+                  console.log(`  jettypod work create feature "Feature Title" "Description" --parent=${epicId}`);
+                  console.log('');
+                  console.log('Then plan each feature:');
+                  console.log('  jettypod work discover <feature-id>');
+                  console.log('');
+                  console.log('💡 Tip: Claude Code will suggest UX approaches and generate BDD scenarios');
+                })();
+              }
+            );
+          }
+        );
+      });
+      break;
+    }
+
+    case 'implement': {
+      const featureId = parseInt(args[0]);
+
+      if (!featureId || isNaN(featureId)) {
+        console.error('Error: Feature ID is required');
+        console.log('Usage: jettypod work implement <feature-id> [--scenario-file="path"] [--prototypes="file1,file2"] [--winner="file.js"] [--rationale="why this approach"]');
+        process.exit(1);
+      }
+
+      // Parse optional flags
+      const scenarioFileIndex = args.findIndex(a => a.startsWith('--scenario-file='));
+      const prototypesIndex = args.findIndex(a => a.startsWith('--prototypes='));
+      const winnerIndex = args.findIndex(a => a.startsWith('--winner='));
+      const rationaleIndex = args.findIndex(a => a.startsWith('--rationale='));
+
+      const scenarioFileArg = scenarioFileIndex !== -1
+        ? args[scenarioFileIndex].split('=')[1].replace(/^["']|["']$/g, '')
+        : null;
+      const prototypes = prototypesIndex !== -1
+        ? args[prototypesIndex].split('=')[1].replace(/^["']|["']$/g, '').split(',').map(p => p.trim())
+        : [];
+      const winner = winnerIndex !== -1
+        ? args[winnerIndex].split('=')[1].replace(/^["']|["']$/g, '')
+        : null;
+      const rationale = rationaleIndex !== -1
+        ? args[rationaleIndex].split('=')[1].replace(/^["']|["']$/g, '')
+        : null;
+
+      db.get(`SELECT * FROM work_items WHERE id = ?`, [featureId], (err, feature) => {
+        if (err) {
+          console.error(`Error: ${err.message}`);
+          process.exit(1);
+        }
+
+        if (!feature) {
+          console.error(`Error: Feature #${featureId} not found`);
+          process.exit(1);
+        }
+
+        if (feature.type !== 'feature') {
+          console.error(`Error: Work item #${featureId} is not a feature (type: ${feature.type})`);
+          console.log('');
+          console.log('The implement command transitions features from Discovery to Implementation phase.');
+          console.log('Only features have phases.');
+          process.exit(1);
+        }
+
+        // Use scenario_file from flag if provided, otherwise from database
+        const scenarioFile = scenarioFileArg || feature.scenario_file;
+
+        // Validate that BDD scenarios exist (either from flag or database)
+        if (!scenarioFile) {
+          console.error(`Error: Feature #${featureId} has no BDD scenarios`);
+          console.log('');
+          console.log('Discovery is not complete without BDD scenarios.');
+          console.log('');
+          console.log('To complete discovery, provide the scenario file:');
+          console.log(`  jettypod work implement ${featureId} --scenario-file="features/[feature-name].feature" --winner="..." --rationale="..."`);
+          console.log('');
+          console.log('Or generate scenarios using the feature-planning skill first.');
+          process.exit(1);
+        }
+
+        // Check if scenario file actually exists on disk
+        const fs = require('fs');
+        const path = require('path');
+        const scenarioPath = path.join(process.cwd(), scenarioFile);
+
+        if (!fs.existsSync(scenarioPath)) {
+          console.error(`Error: Scenario file not found: ${scenarioFile}`);
+          console.log('');
+          console.log('The scenario file must exist on disk before transitioning to implementation.');
+          console.log('');
+          console.log('To fix this:');
+          console.log(`  1. Create the file at: ${scenarioFile}`);
+          console.log('  2. Or check the path is correct');
+          process.exit(1);
+        }
+
+        // Determine if this is a transition or an update
+        // Also handle the case where phase is implementation but mode is not set (partial state)
+        const isTransition = feature.phase === 'discovery' || !feature.mode;
+        const isUpdate = feature.phase === 'implementation' && feature.mode;
+
+        // Prepare values
+        const prototypeFilesValue = prototypes.length > 0 ? JSON.stringify(prototypes) : null;
+        const winnerValue = winner || null;
+        const rationaleValue = rationale || null;
+        const scenarioFileValue = scenarioFile; // Already validated above
+
+        // Update query: if transitioning, set phase, mode, and scenario_file; if updating, just update decision fields
+        let updateSql;
+        let updateParams;
+
+        if (isTransition) {
+          // When transitioning to implementation, ensure status is 'todo' (ready for work)
+          // This prevents status from being left as NULL or in a discovery-related state
+          updateSql = `UPDATE work_items SET phase = 'implementation', mode = 'speed', status = 'todo', scenario_file = ?, prototype_files = ?, discovery_winner = ?, discovery_rationale = ? WHERE id = ?`;
+          updateParams = [scenarioFileValue, prototypeFilesValue, winnerValue, rationaleValue, featureId];
+        } else {
+          updateSql = `UPDATE work_items SET prototype_files = ?, discovery_winner = ?, discovery_rationale = ? WHERE id = ?`;
+          updateParams = [prototypeFilesValue, winnerValue, rationaleValue, featureId];
+        }
+
+        db.run(
+          updateSql,
+          updateParams,
+          (err) => {
+            if (err) {
+              console.error(`Error: ${err.message}`);
+              process.exit(1);
+            }
+
+            console.log('');
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            if (isTransition) {
+              console.log(`✅ Feature #${featureId} transitioned to Implementation Phase`);
+            } else {
+              console.log(`✅ Feature #${featureId} discovery decision updated`);
+            }
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            console.log('');
+            console.log(`Title: ${feature.title}`);
+            console.log('Phase: Implementation');
+            console.log('Mode: Speed');
+            console.log(`Scenarios: ${scenarioFileValue}`);
+            if (prototypes.length > 0) {
+              console.log(`Prototypes: ${prototypes.join(', ')}`);
+            }
+            if (winner) {
+              console.log(`Winner: ${winner}`);
+            }
+            if (rationale) {
+              console.log(`Rationale: ${rationale}`);
+            }
+            console.log('');
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            console.log('🚀 Speed Mode: Prove It Works');
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            console.log('');
+            console.log('Build code that passes happy path scenarios.');
+            console.log('Focus:');
+            console.log('  • Happy path only');
+            console.log('  • Single file when possible');
+            console.log('  • localStorage for data');
+            console.log('  • Basic try/catch');
+            console.log('');
+            console.log('⚠️  Speed Mode is a checkpoint - pass through quickly!');
+            console.log('');
+            console.log('Next: Elevate to Stable Mode');
+            console.log(`  jettypod work elevate ${featureId} stable`);
+            console.log('');
+          }
+        );
+      });
+      break;
+    }
+
+    case 'discover': {
+      const featureId = parseInt(args[0]);
+
+      if (!featureId || isNaN(featureId)) {
+        console.error('Error: Feature ID is required');
+        console.log('Usage: jettypod work discover <feature-id>');
+        process.exit(1);
+      }
+
+      db.get(`SELECT * FROM work_items WHERE id = ?`, [featureId], (err, feature) => {
+        if (err) {
+          console.error(`Error: ${err.message}`);
+          process.exit(1);
+        }
+
+        if (!feature) {
+          console.error(`Error: Feature #${featureId} not found`);
+          process.exit(1);
+        }
+
+        if (feature.type !== 'feature') {
+          console.error(`Error: Work item #${featureId} is not a feature (type: ${feature.type})`);
+          process.exit(1);
+        }
+
+        // Get parent epic if exists
+        db.get(`SELECT * FROM work_items WHERE id = ?`, [feature.parent_id || feature.epic_id], (err, epic) => {
+          // Get epic's architectural decisions if epic exists
+          if (epic && epic.type === 'epic') {
+            db.all(
+              `SELECT * FROM discovery_decisions WHERE work_item_id = ?`,
+              [epic.id],
+              (err, decisions) => {
+                console.log(`✨ Starting feature discovery for #${featureId}: ${feature.title}`);
+                console.log('');
+                console.log(`Description: ${feature.description || 'No description'}`);
+                console.log('');
+
+                if (epic) {
+                  console.log(`Epic: #${epic.id} ${epic.title}`);
+
+                  if (decisions && decisions.length > 0) {
+                    console.log('');
+                    console.log('📋 Epic architectural decisions:');
+                    decisions.forEach((d) => {
+                      console.log(`  • ${d.aspect}: ${d.decision}`);
+                    });
+                  }
+                }
+
+                console.log('');
+                console.log('────────────────────────────────────────────────────');
+                console.log('Feature Discovery Context (for Claude Code):');
+                console.log('────────────────────────────────────────────────────');
+                console.log(`Feature ID: ${featureId}`);
+                console.log(`Title: ${feature.title}`);
+                console.log(`Description: ${feature.description || 'Not provided'}`);
+                if (epic) {
+                  console.log(`Epic: #${epic.id} ${epic.title}`);
+                  if (decisions && decisions.length > 0) {
+                    console.log('Architectural Constraints:');
+                    decisions.forEach((d) => {
+                      console.log(`  ${d.aspect}: ${d.decision}`);
+                    });
+                  }
+                }
+                console.log('');
+                console.log('💬 Now ask Claude Code:');
+                console.log(`   "Help me with feature discovery for #${featureId}"`);
+                console.log('');
+                console.log('Claude will use the feature-planning skill to guide you through:');
+                console.log('  1. Suggesting 3 UX approaches');
+                console.log('  2. Optional prototyping');
+                console.log('  3. Choosing the winner');
+                console.log('  4. Generating BDD scenarios');
+                console.log('  5. Transitioning to implementation');
+                console.log('');
+                console.log('📋 The skill is at: .claude/skills/feature-planning/SKILL.md');
+              }
+            );
+          } else {
+            console.log(`✨ Starting feature discovery for #${featureId}: ${feature.title}`);
+            console.log('');
+            console.log(`Description: ${feature.description || 'No description'}`);
+            console.log('');
+            console.log('────────────────────────────────────────────────────');
+            console.log('Feature Discovery Context (for Claude Code):');
+            console.log('────────────────────────────────────────────────────');
+            console.log(`Feature ID: ${featureId}`);
+            console.log(`Title: ${feature.title}`);
+            console.log(`Description: ${feature.description || 'Not provided'}`);
+            console.log('');
+            console.log('💬 Now ask Claude Code:');
+            console.log(`   "Help me with feature discovery for #${featureId}"`);
+            console.log('');
+            console.log('Claude will use the feature-planning skill to guide you through:');
+            console.log('  1. Suggesting 3 UX approaches');
+            console.log('  2. Optional prototyping');
+            console.log('  3. Choosing the winner');
+            console.log('  4. Generating BDD scenarios');
+            console.log('  5. Transitioning to implementation');
+            console.log('');
+            console.log('📋 The skill is at: .claude/skills/feature-planning/SKILL.md');
+          }
+        });
+      });
+      break;
+    }
+
+    case 'children': {
+      const parentId = parseInt(args[0]);
+
+      if (!parentId || isNaN(parentId)) {
+        console.log('Usage: jettypod work children <parent-id>');
+        console.log('');
+        console.log('Lists all direct children of a work item.');
+        console.log('');
+        console.log('Example:');
+        console.log('  jettypod work children 42    # List children of epic/feature #42');
+        process.exit(1);
+      }
+
+      try {
+        await waitForMigrations();
+
+        // First verify the parent exists
+        const parent = await new Promise((resolve, reject) => {
+          db.get('SELECT id, title, type FROM work_items WHERE id = ?', [parentId], (err, row) => {
+            if (err) reject(err);
+            else resolve(row);
+          });
+        });
+
+        if (!parent) {
+          console.error(`Error: Work item #${parentId} not found`);
+          process.exit(1);
+        }
+
+        // Get children
+        const children = await new Promise((resolve, reject) => {
+          db.all(
+            'SELECT id, title, type, status, mode FROM work_items WHERE parent_id = ? ORDER BY id',
+            [parentId],
+            (err, rows) => {
+              if (err) reject(err);
+              else resolve(rows || []);
+            }
+          );
+        });
+
+        console.log(`Children of ${TYPE_EMOJIS[parent.type] || '📦'} #${parent.id} "${parent.title}":`);
+        console.log('');
+
+        if (children.length === 0) {
+          console.log('  (no children)');
+        } else {
+          children.forEach(child => {
+            const emoji = TYPE_EMOJIS[child.type] || '📦';
+            const statusEmoji = STATUS_EMOJIS[child.status] || '';
+            const modeStr = child.mode ? ` [${child.mode}]` : '';
+            console.log(`  ${emoji} #${child.id}: ${child.title}${modeStr} ${statusEmoji}`);
+          });
+        }
+        console.log('');
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+      break;
+    }
+
+    default:
+      console.log(`
+JettyPod Work Tracking
+
+Commands:
+  jettypod work create <type> <title> [desc] [--parent=ID]
+    Types: epic, feature, bug, chore
+
+  jettypod backlog [filter]
+    Show work items (active by default)
+    Filters: all, completed
+
+  jettypod work show <id>
+    Show work item details
+
+  jettypod work status <id> <status>
+    Statuses: backlog, todo, in_progress, done, cancelled
+
+  jettypod work set-branch <id> <branch-name>
+    Set branch for work item
+
+  jettypod work set-mode <id> <mode>
+    Set mode (speed/discovery/stable/production)
+
+  jettypod work current <id>
+    Set as current work item
+
+  jettypod work epic <id>
+    Show epic overview
+
+Examples:
+  jettypod work create epic "Q1 Roadmap"
+  jettypod work create feature "Auth" "" --parent=1
+  jettypod work set-branch 2 feature/auth
+  jettypod work set-mode 2 speed
+  jettypod work current 2
+  jettypod work show 2
+      `);
+  }
+
+  // Don't explicitly close DB in test environments - let Node.js handle cleanup
+  // This prevents FATAL errors when async operations are still pending
+  if (process.env.NODE_ENV !== 'test') {
+    await closeDb();
+  }
+}
+
+// Export for use in jettypod.js and other modules
+module.exports = { main, getCurrentWork, updateStatus, create };
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}