edsger 0.2.2 → 0.2.4

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

@@ -1,11 +1,13 @@
 import { query } from '@anthropic-ai/claude-code';
 import { logInfo, logError } from '../../utils/logger.js';
 import { saveTechnicalDesignViaHttp } from './http-fallback.js';
-import { fetchTechnicalDesignContext, } from './context-fetcher.js';
+import { fetchTechnicalDesignContext } from './context-fetcher.js';
 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 { performVerificationCycle, buildDesignResult, buildVerificationFailureResult, buildNoResultsError, } from './analyzer-helpers.js';
+import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 function userMessage(content) {
     return {
         type: 'user',
@@ -23,351 +25,319 @@ export const generateTechnicalDesign = async (options, config, checklistContext)
         logInfo(`Using MCP server: ${mcpServerUrl}`);
     }
     try {
-        // Fetch all required context information via MCP endpoints
-        if (verbose) {
-            logInfo('Fetching technical design context via MCP endpoints...');
-        }
-        const context = await fetchTechnicalDesignContext(mcpServerUrl, mcpToken, featureId, verbose);
+        // Fetch and prepare context
+        const context = await prepareDesignContext(mcpServerUrl, mcpToken, featureId, checklistContext, verbose);
         const systemPrompt = createTechnicalDesignSystemPrompt(config, mcpServerUrl, mcpToken, featureId);
-        const contextInfo = formatTechnicalDesignContext(context);
-        // Add checklist context to the design prompt
-        let finalContextInfo = contextInfo;
-        if (checklistContext && checklistContext.checklists.length > 0) {
-            const checklistInfo = formatChecklistsForContext(checklistContext);
-            finalContextInfo = contextInfo + '\n\n' + checklistInfo;
-            if (verbose) {
-                logInfo(`Added ${checklistContext.checklists.length} checklists to design context`);
-            }
-        }
-        const designPrompt = createTechnicalDesignPromptWithContext(featureId, finalContextInfo);
-        let lastAssistantResponse = '';
+        const initialDesignPrompt = context.designPrompt;
+        const maxIterations = options.maxVerificationIterations || 10;
+        let currentIteration = 0;
+        let currentPrompt = initialDesignPrompt;
         let structuredDesignResult = null;
+        let verificationResult = null;
         if (verbose) {
             logInfo('Starting Claude Code query with pre-fetched information...');
         }
-        // Use Claude Code SDK without MCP servers - all info is pre-fetched
-        for await (const message of query({
-            prompt: prompt(designPrompt),
-            options: {
-                appendSystemPrompt: systemPrompt,
-                model: config.claude.model || 'sonnet',
-                maxTurns: 1000,
-                permissionMode: 'bypassPermissions',
-            },
-        })) {
+        // Iterative improvement loop: design → verification → improve → re-design
+        while (currentIteration < maxIterations) {
+            currentIteration++;
+            if (verbose && currentIteration > 1) {
+                logInfo(`\n🔄 Iteration ${currentIteration}/${maxIterations}: Improving design based on verification feedback...`);
+            }
+            // Log iteration start (for iterations after the first)
+            if (currentIteration > 1) {
+                await logFeaturePhaseEvent(mcpServerUrl, mcpToken, {
+                    featureId,
+                    eventType: 'phase_started',
+                    phase: 'technical_design',
+                    result: 'info',
+                    metadata: {
+                        iteration: currentIteration,
+                        max_iterations: maxIterations,
+                        re_design: true,
+                        timestamp: new Date().toISOString(),
+                    },
+                }, verbose);
+            }
+            // Execute design query
+            const newDesignResult = await executeDesignQuery(currentPrompt, systemPrompt, config, verbose);
+            // No result produced, break out
+            if (!newDesignResult?.technical_design) {
+                if (verbose) {
+                    logError('⚠️  Design generation failed in this iteration');
+                }
+                break;
+            }
+            // Update with new design result
+            structuredDesignResult = newDesignResult;
+            // Log design completion for this iteration
+            await logFeaturePhaseEvent(mcpServerUrl, mcpToken, {
+                featureId,
+                eventType: 'phase_completed',
+                phase: 'technical_design',
+                result: 'success',
+                metadata: {
+                    iteration: currentIteration,
+                    max_iterations: maxIterations,
+                    design_step: 'completed',
+                    timestamp: new Date().toISOString(),
+                },
+            }, verbose);
+            // Save technical design immediately after generation
             if (verbose) {
-                logInfo(`Received message type: ${message.type}`);
+                logInfo(`💾 Saving technical design (iteration ${currentIteration})...`);
             }
-            // Stream the technical design generation process
-            if (message.type === 'assistant' && message.message?.content) {
-                for (const content of message.message.content) {
-                    if (content.type === 'text') {
-                        lastAssistantResponse += content.text + '\n';
-                        if (verbose) {
-                            console.log(`\n🤖 ${content.text}`);
-                        }
+            await saveTechnicalDesign(mcpServerUrl, mcpToken, featureId, structuredDesignResult.technical_design, verbose);
+            // Perform verification cycle
+            const verificationCycle = await performVerificationCycle(structuredDesignResult.technical_design, checklistContext || null, featureId, context.featureName, context.featureDescription, config, currentIteration, maxIterations, mcpServerUrl, mcpToken, verbose);
+            verificationResult = verificationCycle.verificationResult;
+            // If verification passed, exit
+            if (verificationCycle.passed) {
+                if (verbose) {
+                    logInfo('✅ Verification passed! Technical design saved.');
+                }
+                break;
+            }
+            // Verification failed
+            if (currentIteration < maxIterations && verificationCycle.nextPrompt) {
+                // We have more iterations - retry with improvement prompt
+                if (verbose) {
+                    logInfo(`🔄 Will improve and save design in next iteration (${maxIterations - currentIteration} attempts remaining)`);
+                }
+                currentPrompt = verificationCycle.nextPrompt;
+            }
+            else {
+                // Max iterations reached or no next prompt - exit loop
+                if (verbose) {
+                    logInfo('⚠️  Max iterations reached. Last design version saved.');
+                }
+                break;
+            }
+        }
+        // Handle results
+        if (!structuredDesignResult?.technical_design) {
+            return buildNoResultsError(featureId);
+        }
+        // Check if verification failed after all iterations
+        if (verificationResult &&
+            verificationResult.rejected_count > 0 &&
+            checklistContext &&
+            checklistContext.checklists.length > 0) {
+            logError(`❌ Final result: Checklist verification FAILED after ${currentIteration} iterations`);
+            logError(`   Technical design saved for manual review`);
+            return buildVerificationFailureResult(featureId, structuredDesignResult.technical_design, verificationResult, currentIteration);
+        }
+        // Return success result
+        return buildDesignResult(featureId, structuredDesignResult.technical_design, structuredDesignResult.summary ||
+            'Technical design generated successfully', currentIteration);
+    }
+    catch (error) {
+        logError(`Technical design generation failed: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            featureId,
+            technicalDesign: null,
+            status: 'error',
+            summary: `Generation failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+};
+/**
+ * Prepare all context information needed for design
+ */
+async function prepareDesignContext(mcpServerUrl, mcpToken, featureId, checklistContext, verbose) {
+    if (verbose) {
+        logInfo('Fetching technical design context via MCP endpoints...');
+    }
+    const context = await fetchTechnicalDesignContext(mcpServerUrl, mcpToken, featureId, verbose);
+    const { content: contextInfo, downloadedImages } = await formatTechnicalDesignContext(context);
+    if (verbose && downloadedImages.length > 0) {
+        logInfo(`Downloaded ${downloadedImages.length} images for Claude Code:`);
+        downloadedImages.forEach((img) => {
+            logInfo(`  - ${img.url} -> ${img.localPath}`);
+        });
+    }
+    // Add checklist context to the design prompt
+    let finalContextInfo = contextInfo;
+    if (checklistContext && checklistContext.checklists.length > 0) {
+        const checklistInfo = formatChecklistsForContext(checklistContext);
+        finalContextInfo = contextInfo + '\n\n' + checklistInfo;
+        if (verbose) {
+            logInfo(`Added ${checklistContext.checklists.length} checklists to design context`);
+        }
+    }
+    const designPrompt = createTechnicalDesignPromptWithContext(featureId, finalContextInfo);
+    return {
+        featureName: context.feature.name,
+        featureDescription: context.feature.description || undefined,
+        designPrompt,
+    };
+}
+/**
+ * Execute design query and parse result
+ */
+async function executeDesignQuery(designPrompt, systemPrompt, config, verbose) {
+    let lastAssistantResponse = '';
+    let structuredDesignResult = null;
+    if (verbose) {
+        logInfo('🤖 Starting design agent query...');
+    }
+    // Use Claude Code SDK without MCP servers - all info is pre-fetched
+    for await (const message of query({
+        prompt: prompt(designPrompt),
+        options: {
+            appendSystemPrompt: systemPrompt,
+            model: config.claude.model || 'sonnet',
+            maxTurns: 1000,
+            permissionMode: 'bypassPermissions',
+        },
+    })) {
+        if (verbose) {
+            logInfo(`   Received message type: ${message.type}`);
+        }
+        // Stream the technical design generation process
+        if (message.type === 'assistant' && message.message?.content) {
+            for (const content of message.message.content) {
+                if (content.type === 'text') {
+                    lastAssistantResponse += content.text + '\n';
+                    if (verbose) {
+                        console.log(`\n🤖 ${content.text}`);
                     }
-                    else if (content.type === 'tool_use') {
-                        if (verbose) {
-                            console.log(`\n🔧 ${content.name}: ${content.input.description || 'Running...'}`);
-                        }
+                }
+                else if (content.type === 'tool_use') {
+                    if (verbose) {
+                        console.log(`\n🔧 ${content.name}: ${content.input.description || 'Running...'}`);
                     }
                 }
             }
-            if (message.type === 'result') {
-                if (message.subtype === 'success') {
-                    logInfo('\n🎨 Technical design generation completed, parsing results...');
-                    try {
-                        // Try to extract JSON from markdown code block or parse directly
-                        const responseText = message.result || lastAssistantResponse;
-                        let jsonResult = null;
-                        // DEBUG: Log response text details
-                        console.log('=== DEBUG: Response Text Analysis ===');
-                        console.log('message.result exists:', !!message.result);
-                        console.log('lastAssistantResponse exists:', !!lastAssistantResponse);
-                        console.log('responseText length:', responseText.length);
-                        console.log('responseText first 200 chars:', JSON.stringify(responseText.substring(0, 200)));
-                        console.log('responseText last 200 chars:', JSON.stringify(responseText.substring(responseText.length - 200)));
-                        console.log('Contains ```json:', responseText.includes('```json'));
-                        console.log('Contains technical_design_result:', responseText.includes('"technical_design_result"'));
-                        // First try to extract JSON from markdown code block
-                        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-                        console.log('=== DEBUG: Markdown Block Match ===');
-                        console.log('jsonBlockMatch found:', !!jsonBlockMatch);
-                        if (jsonBlockMatch) {
-                            console.log('Matched JSON length:', jsonBlockMatch[1].length);
-                            console.log('Matched JSON first 100 chars:', JSON.stringify(jsonBlockMatch[1].substring(0, 100)));
-                            jsonResult = JSON.parse(jsonBlockMatch[1]);
-                        }
-                        else {
-                            console.log('=== DEBUG: JSON Object Search ===');
-                            // Try to find JSON object containing "technical_design_result"
-                            const lines = responseText.split('\n');
-                            let jsonStartIndex = -1;
-                            console.log('Total lines:', lines.length);
-                            console.log('Lines preview:', lines
-                                .slice(0, 10)
-                                .map((line, i) => `${i}: ${JSON.stringify(line.substring(0, 50))}`));
-                            // Find the line that contains the start of a JSON object with "technical_design_result"
-                            for (let i = 0; i < lines.length; i++) {
-                                const line = lines[i].trim();
-                                if (line.startsWith('{') &&
-                                    responseText.includes('"technical_design_result"')) {
-                                    console.log(`Found { at line ${i}: ${JSON.stringify(line)}`);
-                                    const fromThisLine = lines.slice(i).join('\n');
-                                    if (fromThisLine.includes('"technical_design_result"')) {
-                                        jsonStartIndex = responseText.indexOf(lines[i]);
-                                        console.log(`JSON start found at line ${i}, responseText index: ${jsonStartIndex}`);
-                                        break;
-                                    }
+        }
+        if (message.type === 'result') {
+            if (message.subtype === 'success') {
+                logInfo('\n🎨 Technical design generation completed, parsing results...');
+                try {
+                    // Try to extract JSON from markdown code block or parse directly
+                    const responseText = message.result || lastAssistantResponse;
+                    let jsonResult = null;
+                    // First try to extract JSON from markdown code block
+                    const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                    if (jsonBlockMatch) {
+                        jsonResult = JSON.parse(jsonBlockMatch[1]);
+                    }
+                    else {
+                        // Try to find JSON object containing "technical_design_result"
+                        let jsonStartIndex = -1;
+                        // Find the position of "technical_design_result" and work backwards to find the opening brace
+                        if (responseText.includes('"technical_design_result"')) {
+                            const targetIndex = responseText.indexOf('"technical_design_result"');
+                            // Work backwards from "technical_design_result" to find the opening '{'
+                            for (let i = targetIndex; i >= 0; i--) {
+                                if (responseText[i] === '{') {
+                                    jsonStartIndex = i;
+                                    break;
                                 }
                             }
-                            if (jsonStartIndex !== -1) {
-                                // Find the complete JSON object starting from this position
-                                let braceCount = 0;
-                                let endIndex = jsonStartIndex;
-                                let inString = false;
-                                let escapeNext = false;
-                                for (let i = jsonStartIndex; i < responseText.length; i++) {
-                                    const char = responseText[i];
-                                    if (escapeNext) {
-                                        escapeNext = false;
-                                        continue;
-                                    }
-                                    if (char === '\\' && inString) {
-                                        escapeNext = true;
-                                        continue;
-                                    }
-                                    if (char === '"') {
-                                        inString = !inString;
-                                        continue;
+                        }
+                        if (jsonStartIndex !== -1) {
+                            // Find the complete JSON object starting from this position
+                            let braceCount = 0;
+                            let endIndex = jsonStartIndex;
+                            let inString = false;
+                            let escapeNext = false;
+                            for (let i = jsonStartIndex; i < responseText.length; i++) {
+                                const char = responseText[i];
+                                if (escapeNext) {
+                                    escapeNext = false;
+                                    continue;
+                                }
+                                if (char === '\\' && inString) {
+                                    escapeNext = true;
+                                    continue;
+                                }
+                                if (char === '"') {
+                                    inString = !inString;
+                                    continue;
+                                }
+                                if (!inString) {
+                                    if (char === '{') {
+                                        braceCount++;
                                     }
-                                    if (!inString) {
-                                        if (char === '{') {
-                                            braceCount++;
-                                        }
-                                        else if (char === '}') {
-                                            braceCount--;
-                                            if (braceCount === 0) {
-                                                endIndex = i;
-                                                break;
-                                            }
+                                    else if (char === '}') {
+                                        braceCount--;
+                                        if (braceCount === 0) {
+                                            endIndex = i;
+                                            break;
                                         }
                                     }
                                 }
-                                const jsonStr = responseText.substring(jsonStartIndex, endIndex + 1);
-                                console.log('=== DEBUG: JSON Extraction ===');
-                                console.log('JSON start index:', jsonStartIndex);
-                                console.log('JSON end index:', endIndex);
-                                console.log('Extracted JSON length:', jsonStr.length);
-                                console.log('Extracted JSON first 100 chars:', JSON.stringify(jsonStr.substring(0, 100)));
-                                console.log('Extracted JSON last 100 chars:', JSON.stringify(jsonStr.substring(jsonStr.length - 100)));
-                                try {
-                                    jsonResult = JSON.parse(jsonStr);
-                                    console.log('JSON parsing succeeded!');
-                                }
-                                catch (parseError) {
-                                    console.log('Failed to parse extracted JSON:', parseError);
-                                    console.log('Extracted JSON string:', jsonStr.substring(0, 200) + '...');
-                                    console.log('=== DEBUG: Fallback to full response ===');
-                                    console.log('Attempting to parse entire responseText as JSON');
-                                    // Try to parse the entire response as JSON as fallback
-                                    jsonResult = JSON.parse(responseText);
-                                }
                             }
-                            else {
-                                console.log('=== DEBUG: No JSON start found ===');
-                                console.log('Falling back to parse entire responseText as JSON');
-                                // Try to parse the entire response as JSON
-                                jsonResult = JSON.parse(responseText);
+                            const jsonStr = responseText.substring(jsonStartIndex, endIndex + 1);
+                            try {
+                                jsonResult = JSON.parse(jsonStr);
                             }
-                        }
-                        console.log('=== DEBUG: Final Result Processing ===');
-                        console.log('jsonResult exists:', !!jsonResult);
-                        console.log('jsonResult has technical_design_result:', !!(jsonResult && jsonResult.technical_design_result));
-                        if (jsonResult && jsonResult.technical_design_result) {
-                            console.log('checklist_item_results in parsed JSON:', !!jsonResult.technical_design_result.checklist_item_results);
-                            if (jsonResult.technical_design_result.checklist_item_results) {
-                                console.log('checklist_item_results length:', jsonResult.technical_design_result.checklist_item_results
-                                    .length);
+                            catch (parseError) {
+                                logError(`Failed to parse extracted JSON: ${parseError}`);
+                                // Try to parse the entire response as JSON as fallback
+                                jsonResult = JSON.parse(responseText);
                             }
-                            structuredDesignResult = jsonResult.technical_design_result;
                         }
                         else {
-                            throw new Error('Invalid JSON structure');
+                            // Try to parse the entire response as JSON
+                            jsonResult = JSON.parse(responseText);
                         }
                     }
-                    catch (error) {
-                        logError(`Failed to parse structured design result: ${error}`);
-                        // Extract technical design from response if JSON parsing fails
-                        const extractedDesign = extractTechnicalDesignFromResponse(message.result || lastAssistantResponse);
-                        structuredDesignResult = {
-                            status: extractedDesign ? 'success' : 'error',
-                            technical_design: extractedDesign,
-                            summary: extractedDesign
-                                ? 'Technical design generated successfully'
-                                : 'Failed to generate technical design',
-                        };
-                    }
-                }
-                else {
-                    logError(`\n⚠️  Technical design generation incomplete: ${message.subtype}`);
-                    if (message.subtype === 'error_max_turns') {
-                        logError('💡 Try increasing timeout or reducing complexity');
+                    if (jsonResult && jsonResult.technical_design_result) {
+                        structuredDesignResult = jsonResult.technical_design_result;
                     }
-                    // Try to parse results from the last assistant response
-                    if (lastAssistantResponse) {
-                        try {
-                            const responseText = lastAssistantResponse;
-                            let jsonResult = null;
-                            const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-                            if (jsonBlockMatch) {
-                                jsonResult = JSON.parse(jsonBlockMatch[1]);
-                                if (jsonResult && jsonResult.technical_design_result) {
-                                    structuredDesignResult = jsonResult.technical_design_result;
-                                }
-                            }
-                            else {
-                                // Try to find JSON object containing "technical_design_result"
-                                const lines = responseText.split('\n');
-                                let jsonStartIndex = -1;
-                                // Find the line that contains the start of a JSON object with "technical_design_result"
-                                for (let i = 0; i < lines.length; i++) {
-                                    const line = lines[i].trim();
-                                    if (line.startsWith('{') &&
-                                        responseText.includes('"technical_design_result"')) {
-                                        const fromThisLine = lines.slice(i).join('\n');
-                                        if (fromThisLine.includes('"technical_design_result"')) {
-                                            jsonStartIndex = responseText.indexOf(lines[i]);
-                                            break;
-                                        }
-                                    }
-                                }
-                                if (jsonStartIndex !== -1) {
-                                    // Find the complete JSON object starting from this position
-                                    let braceCount = 0;
-                                    let endIndex = jsonStartIndex;
-                                    let inString = false;
-                                    let escapeNext = false;
-                                    for (let i = jsonStartIndex; i < responseText.length; i++) {
-                                        const char = responseText[i];
-                                        if (escapeNext) {
-                                            escapeNext = false;
-                                            continue;
-                                        }
-                                        if (char === '\\' && inString) {
-                                            escapeNext = true;
-                                            continue;
-                                        }
-                                        if (char === '"') {
-                                            inString = !inString;
-                                            continue;
-                                        }
-                                        if (!inString) {
-                                            if (char === '{') {
-                                                braceCount++;
-                                            }
-                                            else if (char === '}') {
-                                                braceCount--;
-                                                if (braceCount === 0) {
-                                                    endIndex = i;
-                                                    break;
-                                                }
-                                            }
-                                        }
-                                    }
-                                    const jsonStr = responseText.substring(jsonStartIndex, endIndex + 1);
-                                    try {
-                                        jsonResult = JSON.parse(jsonStr);
-                                        if (jsonResult && jsonResult.technical_design_result) {
-                                            structuredDesignResult =
-                                                jsonResult.technical_design_result;
-                                        }
-                                    }
-                                    catch (parseError) {
-                                        logError(`Failed to parse extracted JSON: ${parseError}`);
-                                    }
-                                }
-                                if (!structuredDesignResult) {
-                                    const extractedDesign = extractTechnicalDesignFromResponse(lastAssistantResponse);
-                                    if (extractedDesign) {
-                                        structuredDesignResult = {
-                                            status: 'success',
-                                            technical_design: extractedDesign,
-                                            summary: 'Technical design generated successfully',
-                                        };
-                                    }
-                                }
-                            }
-                        }
-                        catch (error) {
-                            logError(`Failed to parse assistant response: ${error}`);
-                        }
+                    else {
+                        throw new Error('Invalid JSON structure');
                     }
                 }
-            }
-        }
-        // Save the technical design if we have it
-        if (structuredDesignResult?.technical_design) {
-            if (verbose) {
-                logInfo('Saving technical design...');
-            }
-            const designSaved = await updateTechnicalDesign(mcpServerUrl, mcpToken, featureId, structuredDesignResult.technical_design, verbose);
-            // Try HTTP fallback if direct update failed
-            if (!designSaved) {
-                if (verbose) {
-                    logInfo('Direct update failed, trying HTTP fallback...');
+                catch (error) {
+                    logError(`Failed to parse structured design result: ${error}`);
+                    // Extract technical design from response if JSON parsing fails
+                    const extractedDesign = extractTechnicalDesignFromResponse(message.result || lastAssistantResponse);
+                    structuredDesignResult = {
+                        status: extractedDesign ? 'success' : 'error',
+                        technical_design: extractedDesign,
+                        summary: extractedDesign
+                            ? 'Technical design generated successfully'
+                            : 'Failed to generate technical design',
+                    };
                 }
-                const fallbackSaved = await saveTechnicalDesignViaHttp({
-                    mcpServerUrl,
-                    mcpToken,
-                    featureId,
-                    technicalDesign: structuredDesignResult.technical_design,
-                    verbose,
-                });
-                if (!fallbackSaved && verbose) {
-                    logError('⚠️  Both direct update and HTTP fallback failed');
+            }
+            else {
+                logError(`\n⚠️  Technical design generation incomplete: ${message.subtype}`);
+                if (message.subtype === 'error_max_turns') {
+                    logError('💡 Try increasing timeout or reducing complexity');
                 }
-                return {
-                    featureId,
-                    technicalDesign: structuredDesignResult.technical_design,
-                    status: fallbackSaved ? 'success' : 'error',
-                    summary: fallbackSaved
-                        ? 'Technical design generated and saved via HTTP fallback'
-                        : 'Technical design generated but failed to save',
-                    savedViaHttp: fallbackSaved,
-                    data: {
-                        checklist_item_results: structuredDesignResult.checklist_item_results || [],
-                    },
-                };
             }
-            return {
-                featureId,
-                technicalDesign: structuredDesignResult.technical_design,
-                status: 'success',
-                summary: 'Technical design generated and saved successfully',
-                data: {
-                    checklist_item_results: structuredDesignResult.checklist_item_results || [],
-                },
-            };
         }
-        return {
-            featureId,
-            technicalDesign: null,
-            status: 'error',
-            summary: 'No technical design was generated',
-        };
     }
-    catch (error) {
-        logError(`Technical design generation failed: ${error instanceof Error ? error.message : String(error)}`);
-        return {
+    return structuredDesignResult;
+}
+/**
+ * Save technical design document
+ */
+async function saveTechnicalDesign(mcpServerUrl, mcpToken, featureId, technicalDesign, verbose) {
+    if (verbose) {
+        logInfo('Saving technical design...');
+    }
+    const designSaved = await updateTechnicalDesign(mcpServerUrl, mcpToken, featureId, technicalDesign, verbose);
+    // Try HTTP fallback if direct update failed
+    if (!designSaved) {
+        if (verbose) {
+            logInfo('Direct update failed, trying HTTP fallback...');
+        }
+        const fallbackSaved = await saveTechnicalDesignViaHttp({
+            mcpServerUrl,
+            mcpToken,
             featureId,
-            technicalDesign: null,
-            status: 'error',
-            summary: `Generation failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
+            technicalDesign,
+            verbose,
+        });
+        if (!fallbackSaved && verbose) {
+            logError('⚠️  Both direct update and HTTP fallback failed');
+        }
     }
-};
+}
 const extractTechnicalDesignFromResponse = (response) => {
     // Try to extract technical design content from the response
     // Look for markdown sections that contain technical design