edsger 0.50.0 → 0.52.0

package/dist/phases/pull-request/creator.js

@@ -1,6 +1,6 @@
 /**
  * Pull Request Creator for the development workflow
- * Creates pull requests from feature branches after successful testing
+ * Creates pull requests from issue branches after successful testing
  */
 import { Octokit } from '@octokit/rest';
 import { execFileSync, execSync } from 'child_process';
@@ -9,7 +9,7 @@ import { logDebug } from '../../utils/logger.js';
 // GitHub PR title best practice: keep under 72 characters
 const MAX_PR_TITLE_LENGTH = 72;
 const PR_TITLE_PREFIX = 'feat: ';
-const MAX_FEATURE_NAME_LENGTH = MAX_PR_TITLE_LENGTH - PR_TITLE_PREFIX.length;
+const MAX_ISSUE_NAME_LENGTH = MAX_PR_TITLE_LENGTH - PR_TITLE_PREFIX.length;
 /**
  * Truncate text to a maximum length, adding ellipsis if truncated
  */
@@ -123,14 +123,14 @@ const switchToMainBranch = (mainBranch = 'main', verbose) => {
     }
 };
 /**
- * Generate pull request title from feature name
+ * Generate pull request title from issue name
  * Truncates to keep under 72 characters (GitHub best practice)
  */
-const generatePRTitle = (featureName) => {
-    // Remove feature ID prefix if present (e.g., "FEAT-123: Feature Name" -> "Feature Name")
-    const cleanName = featureName.replace(/^[A-Z]+-\d+:\s*/, '');
+const generatePRTitle = (issueName) => {
+    // Remove issue ID prefix if present (e.g., "FEAT-123: Issue Name" -> "Issue Name")
+    const cleanName = issueName.replace(/^[A-Z]+-\d+:\s*/, '');
     // Truncate to keep total title under 72 chars
-    const truncatedName = truncateText(cleanName.toLowerCase(), MAX_FEATURE_NAME_LENGTH);
+    const truncatedName = truncateText(cleanName.toLowerCase(), MAX_ISSUE_NAME_LENGTH);
     return `${PR_TITLE_PREFIX}${truncatedName}`;
 };
 const findExistingPullRequest = async (opts) => {
@@ -162,55 +162,55 @@ const findExistingPullRequest = async (opts) => {
     }
 };
 /**
- * Generate pull request body with feature details
+ * Generate pull request body with issue details
  */
-const generatePRBody = (feature) => {
+const generatePRBody = (issue) => {
     const sections = [];
-    // Feature URL section
+    // Issue URL section
     const appUrl = process.env.NEXTAUTH_URL || process.env.APP_URL || 'http://localhost:3000';
-    if (feature.productId) {
-        sections.push('## Feature Details');
-        sections.push(`📋 [View Feature Details](${appUrl}/products/${feature.productId}/features/${feature.id})`);
+    if (issue.productId) {
+        sections.push('## Issue Details');
+        sections.push(`📋 [View Issue Details](${appUrl}/products/${issue.productId}/issues/${issue.id})`);
         sections.push('');
     }
     // Test Report section (if available)
-    if (feature.testReportUrl) {
+    if (issue.testReportUrl) {
         sections.push('## Test Report');
-        sections.push(`🧪 [View Detailed Test Report](${feature.testReportUrl})`);
+        sections.push(`🧪 [View Detailed Test Report](${issue.testReportUrl})`);
         sections.push('');
     }
     // Metadata
     sections.push('---');
-    sections.push(`Feature ID: ${feature.id}`);
+    sections.push(`Issue ID: ${issue.id}`);
     sections.push(`Created by: Automated Workflow`);
     return sections.join('\n');
 };
 /**
- * Create a pull request for the feature
+ * Create a pull request for the issue
  */
-export async function createPullRequest(config, feature) {
+export async function createPullRequest(config, issue) {
     const { githubToken, owner, repo, baseBranch = 'main', verbose } = config;
     try {
         // Initialize Octokit with personal access token
         const octokit = new Octokit({
             auth: githubToken,
         });
-        // Get current branch (should be dev/feature-id)
+        // Get current branch (should be dev/issue-id)
         let currentBranch = getCurrentBranch();
         logDebug(`Current branch: ${currentBranch}`, verbose);
         // If we're on the base branch, switch to dev branch (should already exist)
         // Default behavior now checks remote if not found locally (multi-clone scenario)
         if (currentBranch === baseBranch) {
-            const devBranch = `dev/${feature.id}`;
+            const devBranch = `dev/${issue.id}`;
             logDebug(`Currently on ${baseBranch} branch, switching to ${devBranch}`, verbose);
             switchToBranch(devBranch, verbose, githubToken);
             currentBranch = devBranch;
         }
-        // Extract feature ID from current branch (dev/feature-id)
+        // Extract issue ID from current branch (dev/issue-id)
         let targetBranch = baseBranch;
         if (currentBranch.startsWith('dev/')) {
-            const featureId = currentBranch.replace('dev/', '');
-            targetBranch = `feat/${featureId}`;
+            const issueId = currentBranch.replace('dev/', '');
+            targetBranch = `feat/${issueId}`;
             // Create the feat/ branch from base branch (main)
             logDebug(`Creating target branch: ${targetBranch} from ${baseBranch}`, verbose);
             try {
@@ -259,8 +259,8 @@ export async function createPullRequest(config, feature) {
             }
         }
         // Generate PR title and body
-        const title = generatePRTitle(feature.name);
-        const body = generatePRBody(feature);
+        const title = generatePRTitle(issue.name);
+        const body = generatePRBody(issue);
         // Check if PR already exists
         const existingPR = await findExistingPullRequest({
             octokit,

package/dist/phases/pull-request/handler.d.ts

@@ -3,13 +3,13 @@
  */
 import { type PipelineResult } from '../../types/pipeline.js';
 export interface PullRequestHandlerOptions {
-    featureId: string;
+    issueId: string;
     results: readonly PipelineResult[];
     testingResult?: PipelineResult;
     verbose?: boolean;
 }
 /**
- * Create pull request for successful feature implementation
+ * Create pull request for successful issue implementation
  * Returns true if PR was successfully created, false otherwise
  */
-export declare function handlePullRequestCreation({ featureId, results, testingResult, verbose, }: PullRequestHandlerOptions): Promise<boolean>;
+export declare function handlePullRequestCreation({ issueId, results, testingResult, verbose, }: PullRequestHandlerOptions): Promise<boolean>;

package/dist/phases/pull-request/handler.js

@@ -1,31 +1,31 @@
 /**
  * Pull request creation handler for pipeline execution
  */
-import { getFeature } from '../../api/features/index.js';
 import { getGitHubConfig } from '../../api/github.js';
+import { getIssue } from '../../api/issues/index.js';
 import { getCurrentBranch, updateBranch, } from '../../services/branches.js';
 import { logDebug } from '../../utils/logger.js';
 import { createPullRequest } from './creator.js';
 /**
- * Create pull request for successful feature implementation
+ * Create pull request for successful issue implementation
  * Returns true if PR was successfully created, false otherwise
  */
 // eslint-disable-next-line complexity -- orchestration function with branch detection, PR creation, and status updates
-export async function handlePullRequestCreation({ featureId, results, testingResult, verbose, }) {
-    logDebug('Creating pull request for successful feature...', verbose);
-    // Get feature details for PR creation
-    const feature = await getFeature(featureId, verbose);
-    if (!feature) {
-        logDebug('Could not fetch feature details for pull request creation', verbose);
+export async function handlePullRequestCreation({ issueId, results, testingResult, verbose, }) {
+    logDebug('Creating pull request for successful issue...', verbose);
+    // Get issue details for PR creation
+    const issue = await getIssue(issueId, verbose);
+    if (!issue) {
+        logDebug('Could not fetch issue details for pull request creation', verbose);
         return false;
     }
-    // Get current branch for the feature
+    // Get current branch for the issue
     let currentBranch = null;
     try {
-        currentBranch = await getCurrentBranch({ featureId, verbose });
+        currentBranch = await getCurrentBranch({ issueId, verbose });
     }
     catch (error) {
-        logDebug(`Could not fetch branch for feature: ${error}`, verbose);
+        logDebug(`Could not fetch branch for issue: ${error}`, verbose);
     }
     // Check if PR already exists on the branch
     if (currentBranch?.pull_request_url) {
@@ -34,7 +34,7 @@ export async function handlePullRequestCreation({ featureId, results, testingRes
         return true;
     }
     // Get GitHub configuration from product developer settings
-    const githubConfig = await getGitHubConfig(featureId, verbose);
+    const githubConfig = await getGitHubConfig(issueId, verbose);
     if (!githubConfig.configured ||
         !githubConfig.token ||
         !githubConfig.owner ||
@@ -52,10 +52,10 @@ export async function handlePullRequestCreation({ featureId, results, testingRes
         baseBranch: 'main',
         verbose,
     }, {
-        id: feature.id,
-        name: feature.name,
-        description: feature.description || '',
-        productId: feature.product_id,
+        id: issue.id,
+        name: issue.name,
+        description: issue.description || '',
+        productId: issue.product_id,
         // Get technical design and test result from previous phases (if available)
         technicalDesign: results.find((r) => r.phase === 'technical-design')?.data?.technicalDesign,
         testResult: testingResult

package/dist/phases/release-sync/index.js

@@ -8,7 +8,7 @@
 import { getGitHubConfigByProduct } from '../../api/github.js';
 import { getReleaseByTag, upsertRelease, } from '../../api/releases.js';
 import { logInfo, logSuccess, logWarning } from '../../utils/logger.js';
-import { cloneFeatureRepo, ensureWorkspaceDir, syncRepoToRef, } from '../../workspace/workspace-manager.js';
+import { cloneIssueRepo, ensureWorkspaceDir, syncRepoToRef, } from '../../workspace/workspace-manager.js';
 import { fetchLatestTwoReleases, getDefaultBranchHead, } from './github.js';
 import { detectSnapshotVersion, isPlausibleSnapshotTag } from './snapshot.js';
 /**
@@ -95,7 +95,7 @@ export async function runReleaseSync(options, _config) {
     let cwd;
     try {
         const workspaceRoot = ensureWorkspaceDir();
-        const { repoPath } = cloneFeatureRepo(workspaceRoot, `release-sync-${productId}`, gh.owner, gh.repo, gh.token);
+        const { repoPath } = cloneIssueRepo(workspaceRoot, `release-sync-${productId}`, gh.owner, gh.repo, gh.token);
         cwd = repoPath;
     }
     catch (err) {

package/dist/phases/run-sheet/agent.js

@@ -34,7 +34,7 @@ Bash safety rules (strict):
 Output rules:
 1. Output ONLY the final run-sheet Markdown. No preamble ("Here is..."), no trailing commentary, no wrapping code fence around the whole document.
 2. Follow the structure of the TEMPLATE exactly — same section headings in the same order. If the template is free-form prose, infer sensible sections from it.
-3. Ground every claim in the repo. Do not invent features, APIs, or risks that are not evidenced by the diff or code.
+3. Ground every claim in the repo. Do not invent issues, APIs, or risks that are not evidenced by the diff or code.
 4. If the release is marked DRAFT, include a short "Draft" note near the top explaining the tag is not yet cut.
 5. Prefer concise bullet points over long paragraphs for actionable items. Aim for under 600 lines of Markdown total — be specific, not exhaustive.
 6. If the diff is empty or there is no previous ref to compare against, state that plainly rather than fabricating content.`;
@@ -96,7 +96,6 @@ function summariseToolUse(name, input, turn) {
     const desc = typeof descRaw === 'string' ? descRaw : 'Running...';
     return `[Turn ${turn}] ${name}: ${desc.slice(0, 160)}`;
 }
-// eslint-disable-next-line complexity -- agent loop with message type handling
 export async function generateRunSheetWithAgent(input) {
     const { repoDir } = input;
     let assistantText = '';

package/dist/phases/run-sheet/index.js

@@ -18,7 +18,7 @@ import { getProduct } from '../../api/products.js';
 import { getRelease } from '../../api/releases.js';
 import { getRunSheetByRelease, upsertRunSheet, } from '../../api/run-sheets.js';
 import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { cloneFeatureRepo, ensureWorkspaceDir, getFeatureRepoPath, isSafeGitRef, syncRepoToRef, } from '../../workspace/workspace-manager.js';
+import { cloneIssueRepo, ensureWorkspaceDir, getIssueRepoPath, isSafeGitRef, syncRepoToRef, } from '../../workspace/workspace-manager.js';
 import { getDefaultBranchHead } from '../release-sync/github.js';
 import { generateRunSheetWithAgent } from './agent.js';
 // Stale locks (e.g. left behind by a crashed or SIGKILLed CLI) are
@@ -261,7 +261,7 @@ export async function runRunSheet(options) {
             logInfo(`Pruned ${pruned.removed.length} stale run-sheet workspace(s).`);
         }
         const workspaceName = `run-sheet-${release.id}`;
-        const repoPathAhead = getFeatureRepoPath(workspaceRoot, workspaceName);
+        const repoPathAhead = getIssueRepoPath(workspaceRoot, workspaceName);
         lockPath = `${repoPathAhead}.lock`;
         if (!tryAcquireFileLock(lockPath)) {
             return {
@@ -272,7 +272,7 @@ export async function runRunSheet(options) {
             };
         }
         try {
-            const { repoPath } = cloneFeatureRepo(workspaceRoot, workspaceName, owner, repo, token);
+            const { repoPath } = cloneIssueRepo(workspaceRoot, workspaceName, owner, repo, token);
             repoDir = repoPath;
             // SNAPSHOT releases have no GitHub release object backing them, so
             // `published_at` is null. Use that as a free local signal to skip

package/dist/phases/smoke-test/index.js

@@ -10,7 +10,7 @@ import { getProduct } from '../../api/products.js';
 import { clearReleaseTestCases, createReleaseTestCases, } from '../../api/release-test-cases.js';
 import { getRelease, updateRelease } from '../../api/releases.js';
 import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { cloneFeatureRepo, ensureWorkspaceDir, syncRepoToRef, } from '../../workspace/workspace-manager.js';
+import { cloneIssueRepo, ensureWorkspaceDir, syncRepoToRef, } from '../../workspace/workspace-manager.js';
 import { buildDiffDigest, fetchCompare, getDefaultBranchHead, summariseStats, } from '../release-sync/github.js';
 import { executeSmokeTestQuery } from './agent.js';
 import { buildSmokeTestUserPrompt, createSmokeTestSystemPrompt, } from './prompts.js';
@@ -104,7 +104,7 @@ async function runSmokeTestInner(ctx) {
     let cwd;
     try {
         const workspaceRoot = ensureWorkspaceDir();
-        const { repoPath } = cloneFeatureRepo(workspaceRoot, `release-${release.product_id}`, ghResolved.owner, ghResolved.repo, ghResolved.token);
+        const { repoPath } = cloneIssueRepo(workspaceRoot, `release-${release.product_id}`, ghResolved.owner, ghResolved.repo, ghResolved.token);
         cwd = repoPath;
     }
     catch (err) {

package/dist/phases/technical-design/context.d.ts

@@ -1,7 +1,7 @@
 import { type ProductInfo } from '../../api/products.js';
-import type { FeatureInfo, TestCase, UserStory } from '../../types/features.js';
+import type { IssueInfo, TestCase, UserStory } from '../../types/issues.js';
 export interface TechnicalDesignContext {
-    feature: FeatureInfo;
+    issue: IssueInfo;
     product: ProductInfo;
     user_stories: UserStory[];
     test_cases: TestCase[];
@@ -9,4 +9,4 @@ export interface TechnicalDesignContext {
 /**
  * Fetch all technical design context information via MCP endpoints
  */
-export declare function fetchTechnicalDesignContext(featureId: string, verbose?: boolean): Promise<TechnicalDesignContext>;
+export declare function fetchTechnicalDesignContext(issueId: string, verbose?: boolean): Promise<TechnicalDesignContext>;

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

@@ -1,31 +1,31 @@
-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 { logError, logInfo } from '../../utils/logger.js';
 /**
  * Fetch all technical design context information via MCP endpoints
  */
-export async function fetchTechnicalDesignContext(featureId, verbose) {
+export async function fetchTechnicalDesignContext(issueId, verbose) {
     try {
         if (verbose) {
-            logInfo(`Fetching complete technical design context for feature: ${featureId}`);
+            logInfo(`Fetching complete technical design context for issue: ${issueId}`);
         }
         // Fetch all required data in parallel for better performance
-        const [feature, userStories, testCases] = await Promise.all([
-            getFeature(featureId, verbose),
-            getUserStories(featureId, verbose),
-            getTestCases(featureId, verbose),
+        const [issue, userStories, testCases] = 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(`✅ Technical design context fetched successfully:`);
-            logInfo(`   Feature: ${feature.name}`);
+            logInfo(`   Issue: ${issue.name}`);
             logInfo(`   Product: ${product.name}`);
             logInfo(`   User Stories: ${userStories.length}`);
             logInfo(`   Test Cases: ${testCases.length} (${testCases.filter((tc) => tc.is_critical).length} critical)`);
-            logInfo(`   Existing Technical Design: ${feature.technical_design ? 'Yes' : 'No'}`);
+            logInfo(`   Existing Technical Design: ${issue.technical_design ? 'Yes' : 'No'}`);
         }
         return {
-            feature,
+            issue,
             product,
             user_stories: userStories,
             test_cases: testCases,

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

@@ -1,12 +1,12 @@
 import { type ChecklistPhaseContext } from '../../services/checklist.js';
 import { type ChecklistItemResult, type EdsgerConfig, type VerificationResult } from '../../types/index.js';
 export interface TechnicalDesignOptions {
-    featureId: string;
+    issueId: string;
     verbose?: boolean;
     maxVerificationIterations?: number;
 }
 export interface TechnicalDesignResult {
-    featureId: string;
+    issueId: string;
     technicalDesign: string | null;
     status: 'success' | 'error';
     summary: string;

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

@@ -1,7 +1,7 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
-import { updateTechnicalDesign } from '../../api/features/index.js';
+import { updateTechnicalDesign } 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 { formatChecklistsForContext, } from '../../services/checklist.js';
 import { extractChecklistItems, runPhaseCoaching, } from '../../services/coaching/index.js';
 import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services/feedbacks.js';
@@ -26,14 +26,14 @@ async function* prompt(analysisPrompt) {
 }
 // eslint-disable-next-line complexity
 export const generateTechnicalDesign = async (options, config, checklistContext) => {
-    const { featureId, verbose } = options;
+    const { issueId, verbose } = options;
     if (verbose) {
-        logInfo(`Starting technical design generation for feature ID: ${featureId}`);
+        logInfo(`Starting technical design generation for issue ID: ${issueId}`);
     }
     try {
         // Fetch and prepare context
-        const context = await prepareDesignContext(featureId, checklistContext, verbose);
-        const systemPrompt = await createTechnicalDesignSystemPrompt(config, featureId);
+        const context = await prepareDesignContext(issueId, checklistContext, verbose);
+        const systemPrompt = await createTechnicalDesignSystemPrompt(config, issueId);
         const initialDesignPrompt = context.designPrompt;
         const maxIterations = options.maxVerificationIterations || 10;
         let currentIteration = 0;
@@ -53,8 +53,8 @@ export const generateTechnicalDesign = 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: 'technical_design',
                     result: 'info',
@@ -80,8 +80,8 @@ export const generateTechnicalDesign = async (options, config, checklistContext)
             // Update with new design result
             structuredDesignResult = queryResult.data;
             // Log design completion for this iteration
-            await logFeaturePhaseEvent({
-                featureId,
+            await logIssuePhaseEvent({
+                issueId,
                 eventType: 'phase_completed',
                 phase: 'technical_design',
                 result: 'success',
@@ -97,10 +97,10 @@ export const generateTechnicalDesign = async (options, config, checklistContext)
             if (verbose) {
                 logInfo(`💾 Saving technical design (iteration ${currentIteration})...`);
             }
-            await updateTechnicalDesign(featureId, structuredDesignResult.technical_design, verbose);
+            await updateTechnicalDesign(issueId, structuredDesignResult.technical_design, verbose);
             // Coaching loop: self-rate → coach → improve → repeat (between execute and verify)
             const coaching = await runPhaseCoaching({
-                featureId,
+                issueId,
                 phase: 'technical_design',
                 phaseResult: { execution_session_id: executionSessionId },
                 checklistItems: extractChecklistItems(checklistContext),
@@ -114,7 +114,7 @@ export const generateTechnicalDesign = async (options, config, checklistContext)
                         if (design && typeof design === 'string') {
                             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                             structuredDesignResult.technical_design = design;
-                            await updateTechnicalDesign(featureId, design, verbose);
+                            await updateTechnicalDesign(issueId, design, verbose);
                         }
                         else {
                             logError('Coaching improvement response missing technical_design field. Keeping previous design.');
@@ -132,9 +132,9 @@ export const generateTechnicalDesign = async (options, config, checklistContext)
                 technicalDesign: structuredDesignResult.technical_design,
                 checklistContext: checklistContext || null,
                 feedbacksContext: context.feedbacksContext,
-                featureId,
-                featureName: context.featureName,
-                featureDescription: context.featureDescription,
+                issueId,
+                issueName: context.issueName,
+                issueDescription: context.issueDescription,
                 config,
                 currentIteration,
                 maxIterations,
@@ -174,7 +174,7 @@ export const generateTechnicalDesign = async (options, config, checklistContext)
         }
         // Handle results
         if (!structuredDesignResult?.technical_design) {
-            return buildNoResultsError(featureId);
+            return buildNoResultsError(issueId);
         }
         // Check if verification failed after all iterations
         if (verificationResult &&
@@ -183,10 +183,10 @@ export const generateTechnicalDesign = async (options, config, checklistContext)
             checklistContext.checklists.length > 0) {
             logError(`❌ Final result: Checklist verification FAILED after ${currentIteration} iterations`);
             logError(`   Technical design saved for manual review`);
-            return buildVerificationFailureResult(featureId, structuredDesignResult.technical_design, verificationResult, currentIteration);
+            return buildVerificationFailureResult(issueId, structuredDesignResult.technical_design, verificationResult, currentIteration);
         }
         // Return success result with session ID for coaching at phase-executor level
-        const result = buildDesignResult(featureId, structuredDesignResult.technical_design, structuredDesignResult.summary ||
+        const result = buildDesignResult(issueId, structuredDesignResult.technical_design, structuredDesignResult.summary ||
             'Technical design generated successfully', currentIteration);
         return {
             ...result,
@@ -199,7 +199,7 @@ export const generateTechnicalDesign = async (options, config, checklistContext)
     catch (error) {
         logError(`Technical design generation failed: ${error instanceof Error ? error.message : String(error)}`);
         return {
-            featureId,
+            issueId,
             technicalDesign: null,
             status: 'error',
             summary: `Generation failed: ${error instanceof Error ? error.message : String(error)}`,
@@ -210,11 +210,11 @@ export const generateTechnicalDesign = async (options, config, checklistContext)
  * Prepare all context information needed for design
  */
 // eslint-disable-next-line complexity -- assembles context from many data sources with fallback handling
-async function prepareDesignContext(featureId, checklistContext, verbose) {
+async function prepareDesignContext(issueId, checklistContext, verbose) {
     if (verbose) {
         logInfo('Fetching technical design context via MCP endpoints...');
     }
-    const context = await fetchTechnicalDesignContext(featureId, verbose);
+    const context = await fetchTechnicalDesignContext(issueId, verbose);
     const { content: contextInfo, downloadedImages } = await formatTechnicalDesignContext(context);
     if (verbose && downloadedImages.length > 0) {
         logInfo(`Downloaded ${downloadedImages.length} images for Claude Code:`);
@@ -226,7 +226,7 @@ async function prepareDesignContext(featureId, checklistContext, verbose) {
     let hasFeedbacks = false;
     let feedbacksContext = null;
     // Check if there's existing technical design
-    const existingTechnicalDesign = context.feature.technical_design;
+    const existingTechnicalDesign = context.issue.technical_design;
     const hasExistingDesign = !!existingTechnicalDesign && existingTechnicalDesign.trim().length > 0;
     // Add existing technical design to context if it exists
     if (hasExistingDesign && verbose) {
@@ -234,7 +234,7 @@ async function prepareDesignContext(featureId, checklistContext, verbose) {
     }
     // Add feedbacks context to the design prompt
     try {
-        feedbacksContext = await getFeedbacksForPhase({ featureId, verbose }, 'technical-design');
+        feedbacksContext = await getFeedbacksForPhase({ issueId, verbose }, 'technical-design');
         if (verbose) {
             logInfo(`📋 Feedbacks fetched successfully: ${feedbacksContext.feedbacks.length} feedbacks found`);
             if (feedbacksContext.feedbacks.length > 0) {
@@ -311,10 +311,10 @@ async function prepareDesignContext(featureId, checklistContext, verbose) {
             });
         }
     }
-    const designPrompt = createTechnicalDesignPromptWithContext(featureId, finalContextInfo, existingTechnicalDesign, isIncrementalUpdate);
+    const designPrompt = createTechnicalDesignPromptWithContext(issueId, finalContextInfo, existingTechnicalDesign, isIncrementalUpdate);
     return {
-        featureName: context.feature.name,
-        featureDescription: context.feature.description || undefined,
+        issueName: context.issue.name,
+        issueDescription: context.issue.description || undefined,
         designPrompt,
         hasExistingDesign,
         hasFeedbacks,

package/dist/phases/technical-design/outcome.d.ts

@@ -1,6 +1,6 @@
 import { type ChecklistVerificationResult } from '../technical-design-verification/agent.js';
 export interface TechnicalDesignResult {
-    featureId: string;
+    issueId: string;
     technicalDesign: string | null;
     status: 'success' | 'error';
     summary: string;
@@ -14,12 +14,12 @@ export interface TechnicalDesignResult {
 /**
  * Build successful design result
  */
-export declare function buildDesignResult(featureId: string, technicalDesign: string, summary: string, iterations: number, checklistItemResults?: any[]): TechnicalDesignResult;
+export declare function buildDesignResult(issueId: string, technicalDesign: string, summary: string, iterations: number, checklistItemResults?: any[]): TechnicalDesignResult;
 /**
  * Build verification failure result
  */
-export declare function buildVerificationFailureResult(featureId: string, technicalDesign: string, verificationResult: ChecklistVerificationResult, iterations: number): TechnicalDesignResult;
+export declare function buildVerificationFailureResult(issueId: string, technicalDesign: string, verificationResult: ChecklistVerificationResult, iterations: number): TechnicalDesignResult;
 /**
  * Build error result when no design was generated
  */
-export declare function buildNoResultsError(featureId: string): TechnicalDesignResult;
+export declare function buildNoResultsError(issueId: string): TechnicalDesignResult;

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

@@ -1,11 +1,11 @@
 /**
  * Build successful design result
  */
-export function buildDesignResult(featureId, technicalDesign, summary, iterations, 
+export function buildDesignResult(issueId, technicalDesign, summary, iterations, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 checklistItemResults) {
     return {
-        featureId,
+        issueId,
         technicalDesign,
         status: 'success',
         summary,
@@ -18,9 +18,9 @@ checklistItemResults) {
 /**
  * Build verification failure result
  */
-export function buildVerificationFailureResult(featureId, technicalDesign, verificationResult, iterations) {
+export function buildVerificationFailureResult(issueId, technicalDesign, verificationResult, iterations) {
     return {
-        featureId,
+        issueId,
         technicalDesign,
         status: 'error',
         summary: `Checklist verification failed after ${iterations} iterations: ${verificationResult.summary}`,
@@ -31,9 +31,9 @@ export function buildVerificationFailureResult(featureId, technicalDesign, verif
 /**
  * Build error result when no design was generated
  */
-export function buildNoResultsError(featureId) {
+export function buildNoResultsError(issueId) {
     return {
-        featureId,
+        issueId,
         technicalDesign: null,
         status: 'error',
         summary: 'Failed to generate technical design - no valid result received',

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

@@ -1,7 +1,7 @@
 import { type EdsgerConfig } from '../../types/index.js';
 import { type ChecklistVerificationResult } from '../technical-design-verification/agent.js';
-export declare const createTechnicalDesignSystemPrompt: (_config: EdsgerConfig, mcpServerUrl?: string, mcpToken?: string, featureId?: string, projectDir?: string) => Promise<string>;
-export declare const createTechnicalDesignPromptWithContext: (featureId: string, contextInfo: string, existingTechnicalDesign?: string | null, isIncrementalUpdate?: boolean) => string;
+export declare const createTechnicalDesignSystemPrompt: (_config: EdsgerConfig, mcpServerUrl?: string, mcpToken?: string, issueId?: string, projectDir?: string) => Promise<string>;
+export declare const createTechnicalDesignPromptWithContext: (issueId: string, contextInfo: string, existingTechnicalDesign?: string | null, isIncrementalUpdate?: boolean) => string;
 /**
  * Create a prompt for the technical design agent to improve based on verification feedback
  */