jettypod 4.1.2 → 4.1.4

package/features/step_definitions/production-mode-skill.steps.js

@@ -1,862 +0,0 @@
-const { Given, When, Then } = require('@cucumber/cucumber');
-const fs = require('fs');
-const path = require('path');
-const assert = require('assert');
-
-let testDir;
-let db;
-let featureId;
-let testFeatureFile;
-let productionStandardsFile;
-let skillOutput;
-
-// Given Steps
-
-Given('a feature just completed stable mode within {int} day', async function(days) {
-  // Setup test environment
-  testDir = path.join(__dirname, '../../test-tmp', `production-mode-${Date.now()}`);
-  fs.mkdirSync(testDir, { recursive: true });
-  process.chdir(testDir);
-
-  // Initialize database
-  const { getDb } = require('../../lib/database');
-  db = getDb();
-
-  // Create feature with stable mode completed recently
-  const yesterday = new Date();
-  yesterday.setDate(yesterday.getDate() - 1);
-
-  await new Promise((resolve, reject) => {
-    db.run(
-      `INSERT INTO work_items (type, title, description, status, mode, phase, completed_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`,
-      ['feature', 'Test Feature', 'A test feature', 'done', 'stable', 'implementation', yesterday.toISOString()],
-      function(err) {
-        if (err) reject(err);
-        featureId = this.lastID;
-        resolve();
-      }
-    );
-  });
-});
-
-Given('production scenarios already exist in the feature file', function() {
-  // Create test feature file with production scenarios
-  const featuresDir = path.join(testDir, 'features');
-  fs.mkdirSync(featuresDir, { recursive: true });
-
-  testFeatureFile = path.join(featuresDir, 'test-feature.feature');
-  fs.writeFileSync(testFeatureFile, `Feature: Test Feature
-
-Scenario: Happy path (speed mode)
-  Given initial state
-  When user takes action
-  Then success
-
-Scenario: Error handling (stable mode)
-  Given initial state
-  When invalid action
-  Then appropriate error
-
-# PRODUCTION MODE SCENARIOS
-Scenario: Load testing - handle 1000 concurrent users (production mode)
-  Given system under load
-  When 1000 concurrent requests
-  Then p95 latency < 2s
-
-Scenario: Security - rate limiting enforcement (production mode)
-  Given anonymous user
-  When exceeds 100 req/min
-  Then returns 429 with Retry-After
-`);
-
-  // Update database with scenario file path
-  return new Promise((resolve, reject) => {
-    db.run(
-      `UPDATE work_items SET scenario_file = ? WHERE id = ?`,
-      [testFeatureFile, featureId],
-      (err) => {
-        if (err) reject(err);
-        resolve();
-      }
-    );
-  });
-});
-
-Given('production chores already exist for the feature', async function() {
-  // Create production chores
-  const chores = [
-    'Implement load testing for Test Feature',
-    'Implement rate limiting for Test Feature'
-  ];
-
-  for (const title of chores) {
-    await new Promise((resolve, reject) => {
-      db.run(
-        `INSERT INTO work_items (type, title, parent_id, status, mode)
-         VALUES (?, ?, ?, ?, ?)`,
-        ['chore', title, featureId, 'todo', 'production'],
-        (err) => {
-          if (err) reject(err);
-          resolve();
-        }
-      );
-    });
-  }
-});
-
-Given('production standards file exists', function() {
-  // Create .jettypod directory and standards file
-  const jettypodDir = path.join(testDir, '.jettypod');
-  fs.mkdirSync(jettypodDir, { recursive: true });
-
-  productionStandardsFile = path.join(jettypodDir, 'production-standards.json');
-
-  const standards = {
-    preset: 'production-saas',
-    standards: [
-      {
-        id: 'performance_budgets',
-        domain: 'performance',
-        acceptance: 'p95 < 2s, p50 < 500ms; enforced in CI'
-      },
-      {
-        id: 'waf_rate_limits',
-        domain: 'security',
-        acceptance: 'Per-IP 100/min, per-token 1000/min; 429s with Retry-After'
-      }
-    ]
-  };
-
-  fs.writeFileSync(productionStandardsFile, JSON.stringify(standards, null, 2));
-});
-
-Given('a feature completed stable mode over {int} days ago', async function(days) {
-  // Setup test environment
-  testDir = path.join(__dirname, '../../test-tmp', `production-mode-${Date.now()}`);
-  fs.mkdirSync(testDir, { recursive: true });
-  process.chdir(testDir);
-
-  // Initialize database
-  const { getDb } = require('../../lib/database');
-  db = getDb();
-
-  // Create feature with stable mode completed 7+ days ago
-  const oldDate = new Date();
-  oldDate.setDate(oldDate.getDate() - days);
-
-  await new Promise((resolve, reject) => {
-    db.run(
-      `INSERT INTO work_items (type, title, description, status, mode, phase, completed_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`,
-      ['feature', 'Test Feature', 'A test feature', 'done', 'stable', 'implementation', oldDate.toISOString()],
-      function(err) {
-        if (err) reject(err);
-        featureId = this.lastID;
-        resolve();
-      }
-    );
-  });
-});
-
-Given('a feature in stable mode with no production scenarios', async function() {
-  // Setup test environment
-  testDir = path.join(__dirname, '../../test-tmp', `production-mode-${Date.now()}`);
-  fs.mkdirSync(testDir, { recursive: true });
-  process.chdir(testDir);
-
-  // Initialize database
-  const { getDb } = require('../../lib/database');
-  db = getDb();
-
-  // Create feature without production scenarios
-  await new Promise((resolve, reject) => {
-    db.run(
-      `INSERT INTO work_items (type, title, description, status, mode, phase)
-       VALUES (?, ?, ?, ?, ?, ?)`,
-      ['feature', 'New Feature', 'A feature without production scenarios', 'done', 'stable', 'implementation'],
-      function(err) {
-        if (err) reject(err);
-        featureId = this.lastID;
-        resolve();
-      }
-    );
-  });
-
-  // Create basic feature file without production scenarios
-  const featuresDir = path.join(testDir, 'features');
-  fs.mkdirSync(featuresDir, { recursive: true });
-
-  testFeatureFile = path.join(featuresDir, 'new-feature.feature');
-  fs.writeFileSync(testFeatureFile, `Feature: New Feature
-
-Scenario: Happy path (speed mode)
-  Given initial state
-  When user takes action
-  Then success
-
-Scenario: Error handling (stable mode)
-  Given initial state
-  When invalid action
-  Then appropriate error
-`);
-
-  // Update database with scenario file path
-  return new Promise((resolve, reject) => {
-    db.run(
-      `UPDATE work_items SET scenario_file = ? WHERE id = ?`,
-      [testFeatureFile, featureId],
-      (err) => {
-        if (err) reject(err);
-        resolve();
-      }
-    );
-  });
-});
-
-Given('no production chores exist for the feature', function() {
-  // Verify no production chores exist
-  return new Promise((resolve, reject) => {
-    db.all(
-      `SELECT * FROM work_items WHERE parent_id = ? AND mode = ?`,
-      [featureId, 'production'],
-      (err, rows) => {
-        if (err) reject(err);
-        assert.strictEqual(rows.length, 0, 'No production chores should exist yet');
-        resolve();
-      }
-    );
-  });
-});
-
-Given('production standards file exists from external-transition', function() {
-  // Create .jettypod directory and standards file with richer content
-  const jettypodDir = path.join(testDir, '.jettypod');
-  fs.mkdirSync(jettypodDir, { recursive: true });
-
-  productionStandardsFile = path.join(jettypodDir, 'production-standards.json');
-
-  const standards = {
-    preset: 'production-saas',
-    refinement: {
-      app_description: 'Project management for software teams',
-      user_count: '100-1k',
-      downtime_impact: 'revenue_loss',
-      compliance: ['GDPR']
-    },
-    standards: [
-      {
-        id: 'performance_budgets',
-        domain: 'performance',
-        acceptance: 'p95 < 2s, p50 < 500ms; enforced in CI',
-        reasoning: '500 users expect responsive UI'
-      },
-      {
-        id: 'waf_rate_limits',
-        domain: 'security',
-        acceptance: 'Per-IP 100/min, per-token 1000/min; 429s with Retry-After',
-        reasoning: 'Public internet exposure'
-      },
-      {
-        id: 'gdpr_export',
-        domain: 'compliance',
-        acceptance: 'Self-serve export API (JSON/CSV); ≤ 30d SLA',
-        reasoning: 'GDPR compliance for EU users'
-      }
-    ]
-  };
-
-  fs.writeFileSync(productionStandardsFile, JSON.stringify(standards, null, 2));
-});
-
-// When Steps
-
-When('I start the production-mode skill for this feature', function() {
-  // Simulate starting the production-mode skill
-  // The skill would detect context and act accordingly
-  skillOutput = {
-    featureId: featureId,
-    scenarioFile: testFeatureFile,
-    standardsFile: productionStandardsFile
-  };
-});
-
-// Then Steps
-
-Then('it detects Scenario A \\(hot context)', function() {
-  // Verify detection logic would identify Scenario A
-  // Check: scenarios exist, chores exist, recent stable completion
-  return new Promise((resolve, reject) => {
-    db.get(
-      `SELECT * FROM work_items WHERE id = ?`,
-      [featureId],
-      (err, feature) => {
-        if (err) reject(err);
-
-        const completedDate = new Date(feature.completed_at);
-        const daysSince = Math.floor((Date.now() - completedDate.getTime()) / (1000 * 60 * 60 * 24));
-
-        assert.ok(daysSince <= 1, 'Feature should be recently completed');
-        assert.ok(fs.existsSync(testFeatureFile), 'Scenario file should exist');
-        assert.ok(testFeatureFile.includes('PRODUCTION MODE'), 'Should have production scenarios');
-
-        resolve();
-      }
-    );
-  });
-});
-
-Then('it validates existing scenarios against current standards', function() {
-  // Verify validation would occur
-  const scenarioContent = fs.readFileSync(testFeatureFile, 'utf-8');
-  const standards = JSON.parse(fs.readFileSync(productionStandardsFile, 'utf-8'));
-
-  assert.ok(scenarioContent.includes('production mode'), 'Should have production scenarios');
-  assert.ok(standards.standards.length > 0, 'Should have standards to validate against');
-});
-
-Then('it identifies no gaps', function() {
-  // Check that existing scenarios cover required standards
-  const scenarioContent = fs.readFileSync(testFeatureFile, 'utf-8');
-  const standards = JSON.parse(fs.readFileSync(productionStandardsFile, 'utf-8'));
-
-  // Verify key standards are covered
-  assert.ok(scenarioContent.includes('Load testing'), 'Should have performance scenario');
-  assert.ok(scenarioContent.includes('rate limiting'), 'Should have security scenario');
-});
-
-Then('it proceeds to implement existing production chores', function() {
-  // Verify production chores exist and are ready to implement
-  return new Promise((resolve, reject) => {
-    db.all(
-      `SELECT * FROM work_items WHERE parent_id = ? AND mode = ?`,
-      [featureId, 'production'],
-      (err, rows) => {
-        if (err) reject(err);
-        assert.ok(rows.length > 0, 'Production chores should exist');
-        assert.strictEqual(rows[0].status, 'todo', 'Chores should be ready to implement');
-        resolve();
-      }
-    );
-  });
-});
-
-Then('it detects Scenario B \\(cold context)', function() {
-  // Verify detection logic would identify Scenario B
-  return new Promise((resolve, reject) => {
-    db.get(
-      `SELECT * FROM work_items WHERE id = ?`,
-      [featureId],
-      (err, feature) => {
-        if (err) reject(err);
-
-        const completedDate = new Date(feature.completed_at);
-        const daysSince = Math.floor((Date.now() - completedDate.getTime()) / (1000 * 60 * 60 * 24));
-
-        assert.ok(daysSince > 1, 'Feature should be older than 1 day');
-        resolve();
-      }
-    );
-  });
-});
-
-Then('it re-validates existing scenarios against current standards', function() {
-  // Same as validation but emphasizes re-checking
-  const scenarioContent = fs.readFileSync(testFeatureFile, 'utf-8');
-  const standards = JSON.parse(fs.readFileSync(productionStandardsFile, 'utf-8'));
-
-  assert.ok(scenarioContent.includes('production mode'), 'Should have production scenarios');
-  assert.ok(standards.standards.length > 0, 'Should have current standards');
-});
-
-Then('it checks if project state changed since stable mode', function() {
-  // Verify project state check would occur
-  const config = require('../../lib/config');
-  const projectConfig = config.read();
-
-  // Config should be readable (state may be internal or external)
-  assert.ok(projectConfig.hasOwnProperty('project_state'), 'Should check project state');
-});
-
-Then('it identifies any gaps in standards coverage', function() {
-  // Check for gaps between scenarios and standards
-  const scenarioContent = fs.readFileSync(testFeatureFile, 'utf-8');
-  const standards = JSON.parse(fs.readFileSync(productionStandardsFile, 'utf-8'));
-
-  // In this test, scenarios should cover standards
-  assert.ok(scenarioContent.length > 0, 'Should have scenarios to check');
-  assert.ok(standards.standards.length > 0, 'Should have standards to check against');
-});
-
-Then('it updates scenarios if needed', function() {
-  // Verify ability to update scenarios (file is writable)
-  assert.ok(fs.existsSync(testFeatureFile), 'Scenario file should exist');
-
-  const stats = fs.statSync(testFeatureFile);
-  assert.ok(stats.isFile(), 'Should be a file that can be updated');
-});
-
-Then('it detects Scenario C \\(post-transition)', function() {
-  // Verify detection logic would identify Scenario C
-  return new Promise((resolve, reject) => {
-    db.all(
-      `SELECT * FROM work_items WHERE parent_id = ? AND mode = ?`,
-      [featureId, 'production'],
-      (err, rows) => {
-        if (err) reject(err);
-
-        const scenarioContent = fs.readFileSync(testFeatureFile, 'utf-8');
-        const hasProductionScenarios = scenarioContent.includes('production mode');
-
-        assert.strictEqual(rows.length, 0, 'No production chores should exist');
-        assert.ok(!hasProductionScenarios, 'No production scenarios should exist');
-
-        resolve();
-      }
-    );
-  });
-});
-
-Then('it reads production standards from file', function() {
-  // Verify standards file can be read
-  assert.ok(fs.existsSync(productionStandardsFile), 'Standards file should exist');
-
-  const standards = JSON.parse(fs.readFileSync(productionStandardsFile, 'utf-8'));
-  assert.ok(standards.standards, 'Should have standards array');
-  assert.ok(standards.standards.length > 0, 'Should have at least one standard');
-});
-
-Then('it generates production scenarios from activated standards', function() {
-  // Verify standards could be converted to scenarios
-  const standards = JSON.parse(fs.readFileSync(productionStandardsFile, 'utf-8'));
-
-  // Each standard should have acceptance criteria that can become scenarios
-  standards.standards.forEach(standard => {
-    assert.ok(standard.acceptance, `Standard ${standard.id} should have acceptance criteria`);
-    assert.ok(standard.domain, `Standard ${standard.id} should have domain`);
-  });
-});
-
-Then('it appends scenarios to the feature file', function() {
-  // Verify scenarios can be appended
-  const originalContent = fs.readFileSync(testFeatureFile, 'utf-8');
-
-  // Simulate appending a scenario
-  const newScenario = '\n# PRODUCTION MODE SCENARIO\nScenario: Test scenario\n  Given test\n  When test\n  Then test\n';
-  fs.appendFileSync(testFeatureFile, newScenario);
-
-  const updatedContent = fs.readFileSync(testFeatureFile, 'utf-8');
-  assert.ok(updatedContent.includes('Test scenario'), 'Scenario should be appended');
-  assert.ok(updatedContent.length > originalContent.length, 'Content should be longer');
-});
-
-Then('it proposes production chores based on standards', function() {
-  // Verify chores could be proposed from standards
-  const standards = JSON.parse(fs.readFileSync(productionStandardsFile, 'utf-8'));
-
-  // Each standard should be convertible to a chore
-  standards.standards.forEach(standard => {
-    assert.ok(standard.id, 'Standard should have ID for chore naming');
-    assert.ok(standard.acceptance, 'Standard should have acceptance for chore description');
-  });
-});
-
-Then('it creates chores after user confirmation', async function() {
-  // Simulate creating chores
-  const standards = JSON.parse(fs.readFileSync(productionStandardsFile, 'utf-8'));
-
-  // Create one chore per standard
-  for (const standard of standards.standards) {
-    await new Promise((resolve, reject) => {
-      db.run(
-        `INSERT INTO work_items (type, title, parent_id, status, mode)
-         VALUES (?, ?, ?, ?, ?)`,
-        ['chore', `Implement ${standard.id}`, featureId, 'todo', 'production'],
-        (err) => {
-          if (err) reject(err);
-          resolve();
-        }
-      );
-    });
-  }
-
-  // Verify chores were created
-  return new Promise((resolve, reject) => {
-    db.all(
-      `SELECT * FROM work_items WHERE parent_id = ? AND mode = ?`,
-      [featureId, 'production'],
-      (err, rows) => {
-        if (err) reject(err);
-        assert.strictEqual(rows.length, standards.standards.length, 'Should create one chore per standard');
-        resolve();
-      }
-    );
-  });
-});
-
-// STABLE MODE - Error Handling Steps
-
-Given('a feature in stable mode', async function() {
-  testDir = path.join(__dirname, '../../test-tmp', `production-mode-${Date.now()}`);
-  fs.mkdirSync(testDir, { recursive: true });
-  process.chdir(testDir);
-
-  const { getDb } = require('../../lib/database');
-  db = getDb();
-
-  await new Promise((resolve, reject) => {
-    db.run(
-      `INSERT INTO work_items (type, title, description, status, mode, phase)
-       VALUES (?, ?, ?, ?, ?, ?)`,
-      ['feature', 'Test Feature', 'A test feature', 'done', 'stable', 'implementation'],
-      function(err) {
-        if (err) reject(err);
-        featureId = this.lastID;
-        resolve();
-      }
-    );
-  });
-
-  // Create basic feature file
-  const featuresDir = path.join(testDir, 'features');
-  fs.mkdirSync(featuresDir, { recursive: true });
-  testFeatureFile = path.join(featuresDir, 'test-feature.feature');
-  fs.writeFileSync(testFeatureFile, 'Feature: Test Feature\n\nScenario: Happy path\n  Given test\n');
-
-  await new Promise((resolve, reject) => {
-    db.run(
-      `UPDATE work_items SET scenario_file = ? WHERE id = ?`,
-      [testFeatureFile, featureId],
-      (err) => {
-        if (err) reject(err);
-        resolve();
-      }
-    );
-  });
-});
-
-Given('the production standards file does not exist at .jettypod\\/production-standards.json', function() {
-  const jettypodDir = path.join(testDir, '.jettypod');
-  if (fs.existsSync(jettypodDir)) {
-    const standardsFile = path.join(jettypodDir, 'production-standards.json');
-    if (fs.existsSync(standardsFile)) {
-      fs.unlinkSync(standardsFile);
-    }
-  }
-});
-
-Given('the production standards file exists but contains malformed JSON', function() {
-  const jettypodDir = path.join(testDir, '.jettypod');
-  fs.mkdirSync(jettypodDir, { recursive: true });
-
-  productionStandardsFile = path.join(jettypodDir, 'production-standards.json');
-  fs.writeFileSync(productionStandardsFile, '{ "broken": json }');
-});
-
-Given('the production standards file exists with valid JSON', function() {
-  const jettypodDir = path.join(testDir, '.jettypod');
-  fs.mkdirSync(jettypodDir, { recursive: true });
-
-  productionStandardsFile = path.join(jettypodDir, 'production-standards.json');
-  fs.writeFileSync(productionStandardsFile, JSON.stringify({ valid: 'json' }, null, 2));
-});
-
-Given('the standards array is missing required fields', function() {
-  const malformedStandards = {
-    preset: 'production-saas',
-    standards: [
-      {
-        id: 'test_standard'
-        // Missing domain, acceptance
-      }
-    ]
-  };
-  fs.writeFileSync(productionStandardsFile, JSON.stringify(malformedStandards, null, 2));
-});
-
-Given('the feature has no scenario_file set in database', async function() {
-  return new Promise((resolve, reject) => {
-    db.run(
-      `UPDATE work_items SET scenario_file = NULL WHERE id = ?`,
-      [featureId],
-      (err) => {
-        if (err) reject(err);
-        resolve();
-      }
-    );
-  });
-});
-
-Given('the feature has scenario_file set in database', async function() {
-  testFeatureFile = path.join(testDir, 'features', 'nonexistent.feature');
-  return new Promise((resolve, reject) => {
-    db.run(
-      `UPDATE work_items SET scenario_file = ? WHERE id = ?`,
-      [testFeatureFile, featureId],
-      (err) => {
-        if (err) reject(err);
-        resolve();
-      }
-    );
-  });
-});
-
-Given('the file does not exist at that path', function() {
-  if (fs.existsSync(testFeatureFile)) {
-    fs.unlinkSync(testFeatureFile);
-  }
-});
-
-Given('an invalid feature ID', function() {
-  featureId = 999999;
-});
-
-Given('a feature marked as done in stable mode', async function() {
-  testDir = path.join(__dirname, '../../test-tmp', `production-mode-${Date.now()}`);
-  fs.mkdirSync(testDir, { recursive: true });
-  process.chdir(testDir);
-
-  const { getDb } = require('../../lib/database');
-  db = getDb();
-
-  await new Promise((resolve, reject) => {
-    db.run(
-      `INSERT INTO work_items (type, title, description, status, mode, phase)
-       VALUES (?, ?, ?, ?, ?, ?)`,
-      ['feature', 'Test Feature', 'A test feature', 'done', 'stable', 'implementation'],
-      function(err) {
-        if (err) reject(err);
-        featureId = this.lastID;
-        resolve();
-      }
-    );
-  });
-});
-
-Given('the completed_at field is null', async function() {
-  return new Promise((resolve, reject) => {
-    db.run(
-      `UPDATE work_items SET completed_at = NULL WHERE id = ?`,
-      [featureId],
-      (err) => {
-        if (err) reject(err);
-        resolve();
-      }
-    );
-  });
-});
-
-Given('the file is not readable due to permissions', function() {
-  if (process.platform !== 'win32') {
-    fs.chmodSync(productionStandardsFile, 0o000);
-  } else {
-    this.skip();
-  }
-});
-
-Given('a feature in Scenario C \\(generating scenarios)', async function() {
-  await this.runStep('Given a feature in stable mode with no production scenarios');
-  await this.runStep('Given no production chores exist for the feature');
-  await this.runStep('Given production standards file exists from external-transition');
-});
-
-Given('production standards are loaded successfully', function() {
-  assert.ok(fs.existsSync(productionStandardsFile), 'Standards file should exist');
-  const standards = JSON.parse(fs.readFileSync(productionStandardsFile, 'utf-8'));
-  assert.ok(standards.standards.length > 0, 'Standards should be loaded');
-});
-
-Given('the scenario file is not writable due to permissions', function() {
-  if (process.platform !== 'win32') {
-    fs.chmodSync(testFeatureFile, 0o444);
-  } else {
-    this.skip();
-  }
-});
-
-Given('the production standards file exists with empty standards array', function() {
-  const jettypodDir = path.join(testDir, '.jettypod');
-  fs.mkdirSync(jettypodDir, { recursive: true });
-
-  productionStandardsFile = path.join(jettypodDir, 'production-standards.json');
-  fs.writeFileSync(productionStandardsFile, JSON.stringify({ preset: 'test', standards: [] }, null, 2));
-});
-
-Given('the database file is locked or corrupted', function() {
-  if (db) {
-    db.close();
-  }
-  const dbPath = path.join(testDir, '.jettypod', 'work.db');
-  if (fs.existsSync(dbPath)) {
-    fs.writeFileSync(dbPath, 'CORRUPTED DATA');
-  }
-});
-
-Given('production scenarios exist in the feature file', function() {
-  const content = fs.readFileSync(testFeatureFile, 'utf-8');
-  if (!content.includes('# PRODUCTION MODE')) {
-    fs.appendFileSync(testFeatureFile, '\n# PRODUCTION MODE SCENARIOS\n\nScenario: Test production scenario\n  Given production\n');
-  }
-});
-
-Given('production chores exist for the feature', async function() {
-  await new Promise((resolve, reject) => {
-    db.run(
-      `INSERT INTO work_items (type, title, parent_id, status, mode)
-       VALUES (?, ?, ?, ?, ?)`,
-      ['chore', 'Test production chore', featureId, 'todo', 'production'],
-      (err) => {
-        if (err) reject(err);
-        resolve();
-      }
-    );
-  });
-});
-
-When('I start the production-mode skill with that feature ID', function() {
-  skillOutput = { featureId };
-});
-
-When('the context detector checks time since stable completion', function() {
-  // This is implicitly tested by the detection logic
-  skillOutput = { checkingCompletedAt: true };
-});
-
-When('attempting to append scenarios to the file', function() {
-  try {
-    fs.appendFileSync(testFeatureFile, '\nNew scenario');
-    skillOutput = { error: null };
-  } catch (err) {
-    skillOutput = { error: err };
-  }
-});
-
-Then('it fails with error {string}', function(errorMessage) {
-  const { detectContext } = require('../../lib/production-context-detector');
-  const { readStandards } = require('../../lib/production-standards-reader');
-
-  if (errorMessage.includes('Production standards file not found')) {
-    return readStandards().catch(err => {
-      assert.ok(err.message.includes('not found'), 'Should error about missing file');
-    });
-  } else if (errorMessage.includes('Failed to parse')) {
-    return readStandards().catch(err => {
-      assert.ok(err.message.includes('parse') || err.message.includes('JSON'), 'Should error about parsing');
-    });
-  } else if (errorMessage.includes('Invalid standards format')) {
-    return readStandards().catch(err => {
-      assert.ok(err.message.includes('Invalid') || err.message.includes('format'), 'Should error about format');
-    });
-  } else if (errorMessage.includes('Feature has no scenario file')) {
-    return detectContext(featureId).catch(err => {
-      assert.ok(err.message.includes('scenario'), 'Should error about scenario file');
-    });
-  } else if (errorMessage.includes('Scenario file not found')) {
-    const { appendScenarios } = require('../../lib/production-scenario-appender');
-    return appendScenarios(testFeatureFile, []).catch(err => {
-      assert.ok(err.message.includes('not found'), 'Should error about file not found');
-    });
-  } else if (errorMessage.includes('Feature not found')) {
-    return detectContext(featureId).catch(err => {
-      assert.ok(err.message.includes('not found'), 'Should error about feature not found');
-    });
-  }
-});
-
-Then('it suggests running external-transition first', function() {
-  // Error message should suggest external-transition
-  return require('../../lib/production-standards-reader').readStandards().catch(err => {
-    assert.ok(err.message.includes('external-transition'), 'Should mention external-transition');
-  });
-});
-
-Then('it shows the JSON parsing error details', function() {
-  return require('../../lib/production-standards-reader').readStandards().catch(err => {
-    assert.ok(err.message.length > 0, 'Should have error details');
-  });
-});
-
-Then('it specifies which required fields are missing', function() {
-  return require('../../lib/production-standards-reader').readStandards().catch(err => {
-    assert.ok(err.message.includes('domain') || err.message.includes('acceptance'), 'Should specify missing fields');
-  });
-});
-
-Then('it suggests the feature may not be properly initialized', function() {
-  return require('../../lib/production-context-detector').detectContext(featureId).catch(err => {
-    assert.ok(err.message.length > 0, 'Should have helpful error message');
-  });
-});
-
-Then('it shows the expected file path', function() {
-  const { appendScenarios } = require('../../lib/production-scenario-appender');
-  return appendScenarios(testFeatureFile, []).catch(err => {
-    assert.ok(err.message.includes(testFeatureFile) || err.message.includes('Scenario file'), 'Should show path');
-  });
-});
-
-Then('it treats this as Scenario C \\(no production content yet)', async function() {
-  const { detectContext } = require('../../lib/production-context-detector');
-  const scenario = await detectContext(featureId);
-  assert.strictEqual(scenario, 'SCENARIO_C', 'Should detect Scenario C when completed_at is null');
-});
-
-Then('it fails with error indicating permission denied', function() {
-  if (process.platform === 'win32') {
-    this.skip();
-  }
-  return require('../../lib/production-standards-reader').readStandards().catch(err => {
-    assert.ok(err.message.includes('EACCES') || err.message.includes('permission'), 'Should indicate permission error');
-  });
-});
-
-Then('it shows the file path with permission issues', function() {
-  if (process.platform === 'win32') {
-    this.skip();
-  }
-  return require('../../lib/production-standards-reader').readStandards().catch(err => {
-    assert.ok(err.message.length > 0, 'Should show path or error details');
-  });
-});
-
-Then('it fails with error indicating write permission denied', function() {
-  if (process.platform === 'win32') {
-    this.skip();
-  }
-  assert.ok(skillOutput.error, 'Should have error');
-  assert.ok(skillOutput.error.message.includes('EACCES') || skillOutput.error.code === 'EACCES', 'Should be permission error');
-});
-
-Then('it completes successfully', function() {
-  const standards = JSON.parse(fs.readFileSync(productionStandardsFile, 'utf-8'));
-  assert.strictEqual(standards.standards.length, 0, 'Should handle empty standards');
-});
-
-Then('reports {int} standards to implement', function(count) {
-  const standards = JSON.parse(fs.readFileSync(productionStandardsFile, 'utf-8'));
-  assert.strictEqual(standards.standards.length, count, `Should report ${count} standards`);
-});
-
-Then('it fails with database error', function() {
-  const { getDb } = require('../../lib/database');
-  try {
-    const brokenDb = getDb();
-    brokenDb.get('SELECT * FROM work_items', (err) => {
-      assert.ok(err, 'Should have database error');
-    });
-  } catch (err) {
-    assert.ok(err, 'Should throw or callback with error');
-  }
-});
-
-Then('it suggests checking database integrity', function() {
-  // The error handling should suggest checking the database
-  assert.ok(true, 'Error message should suggest integrity check');
-});
-
-// Cleanup
-process.on('exit', () => {
-  if (testDir && fs.existsSync(testDir)) {
-    fs.rmSync(testDir, { recursive: true, force: true });
-  }
-});