jettypod 4.4.21 → 4.4.22

package/lib/work-commands/steps.js

@@ -0,0 +1,1233 @@
+const { Given, When, Then, AfterAll } = 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 workCommands = require('./index');
+const { resetDb } = require('../../lib/database');
+const { runMigrations } = require('../../lib/migrations');
+
+const testDir = path.join('/tmp', 'jettypod-work-commands-test-' + Date.now());
+
+// Dynamic getters for paths that update when directory changes
+function getJettypodDir() {
+  return path.join(process.cwd(), '.jettypod');
+}
+
+function getDbPath() {
+  const dbFileName = process.env.NODE_ENV === 'test' ? 'test-work.db' : 'work.db';
+  return path.join(getJettypodDir(), dbFileName);
+}
+
+function getCurrentWorkPath() {
+  return path.join(getJettypodDir(), 'current-work.json');
+}
+
+// Helper to get database connection (always use singleton)
+function getTestDb() {
+  const { getDb } = require('../../lib/database');
+  return getDb();
+}
+
+// Keep these for backward compatibility in some steps that use testDir
+const jettypodDir = path.join(testDir, '.jettypod');
+const dbFileName = process.env.NODE_ENV === 'test' ? 'test-work.db' : 'work.db';
+const dbPath = path.join(jettypodDir, dbFileName);
+const currentWorkPath = path.join(jettypodDir, 'current-work.json');
+const claudePath = path.join(testDir, 'CLAUDE.md');
+
+// Test state
+let testContext = {};
+let originalDir = process.cwd(); // Store original directory for CLI tests
+
+// 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 });
+}
+
+// Setup test environment
+async function setupTestEnv() {
+  // Reset singleton db connection to avoid stale connections
+  const { closeDb } = require('../../lib/database');
+  await closeDb();
+  resetDb();
+
+  // 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 });
+  fs.mkdirSync(getJettypodDir(), { recursive: true });
+
+  // Change to test directory
+  process.chdir(testDir);
+
+  // Initialize git
+  try {
+    execSync('git init', { stdio: 'pipe' });
+    execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
+    execSync('git config user.name "Test"', { stdio: 'pipe' });
+    execSync('git checkout -b main', { stdio: 'pipe' });
+  } catch (e) {
+    // Git already initialized
+  }
+
+  // Use singleton getDb() to initialize database
+  const { getDb } = require('../../lib/database');
+  const db = getDb();
+
+  // Run all migrations to ensure schema is up to date
+  await runMigrations(db);
+
+  // Don't close - let singleton manage it
+}
+
+// Cleanup test environment
+async function cleanupTestEnv() {
+  const { closeDb } = require('../../lib/database');
+  await closeDb();
+  resetDb();
+
+  // SAFETY: Only delete if testDir is in /tmp
+  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
+    process.chdir(originalDir);
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+  testContext = {};
+}
+
+// Before each scenario
+Given('a work item exists with id {string} and title {string}', async function (id, title) {
+  await setupTestEnv();
+  return new Promise((resolve) => {
+    const db = getTestDb();
+    db.run(`INSERT INTO work_items (id, type, title, status) VALUES (?, 'feature', ?, 'todo')`, [parseInt(id), title], () => {
+      // Removed db.close() - let Node.js handle cleanup
+      resolve();
+    });
+  });
+});
+
+Given('a work item exists with id {string} title {string} parent {string} and type {string}', async function (id, title, parentId, type) {
+  if (!fs.existsSync(testDir)) await setupTestEnv();
+  return new Promise((resolve) => {
+    const db = getTestDb();
+    db.run(`INSERT INTO work_items (id, type, title, status, parent_id) VALUES (?, ?, ?, 'todo', ?)`,
+      [parseInt(id), type, title, parseInt(parentId)], () => {
+        // Removed db.close() - let Node.js handle cleanup
+        resolve();
+      });
+  });
+});
+
+Given('a work item exists with id {string} title {string} and type {string}', async function (id, title, type) {
+  if (!fs.existsSync(testDir)) await setupTestEnv();
+  return new Promise((resolve) => {
+    const db = getTestDb();
+    const idInt = parseInt(id);
+    db.run(`INSERT INTO work_items (id, type, title, status) VALUES (?, ?, ?, 'todo')`,
+      [idInt, type, title], () => {
+      // Removed db.close() - let Node.js handle cleanup
+      resolve();
+    });
+  });
+});
+
+Given('a work item exists with id {string} title {string} and status {string}', async function (id, title, status) {
+  if (!fs.existsSync(testDir)) await setupTestEnv();
+  return new Promise((resolve) => {
+    const db = getTestDb();
+    db.run(`INSERT INTO work_items (id, type, title, status) VALUES (?, 'feature', ?, ?)`, [parseInt(id), title, status], () => {
+      // Removed db.close() - let Node.js handle cleanup
+      resolve();
+    });
+  });
+});
+
+Given('work item {string} is currently active with status {string}', async function (id, status) {
+  await setupTestEnv();
+  return new Promise((resolve) => {
+    const db = getTestDb();
+    db.run(`INSERT INTO work_items (id, type, title, status) VALUES (?, 'feature', 'Test Item', ?)`, [parseInt(id), status], () => {
+      // Removed db.close() - let Node.js handle cleanup
+      const currentWork = {
+        id: parseInt(id),
+        title: 'Test Item',
+        type: 'feature',
+        status: status
+      };
+      fs.writeFileSync(getCurrentWorkPath(), JSON.stringify(currentWork, null, 2));
+      resolve();
+    });
+  });
+});
+
+Given('CLAUDE.md exists with mode {string}', async function (mode) {
+  if (!fs.existsSync(testDir)) await setupTestEnv();
+  const content = `<claude_context project="test">
+<project_state>internal - Internal (team only, staging/preview - no external users)</project_state>
+<mode>${mode}</mode>
+</claude_context>`;
+  fs.writeFileSync(claudePath, content);
+});
+
+Given('I am on branch {string}', function (branch) {
+  try {
+    execSync(`git checkout -b ${branch}`, { stdio: 'pipe' });
+  } catch (e) {
+    execSync(`git checkout ${branch}`, { stdio: 'pipe' });
+  }
+});
+
+When('I run {string}', async function (command) {
+  const parts = command.split(' ');
+  if (parts[0] === 'jettypod' && parts[1] === 'work' && parts[2] === 'start') {
+    const id = parseInt(parts[3]);
+    const result = await workCommands.startWork(id);
+    testContext.output = `Working on: [#${result.workItem.id}] ${result.workItem.title} (${result.workItem.type})`;
+    if (result.workItem.parent_title) {
+      testContext.output = `Working on: [#${result.workItem.id}] ${result.workItem.title} (${result.workItem.type} of #${result.workItem.parent_id} ${result.workItem.parent_title})`;
+    }
+  } else if (parts[0] === 'jettypod' && (parts[1] === 'init' || parts.length === 1)) {
+    // Capture output for jettypod init
+    const originalLog = console.log;
+    let capturedOutput = '';
+    console.log = (...args) => {
+      capturedOutput += args.join(' ') + '\n';
+      originalLog(...args);
+    };
+
+    // Ensure testDir exists or use current directory
+    const workDir = (testDir && fs.existsSync(testDir)) ? testDir : process.cwd();
+
+    try {
+      const output = execSync(
+        `node ${path.join(__dirname, '../../jettypod.js')} ${parts.slice(1).join(' ')}`,
+        { cwd: workDir, encoding: 'utf-8' }
+      );
+      capturedOutput += output;
+    } catch (err) {
+      capturedOutput += err.stdout || '';
+    } finally {
+      console.log = originalLog;
+    }
+
+    testContext.commandOutput = capturedOutput;
+    testContext.initOutput = capturedOutput;
+    // Also set on 'this' for other step files (e.g., terminal-logo tests)
+    this.commandOutput = capturedOutput;
+    this.initOutput = capturedOutput;
+  } else if (parts[0] === 'jettypod') {
+    // Handle other jettypod commands (backlog, project external, etc.)
+    const workDir = (testDir && fs.existsSync(testDir)) ? testDir : process.cwd();
+
+    try {
+      const output = execSync(
+        `node ${path.join(__dirname, '../../jettypod.js')} ${parts.slice(1).join(' ')}`,
+        { cwd: workDir, encoding: 'utf-8' }
+      );
+      testContext.commandOutput = output;
+      this.commandOutput = output;
+      this.output = output; // For external-transition tests
+      this.error = null; // No error occurred
+    } catch (err) {
+      testContext.commandOutput = err.stdout || '';
+      this.commandOutput = err.stdout || '';
+      this.output = err.stdout || err.stderr || err.message; // For external-transition tests
+      this.error = err; // Store error for external-transition tests
+    }
+  }
+});
+
+When('I run {string} and enter status {string}', async function (command, status) {
+  await workCommands.stopWork(status);
+});
+
+Then('the current work file should contain work item {string}', function (id) {
+  assert(fs.existsSync(getCurrentWorkPath()), 'Current work file does not exist');
+  const currentWork = JSON.parse(fs.readFileSync(getCurrentWorkPath(), 'utf-8'));
+  assert.strictEqual(currentWork.id, parseInt(id));
+});
+
+Then('the work item {string} status should be {string}', function (id, status) {
+  const db = getTestDb();
+  return new Promise((resolve) => {
+    db.get(`SELECT status FROM work_items WHERE id = ?`, [parseInt(id)], (err, row) => {
+      // Removed db.close() - let Node.js handle cleanup
+      assert.strictEqual(row.status, status);
+      resolve();
+    });
+  });
+});
+
+Then('a feature branch {string} should be created', function (branchName) {
+  const branches = execSync('git branch', { encoding: 'utf-8' });
+  assert(branches.includes(branchName), `Branch ${branchName} not found`);
+});
+
+Then('CLAUDE.md current_work should show {string}', function (text) {
+  const content = fs.readFileSync(claudePath, 'utf-8');
+  assert(content.includes(text), `CLAUDE.md does not contain: ${text}`);
+});
+
+Then('the current work file should be empty', function () {
+  assert(!fs.existsSync(getCurrentWorkPath()), 'Current work file still exists');
+});
+
+Then('the output should contain {string}', function (text) {
+  assert(testContext.output && testContext.output.includes(text), `Output does not contain: ${text}`);
+});
+
+Then('CLAUDE.md mode should still be {string}', function (mode) {
+  const content = fs.readFileSync(claudePath, 'utf-8');
+  const modeMatch = content.match(/<mode>(.*?)<\/mode>/);
+  assert(modeMatch && modeMatch[1] === mode, `Mode is not ${mode}`);
+});
+
+Then('I should be on branch {string}', function (branchName) {
+  const currentBranch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+  assert.strictEqual(currentBranch, branchName);
+});
+
+// Stable tests steps
+
+Given('jettypod is initialized', async function () {
+  await setupTestEnv();
+});
+
+Given('jettypod is not initialized', function () {
+  // 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);
+  // Don't create .jettypod directory
+});
+
+Given('I have current work', async function () {
+  await setupTestEnv();
+  return new Promise((resolve) => {
+    const db = getTestDb();
+    db.run(`INSERT INTO work_items (id, type, title, status) VALUES (1, 'feature', 'Test Work', 'in_progress')`, () => {
+      // Removed db.close() - let Node.js handle cleanup
+      const currentWork = {
+        id: 1,
+        title: 'Test Work',
+        type: 'feature',
+        status: 'in_progress'
+      };
+      fs.writeFileSync(getCurrentWorkPath(), JSON.stringify(currentWork, null, 2));
+      resolve();
+    });
+  });
+});
+
+Given('no work is active', function () {
+  if (fs.existsSync(getCurrentWorkPath())) {
+    fs.unlinkSync(getCurrentWorkPath());
+  }
+});
+
+Given('current work file is corrupted', async function () {
+  await setupTestEnv();
+  fs.writeFileSync(getCurrentWorkPath(), 'invalid json {{{');
+});
+
+Given('jettypod is initialized without git', function (done) {
+  // Reset database singleton to avoid issues with previous tests
+  resetDb();
+
+  // 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);  // Change directory BEFORE creating .jettypod
+  fs.mkdirSync(getJettypodDir(), { recursive: true });
+
+  // Initialize database but no git - use proper migrations
+  const db = getTestDb();
+  runMigrations(db).then(() => done()).catch(done);
+});
+
+Given('I have a work item', async function () {
+  // Check if we need full setup (including git) or just database
+  const dbPath = path.join(getJettypodDir(), process.env.NODE_ENV === 'test' ? 'test-work.db' : 'work.db');
+  const needsSetup = !fs.existsSync(dbPath);
+
+  if (needsSetup) {
+    // Check if we're in a git-free test (testDir exists but no .git)
+    const isWithoutGit = fs.existsSync(testDir) && !fs.existsSync(path.join(testDir, '.git'));
+    if (!isWithoutGit) {
+      await setupTestEnv();
+    }
+  } else {
+    // Database exists, but clean up git state from previous scenarios
+    if (fs.existsSync(testDir) && fs.existsSync(path.join(testDir, '.git'))) {
+      try {
+        // Remove all feature branches
+        const branches = execSync('git branch', { cwd: testDir, encoding: 'utf8', stdio: 'pipe' });
+        branches.split('\n').forEach(branch => {
+          branch = branch.trim().replace('*', '').trim();
+          if (branch && branch.startsWith('feature/')) {
+            try {
+              execSync(`git branch -D "${branch}"`, { cwd: testDir, stdio: 'pipe' });
+            } catch (e) {
+              // Branch might be checked out or already deleted, ignore
+            }
+          }
+        });
+
+        // Prune worktrees
+        try {
+          execSync('git worktree prune', { cwd: testDir, stdio: 'pipe' });
+        } catch (e) {
+          // Ignore prune errors
+        }
+
+        // Remove worktree directories
+        const worktreeDir = path.join(testDir, '.jettypod-work');
+        if (fs.existsSync(worktreeDir)) {
+          fs.rmSync(worktreeDir, { recursive: true, force: true });
+        }
+      } catch (e) {
+        // If cleanup fails, ignore and continue
+      }
+    }
+  }
+
+  return new Promise((resolve) => {
+    const db = getTestDb();
+    db.run(`INSERT INTO work_items (id, type, title, status) VALUES (1, 'feature', 'Test Item', 'todo')`, () => {
+      testContext.workItemId = 1;
+      this.workItemId = 1; // Also set on this for git-hooks steps compatibility
+      resolve();
+    });
+  });
+});
+
+Given('I start work on it', function () {
+  // Check if workItemId is in testContext or this (from other step files)
+  const workItemId = testContext.workItemId || this.workItemId;
+
+  // Use CLI to avoid database singleton issues across test contexts
+  try {
+    testExecSync(`node ${path.join(__dirname, '../../jettypod.js')} work start ${workItemId}`, { cwd: testDir, stdio: 'pipe' });
+    testContext.firstWorkItemId = workItemId;
+  } catch (err) {
+    // If CLI fails, try direct module call
+    return workCommands.startWork(workItemId).then(result => {
+      testContext.firstWorkItemId = result.workItem.id;
+    });
+  }
+});
+
+When('I try to start work with ID {string}', async function (id) {
+  try {
+    await workCommands.startWork(id);
+    testContext.error = null;
+  } catch (err) {
+    testContext.error = err.message;
+  }
+});
+
+When('I try to stop work with status {string}', async function (status) {
+  try {
+    await workCommands.stopWork(status);
+    testContext.error = null;
+  } catch (err) {
+    testContext.error = err.message;
+  }
+});
+
+When('I try to stop work', async function () {
+  try {
+    await workCommands.stopWork();
+    testContext.error = null;
+  } catch (err) {
+    testContext.error = err.message;
+  }
+});
+
+When('I get current work', async function () {
+  try {
+    testContext.currentWork = await workCommands.getCurrentWork();
+  } catch (err) {
+    testContext.currentWork = null;
+  }
+});
+
+// Note: "I start work on the item" is defined in git-hooks/steps.js
+
+When('I start work on a different item', async function () {
+  // Create a second work item
+  return new Promise((resolve) => {
+    const db = getTestDb();
+    db.run(`INSERT INTO work_items (id, type, title, status) VALUES (2, 'feature', 'Second Item', 'todo')`, async () => {
+      // Removed db.close() - let Node.js handle cleanup
+      testContext.secondWorkItemId = 2;
+      await workCommands.startWork(testContext.secondWorkItemId);
+      resolve();
+    });
+  });
+});
+
+Then('I get an error {string}', function (expectedError) {
+  assert(testContext.error, 'No error was thrown');
+  assert(testContext.error.includes(expectedError), `Expected error "${expectedError}" but got "${testContext.error}"`);
+});
+
+Then('operation succeeds with no changes', function () {
+  assert.strictEqual(testContext.error, null, 'Operation should not error');
+});
+
+Then('it returns null', function () {
+  assert.strictEqual(testContext.currentWork, null);
+});
+
+Then('it succeeds without creating branch', function () {
+  assert(!fs.existsSync(path.join(testDir, '.git')), 'Git directory should not exist');
+  assert(fs.existsSync(getCurrentWorkPath()), 'Current work file should exist');
+});
+
+Then('the first item stops being current', function () {
+  const currentWork = JSON.parse(fs.readFileSync(getCurrentWorkPath(), 'utf-8'));
+  assert.notStrictEqual(currentWork.id, testContext.firstWorkItemId);
+});
+
+Then('the second item becomes current', function () {
+  const currentWork = JSON.parse(fs.readFileSync(getCurrentWorkPath(), 'utf-8'));
+  assert.strictEqual(currentWork.id, testContext.secondWorkItemId);
+});
+
+Then('the status remains {string}', function (expectedStatus) {
+  const db = getTestDb();
+  return new Promise((resolve) => {
+    db.get(`SELECT status FROM work_items WHERE id = ?`, [testContext.workItemId], (err, row) => {
+      // Removed db.close() - let Node.js handle cleanup
+      assert.strictEqual(row.status, expectedStatus);
+      resolve();
+    });
+  });
+});
+
+// Mode-required steps - Epic
+When('I create an epic {string} without mode', function(title) {
+  try {
+    const output = execSync(
+      `node ${path.join(__dirname, '../../jettypod.js')} work create epic "${title}"`,
+      { cwd: testDir, encoding: 'utf-8' }
+    );
+    testContext.lastOutput = output;
+
+    const match = output.match(/Created \w+ #(\d+):/);
+    if (match) {
+      testContext.createdItemId = parseInt(match[1]);
+      testContext.epicId = parseInt(match[1]);  // Also set epicId for parent references
+      testContext.lastCreatedId = parseInt(match[1]);  // For start work steps
+    }
+  } catch (err) {
+    testContext.error = err.stderr || err.message;
+  }
+});
+
+// Removed duplicate: When('I create an epic {string} with mode {string}')
+// Using the Given version at line 538 instead
+
+// Mode-required steps - Feature
+When('I create a feature {string} with mode {string}', function(title, mode) {
+  try {
+    const output = execSync(
+      `node ${path.join(__dirname, '../../jettypod.js')} work create feature "${title}" "" --mode=${mode}`,
+      { cwd: testDir, encoding: 'utf-8' }
+    );
+    testContext.lastOutput = output;
+
+    const match = output.match(/Created \w+ #(\d+):/);
+    if (match) {
+      testContext.createdItemId = parseInt(match[1]);
+      testContext.lastCreatedId = parseInt(match[1]);  // For start work steps
+      testContext.lastFeatureId = parseInt(match[1]);  // For type-specific start work steps
+      if (!testContext.createdItemIds) testContext.createdItemIds = [];
+      testContext.createdItemIds.push(testContext.createdItemId);
+    }
+  } catch (err) {
+    testContext.error = err.stderr || err.message;
+  }
+});
+
+When('I create a feature {string} without mode', function(title) {
+  try {
+    const output = execSync(
+      `node ${path.join(__dirname, '../../jettypod.js')} work create feature "${title}"`,
+      { cwd: testDir, encoding: 'utf-8' }
+    );
+    testContext.lastOutput = output;
+
+    const match = output.match(/Created \w+ #(\d+):/);
+    if (match) {
+      testContext.createdItemId = parseInt(match[1]);
+    }
+  } catch (err) {
+    testContext.error = err.stderr || err.message;
+  }
+});
+
+When('I try to create a feature {string} without mode', function(title) {
+  try {
+    const output = execSync(
+      `node ${path.join(__dirname, '../../jettypod.js')} work create feature "${title}"`,
+      { cwd: testDir, encoding: 'utf-8', stderr: 'pipe' }
+    );
+    testContext.lastOutput = output;
+  } catch (err) {
+    testContext.error = err.stderr || err.message;
+  }
+});
+
+When('I try to create a feature {string} with mode {string}', function(title, mode) {
+  try {
+    const output = execSync(
+      `node ${path.join(__dirname, '../../jettypod.js')} work create feature "${title}" "" --mode=${mode}`,
+      { cwd: testDir, encoding: 'utf-8', stderr: 'pipe' }
+    );
+    testContext.lastOutput = output;
+  } catch (err) {
+    testContext.error = err.stderr || err.message;
+  }
+});
+
+Then('the work item is created successfully', function() {
+  assert(testContext.lastOutput.includes('Created'));
+  assert(typeof testContext.createdItemId === 'number');
+});
+
+Then('the work item has mode {string}', function(mode) {
+  const db = getTestDb();
+  return new Promise((resolve) => {
+    db.get('SELECT mode FROM work_items WHERE id = ?', [testContext.createdItemId], (err, row) => {
+      // Removed db.close() - let Node.js handle cleanup
+      assert.strictEqual(row.mode, mode);
+      resolve();
+    });
+  });
+});
+
+Then('the work item has no mode', function() {
+  const db = getTestDb();
+  return new Promise((resolve) => {
+    db.get('SELECT mode FROM work_items WHERE id = ?', [testContext.createdItemId], (err, row) => {
+      // Removed db.close() - let Node.js handle cleanup
+      assert.strictEqual(row.mode, null);
+      resolve();
+    });
+  });
+});
+
+Then('no work item is created', function() {
+  const db = getTestDb();
+  return new Promise((resolve) => {
+    db.get('SELECT COUNT(*) as count FROM work_items', [], (err, row) => {
+      // Removed db.close() - let Node.js handle cleanup
+      assert.strictEqual(row.count, 0);
+      resolve();
+    });
+  });
+});
+
+Given('I create an epic {string} with mode {string}', function(title, mode) {
+  const output = execSync(
+    `node ${path.join(__dirname, '../../jettypod.js')} work create epic "${title}" "" --mode=${mode}`,
+    { cwd: testDir, encoding: 'utf-8' }
+  );
+
+  const match = output.match(/Created \w+ #(\d+):/);
+  if (match) {
+    testContext.epicId = parseInt(match[1]);
+  }
+});
+
+Given('I create a feature {string} with mode {string} and parent epic', function(title, mode) {
+  const output = execSync(
+    `node ${path.join(__dirname, '../../jettypod.js')} work create feature "${title}" "" --mode=${mode} --parent=${testContext.epicId}`,
+    { cwd: testDir, encoding: 'utf-8' }
+  );
+
+  const match = output.match(/Created \w+ #(\d+):/);
+  if (match) {
+    const id = parseInt(match[1]);
+    // Store based on mode to support multiple features with different modes
+    if (mode === 'speed') {
+      testContext.lastCreatedSpeedFeatureId = id;
+    } else if (mode === 'stable') {
+      testContext.lastCreatedStableFeatureId = id;
+    }
+    // Also store as generic lastCreatedId for backward compatibility
+    testContext.lastCreatedId = id;
+  }
+});
+
+When('I view the backlog', function() {
+  testContext.lastOutput = execSync(
+    `node ${path.join(__dirname, '../../jettypod.js')} backlog`,
+    { cwd: testDir, encoding: 'utf-8' }
+  );
+});
+
+Then('I see the epic with mode {string}', function(mode) {
+  assert(testContext.lastOutput.includes('Test Epic'));
+});
+
+Then('I see the child feature with mode {string}', function(mode) {
+  assert(testContext.lastOutput.includes('Child Feature'));
+  assert(testContext.lastOutput.includes(`[${mode}]`));
+});
+
+// Bug steps
+When('I create a bug {string} with mode {string}', function(title, mode) {
+  try {
+    const output = execSync(
+      `node ${path.join(__dirname, '../../jettypod.js')} work create bug "${title}" "" --mode=${mode}`,
+      { cwd: testDir, encoding: 'utf-8' }
+    );
+    testContext.lastOutput = output;
+
+    const match = output.match(/Created \w+ #(\d+):/);
+    if (match) {
+      testContext.createdItemId = parseInt(match[1]);
+      testContext.lastCreatedId = parseInt(match[1]);  // For start work steps
+      testContext.lastBugId = parseInt(match[1]);  // For type-specific start work steps
+    }
+  } catch (err) {
+    testContext.error = err.stderr || err.message;
+  }
+});
+
+When('I create a bug {string} without mode', function(title) {
+  try {
+    const output = execSync(
+      `node ${path.join(__dirname, '../../jettypod.js')} work create bug "${title}"`,
+      { cwd: testDir, encoding: 'utf-8' }
+    );
+    testContext.lastOutput = output;
+
+    const match = output.match(/Created \w+ #(\d+):/);
+    if (match) {
+      testContext.createdItemId = parseInt(match[1]);
+    }
+  } catch (err) {
+    testContext.error = err.stderr || err.message;
+  }
+});
+
+When('I try to create a bug {string} without mode', function(title) {
+  try {
+    const output = execSync(
+      `node ${path.join(__dirname, '../../jettypod.js')} work create bug "${title}"`,
+      { cwd: testDir, encoding: 'utf-8', stderr: 'pipe' }
+    );
+    testContext.lastOutput = output;
+  } catch (err) {
+    testContext.error = err.stderr || err.message;
+  }
+});
+
+When('I try to create a bug {string} with mode {string}', function(title, mode) {
+  try {
+    const output = execSync(
+      `node ${path.join(__dirname, '../../jettypod.js')} work create bug "${title}" "" --mode=${mode}`,
+      { cwd: testDir, encoding: 'utf-8', stderr: 'pipe' }
+    );
+    testContext.lastOutput = output;
+  } catch (err) {
+    testContext.error = err.stderr || err.message;
+  }
+});
+
+// Chore steps
+When('I try to create a chore {string} with mode {string}', function(title, mode) {
+  try {
+    execSync(
+      `node ${path.join(__dirname, '../../jettypod.js')} work create chore "${title}" "" --mode=${mode}`,
+      { cwd: testDir, encoding: 'utf-8', stdio: 'pipe' }
+    );
+    testContext.error = null;
+  } catch (err) {
+    testContext.error = err.stderr || err.message;
+  }
+});
+
+When('I create a chore {string} without mode', function(title) {
+  try {
+    const output = execSync(
+      `node ${path.join(__dirname, '../../jettypod.js')} work create chore "${title}"`,
+      { cwd: testDir, encoding: 'utf-8' }
+    );
+    testContext.lastOutput = output;
+
+    const match = output.match(/Created \w+ #(\d+):/);
+    if (match) {
+      testContext.createdItemId = parseInt(match[1]);
+    }
+  } catch (err) {
+    testContext.error = err.stderr || err.message;
+  }
+});
+
+When('I try to create a chore {string} without mode', function(title) {
+  try {
+    const output = execSync(
+      `node ${path.join(__dirname, '../../jettypod.js')} work create chore "${title}"`,
+      { cwd: testDir, encoding: 'utf-8', stderr: 'pipe' }
+    );
+    testContext.lastOutput = output;
+  } catch (err) {
+    testContext.error = err.stderr || err.message;
+  }
+});
+
+// Additional assertions
+Then('the work item has NULL mode', function() {
+  const db = getTestDb();
+  return new Promise((resolve) => {
+    db.get('SELECT mode FROM work_items WHERE id = ?', [testContext.createdItemId], (err, row) => {
+      // Removed db.close() - let Node.js handle cleanup
+      assert.strictEqual(row.mode, null);
+      resolve();
+    });
+  });
+});
+
+Given('I create a bug {string} with parent epic', function(title) {
+  const output = execSync(
+    `node ${path.join(__dirname, '../../jettypod.js')} work create bug "${title}" "" --parent=${testContext.epicId}`,
+    { cwd: testDir, encoding: 'utf-8' }
+  );
+
+  const match = output.match(/Created \w+ #(\d+):/);
+  if (match) {
+    testContext.lastCreatedStableBugId = parseInt(match[1]);  // For hierarchical scenarios
+  }
+});
+
+Given('I create a chore {string} without mode and parent epic', function(title) {
+  const output = execSync(
+    `node ${path.join(__dirname, '../../jettypod.js')} work create chore "${title}" "" --parent=${testContext.epicId}`,
+    { cwd: testDir, encoding: 'utf-8' }
+  );
+
+  const match = output.match(/Created \w+ #(\d+):/);
+  if (match) {
+    testContext.lastChoreId = parseInt(match[1]);
+  }
+});
+
+Given('I create a chore {string} without mode and parent feature', function(title) {
+  const output = execSync(
+    `node ${path.join(__dirname, '../../jettypod.js')} work create chore "${title}" "" --parent=${testContext.lastFeatureId}`,
+    { cwd: testDir, encoding: 'utf-8' }
+  );
+
+  const match = output.match(/Created \w+ #(\d+):/);
+  if (match) {
+    testContext.lastChoreId = parseInt(match[1]);
+  }
+});
+
+Then('I see the feature with mode {string}', function(mode) {
+  assert(testContext.lastOutput.includes('Speed Feature'));
+  assert(testContext.lastOutput.includes(`[${mode}]`));
+});
+
+Then('I see the bug with mode {string}', function(mode) {
+  assert(testContext.lastOutput.includes('Stable Bug'));
+  assert(testContext.lastOutput.includes(`[${mode}]`));
+});
+
+Then('I see the chore with mode {string}', function(mode) {
+  assert(testContext.lastOutput.includes('Production Chore'));
+  assert(testContext.lastOutput.includes(`[${mode}]`));
+});
+
+Then('I see the epic without mode indicator', function() {
+  assert(testContext.lastOutput.includes('Test Epic'));
+  // Epic should NOT have a mode indicator
+  const epicLine = testContext.lastOutput.split('\n').find(line => line.includes('Test Epic'));
+  assert(!epicLine.match(/\[(speed|discovery|stable|production)\]/), 'Epic should not have a mode indicator');
+});
+
+Then('I see the chore without mode indicator', function() {
+  assert(testContext.lastOutput.includes('Test Chore'));
+  // Chore should NOT have a mode indicator
+  const choreLine = testContext.lastOutput.split('\n').find(line => line.includes('Test Chore'));
+  assert(!choreLine.match(/\[(speed|discovery|stable|production)\]/), 'Chore should not have a mode indicator');
+});
+
+Then('I see the bug without mode indicator', function() {
+  assert(testContext.lastOutput.includes('Test Bug'));
+  // Bug should NOT have a mode indicator
+  const bugLine = testContext.lastOutput.split('\n').find(line => line.includes('Test Bug'));
+  assert(!bugLine.match(/\[(speed|discovery|stable|production)\]/), 'Bug should not have a mode indicator');
+});
+
+Then('both work items are created successfully', function() {
+  assert(testContext.createdItemIds);
+  assert(testContext.createdItemIds.length >= 2);
+});
+
+Then('they have different modes', function() {
+  const db = getTestDb();
+  const placeholders = testContext.createdItemIds.map(() => '?').join(',');
+  return new Promise((resolve, reject) => {
+    db.all(`SELECT mode FROM work_items WHERE id IN (${placeholders})`, ...testContext.createdItemIds, (err, rows) => {
+      if (err) {
+        return reject(err);
+      }
+      assert.strictEqual(rows.length, 2);
+      assert.notStrictEqual(rows[0].mode, rows[1].mode);
+      resolve();
+    });
+  });
+});
+
+// Steps for work-start-mode.feature
+Given('CLAUDE.md exists', function() {
+  const claudePath = path.join(testDir, 'CLAUDE.md');
+  const content = `<claude_context project="test">
+<current_work>
+Working on: [#1] Test Item (feature)
+Mode: speed
+Status: in_progress
+</current_work>
+<mode>speed</mode>
+</claude_context>`;
+  fs.writeFileSync(claudePath, content);
+});
+
+Given('the feature status is {string}', function(status) {
+  const db = getTestDb();
+  return new Promise((resolve, reject) => {
+    db.run('UPDATE work_items SET status = ? WHERE id = ?', [status, testContext.lastCreatedId], (err) => {
+      // Removed db.close() - let Node.js handle cleanup
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+});
+
+Given('CLAUDE.md has mode {string}', function(mode) {
+  const claudePath = path.join(testDir, 'CLAUDE.md');
+  const content = `<claude_context project="test">
+<current_work>
+Working on: [#1] Test Item (feature)
+Mode: ${mode}
+Status: in_progress
+</current_work>
+<mode>${mode}</mode>
+</claude_context>`;
+  fs.writeFileSync(claudePath, content);
+});
+
+When('I start work on the feature', async function() {
+  const { startWork } = require('../../features/work-commands');
+  // Capture console.log output
+  const originalLog = console.log;
+  let capturedOutput = '';
+  console.log = (...args) => {
+    capturedOutput += args.join(' ') + '\n';
+    originalLog(...args);
+  };
+  testContext.result = await startWork(testContext.lastFeatureId);
+  console.log = originalLog;
+  testContext.output = capturedOutput;
+});
+
+When('I start work on the bug', async function() {
+  const { startWork } = require('../../features/work-commands');
+  // Capture console.log output
+  const originalLog = console.log;
+  let capturedOutput = '';
+  console.log = (...args) => {
+    capturedOutput += args.join(' ') + '\n';
+    originalLog(...args);
+  };
+  testContext.result = await startWork(testContext.lastBugId);
+  console.log = originalLog;
+  testContext.output = capturedOutput;
+});
+
+When('I start work on the chore', async function() {
+  const { startWork } = require('../../features/work-commands');
+  testContext.result = await startWork(testContext.lastChoreId);
+});
+
+When('I start work on the epic', async function() {
+  const { startWork } = require('../../features/work-commands');
+  testContext.result = await startWork(testContext.lastCreatedId);
+});
+
+When('I start work on the speed feature', async function() {
+  const { startWork } = require('../../features/work-commands');
+  testContext.result = await startWork(testContext.lastCreatedSpeedFeatureId);
+});
+
+When('I start work on the stable bug', async function() {
+  const { startWork } = require('../../features/work-commands');
+  testContext.result = await startWork(testContext.lastCreatedStableBugId);
+});
+
+When('I start work on the stable feature', async function() {
+  const { startWork } = require('../../features/work-commands');
+  // Find the stable feature ID from the last created items
+  const { getDb } = require('../../lib/database');
+  const db = getDb();
+  return new Promise((resolve) => {
+    db.get('SELECT id FROM work_items WHERE title = ? AND mode = ?', ['Stable Feature', 'stable'], (err, row) => {
+      if (row) {
+        startWork(row.id).then(() => resolve());
+      } else {
+        resolve();
+      }
+    });
+  });
+});
+
+When('I stop work', async function() {
+  const { stopWork } = require('../../features/work-commands');
+  await stopWork();
+});
+
+Then('CLAUDE.md mode is set to {string}', function(expectedMode) {
+  // Now reads from session file instead of CLAUDE.md
+  const sessionPath = path.join(process.cwd(), '.claude', 'session.md');
+  if (!fs.existsSync(sessionPath)) {
+    assert.fail('Session file should exist at .claude/session.md');
+  }
+  const content = fs.readFileSync(sessionPath, 'utf-8');
+  const modeMatch = content.match(/^Mode: (.+)$/m);
+  assert(modeMatch, 'Session file should have a Mode line');
+  assert.strictEqual(modeMatch[1], expectedMode);
+});
+
+Then('CLAUDE.md has no mode line', function() {
+  // For epics, no session file should be created
+  const sessionPath = path.join(process.cwd(), '.claude', 'session.md');
+  assert(!fs.existsSync(sessionPath), 'Session file should not exist for epics (no mode)');
+});
+
+Then('the current work section exists', function() {
+  // Check that current work is set in database (works for all items including epics)
+  const { getCurrentWork } = require('../../lib/current-work');
+  const currentWork = getCurrentWork();
+  assert(currentWork, 'Current work should be set in database');
+});
+
+Then('the work item still has mode {string}', function(expectedMode) {
+  const db = getTestDb();
+  return new Promise((resolve, reject) => {
+    db.get('SELECT mode FROM work_items WHERE id = ?', [testContext.lastCreatedId], (err, row) => {
+      // Removed db.close() - let Node.js handle cleanup
+      if (err) {
+        reject(err);
+      } else {
+        assert.strictEqual(row.mode, expectedMode);
+        resolve();
+      }
+    });
+  });
+});
+
+// Steps for work-set-mode.feature
+When('I set mode for current item to {string}', async function(mode) {
+  try {
+    // Get current work item ID from database
+    const { getCurrentWork } = require('../../lib/current-work');
+    const currentWork = await getCurrentWork();
+    if (!currentWork) {
+      testContext.error = 'No current work item';
+      return;
+    }
+    execSync(
+      `node ${path.join(__dirname, '../../jettypod.js')} work set-mode ${currentWork.id} ${mode}`,
+      { cwd: testDir, encoding: 'utf-8', stdio: 'pipe' }
+    );
+    testContext.error = null;
+  } catch (err) {
+    testContext.error = err.message || err;
+  }
+});
+
+When('I set mode for item {string} to {string}', function(title, mode) {
+  const db = getTestDb();
+  return new Promise((resolve) => {
+    db.get('SELECT id FROM work_items WHERE title = ?', [title], (err, row) => {
+      // Removed db.close() - let Node.js handle cleanup
+      if (err || !row) {
+        testContext.error = 'Work item not found';
+        resolve();
+        return;
+      }
+      try {
+        execSync(
+          `node ${path.join(__dirname, '../../jettypod.js')} work set-mode ${row.id} ${mode}`,
+          { cwd: testDir, encoding: 'utf-8', stdio: 'pipe' }
+        );
+        testContext.error = null;
+      } catch (err) {
+        testContext.error = err.message || err;
+      }
+      resolve();
+    });
+  });
+});
+
+When('I set mode for the epic to {string}', function(mode) {
+  try {
+    execSync(
+      `node ${path.join(__dirname, '../../jettypod.js')} work set-mode ${testContext.epicId} ${mode}`,
+      { cwd: testDir, encoding: 'utf-8', stdio: 'pipe' }
+    );
+    testContext.error = null;
+  } catch (err) {
+    testContext.error = err.message || err;
+  }
+});
+
+When('I try to set mode to {string}', function(mode) {
+  try {
+    // Get work item ID from testContext (set by create/start commands)
+    const workItemId = testContext.createdItemId || testContext.workItemId || testContext.firstWorkItemId;
+
+    if (!workItemId) {
+      throw new Error('No work item ID found in test context');
+    }
+
+    try {
+      testExecSync(
+        `node ${path.join(__dirname, '../../jettypod.js')} work set-mode ${workItemId} ${mode}`,
+        { cwd: testDir, encoding: 'utf-8', stdio: 'pipe' }
+      );
+      testContext.error = null;
+    } catch (cmdErr) {
+      // Check if error is due to invalid mode
+      const errOutput = cmdErr.stderr || cmdErr.message;
+      if (errOutput.includes('Invalid mode')) {
+        testContext.error = 'Invalid mode';
+      } else {
+        testContext.error = cmdErr.message || cmdErr;
+      }
+    }
+  } catch (err) {
+    testContext.error = err.message || err;
+  }
+});
+
+Then('I get error {string}', function(expectedError) {
+  assert(testContext.error, 'Expected an error but got none');
+  assert(testContext.error.includes(expectedError), `Expected error to include "${expectedError}" but got: ${testContext.error}`);
+});
+
+Then('item {string} has mode {string}', function(title, expectedMode) {
+  const db = getTestDb();
+  return new Promise((resolve) => {
+    db.get('SELECT mode FROM work_items WHERE title = ?', [title], (err, row) => {
+      // Removed db.close() - let Node.js handle cleanup
+      assert.strictEqual(row.mode, expectedMode);
+      resolve();
+    });
+  });
+});
+
+Then('the epic has mode {string}', function(expectedMode) {
+  const db = getTestDb();
+  return new Promise((resolve) => {
+    db.get('SELECT mode FROM work_items WHERE id = ?', [testContext.epicId], (err, row) => {
+      // Removed db.close() - let Node.js handle cleanup
+      assert.strictEqual(row.mode, expectedMode);
+      resolve();
+    });
+  });
+});
+
+Then('CLAUDE.md still has no mode line', function() {
+  const claudePath = path.join(testDir, 'CLAUDE.md');
+  const content = fs.readFileSync(claudePath, 'utf-8');
+  const modeMatch = content.match(/^Mode: (.+)$/m);
+  assert(!modeMatch, 'CLAUDE.md should not have a Mode line for epics');
+});
+
+Given('I start work on the feature {string}', async function(title) {
+  const { startWork } = require('../../features/work-commands');
+  const db = getTestDb();
+  return new Promise((resolve) => {
+    db.get('SELECT id FROM work_items WHERE title = ?', [title], async (err, row) => {
+      // Removed db.close() - let Node.js handle cleanup
+      if (err || !row) {
+        throw new Error('Work item not found');
+      }
+      testContext.result = await startWork(row.id);
+      resolve();
+    });
+  });
+});
+
+// Steps for bug-workflow-display.feature
+Then('the output contains {string}', function(text) {
+  assert(testContext.output, 'No output captured');
+  assert(testContext.output.includes(text), `Output does not contain: ${text}\n\nActual output:\n${testContext.output}`);
+});
+
+Then('the output does not contain {string}', function(text) {
+  assert(testContext.output, 'No output captured');
+  assert(!testContext.output.includes(text), `Output should not contain: ${text}\n\nActual output:\n${testContext.output}`);
+});
+
+// Simple bug/feature creation for backward compatibility
+Given('I create a bug {string}', function(title) {
+  try {
+    const output = execSync(
+      `node ${path.join(__dirname, '../../jettypod.js')} work create bug "${title}"`,
+      { cwd: testDir, encoding: 'utf-8' }
+    );
+    testContext.lastOutput = output;
+    testContext.output = output;
+
+    const match = output.match(/Created \w+ #(\d+):/);
+    if (match) {
+      testContext.createdItemId = parseInt(match[1]);
+      testContext.lastBugId = parseInt(match[1]);
+      testContext.lastCreatedId = parseInt(match[1]);
+    }
+  } catch (err) {
+    testContext.error = err.stderr || err.message;
+  }
+});
+
+Given('I create a feature {string}', function(title) {
+  try {
+    const output = execSync(
+      `node ${path.join(__dirname, '../../jettypod.js')} work create feature "${title}"`,
+      { cwd: testDir, encoding: 'utf-8' }
+    );
+    testContext.lastOutput = output;
+    testContext.output = output;
+
+    const match = output.match(/Created \w+ #(\d+):/);
+    if (match) {
+      testContext.createdItemId = parseInt(match[1]);
+      testContext.lastFeatureId = parseInt(match[1]);
+      testContext.lastCreatedId = parseInt(match[1]);
+    }
+  } catch (err) {
+    testContext.error = err.stderr || err.message;
+  }
+});
+
+// Cleanup after all scenarios complete (AfterAll allows async operations)
+AfterAll(async function() {
+  const { closeDb } = require('../../lib/database');
+  await closeDb();
+});