jettypod 4.4.120 → 4.4.121

package/lib/work-commands/index.js

@@ -1331,13 +1331,12 @@ async function cleanupWorkItem(workItemId, options = {}) {
  * 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) {
@@ -2014,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) => {
@@ -2028,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.`);
+            }
+          }
+        }
       }
     }
 
@@ -2058,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) => {
@@ -1532,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,
@@ -1542,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'
+              ${activeSessionFilter}
               ORDER BY w.ready_for_review DESC, w.id ASC
-            `, [], (err, rows) => {
+            `, activeParams, (err, rows) => {
               if (err) return reject(err);
               resolve(rows || []);
             });
@@ -1673,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);
 
@@ -1749,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
@@ -2594,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
 

package/package.json

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

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

@@ -303,12 +303,36 @@ Related Tests Passing
 Ready to commit and merge.
 ```
 
-**Proceed to Step 4.**
+**Proceed to Step 3B.**
 
 **Quality Gate:** Before committing, review every `.steps.js` file you wrote or modified. Check for banlist violations: `setTimeout`/`sleep`, module-level `let`/`var`, raw SQL, assertions in Given/When, self-fulfilling mocks, steps longer than 5 lines. Fix violations before proceeding.
 
 ---
 
+### Step 3B: Prove It Works
+
+**Before committing, demonstrate the fix works in practice — not just that tests pass.**
+
+1. **Run or build the actual code** — compile, start the server, execute the command, or trigger the relevant workflow
+2. **Show real output** — display console output, build result, or observable behavior
+3. **Confirm the bug is fixed** — verify the original bug scenario no longer reproduces
+
+**Display:**
+
+```
+Verifying fix in practice...
+
+[Actual output from running/building the code]
+
+Verified: [what was confirmed — original bug no longer reproduces]
+```
+
+**If the change cannot be run directly** (requires hardware, external service, or manual UI interaction), state what the user should verify manually and why you can't verify it yourself.
+
+**Proceed to Step 4.**
+
+---
+
 ### Step 4: Commit and Merge
 
 **Emit gate signal:**
@@ -339,6 +363,8 @@ Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
 jettypod work merge <bug-id>
 ```
 
+**If merge fails with `Uncommitted changes detected`:** `git stash` from main repo CWD → create a work item for the stashed changes → `jettypod work start <id>` → `git stash pop` in that worktree → commit → merge → cleanup → then retry your original merge.
+
 ```bash
 # Step 2: cd to main repo
 cd <main-repo-path>
@@ -359,6 +385,22 @@ jettypod work cleanup <bug-id>
 **The merge command automatically sets the bug as ready for review.**
 It will appear with accept/reject buttons on the kanban board. Do NOT call `jettypod work status <bug-id> done` — that bypasses the review gate.
 
+**Generate QA checklist:**
+
+Based on the bug fix and regression test, generate specific QA steps to verify the fix and ensure no regressions. Write a JSON array to `/tmp/qa-steps.json`:
+```json
+[
+  {"section": "Bug Fix Verification", "text": "Reproduce the original bug scenario — it should no longer occur", "detail": "Steps to reproduce..."},
+  {"section": "Regression Check", "text": "Verify related functionality still works", "detail": "..."},
+  ...
+]
+```
+Be specific. 3-8 steps covering: original bug fixed, regression scenarios, edge cases.
+
+```bash
+jettypod work set-qa-steps <bug-id> --from=/tmp/qa-steps.json
+```
+
 **Emit gate signal:**
 
 ```bash

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

@@ -479,7 +479,29 @@ Returning to iteration loop...
 
 Go back to Step 5 to fix issues.
 
-**If all verification passes → Move to Step 7.**
+**If all verification passes → Move to Step 6B.**
+
+### Step 6B: Prove It Works
+
+**Before committing, demonstrate the change works in practice — not just that tests pass.**
+
+1. **Run or build the actual code** — compile, start the server, execute the command, or trigger the relevant workflow
+2. **Show real output** — display console output, build result, or observable behavior
+3. **Confirm it matches expectations** — verify the output is what was requested
+
+**Display:**
+
+```
+Verifying in practice...
+
+[Actual output from running/building the code]
+
+Verified: [what was confirmed]
+```
+
+**If the change cannot be run directly** (requires hardware, external service, or manual UI interaction), state what the user should verify manually and why you can't verify it yourself.
+
+**Move to Step 7.**
 
 ### Step 7: Complete and Merge
 
@@ -505,6 +527,8 @@ git push
 jettypod work merge [chore-id]
 ```
 
+**If merge fails with `Uncommitted changes detected`:** `git stash` from main repo CWD → create a work item for the stashed changes → `jettypod work start <id>` → `git stash pop` in that worktree → commit → merge → cleanup → then retry your original merge.
+
 ```bash
 # Step 2: cd to main repo
 cd /path/to/main/repo
@@ -516,6 +540,21 @@ pwd && ls .jettypod  # verify
 jettypod work cleanup [chore-id]
 ```
 
+**Generate QA checklist:**
+
+Based on the chore work completed, generate specific QA steps. Write a JSON array to `/tmp/qa-steps.json`:
+```json
+[
+  {"section": "Section Name", "text": "Action to perform and expected result", "detail": "Additional context"},
+  ...
+]
+```
+Be specific. 3-8 steps covering what was changed and how to verify it works.
+
+```bash
+jettypod work set-qa-steps [chore-id] --from=/tmp/qa-steps.json
+```
+
 **Display:**
 
 ```