jettypod 4.4.21 → 4.4.22

package/lib/git-hooks/index.js

@@ -0,0 +1,94 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Install JettyPod git hooks into .git/hooks directory
+ * @returns {boolean} True if hooks installed successfully, false if not a git repo
+ * @throws {Error} If hook files cannot be copied or made executable
+ */
+function installHooks() {
+  const gitHooksDir = path.join(process.cwd(), '.git', 'hooks');
+  const jettypodHooksDir = path.join(__dirname);
+
+  if (!fs.existsSync(gitHooksDir)) {
+    console.log('⚠️  Not a git repository - skipping hook installation');
+    return false;
+  }
+
+  const hooks = ['pre-commit', 'post-commit', 'post-merge'];
+
+  hooks.forEach(hook => {
+    // Check both locations: features/git-hooks and .jettypod/hooks
+    let sourcePath = path.join(jettypodHooksDir, hook);
+    if (!fs.existsSync(sourcePath)) {
+      sourcePath = path.join(process.cwd(), '.jettypod', 'hooks', hook);
+    }
+
+    if (!fs.existsSync(sourcePath)) {
+      console.log(`⚠️  Hook ${hook} not found, skipping`);
+      return;
+    }
+
+    const targetPath = path.join(gitHooksDir, hook);
+
+    try {
+      // Read hook content and inject module path
+      let hookContent = fs.readFileSync(sourcePath, 'utf-8');
+
+      // Find the jettypod root (project root where jettypod.js is)
+      // Use __dirname which is reliable in this context (features/git-hooks/)
+      const jettypodRoot = path.resolve(__dirname, '..', '..');
+      const modulesPath = path.join(jettypodRoot, 'node_modules');
+
+      // Inject NODE_PATH setup after shebang
+      if (hookContent.includes('require(\'sqlite3\')')) {
+        hookContent = hookContent.replace(
+          '#!/usr/bin/env node',
+          `#!/usr/bin/env node\n\n// Injected module path\nprocess.env.NODE_PATH = '${modulesPath}' + ':' + (process.env.NODE_PATH || '');require('module').Module._initPaths();`
+        );
+      }
+
+      // Replace __JETTYPOD_ROOT__ placeholder with actual jettypod root path
+      hookContent = hookContent.replace(/__JETTYPOD_ROOT__/g, jettypodRoot);
+
+      fs.writeFileSync(targetPath, hookContent);
+
+      // Make executable
+      fs.chmodSync(targetPath, 0o755);
+    } catch (err) {
+      throw new Error(`Failed to install ${hook} hook: ${err.message}`);
+    }
+  });
+
+  console.log('✓ Git hooks installed (pre-commit, post-commit, post-merge)');
+  return true;
+}
+
+/**
+ * Check if JettyPod git hooks are installed
+ * @returns {boolean} True if hooks are installed
+ */
+function areHooksInstalled() {
+  const gitHooksDir = path.join(process.cwd(), '.git', 'hooks');
+  if (!fs.existsSync(gitHooksDir)) {
+    return false;
+  }
+
+  try {
+    const postCommitPath = path.join(gitHooksDir, 'post-commit');
+    if (!fs.existsSync(postCommitPath)) {
+      return false;
+    }
+
+    const content = fs.readFileSync(postCommitPath, 'utf-8');
+    return content.includes('JettyPod');
+  } catch (err) {
+    // If we can't read the file, assume not installed
+    return false;
+  }
+}
+
+module.exports = {
+  installHooks,
+  areHooksInstalled
+};

package/lib/git-hooks/post-commit

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+
+// JettyPod Git Hook: post-commit
+// Auto-updates work item status and regenerates docs
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const jettypodDir = path.join(process.cwd(), '.jettypod');
+const currentWorkPath = path.join(jettypodDir, 'current-work.json');
+const dbPath = path.join(jettypodDir, 'work.db');
+
+// Update work item status if needed
+(async () => {
+  if (fs.existsSync(currentWorkPath)) {
+    const currentWork = JSON.parse(fs.readFileSync(currentWorkPath, 'utf-8'));
+
+    // Only update if status is todo
+    if (currentWork.status === 'todo') {
+      try {
+        // This hook is for jettypod-source development only
+        const { updateStatus } = require(path.join(process.cwd(), 'features', 'work-tracking'));
+        await updateStatus(currentWork.id, 'in_progress');
+
+        // Update current work file
+        currentWork.status = 'in_progress';
+        fs.writeFileSync(currentWorkPath, JSON.stringify(currentWork, null, 2));
+
+        console.log(`\n✓ Work item #${currentWork.id} status updated: todo → in_progress`);
+      } catch (err) {
+        console.error('Failed to update work item:', err);
+      }
+    }
+  }
+})();
+
+// Only generate docs in worktrees (skip on main branch)
+if (process.cwd().includes('.jettypod-work')) {
+  generateDocs();
+}
+
+function generateDocs() {
+  const featuresDir = path.join(process.cwd(), 'features');
+  const outputPath = path.join(process.cwd(), 'SYSTEM-BEHAVIOR.md');
+
+  // Skip if no features directory
+  if (!fs.existsSync(featuresDir)) {
+    return;
+  }
+
+  try {
+    const docsGenerator = require(path.join(process.cwd(), 'lib', 'docs-generator'));
+    docsGenerator.generate();
+    console.log('📚 Documentation updated');
+  } catch (err) {
+    // Fail silently - docs generation is optional
+  }
+}

package/lib/git-hooks/post-merge

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+// JettyPod Git Hook: post-merge
+// Auto-updates work item status to done when merging to main
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const jettypodDir = path.join(process.cwd(), '.jettypod');
+const currentWorkPath = path.join(jettypodDir, 'current-work.json');
+const dbPath = path.join(jettypodDir, 'work.db');
+
+// Skip if no current work
+if (!fs.existsSync(currentWorkPath)) {
+  process.exit(0);
+}
+
+// Detect the default branch and check if we're on it
+let currentBranch;
+try {
+  currentBranch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+} catch (e) {
+  process.exit(0);
+}
+
+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' });
+    defaultBranch = 'main';
+  } catch {
+    try {
+      execSync('git rev-parse --verify master', { stdio: 'pipe' });
+      defaultBranch = 'master';
+    } catch {
+      // If neither exists, skip the hook
+      process.exit(0);
+    }
+  }
+}
+
+// Only update status when merging to the default branch
+if (currentBranch !== defaultBranch) {
+  process.exit(0);
+}
+
+const currentWork = JSON.parse(fs.readFileSync(currentWorkPath, 'utf-8'));
+
+// Update to done using shared updateStatus (includes epic auto-close logic)
+(async () => {
+  try {
+    const { updateStatus } = require('__JETTYPOD_ROOT__/features/work-tracking');
+    await updateStatus(currentWork.id, 'done');
+
+    // Clear current work pointer since work is done
+    fs.unlinkSync(currentWorkPath);
+
+    console.log(`\n✓ Work item #${currentWork.id} status updated: → done (merged to ${currentBranch})`);
+  } catch (err) {
+    console.error('Failed to update work item:', err);
+    process.exit(1);
+  }
+})();

package/lib/git-hooks/pre-commit

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+// Pre-commit hook: Run tests before allowing commit
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Check if we're in a real project (not a test directory)
+const packageJsonPath = path.join(process.cwd(), 'package.json');
+if (!fs.existsSync(packageJsonPath)) {
+  // Skip tests in test directories
+  process.exit(0);
+}
+
+console.log('\n🧪 Running tests before commit...\n');
+
+try {
+  // Run tests
+  execSync('npm test', { stdio: 'inherit' });
+
+  console.log('\n✅ Tests passed! Proceeding with commit.\n');
+  process.exit(0);
+} catch (err) {
+  console.log('\n❌ Tests failed! Commit blocked.\n');
+  console.log('Fix the failing tests or use --no-verify to skip this check.\n');
+  process.exit(1);
+}

package/lib/git-hooks/simple-steps.js

@@ -0,0 +1,53 @@
+const { Given, When, Then } = require('@cucumber/cucumber');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const sqlite3 = require('sqlite3').verbose();
+
+const testDir = path.join('/tmp', 'hooks-simple-' + Date.now());
+const dbFileName = process.env.NODE_ENV === 'test' ? 'test-work.db' : 'work.db';
+let originalDir;
+let workItemId;
+
+Given('I initialize a git repo with jettypod', function () {
+  originalDir = process.cwd();
+  // SAFETY: Only delete if testDir is in /tmp
+  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(testDir, { recursive: true });
+  process.chdir(testDir);
+
+  execSync('git init', { stdio: 'pipe' });
+  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
+  execSync('git config user.name "Test"', { stdio: 'pipe' });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} init`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
+});
+
+Given('I create and start work on a todo item', function () {
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work create feature "Test"`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work status 1 todo`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work start 1`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
+  workItemId = 1;
+});
+
+Then('the hook updates status to in_progress', function () {
+  const dbPath = path.join(testDir, '.jettypod', dbFileName);
+  const db = new sqlite3.Database(dbPath);
+
+  return new Promise((resolve) => {
+    db.get(`SELECT status FROM work_items WHERE id = ?`, [workItemId], (err, row) => {
+      db.close();
+      assert.strictEqual(row.status, 'in_progress');
+
+      // Cleanup
+      if (fs.existsSync(testDir)) {
+        process.chdir(originalDir);
+        fs.rmSync(testDir, { recursive: true, force: true });
+      }
+
+      resolve();
+    });
+  });
+});

package/lib/git-hooks/simple-test.feature

@@ -0,0 +1,10 @@
+Feature: Git Hooks Integration
+  As a developer
+  I want work item status to auto-update on commits
+  So I don't manually track progress
+
+  Scenario: Integration - post-commit hook updates status
+    Given I initialize a git repo with jettypod
+    And I create and start work on a todo item
+    When I make a commit
+    Then the hook updates status to in_progress

package/lib/git-hooks/steps.js

@@ -0,0 +1,196 @@
+const { Given, When, Then } = require('@cucumber/cucumber');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const sqlite3 = require('sqlite3').verbose();
+
+const testDir = path.join('/tmp', 'jettypod-hooks-test-' + Date.now());
+const dbFileName = process.env.NODE_ENV === 'test' ? 'test-work.db' : 'work.db';
+let originalDir;
+
+// Helper to ensure NODE_ENV=test is always set for test execSync calls
+function testExecSync(command, options = {}) {
+  const env = { ...process.env, NODE_ENV: 'test', ...options.env };
+  return execSync(command, { ...options, env });
+}
+
+Given('I have initialized jettypod with git', function () {
+  originalDir = process.cwd();
+  // SAFETY: Only delete if testDir is in /tmp
+  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(testDir, { recursive: true });
+  process.chdir(testDir);
+
+  execSync('git init', { stdio: 'pipe' });
+  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
+  execSync('git config user.name "Test"', { stdio: 'pipe' });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} init`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
+
+  // Verify hooks installed
+  const hookPath = path.join(testDir, '.git', 'hooks', 'post-commit');
+  this.hooksInstalled = fs.existsSync(hookPath);
+});
+
+Given('I create a work item via work commands', function () {
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work create feature "Test Feature"`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
+  this.workItemId = 1;
+});
+
+Given('I start work on the item', function () {
+  const jettypodPath = path.join(__dirname, '../../jettypod.js');
+  const workDir = process.cwd();
+  const workItemId = this.workItemId || 1;
+
+  testExecSync(`node ${jettypodPath} work start ${workItemId}`, { cwd: workDir, stdio: 'pipe' });
+});
+
+When('I commit changes', function () {
+  fs.writeFileSync('test.txt', 'test content');
+  execSync('git add .', { stdio: 'pipe' });
+  execSync('git commit -m "test commit"', { stdio: 'pipe' });
+});
+
+Then('the work item status updates automatically', function () {
+  const dbPath = path.join(testDir, '.jettypod', dbFileName);
+  const db = new sqlite3.Database(dbPath);
+
+  return new Promise((resolve) => {
+    db.get(`SELECT status FROM work_items WHERE id = ?`, [this.workItemId], (err, row) => {
+      db.close();
+      // Should be in_progress (updated by post-commit hook)
+      assert(row.status === 'in_progress' || row.status === 'backlog',
+        `Expected in_progress or backlog, got ${row.status}`);
+      resolve();
+    });
+  });
+});
+
+Then('the current work file still exists', function () {
+  const currentWorkPath = path.join(testDir, '.jettypod', 'current-work.json');
+  assert(fs.existsSync(currentWorkPath), 'Current work file should still exist');
+
+  // Cleanup
+  if (fs.existsSync(testDir)) {
+    process.chdir(originalDir);
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+});
+
+Given('I have a work item with status {string}', function (status) {
+  originalDir = process.cwd();
+  // SAFETY: Only delete if testDir is in /tmp
+  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(testDir, { recursive: true });
+  process.chdir(testDir);
+
+  execSync('git init', { stdio: 'pipe' });
+  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
+  execSync('git config user.name "Test"', { stdio: 'pipe' });
+
+  // Make initial commit so branch exists
+  fs.writeFileSync('README.md', '# Test');
+  execSync('git add .', { stdio: 'pipe' });
+  execSync('git commit -m "Initial commit"', { stdio: 'pipe' });
+
+  // Store default branch name
+  this.defaultBranch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} init`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
+
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work create feature "Test"`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work status 1 ${status}`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
+
+  this.workItemId = 1;
+  this.initialStatus = status;
+});
+
+Given('the work item is set as current work', function () {
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work start ${this.workItemId}`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
+});
+
+Given('I am on a feature branch', function () {
+  // Make initial commit on main so it exists
+  fs.writeFileSync('init.txt', 'init');
+  execSync('git add .', { stdio: 'pipe' });
+  execSync('git commit -m "initial commit"', { stdio: 'pipe' });
+
+  // Now create feature branch
+  execSync('git checkout -b feature/test', { stdio: 'pipe' });
+});
+
+When('I make my first commit', function () {
+  fs.writeFileSync('test.txt', 'test');
+  execSync('git add .', { stdio: 'pipe' });
+  execSync('git commit -m "first commit"', { stdio: 'pipe' });
+});
+
+When('I merge to main', function () {
+  // Commit on feature branch
+  fs.writeFileSync('feature.txt', 'feature');
+  execSync('git add .', { stdio: 'pipe' });
+  execSync('git commit -m "feature commit"', { stdio: 'pipe' });
+
+  // Switch to default branch and merge
+  execSync(`git checkout ${this.defaultBranch}`, { stdio: 'pipe' });
+  execSync('git merge feature/test --no-edit', { stdio: 'pipe' });
+});
+
+Then('the work item status should be {string}', function (expectedStatus) {
+  const dbPath = path.join(testDir, '.jettypod', dbFileName);
+
+  return new Promise((resolve) => {
+    // Give the post-merge hook time to complete
+    setTimeout(() => {
+      const db = new sqlite3.Database(dbPath);
+      db.get(`SELECT status FROM work_items WHERE id = ?`, [this.workItemId], (err, row) => {
+        db.close();
+        assert.strictEqual(row.status, expectedStatus);
+
+        // Cleanup
+        if (fs.existsSync(testDir)) {
+          process.chdir(originalDir);
+          fs.rmSync(testDir, { recursive: true, force: true });
+        }
+
+        resolve();
+      });
+    }, 50); // Small delay to ensure hook completes
+  });
+});
+
+Given('no work item is set as current', function () {
+  originalDir = process.cwd();
+  // SAFETY: Only delete if testDir is in /tmp
+  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(testDir, { recursive: true });
+  process.chdir(testDir);
+
+  execSync('git init', { stdio: 'pipe' });
+  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
+  execSync('git config user.name "Test"', { stdio: 'pipe' });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} init`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
+});
+
+When('I make a commit', function () {
+  fs.writeFileSync('test.txt', 'test');
+  execSync('git add .', { stdio: 'pipe' });
+  execSync('git commit -m "test"', { stdio: 'pipe' });
+});
+
+Then('no errors occur', function () {
+  // If we got here, no errors occurred
+  assert(true);
+
+  // Cleanup
+  if (fs.existsSync(testDir)) {
+    process.chdir(originalDir);
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+});

package/lib/mode-prompts/index.js

@@ -0,0 +1,95 @@
+const readline = require('readline');
+const fs = require('fs');
+const path = require('path');
+const sqlite3 = require('sqlite3').verbose();
+
+/**
+ * Prompt user for work item status update
+ * @param {Object} currentWork - Current work item with id, title, and status
+ * @returns {Promise<string|null>} New status or null if skipped
+ * @throws {Error} If currentWork is invalid or missing required fields
+ */
+function promptForStatusUpdate(currentWork) {
+  // Validate input
+  if (!currentWork || typeof currentWork !== 'object') {
+    return Promise.reject(new Error('Invalid currentWork: must be an object'));
+  }
+
+  if (!currentWork.id || !currentWork.title || !currentWork.status) {
+    return Promise.reject(new Error('Invalid currentWork: missing id, title, or status'));
+  }
+
+  return new Promise((resolve, reject) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    console.log(`\nCurrent work: [#${currentWork.id}] ${currentWork.title} (${currentWork.status})`);
+    rl.question('Update status? [in_progress/blocked/done/skip]: ', (answer) => {
+      rl.close();
+
+      const status = answer.trim();
+      if (status === 'skip' || status === '') {
+        resolve(null);
+      } else if (['in_progress', 'blocked', 'done', 'todo', 'backlog'].includes(status)) {
+        resolve(status);
+      } else {
+        console.log('Invalid status, skipping update');
+        resolve(null);
+      }
+    });
+  });
+}
+
+/**
+ * Update work item status in database and current work file
+ * Uses shared updateStatus from work-tracking for consistency and epic auto-close logic
+ * @param {number} workItemId - ID of work item to update
+ * @param {string} newStatus - New status value
+ * @returns {Promise<void>}
+ * @throws {Error} If workItemId is invalid, newStatus is invalid, database not found, or file operations fail
+ */
+async function updateWorkItemStatus(workItemId, newStatus) {
+  // Validate inputs
+  if (!workItemId || isNaN(workItemId) || workItemId < 1) {
+    return Promise.reject(new Error('Invalid work item ID'));
+  }
+
+  const validStatuses = ['in_progress', 'blocked', 'done', 'todo', 'backlog', 'cancelled'];
+  if (!newStatus || !validStatuses.includes(newStatus)) {
+    return Promise.reject(new Error(`Invalid status: ${newStatus}`));
+  }
+
+  const jettypodDir = path.join(process.cwd(), '.jettypod');
+  const { getDbPath } = require('../../lib/database');
+  const dbPath = getDbPath();
+  const currentWorkPath = path.join(jettypodDir, 'current-work.json');
+
+  // Check database exists
+  if (!fs.existsSync(dbPath)) {
+    return Promise.reject(new Error('Work database not found. Run: jettypod init'));
+  }
+
+  // Use shared updateStatus from work-tracking (includes epic auto-close logic)
+  const { updateStatus } = require('../work-tracking');
+  await updateStatus(workItemId, newStatus);
+
+  // Update current work file if it exists
+  if (fs.existsSync(currentWorkPath)) {
+    try {
+      const currentWork = JSON.parse(fs.readFileSync(currentWorkPath, 'utf-8'));
+      currentWork.status = newStatus;
+      fs.writeFileSync(currentWorkPath, JSON.stringify(currentWork, null, 2));
+    } catch (fileErr) {
+      return Promise.reject(new Error(`Failed to update current work file: ${fileErr.message}`));
+    }
+  }
+
+  console.log(`✓ Work item #${workItemId} status updated to ${newStatus}`);
+}
+
+module.exports = {
+  promptForStatusUpdate,
+  updateWorkItemStatus
+};

package/lib/mode-prompts/simple-steps.js

@@ -0,0 +1,44 @@
+const { Given, When, Then } = require('@cucumber/cucumber');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const testDir = path.join('/tmp', 'mode-prompts-' + Date.now());
+let originalDir;
+
+Given('I have jettypod with a work item in progress', function () {
+  originalDir = process.cwd();
+  // SAFETY: Only delete if testDir is in /tmp
+  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(testDir, { recursive: true });
+  process.chdir(testDir);
+
+  execSync('git init', { stdio: 'pipe' });
+  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
+  execSync('git config user.name "Test"', { stdio: 'pipe' });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} init`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work create feature "Test"`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work start 1`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
+});
+
+When('I check current work exists', function () {
+  const currentWorkPath = path.join(testDir, '.jettypod', 'current-work.json');
+  this.currentWorkExists = fs.existsSync(currentWorkPath);
+  if (this.currentWorkExists) {
+    this.currentWork = JSON.parse(fs.readFileSync(currentWorkPath, 'utf-8'));
+  }
+});
+
+Then('the work item has a status', function () {
+  assert(this.currentWorkExists, 'Current work file should exist');
+  assert(this.currentWork.status, 'Work item should have a status');
+
+  // Cleanup
+  if (fs.existsSync(testDir)) {
+    process.chdir(originalDir);
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+});

package/lib/mode-prompts/simple-test.feature

@@ -0,0 +1,9 @@
+Feature: Mode Change Prompts
+  As a developer
+  I want to update work status when switching modes
+  So my work state stays current
+
+  Scenario: Integration - mode change with work item present
+    Given I have jettypod with a work item in progress
+    When I check current work exists
+    Then the work item has a status