edsger 0.50.0 → 0.52.0

package/dist/phases/autonomous/index.js

@@ -2,15 +2,15 @@
  * Autonomous Development Phase
  *
  * Runs a time-limited loop where Claude Code SDK analyzes the codebase,
- * decides the next actionable step toward the feature's objective (description),
+ * decides the next actionable step toward the issue's objective (description),
  * implements it, and commits. All iterations build on the same branch.
  * A PR is created after the first iteration; subsequent pushes update it.
  */
 import { query } from '@anthropic-ai/claude-agent-sdk';
-import { getFeature } from '../../api/features/get-feature.js';
 import { getGitHubConfig } from '../../api/github.js';
+import { getIssue } from '../../api/issues/get-issue.js';
 import { DEFAULT_MODEL } from '../../constants.js';
-import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
+import { logIssuePhaseEvent } from '../../services/audit-logs.js';
 import { createBranches, getCurrentBranch, updateBranch, } from '../../services/branches.js';
 import { prepareCustomBranchGitEnvironmentAsync, resetUncommittedChanges, } from '../../utils/git-branch-manager.js';
 import { gitPush } from '../../utils/git-push.js';
@@ -55,9 +55,9 @@ async function* prompt(userPrompt) {
 /**
  * Run a single autonomous iteration using Claude Code SDK
  */
-async function runIteration(featureId, featureDescription, config, verbose) {
-    const systemPrompt = await createAutonomousSystemPrompt(featureId);
-    const userPromptText = createAutonomousUserPrompt(featureDescription);
+async function runIteration(issueId, issueDescription, config, verbose) {
+    const systemPrompt = await createAutonomousSystemPrompt(issueId);
+    const userPromptText = createAutonomousUserPrompt(issueDescription);
     let lastAssistantResponse = '';
     for await (const message of query({
         prompt: prompt(userPromptText),
@@ -128,9 +128,9 @@ function parseIterationResult(responseText) {
  * Handle a successful iteration: push, create PR, and log
  */
 async function handleSuccessfulIteration(opts) {
-    const { featureId, devBranchName, currentBranch, iterationResult, totalIterations, iterationDuration, startTime, endTime, existingPrUrl, verbose, } = opts;
+    const { issueId, devBranchName, currentBranch, iterationResult, totalIterations, iterationDuration, startTime, endTime, existingPrUrl, verbose, } = opts;
     // Get GitHub config for push authentication and PR creation
-    const githubConfig = await getGitHubConfig(featureId, verbose);
+    const githubConfig = await getGitHubConfig(issueId, verbose);
     // Push to remote with authentication
     const pushResult = gitPush({
         branchName: devBranchName,
@@ -148,8 +148,8 @@ async function handleSuccessfulIteration(opts) {
         ({ prUrl, prNumber } = prInfo);
     }
     // Log iteration completion to audit logs
-    await logFeaturePhaseEvent({
-        featureId,
+    await logIssuePhaseEvent({
+        issueId,
         eventType: 'autonomous_iteration_completed',
         phase: 'autonomous',
         result: 'success',
@@ -207,7 +207,7 @@ githubConfig, devBranchName, currentBranch, verbose) {
  * Handle a failed iteration: reset and log
  */
 async function handleFailedIteration(opts) {
-    const { featureId, totalIterations, iterationDuration, startTime, endTime, verbose, } = opts;
+    const { issueId, totalIterations, iterationDuration, startTime, endTime, verbose, } = opts;
     logError(`❌ Iteration ${totalIterations} failed`);
     try {
         resetUncommittedChanges(verbose);
@@ -215,8 +215,8 @@ async function handleFailedIteration(opts) {
     catch {
         // Ignore cleanup errors
     }
-    await logFeaturePhaseEvent({
-        featureId,
+    await logIssuePhaseEvent({
+        issueId,
         eventType: 'autonomous_iteration_failed',
         phase: 'autonomous',
         result: 'error',
@@ -235,27 +235,27 @@ async function handleFailedIteration(opts) {
  */
 // eslint-disable-next-line complexity -- orchestration function coordinating autonomous development lifecycle
 export async function runAutonomousDevelopment(options, config, _checklistContext) {
-    const { featureId, verbose } = options;
+    const { issueId, verbose } = options;
     const startTime = Date.now();
-    logInfo(`\n🤖 Starting autonomous development for feature: ${featureId}`);
-    // 1. Fetch feature info to get description (= objective) and autonomous_hours
-    const feature = await getFeature(featureId, verbose);
-    const featureDescription = feature.description || '';
-    const autonomousHours = feature.autonomous_hours || 4;
-    if (!featureDescription) {
+    logInfo(`\n🤖 Starting autonomous development for issue: ${issueId}`);
+    // 1. Fetch issue info to get description (= objective) and autonomous_hours
+    const issue = await getIssue(issueId, verbose);
+    const issueDescription = issue.description || '';
+    const autonomousHours = issue.autonomous_hours || 4;
+    if (!issueDescription) {
         return {
-            featureId,
+            issueId,
             status: 'error',
-            message: 'Feature description is required for autonomous mode (it serves as the objective)',
+            message: 'Issue description is required for autonomous mode (it serves as the objective)',
         };
     }
     const endTime = startTime + autonomousHours * 3600000;
     logInfo(`⏰ Autonomous mode will run for ${autonomousHours} hour(s)`);
-    logInfo(`🎯 Objective: ${truncateText(featureDescription.replace(/<[^>]*>/g, ''), 200)}`);
+    logInfo(`🎯 Objective: ${truncateText(issueDescription.replace(/<[^>]*>/g, ''), 200)}`);
     // 2. Get or create branch
     let currentBranch = null;
     try {
-        currentBranch = await getCurrentBranch({ featureId, verbose });
+        currentBranch = await getCurrentBranch({ issueId, verbose });
     }
     catch {
         if (verbose) {
@@ -263,12 +263,12 @@ export async function runAutonomousDevelopment(options, config, _checklistContex
         }
     }
     if (!currentBranch) {
-        const featureName = truncateText(feature.name || 'Autonomous Development', 100);
-        const defaultBranchName = `dev/${featureId}`;
-        const createdBranches = await createBranches({ featureId, verbose }, [
+        const issueName = truncateText(issue.name || 'Autonomous Development', 100);
+        const defaultBranchName = `dev/${issueId}`;
+        const createdBranches = await createBranches({ issueId, verbose }, [
             {
-                name: featureName,
-                description: `Autonomous development branch for: ${featureName}`,
+                name: issueName,
+                description: `Autonomous development branch for: ${issueName}`,
                 branch_name: defaultBranchName,
                 status: 'pending',
             },
@@ -282,12 +282,12 @@ export async function runAutonomousDevelopment(options, config, _checklistContex
     }
     if (!currentBranch) {
         return {
-            featureId,
+            issueId,
             status: 'error',
             message: 'Failed to create or find a branch for autonomous development',
         };
     }
-    const devBranchName = currentBranch.branch_name || `dev/${featureId}`;
+    const devBranchName = currentBranch.branch_name || `dev/${issueId}`;
     // 3. Update branch status to in_progress
     if (currentBranch.status === 'pending') {
         try {
@@ -301,7 +301,7 @@ export async function runAutonomousDevelopment(options, config, _checklistContex
     }
     // 4. Prepare git environment (checkout branch + rebase with main)
     const { cleanup: cleanupGit } = await prepareCustomBranchGitEnvironmentAsync({
-        featureBranch: devBranchName,
+        issueBranch: devBranchName,
         baseBranch: 'main',
         verbose,
         resolveConflicts: true,
@@ -319,13 +319,13 @@ export async function runAutonomousDevelopment(options, config, _checklistContex
             const iterationStart = Date.now();
             logInfo(`\n${'='.repeat(60)}\n🔄 Autonomous iteration ${totalIterations}\n${'='.repeat(60)}`);
             // Run iteration
-            const iterationResult = await runIteration(featureId, featureDescription, config, verbose);
+            const iterationResult = await runIteration(issueId, issueDescription, config, verbose);
             const iterationDuration = Date.now() - iterationStart;
             logInfo(`⏱️  Iteration ${totalIterations} took ${(iterationDuration / 1000).toFixed(0)}s`);
             if (iterationResult.success) {
                 logInfo(`✅ Iteration ${totalIterations}: ${iterationResult.summary || 'completed'}`);
                 const prInfo = await handleSuccessfulIteration({
-                    featureId,
+                    issueId,
                     devBranchName,
                     currentBranch,
                     iterationResult,
@@ -341,7 +341,7 @@ export async function runAutonomousDevelopment(options, config, _checklistContex
             }
             else {
                 await handleFailedIteration({
-                    featureId,
+                    issueId,
                     totalIterations,
                     iterationDuration,
                     startTime,
@@ -382,7 +382,7 @@ export async function runAutonomousDevelopment(options, config, _checklistContex
         }
         logInfo(`${'='.repeat(60)}\n`);
         return {
-            featureId,
+            issueId,
             status: 'success',
             message: `Autonomous development completed: ${totalIterations} iterations in ${elapsedHours.toFixed(2)} hours`,
             branchName: devBranchName,
@@ -395,7 +395,7 @@ export async function runAutonomousDevelopment(options, config, _checklistContex
         const elapsedHours = (Date.now() - startTime) / 3600000;
         logError(`Autonomous development failed: ${error instanceof Error ? error.message : String(error)}`);
         return {
-            featureId,
+            issueId,
             status: 'error',
             message: `Autonomous development failed: ${error instanceof Error ? error.message : String(error)}`,
             branchName: devBranchName,

package/dist/phases/autonomous/prompts.d.ts

@@ -1,5 +1,5 @@
 /**
  * Prompts for the autonomous development phase
  */
-export declare const createAutonomousSystemPrompt: (featureId: string, projectDir?: string) => Promise<string>;
-export declare function createAutonomousUserPrompt(featureDescription: string): string;
+export declare const createAutonomousSystemPrompt: (issueId: string, projectDir?: string) => Promise<string>;
+export declare function createAutonomousUserPrompt(issueDescription: string): string;

package/dist/phases/autonomous/prompts.js

@@ -3,7 +3,7 @@
  */
 import { resolveSkill, substituteVariables, } from '../../services/skill-resolver.js';
 import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export const createAutonomousSystemPrompt = async (featureId, projectDir) => {
+export const createAutonomousSystemPrompt = async (issueId, projectDir) => {
     const skill = await resolveSkill('phase/autonomous', {
         projectDir,
     });
@@ -11,15 +11,15 @@ export const createAutonomousSystemPrompt = async (featureId, projectDir) => {
         throw new Error('Failed to load skill: phase/autonomous');
     }
     let { prompt } = skill;
-    prompt = substituteVariables(prompt, { FEATURE_ID: featureId });
+    prompt = substituteVariables(prompt, { ISSUE_ID: issueId });
     return `${prompt}
 
 ${OUTPUT_CONTRACTS['autonomous']}`;
 };
-export function createAutonomousUserPrompt(featureDescription) {
+export function createAutonomousUserPrompt(issueDescription) {
     return `## Objective
 
-${featureDescription}
+${issueDescription}
 
 ## Instructions
 

package/dist/phases/branch-planning/context.d.ts

@@ -1,8 +1,8 @@
 import { type ProductInfo } from '../../api/products.js';
 import { type Branch } from '../../services/branches.js';
-import type { FeatureInfo, TestCase, UserStory } from '../../types/features.js';
+import type { IssueInfo, TestCase, UserStory } from '../../types/issues.js';
 export interface BranchPlanningContext {
-    feature: FeatureInfo;
+    issue: IssueInfo;
     product: ProductInfo;
     user_stories: UserStory[];
     test_cases: TestCase[];
@@ -11,4 +11,4 @@ export interface BranchPlanningContext {
 /**
  * Fetch all context information needed for branch planning via MCP endpoints
  */
-export declare function fetchBranchPlanningContext(featureId: string, verbose?: boolean): Promise<BranchPlanningContext>;
+export declare function fetchBranchPlanningContext(issueId: string, verbose?: boolean): Promise<BranchPlanningContext>;

package/dist/phases/branch-planning/context.js

@@ -1,34 +1,34 @@
-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 { getBranches } from '../../services/branches.js';
 import { logError, logInfo } from '../../utils/logger.js';
 /**
  * Fetch all context information needed for branch planning via MCP endpoints
  */
-export async function fetchBranchPlanningContext(featureId, verbose) {
+export async function fetchBranchPlanningContext(issueId, verbose) {
     try {
         if (verbose) {
-            logInfo(`Fetching branch planning context for feature: ${featureId}`);
+            logInfo(`Fetching branch planning context for issue: ${issueId}`);
         }
         // Fetch all required data in parallel for better performance
-        const [feature, userStories, testCases, existingBranches] = await Promise.all([
-            getFeature(featureId, verbose),
-            getUserStories(featureId, verbose),
-            getTestCases(featureId, verbose),
-            getBranches({ featureId, verbose }).catch(() => []),
+        const [issue, userStories, testCases, existingBranches] = await Promise.all([
+            getIssue(issueId, verbose),
+            getUserStories(issueId, verbose),
+            getTestCases(issueId, verbose),
+            getBranches({ issueId, verbose }).catch(() => []),
         ]);
-        const product = await getProduct(feature.product_id, verbose);
+        const product = await getProduct(issue.product_id, verbose);
         if (verbose) {
             logInfo(`✅ Branch planning 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}`);
-            logInfo(`   Technical Design: ${feature.technical_design ? 'Yes' : 'No'}`);
+            logInfo(`   Technical Design: ${issue.technical_design ? 'Yes' : 'No'}`);
             logInfo(`   Existing Branches: ${existingBranches.length}`);
         }
         return {
-            feature,
+            issue,
             product,
             user_stories: userStories,
             test_cases: testCases,

package/dist/phases/branch-planning/index.d.ts

@@ -1,6 +1,6 @@
 import { type EdsgerConfig } from '../../types/index.js';
 export interface BranchPlanningOptions {
-    featureId: string;
+    issueId: string;
     verbose?: boolean;
     replaceExisting?: boolean;
 }
@@ -14,12 +14,12 @@ export interface PlannedBranch {
     acceptance_criteria?: string[];
 }
 export interface BranchPlanningResult {
-    featureId: string;
+    issueId: string;
     branches: PlannedBranch[];
     status: 'success' | 'error';
     summary: string;
     rationale?: string;
 }
-export declare const planFeatureBranches: (options: BranchPlanningOptions, config: EdsgerConfig) => Promise<BranchPlanningResult>;
+export declare const planIssueBranches: (options: BranchPlanningOptions, config: EdsgerConfig) => Promise<BranchPlanningResult>;
 export type { BranchPlanningContext } from './context.js';
 export { fetchBranchPlanningContext } from './context.js';

package/dist/phases/branch-planning/index.js

@@ -1,6 +1,6 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { DEFAULT_MODEL } from '../../constants.js';
-import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
+import { logIssuePhaseEvent } from '../../services/audit-logs.js';
 import { clearBranches, createBranches, } from '../../services/branches.js';
 import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services/feedbacks.js';
 import { logDebug, logError, logInfo } from '../../utils/logger.js';
@@ -36,9 +36,9 @@ async function* prompt(analysisPrompt) {
 /**
  * Fetch feedbacks for branch planning phase
  */
-async function fetchBranchPlanningFeedbacks(featureId, verbose) {
+async function fetchBranchPlanningFeedbacks(issueId, verbose) {
     try {
-        const feedbacksContext = await getFeedbacksForPhase({ featureId, verbose }, 'branch-planning');
+        const feedbacksContext = await getFeedbacksForPhase({ issueId, verbose }, 'branch-planning');
         if (verbose) {
             logInfo(`📋 Feedbacks fetched: ${feedbacksContext.feedbacks.length} feedbacks found`);
         }
@@ -72,7 +72,7 @@ function logPlanningMode(opts) {
  * Build user prompt based on mode (incremental vs new planning)
  */
 async function buildUserPrompt(opts) {
-    const { isIncrementalUpdate, feedbacksContext, existingBranchesInfo, contextInfo, featureId, verbose, } = opts;
+    const { isIncrementalUpdate, feedbacksContext, existingBranchesInfo, contextInfo, issueId, verbose, } = opts;
     if (isIncrementalUpdate && feedbacksContext) {
         if (verbose) {
             logInfo('\n🎯 Feedbacks that will be addressed:');
@@ -84,14 +84,14 @@ async function buildUserPrompt(opts) {
         const feedbacksInfo = await formatFeedbacksForContext(feedbacksContext);
         const currentPlanInfo = existingBranchesInfo || 'No existing branch plan documented.';
         const systemPrompt = createImprovementPrompt(feedbacksInfo, currentPlanInfo);
-        return `${systemPrompt}\n\n## Feature Context\n\n${contextInfo}`;
+        return `${systemPrompt}\n\n## Issue Context\n\n${contextInfo}`;
     }
-    return createBranchPlanningPromptWithContext(featureId, contextInfo, existingBranchesInfo || '');
+    return createBranchPlanningPromptWithContext(issueId, contextInfo, existingBranchesInfo || '');
 }
 /**
  * Create branches in database with proper dependencies
  */
-async function persistBranches(sortedBranches, featureId, verbose) {
+async function persistBranches(sortedBranches, issueId, verbose) {
     const branchNameToId = new Map();
     for (const branch of sortedBranches) {
         let baseBranchId;
@@ -108,7 +108,7 @@ async function persistBranches(sortedBranches, featureId, verbose) {
             base_branch_id: baseBranchId,
             status: 'pending',
         };
-        const [created] = await createBranches({ featureId, verbose: false }, [
+        const [created] = await createBranches({ issueId, verbose: false }, [
             branchInput,
         ]);
         if (created && branch.branch_name) {
@@ -117,15 +117,15 @@ async function persistBranches(sortedBranches, featureId, verbose) {
     }
 }
 // eslint-disable-next-line complexity
-export const planFeatureBranches = async (options, config) => {
-    const { featureId, verbose, replaceExisting } = options;
+export const planIssueBranches = async (options, config) => {
+    const { issueId, verbose, replaceExisting } = options;
     if (verbose) {
-        logInfo(`Starting branch planning for feature ID: ${featureId}`);
+        logInfo(`Starting branch planning for issue ID: ${issueId}`);
     }
     try {
         // Log phase start
-        await logFeaturePhaseEvent({
-            featureId,
+        await logIssuePhaseEvent({
+            issueId,
             eventType: 'phase_started',
             phase: 'branch_planning',
             result: 'info',
@@ -135,9 +135,9 @@ export const planFeatureBranches = async (options, config) => {
             },
         }, verbose);
         // Fetch context
-        const context = await fetchBranchPlanningContext(featureId, verbose);
+        const context = await fetchBranchPlanningContext(issueId, verbose);
         // Fetch feedbacks for branch_planning phase
-        const feedbacksContext = await fetchBranchPlanningFeedbacks(featureId, verbose);
+        const feedbacksContext = await fetchBranchPlanningFeedbacks(issueId, verbose);
         const hasFeedbacks = (feedbacksContext?.feedbacks.length || 0) > 0;
         // Determine operation mode
         const hasExistingBranches = context.existing_branches.length > 0;
@@ -154,28 +154,28 @@ export const planFeatureBranches = async (options, config) => {
         // Check if there are existing branches and no feedbacks - no change needed
         if (hasExistingBranches && !hasFeedbacks && !replaceExisting) {
             if (verbose) {
-                logInfo(`Feature already has ${context.existing_branches.length} branches planned and no feedbacks to address.`);
+                logInfo(`Issue already has ${context.existing_branches.length} branches planned and no feedbacks to address.`);
                 logInfo('Use replaceExisting: true to re-plan.');
             }
-            return buildNoChangeResult(featureId, context.existing_branches.length);
+            return buildNoChangeResult(issueId, context.existing_branches.length);
         }
         // Clear existing branches if requested (full re-plan)
         if (replaceExisting && hasExistingBranches) {
             if (verbose) {
                 logInfo(`Clearing ${context.existing_branches.length} existing branches for full re-plan...`);
             }
-            await clearBranches({ featureId, verbose }, true);
+            await clearBranches({ issueId, verbose }, true);
         }
         // Build the user prompt based on mode
-        const contextInfo = formatContextForPrompt(context.feature, context.product, context.user_stories, context.test_cases);
+        const contextInfo = formatContextForPrompt(context.issue, context.product, context.user_stories, context.test_cases);
         const existingBranchesInfo = formatExistingBranchesForPrompt(context.existing_branches);
-        const systemPrompt = await createBranchPlanningSystemPrompt(config, featureId);
+        const systemPrompt = await createBranchPlanningSystemPrompt(config, issueId);
         const userPrompt = await buildUserPrompt({
             isIncrementalUpdate,
             feedbacksContext,
             existingBranchesInfo,
             contextInfo,
-            featureId,
+            issueId,
             verbose,
         });
         if (verbose) {
@@ -186,14 +186,14 @@ export const planFeatureBranches = async (options, config) => {
         if (!result || !result.branches || result.branches.length === 0) {
             const errorMsg = 'No branches were generated';
             logError(errorMsg);
-            return buildErrorResult(featureId, errorMsg);
+            return buildErrorResult(issueId, errorMsg);
         }
         // Validate branches
         const validation = validatePlannedBranches(result.branches);
         if (!validation.valid) {
             const errorMsg = `Invalid branch plan: ${validation.errors.join(', ')}`;
             logError(errorMsg);
-            return buildErrorResult(featureId, errorMsg);
+            return buildErrorResult(issueId, errorMsg);
         }
         // Sort branches by dependency
         const sortedBranches = sortBranchesByDependency(result.branches);
@@ -202,13 +202,13 @@ export const planFeatureBranches = async (options, config) => {
             if (verbose) {
                 logInfo(`🔄 Clearing ${context.existing_branches.length} existing branches for incremental update...`);
             }
-            await clearBranches({ featureId, verbose: false }, true);
+            await clearBranches({ issueId, verbose: false }, true);
         }
         // Create branches in database with proper dependencies
-        await persistBranches(sortedBranches, featureId, verbose);
+        await persistBranches(sortedBranches, issueId, verbose);
         if (verbose) {
             const modeLabel = isIncrementalUpdate ? '🔄 Updated' : '✅ Created';
-            logInfo(`${modeLabel} ${sortedBranches.length} feature branches`);
+            logInfo(`${modeLabel} ${sortedBranches.length} issue branches`);
             sortedBranches.forEach((b, idx) => {
                 logInfo(`   ${idx + 1}. ${b.name}`);
                 if (b.scope) {
@@ -217,8 +217,8 @@ export const planFeatureBranches = async (options, config) => {
             });
         }
         // Log phase completion
-        await logFeaturePhaseEvent({
-            featureId,
+        await logIssuePhaseEvent({
+            issueId,
             eventType: 'phase_completed',
             phase: 'branch_planning',
             result: 'success',
@@ -233,15 +233,15 @@ export const planFeatureBranches = async (options, config) => {
         const summaryPrefix = isIncrementalUpdate
             ? `Updated branch plan based on ${feedbacksContext?.feedbacks.length || 0} feedbacks.`
             : '';
-        return buildSuccessResult(featureId, sortedBranches, result.summary ||
+        return buildSuccessResult(issueId, sortedBranches, result.summary ||
             `${summaryPrefix} ${sortedBranches.length} branches for incremental development`.trim(), result.rationale);
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         logError(`Branch planning failed: ${errorMessage}`);
         // Log phase failure
-        await logFeaturePhaseEvent({
-            featureId,
+        await logIssuePhaseEvent({
+            issueId,
             eventType: 'phase_failed',
             phase: 'branch_planning',
             result: 'error',
@@ -250,7 +250,7 @@ export const planFeatureBranches = async (options, config) => {
                 timestamp: new Date().toISOString(),
             },
         }, verbose);
-        return buildErrorResult(featureId, errorMessage);
+        return buildErrorResult(issueId, errorMessage);
     }
 };
 /**

package/dist/phases/branch-planning/outcome.d.ts

@@ -2,19 +2,19 @@ import { type BranchPlanningResult, type PlannedBranch } from './index.js';
 /**
  * Build a successful branch planning result
  */
-export declare function buildSuccessResult(featureId: string, branches: PlannedBranch[], summary: string, rationale?: string): BranchPlanningResult;
+export declare function buildSuccessResult(issueId: string, branches: PlannedBranch[], summary: string, rationale?: string): BranchPlanningResult;
 /**
  * Build an error result
  */
-export declare function buildErrorResult(featureId: string, errorMessage: string): BranchPlanningResult;
+export declare function buildErrorResult(issueId: string, errorMessage: string): BranchPlanningResult;
 /**
  * Build a result when no changes are needed
  */
-export declare function buildNoChangeResult(featureId: string, existingBranchCount: number): BranchPlanningResult;
+export declare function buildNoChangeResult(issueId: string, existingBranchCount: number): BranchPlanningResult;
 /**
- * Build a result for a single-branch feature
+ * Build a result for a single-branch issue
  */
-export declare function buildSingleBranchResult(featureId: string, branch: PlannedBranch): BranchPlanningResult;
+export declare function buildSingleBranchResult(issueId: string, branch: PlannedBranch): BranchPlanningResult;
 /**
  * Validate planned branches
  */

package/dist/phases/branch-planning/outcome.js

@@ -1,9 +1,9 @@
 /**
  * Build a successful branch planning result
  */
-export function buildSuccessResult(featureId, branches, summary, rationale) {
+export function buildSuccessResult(issueId, branches, summary, rationale) {
     return {
-        featureId,
+        issueId,
         branches,
         status: 'success',
         summary,
@@ -13,9 +13,9 @@ export function buildSuccessResult(featureId, branches, summary, rationale) {
 /**
  * Build an error result
  */
-export function buildErrorResult(featureId, errorMessage) {
+export function buildErrorResult(issueId, errorMessage) {
     return {
-        featureId,
+        issueId,
         branches: [],
         status: 'error',
         summary: `Branch planning failed: ${errorMessage}`,
@@ -24,24 +24,24 @@ export function buildErrorResult(featureId, errorMessage) {
 /**
  * Build a result when no changes are needed
  */
-export function buildNoChangeResult(featureId, existingBranchCount) {
+export function buildNoChangeResult(issueId, existingBranchCount) {
     return {
-        featureId,
+        issueId,
         branches: [],
         status: 'success',
-        summary: `Feature already has ${existingBranchCount} branches planned. No changes needed.`,
+        summary: `Issue already has ${existingBranchCount} branches planned. No changes needed.`,
     };
 }
 /**
- * Build a result for a single-branch feature
+ * Build a result for a single-branch issue
  */
-export function buildSingleBranchResult(featureId, branch) {
+export function buildSingleBranchResult(issueId, branch) {
     return {
-        featureId,
+        issueId,
         branches: [branch],
         status: 'success',
-        summary: 'Feature is small enough to be implemented in a single branch.',
-        rationale: 'The feature scope is limited and can be completed in a single pull request without exceeding reasonable review size.',
+        summary: 'Issue is small enough to be implemented in a single branch.',
+        rationale: 'The issue scope is limited and can be completed in a single pull request without exceeding reasonable review size.',
     };
 }
 /**

package/dist/phases/branch-planning/prompts.d.ts

@@ -2,15 +2,15 @@ import { type EdsgerConfig } from '../../types/index.js';
 /**
  * Create the system prompt for branch planning
  */
-export declare function createBranchPlanningSystemPrompt(config: EdsgerConfig, featureId: string, projectDir?: string): Promise<string>;
+export declare function createBranchPlanningSystemPrompt(config: EdsgerConfig, issueId: string, projectDir?: string): Promise<string>;
 /**
  * Create the user prompt with context for branch planning
  */
-export declare function createBranchPlanningPromptWithContext(featureId: string, contextInfo: string, existingBranchesInfo: string): string;
+export declare function createBranchPlanningPromptWithContext(issueId: string, contextInfo: string, existingBranchesInfo: string): string;
 /**
  * Format the context information for the prompt
  */
-export declare function formatContextForPrompt(feature: {
+export declare function formatContextForPrompt(issue: {
     name: string;
     description?: string | null;
     technical_design?: string | null;