jettypod 4.4.45 → 4.4.46

package/jettypod.js

@@ -1303,6 +1303,23 @@ switch (command) {
         console.error(`Error: ${err.message}`);
         process.exit(1);
       }
+    } else if (subcommand === 'tests') {
+      // Create worktree for writing BDD tests
+      const featureId = parseInt(args[1]);
+      if (!featureId) {
+        console.log('Usage: jettypod work tests <feature-id>');
+        console.log('');
+        console.log('Creates a worktree for writing BDD tests for a feature.');
+        console.log('Tests are written in isolation, then merged with: jettypod work merge');
+        process.exit(1);
+      }
+      const workCommands = require('./lib/work-commands/index.js');
+      try {
+        await workCommands.testsWork(featureId);
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
     } else {
       // CRITICAL SAFETY CHECK: Prevent work status changes from within a worktree
       // This prevents cleanup failures and orphaned worktrees
@@ -2303,76 +2320,127 @@ Quick commands:
     const workflowSubcommand = args[0];
 
     if (workflowSubcommand === 'status') {
+      // workflow status <work-item-id> - shows skill execution history for a work item
+      const workItemId = args[1] ? parseInt(args[1]) : null;
       const { getDb, waitForMigrations } = require('./lib/database');
-      const { getCurrentBranch } = require('./lib/workflow-checkpoint');
 
       try {
         const db = getDb();
         await waitForMigrations();
-        const currentBranch = getCurrentBranch();
 
-        const checkpoints = await new Promise((resolve, reject) => {
-          db.all(
-            `SELECT * FROM workflow_checkpoints ORDER BY updated_at DESC`,
-            [],
-            (err, rows) => {
-              if (err) reject(err);
-              else resolve(rows || []);
+        if (workItemId) {
+          // Show skill executions for specific work item
+          const executions = await new Promise((resolve, reject) => {
+            db.all(
+              `SELECT * FROM skill_executions WHERE work_item_id = ? ORDER BY started_at ASC`,
+              [workItemId],
+              (err, rows) => {
+                if (err) reject(err);
+                else resolve(rows || []);
+              }
+            );
+          });
+
+          const gates = await new Promise((resolve, reject) => {
+            db.all(
+              `SELECT * FROM workflow_gates WHERE work_item_id = ?`,
+              [workItemId],
+              (err, rows) => {
+                if (err) reject(err);
+                else resolve(rows || []);
+              }
+            );
+          });
+
+          console.log(`Workflow Status for #${workItemId}`);
+          console.log('─'.repeat(50));
+          console.log('');
+          console.log('Skill Executions:');
+          if (executions.length === 0) {
+            console.log('  (none)');
+          } else {
+            for (const exec of executions) {
+              console.log(`  ${exec.skill_name}: ${exec.status}`);
             }
-          );
-        });
+          }
 
-        if (checkpoints.length === 0) {
-          console.log('No interrupted workflows found.');
-        } else {
-          console.log('Interrupted Workflows');
-          console.log('─'.repeat(90));
           console.log('');
-          console.log(
-            'ID'.padEnd(4) +
-            'Skill'.padEnd(18) +
-            'Step'.padEnd(10) +
-            'Work Item'.padEnd(12) +
-            'Branch'.padEnd(38) +
-            'Last Active'
-          );
-          console.log('─'.repeat(90));
-
-          for (const cp of checkpoints) {
-            const stepInfo = cp.total_steps
-              ? `${cp.current_step}/${cp.total_steps}`
-              : `${cp.current_step}`;
-            const isCurrent = cp.branch_name === currentBranch;
-            const branchDisplay = cp.branch_name.length > 35
-              ? cp.branch_name.substring(0, 32) + '...'
-              : cp.branch_name;
-            const branchWithMarker = branchDisplay + (isCurrent ? ' *' : '');
-
-            // Format time ago
-            const updatedAt = new Date(cp.updated_at);
-            const now = new Date();
-            const diffMs = now - updatedAt;
-            const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
-            const diffDays = Math.floor(diffHours / 24);
-            const timeAgo = diffDays > 0 ? `${diffDays}d ago` : diffHours > 0 ? `${diffHours}h ago` : 'just now';
+          console.log('Gates:');
+          if (gates.length === 0) {
+            console.log('  (none)');
+          } else {
+            for (const gate of gates) {
+              console.log(`  ${gate.gate_name}: ${gate.passed_at ? 'PASSED' : 'NOT PASSED'}`);
+            }
+          }
+        } else {
+          // No ID - show all interrupted workflows (legacy behavior)
+          const { getCurrentBranch } = require('./lib/workflow-checkpoint');
+          const currentBranch = getCurrentBranch();
 
+          const checkpoints = await new Promise((resolve, reject) => {
+            db.all(
+              `SELECT * FROM workflow_checkpoints ORDER BY updated_at DESC`,
+              [],
+              (err, rows) => {
+                if (err) reject(err);
+                else resolve(rows || []);
+              }
+            );
+          });
+
+          if (checkpoints.length === 0) {
+            console.log('No interrupted workflows found.');
+          } else {
+            console.log('Interrupted Workflows');
+            console.log('─'.repeat(90));
+            console.log('');
             console.log(
-              String(cp.id).padEnd(4) +
-              cp.skill_name.padEnd(18) +
-              stepInfo.padEnd(10) +
-              `#${cp.work_item_id || '-'}`.padEnd(12) +
-              branchWithMarker.padEnd(38) +
-              timeAgo
+              'ID'.padEnd(4) +
+              'Skill'.padEnd(18) +
+              'Step'.padEnd(10) +
+              'Work Item'.padEnd(12) +
+              'Branch'.padEnd(38) +
+              'Last Active'
             );
-          }
+            console.log('─'.repeat(90));
+
+            for (const cp of checkpoints) {
+              const stepInfo = cp.total_steps
+                ? `${cp.current_step}/${cp.total_steps}`
+                : `${cp.current_step}`;
+              const isCurrent = cp.branch_name === currentBranch;
+              const branchDisplay = cp.branch_name.length > 35
+                ? cp.branch_name.substring(0, 32) + '...'
+                : cp.branch_name;
+              const branchWithMarker = branchDisplay + (isCurrent ? ' *' : '');
+
+              // Format time ago
+              const updatedAt = new Date(cp.updated_at);
+              const now = new Date();
+              const diffMs = now - updatedAt;
+              const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+              const diffDays = Math.floor(diffHours / 24);
+              const timeAgo = diffDays > 0 ? `${diffDays}d ago` : diffHours > 0 ? `${diffHours}h ago` : 'just now';
+
+              console.log(
+                String(cp.id).padEnd(4) +
+                cp.skill_name.padEnd(18) +
+                stepInfo.padEnd(10) +
+                `#${cp.work_item_id || '-'}`.padEnd(12) +
+                branchWithMarker.padEnd(38) +
+                timeAgo
+              );
+            }
 
-          console.log('');
-          console.log(`${checkpoints.length} interrupted workflow(s)`);
-          console.log('');
-          console.log('Commands:');
-          console.log('  jettypod workflow show <id>     Show workflow details');
-          console.log('  jettypod workflow resume <id>   Resume a workflow');
-          console.log('  jettypod workflow abort <id>    Abort and clean up a workflow');
+            console.log('');
+            console.log(`${checkpoints.length} interrupted workflow(s)`);
+            console.log('');
+            console.log('Commands:');
+            console.log('  jettypod workflow show <id>     Show workflow details');
+            console.log('  jettypod workflow resume <id>   Resume a workflow');
+            console.log('  jettypod workflow abort <id>    Abort and clean up a workflow');
+          }
         }
       } catch (err) {
         console.error(`Error: ${err.message}`);
@@ -2435,73 +2503,44 @@ Quick commands:
         process.exit(1);
       }
     } else if (workflowSubcommand === 'resume') {
+      // workflow resume - finds interrupted workflows (in-progress skill executions)
       const { getDb, waitForMigrations } = require('./lib/database');
-      const { getCheckpoint, getCurrentBranch } = require('./lib/workflow-checkpoint');
 
       try {
         const db = getDb();
         await waitForMigrations();
-        const currentBranch = getCurrentBranch();
-        const workflowId = args[1] ? parseInt(args[1]) : null;
 
-        let checkpoint;
-
-        if (workflowId) {
-          // Resume by ID - fetch specific workflow
-          checkpoint = await new Promise((resolve, reject) => {
-            db.get(
-              `SELECT * FROM workflow_checkpoints WHERE id = ?`,
-              [workflowId],
-              (err, row) => {
-                if (err) reject(err);
-                else resolve(row);
-              }
-            );
-          });
+        // Find all in-progress skill executions
+        const inProgressExecutions = await new Promise((resolve, reject) => {
+          db.all(
+            `SELECT se.*, wi.title as work_item_title
+             FROM skill_executions se
+             LEFT JOIN work_items wi ON se.work_item_id = wi.id
+             WHERE se.status = 'in_progress'
+             ORDER BY se.started_at DESC`,
+            [],
+            (err, rows) => {
+              if (err) reject(err);
+              else resolve(rows || []);
+            }
+          );
+        });
 
-          if (!checkpoint) {
-            console.log(`Error: No workflow found with ID ${workflowId}`);
-            console.log('');
-            console.log('Use "jettypod workflow status" to see available workflows.');
-            process.exit(1);
-          }
+        if (inProgressExecutions.length === 0) {
+          console.log('No interrupted workflow found');
         } else {
-          // No ID - check current branch
-          checkpoint = await getCheckpoint(db, currentBranch);
-
-          if (!checkpoint) {
-            console.log('No interrupted workflow on current branch.');
+          for (const exec of inProgressExecutions) {
+            console.log('Found interrupted workflow:');
+            console.log(`  Skill: ${exec.skill_name}`);
+            console.log(`  Work Item: #${exec.work_item_id}${exec.work_item_title ? ` - ${exec.work_item_title}` : ''}`);
+            console.log(`  Step ${exec.step_reached}`);
+            console.log(`  Started: ${exec.started_at}`);
+            if (exec.context_json) {
+              console.log(`  Context: ${exec.context_json}`);
+            }
             console.log('');
-            console.log('Use "jettypod workflow status" to see workflows on other branches,');
-            console.log('or specify an ID: "jettypod workflow resume <id>"');
-            process.exit(0);
           }
         }
-
-        // Display resume info
-        const stepInfo = checkpoint.total_steps
-          ? `Step ${checkpoint.current_step} of ${checkpoint.total_steps}`
-          : `Step ${checkpoint.current_step}`;
-
-        const needsBranchSwitch = checkpoint.branch_name !== currentBranch;
-
-        console.log('Resuming Workflow');
-        console.log('─'.repeat(50));
-        console.log('');
-        console.log(`  Skill:      ${checkpoint.skill_name}`);
-        console.log(`  Progress:   ${stepInfo}`);
-        console.log(`  Work Item:  ${checkpoint.work_item_id ? '#' + checkpoint.work_item_id : '-'}`);
-        console.log(`  Branch:     ${checkpoint.branch_name}`);
-        console.log('');
-
-        if (needsBranchSwitch) {
-          console.log(`Switching to branch: ${checkpoint.branch_name}`);
-          console.log('');
-        }
-
-        console.log('[Triggering skill continuation]');
-        // Note: Actual skill triggering would be implemented here
-        // For now, this displays the intent to continue the workflow
       } catch (err) {
         console.error(`Error: ${err.message}`);
         process.exit(1);
@@ -2580,14 +2619,343 @@ Quick commands:
         console.error(`Error: ${err.message}`);
         process.exit(1);
       }
+    } else if (workflowSubcommand === 'start') {
+      // workflow start <skill> <work-item-id>
+      // Validates gates, creates skill execution record
+      const skillName = args[1];
+      const workItemId = parseInt(args[2]);
+
+      if (!skillName || !workItemId) {
+        console.log('Usage: jettypod workflow start <skill> <work-item-id>');
+        console.log('');
+        console.log('Starts a skill for a work item after validating prerequisite gates.');
+        console.log('');
+        console.log('Example: jettypod workflow start speed-mode 42');
+        process.exit(1);
+      }
+
+      const { getDb, waitForMigrations } = require('./lib/database');
+
+      try {
+        const db = getDb();
+        await waitForMigrations();
+
+        // Define gate requirements for each skill
+        const gateRequirements = {
+          'speed-mode': ['feature_planning_complete'],
+          'stable-mode': ['speed_mode_complete'],
+          'production-mode': ['stable_mode_complete'],
+          'feature-planning': [],
+          'epic-planning': []
+        };
+
+        const requiredGates = gateRequirements[skillName] || [];
+
+        // Check prerequisite gates
+        const passedGates = await new Promise((resolve, reject) => {
+          db.all(
+            `SELECT gate_name FROM workflow_gates WHERE work_item_id = ? AND passed_at IS NOT NULL`,
+            [workItemId],
+            (err, rows) => {
+              if (err) reject(err);
+              else resolve(rows ? rows.map(r => r.gate_name) : []);
+            }
+          );
+        });
+
+        const missingGates = requiredGates.filter(g => !passedGates.includes(g));
+
+        if (missingGates.length > 0) {
+          console.log(`Gate validation failed: ${missingGates.join(', ')}`);
+          process.exit(1);
+        }
+
+        // Create skill execution record
+        await new Promise((resolve, reject) => {
+          db.run(
+            `INSERT INTO skill_executions (work_item_id, skill_name, status, step_reached)
+             VALUES (?, ?, 'in_progress', 1)`,
+            [workItemId, skillName],
+            (err) => {
+              if (err) reject(err);
+              else resolve();
+            }
+          );
+        });
+
+        console.log(`Started ${skillName} for #${workItemId}`);
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    } else if (workflowSubcommand === 'complete') {
+      // workflow complete <skill> <work-item-id>
+      // Marks skill execution as completed, passes output gate
+      const skillName = args[1];
+      const workItemId = parseInt(args[2]);
+
+      if (!skillName || !workItemId) {
+        console.log('Usage: jettypod workflow complete <skill> <work-item-id>');
+        console.log('');
+        console.log('Completes a skill and marks its output gate as passed.');
+        console.log('');
+        console.log('Example: jettypod workflow complete speed-mode 42');
+        process.exit(1);
+      }
+
+      const { getDb, waitForMigrations } = require('./lib/database');
+
+      try {
+        const db = getDb();
+        await waitForMigrations();
+
+        // Check if skill is in progress
+        const execution = await new Promise((resolve, reject) => {
+          db.get(
+            `SELECT * FROM skill_executions WHERE work_item_id = ? AND skill_name = ? AND status = 'in_progress'`,
+            [workItemId, skillName],
+            (err, row) => {
+              if (err) reject(err);
+              else resolve(row);
+            }
+          );
+        });
+
+        if (!execution) {
+          console.log(`No in-progress execution found for ${skillName} on #${workItemId}`);
+          process.exit(1);
+        }
+
+        // Update skill execution to completed
+        await new Promise((resolve, reject) => {
+          db.run(
+            `UPDATE skill_executions SET status = 'completed', completed_at = datetime('now')
+             WHERE work_item_id = ? AND skill_name = ? AND status = 'in_progress'`,
+            [workItemId, skillName],
+            (err) => {
+              if (err) reject(err);
+              else resolve();
+            }
+          );
+        });
+
+        // Mark output gate as passed
+        const outputGate = `${skillName.replace(/-/g, '_')}_complete`;
+        await new Promise((resolve, reject) => {
+          db.run(
+            `INSERT OR REPLACE INTO workflow_gates (work_item_id, gate_name, passed_at)
+             VALUES (?, ?, datetime('now'))`,
+            [workItemId, outputGate],
+            (err) => {
+              if (err) reject(err);
+              else resolve();
+            }
+          );
+        });
+
+        console.log(`Completed ${skillName} for #${workItemId}`);
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    } else if (workflowSubcommand === 'checkpoint') {
+      // workflow checkpoint <work-item-id> --step=N [--context='{"key":"value"}']
+      // Updates step progress and optionally stores context
+      const workItemId = parseInt(args[1]);
+      const stepArg = args.find(a => a.startsWith('--step='));
+      const contextArg = args.find(a => a.startsWith('--context='));
+
+      if (!workItemId) {
+        console.log('Usage: jettypod workflow checkpoint <work-item-id> --step=N [--context=JSON]');
+        console.log('');
+        console.log('Updates checkpoint progress for an in-progress skill execution.');
+        console.log('');
+        console.log('Example: jettypod workflow checkpoint 42 --step=3');
+        console.log('Example: jettypod workflow checkpoint 42 --step=2 --context=\'{"iteration":5}\'');
+        process.exit(1);
+      }
+
+      const { getDb, waitForMigrations } = require('./lib/database');
+
+      try {
+        const db = getDb();
+        await waitForMigrations();
+
+        // Find in-progress skill execution
+        const execution = await new Promise((resolve, reject) => {
+          db.get(
+            `SELECT * FROM skill_executions WHERE work_item_id = ? AND status = 'in_progress'`,
+            [workItemId],
+            (err, row) => {
+              if (err) reject(err);
+              else resolve(row);
+            }
+          );
+        });
+
+        if (!execution) {
+          console.log(`No in-progress skill execution found for #${workItemId}`);
+          process.exit(1);
+        }
+
+        // Build update query
+        const updates = [];
+        const values = [];
+
+        if (stepArg) {
+          const step = parseInt(stepArg.split('=')[1]);
+          updates.push('step_reached = ?');
+          values.push(step);
+        }
+
+        if (contextArg) {
+          const contextJson = contextArg.split('=').slice(1).join('=').replace(/^'|'$/g, '');
+          updates.push('context_json = ?');
+          values.push(contextJson);
+        }
+
+        if (updates.length === 0) {
+          console.log('No updates specified. Use --step=N and/or --context=JSON');
+          process.exit(1);
+        }
+
+        values.push(workItemId);
+
+        await new Promise((resolve, reject) => {
+          db.run(
+            `UPDATE skill_executions SET ${updates.join(', ')} WHERE work_item_id = ? AND status = 'in_progress'`,
+            values,
+            (err) => {
+              if (err) reject(err);
+              else resolve();
+            }
+          );
+        });
+
+        console.log(`Checkpoint updated for #${workItemId}`);
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    } else if (workflowSubcommand === 'gate') {
+      // workflow gate pass <work-item-id> <gate-name>
+      // workflow gate check <work-item-id>
+      const gateAction = args[1];
+      const workItemId = parseInt(args[2]);
+
+      if (!gateAction || !workItemId) {
+        console.log('Usage: jettypod workflow gate <action> <work-item-id> [gate-name]');
+        console.log('');
+        console.log('Actions:');
+        console.log('  pass <id> <gate>   Mark a gate as passed');
+        console.log('  check <id>         Show all gates for a work item');
+        console.log('');
+        console.log('Example: jettypod workflow gate pass 42 feature_planning_complete');
+        console.log('Example: jettypod workflow gate check 42');
+        process.exit(1);
+      }
+
+      const { getDb, waitForMigrations } = require('./lib/database');
+
+      try {
+        const db = getDb();
+        await waitForMigrations();
+
+        if (gateAction === 'pass') {
+          const gateName = args[3];
+
+          if (!gateName) {
+            console.log('Usage: jettypod workflow gate pass <work-item-id> <gate-name>');
+            process.exit(1);
+          }
+
+          await new Promise((resolve, reject) => {
+            db.run(
+              `INSERT OR REPLACE INTO workflow_gates (work_item_id, gate_name, passed_at)
+               VALUES (?, ?, datetime('now'))`,
+              [workItemId, gateName],
+              (err) => {
+                if (err) reject(err);
+                else resolve();
+              }
+            );
+          });
+
+          console.log(`Gate passed: ${gateName}`);
+        } else if (gateAction === 'check') {
+          // Get all known gates for this skill workflow
+          const knownGates = [
+            'feature_planning_complete',
+            'speed_mode_complete',
+            'stable_mode_complete',
+            'production_mode_complete'
+          ];
+
+          const passedGates = await new Promise((resolve, reject) => {
+            db.all(
+              `SELECT gate_name, passed_at FROM workflow_gates WHERE work_item_id = ?`,
+              [workItemId],
+              (err, rows) => {
+                if (err) reject(err);
+                else resolve(rows || []);
+              }
+            );
+          });
+
+          const passedGateMap = {};
+          for (const g of passedGates) {
+            passedGateMap[g.gate_name] = g.passed_at;
+          }
+
+          console.log(`Gates for #${workItemId}:`);
+          console.log('');
+
+          for (const gateName of knownGates) {
+            if (passedGateMap[gateName]) {
+              console.log(`${gateName}: PASSED`);
+            } else {
+              console.log(`${gateName}: NOT PASSED`);
+            }
+          }
+
+          // Also show any custom gates
+          const customGates = passedGates.filter(g => !knownGates.includes(g.gate_name));
+          for (const g of customGates) {
+            console.log(`${g.gate_name}: PASSED`);
+          }
+        } else {
+          console.log(`Unknown gate action: ${gateAction}`);
+          console.log('Use "pass" or "check"');
+          process.exit(1);
+        }
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    } else if (workflowSubcommand === '--help') {
+      console.log('Usage: jettypod workflow <command>');
+      console.log('');
+      console.log('Commands:');
+      console.log('  start <skill> <id>       Start a skill for a work item (validates gates)');
+      console.log('  complete <skill> <id>    Complete a skill (marks gates passed)');
+      console.log('  checkpoint <id>          Update checkpoint progress');
+      console.log('  gate <action> <id>       Manage workflow gates');
+      console.log('  resume                   Find interrupted workflows');
+      console.log('  status <id>              Show workflow status for a work item');
+      console.log('');
+      console.log('Legacy Commands:');
+      console.log('  show <id>                Show checkpoint details');
+      console.log('  abort <id>               Abort a checkpoint');
     } else {
       console.log('Usage: jettypod workflow <command>');
       console.log('');
       console.log('Commands:');
-      console.log('  status          List all interrupted workflows');
-      console.log('  show <id>       Show workflow details');
-      console.log('  resume [id]     Resume a workflow');
-      console.log('  abort <id>      Abort and clean up a workflow');
+      console.log('  start <skill> <id>       Start a skill for a work item (validates gates)');
+      console.log('  complete <skill> <id>    Complete a skill (marks gates passed)');
+      console.log('  checkpoint <id>          Update checkpoint progress');
+      console.log('  gate <action> <id>       Manage workflow gates');
+      console.log('  resume                   Find interrupted workflows');
+      console.log('  status <id>              Show workflow status for a work item');
     }
     break;
   }

package/lib/database.js

@@ -203,6 +203,39 @@ function initSchema() {
         }
       });
 
+      db.run(`
+        CREATE TABLE IF NOT EXISTS skill_executions (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          work_item_id INTEGER NOT NULL,
+          skill_name TEXT NOT NULL,
+          status TEXT DEFAULT 'in_progress',
+          step_reached INTEGER DEFAULT 1,
+          context_json TEXT,
+          started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+          completed_at DATETIME,
+          FOREIGN KEY (work_item_id) REFERENCES work_items(id)
+        )
+      `, (err) => {
+        if (err) {
+          throw new Error(`Failed to create skill_executions table: ${err.message}`);
+        }
+      });
+
+      db.run(`
+        CREATE TABLE IF NOT EXISTS workflow_gates (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          work_item_id INTEGER NOT NULL,
+          gate_name TEXT NOT NULL,
+          passed_at DATETIME,
+          UNIQUE(work_item_id, gate_name),
+          FOREIGN KEY (work_item_id) REFERENCES work_items(id)
+        )
+      `, (err) => {
+        if (err) {
+          throw new Error(`Failed to create workflow_gates table: ${err.message}`);
+        }
+      });
+
       // 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')) {

package/lib/work-commands/index.js

@@ -1629,10 +1629,82 @@ async function mergeWork(options = {}) {
   }
 }
 
+/**
+ * Create a worktree for writing BDD tests for a feature
+ * @param {number} featureId - Feature ID to create test worktree for
+ * @returns {Promise<Object>} Worktree info with path and branch
+ * @throws {Error} If feature not found or not in correct phase
+ */
+async function testsWork(featureId) {
+  if (!featureId || isNaN(featureId) || featureId < 1) {
+    return Promise.reject(new Error('Invalid feature ID'));
+  }
+
+  const paths = getPaths();
+
+  if (!fs.existsSync(paths.jettypodDir)) {
+    return Promise.reject(new Error('JettyPod not initialized. Run: jettypod init'));
+  }
+
+  if (!fs.existsSync(paths.dbPath)) {
+    return Promise.reject(new Error('Work database not found. Run: jettypod init'));
+  }
+
+  const db = getDb();
+
+  return new Promise((resolve, reject) => {
+    // Get feature work item
+    db.get(
+      `SELECT * FROM work_items WHERE id = ? AND type = 'feature'`,
+      [featureId],
+      async (err, feature) => {
+        if (err) {
+          return reject(new Error(`Database error: ${err.message}`));
+        }
+
+        if (!feature) {
+          return reject(new Error(`Feature #${featureId} not found`));
+        }
+
+        // Create worktree with tests/ prefix
+        try {
+          const gitRoot = getGitRoot();
+          const worktreeResult = await worktreeManager.createWorktree(feature, {
+            repoPath: gitRoot,
+            branchPrefix: 'tests/feature',
+            pathPrefix: 'tests-'
+          });
+
+          // Set as current work
+          setCurrentWork({
+            id: feature.id,
+            type: feature.type,
+            title: feature.title,
+            status: feature.status || 'in_progress',
+            worktreePath: worktreeResult.worktree_path,
+            branchName: worktreeResult.branch_name
+          });
+
+          console.log(`✅ Created test worktree: ${worktreeResult.worktree_path}`);
+          console.log(`📁 IMPORTANT: Use absolute paths for file operations:`);
+          console.log(`   ${worktreeResult.worktree_path}/features/your-feature.feature (correct)`);
+          console.log(`   features/your-feature.feature (wrong - creates in main repo)`);
+          console.log(`\nWorking on tests for: [#${feature.id}] ${feature.title}`);
+
+          resolve(worktreeResult);
+        } catch (worktreeErr) {
+          reject(new Error(`Failed to create test worktree: ${worktreeErr.message}`));
+        }
+      }
+    );
+  });
+}
+
 module.exports = {
   startWork,
   stopWork,
   getCurrentWork,
   cleanupWorktrees,
-  mergeWork
+  mergeWork,
+  testsWork
 };

package/lib/worktree-manager.js

@@ -29,6 +29,8 @@ const VALID_STATUSES = ['active', 'merging', 'cleanup_pending', 'corrupted'];
  * @param {Object} options - Optional configuration
  * @param {string} options.repoPath - Path to git repository (defaults to process.cwd())
  * @param {Object} options.db - Database connection (defaults to global database)
+ * @param {string} options.branchPrefix - Branch prefix (defaults to 'feature/work')
+ * @param {string} options.pathPrefix - Worktree path prefix (defaults to '')
  * @returns {Promise<Object>} Worktree record with id, work_item_id, branch_name, worktree_path, status
  */
 async function createWorktree(workItem, options = {}) {
@@ -85,9 +87,11 @@ async function createWorktree(workItem, options = {}) {
 
   // Generate branch name and worktree path
   const titleSlug = slugify(workItem.title || 'item');
-  const branchName = `feature/work-${workItem.id}-${titleSlug}`;
+  const branchPrefix = options.branchPrefix || 'feature/work';
+  const pathPrefix = options.pathPrefix || '';
+  const branchName = `${branchPrefix}-${workItem.id}-${titleSlug}`;
   const worktreeBasePath = path.join(gitRoot, '.jettypod-work');
-  const worktreePath = path.join(worktreeBasePath, `${workItem.id}-${titleSlug}`);
+  const worktreePath = path.join(worktreeBasePath, `${pathPrefix}${workItem.id}-${titleSlug}`);
 
   let worktreeId = null;
   let branchCreated = false;

package/package.json

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

package/skills-templates/feature-planning/SKILL.md

@@ -13,20 +13,23 @@ When this skill is activated, you are helping discover the best approach for a f
 
 ## 🔑 Critical Command Distinction
 
-**Two different commands, two different purposes:**
+**Four different commands, four different purposes:**
 
 | Command | Used For | When | Phase |
 |---------|----------|------|-------|
-| `work implement <feature-id>` | Transition feature to implementation phase | During feature planning (Step 8B) | Feature Planning |
-| `work start <chore-id>` | Start implementing a specific chore | After feature planning complete (Step 8D) | Speed Mode |
+| `work implement <feature-id>` | Transition feature to implementation phase | After chores created (Step 8C) | Feature Planning |
+| `work tests start <feature-id>` | Create worktree for test authoring | After transition (Step 8D) | Feature Planning |
+| `work tests merge <feature-id>` | Merge tests to main, cleanup worktree | After tests validated (Step 8D) | Feature Planning |
+| `work start <chore-id>` | Start implementing a specific chore | After tests merged (Step 8E) | Speed Mode |
 
-**CRITICAL:** Both commands are run by **Claude**, not the user. The distinction is:
-- `work implement` = Ends feature planning, creates chores
-- `work start` = Creates worktree/branch for chore (does NOT auto-invoke speed-mode)
+**CRITICAL:** All commands are run by **Claude**, not the user. The distinction is:
+- `work implement` = Ends feature planning, transitions to implementation phase
+- `work tests start/merge` = Write and land BDD tests in isolated worktree
+- `work start` = Creates worktree/branch for chore implementation
 
-**🛑 STOP GATE:** DO NOT run `work start` until Step 8D. If you're in Steps 1-8C, use `work implement` only.
+**🛑 STOP GATE:** DO NOT run `work start` until Step 8E. Tests must be merged to main first.
 
-**🛑 HANDOFF REQUIREMENT:** After `work start`, you MUST invoke speed-mode using the Skill tool. See Step 8D.
+**🛑 HANDOFF REQUIREMENT:** After `work start`, you MUST invoke speed-mode using the Skill tool. See Step 8E.
 
 ---
 
@@ -224,9 +227,9 @@ Example:
 
 **WAIT for user to confirm or adjust the integration contract.**
 
-#### Step 6B: Generate BDD Scenarios AND Step Definitions
+#### Step 6B: Propose BDD Scenarios (DO NOT WRITE YET)
 
-**CRITICAL:** BDD scenarios and step definitions must ALWAYS be created together. Never create scenarios without step definitions.
+**CRITICAL:** Do NOT write files yet. Display the proposed scenarios for user confirmation. Files will be written in Step 8D inside an isolated worktree.
 
 **Feature slug:** Derive `FEATURE_SLUG` from the feature title:
 - Lowercase
@@ -234,43 +237,79 @@ Example:
 - Remove special characters
 - Examples: "Email Password Login" → "email-password-login", "User's Profile (v2)" → "users-profile-v2"
 
-Based on chosen approach, generate:
+Based on chosen approach, **display** the proposed scenarios to the user:
 
-**A. Scenario file** at `features/[feature-slug].feature` using Write tool:
+```
+📋 Proposed BDD Scenarios
 
-1. **Create file** at `features/[feature-slug].feature` using Write tool
-2. **FIRST scenario MUST be the Integration Scenario** from Step 6A (proves reachability)
-3. **Include all "make it work" scenarios**:
-   - All success paths - required functionality AND optional features
-   - Multiple valid workflows if the feature supports them
-   - Success variations (different outcomes that are all correct)
-   - NO error handling scenarios (added in stable mode)
-   - NO validation failures (added in stable mode)
-   - NO security/compliance scenarios (added in production mode)
+**Feature file:** features/[feature-slug].feature
+**Step definitions:** features/step_definitions/[feature-slug].steps.js
+```
 
-**B. Step definitions file** at `features/step_definitions/[feature-slug].steps.js` using Write tool:
+Then show the full Gherkin content:
 
-1. **Create file** at `features/step_definitions/[feature-slug].steps.js`
-2. **Implement all Given/When/Then steps** from the scenarios
-3. **Follow existing patterns** - check other `.steps.js` files for conventions
-4. **Include**:
-   - Test environment setup/cleanup
-   - All Given steps (setup state)
-   - All When steps (execute actions)
-   - All Then steps (verify outcomes)
+```gherkin
+Feature: [Feature Name]
+  [Brief description based on chosen UX approach]
 
-**C. Update database** with scenario file path (run from project root):
+  Epic: [Epic name if applicable]
+  Approach: [Chosen approach name]
 
-```bash
-sqlite3 .jettypod/work.db "UPDATE work_items SET scenario_file = 'features/${FEATURE_SLUG}.feature' WHERE id = ${FEATURE_ID}"
+  # Integration Contract:
+  # Entry Point: [from Step 6A]
+  # Caller Code: [from Step 6A]
+
+# INTEGRATION SCENARIO (REQUIRED - proves feature is reachable)
+Scenario: User can reach [feature] from [entry point]
+  Given I am on [existing entry point users can access]
+  When I [navigate/click/invoke to reach the feature]
+  Then I [see/access the feature]
+
+# FEATURE SCENARIOS (required + optional functionality)
+Scenario: [Core functionality - required workflow]
+  Given [initial state]
+  When [user takes main action]
+  Then [expected successful outcome]
+  And [observable UI/system state change]
+
+Scenario: [Optional feature 1 - if applicable]
+  Given [initial state]
+  When [user uses optional feature]
+  Then [feature works correctly]
+
+# SPEED MODE: All success scenarios above (integration + required + optional)
+# STABLE MODE: Will add error handling, validation failures, edge cases
 ```
 
-Replace `${FEATURE_SLUG}` and `${FEATURE_ID}` with actual values. Example:
-```bash
-sqlite3 .jettypod/work.db "UPDATE work_items SET scenario_file = 'features/email-password-login.feature' WHERE id = 42"
+Then list the step definitions that will be created:
+
+```
+**Step definitions to implement:**
+• Given I am on [entry point] - [brief implementation note]
+• When I [action] - [brief implementation note]
+• Then I [outcome] - [brief implementation note]
+[etc.]
+
+Does this capture the feature correctly? Any scenarios to add/change?
 ```
 
-**Proceed to Step 6.5.**
+**Scenario content requirements:**
+- **FIRST scenario MUST be the Integration Scenario** from Step 6A (proves reachability)
+- **Include all "make it work" scenarios**:
+  - All success paths - required functionality AND optional features
+  - Multiple valid workflows if the feature supports them
+  - Success variations (different outcomes that are all correct)
+  - NO error handling scenarios (added in stable mode)
+  - NO validation failures (added in stable mode)
+  - NO security/compliance scenarios (added in production mode)
+
+**WAIT for user confirmation.**
+
+- If user confirms → Proceed to Step 7
+- If user requests changes → Revise scenarios and display again
+- **Store the confirmed scenarios in memory** - you'll write them in Step 8D
+
+**Proceed to Step 7.**
 
 **Template for speed mode (make it work):**
 
@@ -395,102 +434,9 @@ Scenario: Prevent unauthorized access
 
 </details>
 
-### Step 6.5: Validate BDD Infrastructure
-
-**CRITICAL:** After creating both scenario and step definition files, validate them with cucumber dry-run to catch errors immediately.
-
-**Run this command** (replace `${FEATURE_SLUG}` with actual slug):
-
-```bash
-npx cucumber-js --dry-run features/${FEATURE_SLUG}.feature
-```
-
-Example:
-```bash
-npx cucumber-js --dry-run features/email-password-login.feature
-```
-
-**What the output means:**
-
-✅ **Success** - No errors, all steps have definitions:
-```
-0 scenarios
-0 steps
-```
-(Dry-run doesn't execute, so 0 is correct)
-
-❌ **Undefined steps** - Missing step definitions:
-```
-Undefined. Implement with the following snippet:
-  Given('I am on the login page', function () {
-    ...
-  });
-```
-→ Add the missing step definition to your `.steps.js` file
-
-❌ **Syntax error** - Invalid Gherkin:
-```
-Parse error in features/foo.feature
-```
-→ Fix the feature file syntax
-
-❌ **Duplicate steps** - Multiple definitions match:
-```
-Multiple step definitions match
-```
-→ Remove or rename one of the duplicate step definitions
-
-**If validation fails:**
-1. Read the error message carefully
-2. Fix the step definitions or scenario file
-3. Re-run the dry-run command
-4. **Loop until validation passes** - do NOT proceed to Step 7 until green
-
-**If validation succeeds:**
-Display: "✅ BDD infrastructure validated - all steps have definitions"
-
-**Proceed to Step 6.6.**
-
-**Note:** Unit tests are created during speed mode implementation, not during feature planning. Feature planning focuses on BDD scenarios (user experience); speed mode handles unit tests (implementation details).
-
-### Step 6.6: Commit BDD Files to Main
-
-**CRITICAL:** The BDD files must be committed to main BEFORE creating worktrees. If you skip this step, worktrees won't have the scenario files and speed-mode will fail.
-
-**Commit the BDD files:**
-
-```bash
-git add features/${FEATURE_SLUG}.feature features/steps/${FEATURE_SLUG}.* features/step_definitions/${FEATURE_SLUG}.*
-git commit -m "test: Add BDD scenarios for ${FEATURE_TITLE}
-
-- Feature file: features/${FEATURE_SLUG}.feature
-- Step definitions for speed mode scenarios"
-
-git push
-```
-
-Replace `${FEATURE_SLUG}` and `${FEATURE_TITLE}` with actual values. Example:
-```bash
-git add features/email-password-login.feature features/steps/email-password-login.* features/step_definitions/email-password-login.*
-git commit -m "test: Add BDD scenarios for Email Password Login
-
-- Feature file: features/email-password-login.feature
-- Step definitions for speed mode scenarios"
-
-git push
-```
-
-**Why this matters:**
-- Worktrees are created from the current branch (usually main)
-- If BDD files aren't committed, they won't exist in the worktree
-- Speed-mode will fail trying to run tests against non-existent files
-- **Push is required** so other assistants/machines have the latest main
-
-**Proceed to Step 7.**
-
 ### Step 7: Propose Speed Mode Chores
 
-**CRITICAL:** After BDD validation passes, analyze the codebase and propose technical implementation chores. **DO NOT CREATE CHORES YET** - the feature must transition to implementation mode first (Step 8).
+**CRITICAL:** After user confirms the BDD scenarios, analyze the codebase and propose technical implementation chores. **DO NOT CREATE CHORES YET** - the feature must transition to implementation mode first (Step 8).
 
 **Your analysis should consider:**
 - The BDD scenarios (integration + all success paths)
@@ -633,6 +579,139 @@ After successful transition, display:
 ✅ Feature transitioned to implementation phase
 ✅ Created X chores for speed mode
 
+Now I'll write the BDD tests in an isolated worktree...
+```
+
+**Proceed to Step 8D.**
+
+#### Step 8D: Write Tests in Isolated Worktree
+
+**CRITICAL:** Tests are written in an isolated worktree, not directly on main. This ensures agent failures don't leave uncommitted garbage on main.
+
+**Sub-step 1: Create test worktree**
+
+```bash
+jettypod work tests start ${FEATURE_ID}
+```
+
+This creates:
+- Worktree at `.jettypod-work/tests-<id>-<slug>/`
+- Branch `tests/feature-<id>-<slug>`
+
+**Capture the worktree path from output** - you'll need it for file operations.
+
+Example output:
+```
+✅ Created test worktree: /path/to/.jettypod-work/tests-42-email-login
+Branch: tests/feature-42-email-login
+
+Write your BDD files to:
+  <worktree>/features/email-login.feature
+  <worktree>/features/step_definitions/email-login.steps.js
+
+When done, run: jettypod work tests merge 42
+```
+
+**🛑 STOP AND CHECK:** Verify worktree was created successfully. If you see an error, investigate before continuing.
+
+**Sub-step 2: Write BDD files in the worktree**
+
+Using the scenarios you confirmed in Step 6B, write the files using **absolute paths to the worktree**:
+
+**A. Write scenario file** using Write tool:
+```
+<worktree_path>/features/${FEATURE_SLUG}.feature
+```
+
+**B. Write step definitions file** using Write tool:
+```
+<worktree_path>/features/step_definitions/${FEATURE_SLUG}.steps.js
+```
+
+**Step definition requirements:**
+1. Implement all Given/When/Then steps from the scenarios
+2. Follow existing patterns - check other `.steps.js` files for conventions
+3. Include test environment setup/cleanup
+4. All Given steps (setup state)
+5. All When steps (execute actions)
+6. All Then steps (verify outcomes)
+
+**Sub-step 3: Validate BDD infrastructure**
+
+Run cucumber dry-run **from within the worktree**:
+
+```bash
+cd <worktree_path> && npx cucumber-js --dry-run features/${FEATURE_SLUG}.feature
+```
+
+**What the output means:**
+
+✅ **Success** - No errors, all steps have definitions:
+```
+0 scenarios
+0 steps
+```
+(Dry-run doesn't execute, so 0 is correct)
+
+❌ **Undefined steps** - Missing step definitions:
+```
+Undefined. Implement with the following snippet:
+  Given('I am on the login page', function () {
+    ...
+  });
+```
+→ Add the missing step definition to your `.steps.js` file
+
+❌ **Syntax error** - Invalid Gherkin:
+```
+Parse error in features/foo.feature
+```
+→ Fix the feature file syntax
+
+❌ **Duplicate steps** - Multiple definitions match:
+```
+Multiple step definitions match
+```
+→ Remove or rename one of the duplicate step definitions
+
+**If validation fails:**
+1. Read the error message carefully
+2. Fix the step definitions or scenario file **in the worktree**
+3. Re-run the dry-run command
+4. **Loop until validation passes** - do NOT proceed until green
+
+**If validation succeeds:**
+Display: "✅ BDD infrastructure validated - all steps have definitions"
+
+**Sub-step 4: Update database with scenario file path**
+
+```bash
+sqlite3 .jettypod/work.db "UPDATE work_items SET scenario_file = 'features/${FEATURE_SLUG}.feature' WHERE id = ${FEATURE_ID}"
+```
+
+**Sub-step 5: Merge tests to main**
+
+```bash
+jettypod work tests merge ${FEATURE_ID}
+```
+
+This will:
+- Commit changes in the worktree
+- Merge to main
+- Push to remote
+- Clean up the worktree
+
+**🛑 STOP AND CHECK:** Verify merge succeeded:
+- ✅ "Tests merged to main" → Proceed to Step 8E
+- ❌ Error → Investigate, worktree still exists for debugging
+
+**After successful merge, display:**
+
+```
+✅ Feature transitioned to implementation phase
+✅ Created X chores for speed mode
+✅ BDD tests merged to main
+
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 🎯 Feature Planning Complete!
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -648,9 +727,11 @@ After successful transition, display:
 Start this one? [yes / pick different / done for now]
 ```
 
-#### Step 8D: Start First Chore
+**Proceed to Step 8E.**
+
+#### Step 8E: Start First Chore
 
-**Feature planning is now complete.** The feature has been transitioned to implementation phase and chores are ready.
+**Feature planning is now complete.** The feature has been transitioned to implementation phase, tests are on main, and chores are ready.
 
 The completion message above already includes your recommendation. Now:
 
@@ -763,14 +844,15 @@ Before completing feature planning, ensure:
 - [ ] Exactly 3 approaches suggested
 - [ ] Winner chosen (with prototypes or without)
 - [ ] **Integration Contract defined** (entry point, caller code, integration scenario)
-- [ ] **Integration Scenario is FIRST scenario** in feature file
-- [ ] BDD scenarios written (integration + all success paths)
-- [ ] Step definitions written for ALL scenario steps
-- [ ] Scenarios file exists at `features/[feature-slug].feature`
-- [ ] Step definitions file exists at `features/step_definitions/[feature-slug].steps.js`
-- [ ] BDD infrastructure validated with dry-run (Step 6.5)
-- [ ] Feature transitioned to implementation with `work implement`
-- [ ] **At least one Integration Chore created** (wires feature into app)
-- [ ] Speed mode chores created
-- [ ] First chore started with `work start [chore-id]` (Step 8D)
-- [ ] **Speed-mode skill invoked using Skill tool** (Step 8D)
+- [ ] **Integration Scenario is FIRST scenario** in proposed scenarios
+- [ ] BDD scenarios **proposed and confirmed** by user (Step 6B)
+- [ ] **At least one Integration Chore proposed** (wires feature into app)
+- [ ] Speed mode chores proposed and confirmed (Step 7)
+- [ ] Chores created in database (Step 8B)
+- [ ] Feature transitioned to implementation with `work implement` (Step 8C)
+- [ ] **Test worktree created** with `work tests start` (Step 8D)
+- [ ] **BDD files written** in worktree (Step 8D)
+- [ ] **BDD infrastructure validated** with dry-run (Step 8D)
+- [ ] **Tests merged to main** with `work tests merge` (Step 8D)
+- [ ] First chore started with `work start [chore-id]` (Step 8E)
+- [ ] **Speed-mode skill invoked using Skill tool** (Step 8E)

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

@@ -627,22 +627,34 @@ After merge, you are on main branch. Ready to generate stable mode scenarios.
 
 **⚡ ASYNC BOUNDARY - Must wait for user confirmation**
 
-**1. Read the feature's scenario file and analyze for stable mode needs:**
+**1. Create a test worktree for writing stable mode scenarios:**
+
+```bash
+jettypod work tests <feature-id>
+```
+
+This creates an isolated worktree at `.jettypod-work/tests-<id>-<slug>` with branch `tests/feature-<id>-<slug>`.
+
+**🛑 CRITICAL:** All BDD file operations MUST use absolute paths in the test worktree:
+- ✅ `/path/to/.jettypod-work/tests-42-login/features/login.feature`
+- ❌ `features/login.feature` (this would write to main repo!)
+
+**2. Read the feature's scenario file and analyze for stable mode needs:**
 
 ```bash
 sqlite3 .jettypod/work.db "SELECT id, title, scenario_file FROM work_items WHERE id = <feature-id>"
 ```
 
-**2. Generate stable mode BDD scenarios** covering:
+**3. Generate stable mode BDD scenarios** covering:
 - **Error scenarios** - Invalid input, missing params, system errors, permission failures
 - **Edge cases** - Empty inputs, boundary values, special characters
 - **State consistency** - Concurrent ops, partial failures, invalid state transitions
 
-**3. Append scenarios to the feature file:**
+**4. Append scenarios to the feature file IN THE TEST WORKTREE:**
 
-```bash
-cat >> <scenario-file-path> << 'EOF'
+Use the Edit tool to append to `<worktree-path>/features/<feature-file>`:
 
+```gherkin
 # Stable Mode Scenarios - Error Handling and Edge Cases
 
 Scenario: [Error scenario title]
@@ -654,14 +666,15 @@ Scenario: [Edge case title]
   Given [context]
   When [edge case input]
   Then [expected behavior]
-EOF
 ```
 
-**4. Create step definitions** at `features/step_definitions/<feature-slug>-stable.steps.js`
+**5. Create step definitions IN THE TEST WORKTREE** at `<worktree-path>/features/step_definitions/<feature-slug>-stable.steps.js`
 
-**5. Commit BDD files immediately:**
+**6. Commit and merge the test worktree:**
 
 ```bash
+# Commit in the test worktree
+cd <worktree-path>
 git add features/
 git commit -m "test: Add stable mode BDD scenarios and step definitions
 
@@ -669,13 +682,12 @@ Added error handling and edge case scenarios for stable mode.
 - [N] new stable mode scenarios
 - Step definitions for validation and error handling"
 
-git push
+# Return to main repo and merge
+cd <main-repo-path>
+jettypod work merge <feature-id>
 ```
 
-**🛑 CRITICAL:** Commit IMMEDIATELY after generating files. Do NOT wait for user confirmation.
-Other assistants may be working in parallel - uncommitted files will block their merges.
-
-**6. Present proposal to user:**
+**7. Present proposal to user:**
 
 ```
 📋 Stable Mode Transition
@@ -826,6 +838,12 @@ jettypod work merge --release-lock     # Release held lock
 jettypod work start <chore-id>   # Create worktree and start chore
 ```
 
+**Create test worktree (for writing BDD scenarios):**
+```bash
+jettypod work tests <feature-id>  # Create worktree for writing tests
+jettypod work merge <feature-id>  # Merge tests back to main
+```
+
 **Set feature mode (BEFORE creating chores):**
 ```bash
 jettypod work set-mode <feature-id> stable