jettypod 4.4.118 → 4.4.121

package/lib/update-command/index.js

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

package/lib/work-commands/index.js

@@ -1148,9 +1148,12 @@ async function cleanupWorktrees(options = {}) {
  * Clean up a specific worktree after merge
  * Should be run from main repo after cd'ing out of the worktree
  * @param {number} workItemId - The work item ID to clean up
+ * @param {Object} [options] - Cleanup options
+ * @param {boolean} [options.force] - Force cleanup even if worktree is still active (skips merge requirement)
  * @returns {Promise<Object>} Result with success status
  */
-async function cleanupWorkItem(workItemId) {
+async function cleanupWorkItem(workItemId, options = {}) {
+  const { force = false } = options;
   const db = getDb();
   const gitRoot = getGitRoot();
 
@@ -1183,13 +1186,89 @@ async function cleanupWorkItem(workItemId) {
     return { success: true, message: 'No worktree to clean up' };
   }
 
-  if (worktree.status === 'active') {
+  if (worktree.status === 'active' && !force) {
     return Promise.reject(new Error(
       `Worktree for #${workItemId} is still active.\n` +
-      `Run 'jettypod work merge ${workItemId}' first.`
+      `Run 'jettypod work merge ${workItemId}' first, or use --force to skip merge.`
     ));
   }
 
+  // Force cleanup of active worktree — warn about unmerged work
+  if (worktree.status === 'active' && force) {
+    const warnings = [];
+
+    // Check for uncommitted changes in the worktree
+    if (worktree.worktree_path && fs.existsSync(worktree.worktree_path)) {
+      try {
+        const dirtyFiles = execSync('git status --porcelain', {
+          cwd: worktree.worktree_path,
+          stdio: 'pipe'
+        }).toString().trim();
+        if (dirtyFiles) {
+          const fileCount = dirtyFiles.split('\n').length;
+          warnings.push(`${fileCount} uncommitted change${fileCount !== 1 ? 's' : ''}`);
+        }
+      } catch {
+        // Worktree may be in a bad state — not a blocker for force cleanup
+      }
+    }
+
+    // Check for unmerged commits on the branch
+    if (worktree.branch_name) {
+      try {
+        const unmergedLog = execSync(`git log main..${worktree.branch_name} --oneline`, {
+          cwd: gitRoot,
+          stdio: 'pipe'
+        }).toString().trim();
+        if (unmergedLog) {
+          const commitCount = unmergedLog.split('\n').length;
+          warnings.push(`${commitCount} unmerged commit${commitCount !== 1 ? 's' : ''}`);
+        }
+      } catch {
+        // Branch may not exist or may not have diverged — not a blocker
+      }
+    }
+
+    // Display warnings and prompt for confirmation
+    console.log(`\n⚠️  Force cleanup of active worktree for #${workItemId}: ${worktree.title}\n`);
+    if (warnings.length > 0) {
+      console.log(`   This worktree has ${warnings.join(' and ')}.\n   This data will be lost and cannot be recovered easily.\n`);
+    } else {
+      console.log(`   No unmerged commits or uncommitted changes detected.\n`);
+    }
+
+    // Interactive confirmation
+    const confirmed = await new Promise((resolve) => {
+      const readline = require('readline');
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      rl.question('Proceed with force cleanup? (y/N): ', (answer) => {
+        rl.close();
+        resolve(answer.trim().toLowerCase() === 'y');
+      });
+    });
+
+    if (!confirmed) {
+      console.log('Cancelled.');
+      return { success: false, message: 'Force cleanup cancelled by user' };
+    }
+
+    // Update work item status to cancelled
+    await new Promise((resolve, reject) => {
+      db.run(
+        `UPDATE work_items SET status = 'cancelled' WHERE id = ?`,
+        [workItemId],
+        (err) => {
+          if (err) return reject(err);
+          resolve();
+        }
+      );
+    });
+    console.log(`📋 Work item #${workItemId} marked as cancelled`);
+  }
+
   console.log(`Cleaning up worktree for #${workItemId}: ${worktree.title}`);
 
   // Remove git worktree if it exists
@@ -1252,13 +1331,12 @@ async function cleanupWorkItem(workItemId) {
  * Pushes feature branch, checks out main, merges, and pushes main
  * Post-merge hook will mark work item as done and cleanup worktree
  * @param {Object} options - Merge options
- * @param {boolean} options.withTransition - Hold lock for transition phase (BDD generation)
  * @param {boolean} options.releaseLock - Release held lock only (no merge)
- * @returns {Promise<void|Object>} Returns {lockHeld: true} if withTransition, void otherwise
+ * @returns {Promise<void>}
  * @throws {Error} If no current work, git operations fail, or not in git repo
  */
 async function mergeWork(options = {}) {
-  const { withTransition = false, releaseLock = false, featureBranch = null, workItemId = null } = options;
+  const { releaseLock = false, featureBranch = null, workItemId = null } = options;
 
   // Handle lock release-only mode first (can run from anywhere)
   if (releaseLock) {
@@ -1561,6 +1639,8 @@ async function mergeWork(options = {}) {
     // and should never block branch switching
     const generatedFilesForReset = [
       'cucumber-results.json',
+      'cucumber-results.ndjson',
+      '@rerun.txt',
       'package-lock.json',
       'yarn.lock',
       'pnpm-lock.yaml'
@@ -1700,6 +1780,8 @@ async function mergeWork(options = {}) {
         // Check if all conflicts are in generated files that can be auto-resolved
         const generatedFiles = [
           'cucumber-results.json',
+          'cucumber-results.ndjson',
+          '@rerun.txt',
           'package-lock.json',
           'yarn.lock',
           'pnpm-lock.yaml'
@@ -1931,7 +2013,7 @@ async function mergeWork(options = {}) {
         });
         console.log(`✅ ${currentWork.type.charAt(0).toUpperCase() + currentWork.type.slice(1)} #${currentWork.id} ready for review`);
       } else {
-        // Chore/bug under a feature: mark as done (feature handles the accept flow)
+        // Chore/bug under a feature: mark as done, then check if feature is complete
         console.log(`Marking ${currentWork.type} as done...`);
         const completedAt = new Date().toISOString();
         await new Promise((resolve, reject) => {
@@ -1945,6 +2027,60 @@ async function mergeWork(options = {}) {
           );
         });
         console.log(`✅ ${currentWork.type.charAt(0).toUpperCase() + currentWork.type.slice(1)} #${currentWork.id} marked as done`);
+
+        // Check if all sibling chores under the parent feature are now done
+        // If so, and mode progression is complete, set ready_for_review on the parent
+        const parent = await new Promise((resolve, reject) => {
+          db.get('SELECT id, type, mode FROM work_items WHERE id = ?', [currentWork.parent_id], (err, row) => {
+            if (err) return reject(err);
+            resolve(row);
+          });
+        });
+
+        if (parent && parent.type === 'feature') {
+          const siblingChores = await new Promise((resolve, reject) => {
+            db.all(
+              'SELECT id, status FROM work_items WHERE parent_id = ? AND type = ?',
+              [parent.id, 'chore'],
+              (err, rows) => {
+                if (err) return reject(err);
+                resolve(rows || []);
+              }
+            );
+          });
+
+          const allChoresDone = siblingChores.length > 0 && siblingChores.every(c => c.status === 'done');
+          if (allChoresDone) {
+            const config = await new Promise((resolve, reject) => {
+              db.get('SELECT project_state FROM project_config WHERE id = 1', [], (err, row) => {
+                if (err) return reject(err);
+                resolve(row);
+              });
+            });
+            const projectState = (config && config.project_state) || 'internal';
+            const featureMode = parent.mode || 'speed';
+
+            let featureComplete = false;
+            if (projectState === 'internal') {
+              featureComplete = (featureMode === 'stable');
+            } else if (projectState === 'external') {
+              featureComplete = (featureMode === 'production');
+            }
+
+            if (featureComplete) {
+              await new Promise((resolve, reject) => {
+                db.run('UPDATE work_items SET ready_for_review = 1 WHERE id = ?', [parent.id], (err) => {
+                  if (err) return reject(err);
+                  resolve();
+                });
+              });
+              console.log(`✅ Feature #${parent.id} ready for review (all ${featureMode} mode chores done)`);
+            } else {
+              const nextMode = featureMode === 'speed' ? 'stable' : 'production';
+              console.log(`✓ All ${featureMode} mode chores done. Feature #${parent.id} ready for ${nextMode} mode.`);
+            }
+          }
+        }
       }
     }
 
@@ -1975,20 +2111,9 @@ async function mergeWork(options = {}) {
       console.log('   Worktrees accumulate until cleaned up.');
     }
 
-    if (withTransition) {
-      // Hold lock for transition phase (BDD generation)
-      // Work is done and worktree is cleaned up, but lock is held so no other merges
-      // happen while Claude generates stable scenarios on main
-      console.log('⚠️  Merge lock held for transition phase');
-      console.log('   Skills will release lock after generating stable scenarios');
-      console.log('   Release lock with: jettypod work merge --release-lock');
-      return Promise.resolve({ lockHeld: true });
-    }
-
     return Promise.resolve();
   } finally {
-    // Release lock unless holding for transition
-    if (lock && !withTransition) {
+    if (lock) {
       try {
         await lock.release();
         console.log('✅ Merge lock released');

package/lib/work-tracking/index.js

@@ -298,8 +298,12 @@ function create(type, title, description = '', parentId = null, mode = null, nee
       // Set phase for features (discovery when mode=NULL, implementation when mode is set, NULL for everything else)
       const phase = type === 'feature' ? (mode ? 'implementation' : 'discovery') : null;
 
-      const sql = `INSERT INTO work_items (type, title, description, parent_id, epic_id, mode, needs_discovery, phase, status, plan_at_creation) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
-      db.run(sql, [type, title, description, parentId, epicId, mode, needsDiscovery ? 1 : 0, phase, 'backlog', planAtCreation], function(err) {
+      // If parent has been rejected, tag this child with the current rejection round
+      let rejectionRound = null;
+
+      function doInsert() {
+        const sql = `INSERT INTO work_items (type, title, description, parent_id, epic_id, mode, needs_discovery, phase, status, plan_at_creation, rejection_round) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
+        db.run(sql, [type, title, description, parentId, epicId, mode, needsDiscovery ? 1 : 0, phase, 'backlog', planAtCreation, rejectionRound], function(err) {
         if (err) {
           return reject(err);
         }
@@ -327,6 +331,21 @@ function create(type, title, description = '', parentId = null, mode = null, nee
           resolve(newId);
         }
       });
+      }
+
+      if (parentId) {
+        db.get('SELECT rejection_count FROM work_items WHERE id = ?', [parentId], (err, parentRow) => {
+          if (err) {
+            return reject(err);
+          }
+          if (parentRow && parentRow.rejection_count > 0) {
+            rejectionRound = parentRow.rejection_count;
+          }
+          doInsert();
+        });
+      } else {
+        doInsert();
+      }
     }
   });
 }
@@ -398,13 +417,32 @@ function filterProductionItems(items, itemsById) {
  * Get all work items as hierarchical tree structure
  * @param {boolean} includeCompleted - Include done/cancelled items (default: false)
  * @param {boolean} showAll - Show all items including production (bypasses internal/external filtering)
+ * @param {number|null} sessionId - If provided, hide items owned by OTHER active sessions
  * @returns {Promise<Array>} Root work items with nested children
  * @throws {Error} If database query fails
  */
-function getTree(includeCompleted = false, showAll = false) {
+function getTree(includeCompleted = false, showAll = false, sessionId = null) {
   return new Promise((resolve, reject) => {
-    const whereClause = includeCompleted ? '' : "WHERE (status NOT IN ('done', 'cancelled') OR status IS NULL)";
-    db.all(`SELECT * FROM work_items ${whereClause} ORDER BY parent_id, id`, [], (err, rows) => {
+    const conditions = [];
+    const params = [];
+
+    if (!includeCompleted) {
+      conditions.push("(status NOT IN ('done', 'cancelled') OR status IS NULL)");
+    }
+
+    // Session isolation: hide items actively owned by OTHER sessions
+    if (sessionId) {
+      conditions.push(`work_items.id NOT IN (
+        SELECT cs.work_item_id FROM claude_sessions cs
+        WHERE cs.work_item_id IS NOT NULL
+        AND cs.status = 'active'
+        AND cs.id != ?
+      )`);
+      params.push(sessionId);
+    }
+
+    const whereClause = conditions.length > 0 ? 'WHERE ' + conditions.join(' AND ') : '';
+    db.all(`SELECT * FROM work_items ${whereClause} ORDER BY parent_id, id`, params, (err, rows) => {
       if (err) {
         return reject(new Error(`Failed to fetch work items: ${err.message}`));
       }
@@ -901,6 +939,14 @@ function setScenario(id, scenarioFile) {
   });
 }
 
+// Set QA steps
+function setQaSteps(id, qaStepsJson) {
+  db.run(`UPDATE work_items SET qa_steps = ? WHERE id = ?`, [qaStepsJson, id], () => {
+    const steps = JSON.parse(qaStepsJson);
+    console.log(`Set #${id} qa_steps (${steps.length} steps)`);
+  });
+}
+
 // Set mode
 function setMode(id, mode) {
   return new Promise((resolve, reject) => {
@@ -1184,25 +1230,46 @@ async function main() {
 
   switch(command) {
     case 'create': {
-      const type = args[0];
-      const title = args[1];
-      const desc = args[2] || '';
+      // Support --from=<file> for truncation-safe creation via JSON file
+      const fromArg = args.find(a => a.startsWith('--from='));
+      let type, title, desc, parentId, mode, needsDiscovery;
 
-      let parentId = null;
-      let mode = null;
-      let needsDiscovery = false;
-
-      args.forEach(arg => {
-        if (arg.startsWith('--parent=')) {
-          parentId = parseInt(arg.split('=')[1]);
-        }
-        if (arg.startsWith('--mode=')) {
-          mode = arg.split('=')[1];
-        }
-        if (arg === '--needs-discovery') {
-          needsDiscovery = true;
+      if (fromArg) {
+        const fs = require('fs');
+        const filePath = fromArg.split('=').slice(1).join('=');
+        try {
+          const raw = fs.readFileSync(filePath, 'utf8');
+          const data = JSON.parse(raw);
+          type = data.type;
+          title = data.title;
+          desc = data.description || '';
+          parentId = data.parent ? parseInt(data.parent) : null;
+          mode = data.mode || null;
+          needsDiscovery = !!data.needsDiscovery;
+        } catch (e) {
+          console.error(`Error reading --from file: ${e.message}`);
+          process.exit(1);
         }
-      });
+      } else {
+        type = args[0];
+        title = args[1];
+        desc = args[2] || '';
+        parentId = null;
+        mode = null;
+        needsDiscovery = false;
+
+        args.forEach(arg => {
+          if (arg.startsWith('--parent=')) {
+            parentId = parseInt(arg.split('=')[1]);
+          }
+          if (arg.startsWith('--mode=')) {
+            mode = arg.split('=')[1];
+          }
+          if (arg === '--needs-discovery') {
+            needsDiscovery = true;
+          }
+        });
+      }
 
       try {
         const newId = await create(type, title, desc, parentId, mode, needsDiscovery);
@@ -1277,7 +1344,7 @@ async function main() {
             LEFT JOIN work_items p ON w.parent_id = p.id
             LEFT JOIN work_items e ON w.epic_id = e.id
             WHERE w.status = 'in_progress'
-            ORDER BY w.id ASC
+            ORDER BY w.ready_for_review DESC, w.id ASC
           `, [], (err, rows) => {
             if (err) return reject(err);
             resolve(rows || []);
@@ -1511,7 +1578,23 @@ async function main() {
             expandedIds = new Set(ids);
           }
 
-          // Query for ALL in_progress items
+          // Session isolation for backlog display
+          const sessionId = process.env.JETTYPOD_SESSION_ID ? parseInt(process.env.JETTYPOD_SESSION_ID, 10) : null;
+
+          // Query for ALL in_progress items (with session filtering)
+          const activeParams = [];
+          let activeSessionFilter = '';
+          if (sessionId) {
+            activeSessionFilter = `
+              AND w.id NOT IN (
+                SELECT cs.work_item_id FROM claude_sessions cs
+                WHERE cs.work_item_id IS NOT NULL
+                AND cs.status = 'active'
+                AND cs.id != ?
+              )`;
+            activeParams.push(sessionId);
+          }
+
           const activeItems = await new Promise((resolve, reject) => {
             db.all(`
               SELECT w.id, w.title, w.type, w.status,
@@ -1521,8 +1604,9 @@ async function main() {
               LEFT JOIN work_items p ON w.parent_id = p.id
               LEFT JOIN work_items e ON w.epic_id = e.id
               WHERE w.status = 'in_progress'
-              ORDER BY w.id ASC
-            `, [], (err, rows) => {
+              ${activeSessionFilter}
+              ORDER BY w.ready_for_review DESC, w.id ASC
+            `, activeParams, (err, rows) => {
               if (err) return reject(err);
               resolve(rows || []);
             });
@@ -1652,7 +1736,7 @@ async function main() {
           console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
           console.log('📋  BACKLOG');
           console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-          const items = await getTree(false, showAll);
+          const items = await getTree(false, showAll, sessionId);
 
           printTree(items, '', true, expandedIds);
 
@@ -1728,6 +1812,40 @@ async function main() {
       break;
     }
 
+    case 'set-qa-steps': {
+      const id = parseInt(args[0]);
+      if (isNaN(id)) {
+        console.error('Error: Work item ID is required');
+        console.log('Usage: jettypod work set-qa-steps <id> --from=<path>');
+        process.exit(1);
+      }
+      const fromArg = args.find(a => a.startsWith('--from='));
+      if (!fromArg) {
+        console.error('Error: --from=<path> is required');
+        console.log('Usage: jettypod work set-qa-steps <id> --from=<path>');
+        process.exit(1);
+      }
+      const filePath = fromArg.replace('--from=', '');
+      const fs = require('fs');
+      if (!fs.existsSync(filePath)) {
+        console.error(`Error: File not found: ${filePath}`);
+        process.exit(1);
+      }
+      const qaJson = fs.readFileSync(filePath, 'utf8');
+      try {
+        const parsed = JSON.parse(qaJson);
+        if (!Array.isArray(parsed)) {
+          console.error('Error: QA steps must be a JSON array');
+          process.exit(1);
+        }
+      } catch (e) {
+        console.error(`Error: Invalid JSON in ${filePath}: ${e.message}`);
+        process.exit(1);
+      }
+      setQaSteps(id, qaJson);
+      break;
+    }
+
     case 'current': {
       if (!args[0]) {
         // No ID provided - show current work
@@ -2573,6 +2691,9 @@ Commands:
   jettypod work set-scenario <id> <file>
     Set scenario_file for a feature (e.g., features/my-feature.feature)
 
+  jettypod work set-qa-steps <id> --from=<path>
+    Set QA steps from a JSON file (array of {section, text, detail})
+
   jettypod work current <id>
     Set as current work item