edsger 0.50.0 → 0.52.0

package/dist/phases/code-implementation/index.js

@@ -1,9 +1,9 @@
 /* eslint-disable max-lines -- orchestration module with inline prompt generation and agent execution */
 import { query } from '@anthropic-ai/claude-agent-sdk';
-import { getFeature } from '../../api/features/index.js';
 import { getGitHubConfig } from '../../api/github.js';
+import { getIssue } from '../../api/issues/index.js';
 import { DEFAULT_MODEL } from '../../constants.js';
-import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
+import { logIssuePhaseEvent } from '../../services/audit-logs.js';
 import { createBranches, getBaseBranchInfo, getBranches, getCurrentBranch, updateBranch, } from '../../services/branches.js';
 import { formatChecklistsForContext, } from '../../services/checklist.js';
 import { extractChecklistItems, runPhaseCoaching, } from '../../services/coaching/index.js';
@@ -96,7 +96,7 @@ function logChecklistDebugInfo(implResult, verbose) {
 /**
  * Parse and extract the implementation result from a successful query response
  */
-function parseSuccessResponse(responseText, hasMessageResult, hasAssistantResponse, featureId, verbose
+function parseSuccessResponse(responseText, hasMessageResult, hasAssistantResponse, issueId, verbose
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ) {
     logResponseDebugInfo(responseText, hasMessageResult, hasAssistantResponse, verbose);
@@ -131,7 +131,7 @@ function parseSuccessResponse(responseText, hasMessageResult, hasAssistantRespon
         logDebug(`JSON Parsing Failed - ${errorType}: ${errorMsg}`, verbose);
         logError(`Failed to parse structured implementation result: ${error}`);
         logDebug('Using Fallback Parsing', verbose);
-        const parsedResult = parseImplementationResponse(responseText, featureId, verbose);
+        const parsedResult = parseImplementationResponse(responseText, issueId, verbose);
         logDebug(`Fallback parsed result: branchName=${parsedResult.branchName}, filesModified=${parsedResult.filesModified?.length || 0}, hasSummary=${!!parsedResult.summary}, commitHash=${parsedResult.commitHash}`, verbose);
         return {
             branch_name: parsedResult.branchName,
@@ -149,17 +149,17 @@ function parseSuccessResponse(responseText, hasMessageResult, hasAssistantRespon
  */
 function processQueryResult(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-message, lastAssistantResponse, featureId, verbose
+message, lastAssistantResponse, issueId, verbose
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ) {
     if (message.subtype === 'success') {
         logInfo('\n💻 Code implementation completed, parsing results...');
         const responseText = message.result || lastAssistantResponse;
-        return parseSuccessResponse(responseText, !!message.result, !!lastAssistantResponse, featureId, verbose);
+        return parseSuccessResponse(responseText, !!message.result, !!lastAssistantResponse, issueId, verbose);
     }
     logError(`\n⚠️  Code implementation incomplete: ${message.subtype}`);
     if (message.subtype === 'error_max_turns') {
-        logError('💡 Try breaking down the feature into smaller tasks');
+        logError('💡 Try breaking down the issue into smaller tasks');
     }
     if (lastAssistantResponse) {
         logDebug(`Fallback for incomplete result, subtype: ${message.subtype}`, verbose);
@@ -171,55 +171,55 @@ message, lastAssistantResponse, featureId, verbose
     return null;
 }
 // eslint-disable-next-line complexity
-export const implementFeatureCode = async (options, config, checklistContext) => {
-    const { featureId, verbose, baseBranch = 'main' } = options;
+export const implementIssueCode = async (options, config, checklistContext) => {
+    const { issueId, verbose, baseBranch = 'main' } = options;
     if (verbose) {
-        logInfo(`Starting code implementation for feature ID: ${featureId}`);
+        logInfo(`Starting code implementation for issue ID: ${issueId}`);
         logInfo(`Base branch: ${baseBranch}`);
     }
-    // Check for feature branches - use current branch if available
+    // Check for issue branches - use current branch if available
     // If no branches exist (no branch planning), create a default branch record
     let currentBranch = null;
     try {
-        currentBranch = await getCurrentBranch({ featureId, verbose });
+        currentBranch = await getCurrentBranch({ issueId, verbose });
         if (currentBranch && verbose) {
-            logInfo(`📋 Using feature branch: ${currentBranch.name}`);
+            logInfo(`📋 Using issue branch: ${currentBranch.name}`);
             logInfo(`   Branch name: ${currentBranch.branch_name || 'To be created'}`);
             logInfo(`   Status: ${currentBranch.status}`);
             logInfo(`   Description: ${currentBranch.description || 'No description'}`);
         }
     }
     catch (_error) {
-        // Feature branches not available or error - continue with default behavior
+        // Issue branches not available or error - continue with default behavior
         if (verbose) {
-            logInfo('No feature branches found, using default branch naming');
+            logInfo('No issue branches found, using default branch naming');
         }
     }
     // If no branch exists (no branch planning phase), create a default branch record
     if (!currentBranch) {
         try {
             if (verbose) {
-                logInfo(`📋 Creating default branch record for feature: ${featureId}`);
+                logInfo(`📋 Creating default branch record for issue: ${issueId}`);
             }
-            // Fetch feature info to get the feature name for branch naming
-            let featureName = 'Feature Implementation';
+            // Fetch issue info to get the issue name for branch naming
+            let issueName = 'Issue Implementation';
             try {
-                const featureInfo = await getFeature(featureId, verbose);
-                if (featureInfo?.name) {
-                    // Truncate feature name for branch display (max 100 chars)
-                    featureName = truncateText(featureInfo.name, 100);
+                const issueInfo = await getIssue(issueId, verbose);
+                if (issueInfo?.name) {
+                    // Truncate issue name for branch display (max 100 chars)
+                    issueName = truncateText(issueInfo.name, 100);
                 }
             }
             catch (error) {
                 if (verbose) {
-                    logInfo(`Could not fetch feature name, using default: ${error}`);
+                    logInfo(`Could not fetch issue name, using default: ${error}`);
                 }
             }
-            const defaultBranchName = `dev/${featureId}`;
-            const createdBranches = await createBranches({ featureId, verbose }, [
+            const defaultBranchName = `dev/${issueId}`;
+            const createdBranches = await createBranches({ issueId, verbose }, [
                 {
-                    name: featureName,
-                    description: `Implementation branch for: ${featureName}`,
+                    name: issueName,
+                    description: `Implementation branch for: ${issueName}`,
                     branch_name: defaultBranchName,
                     status: 'pending',
                 },
@@ -238,22 +238,22 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
             }
         }
     }
-    // Update feature branch status to in_progress if we have one
+    // Update issue branch status to in_progress if we have one
     if (currentBranch && currentBranch.status === 'pending') {
         try {
             await updateBranch(currentBranch.id, { status: 'in_progress' }, verbose);
             if (verbose) {
-                logInfo(`✅ Updated feature branch status to in_progress`);
+                logInfo(`✅ Updated issue branch status to in_progress`);
             }
         }
         catch (error) {
             if (verbose) {
-                logError(`Failed to update feature branch status: ${error}`);
+                logError(`Failed to update issue branch status: ${error}`);
             }
         }
     }
     // Determine the actual base branch for branch chaining
-    // If the current feature branch depends on another branch, use that as the base
+    // If the current issue branch depends on another branch, use that as the base
     let actualBaseBranch = baseBranch;
     let rebaseTargetBranch;
     let originalBaseBranch;
@@ -261,7 +261,7 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
     if (currentBranch && currentBranch.base_branch_id) {
         try {
             const allBranches = await getBranches({
-                featureId,
+                issueId,
                 verbose: false,
             });
             const baseBranchInfo = getBaseBranchInfo(currentBranch, allBranches, baseBranch);
@@ -293,10 +293,10 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
             }
         }
     }
-    // Prepare git environment: switch to feature branch and rebase with base
+    // Prepare git environment: switch to issue branch and rebase with base
     // Branch names are stored as dev/... (development branch)
     // PR will be created from dev/... to feat/... after implementation
-    const devBranchName = currentBranch?.branch_name || `dev/${featureId}`;
+    const devBranchName = currentBranch?.branch_name || `dev/${issueId}`;
     if (verbose && currentBranch) {
         logInfo(`🔄 Using dev branch for development: ${devBranchName}`);
     }
@@ -306,7 +306,7 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
     let githubTokenForPush;
     if (devBranchName.startsWith('dev/')) {
         try {
-            const githubConfig = await getGitHubConfig(featureId, verbose);
+            const githubConfig = await getGitHubConfig(issueId, verbose);
             if (githubConfig.configured &&
                 githubConfig.token &&
                 githubConfig.owner &&
@@ -337,7 +337,7 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
     // Use async version to support --onto rebase for branch chaining
     // This correctly handles cases where base branch was squash-merged
     const { cleanup: cleanupGit } = await prepareCustomBranchGitEnvironmentAsync({
-        featureBranch: devBranchName,
+        issueBranch: devBranchName,
         baseBranch: actualBaseBranch,
         rebaseTargetBranch, // For --onto rebase target (e.g., main) when base branch is merged
         originalBaseBranch, // For --onto rebase starting point when base branch was squash-merged
@@ -355,12 +355,12 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
         if (verbose) {
             logInfo('Fetching code implementation context via MCP endpoints...');
         }
-        const context = await fetchCodeImplementationContext(featureId, verbose);
+        const context = await fetchCodeImplementationContext(issueId, verbose);
         // Fetch feedbacks for code implementation phase
-        // For multi-branch features, filter by the current branch to get branch-specific feedbacks
+        // For multi-branch issues, filter by the current branch to get branch-specific feedbacks
         let feedbacksInfo;
         try {
-            const feedbacksContext = await getFeedbacksForPhase({ featureId, verbose }, 'code_implementation', currentBranch?.id // Pass branch_id if we have a current branch
+            const feedbacksContext = await getFeedbacksForPhase({ issueId, verbose }, 'code_implementation', currentBranch?.id // Pass branch_id if we have a current branch
             );
             if (feedbacksContext.feedbacks.length > 0) {
                 feedbacksInfo = await formatFeedbacksForContext(feedbacksContext);
@@ -378,15 +378,15 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
         // Use the dev branch name for development (already computed above)
         const branchName = devBranchName;
         const systemPrompt = createSystemPrompt(config, actualBaseBranch, // Use computed base branch for branch chaining
-        featureId, branchName);
+        issueId, branchName);
         const initialImplementationPrompt = createImplementationPromptWithContext({
-            featureId,
+            issueId,
             context,
             baseBranch: actualBaseBranch, // Use computed base branch for branch chaining
             checklistContext,
             verbose,
             feedbacksInfo,
-            featureBranch: currentBranch,
+            issueBranch: currentBranch,
         });
         const maxIterations = options.maxVerificationIterations || 10;
         let currentIteration = 0;
@@ -406,8 +406,8 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
             }
             // Log iteration start (for iterations after the first)
             if (currentIteration > 1) {
-                await logFeaturePhaseEvent({
-                    featureId,
+                await logIssuePhaseEvent({
+                    issueId,
                     eventType: 'phase_started',
                     phase: 'code_implementation',
                     result: 'info',
@@ -459,7 +459,7 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
                 }
                 // Capture session ID for coaching loop
                 executionSessionId = message.session_id || executionSessionId;
-                newImplementationResult = processQueryResult(message, lastAssistantResponse, featureId, verbose);
+                newImplementationResult = processQueryResult(message, lastAssistantResponse, issueId, verbose);
             }
             // Check if implementation produced results
             if (!newImplementationResult) {
@@ -471,8 +471,8 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
             // Update with new implementation result
             structuredImplementationResult = newImplementationResult;
             // Log implementation completion for this iteration
-            await logFeaturePhaseEvent({
-                featureId,
+            await logIssuePhaseEvent({
+                issueId,
                 eventType: 'phase_completed',
                 phase: 'code_implementation',
                 result: 'success',
@@ -489,7 +489,7 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
             // Coaching loop: self-rate → coach → improve → repeat (between execute and verify)
             // Runs before push so any improvements are committed and pushed together
             const coaching = await runPhaseCoaching({
-                featureId,
+                issueId,
                 phase: 'code_implementation',
                 phaseResult: { execution_session_id: executionSessionId },
                 checklistItems: extractChecklistItems(checklistContext),
@@ -517,9 +517,9 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
                 branchName: structuredImplementationResult.branch_name || branchName,
                 baseBranch: actualBaseBranch, // Use computed base branch for branch chaining
                 checklistContext: checklistContext || null,
-                featureId,
-                featureName: context.feature.name,
-                featureDescription: context.feature.description,
+                issueId,
+                issueName: context.issue.name,
+                issueDescription: context.issue.description,
                 config,
                 currentIteration,
                 maxIterations,
@@ -551,7 +551,7 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
         }
         // Handle results
         if (!structuredImplementationResult) {
-            return buildNoResultsError(featureId, branchName);
+            return buildNoResultsError(issueId, branchName);
         }
         const { branch_name, files_modified, commit_hash, summary, checklist_results, checklist_item_results, } = structuredImplementationResult;
         // Check if verification failed after all iterations
@@ -562,7 +562,7 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
             logError(`❌ Final result: Code verification FAILED after ${currentIteration} iterations`);
             logError(`   Code committed for manual review`);
             return buildVerificationFailureResult({
-                featureId,
+                issueId,
                 branchName: branch_name || branchName,
                 implementationSummary: summary || 'Implementation completed with verification failures',
                 filesModified: files_modified || [],
@@ -571,12 +571,12 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
                 iterations: currentIteration,
             });
         }
-        // Create pull request from dev/ branch to feat/ branch if this is a multi-branch feature
+        // Create pull request from dev/ branch to feat/ branch if this is a multi-branch issue
         let pullRequestUrl = null;
         let pullRequestNumber = null;
         if (currentBranch && devBranchName.startsWith('dev/')) {
             // Get GitHub configuration from developer settings via MCP
-            const githubConfig = await getGitHubConfig(featureId, verbose);
+            const githubConfig = await getGitHubConfig(issueId, verbose);
             if (githubConfig.configured &&
                 githubConfig.token &&
                 githubConfig.owner &&
@@ -593,7 +593,7 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
                 if (verbose) {
                     logInfo(`📝 Creating pull request from ${devBranchName} to ${featBranchName}...`);
                 }
-                const prResult = await createBranchPullRequest(prConfig, devBranchName, currentBranch.name, currentBranch.description || 'Feature branch implementation', baseBranch);
+                const prResult = await createBranchPullRequest(prConfig, devBranchName, currentBranch.name, currentBranch.description || 'Issue branch implementation', baseBranch);
                 if (prResult.success) {
                     pullRequestUrl = prResult.pullRequestUrl || null;
                     pullRequestNumber = prResult.pullRequestNumber || null;
@@ -611,7 +611,7 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
                 logInfo(`   ${githubConfig.message || 'Please configure GitHub App in product developer settings.'}`);
             }
         }
-        // Update feature branch status to ready_for_review if we have one
+        // Update issue branch status to ready_for_review if we have one
         if (currentBranch) {
             try {
                 // Note: branch_name is stored as dev/... and used directly by all phases.
@@ -622,18 +622,18 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
                     pull_request_number: pullRequestNumber,
                 }, verbose);
                 if (verbose) {
-                    logInfo(`✅ Updated feature branch status to ready_for_review`);
+                    logInfo(`✅ Updated issue branch status to ready_for_review`);
                 }
             }
             catch (error) {
                 if (verbose) {
-                    logError(`Failed to update feature branch status: ${error}`);
+                    logError(`Failed to update issue branch status: ${error}`);
                 }
             }
         }
         // Return success result with session ID for coaching
         const implResult = buildImplementationResult({
-            featureId,
+            issueId,
             branchName: branch_name || branchName,
             implementationSummary: summary || 'Implementation completed successfully',
             filesModified: files_modified || [],
@@ -653,8 +653,8 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
     catch (error) {
         logError(`Code implementation failed: ${error instanceof Error ? error.message : String(error)}`);
         return {
-            featureId,
-            branchName: `dev/${featureId}`,
+            issueId,
+            branchName: `dev/${issueId}`,
             implementationSummary: null,
             status: 'error',
             message: `Implementation failed: ${error instanceof Error ? error.message : String(error)}`,
@@ -665,7 +665,7 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
         cleanupGit();
     }
 };
-const createSystemPrompt = (_config, baseBranch, featureId, branchName) => {
+const createSystemPrompt = (_config, baseBranch, issueId, branchName) => {
     const mcpInstructions = `
 
 **MANDATORY Checklist Compliance**:
@@ -680,9 +680,9 @@ If you are provided with checklists in the context, you MUST satisfy ALL of them
 - The system will validate that all checklists have been addressed - missing checklists will cause the pipeline to fail
 
 CRITICAL: Checklists are not optional suggestions - they are mandatory quality gates that must be satisfied.`;
-    return `You are an expert full-stack developer implementing features based on specifications. Your task is to implement complete, production-ready code based on feature requirements, user stories, test cases, and technical design.
+    return `You are an expert full-stack developer implementing issues based on specifications. Your task is to implement complete, production-ready code based on issue requirements, user stories, test cases, and technical design.
 
-**Your Role**: Implement complete, working features based on provided specifications and requirements.
+**Your Role**: Implement complete, working issues based on provided specifications and requirements.
 
 **Available Tools**:
 - Bash: Git operations, running commands, tests, and builds
@@ -697,7 +697,7 @@ CRITICAL: Checklists are not optional suggestions - they are mandatory quality g
 1. **GIT PULL REBASE**: First, ensure main branch is up to date with remote:
    - git checkout ${baseBranch}
    - git pull origin ${baseBranch} --rebase
-2. **CREATE BRANCH**: Create feature branch \`${branchName}\` from ${baseBranch}
+2. **CREATE BRANCH**: Create issue branch \`${branchName}\` from ${baseBranch}
 3. **ANALYZE CODEBASE**: Use Glob and Read to understand the existing code structure
 4. **IMPLEMENT CODE**: Write the actual implementation using Edit/Write tools
 5. **FIX ISSUES**: Address any lint or build failures
@@ -742,8 +742,8 @@ You MUST end your response with a JSON object containing the implementation resu
 \`\`\`json
 {
   "implementation_result": {
-    "feature_id": "FEATURE_ID_PLACEHOLDER",
-    "branch_name": "dev/FEATURE_ID",
+    "issue_id": "ISSUE_ID_PLACEHOLDER",
+    "branch_name": "dev/ISSUE_ID",
     "files_modified": ["file1.ts", "file2.tsx"],
     "commit_hash": "abc123...",
     "summary": "Brief description of what was implemented",
@@ -768,20 +768,20 @@ IMPORTANT: In the checklist context, look for lines that say "ID: [UUID]" in the
 Remember: Quality over speed. It's better to implement correctly than to rush and create bugs.`;
 };
 const createImplementationPromptWithContext = (opts) => {
-    const { featureId, context, baseBranch, checklistContext, verbose, feedbacksInfo, featureBranch, } = opts;
+    const { issueId, context, baseBranch, checklistContext, verbose, feedbacksInfo, issueBranch, } = opts;
     const contextInfo = formatContextForPrompt(context);
     let finalContextInfo = contextInfo;
-    // Add feature branch context if available
-    if (featureBranch) {
+    // Add issue branch context if available
+    if (issueBranch) {
         const branchContext = `
-## Current Feature Branch
+## Current Issue Branch
 
-This is a **multi-branch feature** - the feature has been split into multiple branches for incremental development.
+This is a **multi-branch issue** - the issue has been split into multiple branches for incremental development.
 
 **Current Branch Information:**
-- **Name**: ${featureBranch.name}
-- **Branch**: ${featureBranch.branch_name || 'To be created'}
-- **Description**: ${featureBranch.description || 'No description'}
+- **Name**: ${issueBranch.name}
+- **Branch**: ${issueBranch.branch_name || 'To be created'}
+- **Description**: ${issueBranch.description || 'No description'}
 
 **Important**: Focus ONLY on implementing the scope defined for this specific branch. Do not implement functionality that belongs to other branches.
 `;
@@ -828,11 +828,11 @@ Remember: Checklists are not suggestions - they are mandatory quality gates.`;
         }
     }
     // Determine branch name
-    const branchName = featureBranch?.branch_name || `dev/${featureId}`;
-    const branchDescription = featureBranch
-        ? `\n\n**Note**: This is a multi-branch feature. Focus only on the scope defined for this branch.`
+    const branchName = issueBranch?.branch_name || `dev/${issueId}`;
+    const branchDescription = issueBranch
+        ? `\n\n**Note**: This is a multi-branch issue. Focus only on the scope defined for this branch.`
         : '';
-    return `Implement the ${featureBranch ? `"${featureBranch.name}" branch of` : 'complete'} feature for feature ID: ${featureId}${branchDescription}
+    return `Implement the ${issueBranch ? `"${issueBranch.name}" branch of` : 'complete'} issue for issue ID: ${issueId}${branchDescription}
 
 ${finalContextInfo}
 
@@ -853,9 +853,9 @@ Follow this systematic approach:
    - Where to place new components/files
    - How to integrate with existing systems
 
-4. **IMPLEMENT FEATURE**: Based on the context above, implement the feature by:
+4. **IMPLEMENT ISSUE**: Based on the context above, implement the issue by:
    - Following the technical design (if available)
-   - Satisfying all user stories${featureBranch ? ' relevant to this branch' : ''}
+   - Satisfying all user stories${issueBranch ? ' relevant to this branch' : ''}
    - Creating components, services, APIs, database changes as needed
    - Following existing code patterns and conventions
    - Adding proper error handling and validation
@@ -868,7 +868,7 @@ Follow this systematic approach:
      3. Last resort only: git commit --no-verify -m "message" (explain why in commit message)
 
 ## Important Notes
-${featureBranch ? `- Focus ONLY on implementing the scope for this branch: "${featureBranch.name}"` : '- Focus on implementing ALL user stories completely'}
+${issueBranch ? `- Focus ONLY on implementing the scope for this branch: "${issueBranch.name}"` : '- Focus on implementing ALL user stories completely'}
 - Follow the technical design if provided, or create your own approach
 - Maintain existing code quality and patterns
 - Never skip pre-commit checks - always fix the issues
@@ -876,9 +876,9 @@ ${featureBranch ? `- Focus ONLY on implementing the scope for this branch: "${fe
 
 ${checklistInstructions}
 
-Begin by creating the feature branch and analyzing the codebase structure.`;
+Begin by creating the issue branch and analyzing the codebase structure.`;
 };
-const parseImplementationResponse = (response, featureId, verbose) => {
+const parseImplementationResponse = (response, issueId, verbose) => {
     logDebug('Parsing implementation response...', verbose);
     try {
         // Try to find JSON in the response
@@ -890,7 +890,7 @@ const parseImplementationResponse = (response, featureId, verbose) => {
             if (parsed.implementation_result) {
                 const result = parsed.implementation_result;
                 return {
-                    branchName: result.branch_name || `dev/${featureId}`,
+                    branchName: result.branch_name || `dev/${issueId}`,
                     filesModified: result.files_modified || [],
                     commitHash: result.commit_hash || '',
                     summary: result.summary || '',
@@ -903,7 +903,7 @@ const parseImplementationResponse = (response, featureId, verbose) => {
         const filesMatch = response.match(/files?[:\s]+([^\n]+)/i);
         const commitMatch = response.match(/commit[:\s]+([a-f0-9]{7,})/i);
         return {
-            branchName: branchMatch?.[1] || `dev/${featureId}`,
+            branchName: branchMatch?.[1] || `dev/${issueId}`,
             filesModified: filesMatch
                 ? filesMatch[1].split(/[,\s]+/).filter((f) => f)
                 : [],
@@ -914,7 +914,7 @@ const parseImplementationResponse = (response, featureId, verbose) => {
     catch (error) {
         logError(`Response parsing failed: ${error}`);
         return {
-            branchName: `dev/${featureId}`,
+            branchName: `dev/${issueId}`,
             filesModified: [],
             commitHash: '',
             summary: 'Implementation completed',

package/dist/phases/code-implementation/outcome.d.ts

@@ -6,7 +6,7 @@ export interface VerificationCycleResult {
     nextPrompt: string | null;
 }
 export interface BuildImplementationResultOptions {
-    featureId: string;
+    issueId: string;
     branchName: string;
     implementationSummary: string;
     filesModified: string[];
@@ -29,7 +29,7 @@ export interface BuildImplementationResultOptions {
  */
 export declare function buildImplementationResult(opts: BuildImplementationResultOptions): CodeImplementationResult;
 export interface BuildVerificationFailureResultOptions {
-    featureId: string;
+    issueId: string;
     branchName: string;
     implementationSummary: string;
     filesModified: string[];
@@ -44,4 +44,4 @@ export declare function buildVerificationFailureResult(opts: BuildVerificationFa
 /**
  * Build error result for no implementation
  */
-export declare function buildNoResultsError(featureId: string, branchName: string): CodeImplementationResult;
+export declare function buildNoResultsError(issueId: string, branchName: string): CodeImplementationResult;

package/dist/phases/code-implementation/outcome.js

@@ -2,9 +2,9 @@
  * Build successful implementation result
  */
 export function buildImplementationResult(opts) {
-    const { featureId, branchName, implementationSummary, filesModified, commitHash, checklistResults, checklistItemResults, } = opts;
+    const { issueId, branchName, implementationSummary, filesModified, commitHash, checklistResults, checklistItemResults, } = opts;
     return {
-        featureId,
+        issueId,
         branchName,
         implementationSummary,
         status: 'success',
@@ -21,9 +21,9 @@ export function buildImplementationResult(opts) {
  * Build verification failure result
  */
 export function buildVerificationFailureResult(opts) {
-    const { featureId, branchName, implementationSummary, filesModified, commitHash, verificationResult, iterations, } = opts;
+    const { issueId, branchName, implementationSummary, filesModified, commitHash, verificationResult, iterations, } = opts;
     return {
-        featureId,
+        issueId,
         branchName,
         implementationSummary,
         status: 'error',
@@ -42,9 +42,9 @@ export function buildVerificationFailureResult(opts) {
 /**
  * Build error result for no implementation
  */
-export function buildNoResultsError(featureId, branchName) {
+export function buildNoResultsError(issueId, branchName) {
     return {
-        featureId,
+        issueId,
         branchName,
         implementationSummary: null,
         status: 'error',

package/dist/phases/code-implementation/prompts.d.ts

@@ -1,7 +1,7 @@
 import { type EdsgerConfig } from '../../types/index.js';
 import { type ChecklistVerificationResult } from '../code-implementation-verification/agent.js';
 export declare const createCodeImplementationSystemPrompt: (_config: EdsgerConfig, baseBranch: string, projectDir?: string) => Promise<string>;
-export declare const createCodeImplementationPromptWithContext: (featureId: string, contextInfo: string, baseBranch: string) => string;
+export declare const createCodeImplementationPromptWithContext: (issueId: string, contextInfo: string, baseBranch: string) => string;
 /**
  * Create a prompt for the implementation agent to improve code based on verification feedback
  */

package/dist/phases/code-implementation/prompts.js

@@ -11,8 +11,8 @@ export const createCodeImplementationSystemPrompt = async (_config, baseBranch,
     prompt = substituteVariables(prompt, { BASE_BRANCH: baseBranch });
     return `${prompt}\n\n${OUTPUT_CONTRACTS['code-implementation']}`;
 };
-export const createCodeImplementationPromptWithContext = (featureId, contextInfo, baseBranch) => {
-    return `Implement the complete feature for feature ID: ${featureId}
+export const createCodeImplementationPromptWithContext = (issueId, contextInfo, baseBranch) => {
+    return `Implement the complete issue for issue ID: ${issueId}
 
 ${contextInfo}
 
@@ -22,7 +22,7 @@ Follow this systematic approach:
 
 1. **Git Setup**:
    - Checkout ${baseBranch} and pull latest changes: git pull origin ${baseBranch} --rebase
-   - Create a new feature branch: git checkout -b dev/${featureId}
+   - Create a new issue branch: git checkout -b dev/${issueId}
 
 2. **Codebase Analysis**:
    - Use Glob to understand the project structure and find relevant files
@@ -41,13 +41,13 @@ Follow this systematic approach:
 
 5. **Commit Changes**:
    - Stage all changes: git add .
-   - Commit with descriptive message: git commit -m "feat: implement [feature description]"
+   - Commit with descriptive message: git commit -m "feat: implement [issue description]"
    - Handle any pre-commit hook issues appropriately
 
 ## Important Implementation Notes:
 - Focus on production-ready, maintainable code
 - Follow the technical design specifications closely
-- Implement complete functionality, not just partial features
+- Implement complete functionality, not just partial issues
 - Handle error cases and edge scenarios appropriately
 - Use proper TypeScript types and interfaces
 - Add appropriate validation and error handling
@@ -141,7 +141,7 @@ You MUST return ONLY the JSON object below after completing your improvements. D
 \`\`\`json
 {
   "implementation_result": {
-    "feature_id": "...",
+    "issue_id": "...",
     "branch_name": "${branchName}",
     "files_modified": ["list", "of", "modified", "files"],
     "commit_hash": "new commit hash after improvements",

package/dist/phases/code-implementation-verification/agent.d.ts

@@ -18,11 +18,11 @@ export interface ChecklistVerificationResult {
     feedbacks_rejected_count?: number;
 }
 export interface VerifyCodeImplementationOptions {
-    featureId: string;
+    issueId: string;
     branchName: string;
     baseBranch: string;
-    featureName: string;
-    featureDescription?: string;
+    issueName: string;
+    issueDescription?: string;
     checklistContext: string;
     verbose?: boolean;
 }