edsger 0.50.0 → 0.52.0

package/dist/commands/workflow/processor.js

@@ -1,15 +1,15 @@
 /**
- * Main workflow processor for continuous feature development
- * Monitors for ready_for_ai features and processes them through the complete pipeline
+ * Main workflow processor for continuous issue development
+ * Monitors for ready_for_ai issues and processes them through the complete pipeline
  * Uses functional programming principles
  */
-import { claimNextFeature } from '../../api/features/index.js';
+import { claimNextIssue } from '../../api/issues/index.js';
 import { logInfo } from '../../utils/logger.js';
 import { evaluatePipelineResults } from './core/pipeline-evaluator.js';
 // Import core modules
-import { calculateStats, createCompletedState, createFailedState, createInitialState, createProcessingState, updateFeatureState, } from './core/state-manager.js';
-import { logFeatureError, logFeatureFailed, logFeatureSuccess, logNoFeaturesFound, logPipelineResults, logPollingError, logProcessingStart, logProcessNextFeatureError, logProcessorReady, logProcessorStart, logProcessorStop, logRetryInfo, logSkippingProcessing, } from './core/workflow-logger.js';
-import { runFeatureWorkflow } from './feature-coordinator.js';
+import { calculateStats, createCompletedState, createFailedState, createInitialState, createProcessingState, updateIssueState, } from './core/state-manager.js';
+import { logIssueError, logIssueFailed, logIssueSuccess, logNoIssuesFound, logPipelineResults, logPollingError, logProcessingStart, logProcessNextIssueError, logProcessorReady, logProcessorStart, logProcessorStop, logRetryInfo, logSkippingProcessing, } from './core/workflow-logger.js';
+import { runIssueWorkflow } from './issue-coordinator.js';
 /**
  * Workflow processor using functional programming principles
  */
@@ -17,7 +17,7 @@ export class WorkflowProcessor {
     options;
     config;
     isRunning = false;
-    processedFeatures = createInitialState();
+    processedIssues = createInitialState();
     pollTimer;
     constructor(options, config) {
         this.options = {
@@ -39,10 +39,10 @@ export class WorkflowProcessor {
         this.isRunning = true;
         logProcessorStart(this.options.productId, this.options.pollInterval);
         // Initial check
-        await this.processNextFeature();
-        // Set up polling for new features
+        await this.processNextIssue();
+        // Set up polling for new issues
         this.pollTimer = setInterval(() => {
-            this.processNextFeature().catch((error) => {
+            this.processNextIssue().catch((error) => {
                 logPollingError(error);
             });
         }, this.options.pollInterval);
@@ -63,87 +63,87 @@ export class WorkflowProcessor {
         logProcessorStop();
     }
     /**
-     * Process the next available feature using atomic claim mechanism
+     * Process the next available issue using atomic claim mechanism
      * Uses database-level locking to prevent race conditions between workers
      */
-    async processNextFeature() {
+    async processNextIssue() {
         try {
-            // Skip feature fetching if there are any features currently being processed
-            const stats = calculateStats(this.processedFeatures, this.isRunning);
+            // Skip issue fetching if there are any issues currently being processed
+            const stats = calculateStats(this.processedIssues, this.isRunning);
             if (stats.processing > 0) {
                 if (this.options.verbose) {
                     logSkippingProcessing(stats.processing);
                 }
                 return;
             }
-            // Atomically claim the next available feature
-            // This uses FOR UPDATE SKIP LOCKED to prevent multiple workers from claiming the same feature
-            const claimedFeature = await claimNextFeature(this.options.productId, this.options.verbose);
-            if (!claimedFeature) {
+            // Atomically claim the next available issue
+            // This uses FOR UPDATE SKIP LOCKED to prevent multiple workers from claiming the same issue
+            const claimedIssue = await claimNextIssue(this.options.productId, this.options.verbose);
+            if (!claimedIssue) {
                 if (this.options.verbose) {
-                    logNoFeaturesFound();
+                    logNoIssuesFound();
                 }
                 return;
             }
-            // Process the claimed feature
-            await this.processFeature(claimedFeature);
+            // Process the claimed issue
+            await this.processIssue(claimedIssue);
         }
         catch (error) {
-            logProcessNextFeatureError(error);
+            logProcessNextIssueError(error);
         }
     }
     /**
-     * Process a single feature through the complete pipeline using functional composition
+     * Process a single issue through the complete pipeline using functional composition
      */
-    async processFeature(feature) {
-        const featureId = feature.id;
-        // Check if this is a reprocess due to feature update
-        const existingState = this.processedFeatures.get(featureId);
+    async processIssue(issue) {
+        const issueId = issue.id;
+        // Check if this is a reprocess due to issue update
+        const existingState = this.processedIssues.get(issueId);
         if (existingState &&
             existingState.status === 'completed' &&
             this.options.verbose) {
-            logInfo(`🔄 Reprocessing feature "${feature.name}" - detected status change`);
-            if (feature.updated_at) {
+            logInfo(`🔄 Reprocessing issue "${issue.name}" - detected status change`);
+            if (issue.updated_at) {
                 logInfo(`  Previous process: ${existingState.lastAttempt.toISOString()}`);
-                logInfo(`  Feature updated: ${feature.updated_at}`);
+                logInfo(`  Issue updated: ${issue.updated_at}`);
             }
         }
         // Update state to processing using pure function
-        this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createProcessingState(featureId, currentState));
-        logProcessingStart(feature, this.options.verbose);
+        this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createProcessingState(issueId, currentState));
+        logProcessingStart(issue, this.options.verbose);
         try {
-            // Run feature workflow using feature coordinator with execution mode support
-            const results = await runFeatureWorkflow({
-                featureId,
+            // Run issue workflow using issue coordinator with execution mode support
+            const results = await runIssueWorkflow({
+                issueId,
                 verbose: this.options.verbose,
             }, this.config);
             // Evaluate results using pure function
             const allSuccessful = evaluatePipelineResults(results);
             if (allSuccessful) {
                 // Mark as completed using pure function
-                this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createCompletedState(featureId, currentState));
-                logFeatureSuccess(feature.name);
+                this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createCompletedState(issueId, currentState));
+                logIssueSuccess(issue.name);
                 logPipelineResults(results);
             }
             else {
                 // Mark as failed using pure function
-                this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createFailedState(featureId, currentState));
-                logFeatureFailed(feature.name);
+                this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createFailedState(issueId, currentState));
+                logIssueFailed(issue.name);
                 logPipelineResults(results);
-                const currentState = this.processedFeatures.get(featureId);
-                logRetryInfo(feature.name, currentState?.retryCount ?? 0, this.options.maxRetries);
+                const currentState = this.processedIssues.get(issueId);
+                logRetryInfo(issue.name, currentState?.retryCount ?? 0, this.options.maxRetries);
             }
         }
         catch (error) {
             // Mark as failed using pure function
-            this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createFailedState(featureId, currentState));
-            logFeatureError(feature.name, error);
+            this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createFailedState(issueId, currentState));
+            logIssueError(issue.name, error);
         }
     }
     /**
      * Get current processing statistics using pure function
      */
     getStats() {
-        return calculateStats(this.processedFeatures, this.isRunning);
+        return calculateStats(this.processedIssues, this.isRunning);
     }
 }

package/dist/config/{feature-status.d.ts → issue-status.d.ts}

@@ -1,14 +1,14 @@
 /**
- * Feature status configuration
- * Defines the progression order and mappings for feature statuses
+ * Issue status configuration
+ * Defines the progression order and mappings for issue statuses
  */
-import type { FeatureStatus } from '../types/index.js';
+import type { IssueStatus } from '../types/index.js';
 /**
  * Status progression order - higher index means more advanced status
- * This defines the allowed forward progression through the feature workflow
+ * This defines the allowed forward progression through the issue workflow
  *
  * Business Logic Rules:
- * - Features can only move forward or stay at the same status level
+ * - Issues can only move forward or stay at the same status level
  * - No regression to earlier stages is allowed (e.g., cannot go back to 'backlog' from 'code_implementation')
  * - Status updates preserve development momentum and prevent accidental rollbacks
  *
@@ -21,21 +21,21 @@ import type { FeatureStatus } from '../types/index.js';
  * through to final shipping. All status values must match the database constraint
  * in migration 20251019000000_update_feature_status_constraint.sql
  */
-export declare const STATUS_PROGRESSION_ORDER: readonly FeatureStatus[];
+export declare const STATUS_PROGRESSION_ORDER: readonly IssueStatus[];
 /**
  * Phase to status mapping
- * Maps pipeline phase names to their corresponding feature statuses
+ * Maps pipeline phase names to their corresponding issue statuses
  *
- * This mapping ensures that each pipeline phase updates the feature to the appropriate
- * status. Phase names use kebab-case (e.g., 'feature-analysis') while status values
- * use snake_case (e.g., 'feature_analysis') to match database schema.
+ * This mapping ensures that each pipeline phase updates the issue to the appropriate
+ * status. Phase names use kebab-case (e.g., 'issue-analysis') while status values
+ * use snake_case (e.g., 'issue_analysis') to match database schema.
  *
  * All status values must match the database constraint in migration 20251019000000_update_feature_status_constraint.sql
  *
- * If a phase is not found in this mapping, updateFeatureStatusForPhase will return null
+ * If a phase is not found in this mapping, updateIssueStatusForPhase will return null
  * and skip the status update to prevent unintended regression to 'backlog'.
  */
-export declare const PHASE_STATUS_MAP: Record<string, FeatureStatus>;
+export declare const PHASE_STATUS_MAP: Record<string, IssueStatus>;
 /**
  * Human-selectable statuses
  * These are the statuses that a human user can manually set.
@@ -49,8 +49,8 @@ export declare const PHASE_STATUS_MAP: Record<string, FeatureStatus>;
  * These excluded statuses should not be shown in UI dropdowns for manual status changes
  * because they represent intermediate states that are managed by the workflow system.
  */
-export declare const HUMAN_SELECTABLE_STATUSES: readonly FeatureStatus[];
+export declare const HUMAN_SELECTABLE_STATUSES: readonly IssueStatus[];
 /**
  * Check if a status can be manually selected by a human user
  */
-export declare function isHumanSelectableStatus(status: FeatureStatus): boolean;
+export declare function isHumanSelectableStatus(status: IssueStatus): boolean;

package/dist/config/{feature-status.js → issue-status.js}

@@ -1,13 +1,13 @@
 /**
- * Feature status configuration
- * Defines the progression order and mappings for feature statuses
+ * Issue status configuration
+ * Defines the progression order and mappings for issue statuses
  */
 /**
  * Status progression order - higher index means more advanced status
- * This defines the allowed forward progression through the feature workflow
+ * This defines the allowed forward progression through the issue workflow
  *
  * Business Logic Rules:
- * - Features can only move forward or stay at the same status level
+ * - Issues can only move forward or stay at the same status level
  * - No regression to earlier stages is allowed (e.g., cannot go back to 'backlog' from 'code_implementation')
  * - Status updates preserve development momentum and prevent accidental rollbacks
  *
@@ -24,8 +24,8 @@ export const STATUS_PROGRESSION_ORDER = [
     'backlog',
     'ready_for_ai',
     'assigned_to_ai',
-    'feature_analysis',
-    'feature_analysis_verification',
+    'issue_analysis',
+    'issue_analysis_verification',
     'user_stories_analysis',
     'user_stories_analysis_verification',
     'test_cases_analysis',
@@ -53,20 +53,20 @@ export const STATUS_PROGRESSION_ORDER = [
 ];
 /**
  * Phase to status mapping
- * Maps pipeline phase names to their corresponding feature statuses
+ * Maps pipeline phase names to their corresponding issue statuses
  *
- * This mapping ensures that each pipeline phase updates the feature to the appropriate
- * status. Phase names use kebab-case (e.g., 'feature-analysis') while status values
- * use snake_case (e.g., 'feature_analysis') to match database schema.
+ * This mapping ensures that each pipeline phase updates the issue to the appropriate
+ * status. Phase names use kebab-case (e.g., 'issue-analysis') while status values
+ * use snake_case (e.g., 'issue_analysis') to match database schema.
  *
  * All status values must match the database constraint in migration 20251019000000_update_feature_status_constraint.sql
  *
- * If a phase is not found in this mapping, updateFeatureStatusForPhase will return null
+ * If a phase is not found in this mapping, updateIssueStatusForPhase will return null
  * and skip the status update to prevent unintended regression to 'backlog'.
  */
 export const PHASE_STATUS_MAP = {
-    'feature-analysis': 'feature_analysis',
-    'feature-analysis-verification': 'feature_analysis_verification',
+    'issue-analysis': 'issue_analysis',
+    'issue-analysis-verification': 'issue_analysis_verification',
     'user-stories-analysis': 'user_stories_analysis',
     'user-stories-analysis-verification': 'user_stories_analysis_verification',
     'test-cases-analysis': 'test_cases_analysis',
@@ -106,7 +106,7 @@ export const PHASE_STATUS_MAP = {
 export const HUMAN_SELECTABLE_STATUSES = [
     'backlog',
     'ready_for_ai',
-    'feature_analysis',
+    'issue_analysis',
     'user_stories_analysis',
     'test_cases_analysis',
     'technical_design',

package/dist/errors/index.d.ts

@@ -38,23 +38,23 @@ export declare class ConfigError extends EdsgerError {
 }
 export declare class PhaseError extends EdsgerError {
     readonly phase: string;
-    readonly featureId: string;
+    readonly issueId: string;
     readonly iteration?: number;
-    constructor(phase: string, featureId: string, message: string, iteration?: number, options?: ErrorOptions);
+    constructor(phase: string, issueId: string, message: string, iteration?: number, options?: ErrorOptions);
 }
 export declare class LLMParseError extends EdsgerError {
     readonly rawResponse?: string;
     constructor(message: string, rawResponse?: string, options?: ErrorOptions);
 }
 export declare class WorkerTimeoutError extends EdsgerError {
-    readonly featureId: string;
+    readonly issueId: string;
     readonly timeoutMs: number;
-    constructor(featureId: string, timeoutMs: number, options?: ErrorOptions);
+    constructor(issueId: string, timeoutMs: number, options?: ErrorOptions);
 }
 export declare class WorkerCrashError extends EdsgerError {
-    readonly featureId: string;
+    readonly issueId: string;
     readonly exitCode: number | null;
-    constructor(featureId: string, exitCode: number | null, options?: ErrorOptions);
+    constructor(issueId: string, exitCode: number | null, options?: ErrorOptions);
 }
 export declare class ValidationError extends EdsgerError {
     readonly fields: string[];

package/dist/errors/index.js

@@ -65,13 +65,13 @@ export class ConfigError extends EdsgerError {
 // ---- Phase execution errors ----
 export class PhaseError extends EdsgerError {
     phase;
-    featureId;
+    issueId;
     iteration;
-    constructor(phase, featureId, message, iteration, options) {
+    constructor(phase, issueId, message, iteration, options) {
         super('PHASE_ERROR', message, options);
         this.name = 'PhaseError';
         this.phase = phase;
-        this.featureId = featureId;
+        this.issueId = issueId;
         this.iteration = iteration;
     }
 }
@@ -86,22 +86,22 @@ export class LLMParseError extends EdsgerError {
 }
 // ---- Worker errors ----
 export class WorkerTimeoutError extends EdsgerError {
-    featureId;
+    issueId;
     timeoutMs;
-    constructor(featureId, timeoutMs, options) {
-        super('WORKER_TIMEOUT', `Worker for feature ${featureId} timed out after ${Math.round(timeoutMs / 1000)}s`, options);
+    constructor(issueId, timeoutMs, options) {
+        super('WORKER_TIMEOUT', `Worker for issue ${issueId} timed out after ${Math.round(timeoutMs / 1000)}s`, options);
         this.name = 'WorkerTimeoutError';
-        this.featureId = featureId;
+        this.issueId = issueId;
         this.timeoutMs = timeoutMs;
     }
 }
 export class WorkerCrashError extends EdsgerError {
-    featureId;
+    issueId;
     exitCode;
-    constructor(featureId, exitCode, options) {
-        super('WORKER_CRASH', `Worker for feature ${featureId} crashed with exit code ${exitCode}`, options);
+    constructor(issueId, exitCode, options) {
+        super('WORKER_CRASH', `Worker for issue ${issueId} crashed with exit code ${exitCode}`, options);
         this.name = 'WorkerCrashError';
-        this.featureId = featureId;
+        this.issueId = issueId;
         this.exitCode = exitCode;
     }
 }

package/dist/index.js

@@ -13,6 +13,9 @@ import { runBuild } from './commands/build/index.js';
 import { runChecklists } from './commands/checklists/index.js';
 import { runCodeReview } from './commands/code-review/index.js';
 import { runConfigGet, runConfigList, runConfigSet, runConfigUnset, } from './commands/config/index.js';
+import { runFindBugs } from './commands/find-bugs/index.js';
+import { runFindFeatures } from './commands/find-features/index.js';
+import { parseCategoriesOption, runFindSmells, } from './commands/find-smells/index.js';
 import { runGrowthAnalysis } from './commands/growth-analysis/index.js';
 import { runInit } from './commands/init/index.js';
 import { runIntelligence } from './commands/intelligence/index.js';
@@ -24,6 +27,8 @@ import { runRunSheetCommand } from './commands/run-sheet/index.js';
 import { runSmokeTestCommand } from './commands/smoke-test/index.js';
 import { runTaskWorker } from './commands/task-worker/index.js';
 import { runWorkflow } from './commands/workflow/index.js';
+import { DEFAULT_MAX_FILES as FIND_SMELLS_DEFAULT_MAX_FILES } from './phases/find-smells/index.js';
+import { SMELL_CATEGORIES, } from './phases/find-smells/types.js';
 import { logError, logInfo } from './utils/logger.js';
 // Get package.json version dynamically
 // eslint-disable-next-line @typescript-eslint/naming-convention -- ESM __filename/__dirname polyfill
@@ -354,6 +359,90 @@ program
     }
 });
 // ============================================================
+// Subcommand: edsger find-bugs <productId>
+// ============================================================
+program
+    .command('find-bugs <productId>')
+    .description("AI-audit a product's repository for bugs and file each new finding as an issue")
+    .option('--full', 'Force a full scan even if previous-scan state exists')
+    .option('--branch <name>', 'Branch to scan (defaults to repo default branch)')
+    .option('--max-files <n>', 'Upper bound on files the auditor may Read (default 200)', (value) => {
+    const n = parseInt(value, 10);
+    if (Number.isNaN(n) || n <= 0) {
+        throw new Error('--max-files must be a positive integer');
+    }
+    return n;
+})
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (productId, opts) => {
+    try {
+        await runFindBugs(productId, opts);
+    }
+    catch (error) {
+        logError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// ============================================================
+// Subcommand: edsger find-features <productId>
+// ============================================================
+program
+    .command('find-features <productId>')
+    .description("Synthesise feature opportunities from user feedback + intelligence reports + the product's codebase, and file each one as an issue")
+    .option('--branch <name>', 'Branch to scan (defaults to repo default branch)')
+    .option('--since <duration>', 'Feedback lookback window — e.g. "30d", "12h", "4w" (default 90d)')
+    .option('--min-cluster-size <n>', 'Min feedback mentions for a theme to count as high-confidence (default 3)', (value) => {
+    const n = parseInt(value, 10);
+    if (Number.isNaN(n) || n <= 0) {
+        throw new Error('--min-cluster-size must be a positive integer');
+    }
+    return n;
+})
+    .option('--max-suggestions <n>', 'Cap on opportunities the agent may surface (default 10)', (value) => {
+    const n = parseInt(value, 10);
+    if (Number.isNaN(n) || n <= 0) {
+        throw new Error('--max-suggestions must be a positive integer');
+    }
+    return n;
+})
+    .option('--against-report <id>', 'Narrow the run to opportunities implied by a specific intelligence report')
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (productId, opts) => {
+    try {
+        await runFindFeatures(productId, opts);
+    }
+    catch (error) {
+        logError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// ============================================================
+// Subcommand: edsger find-smells <productId>
+// ============================================================
+program
+    .command('find-smells <productId>')
+    .description("AI-audit a product's repository for code smells (refactor candidates, perf cliffs, dead code, type-safety gaps) and file each new finding as an issue")
+    .option('--full', 'Force a full scan even if previous-scan state exists')
+    .option('--branch <name>', 'Branch to scan (defaults to repo default branch)')
+    .option('--max-files <n>', `Upper bound on files the auditor may Read (default ${FIND_SMELLS_DEFAULT_MAX_FILES})`, (value) => {
+    const n = parseInt(value, 10);
+    if (Number.isNaN(n) || n <= 0) {
+        throw new Error('--max-files must be a positive integer');
+    }
+    return n;
+})
+    .option('--categories <list>', `Comma-separated category filter (${SMELL_CATEGORIES.join(',')})`, parseCategoriesOption)
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (productId, opts) => {
+    try {
+        await runFindSmells(productId, opts);
+    }
+    catch (error) {
+        logError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// ============================================================
 // Subcommand: edsger pr-resolve <productId>
 // ============================================================
 program
@@ -383,7 +472,7 @@ program
     .option('--init', 'Initialize .edsger directory with project templates')
     .option('--product-level', 'Use legacy product-level workflow (requires EDSGER_PRODUCT_ID, EDSGER_MCP_SERVER_URL, EDSGER_MCP_TOKEN env vars)')
     .option('--watch-tasks <productId>', 'Watch and execute pending tasks for a product')
-    .option('--concurrency <number>', 'Max concurrent features to process (default: 3)', parseInt)
+    .option('--concurrency <number>', 'Max concurrent issues to process (default: 3)', parseInt)
     .option('-c, --config <path>', 'Path to config file')
     .option('-v, --verbose', 'Verbose output');
 program.action(async (options) => {

package/dist/phases/app-store-generation/context.js

@@ -32,11 +32,11 @@ export async function fetchAppStoreContext(productId, verbose) {
  */
 export function formatContextForPrompt(context) {
     const { product, existingConfigs } = context;
-    const featuresList = product.features && product.features.length > 0
-        ? product.features
+    const issuesList = product.issues && product.issues.length > 0
+        ? product.issues
             .map((f) => `- **${f.name}**: ${f.description || 'No description'} (Status: ${f.status || 'unknown'})`)
             .join('\n')
-        : 'No features listed.';
+        : 'No issues listed.';
     const existingListings = existingConfigs.length > 0
         ? existingConfigs
             .map((c) => {
@@ -54,15 +54,15 @@ export function formatContextForPrompt(context) {
 - **Product ID**: ${product.id}
 - **Description**: ${product.description || 'No description provided'}
 
-## Product Features (${product.features?.length || 0})
-${featuresList}
+## Product Issues (${product.issues?.length || 0})
+${issuesList}
 
 ## Existing Store Configurations
 ${existingListings}
 
 ---
 
-**Important**: Generate professional app store assets for this product. Use the product name, description, and features to create specific, compelling content. Each screenshot should showcase a real feature with realistic mock data.`;
+**Important**: Generate professional app store assets for this product. Use the product name, description, and issues to create specific, compelling content. Each screenshot should showcase a real issue with realistic mock data.`;
 }
 /**
  * Prepare the full prompt with all context

package/dist/phases/app-store-generation/index.js

@@ -1,7 +1,7 @@
 import { getAppStorePrimaryLocale, saveAppStoreListings, upsertAppStoreConfig, } from '../../api/app-store.js';
 import { getGitHubConfigByProduct } from '../../api/github.js';
 import { logError, logInfo, logSuccess } from '../../utils/logger.js';
-import { cloneFeatureRepo, ensureWorkspaceDir, } from '../../workspace/workspace-manager.js';
+import { cloneIssueRepo, ensureWorkspaceDir, } from '../../workspace/workspace-manager.js';
 import { executeAppStoreQuery } from './agent.js';
 import { prepareAppStoreContext } from './context.js';
 import { createAppStoreSystemPrompt } from './prompts.js';
@@ -48,7 +48,7 @@ export const generateAppStoreAssets = async (options, config) => {
                 'Please configure a GitHub repo in the product settings before generating assets.');
         }
         const workspaceRoot = ensureWorkspaceDir();
-        const { repoPath: repoCwd } = cloneFeatureRepo(workspaceRoot, `app-store-${productId}`, githubConfig.owner, githubConfig.repo, githubConfig.token);
+        const { repoPath: repoCwd } = cloneIssueRepo(workspaceRoot, `app-store-${productId}`, githubConfig.owner, githubConfig.repo, githubConfig.token);
         logInfo(`Repository cloned to: ${repoCwd}`);
         // Prepare context and prompt
         const { context, prompt: analysisPrompt } = await prepareAppStoreContext(productId, targetStore, locale, verbose, true);

package/dist/phases/app-store-generation/prompts.js

@@ -62,8 +62,8 @@ ${contextInfo}
 ## Instructions
 ${codebaseInstructions}
 1. Create compelling store listing content (app_name, subtitle, description, keywords, etc.) for the "${locale}" locale
-2. Design 5-8 screenshot compositions, each highlighting a different key feature
-3. For each screenshot, create a complete HTML template that renders realistic mock app UI for that feature
+2. Design 5-8 screenshot compositions, each highlighting a different key issue
+3. For each screenshot, create a complete HTML template that renders realistic mock app UI for that issue
 4. Use varied gradient backgrounds and engaging headline text for visual appeal
 5. Ensure mock data looks realistic — use real-looking names, numbers, dates, not "Lorem ipsum"
 6. Design mobile screenshots in portrait orientation (phone viewport: 390x844)

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

@@ -2,7 +2,7 @@
  * 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.
  */
@@ -10,7 +10,7 @@ import { type ChecklistPhaseContext } from '../../services/checklist.js';
 import { type EdsgerConfig } from '../../types/index.js';
 import { type PipelinePhaseOptions } from '../../types/pipeline.js';
 export interface AutonomousResult {
-    featureId: string;
+    issueId: string;
     status: 'success' | 'error';
     message: string;
     branchName: string;
@@ -22,7 +22,7 @@ export interface AutonomousResult {
  * Main entry point for autonomous development phase
  */
 export declare function runAutonomousDevelopment(options: PipelinePhaseOptions, config: EdsgerConfig, _checklistContext?: ChecklistPhaseContext | null): Promise<{
-    featureId: string;
+    issueId: string;
     status: string;
     message: string;
     branchName?: string;