edsger 0.41.1 → 0.41.2

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

@@ -0,0 +1,461 @@
+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 { updateTechnicalDesign } from '../../api/features/index.js';
+import { formatTechnicalDesignContext } from '../../utils/formatters.js';
+import { createTechnicalDesignSystemPrompt, createTechnicalDesignPromptWithContext, } from './prompts.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) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(analysisPrompt) {
+    yield userMessage(analysisPrompt);
+    await new Promise((res) => setTimeout(res, 10000));
+}
+export const generateTechnicalDesign = async (options, config, checklistContext) => {
+    const { featureId, verbose } = options;
+    if (verbose) {
+        logInfo(`Starting technical design generation for feature ID: ${featureId}`);
+    }
+    try {
+        // Fetch and prepare context
+        const context = await prepareDesignContext(featureId, checklistContext, verbose);
+        const systemPrompt = createTechnicalDesignSystemPrompt(config, featureId);
+        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...');
+        }
+        // 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({
+                    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({
+                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(`💾 Saving technical design (iteration ${currentIteration})...`);
+            }
+            await saveTechnicalDesign(featureId, structuredDesignResult.technical_design, verbose);
+            // Perform verification cycle
+            const verificationCycle = await performVerificationCycle(structuredDesignResult.technical_design, checklistContext || null, context.feedbacksContext, featureId, context.featureName, context.featureDescription, config, currentIteration, maxIterations, 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(featureId, checklistContext, verbose) {
+    if (verbose) {
+        logInfo('Fetching technical design context via MCP endpoints...');
+    }
+    const context = await fetchTechnicalDesignContext(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}`);
+        });
+    }
+    let finalContextInfo = contextInfo;
+    let hasFeedbacks = false;
+    let feedbacksContext = null;
+    // 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 {
+        feedbacksContext = await getFeedbacksForPhase({ featureId, verbose }, 'technical-design');
+        if (verbose) {
+            logInfo(`📋 Feedbacks fetched successfully: ${feedbacksContext.feedbacks.length} feedbacks found`);
+            if (feedbacksContext.feedbacks.length > 0) {
+                logInfo('📝 Feedbacks details:');
+                feedbacksContext.feedbacks.forEach((fb, idx) => {
+                    logInfo(`   ${idx + 1}. [${fb.feedback_type}] ${fb.title} (priority: ${fb.priority}, resolved: ${fb.is_resolved || false})`);
+                    logInfo(`      Content: ${fb.content.substring(0, 150)}...`);
+                    if (fb.target_type) {
+                        logInfo(`      🎯 Target Type: ${fb.target_type}`);
+                    }
+                    if (fb.document_type) {
+                        logInfo(`      📄 Document: ${fb.document_type}`);
+                    }
+                    if (fb.line_number) {
+                        logInfo(`      📏 Line: ${fb.line_number}`);
+                    }
+                    else if (fb.line_range_start && fb.line_range_end) {
+                        logInfo(`      📏 Lines: ${fb.line_range_start}-${fb.line_range_end}`);
+                    }
+                    if (fb.context_snippet) {
+                        logInfo(`      Referenced: ${fb.context_snippet.substring(0, 100)}...`);
+                    }
+                });
+            }
+        }
+        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`);
+                logInfo(`📄 Feedbacks section length: ${feedbacksInfo.length} characters`);
+            }
+        }
+        else {
+            if (verbose) {
+                logInfo('ℹ️  No unresolved feedbacks found for this phase');
+            }
+        }
+    }
+    catch (error) {
+        // Don't fail if feedbacks fetch fails - just log and continue
+        if (verbose) {
+            logError(`❌ Failed to fetch feedbacks: ${error instanceof Error ? error.message : String(error)}`);
+            if (error instanceof Error && error.stack) {
+                logError(`   Stack: ${error.stack}`);
+            }
+        }
+    }
+    // Add checklist context to the design prompt
+    if (checklistContext && checklistContext.checklists.length > 0) {
+        const checklistInfo = formatChecklistsForContext(checklistContext);
+        finalContextInfo = finalContextInfo + '\n\n' + checklistInfo;
+        if (verbose) {
+            logInfo(`Added ${checklistContext.checklists.length} checklists to design context`);
+        }
+    }
+    // Decide on prompt mode based on existing design and feedbacks
+    const isIncrementalUpdate = hasExistingDesign && hasFeedbacks;
+    if (verbose) {
+        logInfo('\n📋 Design Mode Decision:');
+        logInfo(`   - Has existing design: ${hasExistingDesign}`);
+        logInfo(`   - Has feedbacks: ${hasFeedbacks} (${feedbacksContext?.feedbacks.length || 0} feedbacks)`);
+        logInfo(`   - Mode: ${isIncrementalUpdate ? '🔄 Incremental Update' : hasExistingDesign ? '🔄 Full Redesign' : '✨ New Design'}`);
+        if (isIncrementalUpdate && feedbacksContext) {
+            logInfo('\n🎯 Feedbacks that will be addressed:');
+            feedbacksContext.feedbacks.forEach((fb, idx) => {
+                const priorityBadge = fb.priority >= 9
+                    ? '🔴'
+                    : fb.priority >= 7
+                        ? '🟠'
+                        : fb.priority >= 5
+                            ? '🟡'
+                            : '🟢';
+                logInfo(`   ${idx + 1}. [${fb.feedback_type}] ${fb.title} ${priorityBadge}`);
+                logInfo(`      ${fb.content.substring(0, 100)}${fb.content.length > 100 ? '...' : ''}`);
+            });
+        }
+    }
+    const designPrompt = createTechnicalDesignPromptWithContext(featureId, finalContextInfo, existingTechnicalDesign, isIncrementalUpdate);
+    return {
+        featureName: context.feature.name,
+        featureDescription: context.feature.description || undefined,
+        designPrompt,
+        hasExistingDesign,
+        hasFeedbacks,
+        feedbacksContext,
+    };
+}
+/**
+ * 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...'}`);
+                    }
+                }
+            }
+        }
+        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 (!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);
+                            }
+                            catch (parseError) {
+                                logError(`Failed to parse extracted JSON: ${parseError}`);
+                                // Try to parse the entire response as JSON as fallback
+                                jsonResult = JSON.parse(responseText);
+                            }
+                        }
+                        else {
+                            // Try to parse the entire response as JSON
+                            jsonResult = JSON.parse(responseText);
+                        }
+                    }
+                    if (jsonResult && jsonResult.technical_design_result) {
+                        structuredDesignResult = jsonResult.technical_design_result;
+                    }
+                    else {
+                        throw new Error('Invalid JSON structure');
+                    }
+                }
+                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');
+                }
+            }
+        }
+    }
+    return structuredDesignResult;
+}
+/**
+ * Save technical design document
+ */
+async function saveTechnicalDesign(featureId, technicalDesign, verbose) {
+    if (verbose) {
+        logInfo('Saving technical design...');
+    }
+    const designSaved = await updateTechnicalDesign(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({
+            featureId,
+            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
+    const lines = response.split('\n');
+    let inTechnicalDesign = false;
+    const technicalDesignLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].toLowerCase();
+        // Look for technical design section headers
+        if (line.includes('technical design') ||
+            line.includes('architecture') ||
+            line.includes('# design') ||
+            line.includes('## technical')) {
+            inTechnicalDesign = true;
+            technicalDesignLines.push(lines[i]);
+            continue;
+        }
+        if (inTechnicalDesign) {
+            // Continue until we hit another major section or JSON
+            if (line.startsWith('{') && line.includes('"technical_design_result"')) {
+                break;
+            }
+            technicalDesignLines.push(lines[i]);
+        }
+    }
+    if (technicalDesignLines.length > 0) {
+        return technicalDesignLines.join('\n').trim();
+    }
+    // Ultimate fallback: return the whole response if it seems to contain design content
+    if (response.length > 100 &&
+        (response.toLowerCase().includes('architecture') ||
+            response.toLowerCase().includes('component') ||
+            response.toLowerCase().includes('database'))) {
+        return response.trim();
+    }
+    return null;
+};

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

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

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

@@ -0,0 +1,39 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { getFeature, getUserStories, getTestCases, } from '../../api/features/index.js';
+import { getProduct } from '../../api/products.js';
+/**
+ * Fetch all technical design context information via MCP endpoints
+ */
+export async function fetchTechnicalDesignContext(featureId, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Fetching complete technical design context for feature: ${featureId}`);
+        }
+        // Fetch all required data in parallel for better performance
+        const [feature, user_stories, test_cases] = await Promise.all([
+            getFeature(featureId, verbose),
+            getUserStories(featureId, verbose),
+            getTestCases(featureId, verbose),
+        ]);
+        const product = await getProduct(feature.product_id, verbose);
+        if (verbose) {
+            logInfo(`✅ Technical design context fetched successfully:`);
+            logInfo(`   Feature: ${feature.name}`);
+            logInfo(`   Product: ${product.name}`);
+            logInfo(`   User Stories: ${user_stories.length}`);
+            logInfo(`   Test Cases: ${test_cases.length} (${test_cases.filter((tc) => tc.is_critical).length} critical)`);
+            logInfo(`   Existing Technical Design: ${feature.technical_design ? 'Yes' : 'No'}`);
+        }
+        return {
+            feature,
+            product,
+            user_stories,
+            test_cases,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to fetch technical design context: ${errorMessage}`);
+        throw new Error(`Context fetch failed: ${errorMessage}`);
+    }
+}

package/dist/phases/technical-design/http-fallback.d.ts

@@ -0,0 +1,17 @@
+export interface HttpFallbackOptions {
+    featureId: string;
+    technicalDesign: string;
+    verbose?: boolean;
+}
+/**
+ * Save technical design via HTTP as a fallback when MCP server fails
+ */
+export declare function saveTechnicalDesignViaHttp(options: HttpFallbackOptions): Promise<boolean>;
+/**
+ * Verify that technical design was saved by retrieving it and optionally comparing content
+ */
+export declare function verifyTechnicalDesignSaved(featureId: string, verbose?: boolean, expectedContent?: string): Promise<boolean>;
+/**
+ * Enhanced save with retry logic and verification
+ */
+export declare function saveTechnicalDesignWithRetry(options: HttpFallbackOptions, maxRetries?: number): Promise<boolean>;

package/dist/phases/technical-design/http-fallback.js

@@ -0,0 +1,151 @@
+import { logInfo, logError } from '../../utils/logger.js';
+/**
+ * Save technical design via HTTP as a fallback when MCP server fails
+ */
+export async function saveTechnicalDesignViaHttp(options) {
+    const { featureId, technicalDesign, verbose } = options;
+    const mcpServerUrl = process.env.MCP_SERVER_URL;
+    const mcpToken = process.env.MCP_TOKEN;
+    try {
+        if (verbose) {
+            logInfo('🔄 Attempting to save technical design via HTTP fallback...');
+        }
+        // Make direct HTTP call to the MCP server endpoint
+        const response = await fetch(`${mcpServerUrl}/mcp`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${mcpToken}`,
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                method: 'features/update',
+                params: {
+                    feature_id: featureId,
+                    technical_design: technicalDesign,
+                },
+                id: Math.random().toString(36).substring(7),
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const data = await response.json();
+        if (data.error) {
+            throw new Error(data.error.message || 'HTTP call failed');
+        }
+        if (verbose) {
+            logInfo('✅ Technical design saved successfully via HTTP fallback');
+        }
+        return true;
+    }
+    catch (error) {
+        if (verbose) {
+            logError(`❌ HTTP fallback failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return false;
+    }
+}
+/**
+ * Verify that technical design was saved by retrieving it and optionally comparing content
+ */
+export async function verifyTechnicalDesignSaved(featureId, verbose, expectedContent) {
+    try {
+        if (verbose) {
+            logInfo('🔍 Verifying technical design was saved...');
+        }
+        const mcpServerUrl = process.env.MCP_SERVER_URL;
+        const mcpToken = process.env.MCP_TOKEN;
+        const response = await fetch(`${mcpServerUrl}/mcp`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${mcpToken}`,
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                method: 'features/get',
+                params: {
+                    feature_id: featureId,
+                },
+                id: Math.random().toString(36).substring(7),
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const data = await response.json();
+        if (data.error) {
+            throw new Error(data.error.message || 'Verification failed');
+        }
+        const feature = data.result?.features?.[0];
+        const actualTechnicalDesign = feature?.technical_design;
+        const hasTechnicalDesign = actualTechnicalDesign && actualTechnicalDesign.trim().length > 0;
+        // If expected content is provided, compare it with actual content
+        if (expectedContent && hasTechnicalDesign) {
+            const contentMatches = actualTechnicalDesign.trim() === expectedContent.trim();
+            if (verbose) {
+                if (contentMatches) {
+                    logInfo('✅ Technical design verified - content matches expected');
+                }
+                else {
+                    logInfo('⚠️ Technical design exists but content differs from expected');
+                    logInfo(`Expected length: ${expectedContent.length}, Actual length: ${actualTechnicalDesign.length}`);
+                }
+            }
+            return contentMatches;
+        }
+        if (verbose) {
+            if (hasTechnicalDesign) {
+                logInfo('✅ Technical design verified - successfully saved');
+            }
+            else {
+                logInfo('⚠️ Technical design verification failed - not found');
+            }
+        }
+        return hasTechnicalDesign;
+    }
+    catch (error) {
+        if (verbose) {
+            logError(`❌ Verification failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return false;
+    }
+}
+/**
+ * Enhanced save with retry logic and verification
+ */
+export async function saveTechnicalDesignWithRetry(options, maxRetries = 3) {
+    const { verbose } = options;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        if (verbose && attempt > 1) {
+            logInfo(`🔄 Retry attempt ${attempt} of ${maxRetries}...`);
+        }
+        const saved = await saveTechnicalDesignViaHttp(options);
+        if (saved) {
+            // Verify the save was successful
+            const verified = await verifyTechnicalDesignSaved(options.featureId, verbose);
+            if (verified) {
+                if (verbose) {
+                    logInfo(`✅ Technical design successfully saved and verified (attempt ${attempt})`);
+                }
+                return true;
+            }
+            else if (verbose) {
+                logError(`❌ Save appeared successful but verification failed (attempt ${attempt})`);
+            }
+        }
+        if (attempt < maxRetries) {
+            // Wait before retrying
+            const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000); // Exponential backoff
+            if (verbose) {
+                logInfo(`⏳ Waiting ${delay}ms before retry...`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+    if (verbose) {
+        logError(`❌ Failed to save technical design after ${maxRetries} attempts`);
+    }
+    return false;
+}