jettypod 3.0.1

package/features/work-tracking/index.js

@@ -0,0 +1,1511 @@
+#!/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 } = require('../../lib/database');
+const { getCurrentWork } = require('../../lib/current-work');
+const { TYPE_EMOJIS, STATUS_EMOJIS } = require('../../lib/constants');
+
+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>`));
+        }
+        mode = null; // Explicitly set to null for chores
+      }
+
+      // Default mode to 'discovery' for features and bugs when not specified
+      // Epics and chores don't have modes (NULL)
+      if ((type === 'feature' || type === 'bug') && !mode) {
+        mode = 'discovery';
+      }
+
+      // Validate mode value if provided (only for features and bugs)
+      if (mode) {
+        const validModes = ['speed', 'discovery', 'stable', 'production'];
+        if (!validModes.includes(mode)) {
+          return reject(new Error(`Invalid mode: ${mode}. Must be one of: ${validModes.join(', ')}`));
+        }
+      }
+
+      // Set phase for features (discovery by default, implementation if mode specified, NULL for everything else)
+      const phase = type === 'feature' ? (mode ? 'implementation' : 'discovery') : null;
+
+      const sql = `INSERT INTO work_items (type, title, description, parent_id, mode, needs_discovery, phase) VALUES (?, ?, ?, ?, ?, ?, ?)`;
+      db.run(sql, [type, title, description, parentId, mode, needsDiscovery ? 1 : 0, phase], 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);
+      });
+    }
+  });
+}
+
+/**
+ * Get all work items as hierarchical tree structure
+ * @param {boolean} includeCompleted - Include done/cancelled items (default: false)
+ * @returns {Promise<Array>} Root work items with nested children
+ * @throws {Error} If database query fails
+ */
+function getTree(includeCompleted = false) {
+  return new Promise((resolve, reject) => {
+    const whereClause = includeCompleted ? '' : "WHERE status NOT IN ('done', 'cancelled')";
+    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);
+          }
+        });
+
+        resolve(rootItems);
+      } catch (err) {
+        reject(new Error(`Failed to build work tree: ${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 phase/mode indicator for features
+    let modeIndicator = '';
+    if (item.type === 'feature') {
+      if (item.phase === 'discovery') {
+        modeIndicator = ' [🔍 discovery]';
+      } else if (item.mode) {
+        // Implementation phase - show mode
+        modeIndicator = ` [${item.mode}]`;
+      }
+    } else if (item.type !== 'epic' && item.mode) {
+      // Non-feature, non-epic items (chores, bugs) - show mode only
+      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) {
+      console.log(`${emoji} [#${item.id}] ${item.title}${modeIndicator}${childCount}${expandIndicator}`);
+      if (isExpanded && item.description) {
+        console.log(`   Description: "${item.description}"`);
+      }
+      if (isExpanded && item.status) {
+        console.log(`   Status: ${item.status}${item.mode ? ` | Mode: ${item.mode}` : ''}`);
+      }
+    } else {
+      // Nested items get tree connectors
+      const connector = isLast ? '└── ' : '├── ';
+      console.log(`${prefix}${connector}${emoji} [#${item.id}] ${item.title}${modeIndicator}${childCount}${expandIndicator}`);
+      if (isExpanded && item.description) {
+        const descPrefix = prefix + (isLast ? '    ' : '│   ');
+        console.log(`${descPrefix}Description: "${item.description}"`);
+      }
+      if (isExpanded && item.status) {
+        const descPrefix = prefix + (isLast ? '    ' : '│   ');
+        console.log(`${descPrefix}Status: ${item.status}${item.mode ? ` | Mode: ${item.mode}` : ''}`);
+      }
+    }
+
+    // Only show children if expanded
+    if (hasChildren && isExpanded) {
+      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
+      db.run(`UPDATE work_items SET status = ? WHERE id = ?`, [status, id], (err) => {
+        if (err) {
+          console.error(`Error: ${err.message}`);
+          return reject(err);
+        }
+
+        console.log(`Updated #${id} status to ${status}`);
+
+        // If status is 'done' and item has a parent, check if we should auto-close the parent epic
+        if (status === 'done' && item.parent_id) {
+          db.get('SELECT id, type FROM work_items WHERE id = ?', [item.parent_id], (err, parent) => {
+            if (err || !parent) {
+              return resolve();
+            }
+
+            // Only auto-close epics
+            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) {
+                    db.run('UPDATE work_items SET status = ? WHERE id = ?', ['done', 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();
+                  }
+                }
+              );
+            } 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', 'discovery', '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 and bugs 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;
+      }
+
+      // Update database
+      db.serialize(() => {
+        db.run(`UPDATE work_items SET mode = ? WHERE id = ?`, [mode, id], (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 CLAUDE.md
+          const currentWork = 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-discover ${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-discover ' + 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-discover ${parentId}`);
+                }
+              });
+            }
+          });
+        }
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+      break;
+    }
+
+    case 'tree': {
+      try {
+        // 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);
+        }
+
+        const currentWork = getCurrentWork();
+
+        // Show active work at top if exists
+        if (currentWork) {
+          const emoji = TYPE_EMOJIS[currentWork.type] || '📋';
+          console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+          console.log('🎯  ACTIVE WORK');
+          console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+          console.log(`${emoji} [#${currentWork.id}] ${currentWork.title}`);
+          // Show epic if parent is the epic, otherwise show parent
+          if (currentWork.epic_title && currentWork.epic_id !== currentWork.id && currentWork.parent_id === currentWork.epic_id) {
+            console.log(`└─ Epic: 🎯 #${currentWork.epic_id} ${currentWork.epic_title}`);
+          } else if (currentWork.parent_title) {
+            const parentEmoji = TYPE_EMOJIS[currentWork.parent_type] || '📋';
+            console.log(`└─ Part of: ${parentEmoji} #${currentWork.parent_id} ${currentWork.parent_title}`);
+          } else if (currentWork.epic_title && currentWork.epic_id !== currentWork.id) {
+            console.log(`└─ Epic: 🎯 #${currentWork.epic_id} ${currentWork.epic_title}`);
+          }
+          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] || '📋';
+
+            // Show phase/mode indicator
+            let modeIndicator = '';
+            if (item.type === 'feature') {
+              if (item.phase === 'discovery') {
+                modeIndicator = ' [🔍 discovery]';
+              } else if (item.mode) {
+                modeIndicator = ` [${item.mode}]`;
+              }
+            } else if (item.mode) {
+              modeIndicator = ` [${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('');
+        }
+
+        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 work tree --expand=1         Show details for item #1');
+        console.log('  jettypod work tree --expand=1,2,3     Show details for multiple items');
+        console.log('  jettypod work tree --expand-all       Show all details');
+        console.log('  jettypod work tree                    Collapse all (default)');
+        console.log('');
+      } catch (err) {
+        console.error(`Error displaying work tree: ${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': {
+      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 work tree` 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-discover': {
+      const epicId = parseInt(args[0]);
+
+      if (!epicId || isNaN(epicId)) {
+        console.error('Error: Epic ID is required');
+        console.log('Usage: jettypod work epic-discover <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-discover 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-discover/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> [--prototypes="file1,file2"] [--winner="file.js"]');
+        process.exit(1);
+      }
+
+      // Parse optional --prototypes and --winner flags
+      const prototypesIndex = args.findIndex(a => a.startsWith('--prototypes='));
+      const winnerIndex = args.findIndex(a => a.startsWith('--winner='));
+
+      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;
+
+      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);
+        }
+
+        if (feature.phase !== 'discovery') {
+          console.error(`Error: Feature #${featureId} is not in discovery phase (current phase: ${feature.phase || 'implementation'})`);
+          console.log('');
+          console.log('Features can only be transitioned to implementation from discovery phase.');
+          process.exit(1);
+        }
+
+        // Validate that BDD scenarios exist before transitioning
+        if (!feature.scenario_file) {
+          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:');
+          console.log('  1. Generate scenarios using feature-discover skill');
+          console.log('  2. Or manually create scenarios at features/[feature-name].feature');
+          console.log('  3. Then run: jettypod work implement');
+          console.log('');
+          console.log('💡 Tip: Talk to Claude Code to complete feature discovery');
+          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(), feature.scenario_file);
+
+        if (!fs.existsSync(scenarioPath)) {
+          console.error(`Error: Scenario file not found: ${feature.scenario_file}`);
+          console.log('');
+          console.log('The scenario file path is in the database, but the file doesn\'t exist.');
+          console.log('');
+          console.log('To fix this:');
+          console.log(`  1. Create the file at: ${feature.scenario_file}`);
+          console.log('  2. Or run feature discovery again to regenerate scenarios');
+          console.log('');
+          console.log('💡 Tip: Talk to Claude Code to complete feature discovery');
+          process.exit(1);
+        }
+
+        // Transition to implementation phase, set mode to speed
+        const prototypeFilesValue = prototypes.length > 0 ? JSON.stringify(prototypes) : null;
+        const winnerValue = winner || null;
+
+        db.run(
+          `UPDATE work_items SET phase = 'implementation', mode = 'speed', prototype_files = ?, discovery_winner = ? WHERE id = ?`,
+          [prototypeFilesValue, winnerValue, featureId],
+          (err) => {
+            if (err) {
+              console.error(`Error: ${err.message}`);
+              process.exit(1);
+            }
+
+            console.log('');
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            console.log(`✅ Feature #${featureId} transitioned to Implementation Phase`);
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            console.log('');
+            console.log(`Title: ${feature.title}`);
+            console.log('Phase: Implementation');
+            console.log('Mode: Speed');
+            if (prototypes.length > 0) {
+              console.log(`Prototypes: ${prototypes.join(', ')}`);
+            }
+            if (winner) {
+              console.log(`Winner: ${winner}`);
+            }
+            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-discover 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-discover/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-discover 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-discover/SKILL.md');
+          }
+        });
+      });
+      break;
+    }
+
+    default:
+      console.log(`
+JettyPod Work Tracking
+
+Commands:
+  jettypod work create <type> <title> [desc] [--parent=ID]
+    Types: epic, feature, bug, chore
+
+  jettypod work tree
+    Show hierarchical view (active items only)
+
+  jettypod work completed
+    Show all completed work items
+
+  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();
+}