edsger 0.50.0 → 0.52.0

package/dist/phases/technical-design/prompts.js

@@ -1,6 +1,6 @@
 import { processConditionals, resolveSkill, substituteVariables, } from '../../services/skill-resolver.js';
 import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export const createTechnicalDesignSystemPrompt = async (_config, mcpServerUrl, mcpToken, featureId, projectDir) => {
+export const createTechnicalDesignSystemPrompt = async (_config, mcpServerUrl, mcpToken, issueId, projectDir) => {
     const skill = await resolveSkill('phase/technical-design', {
         projectDir,
     });
@@ -13,14 +13,14 @@ export const createTechnicalDesignSystemPrompt = async (_config, mcpServerUrl, m
         MCP_TOKEN: mcpToken || '',
     });
     prompt = processConditionals(prompt, {
-        hasMcp: !!(mcpServerUrl && mcpToken && featureId),
+        hasMcp: !!(mcpServerUrl && mcpToken && issueId),
     });
     return `${prompt}\n\n${OUTPUT_CONTRACTS['technical-design']}`;
 };
-export const createTechnicalDesignPromptWithContext = (featureId, contextInfo, existingTechnicalDesign, isIncrementalUpdate = false) => {
+export const createTechnicalDesignPromptWithContext = (issueId, contextInfo, existingTechnicalDesign, isIncrementalUpdate = false) => {
     // If incremental update mode (existing design + feedbacks), create focused update prompt
     if (isIncrementalUpdate && existingTechnicalDesign) {
-        return `Update the technical design for feature ID: ${featureId} based on human feedbacks
+        return `Update the technical design for issue ID: ${issueId} based on human feedbacks
 
 ## Current Technical Design
 
@@ -43,7 +43,7 @@ You are in **INCREMENTAL UPDATE** mode. This means:
 **CRITICAL RULE**:
 - **ONLY optimize based on feedbacks** - Do NOT make other improvements or optimizations
 - **Do NOT proactively improve** other parts of the design that feedbacks don't mention
-- **Do NOT add features** that feedbacks don't request
+- **Do NOT add issues** that feedbacks don't request
 - **Do NOT refactor** sections that feedbacks don't ask about
 - If you see potential improvements but no feedback requests them, IGNORE them
 - Your job is ONLY to address the specific feedbacks, nothing more
@@ -75,7 +75,7 @@ Begin by reviewing the feedbacks and identifying which sections of the current d
     const designMode = existingTechnicalDesign
         ? 'Update and improve the existing technical design, or redesign if needed'
         : 'Generate a comprehensive technical design';
-    return `${designMode} for feature ID: ${featureId}
+    return `${designMode} for issue ID: ${issueId}
 
 ${existingTechnicalDesign ? `## Existing Technical Design\n\n${existingTechnicalDesign}\n\n` : ''}${contextInfo}
 
@@ -91,15 +91,15 @@ Follow this systematic approach:
    - Examine README.md, CLAUDE.md or other documentation files if they exist
 
 2. **Technical Design Creation**: Create comprehensive technical design documentation that addresses:
-   - **Architecture Overview**: How the feature integrates with the existing system
+   - **Architecture Overview**: How the issue integrates with the existing system
    - **Component Design**: Frontend components, backend services, database changes needed
-   - **Data Flow**: How data moves through the system for this feature
+   - **Data Flow**: How data moves through the system for this issue
    - **API Design**: Endpoints, request/response formats, error handling
    - **Database Design**: Schema changes, indexes, relationships, migration strategy
    - **Security**: Authentication, authorization, data validation requirements
    - **Performance**: Caching strategies, optimization, scalability considerations
    - **Testing Strategy**: Unit, integration, and end-to-end testing approaches
-   - **Deployment**: How the feature will be deployed and monitored
+   - **Deployment**: How the issue will be deployed and monitored
 
 3. **Implementation Guidance**: Provide specific implementation recommendations and considerations
 
@@ -197,7 +197,7 @@ You MUST return ONLY the JSON object below. Do NOT include any explanatory text,
 \`\`\`json
 {
   "technical_design_result": {
-    "feature_id": "...",
+    "issue_id": "...",
     "status": "success",
     "summary": "Improved technical design based on verification feedback",
     "technical_design": "The COMPLETE improved technical design document in markdown format",

package/dist/phases/technical-design-verification/agent.d.ts

@@ -41,9 +41,9 @@ export interface ChecklistVerificationResult {
 export interface VerifyTechnicalDesignOptions {
     checklistContext: ChecklistPhaseContext;
     feedbacksContext?: FeedbacksContext | null;
-    featureId: string;
-    featureName: string;
-    featureDescription?: string;
+    issueId: string;
+    issueName: string;
+    issueDescription?: string;
     technicalDesign: string;
     verbose?: boolean;
 }

package/dist/phases/technical-design-verification/agent.js

@@ -57,7 +57,7 @@ async function* prompt(verificationPrompt) {
  */
 // eslint-disable-next-line complexity -- orchestration function with checklist verification and result processing
 export async function verifyTechnicalDesignCompliance(options, _config) {
-    const { checklistContext, feedbacksContext, featureId, featureName, featureDescription, technicalDesign, verbose, } = options;
+    const { checklistContext, feedbacksContext, issueId, issueName, issueDescription, technicalDesign, verbose, } = options;
     const totalChecklistItems = checklistContext.checklists.reduce((sum, checklist) => sum + checklist.items.length, 0);
     const totalFeedbacks = feedbacksContext?.feedbacks?.length || 0;
     const hasFeedbacks = totalFeedbacks > 0;
@@ -73,9 +73,9 @@ export async function verifyTechnicalDesignCompliance(options, _config) {
         const verificationPrompt = await createTechnicalDesignVerificationPrompt({
             checklistContext,
             feedbacksContext: feedbacksContext || undefined,
-            featureId,
-            featureName,
-            featureDescription,
+            issueId,
+            issueName,
+            issueDescription,
             technicalDesign,
         });
         let lastAssistantResponse = '';

package/dist/phases/technical-design-verification/index.d.ts

@@ -3,7 +3,7 @@ import { type FeedbacksContext } from '../../services/feedbacks.js';
 import { type EdsgerConfig } from '../../types/index.js';
 import { type ChecklistVerificationResult } from '../technical-design-verification/agent.js';
 export interface TechnicalDesignResult {
-    featureId: string;
+    issueId: string;
     technicalDesign: string | null;
     status: 'success' | 'error';
     summary: string;
@@ -26,9 +26,9 @@ export interface TechnicalDesignVerificationOptions {
     technicalDesign: string;
     checklistContext: ChecklistPhaseContext | null;
     feedbacksContext: FeedbacksContext | null;
-    featureId: string;
-    featureName: string;
-    featureDescription: string | undefined;
+    issueId: string;
+    issueName: string;
+    issueDescription: string | undefined;
     config: EdsgerConfig;
     currentIteration: number;
     maxIterations: number;

package/dist/phases/technical-design-verification/index.js

@@ -1,4 +1,4 @@
-import { logFeatureVerificationEvent } from '../../services/audit-logs.js';
+import { logIssueVerificationEvent } from '../../services/audit-logs.js';
 import { processChecklistItemResultsFromResponse, } from '../../services/checklist.js';
 import { resolveFeedbacks, } from '../../services/feedbacks.js';
 import { logError, logInfo } from '../../utils/logger.js';
@@ -6,7 +6,7 @@ import { createTechnicalDesignImprovementPrompt } from '../technical-design/prom
 import { verifyTechnicalDesignCompliance, } from '../technical-design-verification/agent.js';
 // eslint-disable-next-line complexity -- orchestration function coordinating design verification and improvement cycles
 export async function performVerificationCycle(opts) {
-    const { technicalDesign, checklistContext, feedbacksContext, featureId, featureName, featureDescription, config, currentIteration, maxIterations, verbose, } = opts;
+    const { technicalDesign, checklistContext, feedbacksContext, issueId, issueName, issueDescription, config, currentIteration, maxIterations, verbose, } = opts;
     // No verification needed if no checklist context
     if (!checklistContext || checklistContext.checklists.length === 0) {
         return { passed: true, verificationResult: null };
@@ -17,9 +17,9 @@ export async function performVerificationCycle(opts) {
     const verificationResult = await verifyTechnicalDesignCompliance({
         checklistContext,
         feedbacksContext,
-        featureId,
-        featureName,
-        featureDescription,
+        issueId,
+        issueName,
+        issueDescription,
         technicalDesign,
         verbose,
     }, config);
@@ -36,8 +36,8 @@ export async function performVerificationCycle(opts) {
             }
         }
         // Log verification success
-        await logFeatureVerificationEvent({
-            featureId,
+        await logIssueVerificationEvent({
+            issueId,
             phase: 'technical_design',
             iteration: currentIteration,
             result: 'success',
@@ -55,7 +55,7 @@ export async function performVerificationCycle(opts) {
             value: item.verification_status,
             notes: item.verification_reason || undefined,
         }));
-        await processChecklistItemResultsFromResponse({ featureId }, 'technical_design', checklistItemResults, verbose);
+        await processChecklistItemResultsFromResponse({ issueId }, 'technical_design', checklistItemResults, verbose);
         // Mark confirmed feedbacks as resolved
         if (verificationResult.feedback_verifications &&
             verificationResult.feedback_verifications.length > 0) {
@@ -63,7 +63,7 @@ export async function performVerificationCycle(opts) {
                 .filter((fb) => fb.verification_status === 'confirmed')
                 .map((fb) => fb.feedback_id);
             if (confirmedFeedbackIds.length > 0) {
-                await resolveFeedbacks({ featureId }, confirmedFeedbackIds, verbose);
+                await resolveFeedbacks({ issueId }, confirmedFeedbackIds, verbose);
             }
         }
         return { passed: true, verificationResult };
@@ -78,8 +78,8 @@ export async function performVerificationCycle(opts) {
     }
     logError(`❌ Iteration ${currentIteration}: Verification FAILED - ${errorMessages.join('; ')}`);
     // Log verification failure with improvement suggestions
-    await logFeatureVerificationEvent({
-        featureId,
+    await logIssueVerificationEvent({
+        issueId,
         phase: 'technical_design',
         iteration: currentIteration,
         result: 'error',
@@ -147,6 +147,6 @@ export async function performVerificationCycle(opts) {
         value: item.verification_status,
         notes: item.verification_reason || undefined,
     }));
-    await processChecklistItemResultsFromResponse({ featureId }, 'technical_design', checklistItemResults, verbose);
+    await processChecklistItemResultsFromResponse({ issueId }, 'technical_design', checklistItemResults, verbose);
     return { passed: false, verificationResult };
 }

package/dist/phases/technical-design-verification/prompts.d.ts

@@ -4,9 +4,9 @@ export declare const createTechnicalDesignVerificationSystemPrompt: (projectDir?
 export interface TechnicalDesignVerificationPromptOptions {
     checklistContext: ChecklistPhaseContext;
     feedbacksContext?: FeedbacksContext;
-    featureId: string;
-    featureName: string;
-    featureDescription?: string;
+    issueId: string;
+    issueName: string;
+    issueDescription?: string;
     technicalDesign: string;
 }
 export declare const createTechnicalDesignVerificationPrompt: (options: TechnicalDesignVerificationPromptOptions) => Promise<string>;

package/dist/phases/technical-design-verification/prompts.js

@@ -13,7 +13,7 @@ export const createTechnicalDesignVerificationSystemPrompt = async (projectDir)
 ${OUTPUT_CONTRACTS['technical-design-verification']}`;
 };
 export const createTechnicalDesignVerificationPrompt = async (options) => {
-    const { checklistContext, feedbacksContext, featureId, featureName, featureDescription, technicalDesign, } = options;
+    const { checklistContext, feedbacksContext, issueId, issueName, issueDescription, technicalDesign, } = options;
     // Format all checklist items with their requirements
     const checklistItemsSection = checklistContext.checklists
         .flatMap((checklist) => checklist.items.map((item) => {
@@ -37,7 +37,7 @@ export const createTechnicalDesignVerificationPrompt = async (options) => {
             if (!feedback.content) {
                 return feedback;
             }
-            const { processedMarkdown } = await downloadImagesForClaudeCode(feedback.content, featureId);
+            const { processedMarkdown } = await downloadImagesForClaudeCode(feedback.content, issueId);
             return { ...feedback, content: processedMarkdown };
         }));
         feedbacksSection = `
@@ -64,11 +64,11 @@ ${processedFeedbacks
 
 You are verifying that a technical design document satisfies checklist requirements${totalFeedbacks > 0 ? ' and addresses human feedbacks' : ''}.
 
-## Feature Context
+## Issue Context
 
-**Feature**: ${featureName}
-**Feature ID**: ${featureId}
-**Description**: ${featureDescription || 'No description'}
+**Issue**: ${issueName}
+**Issue ID**: ${issueId}
+**Description**: ${issueDescription || 'No description'}
 
 ## Technical Design Document
 

package/dist/phases/test-cases-analysis/context.d.ts

@@ -1,15 +1,15 @@
 import { type ProductInfo } from '../../api/products.js';
 import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import type { FeatureInfo, TestCase, UserStory } from '../../types/features.js';
+import type { IssueInfo, TestCase, UserStory } from '../../types/issues.js';
 export interface TestCasesAnalysisContext {
-    feature: FeatureInfo;
+    issue: IssueInfo;
     product: ProductInfo;
     existing_user_stories: UserStory[];
     existing_test_cases: TestCase[];
 }
-export declare function fetchTestCasesAnalysisContext(featureId: string, verbose?: boolean): Promise<TestCasesAnalysisContext>;
-export declare function prepareTestCasesAnalysisContext(featureId: string, checklistContext: ChecklistPhaseContext | null | undefined, verbose?: boolean): Promise<{
-    featureContext: TestCasesAnalysisContext;
+export declare function fetchTestCasesAnalysisContext(issueId: string, verbose?: boolean): Promise<TestCasesAnalysisContext>;
+export declare function prepareTestCasesAnalysisContext(issueId: string, checklistContext: ChecklistPhaseContext | null | undefined, verbose?: boolean): Promise<{
+    issueContext: TestCasesAnalysisContext;
     analysisPrompt: string;
     hasFeedbacks: boolean;
 }>;

package/dist/phases/test-cases-analysis/context.js

@@ -1,30 +1,30 @@
-import { getFeature, getTestCases, getUserStories, } from '../../api/features/index.js';
+import { getIssue, getTestCases, getUserStories, } from '../../api/issues/index.js';
 import { getProduct } from '../../api/products.js';
 import { formatChecklistsForContext, } from '../../services/checklist.js';
 import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services/feedbacks.js';
 import { logError, logInfo } from '../../utils/logger.js';
 import { formatTestCasesAnalysisContext } from './formatters.js';
 import { createTestCasesAnalysisPromptWithContext, createTestCasesFeedbackFocusedPromptWithContext, } from './prompts.js';
-export async function fetchTestCasesAnalysisContext(featureId, verbose) {
+export async function fetchTestCasesAnalysisContext(issueId, verbose) {
     try {
         if (verbose) {
-            logInfo(`Fetching test cases analysis context for feature: ${featureId}`);
+            logInfo(`Fetching test cases analysis context for issue: ${issueId}`);
         }
-        const [feature, existingUserStories, existingTestCases] = await Promise.all([
-            getFeature(featureId, verbose),
-            getUserStories(featureId, verbose),
-            getTestCases(featureId, verbose),
+        const [issue, existingUserStories, existingTestCases] = await Promise.all([
+            getIssue(issueId, verbose),
+            getUserStories(issueId, verbose),
+            getTestCases(issueId, verbose),
         ]);
-        const product = await getProduct(feature.product_id, verbose);
+        const product = await getProduct(issue.product_id, verbose);
         if (verbose) {
             logInfo(`✅ Test cases analysis context fetched successfully:`);
-            logInfo(`   Feature: ${feature.name}`);
+            logInfo(`   Issue: ${issue.name}`);
             logInfo(`   Product: ${product.name}`);
             logInfo(`   User Stories: ${existingUserStories.length}`);
             logInfo(`   Existing Test Cases: ${existingTestCases.length}`);
         }
         return {
-            feature,
+            issue,
             product,
             existing_user_stories: existingUserStories,
             existing_test_cases: existingTestCases,
@@ -36,12 +36,12 @@ export async function fetchTestCasesAnalysisContext(featureId, verbose) {
         throw new Error(`Context fetch failed: ${errorMessage}`);
     }
 }
-export async function prepareTestCasesAnalysisContext(featureId, checklistContext, verbose) {
+export async function prepareTestCasesAnalysisContext(issueId, checklistContext, verbose) {
     if (verbose) {
         logInfo('Fetching test cases analysis context via MCP endpoints...');
     }
-    const featureContext = await fetchTestCasesAnalysisContext(featureId, verbose);
-    const { content: contextInfo, downloadedImages } = await formatTestCasesAnalysisContext(featureContext);
+    const issueContext = await fetchTestCasesAnalysisContext(issueId, verbose);
+    const { content: contextInfo, downloadedImages } = await formatTestCasesAnalysisContext(issueContext);
     if (verbose && downloadedImages.length > 0) {
         logInfo(`Downloaded ${downloadedImages.length} images for Claude Code:`);
         downloadedImages.forEach((img) => {
@@ -52,7 +52,7 @@ export async function prepareTestCasesAnalysisContext(featureId, checklistContex
     let hasFeedbacks = false;
     // Add feedbacks context
     try {
-        const feedbacksContext = await getFeedbacksForPhase({ featureId, verbose }, 'test-cases-analysis');
+        const feedbacksContext = await getFeedbacksForPhase({ issueId, verbose }, 'test-cases-analysis');
         if (feedbacksContext.feedbacks.length > 0) {
             hasFeedbacks = true;
             const feedbacksInfo = await formatFeedbacksForContext(feedbacksContext);
@@ -75,12 +75,12 @@ export async function prepareTestCasesAnalysisContext(featureId, checklistContex
             logInfo(`Added ${checklistContext.checklists.length} checklists to analysis context`);
         }
     }
-    const hasExistingArtifacts = featureContext.existing_test_cases.length > 0;
+    const hasExistingArtifacts = issueContext.existing_test_cases.length > 0;
     const analysisPrompt = hasFeedbacks && hasExistingArtifacts
-        ? createTestCasesFeedbackFocusedPromptWithContext(featureId, finalContextInfo)
-        : createTestCasesAnalysisPromptWithContext(featureId, finalContextInfo);
+        ? createTestCasesFeedbackFocusedPromptWithContext(issueId, finalContextInfo)
+        : createTestCasesAnalysisPromptWithContext(issueId, finalContextInfo);
     if (verbose && hasFeedbacks && hasExistingArtifacts) {
         logInfo('Using feedback-focused prompt (re-run with human feedbacks detected)');
     }
-    return { featureContext, analysisPrompt, hasFeedbacks };
+    return { issueContext, analysisPrompt, hasFeedbacks };
 }

package/dist/phases/test-cases-analysis/formatters.js

@@ -1,18 +1,18 @@
 import { formatTestCases, formatUserStories } from '../../utils/formatters.js';
 import { downloadImagesForClaudeCode, } from '../../utils/image-downloader.js';
 export async function formatTestCasesAnalysisContext(context) {
-    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.feature.description || 'No description provided', context.feature.id);
+    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.issue.description || 'No description provided', context.issue.id);
     const content = `# Test Cases Analysis Context
 
-## Feature Information
-- **ID**: ${context.feature.id}
-- **Name**: ${context.feature.name}
+## Issue Information
+- **ID**: ${context.issue.id}
+- **Name**: ${context.issue.name}
 - **Description**:
 ${processedMarkdown}
 
 ${downloadedImages.length > 0 ? '**IMPORTANT**: The description contains images that have been downloaded locally. Please use the Read tool to view these images to fully understand the requirements.' : ''}
 
-- **Current Status**: ${context.feature.status}
+- **Current Status**: ${context.issue.status}
 
 ## Product Information
 - **Product**: ${context.product.name}
@@ -26,10 +26,10 @@ ${formatUserStories(context.existing_user_stories)}
 ${formatTestCases(context.existing_test_cases)}
 
 ## Current Technical Design
-${context.feature.technical_design || 'No technical design available yet'}
+${context.issue.technical_design || 'No technical design available yet'}
 
 ---
 
-**Analysis Instructions**: Based on the above feature information, user stories, and existing test cases, create comprehensive test cases that ensure thorough testing coverage.`;
+**Analysis Instructions**: Based on the above issue information, user stories, and existing test cases, create comprehensive test cases that ensure thorough testing coverage.`;
     return { content, downloadedImages };
 }

package/dist/phases/test-cases-analysis/index.d.ts

@@ -2,7 +2,7 @@ import { type ChecklistPhaseContext } from '../../services/checklist.js';
 import { type EdsgerConfig } from '../../types/index.js';
 import { type TestCasesAnalysisResult } from './outcome.js';
 export interface TestCasesAnalysisOptions {
-    featureId: string;
+    issueId: string;
     verbose?: boolean;
     maxVerificationIterations?: number;
 }

package/dist/phases/test-cases-analysis/index.js

@@ -1,24 +1,24 @@
-import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
+import { logIssuePhaseEvent } from '../../services/audit-logs.js';
 import { extractChecklistItems, runPhaseCoaching, } from '../../services/coaching/index.js';
 import { logError, logInfo, logWarning } from '../../utils/logger.js';
-import { performVerificationCycle } from '../feature-analysis-verification/index.js';
+import { performVerificationCycle } from '../issue-analysis-verification/index.js';
 import { executeTestCasesAnalysisQuery, parseAnalysisResult } from './agent.js';
 import { prepareTestCasesAnalysisContext } from './context.js';
 import { buildTestCasesAnalysisResult, deleteSpecificTestCases, deleteTestCaseArtifacts, getAllDraftTestCaseIds, resetReadyTestCasesToDraft, saveTestCasesAsDraft, updateTestCasesToReady, } from './outcome.js';
 import { createTestCasesAnalysisSystemPrompt } from './prompts.js';
 // eslint-disable-next-line complexity
 export const analyseTestCases = async (options, config, checklistContext) => {
-    const { featureId, verbose } = options;
+    const { issueId, verbose } = options;
     if (verbose) {
-        logInfo(`Starting test cases analysis for feature ID: ${featureId}`);
+        logInfo(`Starting test cases analysis for issue ID: ${issueId}`);
     }
     try {
         // Reset pending_approval test cases to draft so AI can manage them on re-run
-        const resetCount = await resetReadyTestCasesToDraft(featureId, verbose);
+        const resetCount = await resetReadyTestCasesToDraft(issueId, verbose);
         if (verbose && resetCount > 0) {
             logInfo(`✅ Reset ${resetCount} pending_approval test cases to draft for re-analysis`);
         }
-        const context = await prepareTestCasesAnalysisContext(featureId, checklistContext, verbose);
+        const context = await prepareTestCasesAnalysisContext(issueId, checklistContext, verbose);
         const systemPrompt = await createTestCasesAnalysisSystemPrompt();
         const initialAnalysisPrompt = context.analysisPrompt;
         const maxIterations = options.maxVerificationIterations || 10;
@@ -37,8 +37,8 @@ export const analyseTestCases = async (options, config, checklistContext) => {
                 logInfo(`\n🔄 Iteration ${currentIteration}/${maxIterations}: Improving test cases based on verification feedback...`);
             }
             if (currentIteration > 1) {
-                await logFeaturePhaseEvent({
-                    featureId,
+                await logIssuePhaseEvent({
+                    issueId,
                     eventType: 'phase_started',
                     phase: 'test_cases_analysis',
                     result: 'info',
@@ -54,8 +54,8 @@ export const analyseTestCases = async (options, config, checklistContext) => {
             if (!structuredAnalysisResult) {
                 break;
             }
-            await logFeaturePhaseEvent({
-                featureId,
+            await logIssuePhaseEvent({
+                issueId,
                 eventType: 'phase_completed',
                 phase: 'test_cases_analysis',
                 result: 'success',
@@ -73,14 +73,14 @@ export const analyseTestCases = async (options, config, checklistContext) => {
                 if (verbose) {
                     logInfo('🗑️  Processing test case deletions identified by AI...');
                 }
-                await deleteSpecificTestCases(featureId, structuredAnalysisResult.deleted_test_case_ids || [], structuredAnalysisResult.deletion_reasons || {}, verbose);
+                await deleteSpecificTestCases(issueId, structuredAnalysisResult.deleted_test_case_ids || [], structuredAnalysisResult.deletion_reasons || {}, verbose);
             }
             // Save test cases as draft
-            const { testCaseIds } = await saveTestCasesAsDraft(featureId, structuredAnalysisResult.created_test_cases || [], verbose);
+            const { testCaseIds } = await saveTestCasesAsDraft(issueId, structuredAnalysisResult.created_test_cases || [], verbose);
             currentDraftTestCaseIds = testCaseIds;
             // Coaching loop between execute and verify
             await runPhaseCoaching({
-                featureId,
+                issueId,
                 phase: 'test_cases_analysis',
                 phaseResult: structuredAnalysisResult,
                 checklistItems: extractChecklistItems(checklistContext),
@@ -88,7 +88,7 @@ export const analyseTestCases = async (options, config, checklistContext) => {
                     const parsed = parseAnalysisResult(responseText);
                     if (parsed.analysis) {
                         await deleteTestCaseArtifacts(currentDraftTestCaseIds, verbose);
-                        const { testCaseIds: newTestCaseIds } = await saveTestCasesAsDraft(featureId, parsed.analysis.created_test_cases || [], verbose);
+                        const { testCaseIds: newTestCaseIds } = await saveTestCasesAsDraft(issueId, parsed.analysis.created_test_cases || [], verbose);
                         currentDraftTestCaseIds = newTestCaseIds;
                         structuredAnalysisResult = parsed.analysis;
                     }
@@ -105,11 +105,11 @@ export const analyseTestCases = async (options, config, checklistContext) => {
                     created_user_stories: [],
                 },
                 checklistContext: checklistContext || null,
-                context: context.featureContext,
+                context: context.issueContext,
                 config,
                 currentIteration,
                 maxIterations,
-                featureId,
+                issueId,
                 verbose,
             });
             ({ verificationResult } = verificationCycle);
@@ -118,7 +118,7 @@ export const analyseTestCases = async (options, config, checklistContext) => {
                     logInfo('✅ Verification passed! Updating all draft test cases to pending_approval status...');
                 }
                 // Update ALL remaining draft test cases (both kept old ones and newly created)
-                const allDraftIds = await getAllDraftTestCaseIds(featureId, verbose);
+                const allDraftIds = await getAllDraftTestCaseIds(issueId, verbose);
                 await updateTestCasesToReady(allDraftIds, verbose);
                 break;
             }
@@ -143,7 +143,7 @@ export const analyseTestCases = async (options, config, checklistContext) => {
         if (!checklistContext ||
             checklistContext.checklists.length === 0 ||
             !verificationResult) {
-            const allDraftIds = await getAllDraftTestCaseIds(featureId, verbose);
+            const allDraftIds = await getAllDraftTestCaseIds(issueId, verbose);
             if (allDraftIds.length > 0) {
                 if (verbose) {
                     logInfo('✅ No checklist verification needed. Updating all draft test cases to pending_approval status...');
@@ -159,14 +159,14 @@ export const analyseTestCases = async (options, config, checklistContext) => {
             logError(`   Draft test cases (${currentDraftTestCaseIds.length}) kept for manual review`);
             throw new Error(`Checklist verification failed after ${currentIteration} iterations`);
         }
-        return buildTestCasesAnalysisResult(featureId, context.featureContext, structuredAnalysisResult, currentIteration);
+        return buildTestCasesAnalysisResult(issueId, context.issueContext, structuredAnalysisResult, currentIteration);
     }
     catch (error) {
         logError(`Test cases analysis failed: ${error instanceof Error ? error.message : String(error)}`);
         return {
-            featureId,
+            issueId,
             productInfo: null,
-            featureInfo: null,
+            issueInfo: null,
             existingTestCases: [],
             createdTestCases: [],
             summary: `Analysis failed: ${error instanceof Error ? error.message : String(error)}`,

package/dist/phases/test-cases-analysis/outcome.d.ts

@@ -1,16 +1,16 @@
 import { type TestCasesAnalysisContext } from './context.js';
-export declare function resetReadyTestCasesToDraft(featureId: string, verbose?: boolean): Promise<number>;
-export declare function getAllDraftTestCaseIds(featureId: string, verbose?: boolean): Promise<string[]>;
+export declare function resetReadyTestCasesToDraft(issueId: string, verbose?: boolean): Promise<number>;
+export declare function getAllDraftTestCaseIds(issueId: string, verbose?: boolean): Promise<string[]>;
 export declare function deleteTestCaseArtifacts(testCaseIds: string[], verbose?: boolean): Promise<void>;
-export declare function deleteSpecificTestCases(featureId: string, deletedTestCaseIds: string[], deletionReasons: Record<string, string>, verbose?: boolean): Promise<void>;
+export declare function deleteSpecificTestCases(issueId: string, deletedTestCaseIds: string[], deletionReasons: Record<string, string>, verbose?: boolean): Promise<void>;
 export declare function updateTestCasesToReady(testCaseIds: string[], verbose?: boolean): Promise<void>;
-export declare function saveTestCasesAsDraft(featureId: string, createdTestCases: any[], verbose?: boolean): Promise<{
+export declare function saveTestCasesAsDraft(issueId: string, createdTestCases: any[], verbose?: boolean): Promise<{
     testCaseIds: string[];
 }>;
 export interface TestCasesAnalysisResult {
-    featureId: string;
+    issueId: string;
     productInfo: unknown;
-    featureInfo: unknown;
+    issueInfo: unknown;
     existingTestCases: any[];
     createdTestCases: any[];
     summary: string;
@@ -24,4 +24,4 @@ export interface TestCasesAnalysisResult {
         deletion_reasons?: Record<string, string>;
     };
 }
-export declare function buildTestCasesAnalysisResult(featureId: string, context: TestCasesAnalysisContext, structuredAnalysisResult: any, currentIteration: number): TestCasesAnalysisResult;
+export declare function buildTestCasesAnalysisResult(issueId: string, context: TestCasesAnalysisContext, structuredAnalysisResult: any, currentIteration: number): TestCasesAnalysisResult;

package/dist/phases/test-cases-analysis/outcome.js

@@ -1,8 +1,8 @@
-import { batchDeleteTestCases, batchUpdateTestCaseStatus, getTestCases, } from '../../api/features/index.js';
+import { batchDeleteTestCases, batchUpdateTestCaseStatus, getTestCases, } from '../../api/issues/index.js';
 import { callMcpEndpoint } from '../../api/mcp-client.js';
 import { logError, logInfo } from '../../utils/logger.js';
-export async function resetReadyTestCasesToDraft(featureId, verbose) {
-    const testCases = await getTestCases(featureId, false);
+export async function resetReadyTestCasesToDraft(issueId, verbose) {
+    const testCases = await getTestCases(issueId, false);
     const readyIds = testCases
         .filter((tc) => tc.status === 'pending_approval')
         .map((tc) => tc.id);
@@ -15,13 +15,13 @@ export async function resetReadyTestCasesToDraft(featureId, verbose) {
     await batchUpdateTestCaseStatus(readyIds, 'draft', verbose);
     return readyIds.length;
 }
-export async function getAllDraftTestCaseIds(featureId, verbose) {
-    const testCases = await getTestCases(featureId, false);
+export async function getAllDraftTestCaseIds(issueId, verbose) {
+    const testCases = await getTestCases(issueId, false);
     const draftIds = testCases
         .filter((tc) => tc.status === 'draft')
         .map((tc) => tc.id);
     if (verbose) {
-        logInfo(`Found ${draftIds.length} draft test cases for feature`);
+        logInfo(`Found ${draftIds.length} draft test cases for issue`);
     }
     return draftIds;
 }
@@ -37,8 +37,8 @@ function isValidUUID(id) {
     const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
     return uuidRegex.test(id);
 }
-export async function deleteSpecificTestCases(featureId, deletedTestCaseIds, deletionReasons, verbose) {
-    const currentTestCases = await getTestCases(featureId, false);
+export async function deleteSpecificTestCases(issueId, deletedTestCaseIds, deletionReasons, verbose) {
+    const currentTestCases = await getTestCases(issueId, false);
     const testCaseStatusMap = new Map(currentTestCases.map((testCase) => [testCase.id, testCase.status]));
     const validTestCaseIds = deletedTestCaseIds.filter((id) => {
         if (!isValidUUID(id)) {
@@ -75,7 +75,7 @@ export async function updateTestCasesToReady(testCaseIds, verbose) {
         await batchUpdateTestCaseStatus(testCaseIds, 'pending_approval', verbose);
     }
 }
-export async function saveTestCasesAsDraft(featureId, 
+export async function saveTestCasesAsDraft(issueId, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 createdTestCases, verbose) {
     const testCaseIds = [];
@@ -85,7 +85,7 @@ createdTestCases, verbose) {
         }
         try {
             const result = (await callMcpEndpoint('test_cases/create', {
-                feature_id: featureId,
+                issue_id: issueId,
                 test_cases: createdTestCases.map((testCase) => ({
                     name: testCase.name,
                     description: testCase.description,
@@ -109,14 +109,14 @@ createdTestCases, verbose) {
     }
     return { testCaseIds };
 }
-export function buildTestCasesAnalysisResult(featureId, context, 
+export function buildTestCasesAnalysisResult(issueId, context, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 structuredAnalysisResult, currentIteration) {
     const { created_test_cases, deleted_test_case_ids, deletion_reasons, checklist_results, checklist_item_results, } = structuredAnalysisResult;
     return {
-        featureId,
+        issueId,
         productInfo: context.product,
-        featureInfo: context.feature,
+        issueInfo: context.issue,
         existingTestCases: context.existing_test_cases.map((testCase) => ({
             ...testCase,
             created_at: testCase.created_at || new Date().toISOString(),