edsger 0.2.4 → 0.2.6

package/dist/cli/commands/refactor-command.js

@@ -5,9 +5,9 @@ export const runRefactor = async (options) => {
     // Load and validate configuration
     const config = validateConfiguration(options);
     if (options.verbose) {
-        logInfo('Starting code refactoring for current directory...');
+        logInfo('Starting automatic code refactoring for current directory...');
     }
-    logInfo('Analyzing code for refactoring opportunities...');
+    logInfo('Analyzing and refactoring code...');
     try {
         const refactorPrompt = createRefactorPrompt(config);
         const systemPrompt = createSystemPrompt();
@@ -17,6 +17,7 @@ export const runRefactor = async (options) => {
             options: {
                 appendSystemPrompt: systemPrompt,
                 model: config.claude.model || 'sonnet',
+                permissionMode: 'bypassPermissions',
             },
         })) {
             // Stream the refactoring process
@@ -33,7 +34,7 @@ export const runRefactor = async (options) => {
             if (message.type === 'result') {
                 hasCompleted = true;
                 if (message.subtype === 'success') {
-                    logSuccess('Refactoring analysis completed successfully');
+                    logSuccess('Code refactoring completed successfully');
                     process.exit(0);
                 }
                 else {
@@ -56,52 +57,67 @@ export const runRefactor = async (options) => {
     }
 };
 const createSystemPrompt = () => {
-    return `You are an expert code refactoring assistant using Claude Code. Your task is to analyze code in the current directory and suggest or perform refactoring improvements.
+    return `You are an expert code refactoring assistant using Claude Code. Your task is to analyze and AUTOMATICALLY REFACTOR code in the current directory to improve quality and maintainability.
 
 IMPORTANT INSTRUCTIONS:
 1. Use the Bash tool to explore the project structure (ls, find, etc.)
 2. Use the Read tool to examine file contents
 3. Use the Grep tool to search for patterns, code smells, or duplications
-4. Use the Edit tool to apply refactoring changes when appropriate
-5. Analyze code quality, identify technical debt, and suggest improvements
+4. Use the Edit tool to DIRECTLY apply refactoring changes
+5. You have FULL PERMISSION to make refactoring changes without asking for confirmation
 
-REFACTORING FOCUS AREAS:
-- Code duplication and DRY violations
-- Complex functions that need simplification
-- Poor naming conventions
-- Missing type annotations (TypeScript)
-- Inefficient algorithms or data structures
-- Code organization and structure
-- Missing or inadequate error handling
-- Opportunities for better abstraction
-- Performance improvements
+REFACTORING FOCUS AREAS (prioritized):
+1. Code duplication and DRY violations (HIGHEST PRIORITY)
+2. Complex functions that need simplification
+3. Poor naming conventions
+4. Missing type annotations (TypeScript)
+5. Inefficient algorithms or data structures
+6. Code organization and structure
+7. Missing or inadequate error handling
+8. Opportunities for better abstraction
+9. Performance improvements
 
 WORKFLOW:
 1. First, explore the project structure to understand the codebase
 2. Identify files that would benefit from refactoring
-3. Analyze specific issues and patterns
-4. Suggest improvements with clear explanations
-5. Ask for user confirmation before making significant changes
-6. Apply changes using the Edit tool if approved
+3. Analyze specific issues and patterns (focus on high-impact issues first)
+4. For each issue found:
+   - Explain what you're refactoring and why
+   - Apply the refactoring using the Edit tool
+   - Verify the change is correct
+5. Continue until all high-priority refactorings are complete or you run out of turns
 
-Be thorough but focused. Prioritize high-impact refactorings that improve code maintainability and quality.`;
+SAFETY GUIDELINES:
+- Start with safest refactorings (extract utilities, remove duplication)
+- Preserve existing functionality - only improve structure/quality
+- Focus on non-breaking changes
+- Make atomic commits for each logical refactoring
+
+IMPORTANT: You should DIRECTLY perform refactorings without asking for permission. The user has granted you full bypass authority to improve the code.`;
 };
 const createRefactorPrompt = (config) => {
-    return `Please analyze the code in the current directory for refactoring opportunities.
+    return `Please analyze and REFACTOR the code in the current directory. You have full permission to make improvements directly.
+
+TASK: Automatically identify and fix code quality issues
 
 Steps to follow:
 1. Start by running "ls -la" to see the project structure
 2. Identify key source files (focus on patterns: ${config.patterns.join(', ')})
 3. Read and analyze relevant source files
-4. Look for:
-   - Code duplication
+4. Look for HIGH-PRIORITY issues:
+   - Code duplication (MOST IMPORTANT - fix first)
    - Complex or long functions
    - Poor naming
    - Missing types or documentation
    - Error handling issues
    - Performance bottlenecks
-5. Provide a summary of findings with prioritized recommendations
-6. Ask if I'd like you to proceed with any specific refactoring
+5. For EACH issue found, IMMEDIATELY apply the fix:
+   - Use the Edit tool to make the change
+   - Explain what you changed and why
+   - Move to the next issue
+6. Continue refactoring until all high-priority issues are addressed
+
+IMPORTANT: Do NOT ask for permission. You have full bypass authority to improve the code directly. Start refactoring immediately after analysis.
 
-Start by exploring the current directory structure.`;
+Start by exploring the current directory structure and begin refactoring.`;
 };

package/dist/cli/formatters/formatter-utils.d.ts

@@ -0,0 +1,23 @@
+export interface FormatterSection {
+    title: string;
+    content?: string;
+    items?: Array<{
+        label: string;
+        value?: string | number;
+        type?: 'success' | 'error' | 'info';
+    }>;
+    list?: Array<{
+        text: string;
+        isHighlight?: boolean;
+    }>;
+}
+export interface FormatterOptions {
+    title: string;
+    icon: string;
+    sections: FormatterSection[];
+    verbose?: boolean;
+}
+export declare const formatResults: (options: FormatterOptions) => void;
+export declare const createStatusSection: (featureId: string, status: string) => FormatterSection;
+export declare const createSummarySection: (summary?: string) => FormatterSection | null;
+export declare const createContentPreview: (content: string, title: string, maxLines?: number) => FormatterSection;

package/dist/cli/formatters/formatter-utils.js

@@ -0,0 +1,67 @@
+export const formatResults = (options) => {
+    const { title, icon, sections } = options;
+    console.log('\n' + '='.repeat(60));
+    console.log(`${icon} ${title}`);
+    console.log('='.repeat(60));
+    sections.forEach((section) => {
+        if (section.title) {
+            console.log(`\n${section.title}`);
+        }
+        if (section.content) {
+            console.log(section.content);
+        }
+        if (section.items) {
+            section.items.forEach((item) => {
+                const statusIcon = getStatusIcon(item.type);
+                const value = item.value !== undefined ? `: ${item.value}` : '';
+                console.log(`${statusIcon} ${item.label}${value}`);
+            });
+        }
+        if (section.list) {
+            section.list.forEach((listItem, index) => {
+                const prefix = listItem.isHighlight ? '   ⭐' : '   ';
+                console.log(`${prefix}${index + 1}. ${listItem.text}`);
+            });
+        }
+    });
+    console.log('\n' + '='.repeat(60));
+};
+export const createStatusSection = (featureId, status) => ({
+    title: '',
+    items: [
+        { label: '📋 Feature ID', value: featureId },
+        {
+            label: '📊 Status',
+            value: status === 'success' || status === 'testing_passed' ? '✅ Success' : '❌ Failed',
+            type: status === 'success' || status === 'testing_passed' ? 'success' : 'error'
+        }
+    ]
+});
+export const createSummarySection = (summary) => {
+    if (!summary)
+        return null;
+    return {
+        title: '📝 Summary:',
+        content: summary
+    };
+};
+export const createContentPreview = (content, title, maxLines = 10) => {
+    const lines = content.split('\n');
+    const previewLines = lines.slice(0, maxLines);
+    let displayContent = previewLines.join('\n');
+    if (lines.length > maxLines) {
+        displayContent += `\n... (${lines.length - maxLines} more lines)`;
+    }
+    return {
+        title: `${title}:`,
+        content: '─'.repeat(40) + '\n' + displayContent + '\n' + '─'.repeat(40)
+    };
+};
+function getStatusIcon(type) {
+    switch (type) {
+        case 'success': return '✅';
+        case 'error': return '❌';
+        case 'info': return 'ℹ️';
+        default: return '📊';
+    }
+}

package/dist/cli/utils/command-handler.d.ts

@@ -0,0 +1,23 @@
+import { CliOptions } from '../../types/index.js';
+export interface CommandOptions {
+    featureId: string;
+    mcpServerUrl: string;
+    mcpToken: string;
+    verbose?: boolean;
+}
+export interface CommandResult {
+    status: 'success' | 'error' | 'testing_passed' | 'testing_failed' | 'pending';
+    [key: string]: any;
+}
+export interface CommandConfig<TResult extends CommandResult> {
+    name: string;
+    getFeatureId: (options: CliOptions) => string | undefined;
+    checkRequirements: () => Promise<boolean>;
+    requirementsError: string;
+    startMessage: string;
+    successMessage: string;
+    errorMessage: string;
+    analyzer: (commandOptions: CommandOptions, config: any, ...args: any[]) => Promise<TResult>;
+    formatter: (result: TResult, verbose?: boolean) => void;
+}
+export declare function executeCommand<TResult extends CommandResult>(options: CliOptions, config: CommandConfig<TResult>): Promise<void>;

package/dist/cli/utils/command-handler.js

@@ -0,0 +1,39 @@
+import { logInfo, logError, logSuccess } from '../../utils/logger.js';
+import { validateCommandEnvironment, validateRequirements, } from './validation.js';
+export async function executeCommand(options, config) {
+    await validateRequirements(config.checkRequirements, config.requirementsError);
+    const { config: edsgerConfig, mcpServerUrl, mcpToken } = validateCommandEnvironment(options);
+    const featureId = config.getFeatureId(options);
+    if (!featureId) {
+        throw new Error(`Feature ID is required for ${config.name}`);
+    }
+    if (options.verbose) {
+        logInfo(`${config.startMessage}: ${featureId}`);
+    }
+    logInfo(`Starting ${config.name}...`);
+    try {
+        const result = await config.analyzer({
+            featureId,
+            mcpServerUrl,
+            mcpToken,
+            verbose: options.verbose,
+        }, edsgerConfig);
+        config.formatter(result, options.verbose);
+        if (result.status === 'success' || result.status === 'testing_passed') {
+            logSuccess(config.successMessage);
+            process.exit(0);
+        }
+        else if (result.status === 'error' || result.status === 'testing_failed') {
+            logError(config.errorMessage);
+            process.exit(1);
+        }
+        else {
+            logError(`${config.errorMessage}: ${result.status}`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        logError(`${config.errorMessage}: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}

package/dist/phases/bug-fixing/analyzer.js

@@ -1,5 +1,6 @@
 import { query } from '@anthropic-ai/claude-code';
 import { logInfo, logError } from '../../utils/logger.js';
+import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 import { fetchBugFixingContext, formatContextForPrompt, } from './context-fetcher.js';
 function userMessage(content) {
     return {
@@ -23,8 +24,25 @@ export const fixTestFailures = async (options, config) => {
             logInfo('Fetching bug fixing context via MCP endpoints...');
         }
         const context = await fetchBugFixingContext(mcpServerUrl, mcpToken, featureId, verbose);
+        // Fetch feedbacks for bug fixing phase
+        let feedbacksInfo;
+        try {
+            const feedbacksContext = await getFeedbacksForPhase({ featureId, mcpServerUrl, mcpToken, verbose }, 'bug_fixing');
+            if (feedbacksContext.feedbacks.length > 0) {
+                feedbacksInfo = formatFeedbacksForContext(feedbacksContext);
+                if (verbose) {
+                    logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to bug fixing context`);
+                }
+            }
+        }
+        catch (error) {
+            // Don't fail if feedbacks fetch fails - just log and continue
+            if (verbose) {
+                logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
+            }
+        }
         const systemPrompt = createSystemPrompt(config);
-        const bugFixPrompt = createBugFixPromptWithContext(featureId, testErrors, attemptNumber, context);
+        const bugFixPrompt = createBugFixPromptWithContext(featureId, testErrors, attemptNumber, context, feedbacksInfo);
         let lastAssistantResponse = '';
         let structuredFixResult = null;
         if (verbose) {
@@ -208,8 +226,12 @@ You MUST end your response with a JSON object containing the bug fix results in
 
 Focus on systematic bug fixing based on the provided context and test failure information.`;
 }
-function createBugFixPromptWithContext(featureId, testErrors, attemptNumber, context) {
-    const contextInfo = formatContextForPrompt(context, testErrors);
+function createBugFixPromptWithContext(featureId, testErrors, attemptNumber, context, feedbacksInfo) {
+    let contextInfo = formatContextForPrompt(context, testErrors);
+    // Add feedbacks context to the bug fixing prompt
+    if (feedbacksInfo) {
+        contextInfo = contextInfo + '\n\n' + feedbacksInfo;
+    }
     return `Fix the test failures for feature: ${featureId} (Attempt ${attemptNumber})
 
 ${contextInfo}

package/dist/phases/code-implementation/analyzer.js

@@ -1,6 +1,7 @@
 import { query } from '@anthropic-ai/claude-code';
 import { logInfo, logError } from '../../utils/logger.js';
 import { formatChecklistsForContext, } from '../../services/checklist.js';
+import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 import { fetchCodeImplementationContext, formatContextForPrompt, } from './context-fetcher.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 import { performVerificationCycle, buildImplementationResult, buildVerificationFailureResult, buildNoResultsError, } from './analyzer-helpers.js';
@@ -27,8 +28,25 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
             logInfo('Fetching code implementation context via MCP endpoints...');
         }
         const context = await fetchCodeImplementationContext(mcpServerUrl, mcpToken, featureId, verbose);
+        // Fetch feedbacks for code implementation phase
+        let feedbacksInfo;
+        try {
+            const feedbacksContext = await getFeedbacksForPhase({ featureId, mcpServerUrl, mcpToken, verbose }, 'code_implementation');
+            if (feedbacksContext.feedbacks.length > 0) {
+                feedbacksInfo = formatFeedbacksForContext(feedbacksContext);
+                if (verbose) {
+                    logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to implementation context`);
+                }
+            }
+        }
+        catch (error) {
+            // Don't fail if feedbacks fetch fails - just log and continue
+            if (verbose) {
+                logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
+            }
+        }
         const systemPrompt = createSystemPrompt(config, baseBranch, mcpServerUrl, mcpToken, featureId);
-        const initialImplementationPrompt = createImplementationPromptWithContext(featureId, context, baseBranch, checklistContext, verbose);
+        const initialImplementationPrompt = createImplementationPromptWithContext(featureId, context, baseBranch, checklistContext, verbose, feedbacksInfo);
         const maxIterations = options.maxVerificationIterations || 10;
         let currentIteration = 0;
         let currentPrompt = initialImplementationPrompt;
@@ -429,14 +447,18 @@ IMPORTANT: In the checklist context, look for lines that say "ID: [UUID]" in the
 
 Remember: Quality over speed. It's better to implement correctly than to rush and create bugs.`;
 };
-const createImplementationPromptWithContext = (featureId, context, baseBranch, checklistContext, verbose) => {
+const createImplementationPromptWithContext = (featureId, context, baseBranch, checklistContext, verbose, feedbacksInfo) => {
     const contextInfo = formatContextForPrompt(context);
-    // Add checklist context to the implementation prompt
     let finalContextInfo = contextInfo;
+    // Add feedbacks context to the implementation prompt
+    if (feedbacksInfo) {
+        finalContextInfo = finalContextInfo + '\n\n' + feedbacksInfo;
+    }
+    // Add checklist context to the implementation prompt
     let checklistInstructions = '';
     if (checklistContext && checklistContext.checklists.length > 0) {
         const checklistInfo = formatChecklistsForContext(checklistContext);
-        finalContextInfo = contextInfo + '\n\n' + checklistInfo;
+        finalContextInfo = finalContextInfo + '\n\n' + checklistInfo;
         // DEBUG: Log checklist context details
         console.log('=== DEBUG: Checklist Context for Code Implementation ===');
         console.log('Number of checklists:', checklistContext.checklists.length);
@@ -601,9 +623,7 @@ async function pushToRemote(branchName, verbose) {
                 return { success: true };
             }
             catch (retryError) {
-                const errorMessage = retryError instanceof Error
-                    ? retryError.message
-                    : String(retryError);
+                const errorMessage = retryError instanceof Error ? retryError.message : String(retryError);
                 return {
                     success: false,
                     error: errorMessage,

package/dist/phases/feature-analysis/analyzer.js

@@ -3,6 +3,7 @@ import { fetchFeatureAnalysisContext, } from './context-fetcher.js';
 import { formatFeatureAnalysisContext } from '../../prompts/formatters.js';
 import { createFeatureAnalysisSystemPrompt, createFeatureAnalysisPromptWithContext, } from '../../prompts/feature-analysis.js';
 import { formatChecklistsForContext, } from '../../services/checklist.js';
+import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 import { executeAnalysisQuery, performVerificationCycle, saveAnalysisArtifactsAsDraft, updateArtifactsToReady, deleteArtifacts, buildAnalysisResult, buildVerificationFailureResult, buildNoResultsError, } from './analyzer-helpers.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 export const analyzeFeatureWithMCP = async (options, config, checklistContext) => {
@@ -165,11 +166,28 @@ async function prepareAnalysisContext(mcpServerUrl, mcpToken, featureId, checkli
             logInfo(`  - ${img.url} -> ${img.localPath}`);
         });
     }
-    // Add checklist context to the analysis prompt
     let finalContextInfo = contextInfo;
+    // Add feedbacks context to the analysis prompt
+    try {
+        const feedbacksContext = await getFeedbacksForPhase({ featureId, mcpServerUrl, mcpToken, verbose }, 'feature-analysis');
+        if (feedbacksContext.feedbacks.length > 0) {
+            const feedbacksInfo = formatFeedbacksForContext(feedbacksContext);
+            finalContextInfo = finalContextInfo + '\n\n' + feedbacksInfo;
+            if (verbose) {
+                logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to context`);
+            }
+        }
+    }
+    catch (error) {
+        // Don't fail if feedbacks fetch fails - just log and continue
+        if (verbose) {
+            logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    // Add checklist context to the analysis prompt
     if (checklistContext && checklistContext.checklists.length > 0) {
         const checklistInfo = formatChecklistsForContext(checklistContext);
-        finalContextInfo = contextInfo + '\n\n' + checklistInfo;
+        finalContextInfo = finalContextInfo + '\n\n' + checklistInfo;
         if (verbose) {
             logInfo(`Added ${checklistContext.checklists.length} checklists to analysis context`);
         }

package/dist/phases/functional-testing/analyzer.js

@@ -1,6 +1,7 @@
 import { query } from '@anthropic-ai/claude-code';
 import { logInfo, logError } from '../../utils/logger.js';
 import { formatChecklistsForContext, } from '../../services/checklist.js';
+import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 import { saveFunctionalTestResultsWithRetry } from './http-fallback.js';
 import { fetchFunctionalTestingContext, formatContextForPrompt, } from './context-fetcher.js';
 import { updateFeatureStatus } from '../../api/features/index.js';
@@ -27,8 +28,25 @@ export const runFunctionalTesting = async (options, config, checklistContext) =>
             logInfo('Fetching feature testing context via MCP endpoints...');
         }
         const context = await fetchFunctionalTestingContext(mcpServerUrl, mcpToken, featureId, verbose);
+        // Fetch feedbacks for functional testing phase
+        let feedbacksInfo;
+        try {
+            const feedbacksContext = await getFeedbacksForPhase({ featureId, mcpServerUrl, mcpToken, verbose }, 'functional_testing');
+            if (feedbacksContext.feedbacks.length > 0) {
+                feedbacksInfo = formatFeedbacksForContext(feedbacksContext);
+                if (verbose) {
+                    logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to testing context`);
+                }
+            }
+        }
+        catch (error) {
+            // Don't fail if feedbacks fetch fails - just log and continue
+            if (verbose) {
+                logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
+            }
+        }
         const systemPrompt = createSystemPrompt(config, mcpServerUrl, mcpToken, featureId);
-        const testingPrompt = createTestingPromptWithContext(featureId, context, checklistContext, verbose);
+        const testingPrompt = createTestingPromptWithContext(featureId, context, checklistContext, verbose, feedbacksInfo);
         let lastAssistantResponse = '';
         let structuredTestResult = null;
         let testStatus = 'testing_failed';
@@ -475,13 +493,17 @@ IMPORTANT: In the checklist context, look for lines that say "ID: [UUID]" in the
 
 Focus on systematic testing based on the provided context information.${mcpInstructions}`;
 };
-const createTestingPromptWithContext = (featureId, context, checklistContext, verbose) => {
+const createTestingPromptWithContext = (featureId, context, checklistContext, verbose, feedbacksInfo) => {
     const contextInfo = formatContextForPrompt(context);
-    // Add checklist context to the testing prompt
     let finalContextInfo = contextInfo;
+    // Add feedbacks context to the testing prompt
+    if (feedbacksInfo) {
+        finalContextInfo = finalContextInfo + '\n\n' + feedbacksInfo;
+    }
+    // Add checklist context to the testing prompt
     if (checklistContext && checklistContext.checklists.length > 0) {
         const checklistInfo = formatChecklistsForContext(checklistContext);
-        finalContextInfo = contextInfo + '\n\n' + checklistInfo;
+        finalContextInfo = finalContextInfo + '\n\n' + checklistInfo;
         if (verbose) {
             logInfo(`Added ${checklistContext.checklists.length} checklists to testing context`);
         }

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

@@ -6,6 +6,7 @@ import { updateTechnicalDesign } from '../../api/features/index.js';
 import { formatTechnicalDesignContext } from '../../prompts/formatters.js';
 import { createTechnicalDesignSystemPrompt, createTechnicalDesignPromptWithContext, } from '../../prompts/technical-design.js';
 import { formatChecklistsForContext, } from '../../services/checklist.js';
+import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 import { performVerificationCycle, buildDesignResult, buildVerificationFailureResult, buildNoResultsError, } from './analyzer-helpers.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 function userMessage(content) {
@@ -155,20 +156,59 @@ async function prepareDesignContext(mcpServerUrl, mcpToken, featureId, checklist
             logInfo(`  - ${img.url} -> ${img.localPath}`);
         });
     }
-    // Add checklist context to the design prompt
     let finalContextInfo = contextInfo;
+    let hasFeedbacks = false;
+    // Check if there's existing technical design
+    const existingTechnicalDesign = context.feature.technical_design;
+    const hasExistingDesign = !!existingTechnicalDesign && existingTechnicalDesign.trim().length > 0;
+    // Add existing technical design to context if it exists
+    if (hasExistingDesign && verbose) {
+        logInfo('📋 Found existing technical design - will perform incremental update if feedbacks exist');
+    }
+    // Add feedbacks context to the design prompt
+    try {
+        const feedbacksContext = await getFeedbacksForPhase({ featureId, mcpServerUrl, mcpToken, verbose }, 'technical-design');
+        if (feedbacksContext.feedbacks.length > 0) {
+            hasFeedbacks = true;
+            const feedbacksInfo = formatFeedbacksForContext(feedbacksContext);
+            finalContextInfo = finalContextInfo + '\n\n' + feedbacksInfo;
+            if (verbose) {
+                logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to design context`);
+            }
+        }
+    }
+    catch (error) {
+        // Don't fail if feedbacks fetch fails - just log and continue
+        if (verbose) {
+            logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    // Add checklist context to the design prompt
     if (checklistContext && checklistContext.checklists.length > 0) {
         const checklistInfo = formatChecklistsForContext(checklistContext);
-        finalContextInfo = contextInfo + '\n\n' + checklistInfo;
+        finalContextInfo = finalContextInfo + '\n\n' + checklistInfo;
         if (verbose) {
             logInfo(`Added ${checklistContext.checklists.length} checklists to design context`);
         }
     }
-    const designPrompt = createTechnicalDesignPromptWithContext(featureId, finalContextInfo);
+    // Decide on prompt mode based on existing design and feedbacks
+    const isIncrementalUpdate = hasExistingDesign && hasFeedbacks;
+    if (isIncrementalUpdate && verbose) {
+        logInfo('🔄 Mode: Incremental Update (existing design + feedbacks)');
+    }
+    else if (hasExistingDesign && verbose) {
+        logInfo('🔄 Mode: Full Redesign (existing design but no feedbacks)');
+    }
+    else if (verbose) {
+        logInfo('✨ Mode: New Design (no existing design)');
+    }
+    const designPrompt = createTechnicalDesignPromptWithContext(featureId, finalContextInfo, existingTechnicalDesign, isIncrementalUpdate);
     return {
         featureName: context.feature.name,
         featureDescription: context.feature.description || undefined,
         designPrompt,
+        hasExistingDesign,
+        hasFeedbacks,
     };
 }
 /**

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

@@ -1,3 +1,3 @@
 import { EdsgerConfig } from '../types/index.js';
 export declare const createTechnicalDesignSystemPrompt: (_config: EdsgerConfig, mcpServerUrl?: string, mcpToken?: string, featureId?: string) => string;
-export declare const createTechnicalDesignPromptWithContext: (featureId: string, contextInfo: string) => string;
+export declare const createTechnicalDesignPromptWithContext: (featureId: string, contextInfo: string, existingTechnicalDesign?: string | null, isIncrementalUpdate?: boolean) => string;

package/dist/prompts/technical-design.js

@@ -89,11 +89,58 @@ IMPORTANT: In the checklist context, look for lines that say "ID: [UUID]" in the
 
 Focus on systematic technical design based on the provided context information.${mcpInstructions}`;
 };
-export const createTechnicalDesignPromptWithContext = (featureId, contextInfo) => {
-    return `Generate a comprehensive technical design for feature ID: ${featureId}
+export const createTechnicalDesignPromptWithContext = (featureId, contextInfo, existingTechnicalDesign, isIncrementalUpdate = false) => {
+    // If incremental update mode (existing design + feedbacks), create focused update prompt
+    if (isIncrementalUpdate && existingTechnicalDesign) {
+        return `Update the technical design for feature ID: ${featureId} based on human feedbacks
+
+## Current Technical Design
+
+${existingTechnicalDesign}
+
+## Context and Feedbacks
 
 ${contextInfo}
 
+## IMPORTANT: Incremental Update Mode
+
+You are in **INCREMENTAL UPDATE** mode. This means:
+
+1. **DO NOT redesign from scratch** - The current technical design is already approved
+2. **Focus ONLY on the feedbacks provided** - Address each feedback point specifically
+3. **Make targeted modifications** - Only change the sections that feedbacks request
+4. **Preserve approved sections** - Keep all parts of the design that are not mentioned in feedbacks
+5. **Track changes** - In your summary, clearly indicate what was modified and why
+
+## Update Instructions
+
+Follow this focused approach:
+
+1. **Review Current Design**: Carefully read the existing technical design above
+2. **Analyze Feedbacks**: Understand what specific changes are requested in the feedbacks
+3. **Make Targeted Updates**:
+   - Address each feedback point one by one
+   - Modify only the relevant sections of the design
+   - Preserve the structure and content of unchanged sections
+4. **Verify Completeness**: Ensure all feedbacks have been addressed
+
+## Important Notes
+- This is NOT a full redesign - only update what feedbacks specifically request
+- Maintain consistency with the existing design's structure and style
+- If a feedback is unclear, make your best interpretation and note it in recommendations
+- Keep all approved content that is not mentioned in feedbacks
+- Your summary should list each feedback addressed and the changes made
+
+Begin by reviewing the feedbacks and identifying which sections of the current design need updates.`;
+    }
+    // Default mode: full design (either new design or full redesign)
+    const designMode = existingTechnicalDesign
+        ? 'Update and improve the existing technical design, or redesign if needed'
+        : 'Generate a comprehensive technical design';
+    return `${designMode} for feature ID: ${featureId}
+
+${existingTechnicalDesign ? `## Existing Technical Design\n\n${existingTechnicalDesign}\n\n` : ''}${contextInfo}
+
 ## Technical Design Instructions
 
 Follow this systematic approach:
@@ -122,7 +169,7 @@ Follow this systematic approach:
 - Focus on creating detailed architectural specifications
 - Consider the user stories to understand what needs to be built
 - Use test cases to inform testing strategy and validation approaches
-- Build upon existing technical design if available, or create from scratch
+${existingTechnicalDesign ? '- Build upon or improve the existing technical design provided above' : '- Create a complete new technical design from scratch'}
 - Consider integration with existing systems and architecture
 - Address scalability, maintainability, and performance requirements
 

package/dist/services/feedbacks.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Feedbacks service for pipeline integration
+ * Provides human-guided feedbacks to influence Claude Code behavior in each phase
+ */
+import { PipelinePhaseOptions } from '../types/pipeline.js';
+export type { PipelinePhaseOptions };
+export type FeedbackType = 'requirement' | 'constraint' | 'preference' | 'context' | 'quality_criteria';
+export interface Feedback {
+    id: string;
+    feature_id: string | null;
+    product_id: string | null;
+    phase: string;
+    feedback_type: FeedbackType;
+    title: string;
+    content: string;
+    priority: number;
+    is_active: boolean;
+    created_by: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface FeedbacksContext {
+    phase: string;
+    feature_id: string;
+    feedbacks: Feedback[];
+}
+/**
+ * Fetch feedbacks for a specific phase
+ * Includes both feature-level and product-level feedbacks
+ */
+export declare function getFeedbacksForPhase(options: PipelinePhaseOptions, phase: string): Promise<FeedbacksContext>;
+/**
+ * Format feedbacks context as string for LLM consumption
+ */
+export declare function formatFeedbacksForContext(context: FeedbacksContext): string;

package/dist/services/feedbacks.js

@@ -0,0 +1,142 @@
+/**
+ * Feedbacks service for pipeline integration
+ * Provides human-guided feedbacks to influence Claude Code behavior in each phase
+ */
+/**
+ * Fetch feedbacks for a specific phase
+ * Includes both feature-level and product-level feedbacks
+ */
+export async function getFeedbacksForPhase(options, phase) {
+    const { mcpServerUrl, mcpToken, featureId, verbose } = options;
+    // Convert phase name from hyphen to underscore format for database compatibility
+    // e.g., 'feature-analysis' -> 'feature_analysis'
+    const dbPhase = phase.replace(/-/g, '_');
+    if (verbose) {
+        console.log(`🔍 Fetching feedbacks: phase="${phase}" (db: "${dbPhase}"), feature_id="${featureId}"`);
+    }
+    const response = await fetch(`${mcpServerUrl}/mcp`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${mcpToken}`,
+        },
+        body: JSON.stringify({
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'feedbacks/get',
+            params: {
+                feature_id: featureId,
+                phase: dbPhase,
+            },
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to fetch feedbacks for phase "${phase}": ${response.status} ${response.statusText}. Response: ${errorText}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+        throw new Error(`MCP Error for phase "${phase}": ${data.error.message || JSON.stringify(data.error)}`);
+    }
+    // Handle empty result gracefully
+    if (!data.result) {
+        return {
+            phase,
+            feature_id: featureId,
+            feedbacks: [],
+        };
+    }
+    return data.result;
+}
+/**
+ * Format feedbacks context as string for LLM consumption
+ */
+export function formatFeedbacksForContext(context) {
+    if (!context.feedbacks || context.feedbacks.length === 0) {
+        return '';
+    }
+    // Group feedbacks by type
+    const grouped = groupBy(context.feedbacks, 'feedback_type');
+    const sections = [];
+    // Requirements
+    if (grouped.requirement && grouped.requirement.length > 0) {
+        sections.push(`## 📋 Additional Requirements\n\n${formatFeedbacksList(grouped.requirement)}`);
+    }
+    // Constraints
+    if (grouped.constraint && grouped.constraint.length > 0) {
+        sections.push(`## 🚫 Constraints\n\n${formatFeedbacksList(grouped.constraint)}`);
+    }
+    // Preferences
+    if (grouped.preference && grouped.preference.length > 0) {
+        sections.push(`## 💡 Preferences\n\n${formatFeedbacksList(grouped.preference)}`);
+    }
+    // Context
+    if (grouped.context && grouped.context.length > 0) {
+        sections.push(`## 🔍 Additional Context\n\n${formatFeedbacksList(grouped.context)}`);
+    }
+    // Quality Criteria
+    if (grouped.quality_criteria && grouped.quality_criteria.length > 0) {
+        sections.push(`## ✅ Quality Criteria\n\n${formatFeedbacksList(grouped.quality_criteria)}`);
+    }
+    const phaseDisplay = context.phase.replace(/_/g, '-');
+    return `
+---
+
+# 🎯 Human Feedbacks for ${phaseDisplay} Phase
+
+These feedbacks have been provided by the development team to guide your work in this phase. They represent domain knowledge, business constraints, and quality expectations that must be incorporated into your analysis and outputs.
+
+${sections.join('\n\n')}
+
+---
+
+**IMPORTANT**: These human-provided feedbacks are MANDATORY and take precedence over default behavior. Please ensure your work:
+- ✅ Satisfies ALL requirements listed above
+- ✅ Respects ALL constraints
+- ✅ Incorporates stated preferences where possible
+- ✅ Considers the additional context provided
+- ✅ Meets ALL quality criteria
+
+If any feedback conflicts with checklist items or other requirements, prioritize the human feedbacks and note any conflicts in your response.
+`;
+}
+/**
+ * Format a list of feedbacks with priority ordering
+ */
+function formatFeedbacksList(feedbacks) {
+    // Sort by priority (highest first)
+    const sorted = [...feedbacks].sort((a, b) => b.priority - a.priority);
+    return sorted
+        .map((feedback, idx) => {
+        const priorityBadge = getPriorityBadge(feedback.priority);
+        return `### ${idx + 1}. ${feedback.title} ${priorityBadge}\n\n${feedback.content}\n`;
+    })
+        .join('\n');
+}
+/**
+ * Get priority badge emoji
+ */
+function getPriorityBadge(priority) {
+    if (priority >= 9)
+        return '🔴'; // Critical
+    if (priority >= 7)
+        return '🟠'; // High
+    if (priority >= 5)
+        return '🟡'; // Medium
+    if (priority >= 3)
+        return '🟢'; // Low
+    return '⚪'; // Minimal
+}
+/**
+ * Group array of objects by a key
+ */
+function groupBy(array, key) {
+    return array.reduce((result, item) => {
+        const groupKey = String(item[key]);
+        if (!result[groupKey]) {
+            result[groupKey] = [];
+        }
+        result[groupKey].push(item);
+        return result;
+    }, {});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "type": "module",
   "main": "dist/index.js",
   "bin": {