codehere 0.1.1 → 0.2.1

package/dist/application/use-cases/edit-file-use-case.js

@@ -2,11 +2,11 @@
  * Application Use Case: EditFileUseCase
  * Handles file editing with verification and Reflexion
  */
+const DEBUG = process.env.CODEHERE_DEBUG === '1';
 import { container } from '../services/dependency-container.js';
 import { backupFile, rollbackFile } from '../../verification/backup.js';
 import { executionTracer } from '../../infrastructure/observability/execution-tracer.js';
 import { validateFilePath } from '../../infrastructure/security/input-validator.js';
-import { calculateCost } from '../../infrastructure/cost-calculator.js';
 export class EditFileUseCase {
     aiService;
     verificationService;
@@ -62,11 +62,6 @@ export class EditFileUseCase {
                 rootNodeId = lineage?.rootNodeId;
             }
         }
-        // Cost tracking variables (populated during AI generation)
-        let usage;
-        let model;
-        let costBreakdown;
-        let explanation; // Explanation of changes (if requested)
         // Validate file path
         const pathValidation = validateFilePath(request.filepath);
         if (!pathValidation.valid) {
@@ -90,7 +85,8 @@ export class EditFileUseCase {
                 regulatoryRelevant: this.isRegulatoryRelevant(request.filepath, request.instruction),
             };
             const governDecision = await this.nistAIRMF.govern(riskContext);
-            console.log(`[EditFileUseCase] NIST AI RMF Govern: ${governDecision.decision}`);
+            if (DEBUG)
+                console.log(`[EditFileUseCase] NIST AI RMF Govern: ${governDecision.decision}`);
             if (governDecision.outcome === 'blocked') {
                 return {
                     success: false,
@@ -98,44 +94,14 @@ export class EditFileUseCase {
                 };
             }
             if (governDecision.outcome === 'requires_review') {
-                console.warn(`[EditFileUseCase] ⚠️  Governance requires review: ${governDecision.rationale}`);
-            }
-        }
-        // CRITICAL FIX: Security check FIRST (before any expensive operations)
-        // This prevents wasting time and tokens on dangerous code
-        // RESEARCH CONTEXT: 45% of AI-generated code has security flaws, 35% has license issues
-        // Use Enhanced Security Gate if available (includes all scanners), fallback to SAST only
-        if (this.enhancedSecurityGate) {
-            // Fast pre-check on instruction before generating edit
-            const fastCheck = await this.enhancedSecurityGate.fastCheck(request.instruction);
-            if (!fastCheck.allowed) {
-                return {
-                    success: false,
-                    error: `Security vulnerabilities detected in instruction: ${fastCheck.findings.join('; ')}`,
-                    securityFindings: fastCheck.findings,
-                };
-            }
-        }
-        else if (this.sastScanner) {
-            // Legacy: Quick security check on instruction before generating edit
-            // This is a fast pattern-based check, full AI scan happens after edit generation
-            // Skip security checks in test mode (CODEHERE_SKIP_SECURITY=1)
-            const skipSecurity = process.env.CODEHERE_SKIP_SECURITY === '1';
-            if (!skipSecurity) {
-                const quickSecurityCheck = await this.sastScanner.scanInstruction(request.instruction);
-                if (quickSecurityCheck && quickSecurityCheck.findings && quickSecurityCheck.findings.length > 0) {
-                    const criticalFindings = quickSecurityCheck.findings.filter((f) => f.severity === 'critical') || [];
-                    const highFindings = quickSecurityCheck.findings.filter((f) => f.severity === 'high') || [];
-                    if (criticalFindings.length > 0 || highFindings.length > 0) {
-                        return {
-                            success: false,
-                            error: `Security vulnerabilities detected: ${criticalFindings.length} critical, ${highFindings.length} high severity findings. Review and fix before applying.`,
-                            securityFindings: quickSecurityCheck.findings,
-                        };
-                    }
-                }
+                if (DEBUG)
+                    console.warn(`[EditFileUseCase] ⚠️  Governance requires review: ${governDecision.rationale}`);
             }
         }
+        // NOTE: We do NOT scan the instruction text itself for security patterns.
+        // The instruction is a human request like "fix the SQL injection" — scanning it
+        // would block legitimate fix requests. Security scanning happens on the GENERATED
+        // code output, not on what the user asked for.
         const { readFileSync, writeFileSync, existsSync, mkdirSync } = await import('fs');
         const { join, dirname } = await import('path');
         // Use sanitized path if validation found issues
@@ -156,26 +122,33 @@ export class EditFileUseCase {
             });
             if (frictionPoint) {
                 frictionApplied = frictionPoint;
-                console.log(`[EditFileUseCase] ⚠️ Friction applied: ${frictionPoint.message}`);
+                if (DEBUG)
+                    console.log(`[EditFileUseCase] ⚠️ Friction applied: ${frictionPoint.message}`);
                 // For CLI: Log warning. For UI: This would pause and wait for user interaction
                 if (frictionPoint.requiresExplicitConfirmation) {
                     // In CLI, we'll allow it but log the warning
                     // In UI, this would block until user confirms
-                    console.warn(`[EditFileUseCase] Explicit confirmation required: ${frictionPoint.message}`);
+                    if (DEBUG)
+                        console.warn(`[EditFileUseCase] Explicit confirmation required: ${frictionPoint.message}`);
                 }
             }
         }
         // Handle file creation if file doesn't exist
         if (!fileExists) {
-            console.log(`[EditFileUseCase] File does not exist, creating new file: ${fullPath}`);
-            console.log(`[EditFileUseCase] Instruction: ${request.instruction}`);
+            if (DEBUG)
+                console.log(`[EditFileUseCase] File does not exist, creating new file: ${fullPath}`);
+            if (DEBUG)
+                console.log(`[EditFileUseCase] Instruction: ${request.instruction}`);
             return await this.createFile(request, fullPath);
         }
-        console.log(`[EditFileUseCase] Editing existing file: ${fullPath}`);
-        console.log(`[EditFileUseCase] Instruction: ${request.instruction}`);
+        if (DEBUG)
+            console.log(`[EditFileUseCase] Editing existing file: ${fullPath}`);
+        if (DEBUG)
+            console.log(`[EditFileUseCase] Instruction: ${request.instruction}`);
         // Read current content
         const currentContent = readFileSync(fullPath, 'utf-8');
-        console.log(`[EditFileUseCase] File size: ${currentContent.length} chars`);
+        if (DEBUG)
+            console.log(`[EditFileUseCase] File size: ${currentContent.length} chars`);
         // Update risk level with file context
         const updatedRiskLevel = this.determineRiskLevel(request.instruction, currentContent);
         // 3. Check HITL Validation requirement
@@ -190,7 +163,8 @@ export class EditFileUseCase {
         })) {
             hitlRequired = true;
             // Note: In CLI, we proceed with warning. In UI, this would block until approval
-            console.warn(`[EditFileUseCase] ⚠️ HITL validation required for this operation`);
+            if (DEBUG)
+                console.warn(`[EditFileUseCase] ⚠️ HITL validation required for this operation`);
         }
         // Track edit generation in lineage
         if (this.promptToCodeLineage && lineageId && rootNodeId) {
@@ -224,48 +198,22 @@ export class EditFileUseCase {
                     enhancedInstruction = `${request.instruction}\n\n${contextParts.join('\n\n')}`;
                 }
             }
-            const editResult = await this.aiService.generateEdit(currentContent, enhancedInstruction, request.filepath, request.requestExplanation);
-            // Extract diff and capture usage/cost/explanation data
-            diff = editResult.text;
-            usage = editResult.usage;
-            model = editResult.model;
-            explanation = editResult.explanation;
+            diff = await this.aiService.generateEdit(currentContent, enhancedInstruction, request.filepath);
             codeGenSpinner.stop();
-            console.log(`[EditFileUseCase] Generated diff length: ${diff.length} chars`);
-            // Calculate cost if usage data is available
-            if (usage && model) {
-                const provider = process.env.CODEHERE_AI_PROVIDER || 'openai';
-                costBreakdown = calculateCost(usage, model, provider);
-                console.log(`[EditFileUseCase] Cost: $${costBreakdown.totalCost.toFixed(4)} (${usage.inputTokens} input + ${usage.outputTokens} output tokens)`);
-            }
-            // P0 Security: Validate LLM output before processing
-            if (this.enhancedSecurityGate) {
-                const outputValidation = await this.enhancedSecurityGate.validateOutput(diff, {
-                    query: enhancedInstruction,
-                    operation: 'generateEdit',
-                });
-                if (!outputValidation.allowed) {
-                    return {
-                        success: false,
-                        error: `Security: Output validation failed. Findings: ${outputValidation.findings.join('; ')}`,
-                        securityFindings: outputValidation.findings,
-                    };
-                }
-                // Use sanitized output if available
-                if (outputValidation.sanitized && outputValidation.sanitized !== diff) {
-                    console.warn(`[EditFileUseCase] Output sanitized due to security findings`);
-                    diff = outputValidation.sanitized;
-                }
-            }
+            if (DEBUG)
+                console.log(`[EditFileUseCase] Generated diff length: ${diff.length} chars`);
             if (diff.length > 0) {
-                console.log(`[EditFileUseCase] Diff preview: ${diff.substring(0, 200)}...`);
+                if (DEBUG)
+                    console.log(`[EditFileUseCase] Diff preview: ${diff.substring(0, 200)}...`);
             }
             else {
-                console.warn(`[EditFileUseCase] Warning: Empty diff generated`);
+                if (DEBUG)
+                    console.warn(`[EditFileUseCase] Warning: Empty diff generated`);
             }
         }
         catch (error) {
-            console.error(`[EditFileUseCase] Failed to generate edit:`, error);
+            if (DEBUG)
+                console.error(`[EditFileUseCase] Failed to generate edit:`, error);
             return {
                 success: false,
                 error: `Failed to generate edit: ${error instanceof Error ? error.message : String(error)}`,
@@ -275,34 +223,53 @@ export class EditFileUseCase {
         let newContent;
         try {
             newContent = await this.applyDiff(currentContent, diff);
-            console.log(`[EditFileUseCase] Applied diff, new content size: ${newContent.length} chars`);
+            if (DEBUG)
+                console.log(`[EditFileUseCase] Applied diff, new content size: ${newContent.length} chars`);
             // Check if content actually changed
             if (newContent === currentContent) {
-                console.warn(`[EditFileUseCase] Warning: Content unchanged after applying diff`);
+                if (DEBUG)
+                    console.warn(`[EditFileUseCase] Warning: Content unchanged after applying diff`);
             }
             else {
                 const diffSize = newContent.length - currentContent.length;
-                console.log(`[EditFileUseCase] Content changed: ${diffSize > 0 ? '+' : ''}${diffSize} chars difference`);
+                if (DEBUG)
+                    console.log(`[EditFileUseCase] Content changed: ${diffSize > 0 ? '+' : ''}${diffSize} chars difference`);
             }
         }
         catch (error) {
-            console.error(`[EditFileUseCase] Failed to apply diff:`, error);
+            if (DEBUG)
+                console.error(`[EditFileUseCase] Failed to apply diff:`, error);
             return {
                 success: false,
                 error: `Failed to apply diff: ${error instanceof Error ? error.message : String(error)}`,
             };
         }
-        // Comprehensive security scan - before verification
-        // RESEARCH CONTEXT: 45% AI code has flaws, 35% license issues, provider bias risk
-        // Use Enhanced Security Gate if available (all scanners), fallback to SAST only
-        let securityResult = null; // Will be set by security scan
+        // Security scan: compare BEFORE vs AFTER to detect NEW issues only.
+        // We don't block edits for pre-existing vulnerabilities — that would prevent
+        // users from fixing files that already have issues (the whole point of `codehere fix`).
+        let securityResult = null;
         if (this.enhancedSecurityGate) {
-            // Show progress indicator for security scanning (can take 10-15s)
             const { createSpinner } = await import('../../ui.js');
             const securitySpinner = createSpinner('Scanning for security vulnerabilities...');
             securitySpinner.start();
-            // Comprehensive scan: SAST + License + Provider Bias + Uncertainty
+            // Scan the NEW content
             securityResult = await this.enhancedSecurityGate.scan(request.filepath, newContent, request.instruction, { query: request.instruction });
+            // If the new content has issues, check if they're NEW or pre-existing
+            if (!securityResult.passed && fileExists) {
+                const originalContent = readFileSync(fullPath, 'utf-8');
+                const originalResult = await this.enhancedSecurityGate.scan(request.filepath, originalContent, '', {});
+                // Count findings: only block if the edit ADDED new vulnerabilities
+                const originalCount = (originalResult.sast?.findings?.length || 0);
+                const newCount = (securityResult.sast?.findings?.length || 0);
+                if (newCount <= originalCount) {
+                    // Edit didn't make things worse — allow it, but warn
+                    securityResult.passed = true;
+                    if (newCount > 0) {
+                        securityResult.warnings = securityResult.warnings || [];
+                        securityResult.warnings.push(`File has ${newCount} pre-existing security finding(s). Consider fixing them too.`);
+                    }
+                }
+            }
             securitySpinner.stop();
             if (!securityResult.passed) {
                 const errorMessages = [
@@ -311,16 +278,16 @@ export class EditFileUseCase {
                 ];
                 return {
                     success: false,
-                    error: `Security validation failed: ${errorMessages.join('; ')}`,
+                    error: `Edit would introduce new security vulnerabilities: ${errorMessages.join('; ')}`,
                     securityFindings: securityResult.sast.findings,
                     licenseFindings: securityResult.license.findings,
                     providerBiasFindings: securityResult.providerBias.findings,
                     uncertaintyFindings: securityResult.uncertainty,
                 };
             }
-            // Log warnings for non-blocking issues (provider bias, uncertainty)
-            if (securityResult.warnings.length > 0) {
-                console.warn(`[EditFileUseCase] Security warnings: ${securityResult.warnings.join('; ')}`);
+            if (securityResult.warnings && securityResult.warnings.length > 0) {
+                if (DEBUG)
+                    console.warn(`[EditFileUseCase] Security warnings: ${securityResult.warnings.join('; ')}`);
             }
             // NIST AI RMF: MAP - Context framing and risk identification (Enterprise Governance)
             if (this.nistAIRMF) {
@@ -346,7 +313,8 @@ export class EditFileUseCase {
                         dependencies: 0, // Could be enhanced
                     },
                 });
-                console.log(`[EditFileUseCase] NIST AI RMF Map: ${mapDecision.decision}`);
+                if (DEBUG)
+                    console.log(`[EditFileUseCase] NIST AI RMF Map: ${mapDecision.decision}`);
                 if (mapDecision.outcome === 'blocked') {
                     return {
                         success: false,
@@ -364,15 +332,19 @@ export class EditFileUseCase {
                     providerBiasFindings: securityResult.providerBias.findings?.length || 0,
                     uncertaintyScore: securityResult.uncertainty?.combined?.value,
                 });
-                console.log(`[EditFileUseCase] NIST AI RMF Measure: ${measureDecision.decision}`);
+                if (DEBUG)
+                    console.log(`[EditFileUseCase] NIST AI RMF Measure: ${measureDecision.decision}`);
             }
             // Policy-as-Code: Evaluate policies before proceeding (Enterprise Governance)
-            if (this.policyAsCode) {
+            // Skip policy check if the security gate already approved (edit didn't introduce new issues)
+            if (this.policyAsCode && securityResult && !securityResult.passed) {
                 // Debug: Log security findings before policy evaluation
                 const criticalHighFindings = securityResult.sast.findings.filter((f) => f.severity === 'critical' || f.severity === 'high');
-                console.log(`[EditFileUseCase] Security scan: ${securityResult.sast.findings.length} total findings, ${criticalHighFindings.length} critical/high`);
+                if (DEBUG)
+                    console.log(`[EditFileUseCase] Security scan: ${securityResult.sast.findings.length} total findings, ${criticalHighFindings.length} critical/high`);
                 if (criticalHighFindings.length > 0) {
-                    console.log(`[EditFileUseCase] Critical/High findings:`, criticalHighFindings.map((f) => `${f.severity}: ${f.category} - ${f.description}`).join('; '));
+                    if (DEBUG)
+                        console.log(`[EditFileUseCase] Critical/High findings:`, criticalHighFindings.map((f) => `${f.severity}: ${f.category} - ${f.description}`).join('; '));
                 }
                 const policyEvaluation = await this.policyAsCode.evaluate({
                     filepath: request.filepath,
@@ -384,18 +356,22 @@ export class EditFileUseCase {
                     uncertainty: securityResult.uncertainty,
                 });
                 // Debug: Log policy evaluation results
-                console.log(`[EditFileUseCase] Policy evaluation: ${policyEvaluation.results.length} rules evaluated, ${policyEvaluation.blockingRules.length} blocking`);
+                if (DEBUG)
+                    console.log(`[EditFileUseCase] Policy evaluation: ${policyEvaluation.results.length} rules evaluated, ${policyEvaluation.blockingRules.length} blocking`);
                 policyEvaluation.results.forEach((result) => {
                     if (!result.passed) {
-                        console.log(`[EditFileUseCase] Policy rule "${result.ruleName}": ${result.message}`);
+                        if (DEBUG)
+                            console.log(`[EditFileUseCase] Policy rule "${result.ruleName}": ${result.message}`);
                         if (result.evidence) {
-                            console.log(`[EditFileUseCase] Evidence:`, JSON.stringify(result.evidence, null, 2));
+                            if (DEBUG)
+                                console.log(`[EditFileUseCase] Evidence:`, JSON.stringify(result.evidence, null, 2));
                         }
                     }
                 });
                 if (!policyEvaluation.passed && policyEvaluation.blockingRules.length > 0) {
                     const blockingRule = policyEvaluation.blockingRules[0];
-                    console.error(`[EditFileUseCase] Policy violation: ${blockingRule.ruleName} - ${blockingRule.message}`);
+                    if (DEBUG)
+                        console.error(`[EditFileUseCase] Policy violation: ${blockingRule.ruleName} - ${blockingRule.message}`);
                     return {
                         success: false,
                         error: `Policy violation: ${blockingRule.message}`,
@@ -406,7 +382,8 @@ export class EditFileUseCase {
                     };
                 }
                 if (policyEvaluation.results.length > 0) {
-                    console.log(`[EditFileUseCase] Policy evaluation: ${policyEvaluation.results.filter(r => r.passed).length}/${policyEvaluation.results.length} passed`);
+                    if (DEBUG)
+                        console.log(`[EditFileUseCase] Policy evaluation: ${policyEvaluation.results.filter(r => r.passed).length}/${policyEvaluation.results.length} passed`);
                 }
             }
             // Track security scan in lineage
@@ -426,24 +403,45 @@ export class EditFileUseCase {
             }
         }
         else if (this.sastScanner) {
-            // Legacy: SAST-only scan
+            // SAST-only scan: compare before vs after to only block NEW issues
             const securityCheck = await this.sastScanner.scan(request.filepath, newContent);
-            const criticalFindings = securityCheck.findings?.filter(f => f.severity === 'critical') || [];
-            const highFindings = securityCheck.findings?.filter(f => f.severity === 'high') || [];
-            // Block edits with critical or high severity findings
-            if (criticalFindings.length > 0 || highFindings.length > 0) {
-                return {
-                    success: false,
-                    error: `Security vulnerabilities detected: ${criticalFindings.length} critical, ${highFindings.length} high severity findings. Review and fix before applying.`,
-                    securityFindings: securityCheck.findings,
-                };
+            const newFindings = securityCheck.findings || [];
+            if (newFindings.length > 0 && fileExists) {
+                const originalContent = readFileSync(fullPath, 'utf-8');
+                const originalCheck = await this.sastScanner.scan(request.filepath, originalContent);
+                const originalCount = originalCheck.findings?.length || 0;
+                // Only block if the edit ADDED new vulnerabilities
+                if (newFindings.length > originalCount) {
+                    const criticalFindings = newFindings.filter(f => f.severity === 'critical');
+                    const highFindings = newFindings.filter(f => f.severity === 'high');
+                    if (criticalFindings.length > 0 || highFindings.length > 0) {
+                        return {
+                            success: false,
+                            error: `Edit would introduce new security vulnerabilities: ${criticalFindings.length} critical, ${highFindings.length} high severity findings.`,
+                            securityFindings: newFindings,
+                        };
+                    }
+                }
+            }
+            else if (newFindings.length > 0 && !fileExists) {
+                // New file — block if it has critical/high issues
+                const criticalFindings = newFindings.filter(f => f.severity === 'critical');
+                const highFindings = newFindings.filter(f => f.severity === 'high');
+                if (criticalFindings.length > 0 || highFindings.length > 0) {
+                    return {
+                        success: false,
+                        error: `Security vulnerabilities detected in new file: ${criticalFindings.length} critical, ${highFindings.length} high severity findings.`,
+                        securityFindings: newFindings,
+                    };
+                }
             }
         }
         // Create backup before applying edit
         let backupPath;
         try {
             backupPath = await backupFile(fullPath);
-            console.log(`[EditFileUseCase] Backup created: ${backupPath}`);
+            if (DEBUG)
+                console.log(`[EditFileUseCase] Backup created: ${backupPath}`);
             // Link backup to current run for undo capability
             const runId = executionTracer.getCurrentRunId();
             if (runId) {
@@ -460,7 +458,8 @@ export class EditFileUseCase {
             }
         }
         catch (error) {
-            console.warn(`[EditFileUseCase] Failed to create backup: ${error instanceof Error ? error.message : String(error)}`);
+            if (DEBUG)
+                console.warn(`[EditFileUseCase] Failed to create backup: ${error instanceof Error ? error.message : String(error)}`);
             // Continue anyway - backup failure shouldn't block edit
         }
         // 4. Team Standards Validation (before writing file)
@@ -469,13 +468,15 @@ export class EditFileUseCase {
             const teamId = 'default'; // TODO: Get from config or context
             const standardsResult = this.teamStandards.validateCode(teamId, newContent, request.filepath);
             if (!standardsResult.passed) {
-                console.warn(`[EditFileUseCase] Team standards violations: ${standardsResult.violations.length}`);
+                if (DEBUG)
+                    console.warn(`[EditFileUseCase] Team standards violations: ${standardsResult.violations.length}`);
                 // Try auto-fix
                 const fixedResult = this.teamStandards.applyStyleGuide(teamId, newContent, request.filepath);
                 if (fixedResult.fixesApplied > 0) {
                     newContent = fixedResult.modified;
                     teamStandardsApplied = true;
-                    console.log(`[EditFileUseCase] Auto-fixed ${fixedResult.fixesApplied} style issues`);
+                    if (DEBUG)
+                        console.log(`[EditFileUseCase] Auto-fixed ${fixedResult.fixesApplied} style issues`);
                 }
                 else {
                     // Critical violations that can't be auto-fixed
@@ -522,18 +523,11 @@ export class EditFileUseCase {
             uncertainty: securityResult?.uncertainty?.combined?.value,
         };
         displayReviewCheckpoint(reviewInfo);
-        // Verify if verification service available and not skipped
+        // Verify if verification service available
         let verification;
-        // Skip verification if --no-verify flag OR CODEHERE_SKIP_VERIFICATION=1 env var
-        const skipVerification = request.skipVerification || process.env.CODEHERE_SKIP_VERIFICATION === '1';
-        if (skipVerification) {
-            const reason = request.skipVerification ? '--no-verify flag' : 'CODEHERE_SKIP_VERIFICATION=1';
-            console.log(`[EditFileUseCase] ⚠️  Verification skipped (${reason})`);
-            console.log(`[EditFileUseCase] Writing file without verification...`);
-            writeFileSync(fullPath, newContent, 'utf-8');
-        }
-        else if (this.verificationService) {
-            console.log(`[EditFileUseCase] Writing file and verifying...`);
+        if (this.verificationService) {
+            if (DEBUG)
+                console.log(`[EditFileUseCase] Writing file and verifying...`);
             writeFileSync(fullPath, newContent, 'utf-8');
             // Show progress indicator for verification (can take 5-10s)
             const { createSpinner } = await import('../../ui.js');
@@ -546,27 +540,34 @@ export class EditFileUseCase {
             else {
                 verificationSpinner.fail('Verification failed');
             }
-            console.log(`[EditFileUseCase] Verification result: success=${verification.success}, compiled=${verification.compiled}, testsPassed=${verification.testsPassed}`);
+            if (DEBUG)
+                console.log(`[EditFileUseCase] Verification result: success=${verification.success}, compiled=${verification.compiled}, testsPassed=${verification.testsPassed}`);
             if (verification.errors && verification.errors.length > 0) {
-                console.error(`[EditFileUseCase] Verification errors: ${verification.errors.join('; ')}`);
+                if (DEBUG)
+                    console.error(`[EditFileUseCase] Verification errors: ${verification.errors.join('; ')}`);
             }
             if (!verification.success) {
-                console.warn(`[EditFileUseCase] Verification failed, rolling back...`);
+                if (DEBUG)
+                    console.warn(`[EditFileUseCase] Verification failed, rolling back...`);
                 // Automatic rollback on verification failure
                 if (backupPath) {
                     try {
                         await rollbackFile(fullPath, backupPath);
-                        console.log(`[EditFileUseCase] File rolled back successfully`);
+                        if (DEBUG)
+                            console.log(`[EditFileUseCase] File rolled back successfully`);
                     }
                     catch (rollbackError) {
-                        console.error(`[EditFileUseCase] Rollback failed: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+                        if (DEBUG)
+                            console.error(`[EditFileUseCase] Rollback failed: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
                         // Try to restore from original content as fallback
                         try {
                             writeFileSync(fullPath, currentContent, 'utf-8');
-                            console.log(`[EditFileUseCase] File restored from original content`);
+                            if (DEBUG)
+                                console.log(`[EditFileUseCase] File restored from original content`);
                         }
                         catch (restoreError) {
-                            console.error(`[EditFileUseCase] Restore also failed: ${restoreError instanceof Error ? restoreError.message : String(restoreError)}`);
+                            if (DEBUG)
+                                console.error(`[EditFileUseCase] Restore also failed: ${restoreError instanceof Error ? restoreError.message : String(restoreError)}`);
                         }
                     }
                 }
@@ -596,7 +597,8 @@ export class EditFileUseCase {
         }
         else {
             // No verification - just apply (still create backup for undo capability)
-            console.log(`[EditFileUseCase] No verification service, writing file directly`);
+            if (DEBUG)
+                console.log(`[EditFileUseCase] No verification service, writing file directly`);
             writeFileSync(fullPath, newContent, 'utf-8');
         }
         const edit = {
@@ -623,7 +625,8 @@ export class EditFileUseCase {
                     generatedBy: 'EditFileUseCase',
                 },
             });
-            console.log(`[EditFileUseCase] Edit recorded for learning`);
+            if (DEBUG)
+                console.log(`[EditFileUseCase] Edit recorded for learning`);
         }
         // 6. Complete Prompt-to-Code Lineage tracking
         if (this.promptToCodeLineage && lineageId && rootNodeId) {
@@ -635,9 +638,11 @@ export class EditFileUseCase {
             }, {
                 verificationPassed: verification?.success || false,
             });
-            console.log(`[EditFileUseCase] Lineage tracking complete`);
+            if (DEBUG)
+                console.log(`[EditFileUseCase] Lineage tracking complete`);
         }
-        console.log(`[EditFileUseCase] Edit completed successfully`);
+        if (DEBUG)
+            console.log(`[EditFileUseCase] Edit completed successfully`);
         return {
             success: true,
             edit,
@@ -645,10 +650,6 @@ export class EditFileUseCase {
             frictionApplied,
             hitlRequired,
             hitlCheckpointId,
-            usage,
-            model,
-            cost: costBreakdown,
-            explanation,
         };
     }
     /**
@@ -661,18 +662,22 @@ export class EditFileUseCase {
             // Ensure directory exists
             const dir = dirname(fullPath);
             if (!existsSync(dir)) {
-                console.log(`[EditFileUseCase] Creating directory: ${dir}`);
+                if (DEBUG)
+                    console.log(`[EditFileUseCase] Creating directory: ${dir}`);
                 mkdirSync(dir, { recursive: true });
             }
             // Generate file content using AI
-            console.log(`[EditFileUseCase] Generating new file content...`);
+            if (DEBUG)
+                console.log(`[EditFileUseCase] Generating new file content...`);
             let fileContent;
             try {
                 fileContent = await this.aiService.generateFileContent(request.filepath, request.instruction, request.requirements || []);
-                console.log(`[EditFileUseCase] Generated content length: ${fileContent.length} chars`);
+                if (DEBUG)
+                    console.log(`[EditFileUseCase] Generated content length: ${fileContent.length} chars`);
             }
             catch (error) {
-                console.error(`[EditFileUseCase] Failed to generate file content:`, error);
+                if (DEBUG)
+                    console.error(`[EditFileUseCase] Failed to generate file content:`, error);
                 return {
                     success: false,
                     error: `Failed to generate file content: ${error instanceof Error ? error.message : String(error)}`,
@@ -693,15 +698,19 @@ export class EditFileUseCase {
             }
             // Write file
             writeFileSync(fullPath, fileContent, 'utf-8');
-            console.log(`[EditFileUseCase] File created successfully: ${fullPath}`);
+            if (DEBUG)
+                console.log(`[EditFileUseCase] File created successfully: ${fullPath}`);
             // Verify if verification service available
             let verification;
             if (this.verificationService) {
-                console.log(`[EditFileUseCase] Verifying new file...`);
+                if (DEBUG)
+                    console.log(`[EditFileUseCase] Verifying new file...`);
                 verification = await this.verificationService.verify(fullPath);
-                console.log(`[EditFileUseCase] Verification result: success=${verification.success}, compiled=${verification.compiled}, testsPassed=${verification.testsPassed}`);
+                if (DEBUG)
+                    console.log(`[EditFileUseCase] Verification result: success=${verification.success}, compiled=${verification.compiled}, testsPassed=${verification.testsPassed}`);
                 if (!verification.success) {
-                    console.warn(`[EditFileUseCase] Verification failed for new file, but keeping it for inspection`);
+                    if (DEBUG)
+                        console.warn(`[EditFileUseCase] Verification failed for new file, but keeping it for inspection`);
                     return {
                         success: false,
                         verification,
@@ -719,7 +728,8 @@ export class EditFileUseCase {
                     verificationResult: verification,
                 },
             };
-            console.log(`[EditFileUseCase] File creation completed successfully`);
+            if (DEBUG)
+                console.log(`[EditFileUseCase] File creation completed successfully`);
             return {
                 success: true,
                 edit,
@@ -727,7 +737,8 @@ export class EditFileUseCase {
             };
         }
         catch (error) {
-            console.error(`[EditFileUseCase] Failed to create file:`, error);
+            if (DEBUG)
+                console.error(`[EditFileUseCase] Failed to create file:`, error);
             return {
                 success: false,
                 error: `Failed to create file: ${error instanceof Error ? error.message : String(error)}`,