jettypod 4.4.37 → 4.4.39

package/lib/database.js

@@ -100,10 +100,16 @@ function getDb() {
       });
 
       // Enable WAL mode for better concurrency and avoid locking issues
-      db.run('PRAGMA journal_mode = WAL');
-      db.run('PRAGMA synchronous = NORMAL');
+      db.run('PRAGMA journal_mode = WAL', (err) => {
+        if (err) console.warn('PRAGMA journal_mode failed:', err.message);
+      });
+      db.run('PRAGMA synchronous = NORMAL', (err) => {
+        if (err) console.warn('PRAGMA synchronous failed:', err.message);
+      });
       // Reduce busy timeout to fail faster in tests
-      db.run('PRAGMA busy_timeout = 5000');
+      db.run('PRAGMA busy_timeout = 5000', (err) => {
+        if (err) console.warn('PRAGMA busy_timeout failed:', err.message);
+      });
 
       initSchema();
     } catch (err) {
@@ -141,6 +147,7 @@ function initSchema() {
           phase TEXT,
           prototype_files TEXT,
           discovery_winner TEXT,
+          discovery_rationale TEXT,
           scenario_file TEXT,
           completed_at TEXT,
           created_at DATETIME DEFAULT CURRENT_TIMESTAMP
@@ -196,29 +203,30 @@ function initSchema() {
         }
       });
 
-      // Migrations: Add columns if they don't exist
-      // Note: ALTER TABLE errors are expected if column exists, so we silently ignore them
-      db.run(`ALTER TABLE work_items ADD COLUMN branch_name TEXT`, () => {});
-      db.run(`ALTER TABLE work_items ADD COLUMN file_paths TEXT`, () => {});
-      db.run(`ALTER TABLE work_items ADD COLUMN commit_sha TEXT`, () => {});
-      db.run(`ALTER TABLE work_items ADD COLUMN mode TEXT`, () => {});
-      db.run(`ALTER TABLE work_items ADD COLUMN current INTEGER DEFAULT 0`, () => {});
-      db.run(`ALTER TABLE work_items ADD COLUMN needs_discovery INTEGER DEFAULT 0`, () => {});
-      // NOTE: phase column is handled by migration 006-feature-phase-field.js
-      // Do NOT add it here - the migration includes important data migration logic
-      // NOTE: completed_at column is handled by migration 011-add-completed-at.js
-      // Do NOT add it here - the migration system handles it properly
-      // NOTE: worktree_path column is handled by migration 012-add-worktree-path.js
-      db.run(`ALTER TABLE work_items ADD COLUMN worktree_path TEXT`, () => {});
-      db.run(`ALTER TABLE work_items ADD COLUMN architectural_decision TEXT`, async () => {
+      // Migrations: Add columns if they don't exist (for databases created before these columns were in base schema)
+      const handleAlterError = (columnName) => (err) => {
+        if (err && !err.message.includes('duplicate column')) {
+          console.warn(`ALTER TABLE ADD COLUMN ${columnName} failed:`, err.message);
+        }
+      };
+      db.run(`ALTER TABLE work_items ADD COLUMN branch_name TEXT`, handleAlterError('branch_name'));
+      db.run(`ALTER TABLE work_items ADD COLUMN file_paths TEXT`, handleAlterError('file_paths'));
+      db.run(`ALTER TABLE work_items ADD COLUMN commit_sha TEXT`, handleAlterError('commit_sha'));
+      db.run(`ALTER TABLE work_items ADD COLUMN mode TEXT`, handleAlterError('mode'));
+      db.run(`ALTER TABLE work_items ADD COLUMN current INTEGER DEFAULT 0`, handleAlterError('current'));
+      db.run(`ALTER TABLE work_items ADD COLUMN needs_discovery INTEGER DEFAULT 0`, handleAlterError('needs_discovery'));
+      db.run(`ALTER TABLE work_items ADD COLUMN worktree_path TEXT`, handleAlterError('worktree_path'));
+      db.run(`ALTER TABLE work_items ADD COLUMN discovery_rationale TEXT`, handleAlterError('discovery_rationale'));
+      db.run(`ALTER TABLE work_items ADD COLUMN architectural_decision TEXT`, async (err) => {
+        handleAlterError('architectural_decision')(err);
         // Run data migrations after all schema operations complete (skip in test environments)
         if (process.env.NODE_ENV !== 'test') {
           try {
             await runMigrations(db);
             resolve();
           } catch (err) {
-            // Silently ignore migration errors but still resolve - don't block startup
-            resolve();
+            console.error('Migration failed:', err.message);
+            reject(err);
           }
         } else {
           resolve();
@@ -228,11 +236,48 @@ function initSchema() {
   });
 }
 
+/**
+ * Validate that all expected columns exist in work_items table
+ * @param {sqlite3.Database} database - Database connection to validate
+ * @returns {Promise<void>} Resolves if valid, rejects with missing columns
+ */
+function validateSchema(database) {
+  const expectedColumns = [
+    'id', 'type', 'title', 'description', 'status', 'parent_id', 'epic_id',
+    'branch_name', 'file_paths', 'commit_sha', 'mode', 'current', 'phase',
+    'prototype_files', 'discovery_winner', 'discovery_rationale', 'scenario_file',
+    'completed_at', 'created_at', 'needs_discovery', 'worktree_path', 'architectural_decision'
+  ];
+
+  return new Promise((resolve, reject) => {
+    database.all(`PRAGMA table_info(work_items)`, [], (err, rows) => {
+      if (err) {
+        return reject(new Error(`Failed to get schema info: ${err.message}`));
+      }
+
+      const existingColumns = rows.map(r => r.name);
+      const missingColumns = expectedColumns.filter(col => !existingColumns.includes(col));
+
+      if (missingColumns.length > 0) {
+        console.error('Missing columns in work_items table:', missingColumns.join(', '));
+        return reject(new Error(`Schema validation failed: missing columns: ${missingColumns.join(', ')}`));
+      }
+
+      resolve();
+    });
+  });
+}
+
 /**
  * Close database connection
  * @returns {Promise<void>} Resolves when database is closed
  */
-function closeDb() {
+async function closeDb() {
+  // Wait for any pending migrations before closing
+  if (migrationPromise) {
+    try { await migrationPromise; } catch { /* ignore migration errors on close */ }
+  }
+
   return new Promise((resolve) => {
     // Guard against concurrent close attempts
     if (isClosing || !db) {
@@ -292,6 +337,7 @@ module.exports = {
   getDbPath,
   getJettypodDir,
   waitForMigrations,
+  validateSchema,
   dbPath,  // Deprecated: use getDbPath() for dynamic path
   jettypodDir  // Deprecated: use getJettypodDir() for dynamic path
 };

package/lib/merge-lock.js

@@ -115,18 +115,30 @@ function insertLock(db, workItemId, lockedBy) {
  * Clean up stale locks that are older than the threshold
  *
  * @param {Object} db - SQLite database connection
- * @param {number} staleThresholdMs - Age threshold in milliseconds (default: 120000 = 2 minutes)
- * @returns {Promise<void>}
+ * @param {number|Object} staleThresholdOrOptions - Age threshold in milliseconds (default: 120000), or options object with staleThreshold
+ * @returns {Promise<number>} Count of locks removed
  */
-function cleanupStaleLocks(db, staleThresholdMs = 120000) {
+function cleanupStaleLocks(db, staleThresholdOrOptions = 120000) {
+  if (!db) {
+    return Promise.reject(new Error('Database connection required'));
+  }
+
+  // Support both number (old API) and options object (new API)
+  let staleThresholdMs;
+  if (typeof staleThresholdOrOptions === 'object') {
+    staleThresholdMs = staleThresholdOrOptions.staleThreshold || 120000;
+  } else {
+    staleThresholdMs = staleThresholdOrOptions;
+  }
+
   return new Promise((resolve, reject) => {
     db.run(
       `DELETE FROM merge_locks
        WHERE (julianday('now') - julianday(locked_at)) * 86400000 > ?`,
       [staleThresholdMs],
-      (err) => {
+      function(err) {
         if (err) return reject(err);
-        resolve();
+        resolve(this.changes); // Return count of deleted locks
       }
     );
   });
@@ -179,33 +191,6 @@ function createLockHandle(db, lockId, lockedBy, workItemId) {
   };
 }
 
-/**
- * Clean up stale locks older than threshold
- *
- * @param {Object} db - SQLite database connection
- * @param {Object} options - Optional configuration
- * @param {number} options.staleThreshold - Age threshold in ms (default: 300000 = 5 minutes)
- * @returns {Promise<number>} Count of locks removed
- */
-async function cleanupStaleLocks(db, options = {}) {
-  if (!db) {
-    throw new Error('Database connection required');
-  }
-
-  const staleThreshold = options.staleThreshold || 300000; // 5 minutes default
-  const staleTime = new Date(Date.now() - staleThreshold).toISOString();
-
-  return new Promise((resolve, reject) => {
-    db.run(
-      'DELETE FROM merge_locks WHERE locked_at < ?',
-      [staleTime],
-      function(err) {
-        if (err) reject(err);
-        else resolve(this.changes); // Return count of deleted locks
-      }
-    );
-  });
-}
 
 /**
  * Sleep for specified milliseconds

package/lib/preflight-validator.js

@@ -0,0 +1,66 @@
+// Preflight Validator - validates prerequisites before workflow transitions
+// Speed mode implementation - checks scenario_file and chores exist
+
+const { getDb } = require('./database');
+
+/**
+ * Validate feature prerequisites before transitioning to implementation
+ * @param {number} featureId - Feature ID to validate
+ * @returns {Promise<{success: boolean, failures: Array<{check: string, remediation: string}>}>}
+ */
+function validateFeatureToImplement(featureId) {
+  return new Promise((resolve, reject) => {
+    const db = getDb();
+    const failures = [];
+
+    // Get feature details
+    db.get(
+      'SELECT id, title, type, phase, scenario_file FROM work_items WHERE id = ?',
+      [featureId],
+      (err, feature) => {
+        if (err) {
+          return reject(new Error(`Failed to get feature: ${err.message}`));
+        }
+
+        if (!feature) {
+          return reject(new Error(`Feature #${featureId} not found`));
+        }
+
+        // Check 1: scenario_file must be set
+        if (!feature.scenario_file) {
+          failures.push({
+            check: 'scenario_file',
+            remediation: 'Use the feature-planning skill to generate BDD scenarios first.\n  Invoke skill: feature-planning'
+          });
+        }
+
+        // Check 2: chores must exist
+        db.all(
+          'SELECT id, title FROM work_items WHERE parent_id = ? AND type = ?',
+          [featureId, 'chore'],
+          (err, chores) => {
+            if (err) {
+              return reject(new Error(`Failed to get chores: ${err.message}`));
+            }
+
+            if (!chores || chores.length === 0) {
+              failures.push({
+                check: 'chores_exist',
+                remediation: 'Complete feature planning to generate speed mode chores.\n  Invoke skill: feature-planning'
+              });
+            }
+
+            resolve({
+              success: failures.length === 0,
+              failures: failures
+            });
+          }
+        );
+      }
+    );
+  });
+}
+
+module.exports = {
+  validateFeatureToImplement
+};

package/lib/production-standards-reader.js

@@ -11,7 +11,7 @@ async function readStandards() {
 
   // Check file exists
   if (!fs.existsSync(standardsPath)) {
-    throw new Error('Production standards not found');
+    throw new Error('Production standards file not found');
   }
 
   // Read file with specific error handling
@@ -59,7 +59,7 @@ async function readStandards() {
 function validateStandardsFormat(standards) {
   // Validate standards object exists
   if (!standards) {
-    throw new Error('Invalid standards format: Standards object is null or undefined');
+    throw new Error('Standards object is null or undefined');
   }
 
   // Validate required top-level fields
@@ -98,7 +98,7 @@ function validateStandardsFormat(standards) {
     }
 
     if (!standard.acceptance) {
-      throw new Error(`Invalid standard format: missing acceptance field`);
+      throw new Error(`Standard ${standard.id} missing required field: acceptance`);
     }
 
     // Validate infrastructure-scoped standards have all required fields

package/lib/work-commands/index.js

@@ -55,7 +55,7 @@ async function startWork(id) {
     // Get work item
     db.get(`
       SELECT w.*,
-             p.title as parent_title, p.id as parent_id, p.scenario_file as parent_scenario_file, p.mode as parent_mode,
+             p.title as parent_title, p.id as parent_id, p.scenario_file as parent_scenario_file, p.mode as parent_mode, p.phase as parent_phase, 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
@@ -139,6 +139,18 @@ async function startWork(id) {
         return reject(new Error(`Cannot start epic #${id} directly.\n\nTo plan this epic's features, use the epic-planning skill:\n  Invoke skill: epic-planning\n\nOr start an existing feature/chore:\n  jettypod backlog  # to see available work items`));
       }
 
+      // Validate chores have their parent feature in implementation phase
+      if (workItem.type === 'chore' && workItem.parent_type === 'feature' && workItem.parent_phase !== 'implementation') {
+        return reject(new Error(
+          `Cannot start chore - feature not in implementation phase\n\n` +
+          `Chore #${id}: ${workItem.title}\n` +
+          `Parent Feature #${workItem.parent_id}: ${workItem.parent_title}\n` +
+          `  Phase: ${workItem.parent_phase || 'discovery'}\n\n` +
+          `To transition the feature to implementation phase:\n` +
+          `  jettypod work implement ${workItem.parent_id} --winner="..." --rationale="..."`
+        ));
+      }
+
       // Update status to in_progress if currently todo
       const finalStatus = workItem.status === 'todo' ? 'in_progress' : workItem.status;
 

package/lib/work-tracking/index.js

@@ -76,8 +76,8 @@ function create(type, title, description = '', parentId = null, mode = null, nee
           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) => {
+        // Check parent's mode, phase, and scenario_file
+        db.get('SELECT id, title, type, mode, phase, scenario_file, epic_id FROM work_items WHERE id = ?', [parentId], (err, parent) => {
           if (err) {
             return reject(new Error(`Failed to validate parent: ${err.message}`));
           }
@@ -90,19 +90,19 @@ function create(type, title, description = '', parentId = null, mode = null, nee
             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) {
+          // For chores under features, validate prerequisites exist
+          // Allow chores in discovery phase if scenario_file is set (feature-planning creates chores before work implement)
+          // Otherwise require mode to be set
+          if (parent.type === 'feature' && !parent.mode && !parent.scenario_file) {
             return reject(new Error(
-              `Cannot create chore for feature without a mode.\n\n` +
+              `Cannot create chore for feature without BDD scenarios.\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="..."`
+              `Chores can only be created after BDD scenarios are generated.\n\n` +
+              `Use the feature-planning skill to generate scenarios and chores:\n` +
+              `  Invoke skill: feature-planning`
             ));
           }
 
@@ -2006,6 +2006,9 @@ async function main() {
     }
 
     case 'implement': {
+      // Ensure migrations are complete before accessing database
+      await waitForMigrations();
+
       const featureId = parseInt(args[0]);
 
       if (!featureId || isNaN(featureId)) {
@@ -2057,14 +2060,15 @@ async function main() {
 
         // Validate that BDD scenarios exist (either from flag or database)
         if (!scenarioFile) {
-          console.error(`Error: Feature #${featureId} has no BDD scenarios`);
+          console.error(`Error: Cannot implement - 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('Use the feature-planning skill to generate BDD scenarios:');
+          console.log('  Invoke skill: feature-planning');
           console.log('');
-          console.log('Or generate scenarios using the feature-planning skill first.');
+          console.log('Or provide the scenario file directly:');
+          console.log(`  jettypod work implement ${featureId} --scenario-file="features/[feature-name].feature" --winner="..." --rationale="..."`);
           process.exit(1);
         }
 
@@ -2084,79 +2088,126 @@ async function main() {
           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) => {
+        // Check if chores exist - required before transitioning to implementation
+        db.all(
+          'SELECT id, title, status FROM work_items WHERE parent_id = ? AND type = ? ORDER BY created_at ASC',
+          [featureId, 'chore'],
+          (err, chores) => {
             if (err) {
-              console.error(`Error: ${err.message}`);
+              console.error(`Error checking chores: ${err.message}`);
               process.exit(1);
             }
 
-            console.log('');
-            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            if (!chores || chores.length === 0) {
+              console.error(`Error: Cannot implement - no chores exist`);
+              console.log('');
+              console.log('Feature planning must generate speed mode chores before transitioning to implementation.');
+              console.log('');
+              console.log('Complete feature planning first:');
+              console.log('  Invoke skill: feature-planning');
+              process.exit(1);
+            }
+
+            // Get first chore for auto-start
+            const firstChore = chores[0];
+
+            // 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) {
-              console.log(`✅ Feature #${featureId} transitioned to Implementation Phase`);
+              // 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 {
-              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(', ')}`);
+              updateSql = `UPDATE work_items SET prototype_files = ?, discovery_winner = ?, discovery_rationale = ? WHERE id = ?`;
+              updateParams = [prototypeFilesValue, winnerValue, rationaleValue, featureId];
             }
-            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('');
+
+            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}`);
+                }
+
+                // Auto-start first chore if transitioning
+                if (isTransition && firstChore) {
+                  console.log('');
+                  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+                  console.log('🚀 Auto-starting first chore...');
+                  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+                  // Import and call startWork
+                  const { startWork } = require('../work-commands');
+                  startWork(firstChore.id).then(() => {
+                    console.log('');
+                    console.log('✅ First chore started! Invoke skill: speed-mode');
+                    console.log('');
+                  }).catch((startErr) => {
+                    console.log('');
+                    console.log(`⚠️  Feature transitioned but failed to auto-start chore: ${startErr.message}`);
+                    console.log(`   Manually start with: jettypod work start ${firstChore.id}`);
+                    console.log('');
+                  });
+                } else {
+                  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('');
+                }
+              }
+            );
           }
         );
       });

package/package.json

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