edsger 0.50.0 → 0.52.0

package/dist/phases/{feature-analysis → issue-analysis}/index.js

@@ -1,26 +1,26 @@
-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 { executeAnalysisQuery, parseAnalysisResult } from './agent.js';
 import { prepareAnalysisContext } from './context.js';
 import { buildAnalysisResult, deleteArtifacts, deleteSpecificArtifacts, getAllDraftArtifactIds, resetReadyArtifactsToDraft, saveAnalysisArtifactsAsDraft, updateArtifactsToReady, } from './outcome.js';
-import { createFeatureAnalysisSystemPrompt } from './prompts.js';
+import { createIssueAnalysisSystemPrompt } from './prompts.js';
 // eslint-disable-next-line complexity
-export const analyseFeature = async (options, config, checklistContext) => {
-    const { featureId, verbose } = options;
+export const analyseIssue = async (options, config, checklistContext) => {
+    const { issueId, verbose } = options;
     if (verbose) {
-        logInfo(`Starting feature analysis for feature ID: ${featureId}`);
+        logInfo(`Starting issue analysis for issue ID: ${issueId}`);
     }
     try {
         // Reset pending_approval artifacts to draft so AI can manage them on re-run
-        const resetResult = await resetReadyArtifactsToDraft(featureId, verbose);
+        const resetResult = await resetReadyArtifactsToDraft(issueId, verbose);
         if (verbose &&
             (resetResult.resetUserStories > 0 || resetResult.resetTestCases > 0)) {
             logInfo(`✅ Reset ${resetResult.resetUserStories} user stories and ${resetResult.resetTestCases} test cases to draft for re-analysis`);
         }
-        const context = await prepareAnalysisContext(featureId, checklistContext, verbose);
-        const systemPrompt = await createFeatureAnalysisSystemPrompt();
+        const context = await prepareAnalysisContext(issueId, checklistContext, verbose);
+        const systemPrompt = await createIssueAnalysisSystemPrompt();
         const initialAnalysisPrompt = context.analysisPrompt;
         const maxIterations = options.maxVerificationIterations || 10;
         let currentIteration = 0;
@@ -41,10 +41,10 @@ export const analyseFeature = 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: 'feature_analysis',
+                    phase: 'issue_analysis',
                     result: 'info',
                     metadata: {
                         iteration: currentIteration,
@@ -59,10 +59,10 @@ export const analyseFeature = async (options, config, checklistContext) => {
             if (!structuredAnalysisResult) {
                 break;
             }
-            await logFeaturePhaseEvent({
-                featureId,
+            await logIssuePhaseEvent({
+                issueId,
                 eventType: 'phase_completed',
-                phase: 'feature_analysis',
+                phase: 'issue_analysis',
                 result: 'success',
                 metadata: {
                     iteration: currentIteration,
@@ -81,16 +81,16 @@ export const analyseFeature = async (options, config, checklistContext) => {
                 if (verbose) {
                     logInfo('🗑️  Processing deletions identified by AI during analysis...');
                 }
-                await deleteSpecificArtifacts(featureId, structuredAnalysisResult.deleted_user_story_ids || [], structuredAnalysisResult.deleted_test_case_ids || [], structuredAnalysisResult.deletion_reasons || {}, verbose);
+                await deleteSpecificArtifacts(issueId, structuredAnalysisResult.deleted_user_story_ids || [], structuredAnalysisResult.deleted_test_case_ids || [], structuredAnalysisResult.deletion_reasons || {}, verbose);
             }
             // Save artifacts as draft and get their IDs
-            const { userStoryIds, testCaseIds } = await saveAnalysisArtifactsAsDraft(featureId, structuredAnalysisResult.created_user_stories || [], structuredAnalysisResult.created_test_cases || [], verbose);
+            const { userStoryIds, testCaseIds } = await saveAnalysisArtifactsAsDraft(issueId, structuredAnalysisResult.created_user_stories || [], structuredAnalysisResult.created_test_cases || [], verbose);
             currentDraftUserStoryIds = userStoryIds;
             currentDraftTestCaseIds = testCaseIds;
             // Coaching loop between execute and verify
             await runPhaseCoaching({
-                featureId,
-                phase: 'feature_analysis',
+                issueId,
+                phase: 'issue_analysis',
                 phaseResult: structuredAnalysisResult,
                 checklistItems: extractChecklistItems(checklistContext),
                 onImproved: async (_sessionId, responseText) => {
@@ -98,13 +98,13 @@ export const analyseFeature = async (options, config, checklistContext) => {
                     if (parsed.analysis) {
                         // Delete old drafts and save improved ones
                         await deleteArtifacts(currentDraftUserStoryIds, currentDraftTestCaseIds, verbose);
-                        const { userStoryIds: newUserStoryIds, testCaseIds: newTestCaseIds, } = await saveAnalysisArtifactsAsDraft(featureId, parsed.analysis.created_user_stories || [], parsed.analysis.created_test_cases || [], verbose);
+                        const { userStoryIds: newUserStoryIds, testCaseIds: newTestCaseIds, } = await saveAnalysisArtifactsAsDraft(issueId, parsed.analysis.created_user_stories || [], parsed.analysis.created_test_cases || [], verbose);
                         currentDraftUserStoryIds = newUserStoryIds;
                         currentDraftTestCaseIds = newTestCaseIds;
                         structuredAnalysisResult = parsed.analysis;
                     }
                     else {
-                        logWarning(`Coaching improvement response could not be parsed for feature-analysis. Keeping previous drafts. ${parsed.error || ''}`);
+                        logWarning(`Coaching improvement response could not be parsed for issue-analysis. Keeping previous drafts. ${parsed.error || ''}`);
                     }
                 },
                 verbose,
@@ -113,11 +113,11 @@ export const analyseFeature = async (options, config, checklistContext) => {
             const verificationCycle = await performVerificationCycle({
                 structuredAnalysisResult,
                 checklistContext: checklistContext || null,
-                context: context.featureContext,
+                context: context.issueContext,
                 config,
                 currentIteration,
                 maxIterations,
-                featureId,
+                issueId,
                 verbose,
             });
             ({ verificationResult } = verificationCycle);
@@ -126,7 +126,7 @@ export const analyseFeature = async (options, config, checklistContext) => {
                 if (verbose) {
                     logInfo('✅ Verification passed! Updating all draft artifacts to pending_approval status...');
                 }
-                const allDrafts = await getAllDraftArtifactIds(featureId, verbose);
+                const allDrafts = await getAllDraftArtifactIds(issueId, verbose);
                 await updateArtifactsToReady(allDrafts.userStoryIds, allDrafts.testCaseIds, verbose);
                 break;
             }
@@ -157,7 +157,7 @@ export const analyseFeature = async (options, config, checklistContext) => {
         if (!checklistContext ||
             checklistContext.checklists.length === 0 ||
             !verificationResult) {
-            const allDrafts = await getAllDraftArtifactIds(featureId, verbose);
+            const allDrafts = await getAllDraftArtifactIds(issueId, verbose);
             if (allDrafts.userStoryIds.length > 0 ||
                 allDrafts.testCaseIds.length > 0) {
                 if (verbose) {
@@ -180,14 +180,14 @@ export const analyseFeature = async (options, config, checklistContext) => {
         // Return success result
         // Note: Artifacts have already been saved and updated to 'pending_approval' status (if verification passed)
         // or remain as draft (if verification failed)
-        return buildAnalysisResult(featureId, context.featureContext, structuredAnalysisResult, currentIteration);
+        return buildAnalysisResult(issueId, context.issueContext, structuredAnalysisResult, currentIteration);
     }
     catch (error) {
-        logError(`Feature analysis failed: ${error instanceof Error ? error.message : String(error)}`);
+        logError(`Issue analysis failed: ${error instanceof Error ? error.message : String(error)}`);
         return {
-            featureId,
+            issueId,
             productInfo: null,
-            featureInfo: null,
+            issueInfo: null,
             existingUserStories: [],
             existingTestCases: [],
             createdUserStories: [],

package/dist/phases/issue-analysis/outcome.d.ts

@@ -0,0 +1,40 @@
+import { type IssueAnalysisResult } from '../../types/index.js';
+import { type IssueAnalysisContext } from './context.js';
+/**
+ * Reset ready user stories and test cases to draft for re-analysis
+ */
+export declare function resetReadyArtifactsToDraft(issueId: string, verbose?: boolean): Promise<{
+    resetUserStories: number;
+    resetTestCases: number;
+}>;
+/**
+ * Get all draft artifact IDs for an issue
+ */
+export declare function getAllDraftArtifactIds(issueId: string, verbose?: boolean): Promise<{
+    userStoryIds: string[];
+    testCaseIds: string[];
+}>;
+/**
+ * Delete artifacts after verification failure
+ */
+export declare function deleteArtifacts(userStoryIds: string[], testCaseIds: string[], verbose?: boolean): Promise<void>;
+/**
+ * Delete specific artifacts identified by AI during analysis
+ * Only deletes artifacts with status 'draft'
+ */
+export declare function deleteSpecificArtifacts(issueId: string, deletedUserStoryIds: string[], deletedTestCaseIds: string[], deletionReasons: Record<string, string>, verbose?: boolean): Promise<void>;
+/**
+ * Update artifacts to pending_approval status after successful verification
+ */
+export declare function updateArtifactsToReady(userStoryIds: string[], testCaseIds: string[], verbose?: boolean): Promise<void>;
+/**
+ * Save analysis artifacts as draft and return their IDs
+ */
+export declare function saveAnalysisArtifactsAsDraft(issueId: string, createdUserStories: Record<string, unknown>[], createdTestCases: Record<string, unknown>[], verbose?: boolean): Promise<{
+    userStoryIds: string[];
+    testCaseIds: string[];
+}>;
+/**
+ * Build the final analysis result object
+ */
+export declare function buildAnalysisResult(issueId: string, context: IssueAnalysisContext, structuredAnalysisResult: any, currentIteration: number): IssueAnalysisResult;

package/dist/phases/{feature-analysis → issue-analysis}/outcome.js

@@ -1,13 +1,13 @@
-import { batchDeleteTestCases, batchDeleteUserStories, batchUpdateTestCaseStatus, batchUpdateUserStoryStatus, getTestCases, getUserStories, } from '../../api/features/index.js';
+import { batchDeleteTestCases, batchDeleteUserStories, batchUpdateTestCaseStatus, batchUpdateUserStoryStatus, getTestCases, getUserStories, } from '../../api/issues/index.js';
 import { callMcpEndpoint } from '../../api/mcp-client.js';
 import { logError, logInfo } from '../../utils/logger.js';
 /**
  * Reset ready user stories and test cases to draft for re-analysis
  */
-export async function resetReadyArtifactsToDraft(featureId, verbose) {
+export async function resetReadyArtifactsToDraft(issueId, verbose) {
     const [stories, testCases] = await Promise.all([
-        getUserStories(featureId, false),
-        getTestCases(featureId, false),
+        getUserStories(issueId, false),
+        getTestCases(issueId, false),
     ]);
     const readyStoryIds = stories
         .filter((s) => s.status === 'pending_approval')
@@ -33,12 +33,12 @@ export async function resetReadyArtifactsToDraft(featureId, verbose) {
     };
 }
 /**
- * Get all draft artifact IDs for a feature
+ * Get all draft artifact IDs for an issue
  */
-export async function getAllDraftArtifactIds(featureId, verbose) {
+export async function getAllDraftArtifactIds(issueId, verbose) {
     const [stories, testCases] = await Promise.all([
-        getUserStories(featureId, false),
-        getTestCases(featureId, false),
+        getUserStories(issueId, false),
+        getTestCases(issueId, false),
     ]);
     const userStoryIds = stories
         .filter((s) => s.status === 'draft')
@@ -79,11 +79,11 @@ function isValidUUID(id) {
  * Delete specific artifacts identified by AI during analysis
  * Only deletes artifacts with status 'draft'
  */
-export async function deleteSpecificArtifacts(featureId, deletedUserStoryIds, deletedTestCaseIds, deletionReasons, verbose) {
+export async function deleteSpecificArtifacts(issueId, deletedUserStoryIds, deletedTestCaseIds, deletionReasons, verbose) {
     // Fetch current artifacts to verify their status
     const [currentUserStories, currentTestCases] = await Promise.all([
-        getUserStories(featureId, false),
-        getTestCases(featureId, false),
+        getUserStories(issueId, false),
+        getTestCases(issueId, false),
     ]);
     // Create maps for quick lookup
     const userStoryStatusMap = new Map(currentUserStories.map((story) => [story.id, story.status]));
@@ -163,7 +163,7 @@ export async function updateArtifactsToReady(userStoryIds, testCaseIds, verbose)
 /**
  * Save analysis artifacts as draft and return their IDs
  */
-export async function saveAnalysisArtifactsAsDraft(featureId, createdUserStories, createdTestCases, verbose) {
+export async function saveAnalysisArtifactsAsDraft(issueId, createdUserStories, createdTestCases, verbose) {
     const userStoryIds = [];
     const testCaseIds = [];
     // Save user stories as draft
@@ -173,7 +173,7 @@ export async function saveAnalysisArtifactsAsDraft(featureId, createdUserStories
         }
         try {
             const result = (await callMcpEndpoint('user_stories/create', {
-                feature_id: featureId,
+                issue_id: issueId,
                 user_stories: createdUserStories.map((story) => ({
                     title: story.title,
                     description: story.description,
@@ -198,7 +198,7 @@ export async function saveAnalysisArtifactsAsDraft(featureId, createdUserStories
         }
         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,
@@ -222,14 +222,14 @@ export async function saveAnalysisArtifactsAsDraft(featureId, createdUserStories
 /**
  * Build the final analysis result object
  */
-export function buildAnalysisResult(featureId, context, 
+export function buildAnalysisResult(issueId, context, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 structuredAnalysisResult, currentIteration) {
     const { created_user_stories, created_test_cases, deleted_user_story_ids, deleted_test_case_ids, deletion_reasons, checklist_results, checklist_item_results, } = structuredAnalysisResult;
     return {
-        featureId,
+        issueId,
         productInfo: context.product,
-        featureInfo: context.feature,
+        issueInfo: context.issue,
         existingUserStories: context.existing_user_stories.map((story) => {
             const approvedOrDraft = story.status === 'approved' ? 'approved' : 'draft';
             return {

package/dist/phases/{feature-analysis → issue-analysis}/prompts.d.ts

@@ -1,6 +1,6 @@
-import { type ChecklistVerificationResult } from '../feature-analysis-verification/agent.js';
-export declare const createFeatureAnalysisSystemPrompt: (projectDir?: string) => Promise<string>;
-export declare const createFeatureAnalysisPromptWithContext: (featureId: string, contextInfo: string) => string;
+import { type ChecklistVerificationResult } from '../issue-analysis-verification/agent.js';
+export declare const createIssueAnalysisSystemPrompt: (projectDir?: string) => Promise<string>;
+export declare const createIssueAnalysisPromptWithContext: (issueId: string, contextInfo: string) => string;
 /**
  * Create a prompt for the analysis agent to improve based on verification feedback
  */

package/dist/phases/{feature-analysis → issue-analysis}/prompts.js

@@ -1,14 +1,14 @@
 import { resolveSkill } from '../../services/skill-resolver.js';
 import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export const createFeatureAnalysisSystemPrompt = async (projectDir) => {
-    const skill = await resolveSkill('phase/feature-analysis', { projectDir });
+export const createIssueAnalysisSystemPrompt = async (projectDir) => {
+    const skill = await resolveSkill('phase/issue-analysis', { projectDir });
     if (!skill) {
-        throw new Error('Failed to load skill: phase/feature-analysis');
+        throw new Error('Failed to load skill: phase/issue-analysis');
     }
-    return `${skill.prompt}\n\n${OUTPUT_CONTRACTS['feature-analysis']}`;
+    return `${skill.prompt}\n\n${OUTPUT_CONTRACTS['issue-analysis']}`;
 };
-export const createFeatureAnalysisPromptWithContext = (featureId, contextInfo) => {
-    return `Please conduct comprehensive business analysis for feature ID: ${featureId}
+export const createIssueAnalysisPromptWithContext = (issueId, contextInfo) => {
+    return `Please conduct comprehensive business analysis for issue ID: ${issueId}
 
 ${contextInfo}
 
@@ -16,19 +16,19 @@ ${contextInfo}
 
 Follow this systematic approach:
 
-1. **Review Feature Context**: Analyze the feature information, product context, and technical design above
+1. **Review Issue Context**: Analyze the issue information, product context, and technical design above
 
 2. **Review Existing Items**: Study the existing user stories and test cases to understand:
    - What scenarios are already covered
    - What user perspectives are already addressed
    - Where gaps might exist
 
-3. **Business Analysis**: Think about the feature from a business perspective:
+3. **Business Analysis**: Think about the issue from a business perspective:
    - Who are the different types of users?
-   - What problems does this feature solve?
+   - What problems does this issue solve?
    - What are the different use cases and user workflows?
    - What edge cases and error scenarios might occur?
-   - How does this integrate with other features?
+   - How does this integrate with other issues?
 
 4. **Create New User Stories**: Generate user stories that ADD VALUE by covering:
    - Different user types or personas not yet covered
@@ -52,7 +52,7 @@ Follow this systematic approach:
 - Avoid duplicating existing user stories and test cases
 - Consider different user types (admin, regular user, guest, etc.)
 - Think about accessibility, security, and performance implications
-- The feature should already have some design - you're analyzing business requirements
+- The issue should already have some design - you're analyzing business requirements
 - Be thorough but focus on practical, testable scenarios
 
 Begin your systematic analysis based on the above context.`;
@@ -152,7 +152,7 @@ You MUST return ONLY the JSON object below. Do NOT include any explanatory text,
 \`\`\`json
 {
   "analysis": {
-    "feature_id": "...",
+    "issue_id": "...",
     "status": "success",
     "summary": "Improved analysis based on verification feedback",
     "created_user_stories": [

package/dist/phases/{feature-analysis-verification → issue-analysis-verification}/agent.d.ts

@@ -1,6 +1,6 @@
 import { type ChecklistPhaseContext } from '../../services/checklist.js';
 import { type EdsgerConfig } from '../../types/index.js';
-import { type FeatureAnalysisContext } from '../feature-analysis/context.js';
+import { type IssueAnalysisContext } from '../issue-analysis/context.js';
 export interface ChecklistItemVerificationResult {
     checklist_item_id: string;
     is_satisfied: boolean;
@@ -21,7 +21,7 @@ export interface ChecklistVerificationResult {
 }
 export interface VerifyChecklistOptions {
     checklistContext: ChecklistPhaseContext;
-    analysisContext: FeatureAnalysisContext;
+    analysisContext: IssueAnalysisContext;
     createdUserStories: any[];
     createdTestCases: any[];
     verbose?: boolean;

package/dist/phases/{feature-analysis-verification → issue-analysis-verification}/agent.js

@@ -1,5 +1,5 @@
 /**
- * Checklist verification agent for feature analysis
+ * Checklist verification agent for issue analysis
  * This agent independently reviews checklist compliance to ensure objectivity
  */
 import { query } from '@anthropic-ai/claude-agent-sdk';

package/dist/phases/{feature-analysis-verification → issue-analysis-verification}/index.d.ts

@@ -1,6 +1,6 @@
 import { type ChecklistPhaseContext } from '../../services/checklist.js';
 import { type EdsgerConfig } from '../../types/index.js';
-import { type FeatureAnalysisContext } from '../feature-analysis/context.js';
+import { type IssueAnalysisContext } from '../issue-analysis/context.js';
 import { type ChecklistVerificationResult } from './agent.js';
 interface VerificationCycleResult {
     passed: boolean;
@@ -11,15 +11,15 @@ interface VerificationCycleResult {
  * Perform verification and determine if iteration should continue
  * This function only verifies - it does NOT manage artifacts (save/delete/update)
  */
-export interface FeatureAnalysisVerificationOptions {
+export interface IssueAnalysisVerificationOptions {
     structuredAnalysisResult: Record<string, unknown>;
     checklistContext: ChecklistPhaseContext | null;
-    context: FeatureAnalysisContext;
+    context: IssueAnalysisContext;
     config: EdsgerConfig;
     currentIteration: number;
     maxIterations: number;
-    featureId: string;
+    issueId: string;
     verbose?: boolean;
 }
-export declare function performVerificationCycle(opts: FeatureAnalysisVerificationOptions): Promise<VerificationCycleResult>;
+export declare function performVerificationCycle(opts: IssueAnalysisVerificationOptions): Promise<VerificationCycleResult>;
 export {};

package/dist/phases/{feature-analysis-verification → issue-analysis-verification}/index.js

@@ -1,9 +1,9 @@
-import { logFeatureVerificationEvent } from '../../services/audit-logs.js';
+import { logIssueVerificationEvent } from '../../services/audit-logs.js';
 import { logError, logInfo } from '../../utils/logger.js';
-import { createImprovementPrompt } from '../feature-analysis/prompts.js';
+import { createImprovementPrompt } from '../issue-analysis/prompts.js';
 import { verifyChecklistCompliance, } from './agent.js';
 export async function performVerificationCycle(opts) {
-    const { structuredAnalysisResult, checklistContext, context, config, currentIteration, maxIterations, featureId, verbose, } = opts;
+    const { structuredAnalysisResult, checklistContext, context, config, currentIteration, maxIterations, issueId, verbose, } = opts;
     // No verification needed if no checklist context
     if (!checklistContext || checklistContext.checklists.length === 0) {
         return { passed: true, verificationResult: null };
@@ -28,9 +28,9 @@ export async function performVerificationCycle(opts) {
             logInfo(`✅ Checklist verification passed: ${verificationResult.confirmed_count} confirmed, ${verificationResult.uncertain_count} uncertain`);
         }
         // Log verification success
-        await logFeatureVerificationEvent({
-            featureId,
-            phase: 'feature_analysis',
+        await logIssueVerificationEvent({
+            issueId,
+            phase: 'issue_analysis',
             iteration: currentIteration,
             result: 'success',
             verificationData: {
@@ -45,9 +45,9 @@ export async function performVerificationCycle(opts) {
     // Verification failed
     logError(`❌ Iteration ${currentIteration}: Checklist verification FAILED - ${verificationResult.rejected_count} items rejected, ${verificationResult.uncertain_count} uncertain`);
     // Log verification failure with improvement suggestions
-    await logFeatureVerificationEvent({
-        featureId,
-        phase: 'feature_analysis',
+    await logIssueVerificationEvent({
+        issueId,
+        phase: 'issue_analysis',
         iteration: currentIteration,
         result: 'error',
         verificationData: {

package/dist/phases/{feature-analysis-verification → issue-analysis-verification}/prompts.d.ts

@@ -1,9 +1,9 @@
 import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import { type FeatureAnalysisContext } from '../feature-analysis/context.js';
+import { type IssueAnalysisContext } from '../issue-analysis/context.js';
 export declare const createChecklistVerificationSystemPrompt: (projectDir?: string) => Promise<string>;
 export interface ChecklistVerificationPromptOptions {
     checklistContext: ChecklistPhaseContext;
-    analysisContext: FeatureAnalysisContext;
+    analysisContext: IssueAnalysisContext;
     createdUserStories: any[];
     createdTestCases: any[];
 }

package/dist/phases/{feature-analysis-verification → issue-analysis-verification}/prompts.js

@@ -1,13 +1,13 @@
 import { resolveSkill } from '../../services/skill-resolver.js';
 import { OUTPUT_CONTRACTS } from '../output-contracts.js';
 export const createChecklistVerificationSystemPrompt = async (projectDir) => {
-    const skill = await resolveSkill('phase/feature-analysis-verification', {
+    const skill = await resolveSkill('phase/issue-analysis-verification', {
         projectDir,
     });
     if (!skill) {
-        throw new Error('Failed to load skill: phase/feature-analysis-verification');
+        throw new Error('Failed to load skill: phase/issue-analysis-verification');
     }
-    return `${skill.prompt}\n\n${OUTPUT_CONTRACTS['feature-analysis-verification']}`;
+    return `${skill.prompt}\n\n${OUTPUT_CONTRACTS['issue-analysis-verification']}`;
 };
 export const createChecklistVerificationPrompt = (options) => {
     const { checklistContext, analysisContext, createdUserStories, createdTestCases, } = options;
@@ -43,11 +43,11 @@ export const createChecklistVerificationPrompt = (options) => {
 
 You are verifying that generated artifacts (user stories and test cases) satisfy checklist requirements.
 
-## Feature Context
+## Issue Context
 
-**Feature**: ${analysisContext.feature.name}
-**Feature ID**: ${analysisContext.feature.id}
-**Description**: ${analysisContext.feature.description || 'No description'}
+**Issue**: ${analysisContext.issue.name}
+**Issue ID**: ${analysisContext.issue.id}
+**Description**: ${analysisContext.issue.description || 'No description'}
 **Product**: ${analysisContext.product.name}
 
 ## Generated Artifacts