edsger 0.50.0 → 0.52.0

package/dist/commands/workflow/{feature-coordinator.js → issue-coordinator.js}

@@ -1,26 +1,26 @@
 /**
- * Feature Coordinator - High-level workflow orchestration
+ * Issue Coordinator - High-level workflow orchestration
  *
  * Responsibilities:
- * - Fetch feature configuration from API
+ * - Fetch issue configuration from API
  * - Execute phases based on workflow field (pending phases in order)
- * - Coordinate feature-level workflow initialization
+ * - Coordinate issue-level workflow initialization
  * - Handle phase execution results and stop on failure/blocked
  *
- * This is the entry point for feature workflow execution
+ * This is the entry point for issue workflow execution
  */
-import { getFeature } from '../../api/features/get-feature.js';
-import { markWorkflowPhaseCompleted } from '../../api/features/update-feature.js';
+import { getIssue } from '../../api/issues/get-issue.js';
+import { markWorkflowPhaseCompleted } from '../../api/issues/update-issue.js';
 import { cacheBindings, clearBindingsCache, fetchHookBindings, } from '../../services/phase-hooks/index.js';
 import { logError, logInfo, logWarning } from '../../utils/logger.js';
 import { logPhaseResult } from '../../utils/pipeline-logger.js';
-import { runAutonomousPhase, runBranchPlanningPhase, runCodeImplementationPhase, runCodeRefinePhase, runCodeReviewPhase, runFeatureAnalysisPhase, runFunctionalTestingPhase, runPRExecutionPhase, runPRSplittingPhase, runTechnicalDesignPhase, runTestCasesAnalysisPhase, runUserStoriesAnalysisPhase, } from './executors/phase-executor.js';
+import { runAutonomousPhase, runBranchPlanningPhase, runCodeImplementationPhase, runCodeRefinePhase, runCodeReviewPhase, runFunctionalTestingPhase, runIssueAnalysisPhase, runPRExecutionPhase, runPRSplittingPhase, runTechnicalDesignPhase, runTestCasesAnalysisPhase, runUserStoriesAnalysisPhase, } from './executors/phase-executor.js';
 /**
  * Map workflow phase names (underscore format) to phase runner functions
  * Note: code_refine includes built-in verification loop (similar to technical_design)
  */
 const PHASE_RUNNERS = {
-    feature_analysis: runFeatureAnalysisPhase,
+    issue_analysis: runIssueAnalysisPhase,
     user_stories_analysis: runUserStoriesAnalysisPhase,
     test_cases_analysis: runTestCasesAnalysisPhase,
     technical_design: runTechnicalDesignPhase,
@@ -47,14 +47,14 @@ function getPendingPhases(workflow) {
  * Returns the result and marks workflow phase as completed if successful
  */
 async function executePhase(phaseName, options, config) {
-    const { featureId, verbose } = options;
+    const { issueId, verbose } = options;
     // Normalize phase name: kebab-case → snake_case (e.g., code-implementation → code_implementation)
     const normalizedName = phaseName.replace(/-/g, '_');
     const phaseRunner = PHASE_RUNNERS[normalizedName];
     if (!phaseRunner) {
         logWarning(`Unknown workflow phase: ${phaseName}, skipping`);
         return {
-            featureId,
+            issueId,
             phase: phaseName,
             status: 'error',
             message: `Unknown workflow phase: ${phaseName}`,
@@ -69,28 +69,28 @@ async function executePhase(phaseName, options, config) {
     logPhaseResult(result, verbose);
     // Mark workflow phase as completed if successful
     if (result.status === 'success') {
-        await markWorkflowPhaseCompleted(featureId, normalizedName, verbose);
+        await markWorkflowPhaseCompleted(issueId, normalizedName, verbose);
     }
     return result;
 }
 /**
- * Run workflow for a feature based on its workflow field
+ * Run workflow for an issue based on its workflow field
  * Executes all pending phases in order, stopping on failure or blocked
  */
-export async function runFeatureWorkflow(options, config) {
-    const { featureId, verbose } = options;
+export async function runIssueWorkflow(options, config) {
+    const { issueId, verbose } = options;
     try {
-        // 1. Get feature details to check workflow
+        // 1. Get issue details to check workflow
         if (verbose) {
-            logInfo(`🔍 Fetching feature configuration for: ${featureId}`);
+            logInfo(`🔍 Fetching issue configuration for: ${issueId}`);
         }
-        const feature = await getFeature(featureId, verbose);
-        // Fetch and cache hook bindings for this feature's product
+        const issue = await getIssue(issueId, verbose);
+        // Fetch and cache hook bindings for this issue's product
         try {
-            const bindings = await fetchHookBindings(feature.product_id, verbose);
-            cacheBindings(featureId, feature.product_id, bindings);
+            const bindings = await fetchHookBindings(issue.product_id, verbose);
+            cacheBindings(issueId, issue.product_id, bindings);
             if (verbose && bindings.length > 0) {
-                logInfo(`🪝 Loaded ${bindings.length} phase hook binding(s) for product ${feature.product_id}`);
+                logInfo(`🪝 Loaded ${bindings.length} phase hook binding(s) for product ${issue.product_id}`);
             }
         }
         catch (hookError) {
@@ -99,18 +99,18 @@ export async function runFeatureWorkflow(options, config) {
         }
         // Debug log workflow data
         if (verbose) {
-            logInfo(`🔍 Feature data from API:`);
-            logInfo(`  - workflow: ${JSON.stringify(feature.workflow, null, 2)}`);
+            logInfo(`🔍 Issue data from API:`);
+            logInfo(`  - workflow: ${JSON.stringify(issue.workflow, null, 2)}`);
         }
         // 2. Get all pending phases from workflow
-        const pendingPhases = getPendingPhases(feature.workflow);
+        const pendingPhases = getPendingPhases(issue.workflow);
         if (pendingPhases.length === 0) {
             if (verbose) {
                 logInfo('No pending phases in workflow, nothing to execute');
             }
             return [
                 {
-                    featureId,
+                    issueId,
                     phase: 'workflow-initialization',
                     status: 'success',
                     message: 'No pending phases in workflow, nothing to execute',
@@ -137,7 +137,7 @@ export async function runFeatureWorkflow(options, config) {
             // so we no longer need to create it here after code_implementation succeeds.
         }
         // Clean up hook bindings cache
-        clearBindingsCache(featureId);
+        clearBindingsCache(issueId);
         if (verbose) {
             const successCount = results.filter((r) => r.status === 'success').length;
             logInfo(`\n✅ Workflow execution completed: ${successCount}/${results.length} phases succeeded`);
@@ -145,13 +145,13 @@ export async function runFeatureWorkflow(options, config) {
         return results;
     }
     catch (error) {
-        clearBindingsCache(featureId);
+        clearBindingsCache(issueId);
         const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to run feature workflow: ${errorMessage}`);
+        logError(`Failed to run issue workflow: ${errorMessage}`);
         // Return error result
         return [
             {
-                featureId,
+                issueId,
                 phase: 'workflow-initialization',
                 status: 'error',
                 message: `Workflow initialization failed: ${errorMessage}`,

package/dist/commands/workflow/phase-orchestrator.d.ts

@@ -8,7 +8,7 @@
  * - Manage phase result collection and status updates
  *
  * Complete phase flow:
- *   feature-analysis → technical-design → code-implementation →
+ *   issue-analysis → technical-design → code-implementation →
  *   functional-testing → code-review → code-refine → code-refine-verification
  *
  * Uses functional programming principles for composability
@@ -21,6 +21,6 @@ import { type ExecutionMode, type PipelinePhaseOptions, type PipelineResult } fr
  */
 export declare const runPipelineByMode: (options: PipelinePhaseOptions, config: EdsgerConfig, executionMode: ExecutionMode) => Promise<readonly PipelineResult[]>;
 /**
- * Run complete pipeline for a feature using functional composition (legacy)
+ * Run complete pipeline for an issue using functional composition (legacy)
  */
 export declare const runCompletePipeline: (options: PipelinePhaseOptions, config: EdsgerConfig) => () => Promise<readonly PipelineResult[]>;

package/dist/commands/workflow/phase-orchestrator.js

@@ -9,18 +9,18 @@
  * - Manage phase result collection and status updates
  *
  * Complete phase flow:
- *   feature-analysis → technical-design → code-implementation →
+ *   issue-analysis → technical-design → code-implementation →
  *   functional-testing → code-review → code-refine → code-refine-verification
  *
  * Uses functional programming principles for composability
  */
-import { markWorkflowPhaseCompleted, updateFeatureStatusForPhase, } from '../../api/features/index.js';
+import { markWorkflowPhaseCompleted, updateIssueStatusForPhase, } from '../../api/issues/index.js';
 import { handleCodeRefineWithRetry } from '../../phases/code-refine/retry-handler.js';
 import { handleTestFailuresWithRetry } from '../../phases/functional-testing/test-retry-handler.js';
 import { handlePullRequestCreation } from '../../phases/pull-request/handler.js';
 import { logInfo } from '../../utils/logger.js';
 import { logPhaseResult, logPipelineComplete, logPipelineStart, shouldContinuePipeline, } from '../../utils/pipeline-logger.js';
-import { runCodeImplementationPhase, runCodeReviewPhase, runCodeTestingPhase, runFeatureAnalysisPhase, runFunctionalTestingPhase, runPRExecutionPhase, runPRSplittingPhase, runTechnicalDesignPhase, runTestCasesAnalysisPhase, runUserStoriesAnalysisPhase, } from './executors/phase-executor.js';
+import { runCodeImplementationPhase, runCodeReviewPhase, runCodeTestingPhase, runFunctionalTestingPhase, runIssueAnalysisPhase, runPRExecutionPhase, runPRSplittingPhase, runTechnicalDesignPhase, runTestCasesAnalysisPhase, runUserStoriesAnalysisPhase, } from './executors/phase-executor.js';
 /**
  * Helper to log phase result and mark workflow phase as completed if successful
  */
@@ -28,7 +28,7 @@ const logAndMarkPhaseCompleted = async (result, verbose) => {
     const logged = logPhaseResult(result, verbose);
     // Mark workflow phase as completed if phase succeeded
     if (result.status === 'success') {
-        await markWorkflowPhaseCompleted(result.featureId, result.phase, verbose);
+        await markWorkflowPhaseCompleted(result.issueId, result.phase, verbose);
     }
     return logged;
 };
@@ -38,28 +38,28 @@ const logAndMarkPhaseCompleted = async (result, verbose) => {
  */
 // eslint-disable-next-line complexity
 export const runPipelineByMode = async (options, config, executionMode) => {
-    const { featureId, verbose } = options;
+    const { issueId, verbose } = options;
     if (verbose) {
-        logInfo(`🚀 Starting pipeline with mode: ${executionMode} for feature: ${featureId}`);
+        logInfo(`🚀 Starting pipeline with mode: ${executionMode} for issue: ${issueId}`);
         logInfo(`📋 Execution mode details:`);
         logInfo(`  - Mode value: "${executionMode}"`);
         logInfo(`  - Mode type: ${typeof executionMode}`);
-        logInfo(`  - Mode === 'only_feature_analysis': ${executionMode === 'only_feature_analysis'}`);
+        logInfo(`  - Mode === 'only_issue_analysis': ${executionMode === 'only_issue_analysis'}`);
     }
     switch (executionMode) {
         // Complete pipeline
         case 'full_pipeline':
-        case 'from_feature_analysis':
+        case 'from_issue_analysis':
             if (verbose) {
-                logInfo(`  ➡️ Matched: full_pipeline or from_feature_analysis - running complete pipeline`);
+                logInfo(`  ➡️ Matched: full_pipeline or from_issue_analysis - running complete pipeline`);
             }
-            return await runFromFeatureAnalysis(options, config);
-        // Feature Analysis (legacy - generates both user stories and test cases)
-        case 'only_feature_analysis':
+            return await runFromIssueAnalysis(options, config);
+        // Issue Analysis (legacy - generates both user stories and test cases)
+        case 'only_issue_analysis':
             if (verbose) {
-                logInfo(`  ➡️ Matched: only_feature_analysis - running analysis only`);
+                logInfo(`  ➡️ Matched: only_issue_analysis - running analysis only`);
             }
-            return await runOnlyFeatureAnalysis(options, config);
+            return await runOnlyIssueAnalysis(options, config);
         // User Stories Analysis
         case 'only_user_stories_analysis':
             return await runOnlyUserStoriesAnalysis(options, config);
@@ -113,37 +113,37 @@ export const runPipelineByMode = async (options, config, executionMode) => {
     }
 };
 /**
- * Run complete pipeline for a feature using functional composition (legacy)
+ * Run complete pipeline for an issue using functional composition (legacy)
  */
 export const runCompletePipeline = (options, config) => {
     return async () => {
-        return await runFromFeatureAnalysis(options, config);
+        return await runFromIssueAnalysis(options, config);
     };
 };
 // Helper functions for different execution patterns
 /**
- * Finalize pipeline execution by updating feature status to ready_for_review if all phases succeeded
+ * Finalize pipeline execution by updating issue status to ready_for_review if all phases succeeded
  */
 const finalizePipelineExecution = async (options, results, verbose) => {
     // Check if all phases succeeded
     const allSucceeded = results.every((result) => result.status === 'success');
     if (allSucceeded && results.length > 0) {
         // Update status to ready_for_review
-        await updateFeatureStatusForPhase(options.featureId, 'ready-for-review', verbose);
+        await updateIssueStatusForPhase(options.issueId, 'ready-for-review', verbose);
         if (verbose) {
-            logInfo('✅ Pipeline execution completed - feature is ready for review');
+            logInfo('✅ Pipeline execution completed - issue is ready for review');
         }
     }
     return logPipelineComplete(results, verbose);
 };
 /**
- * Run only feature analysis phase
+ * Run only issue analysis phase
  */
-const runOnlyFeatureAnalysis = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+const runOnlyIssueAnalysis = async (options, config) => {
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
-    const analysisResult = await runFeatureAnalysisPhase(options, config);
+    const analysisResult = await runIssueAnalysisPhase(options, config);
     results.push(await logAndMarkPhaseCompleted(analysisResult, verbose));
     return finalizePipelineExecution(options, results, verbose);
 };
@@ -151,8 +151,8 @@ const runOnlyFeatureAnalysis = async (options, config) => {
  * Run only user stories analysis phase
  */
 const runOnlyUserStoriesAnalysis = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
     const analysisResult = await runUserStoriesAnalysisPhase(options, config);
     results.push(await logAndMarkPhaseCompleted(analysisResult, verbose));
@@ -162,8 +162,8 @@ const runOnlyUserStoriesAnalysis = async (options, config) => {
  * Run only test cases analysis phase
  */
 const runOnlyTestCasesAnalysis = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
     const analysisResult = await runTestCasesAnalysisPhase(options, config);
     results.push(await logAndMarkPhaseCompleted(analysisResult, verbose));
@@ -174,8 +174,8 @@ const runOnlyTestCasesAnalysis = async (options, config) => {
  * Flow: user-stories-analysis → test-cases-analysis → technical-design → code-implementation → ...
  */
 const runFromUserStoriesAnalysis = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
     // 1. User Stories Analysis
     const userStoriesResult = await runUserStoriesAnalysisPhase(options, config);
@@ -209,10 +209,10 @@ const runFromUserStoriesAnalysis = async (options, config) => {
         verbose,
     });
     const finalStatus = testingResult.status === 'success' ? 'testing_passed' : 'testing_failed';
-    await updateFeatureStatusForPhase(featureId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
+    await updateIssueStatusForPhase(issueId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
     if (testingResult.status === 'success') {
         const prCreated = await handlePullRequestCreation({
-            featureId,
+            issueId,
             results,
             testingResult,
             verbose,
@@ -231,8 +231,8 @@ const runFromUserStoriesAnalysis = async (options, config) => {
  * Flow: test-cases-analysis → technical-design → code-implementation → ...
  */
 const runFromTestCasesAnalysis = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
     // 1. Test Cases Analysis
     const testCasesResult = await runTestCasesAnalysisPhase(options, config);
@@ -260,10 +260,10 @@ const runFromTestCasesAnalysis = async (options, config) => {
         verbose,
     });
     const finalStatus = testingResult.status === 'success' ? 'testing_passed' : 'testing_failed';
-    await updateFeatureStatusForPhase(featureId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
+    await updateIssueStatusForPhase(issueId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
     if (testingResult.status === 'success') {
         const prCreated = await handlePullRequestCreation({
-            featureId,
+            issueId,
             results,
             testingResult,
             verbose,
@@ -281,8 +281,8 @@ const runFromTestCasesAnalysis = async (options, config) => {
  * Run only technical design phase
  */
 const runOnlyTechnicalDesign = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
     const designResult = await runTechnicalDesignPhase(options, config);
     results.push(await logAndMarkPhaseCompleted(designResult, verbose));
@@ -293,8 +293,8 @@ const runOnlyTechnicalDesign = async (options, config) => {
  * After successful implementation, creates a pull request so the code can be reviewed
  */
 const runOnlyCodeImplementation = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
     const implementationResult = await runCodeImplementationPhase(options, config);
     results.push(await logAndMarkPhaseCompleted(implementationResult, verbose));
@@ -304,14 +304,14 @@ const runOnlyCodeImplementation = async (options, config) => {
             logInfo('\n📝 Creating pull request for implemented code...');
         }
         const prCreated = await handlePullRequestCreation({
-            featureId,
+            issueId,
             results,
             // No testingResult - functional testing was skipped
             verbose,
         });
         // Add PR creation result to results array
         const prResult = {
-            featureId,
+            issueId,
             phase: 'pull-request',
             status: prCreated ? 'success' : 'error',
             message: prCreated
@@ -327,8 +327,8 @@ const runOnlyCodeImplementation = async (options, config) => {
  * Run only PR splitting phase
  */
 const runOnlyPRSplitting = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
     const prSplittingResult = await runPRSplittingPhase(options, config);
     results.push(await logAndMarkPhaseCompleted(prSplittingResult, verbose));
@@ -339,8 +339,8 @@ const runOnlyPRSplitting = async (options, config) => {
  * Flow: pr-splitting → (human review) → pr-execution → testing → ...
  */
 const runFromPRSplitting = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
     // 1. PR Splitting (planning only)
     const prSplittingResult = await runPRSplittingPhase(options, config);
@@ -362,10 +362,10 @@ const runFromPRSplitting = async (options, config) => {
         verbose,
     });
     const finalStatus = testingResult.status === 'success' ? 'testing_passed' : 'testing_failed';
-    await updateFeatureStatusForPhase(featureId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
+    await updateIssueStatusForPhase(issueId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
     if (testingResult.status === 'success') {
         const prCreated = await handlePullRequestCreation({
-            featureId,
+            issueId,
             results,
             testingResult,
             verbose,
@@ -383,8 +383,8 @@ const runFromPRSplitting = async (options, config) => {
  * Run only PR execution phase
  */
 const runOnlyPRExecution = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
     const prExecutionResult = await runPRExecutionPhase(options, config);
     results.push(await logAndMarkPhaseCompleted(prExecutionResult, verbose));
@@ -395,8 +395,8 @@ const runOnlyPRExecution = async (options, config) => {
  * Flow: pr-execution → testing → code-review → code-refine
  */
 const runFromPRExecution = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
     // 1. PR Execution
     const prExecutionResult = await runPRExecutionPhase(options, config);
@@ -412,10 +412,10 @@ const runFromPRExecution = async (options, config) => {
         verbose,
     });
     const finalStatus = testingResult.status === 'success' ? 'testing_passed' : 'testing_failed';
-    await updateFeatureStatusForPhase(featureId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
+    await updateIssueStatusForPhase(issueId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
     if (testingResult.status === 'success') {
         const prCreated = await handlePullRequestCreation({
-            featureId,
+            issueId,
             results,
             testingResult,
             verbose,
@@ -433,22 +433,22 @@ const runFromPRExecution = async (options, config) => {
  * Run only functional testing phase
  */
 const runOnlyFunctionalTesting = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
     const testingResult = await runFunctionalTestingPhase(options, config);
     results.push(await logAndMarkPhaseCompleted(testingResult, verbose));
     return finalizePipelineExecution(options, results, verbose);
 };
 /**
- * Run from feature analysis to end
+ * Run from issue analysis to end
  */
-const runFromFeatureAnalysis = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+const runFromIssueAnalysis = async (options, config) => {
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
-    // 1. Feature Analysis
-    const analysisResult = await runFeatureAnalysisPhase(options, config);
+    // 1. Issue Analysis
+    const analysisResult = await runIssueAnalysisPhase(options, config);
     results.push(await logAndMarkPhaseCompleted(analysisResult, verbose));
     if (!shouldContinuePipeline(results)) {
         return finalizePipelineExecution(options, results, verbose);
@@ -474,11 +474,11 @@ const runFromFeatureAnalysis = async (options, config) => {
     });
     // Update final status based on functional testing result
     const finalStatus = testingResult.status === 'success' ? 'testing_passed' : 'testing_failed';
-    await updateFeatureStatusForPhase(featureId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
+    await updateIssueStatusForPhase(issueId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
     // Create pull request if tests passed
     if (testingResult.status === 'success') {
         const prCreated = await handlePullRequestCreation({
-            featureId,
+            issueId,
             results,
             testingResult,
             verbose,
@@ -497,8 +497,8 @@ const runFromFeatureAnalysis = async (options, config) => {
  * Run from technical design to end
  */
 const runFromTechnicalDesign = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
     // 1. Technical Design
     const designResult = await runTechnicalDesignPhase(options, config);
@@ -521,11 +521,11 @@ const runFromTechnicalDesign = async (options, config) => {
     });
     // Update final status based on functional testing result
     const finalStatus = testingResult.status === 'success' ? 'testing_passed' : 'testing_failed';
-    await updateFeatureStatusForPhase(featureId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
+    await updateIssueStatusForPhase(issueId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
     // Create pull request if tests passed
     if (testingResult.status === 'success') {
         const prCreated = await handlePullRequestCreation({
-            featureId,
+            issueId,
             results,
             testingResult,
             verbose,
@@ -544,8 +544,8 @@ const runFromTechnicalDesign = async (options, config) => {
  * Run from code implementation to end
  */
 const runFromCodeImplementation = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
     // 1. Code Implementation
     const implementationResult = await runCodeImplementationPhase(options, config);
@@ -562,11 +562,11 @@ const runFromCodeImplementation = async (options, config) => {
     });
     // Update final status based on functional testing result
     const finalStatus = testingResult.status === 'success' ? 'testing_passed' : 'testing_failed';
-    await updateFeatureStatusForPhase(featureId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
+    await updateIssueStatusForPhase(issueId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
     // Create pull request if tests passed
     if (testingResult.status === 'success') {
         const prCreated = await handlePullRequestCreation({
-            featureId,
+            issueId,
             results,
             testingResult,
             verbose,
@@ -585,8 +585,8 @@ const runFromCodeImplementation = async (options, config) => {
  * Run from functional testing to end
  */
 const runFromFunctionalTesting = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
     // 1. Functional Testing with retry loop for bug fixes
     const testingResult = await handleTestFailuresWithRetry({
@@ -597,11 +597,11 @@ const runFromFunctionalTesting = async (options, config) => {
     });
     // Update final status based on functional testing result
     const finalStatus = testingResult.status === 'success' ? 'testing_passed' : 'testing_failed';
-    await updateFeatureStatusForPhase(featureId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
+    await updateIssueStatusForPhase(issueId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
     // Create pull request if tests passed
     if (testingResult.status === 'success') {
         const prCreated = await handlePullRequestCreation({
-            featureId,
+            issueId,
             results,
             testingResult,
             verbose,
@@ -621,8 +621,8 @@ const runFromFunctionalTesting = async (options, config) => {
  * Includes automatic retry loop for verification failures
  */
 const runOnlyCodeRefine = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
     // Code Refine with automatic retry for verification failures
     await handleCodeRefineWithRetry({
@@ -637,8 +637,8 @@ const runOnlyCodeRefine = async (options, config) => {
  * Run only code review phase (review PR and create review comments)
  */
 const runOnlyCodeReview = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
     // Code Review - analyze PR and create review comments
     const reviewResult = await runCodeReviewPhase(options, config);
@@ -649,8 +649,8 @@ const runOnlyCodeReview = async (options, config) => {
  * Run from code review to end (code-review → code-refine → code-refine-verification)
  */
 const runFromCodeReview = async (options, config) => {
-    const { featureId, verbose } = options;
-    logPipelineStart(featureId, verbose);
+    const { issueId, verbose } = options;
+    logPipelineStart(issueId, verbose);
     const results = [];
     // 1. Code Review - analyze PR and create review comments
     const reviewResult = await runCodeReviewPhase(options, config);

package/dist/commands/workflow/processor.d.ts

@@ -1,6 +1,6 @@
 /**
- * Main workflow processor for continuous feature development
- * Monitors for ready_for_ai features and processes them through the complete pipeline
+ * Main workflow processor for continuous issue development
+ * Monitors for ready_for_ai issues and processes them through the complete pipeline
  * Uses functional programming principles
  */
 import { type EdsgerConfig } from '../../types/index.js';
@@ -20,7 +20,7 @@ export declare class WorkflowProcessor {
     private readonly options;
     private readonly config;
     private isRunning;
-    private processedFeatures;
+    private processedIssues;
     private pollTimer?;
     constructor(options: WorkflowOptions, config: EdsgerConfig);
     /**
@@ -32,14 +32,14 @@ export declare class WorkflowProcessor {
      */
     stop(): void;
     /**
-     * Process the next available feature using atomic claim mechanism
+     * Process the next available issue using atomic claim mechanism
      * Uses database-level locking to prevent race conditions between workers
      */
-    private processNextFeature;
+    private processNextIssue;
     /**
-     * Process a single feature through the complete pipeline using functional composition
+     * Process a single issue through the complete pipeline using functional composition
      */
-    private processFeature;
+    private processIssue;
     /**
      * Get current processing statistics using pure function
      */