@electriccitizen/bolt 0.1.0 → 0.2.0

package/dist/commands/update.js

@@ -6,10 +6,16 @@
  */
 import { execFile } from 'child_process';
 import { promisify } from 'util';
-import { createInterface } from 'readline';
+import { mkdtempSync, rmSync, existsSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
 import { DdevAdapter } from '../adapters/ddev.js';
 import { runTests } from '../runner.js';
 import { loadConfig } from '../config.js';
+import { isClaudeAvailable, runAgent } from '../ai/agent.js';
+import { buildUpdatePackageTask } from '../ai/prompts/update-package.js';
+import { validateUpdateOutput } from '../ai/schemas/update-result.js';
+import { checkGitState, requireCleanTree, warnUnpushedCommits, confirm } from '../safety.js';
 const execFileAsync = promisify(execFile);
 /** Write progress messages to stderr. */
 function log(msg) {
@@ -24,6 +30,37 @@ function logFail(msg) {
 function logWarn(msg) {
     process.stderr.write(`  ⚠ ${msg}\n`);
 }
+/**
+ * Ensure bolt_inspect module is available after git/composer operations.
+ * Composer update or git checkout can remove the path repo, so we
+ * re-add it if needed.
+ */
+async function ensureBoltInspect() {
+    // Quick check: is the module already enabled?
+    const check = await exec('ddev', ['drush', 'pm:list', '--status=enabled', '--filter=bolt_inspect', '--format=json'], 30_000);
+    if (check.exitCode === 0 && check.stdout.includes('bolt_inspect')) {
+        return; // Module is still enabled.
+    }
+    log('Restoring bolt_inspect module...');
+    // Check if the package is still in composer.
+    const showResult = await exec('ddev', ['composer', 'show', 'electriccitizen/bolt-inspect'], 10_000);
+    if (showResult.exitCode !== 0) {
+        // Package not installed — require it from Packagist.
+        const requireResult = await exec('ddev', ['composer', 'require', 'electriccitizen/bolt-inspect', '--no-interaction'], 120_000);
+        if (requireResult.exitCode !== 0) {
+            logWarn(`Failed to install bolt-inspect: ${requireResult.stderr.trim()}`);
+            return;
+        }
+    }
+    // Enable the module.
+    const enResult = await exec('ddev', ['drush', 'en', 'bolt_inspect', '-y'], 30_000);
+    if (enResult.exitCode !== 0) {
+        logWarn(`Failed to enable bolt_inspect: ${enResult.stderr.trim()}`);
+    }
+    else {
+        logOk('bolt_inspect restored');
+    }
+}
 function formatDuration(ms) {
     if (ms < 1000)
         return `${ms}ms`;
@@ -51,15 +88,6 @@ async function exec(command, args, timeoutMs = 300_000) {
         return { stdout: '', stderr: String(err), exitCode: 1 };
     }
 }
-async function confirm(question) {
-    const rl = createInterface({ input: process.stdin, output: process.stderr });
-    return new Promise((resolve) => {
-        rl.question(`  ${question} (y/N) `, (answer) => {
-            rl.close();
-            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
-        });
-    });
-}
 /**
  * Get the current git branch name.
  */
@@ -170,6 +198,221 @@ function filterCandidates(candidates, options, config) {
     });
     return filtered;
 }
+/**
+ * Try multiple strategies to resolve a Composer update.
+ * Returns the successful attempt or null if all failed.
+ */
+async function resolveComposerUpdate(packageName, targetVersion) {
+    const attempts = [];
+    // Strategy 1: Standard update with dependencies.
+    {
+        const args = ['composer', 'update', packageName, '--with-dependencies'];
+        log(`  Strategy 1: composer update ${packageName} --with-dependencies`);
+        const result = await exec('ddev', args, 300_000);
+        attempts.push({
+            strategy: 'update --with-dependencies',
+            command: args,
+            succeeded: result.exitCode === 0,
+            output: result.stderr,
+        });
+        if (result.exitCode === 0) {
+            const version = await getInstalledVersion(packageName);
+            return { success: true, attempts, resolvedVersion: version };
+        }
+        log('  → Failed, diagnosing...');
+    }
+    // Diagnose: run composer why-not to understand the constraint.
+    const whyNotResult = await exec('ddev', ['composer', 'why-not', packageName, targetVersion], 30_000);
+    if (whyNotResult.stdout.trim()) {
+        log('  Constraint analysis:');
+        const lines = whyNotResult.stdout.trim().split('\n').slice(0, 5);
+        for (const line of lines) {
+            log(`    ${line.trim()}`);
+        }
+    }
+    // Strategy 2: Update with all dependencies (broader resolution).
+    {
+        // Reset any partial changes from strategy 1.
+        await exec('git', ['checkout', '.']);
+        await exec('git', ['clean', '-fd', '-e', '.boltrc.yml', '-e', '.bolt/']);
+        const args = ['composer', 'update', packageName, '--with-all-dependencies'];
+        log(`  Strategy 2: composer update ${packageName} --with-all-dependencies`);
+        const result = await exec('ddev', args, 300_000);
+        attempts.push({
+            strategy: 'update --with-all-dependencies',
+            command: args,
+            succeeded: result.exitCode === 0,
+            output: result.stderr,
+        });
+        if (result.exitCode === 0) {
+            const version = await getInstalledVersion(packageName);
+            return { success: true, attempts, resolvedVersion: version };
+        }
+        log('  → Failed, trying broader resolution...');
+    }
+    // Strategy 3: Require with a caret constraint (let Composer find the best compatible version).
+    {
+        await exec('git', ['checkout', '.']);
+        await exec('git', ['clean', '-fd', '-e', '.boltrc.yml', '-e', '.bolt/']);
+        // Parse the major.minor from target to build a caret constraint.
+        const caretConstraint = buildCaretConstraint(targetVersion);
+        const args = ['composer', 'require', `${packageName}:${caretConstraint}`, '--update-with-all-dependencies'];
+        log(`  Strategy 3: composer require ${packageName}:${caretConstraint} --update-with-all-dependencies`);
+        const result = await exec('ddev', args, 300_000);
+        attempts.push({
+            strategy: `require ${caretConstraint} --update-with-all-dependencies`,
+            command: args,
+            succeeded: result.exitCode === 0,
+            output: result.stderr,
+        });
+        if (result.exitCode === 0) {
+            const version = await getInstalledVersion(packageName);
+            return { success: true, attempts, resolvedVersion: version };
+        }
+        log('  → Failed, trying minor version range...');
+    }
+    // Strategy 4: Try requiring with a tilde constraint (more conservative — same minor).
+    {
+        await exec('git', ['checkout', '.']);
+        await exec('git', ['clean', '-fd', '-e', '.boltrc.yml', '-e', '.bolt/']);
+        const tildeConstraint = buildTildeConstraint(targetVersion);
+        if (tildeConstraint !== buildCaretConstraint(targetVersion)) {
+            const args = ['composer', 'require', `${packageName}:${tildeConstraint}`, '--update-with-all-dependencies'];
+            log(`  Strategy 4: composer require ${packageName}:${tildeConstraint} --update-with-all-dependencies`);
+            const result = await exec('ddev', args, 300_000);
+            attempts.push({
+                strategy: `require ${tildeConstraint} --update-with-all-dependencies`,
+                command: args,
+                succeeded: result.exitCode === 0,
+                output: result.stderr,
+            });
+            if (result.exitCode === 0) {
+                const version = await getInstalledVersion(packageName);
+                return { success: true, attempts, resolvedVersion: version };
+            }
+            log('  → Failed, trying with core update...');
+        }
+    }
+    // Strategy 5: Update the package alongside drupal/core-* (common Drupal constraint pattern).
+    {
+        await exec('git', ['checkout', '.']);
+        await exec('git', ['clean', '-fd', '-e', '.boltrc.yml', '-e', '.bolt/']);
+        const args = [
+            'composer', 'update', packageName,
+            'drupal/core-recommended', 'drupal/core-composer-scaffold', 'drupal/core-project-message',
+            '--with-all-dependencies',
+        ];
+        log(`  Strategy 5: update ${packageName} alongside drupal/core-*`);
+        const result = await exec('ddev', args, 300_000);
+        attempts.push({
+            strategy: 'update with drupal/core-* --with-all-dependencies',
+            command: args,
+            succeeded: result.exitCode === 0,
+            output: result.stderr,
+        });
+        if (result.exitCode === 0) {
+            const version = await getInstalledVersion(packageName);
+            return { success: true, attempts, resolvedVersion: version };
+        }
+    }
+    // All strategies exhausted.
+    log('  All resolution strategies exhausted');
+    await exec('git', ['checkout', '.']);
+    await exec('git', ['clean', '-fd', '-e', '.boltrc.yml', '-e', '.bolt/']);
+    return { success: false, attempts };
+}
+/**
+ * AI-powered update: hand the package to Claude for intelligent conflict resolution.
+ * Claude handles: composer update, conflict diagnosis, drush updb, watchdog, config export.
+ * Returns a structured result or null if the agent fails to produce one.
+ */
+async function aiUpdate(candidate, coreVersion, branchName, siteUrl, baselineTestCount, baselineSuppressedCount) {
+    const task = buildUpdatePackageTask({
+        candidate,
+        coreVersion,
+        branchName,
+        siteUrl,
+        baselineTestCount,
+        baselineSuppressedCount,
+    });
+    log('Using AI reasoning for update...');
+    const result = await runAgent(task);
+    if (!result.success) {
+        logWarn(`AI agent did not return structured output`);
+        if (result.rawResponse) {
+            // Log first few lines of the raw response for debugging.
+            const lines = result.rawResponse.split('\n').slice(0, 5);
+            for (const line of lines) {
+                log(`  ${line}`);
+            }
+        }
+        return null;
+    }
+    const validated = validateUpdateOutput(result.output);
+    if (!validated) {
+        logWarn('AI agent output failed schema validation');
+        return null;
+    }
+    if (result.costUsd) {
+        log(`  AI cost: $${result.costUsd.toFixed(4)} (${result.numTurns} turns, ${formatDuration(result.duration)})`);
+    }
+    return validated;
+}
+/**
+ * Get the current Drupal core version from composer.
+ */
+async function getCoreVersion() {
+    const result = await exec('ddev', ['composer', 'show', 'drupal/core', '--format=json'], 15_000);
+    if (result.exitCode === 0) {
+        try {
+            const data = JSON.parse(result.stdout);
+            return data.versions?.[0] ?? data.version ?? 'unknown';
+        }
+        catch {
+            // Fall through.
+        }
+    }
+    return 'unknown';
+}
+/**
+ * Get the currently installed version of a package from composer.lock.
+ */
+async function getInstalledVersion(packageName) {
+    const result = await exec('ddev', ['composer', 'show', packageName, '--format=json'], 15_000);
+    if (result.exitCode !== 0)
+        return undefined;
+    try {
+        const data = JSON.parse(result.stdout);
+        return data.versions?.[0] ?? data.version;
+    }
+    catch {
+        // Try parsing the version line from non-JSON output.
+        const match = result.stdout.match(/versions?\s*:\s*\*?\s*([\d.]+)/);
+        return match?.[1];
+    }
+}
+/**
+ * Build a caret constraint from a version string.
+ * "1.15.0" → "^1.15"
+ */
+function buildCaretConstraint(version) {
+    const parts = version.replace(/^v/, '').split('.');
+    if (parts.length >= 2) {
+        return `^${parts[0]}.${parts[1]}`;
+    }
+    return `^${parts[0]}`;
+}
+/**
+ * Build a tilde constraint from a version string.
+ * "1.15.0" → "~1.15"
+ */
+function buildTildeConstraint(version) {
+    const parts = version.replace(/^v/, '').split('.');
+    if (parts.length >= 2) {
+        return `~${parts[0]}.${parts[1]}`;
+    }
+    return `~${parts[0]}`;
+}
 /**
  * Sanitize a package name for use in a branch name.
  */
@@ -199,11 +442,56 @@ async function runBaselineTest(adapter, config, siteUrl) {
     return { passed: failCount === 0, failCount, passCount, suppressedCount };
 }
 /**
- * Run a quick test suite for a single module update verification.
+ * Capture VR baselines for the current site state.
+ * Returns the temp directory path containing baseline screenshots.
  */
-async function runModuleTest(adapter, config, siteUrl) {
-    // Same as baseline — run the full test suite to catch regressions.
-    return runBaselineTest(adapter, config, siteUrl);
+async function captureVrBaselines(adapter, config, siteUrl) {
+    const baselineDir = mkdtempSync(join(tmpdir(), 'bolt-vr-'));
+    // Run VR plugin only, capturing baselines (no comparison — no prior baseline exists).
+    // Remove visual-regression from skip list so it runs even if user has it skipped.
+    const skipList = (config.plugins.skip ?? []).filter((p) => p !== 'visual-regression');
+    const testOptions = {
+        url: siteUrl,
+        mode: 'read-only', // VR is read-only, no need for full mode just for screenshots.
+        plugins: ['visual-regression'],
+        output: 'json',
+        exitCode: false,
+        failOn: 'major',
+        headed: false,
+        vrBaseline: baselineDir,
+        screenshots: join(baselineDir, 'current'),
+        configSkip: skipList.length > 0 ? skipList : undefined,
+        boltConfig: config,
+    };
+    await runTests(adapter, testOptions);
+    return baselineDir;
+}
+/**
+ * Run a test suite for a single module update verification.
+ * If vrBaselineDir is provided, includes VR comparison against pre-update baselines.
+ */
+async function runModuleTest(adapter, config, siteUrl, vrBaselineDir) {
+    // Remove visual-regression from skip list when we have baselines to compare.
+    const skipList = vrBaselineDir
+        ? (config.plugins.skip ?? []).filter((p) => p !== 'visual-regression')
+        : (config.plugins.skip ?? []);
+    const testOptions = {
+        url: siteUrl,
+        mode: 'full',
+        output: 'json',
+        exitCode: false,
+        failOn: 'major',
+        headed: false,
+        vrBaseline: vrBaselineDir,
+        screenshots: vrBaselineDir ? join(vrBaselineDir, 'post-update') : undefined,
+        configSkip: skipList.length > 0 ? skipList : undefined,
+        boltConfig: config,
+    };
+    const report = await runTests(adapter, testOptions);
+    const failCount = report.results.filter((r) => r.status === 'fail').length;
+    const passCount = report.results.filter((r) => r.status === 'pass').length;
+    const suppressedCount = report.results.filter((r) => r.status === 'suppressed').length;
+    return { passed: failCount === 0, failCount, passCount, suppressedCount };
 }
 export async function updateCommand(options) {
     const startTime = Date.now();
@@ -213,6 +501,13 @@ export async function updateCommand(options) {
     const results = [];
     process.stderr.write('\nbolt update\n');
     process.stderr.write('━'.repeat(50) + '\n\n');
+    const baseBranch = config.refresh.base_branch || 'main';
+    // --- Git safety checks (skip for dry-run) ---
+    if (!options.dryRun) {
+        const gitState = await checkGitState(baseBranch);
+        requireCleanTree(gitState); // Blocks with exit 2 if dirty — update uses git clean for rollback.
+        warnUnpushedCommits(gitState, 'will be left behind after branch switch');
+    }
     // Verify DDEV connectivity.
     const connected = await adapter.canConnect();
     if (!connected) {
@@ -226,8 +521,29 @@ export async function updateCommand(options) {
         process.stderr.write('Error: Could not detect site URL from DDEV.\n');
         process.exit(2);
     }
+    // --- AI mode detection ---
+    let useAi = false;
+    if (!options.noAi) {
+        const claudeReady = await isClaudeAvailable();
+        if (claudeReady) {
+            useAi = true;
+            logOk('AI mode enabled (Claude Code detected)');
+        }
+        else {
+            log('Claude Code not found — using scripted fallback');
+        }
+    }
+    else {
+        log('AI mode disabled (--no-ai)');
+    }
+    // Get core version for AI compatibility checks.
+    const coreVersion = useAi ? await getCoreVersion() : 'unknown';
+    // Track baseline counts for AI context.
+    let baselinePassCount = 0;
+    let baselineSuppressedCount = 0;
+    // VR baseline directory (captured pre-update, compared post-update per module).
+    let vrBaselineDir;
     // --- Pre-flight ---
-    const baseBranch = config.refresh.base_branch || 'main';
     // 1a. Pre-update refresh (code sync).
     if (!options.skipRefresh) {
         log('Pre-update refresh...');
@@ -273,12 +589,24 @@ export async function updateCommand(options) {
                     'Fix the failures or run `bolt suppress` to baseline known issues.\n');
                 process.exit(1);
             }
+            baselinePassCount = baseline.passCount;
+            baselineSuppressedCount = baseline.suppressedCount;
             logOk(`Baseline test passed (${baseline.passCount} passed, ${baseline.suppressedCount} suppressed)`);
         }
         catch (err) {
             logFail(`Baseline test error: ${err instanceof Error ? err.message : String(err)}`);
             process.exit(2);
         }
+        // 1b-vr. Capture VR baselines from current (pre-update) state.
+        log('Capturing visual regression baselines...');
+        try {
+            vrBaselineDir = await captureVrBaselines(adapter, config, siteUrl);
+            logOk('VR baselines captured (will compare after each update)');
+        }
+        catch (err) {
+            logWarn(`VR baseline capture failed: ${err instanceof Error ? err.message : String(err)}`);
+            log('Updates will proceed without visual regression checks.');
+        }
     }
     // 1c. Get outdated packages.
     log('Checking for outdated packages...');
@@ -369,62 +697,117 @@ export async function updateCommand(options) {
             });
             continue;
         }
-        // Composer update.
+        // --- Update path: AI or scripted ---
         log(`Updating ${candidate.name}...`);
-        const updateResult = await exec('ddev', ['composer', 'update', candidate.name, '--with-dependencies'], 300_000);
-        if (updateResult.exitCode !== 0) {
-            logFail(`composer update failed: ${updateResult.stderr.trim()}`);
-            // Rollback.
-            await exec('git', ['checkout', '.']);
-            await exec('git', ['clean', '-fd']);
-            await exec('git', ['checkout', baseBranch]);
-            await exec('git', ['branch', '-D', branchName]);
-            results.push({
-                package: candidate.name,
-                oldVersion: candidate.currentVersion,
-                newVersion: candidate.latestVersion,
-                status: 'conflict',
-                branch: branchName,
-                error: updateResult.stderr.trim(),
-                duration: Date.now() - moduleStart,
-            });
-            continue;
+        let resolvedVersion = candidate.latestVersion;
+        let dbUpdates = 0;
+        let updateStrategy = '';
+        let updateAttempts;
+        let aiUsedSuccessfully = false;
+        if (useAi) {
+            // AI path — Claude reasons through the update autonomously.
+            const aiResult = await aiUpdate(candidate, coreVersion, branchName, siteUrl, baselinePassCount, baselineSuppressedCount);
+            if (aiResult && aiResult.success) {
+                aiUsedSuccessfully = true;
+                resolvedVersion = aiResult.newVersion || candidate.latestVersion;
+                dbUpdates = aiResult.dbUpdatesApplied ? 1 : 0;
+                updateStrategy = `AI: ${aiResult.strategy}`;
+                logOk(`AI updated to ${resolvedVersion} (${aiResult.strategy})`);
+                if (aiResult.watchdogErrors.length > 0) {
+                    logWarn(`Watchdog errors detected: ${aiResult.watchdogErrors.length}`);
+                    for (const err of aiResult.watchdogErrors.slice(0, 3)) {
+                        log(`  ${err}`);
+                    }
+                }
+            }
+            else if (aiResult && !aiResult.success) {
+                logWarn(`AI update failed: ${aiResult.error ?? 'unknown error'}`);
+                log('Falling back to scripted resolution...');
+            }
+            else {
+                logWarn('AI did not return a result. Falling back to scripted resolution...');
+            }
         }
-        // Database updates.
-        log('Running database updates...');
-        const updbResult = await exec('ddev', ['drush', 'updb', '-y']);
-        const dbUpdates = updbResult.stdout.includes('No pending updates') ? 0 : 1;
-        if (updbResult.exitCode !== 0) {
-            logFail(`drush updb failed: ${updbResult.stderr.trim()}`);
-            // Rollback.
-            await exec('git', ['checkout', '.']);
-            await exec('git', ['clean', '-fd']);
-            await exec('git', ['checkout', baseBranch]);
-            await exec('git', ['branch', '-D', branchName]);
-            results.push({
-                package: candidate.name,
-                oldVersion: candidate.currentVersion,
-                newVersion: candidate.latestVersion,
-                status: 'fail',
-                branch: branchName,
-                error: `drush updb failed: ${updbResult.stderr.trim()}`,
-                duration: Date.now() - moduleStart,
-            });
-            continue;
+        // Scripted fallback (or primary path when --no-ai).
+        if (!aiUsedSuccessfully) {
+            const resolution = await resolveComposerUpdate(candidate.name, candidate.latestVersion);
+            if (!resolution.success) {
+                const strategiesTried = resolution.attempts.length;
+                logFail(`All ${strategiesTried} resolution strategies failed for ${candidate.name}`);
+                // Show the last meaningful error.
+                const lastAttempt = resolution.attempts[resolution.attempts.length - 1];
+                if (lastAttempt?.output) {
+                    const errorLines = lastAttempt.output.trim().split('\n').slice(0, 3);
+                    for (const line of errorLines) {
+                        log(`  ${line}`);
+                    }
+                }
+                // Rollback (already clean from resolver, but ensure we're on base branch).
+                await exec('git', ['checkout', baseBranch]);
+                await exec('git', ['branch', '-D', branchName]);
+                results.push({
+                    package: candidate.name,
+                    oldVersion: candidate.currentVersion,
+                    newVersion: candidate.latestVersion,
+                    status: 'conflict',
+                    branch: branchName,
+                    error: `${strategiesTried} strategies failed. Last: ${lastAttempt?.strategy}`,
+                    attempts: resolution.attempts.map((a) => a.strategy),
+                    duration: Date.now() - moduleStart,
+                });
+                continue;
+            }
+            // Resolution succeeded — log which strategy worked.
+            const winningStrategy = resolution.attempts.find((a) => a.succeeded);
+            resolvedVersion = resolution.resolvedVersion ?? candidate.latestVersion;
+            updateStrategy = winningStrategy?.strategy ?? 'standard update';
+            updateAttempts = resolution.attempts.length > 1
+                ? resolution.attempts.map((a) => a.strategy)
+                : undefined;
+            if (resolution.attempts.length > 1) {
+                logOk(`Resolved via: ${winningStrategy?.strategy} (version ${resolvedVersion})`);
+            }
+            else {
+                logOk(`Updated to ${resolvedVersion}`);
+            }
+            // Database updates.
+            log('Running database updates...');
+            const updbResult = await exec('ddev', ['drush', 'updb', '-y']);
+            dbUpdates = updbResult.stdout.includes('No pending updates') ? 0 : 1;
+            if (updbResult.exitCode !== 0) {
+                logFail(`drush updb failed: ${updbResult.stderr.trim()}`);
+                // Rollback.
+                await exec('git', ['checkout', '.']);
+                await exec('git', ['clean', '-fd', '-e', '.boltrc.yml', '-e', '.bolt/']);
+                await exec('git', ['checkout', baseBranch]);
+                await exec('git', ['branch', '-D', branchName]);
+                results.push({
+                    package: candidate.name,
+                    oldVersion: candidate.currentVersion,
+                    newVersion: candidate.latestVersion,
+                    status: 'fail',
+                    branch: branchName,
+                    error: `drush updb failed: ${updbResult.stderr.trim()}`,
+                    duration: Date.now() - moduleStart,
+                });
+                continue;
+            }
+            // Cache rebuild.
+            await exec('ddev', ['drush', 'cr']);
         }
-        // Cache rebuild.
-        await exec('ddev', ['drush', 'cr']);
+        // Ensure bolt_inspect is available (composer update can displace it).
+        await ensureBoltInspect();
         // Run tests.
         log('Running regression tests...');
         let testResult;
         try {
-            testResult = await runModuleTest(adapter, config, siteUrl);
+            testResult = await runModuleTest(adapter, config, siteUrl, vrBaselineDir);
         }
         catch (err) {
             logFail(`Test error: ${err instanceof Error ? err.message : String(err)}`);
             // Rollback.
             await exec('git', ['checkout', '.']);
-            await exec('git', ['clean', '-fd']);
+            await exec('git', ['clean', '-fd', '-e', '.boltrc.yml', '-e', '.bolt/']);
             await exec('git', ['checkout', baseBranch]);
             await exec('git', ['branch', '-D', branchName]);
             results.push({
@@ -442,7 +825,7 @@ export async function updateCommand(options) {
             logFail(`Tests failed: ${testResult.failCount} failure(s)`);
             // Rollback.
             await exec('git', ['checkout', '.']);
-            await exec('git', ['clean', '-fd']);
+            await exec('git', ['clean', '-fd', '-e', '.boltrc.yml', '-e', '.bolt/']);
             await exec('git', ['checkout', baseBranch]);
             await exec('git', ['branch', '-D', branchName]);
             results.push({
@@ -476,11 +859,17 @@ export async function updateCommand(options) {
         }
         // Stage and commit.
         log('Committing...');
-        await exec('git', ['add', '-A']);
+        await exec('git', ['add', '-A', '--', '.', ':!.boltrc.yml', ':!.bolt/']);
+        const actualVersion = resolvedVersion;
+        const resolutionNote = aiUsedSuccessfully
+            ? `Resolution: ${updateStrategy}`
+            : updateAttempts && updateAttempts.length > 1
+                ? `Resolution: ${updateStrategy} (${updateAttempts.length} strategies tried)`
+                : `Composer: ddev composer update ${candidate.name} --with-dependencies`;
         const commitMessage = [
-            `Update ${candidate.name} from ${candidate.currentVersion} to ${candidate.latestVersion}`,
+            `Update ${candidate.name} from ${candidate.currentVersion} to ${actualVersion}`,
             '',
-            `Composer: ddev composer update ${candidate.name} --with-dependencies`,
+            resolutionNote,
             `Database: drush updb (${dbUpdates > 0 ? 'updates applied' : 'no pending updates'})`,
             `Config: drush cex (${configChanges.length > 0 ? `${configChanges.length} files changed` : 'no changes'})`,
             '',
@@ -499,7 +888,7 @@ export async function updateCommand(options) {
         results.push({
             package: candidate.name,
             oldVersion: candidate.currentVersion,
-            newVersion: candidate.latestVersion,
+            newVersion: actualVersion,
             status: 'pass',
             branch: branchName,
             commitHash,
@@ -510,12 +899,22 @@ export async function updateCommand(options) {
             },
             configChanges,
             dbUpdates,
+            attempts: updateAttempts,
             duration: Date.now() - moduleStart,
         });
         // Return to base branch for next module.
         await exec('git', ['checkout', baseBranch]);
         process.stderr.write('\n');
     }
+    // Clean up VR baseline temp directory.
+    if (vrBaselineDir && existsSync(vrBaselineDir)) {
+        try {
+            rmSync(vrBaselineDir, { recursive: true, force: true });
+        }
+        catch {
+            // Non-fatal.
+        }
+    }
     // --- Report ---
     const totalDuration = Date.now() - startTime;
     const updated = results.filter((r) => r.status === 'pass').length;