jettypod 4.2.11 → 4.3.0

package/hooks/post-checkout

@@ -1,13 +1,88 @@
 #!/usr/bin/env node
 
+/**
+ * Post-Checkout Hook
+ *
+ * 1. Prevents checking out default branch in JettyPod worktrees
+ * 2. Imports database snapshots after checkout
+ */
+
 const { importAll } = require('../lib/db-import');
+const { execSync } = require('child_process');
 
 (async () => {
+  const cwd = process.cwd();
+
+  // FIRST: Check if we're in a JettyPod worktree and prevent default branch checkout
+  if (cwd.includes('.jettypod-work')) {
+    try {
+      // Get the branch we just checked out
+      const currentBranch = execSync('git rev-parse --abbrev-ref HEAD', {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe']
+      }).trim();
+
+      // Detect default branch
+      let defaultBranch;
+      try {
+        // Try to get the default branch from git config
+        defaultBranch = execSync('git symbolic-ref refs/remotes/origin/HEAD', {
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'pipe']
+        }).trim().replace('refs/remotes/origin/', '');
+      } catch {
+        // Fallback: check which common branch names exist
+        try {
+          execSync('git rev-parse --verify main', { stdio: ['pipe', 'pipe', 'pipe'] });
+          defaultBranch = 'main';
+        } catch {
+          try {
+            execSync('git rev-parse --verify master', { stdio: ['pipe', 'pipe', 'pipe'] });
+            defaultBranch = 'master';
+          } catch {
+            // Can't determine default branch - skip check
+            defaultBranch = null;
+          }
+        }
+      }
+
+      // Check if we checked out the default branch
+      if (defaultBranch && currentBranch === defaultBranch) {
+        console.error('');
+        console.error('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.error('❌ ERROR: Cannot checkout default branch in worktree');
+        console.error('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.error('');
+        console.error(`You are in a JettyPod worktree for isolated work.`);
+        console.error(`Checking out ${defaultBranch} in a worktree bypasses the merge workflow.`);
+        console.error('');
+        console.error('To merge your changes:');
+        console.error('  1. Commit your changes: git add . && git commit -m "..."');
+        console.error('  2. Use JettyPod merge:  jettypod work merge');
+        console.error('');
+        console.error('This ensures proper worktree cleanup and database updates.');
+        console.error('');
+        console.error('Reverting checkout...');
+        console.error('');
+
+        // Revert to previous branch
+        try {
+          execSync('git checkout -', { stdio: 'inherit' });
+        } catch (revertErr) {
+          console.error('Failed to revert checkout. You may need to manually switch branches.');
+        }
+
+        process.exit(1);
+      }
+    } catch (err) {
+      // If we can't determine the branch, allow the checkout
+      // (better to be permissive than block legitimate operations)
+    }
+  }
+
+  // SECOND: Import database snapshots
   try {
-    // Import JSON snapshots into databases after checkout
     await importAll();
-
-    // Exit successfully - checkout should not be blocked
     process.exit(0);
   } catch (err) {
     // Log error but don't block checkout

package/hooks/pre-push

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+/**
+ * Pre-Push Hook
+ *
+ * Prevents pushing directly from JettyPod worktrees.
+ * Forces use of `jettypod work merge` to ensure proper cleanup.
+ */
+
+const cwd = process.cwd();
+
+// Check if we're in a JettyPod worktree
+if (cwd.includes('.jettypod-work')) {
+  console.error('');
+  console.error('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.error('❌ ERROR: Cannot push directly from worktree');
+  console.error('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.error('');
+  console.error('You are in a JettyPod worktree for isolated work.');
+  console.error('Pushing directly bypasses the merge workflow.');
+  console.error('');
+  console.error('To merge and push your changes:');
+  console.error('  1. Commit your changes: git add . && git commit -m "..."');
+  console.error('  2. Use JettyPod merge:  jettypod work merge');
+  console.error('');
+  console.error('This ensures proper worktree cleanup and database updates.');
+  console.error('');
+
+  process.exit(1);
+}
+
+// Allow pushes from main repo
+process.exit(0);

package/jettypod.js

@@ -1153,7 +1153,11 @@ switch (command) {
     } else if (subcommand === 'merge') {
       const workCommands = require('./features/work-commands/index.js');
       try {
-        await workCommands.mergeWork();
+        // Parse merge flags from args
+        const withTransition = args.includes('--with-transition');
+        const releaseLock = args.includes('--release-lock');
+
+        await workCommands.mergeWork({ withTransition, releaseLock });
       } catch (err) {
         console.error(`Error: ${err.message}`);
         process.exit(1);

package/lib/claudemd.js

@@ -65,11 +65,19 @@ function updateCurrentWork(currentWork, mode) {
 
   // Write to session file (gitignored) instead of CLAUDE.md
   // This prevents merge conflicts and stale context on main branch
+  // Only write session file if we're in a worktree (not root directory)
   if (currentMode !== null) {
-    writeSessionFile(currentWork, currentMode, {
-      epicId: currentWork.epic_id,
-      epicTitle: currentWork.epic_title
-    });
+    try {
+      writeSessionFile(currentWork, currentMode, {
+        epicId: currentWork.epic_id,
+        epicTitle: currentWork.epic_title
+      });
+    } catch (err) {
+      // Skip if not in worktree - validation will throw error
+      if (!err.message.includes('Cannot create session.md in root directory')) {
+        throw err; // Re-throw unexpected errors
+      }
+    }
   }
 }
 

package/lib/current-work.js

@@ -1,7 +1,6 @@
 const fs = require('fs');
 const path = require('path');
 const { getDb } = require('./database');
-const { getSessionByWorktreePath, getAllActiveSessions } = require('./worktree-sessions');
 
 /**
  * Get path to current-work.json file
@@ -12,35 +11,62 @@ function getCurrentWorkPath() {
 }
 
 /**
- * Get current work item from worktree session database
+ * Get current work item based on status='in_progress'
+ * Extracts work item ID from worktree branch name if in a worktree,
+ * otherwise returns first in_progress item
  * @returns {Object|null} Current work item or null if not set
  */
 async function getCurrentWork() {
   const worktreePath = process.cwd();
   const db = getDb();
+  const { execSync } = require('child_process');
+
+  // Try to extract work item ID from branch name (worktree naming: "feature/work-123-some-title" or "123-some-title")
+  let workItemId = null;
+  try {
+    const branchName = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
+    // Match either "feature/work-123-" or "123-" at start
+    const match = branchName.match(/(?:feature\/work-|^)(\d+)-/);
+    if (match) {
+      workItemId = parseInt(match[1]);
+    }
+  } catch (err) {
+    // Not in a git repo or other git error - that's ok
+  }
 
-  // Query worktree session and join with work_items
+  // Query for in_progress work item
   let row;
   try {
     row = await new Promise((resolve, reject) => {
-      db.get(
-        `SELECT
-          wi.id, wi.title, wi.type, wi.status, wi.parent_id, wi.epic_id,
-          parent.title as parent_title,
-          epic.title as epic_title
-         FROM worktree_sessions ws
-         JOIN work_items wi ON ws.work_item_id = wi.id
-         LEFT JOIN work_items parent ON wi.parent_id = parent.id
-         LEFT JOIN work_items epic ON wi.epic_id = epic.id
-         WHERE ws.worktree_path = ?`,
-        [worktreePath],
-        (err, row) => {
-          if (err) {
-            return reject(err);
-          }
-          resolve(row);
+      const query = workItemId
+        ? // If we have an ID from branch name, get that specific item
+          `SELECT
+            wi.id, wi.title, wi.type, wi.status, wi.parent_id, wi.epic_id,
+            parent.title as parent_title,
+            epic.title as epic_title
+           FROM work_items wi
+           LEFT JOIN work_items parent ON wi.parent_id = parent.id
+           LEFT JOIN work_items epic ON wi.epic_id = epic.id
+           WHERE wi.id = ? AND wi.status = 'in_progress'`
+        : // Otherwise get any in_progress item (for main branch)
+          `SELECT
+            wi.id, wi.title, wi.type, wi.status, wi.parent_id, wi.epic_id,
+            parent.title as parent_title,
+            epic.title as epic_title
+           FROM work_items wi
+           LEFT JOIN work_items parent ON wi.parent_id = parent.id
+           LEFT JOIN work_items epic ON wi.epic_id = epic.id
+           WHERE wi.status = 'in_progress'
+           LIMIT 1`;
+
+      const params = workItemId ? [workItemId] : [];
+
+      db.get(query, params, (err, row) => {
+        if (err) {
+          return reject(err);
         }
-      );
+        resolve(row);
+      });
     });
   } catch (dbErr) {
     // Handle database errors gracefully - log but don't crash
@@ -58,53 +84,6 @@ async function getCurrentWork() {
     return row;
   }
 
-  // No session found - check if we should warn about main branch
-  try {
-    const allSessions = await getAllActiveSessions();
-    if (allSessions.length > 0) {
-      // Get all work items in ONE query using IN clause
-      const ids = allSessions.map(s => s.work_item_id);
-      const placeholders = ids.map(() => '?').join(',');
-
-      let workItems;
-      try {
-        workItems = await new Promise((resolve, reject) => {
-          db.all(
-            `SELECT id, title FROM work_items WHERE id IN (${placeholders})`,
-            ids,
-            (err, rows) => {
-              if (err) reject(err);
-              else resolve(rows || []);
-            }
-          );
-        });
-      } catch (workItemErr) {
-        // Database error getting work items - log but continue
-        console.error('Database error getting work items:', workItemErr.message);
-        workItems = [];
-      }
-
-      // Create map of id -> title
-      const titleMap = {};
-      for (const wi of workItems) {
-        titleMap[wi.id] = wi.title;
-      }
-
-      // Display warnings
-      console.warn('No active work in main branch');
-      console.warn('\nActive work in other worktrees:');
-      for (const session of allSessions) {
-        const title = titleMap[session.work_item_id];
-        if (title) {
-          console.warn(`  • ${title} (${session.worktree_path})`);
-        }
-      }
-    }
-  } catch (listErr) {
-    // Ignore listing errors - gracefully fail
-    console.error('Error listing active sessions:', listErr.message);
-  }
-
   return null;
 }
 
@@ -136,41 +115,75 @@ function validateWorkItem(workItem) {
 }
 
 /**
- * Set current work item in worktree session database
+ * Set current work item by updating status to in_progress
  * @param {Object} workItem - Work item to set as current
  * @throws {Error} If workItem is invalid
  */
 async function setCurrentWork(workItem) {
   validateWorkItem(workItem);
 
-  const { createOrUpdateSession } = require('./worktree-sessions');
-  const { execSync } = require('child_process');
-  const worktreePath = process.cwd();
+  const db = getDb();
 
-  // Get current branch name
-  let branchName;
+  // Update work item status to in_progress
   try {
-    branchName = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
+    await new Promise((resolve, reject) => {
+      db.run(
+        'UPDATE work_items SET status = ? WHERE id = ?',
+        ['in_progress', workItem.id],
+        (err) => {
+          if (err) {
+            return reject(new Error(`Failed to set work item status: ${err.message}`));
+          }
+          resolve();
+        }
+      );
+    });
   } catch (err) {
-    branchName = 'unknown';
+    throw new Error(`Failed to set current work: ${err.message}`);
   }
-
-  // Create or update worktree session in database
-  await createOrUpdateSession(worktreePath, workItem.id, branchName);
 }
 
 /**
- * Clear current work item from worktree session database
- * @throws {Error} If session cannot be deleted
+ * Clear current work item by extracting ID from branch and setting status to backlog
+ * @throws {Error} If work item cannot be found or updated
  */
 async function clearCurrentWork() {
-  const { deleteSession } = require('./worktree-sessions');
-  const worktreePath = process.cwd();
+  const { execSync } = require('child_process');
+  const db = getDb();
 
+  // Extract work item ID from branch name
+  let workItemId = null;
   try {
-    await deleteSession(worktreePath);
+    const branchName = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
+    // Match either "feature/work-123-" or "123-" at start
+    const match = branchName.match(/(?:feature\/work-|^)(\d+)-/);
+    if (match) {
+      workItemId = parseInt(match[1]);
+    }
+  } catch (err) {
+    throw new Error('Cannot determine work item from branch name');
+  }
+
+  if (!workItemId) {
+    throw new Error('Cannot clear current work: no work item ID in branch name');
+  }
+
+  // Update work item status back to backlog
+  try {
+    await new Promise((resolve, reject) => {
+      db.run(
+        'UPDATE work_items SET status = ? WHERE id = ?',
+        ['backlog', workItemId],
+        (err) => {
+          if (err) {
+            return reject(new Error(`Failed to clear work item status: ${err.message}`));
+          }
+          resolve();
+        }
+      );
+    });
   } catch (err) {
-    throw new Error(`Failed to clear current work session: ${err.message}`);
+    throw new Error(`Failed to clear current work: ${err.message}`);
   }
 }
 

package/lib/merge-lock.js

@@ -36,11 +36,20 @@ async function acquireMergeLock(db, workItemId, instanceId = null, options = {})
 
   const maxWait = options.maxWait || 60000; // 1 minute default
   const pollInterval = options.pollInterval || 1500; // 1.5 seconds
+  const staleThreshold = options.staleThreshold || 120000; // 2 minutes (reduced from 5 minutes)
   const startTime = Date.now();
 
   // Generate instance identifier
   const lockedBy = instanceId || `${os.hostname()}-${process.pid}`;
 
+  // Proactive cleanup of stale locks before attempting acquisition
+  try {
+    await cleanupStaleLocks(db, staleThreshold);
+  } catch (cleanupErr) {
+    // Log but don't fail - cleanup is best-effort
+    console.warn(`Warning: Failed to cleanup stale locks: ${cleanupErr.message}`);
+  }
+
   while (Date.now() - startTime < maxWait) {
     // Check if lock exists
     const existingLock = await checkExistingLock(db);
@@ -102,6 +111,27 @@ function insertLock(db, workItemId, lockedBy) {
   });
 }
 
+/**
+ * Clean up stale locks that are older than the threshold
+ *
+ * @param {Object} db - SQLite database connection
+ * @param {number} staleThresholdMs - Age threshold in milliseconds (default: 120000 = 2 minutes)
+ * @returns {Promise<void>}
+ */
+function cleanupStaleLocks(db, staleThresholdMs = 120000) {
+  return new Promise((resolve, reject) => {
+    db.run(
+      `DELETE FROM merge_locks
+       WHERE (julianday('now') - julianday(locked_at)) * 86400000 > ?`,
+      [staleThresholdMs],
+      (err) => {
+        if (err) return reject(err);
+        resolve();
+      }
+    );
+  });
+}
+
 /**
  * Create lock handle object with release function
  *

package/lib/session-writer.js

@@ -19,6 +19,23 @@ function getSessionFilePath() {
   return path.join(process.cwd(), '.claude', 'session.md');
 }
 
+/**
+ * Validate that we're in a worktree, not the root directory
+ * @throws {Error} If in root directory
+ */
+function validateWorktreeLocation() {
+  const cwd = process.cwd();
+
+  // Check if current directory is inside .jettypod-work/
+  if (!cwd.includes('.jettypod-work')) {
+    throw new Error(
+      'Cannot create session.md in root directory.\n' +
+      'Session files should only be created in worktrees (.jettypod-work/).\n' +
+      'Use "jettypod work start <id>" to create a worktree for this work item.'
+    );
+  }
+}
+
 /**
  * Ensure .claude directory exists
  */
@@ -69,6 +86,9 @@ function writeSessionFile(workItem, mode, options = {}) {
     throw new Error('Work item must have a string status');
   }
 
+  // Validate we're in a worktree, not root directory
+  validateWorktreeLocation();
+
   ensureClaudeDir();
 
   const skillName = modeToSkillName(mode);

package/lib/worktree-facade.js

@@ -15,6 +15,29 @@
 const worktreeManager = require('./worktree-manager');
 const fs = require('fs');
 const path = require('path');
+const { getDb } = require('./database');
+
+/**
+ * Check if a worktree already exists for a work item
+ *
+ * @param {Object} db - Database connection
+ * @param {number} workItemId - Work item ID
+ * @returns {Promise<Object|null>} Existing worktree or null
+ */
+function checkExistingWorktree(db, workItemId) {
+  return new Promise((resolve, reject) => {
+    db.get(
+      `SELECT * FROM worktrees
+       WHERE work_item_id = ?
+       AND status = 'active'`,
+      [workItemId],
+      (err, row) => {
+        if (err) return reject(err);
+        resolve(row || null);
+      }
+    );
+  });
+}
 
 /**
  * Start work on a work item with graceful degradation
@@ -33,6 +56,7 @@ async function startWork(workItem, options = {}) {
   }
 
   const repoPath = options.repoPath || process.cwd();
+  const db = options.db || getDb();
   const result = {
     mode: null,           // 'worktree' or 'main'
     path: null,           // Working directory path
@@ -41,6 +65,25 @@ async function startWork(workItem, options = {}) {
     warnings: []          // Non-fatal warnings
   };
 
+  // Explicit check for existing worktree (defensive programming)
+  try {
+    const existingWorktree = await checkExistingWorktree(db, workItem.id);
+    if (existingWorktree) {
+      // Another instance is already working on this - fall back to main
+      result.mode = 'main';
+      result.path = repoPath;
+      result.error = {
+        message: `Work item #${workItem.id} already has active worktree at ${existingWorktree.worktree_path}`,
+        reason: 'duplicate_worktree_prevented'
+      };
+      result.warnings.push('Another instance may be working on this chore');
+      return result;
+    }
+  } catch (checkErr) {
+    // If check fails, continue anyway - database constraint will catch duplicates
+    result.warnings.push(`Warning: Could not check for existing worktree: ${checkErr.message}`);
+  }
+
   // Attempt to create worktree
   try {
     const worktree = await worktreeManager.createWorktree(workItem, options);

package/package.json

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