aspectcode 0.4.0 → 1.0.0

package/dist/optimize.js

@@ -2,31 +2,34 @@
 /**
  * Optimize wrapper — tries LLM optimization, falls back to static content.
  *
- * - If an API key is available → run the optimization agent
- * - If evaluator is enabled → single-pass optimize then probe & diagnose
+ * - If an API key is available → generate seed AGENTS.md from KB
+ * - If probeAndRefine=true → run multi-iteration probe-and-refine loop
  * - If no API key → warn and write static AGENTS.md content
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryOptimize = tryOptimize;
 const optimizer_1 = require("@aspectcode/optimizer");
 const evaluator_1 = require("@aspectcode/evaluator");
-const emitters_1 = require("@aspectcode/emitters");
 const logger_1 = require("./logger");
 const store_1 = require("./ui/store");
+const auth_1 = require("./auth");
+const usageTracker_1 = require("./usageTracker");
+const preferences_1 = require("./preferences");
 /**
  * Try to generate AGENTS.md content via LLM using static analysis as context.
  * Falls back to static instruction content when no API key is available.
+ *
+ * @param probeAndRefine  When true, run the multi-iteration probe-and-refine loop
+ *                        after generating the seed. Only on first run or manual rerun.
  */
-async function tryOptimize(ctx, kbContent, toolInstructions, config, baseContent) {
+async function tryOptimize(ctx, kbContent, _toolInstructions, config, _baseContent, probeAndRefine = false, preferences, userSettings, staticRules) {
     const { flags, log, root } = ctx;
-    const optConfig = config?.optimize;
     const evalConfig = config?.evaluate;
-    const evaluatorEnabled = evalConfig?.enabled !== false; // Default: true
-    // ── Resolve settings ──────────────────────────────────────
-    const temperature = flags.temperature ?? optConfig?.temperature;
-    const model = flags.model ?? optConfig?.model;
-    const providerName = flags.provider ?? optConfig?.provider;
-    const maxTokens = optConfig?.maxTokens;
+    const evaluatorEnabled = probeAndRefine && evalConfig?.enabled !== false;
+    // ── Resolve settings (CLI flags > cloud user settings > defaults) ──
+    const temperature = flags.temperature ?? userSettings?.temperature;
+    const model = flags.model ?? userSettings?.model;
+    const maxTokens = userSettings?.maxTokens;
     // ── Load .env and try to resolve a provider ───────────────
     let env;
     try {
@@ -35,8 +38,19 @@ async function tryOptimize(ctx, kbContent, toolInstructions, config, baseContent
     catch {
         env = {};
     }
-    if (providerName && !env['LLM_PROVIDER']) {
-        env['LLM_PROVIDER'] = providerName;
+    // Inject BYOK key from aspectcode.json if set
+    if (config?.apiKey && !env['ASPECTCODE_LLM_KEY']) {
+        env['ASPECTCODE_LLM_KEY'] = config.apiKey;
+    }
+    // Pass CLI token so the aspectcode hosted provider can authenticate
+    const creds = (0, auth_1.loadCredentials)();
+    if (creds && !env['ASPECTCODE_CLI_TOKEN']) {
+        env['ASPECTCODE_CLI_TOKEN'] = creds.token;
+    }
+    // Only set LLM_PROVIDER from CLI flags, not user settings.
+    // When logged in, the hosted proxy handles model selection server-side.
+    if (flags.provider && !env['LLM_PROVIDER']) {
+        env['LLM_PROVIDER'] = flags.provider;
     }
     const providerOptions = {};
     if (model)
@@ -46,169 +60,446 @@ async function tryOptimize(ctx, kbContent, toolInstructions, config, baseContent
     if (maxTokens !== undefined)
         providerOptions.maxTokens = maxTokens;
     let provider;
+    let diagnosisProvider; // Sonnet for higher-quality diagnosis
     try {
-        provider = (0, optimizer_1.resolveProvider)(env, providerOptions);
+        provider = (0, usageTracker_1.withUsageTracking)((0, optimizer_1.resolveProvider)(env, providerOptions));
+        // Use Sonnet for the diagnosis step (higher quality for the most impactful call)
+        try {
+            diagnosisProvider = (0, usageTracker_1.withUsageTracking)((0, optimizer_1.resolveProvider)(env, { ...providerOptions, model: 'claude-sonnet-4-20250514' }));
+        }
+        catch {
+            diagnosisProvider = provider; // Fall back to same provider
+        }
     }
-    catch {
-        // No API key available — fall back to static content
-        store_1.store.addSetupNote('no API key — static mode');
-        log.warn('No LLM API key found. Set OPENAI_API_KEY or ANTHROPIC_API_KEY in .env for optimization.');
-        return {
-            content: (0, emitters_1.generateCanonicalContentForMode)('safe', kbContent.length > 0),
-            reasoning: [],
-        };
+    catch (providerErr) {
+        store_1.store.addSetupNote('no LLM available — using static content');
+        const errMsg = providerErr instanceof Error ? providerErr.message : String(providerErr);
+        log.warn(`LLM failed: ${errMsg}`);
+        return { content: _baseContent, reasoning: [], scopedRules: [], deleteSlugs: [] };
     }
     const providerLabel = model ? `${provider.name} (${model})` : provider.name;
-    store_1.store.addSetupNote(`API key: ${provider.name}`);
-    if (evaluatorEnabled) {
-        store_1.store.addSetupNote('evaluator on');
-    }
     log.info(`Generating with ${logger_1.fmt.cyan(provider.name)}${model ? ` (${logger_1.fmt.cyan(model)})` : ''}…`);
     store_1.store.setProvider(providerLabel);
-    // ── Use static content only as fallback (LLM error / cancellation) ─
-    const fallbackContent = baseContent;
-    // ── Build tool instructions context string ────────────────
-    let toolContext = '';
-    if (toolInstructions.size > 0) {
-        const parts = [];
-        for (const [tool, content] of toolInstructions) {
-            parts.push(`### ${tool}\n${content}`);
-        }
-        toolContext = parts.join('\n\n');
-    }
-    // ── Progress callbacks for live dashboard updates ─────────
-    const onProgress = (step) => {
-        switch (step.kind) {
-            case 'generating':
-                store_1.store.setPhase('optimizing', 'generating AGENTS.md…');
-                break;
-            case 'done':
-                store_1.store.setPhase('optimizing', 'generation complete');
-                break;
-        }
-    };
-    // ── Wrap logger for dashboard ─────────────────────────────
     const optLog = flags.quiet ? undefined : {
         info(msg) { log.info(msg); },
         warn(msg) { log.warn(msg); },
         error(msg) { log.error(msg); },
         debug(msg) { log.debug(msg); },
     };
-    // ── Harvest prompts for evaluator (if enabled) ────────────
-    let harvestedPrompts = [];
-    if (evaluatorEnabled && (evalConfig?.harvestPrompts !== false)) {
-        try {
-            store_1.store.setEvalStatus({ phase: 'harvesting' });
-            store_1.store.setPhase('optimizing', 'harvesting prompts');
-            harvestedPrompts = await (0, evaluator_1.harvestPrompts)({
-                root,
-                sources: evalConfig?.harvestSources,
-                maxPerSource: 50,
-                log: optLog,
-            });
-            store_1.store.setEvalStatus({ phase: 'harvesting', harvestCount: harvestedPrompts.length });
-            if (harvestedPrompts.length > 0) {
-                log.info(`Harvested ${harvestedPrompts.length} prompts from AI tool history`);
-            }
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            log.debug(`Prompt harvesting failed (non-fatal): ${msg}`);
-        }
+    // ── Enrich KB with user preferences ─────────────────────
+    let enrichedKb = kbContent;
+    if (preferences) {
+        const prefBlock = (0, preferences_1.formatPreferencesForPrompt)(preferences);
+        if (prefBlock)
+            enrichedKb = kbContent + '\n\n' + prefBlock;
     }
-    const result = await (0, optimizer_1.runGenerateAgent)({
-        currentInstructions: fallbackContent,
-        kb: kbContent,
-        toolInstructions: toolContext || undefined,
-        provider,
-        log: optLog,
-        onProgress,
-    });
-    for (const reason of result.reasoning) {
-        log.debug(`  ${logger_1.fmt.dim(reason)}`);
+    // ── Use base content as seed AGENTS.md ──────────────────
+    const projectName = root.split('/').pop() || root.split('\\').pop() || 'Project';
+    store_1.store.setPhase('optimizing', 'generating seed AGENTS.md…');
+    let finalContent;
+    if (evaluatorEnabled) {
+        // Use the base content (rendered directly from AnalysisModel) as the seed
+        finalContent = _baseContent;
+        log.info('Using base AGENTS.md for probe-and-refine tuning');
     }
-    // Surface token usage from generation call
-    if (result.usage) {
-        store_1.store.setTokenUsage(result.usage);
+    else {
+        // Use base content directly (already rendered from AnalysisModel)
+        finalContent = _baseContent;
     }
-    // ── Evaluate with probes (if enabled) ─────────────────────
-    let finalContent = result.optimizedInstructions;
+    store_1.store.setPhase('optimizing', 'generation complete');
+    // ── Probe-and-refine loop ──────────────────────────────────
+    const scopedRuleCreates = [];
+    const scopedRuleDeletes = [];
+    const allAppliedEdits = [];
     if (evaluatorEnabled) {
+        const iterationSummaries = [];
+        let totalEditsApplied = 0;
+        // ── Abort controller for immediate cancellation ──────
+        const abortController = new AbortController();
+        const { signal } = abortController;
+        const onStoreChange = () => {
+            if (store_1.store.state.evalStatus.cancelled && !signal.aborted) {
+                abortController.abort();
+            }
+        };
+        store_1.store.on('change', onStoreChange);
         try {
+            const loopConfig = {
+                maxIterations: evalConfig?.maxIterations ?? evaluator_1.DEFAULT_PROBE_REFINE_CONFIG.maxIterations,
+                targetProbesPerIteration: evalConfig?.maxProbes ?? evaluator_1.DEFAULT_PROBE_REFINE_CONFIG.targetProbesPerIteration,
+                maxEditsPerIteration: evalConfig?.maxEditsPerIteration ?? evaluator_1.DEFAULT_PROBE_REFINE_CONFIG.maxEditsPerIteration,
+                charBudget: evalConfig?.charBudget ?? evaluator_1.DEFAULT_PROBE_REFINE_CONFIG.charBudget,
+            };
             store_1.store.setPhase('evaluating');
-            store_1.store.setEvalStatus({ phase: 'probing' });
-            log.info('Running probe-based evaluation…');
-            const maxProbes = evalConfig?.maxProbes ?? 10;
-            const probes = (0, evaluator_1.generateProbes)({
-                kb: kbContent,
-                harvestedPrompts: harvestedPrompts.length > 0 ? harvestedPrompts : undefined,
-                maxProbes,
-            });
-            // Per-probe progress callback for live dashboard
-            const onProbeProgress = (info) => {
-                if (info.phase === 'starting') {
-                    store_1.store.setEvalStatus({
+            const priorTasks = [];
+            let noChangeStreak = 0;
+            let probeExhaustionStreak = 0;
+            let convergedReason;
+            /** Cooperative cancel check — returns true if the user pressed [x]. */
+            const isCancelled = () => signal.aborted;
+            /** Preserves iterationSummaries across setEvalStatus calls. */
+            const setEval = (status) => {
+                store_1.store.setEvalStatus({
+                    ...status,
+                    iterationSummaries: iterationSummaries.length > 0 ? [...iterationSummaries] : undefined,
+                    cancelled: signal.aborted,
+                });
+            };
+            for (let iteration = 1; iteration <= loopConfig.maxIterations; iteration++) {
+                if (isCancelled())
+                    break;
+                log.info(`\n── Iteration ${iteration}/${loopConfig.maxIterations} ──`);
+                // ── Step 1: Generate probes ──────────────────────
+                setEval({
+                    phase: 'generating-probes',
+                    iteration,
+                    maxIterations: loopConfig.maxIterations,
+                });
+                store_1.store.setPhase('evaluating');
+                const probes = await (0, evaluator_1.generateProbes)({
+                    kb: enrichedKb,
+                    currentAgentsMd: finalContent,
+                    priorProbeTasks: priorTasks,
+                    maxProbes: loopConfig.targetProbesPerIteration,
+                    provider,
+                    projectName,
+                    log: optLog,
+                    signal,
+                });
+                if (isCancelled())
+                    break;
+                // Track prior tasks for cross-iteration dedup
+                for (const p of probes)
+                    priorTasks.push(p.task);
+                if (probes.length === 0) {
+                    probeExhaustionStreak++;
+                    log.info(`No new probes generated (streak: ${probeExhaustionStreak})`);
+                    if (probeExhaustionStreak >= 2) {
+                        convergedReason = 'probe diversity exhausted';
+                        log.info(`Converged: ${convergedReason}`);
+                        break;
+                    }
+                    continue;
+                }
+                else {
+                    probeExhaustionStreak = 0;
+                }
+                // ── Step 2: Simulate probes ──────────────────────
+                const probeTasks = probes.map((p) => p.task);
+                setEval({
+                    phase: 'probing',
+                    iteration,
+                    maxIterations: loopConfig.maxIterations,
+                    probesTotal: probes.length,
+                    probeTasks,
+                });
+                store_1.store.setPhase('evaluating');
+                const onProbeProgress = (info) => {
+                    const currentTask = probes[info.probeIndex]?.task;
+                    const brief = currentTask && currentTask.length > 60
+                        ? currentTask.slice(0, 57) + '...'
+                        : currentTask;
+                    setEval({
                         phase: 'probing',
-                        probesPassed: undefined,
+                        iteration,
+                        maxIterations: loopConfig.maxIterations,
+                        probesPassed: info.probeIndex + (info.phase === 'done' ? 1 : 0),
                         probesTotal: info.total,
+                        probeTasks,
+                        currentProbeTask: brief,
+                    });
+                };
+                const simResults = await (0, evaluator_1.runProbes)(finalContent, probes, provider, optLog, signal, onProbeProgress);
+                if (isCancelled())
+                    break;
+                // ── Step 3: Judge each probe ─────────────────────
+                setEval({
+                    phase: 'judging',
+                    iteration,
+                    maxIterations: loopConfig.maxIterations,
+                    probesTotal: simResults.length,
+                    judgedCount: 0,
+                    weakCount: 0,
+                    strongCount: 0,
+                });
+                store_1.store.setPhase('evaluating');
+                const judgedResults = [];
+                let weakCount = 0;
+                let strongCount = 0;
+                const probeResults = [];
+                // Pre-populate pending entries for all probes
+                for (const sim of simResults) {
+                    const brief = sim.task.length > 60 ? sim.task.slice(0, 57) + '...' : sim.task;
+                    probeResults.push({ task: brief, status: 'pending' });
+                }
+                for (let i = 0; i < simResults.length; i++) {
+                    if (isCancelled())
+                        break;
+                    const sim = simResults[i];
+                    const probe = probes[i];
+                    if (!sim.response)
+                        continue;
+                    const judged = await (0, evaluator_1.judgeProbe)({
+                        task: sim.task,
+                        response: sim.response,
+                        expectedBehaviors: probe.expectedBehaviors,
+                        probeId: sim.probeId,
+                        provider,
+                        log: optLog,
+                        signal,
+                    });
+                    judgedResults.push(judged);
+                    const hasWeak = judged.behaviorReviews.some((b) => b.assessment !== 'strong');
+                    if (hasWeak)
+                        weakCount++;
+                    else
+                        strongCount++;
+                    probeResults[i] = { task: probeResults[i].task, status: hasWeak ? 'weak' : 'strong' };
+                    setEval({
+                        phase: 'judging',
+                        iteration,
+                        maxIterations: loopConfig.maxIterations,
+                        probesTotal: simResults.length,
+                        judgedCount: i + 1,
+                        weakCount,
+                        strongCount,
+                        currentProbeTask: probeResults[i].task,
+                        probeResults: [...probeResults],
                     });
-                    store_1.store.setPhase('evaluating', `probe ${info.probeIndex + 1}/${info.total}: ${info.probeId}`);
+                    log.info(`  ${hasWeak ? '✖' : '✔'} ${sim.probeId} (${hasWeak ? 'weak' : 'strong'})`);
+                }
+                if (isCancelled())
+                    break;
+                // ── Step 4: Aggregate diagnosis ──────────────────
+                setEval({
+                    phase: 'diagnosing',
+                    iteration,
+                    maxIterations: loopConfig.maxIterations,
+                    weakCount,
+                    strongCount,
+                    probesTotal: judgedResults.length,
+                });
+                store_1.store.setPhase('evaluating');
+                // Build scoped rules context for diagnosis
+                const rulesCtx = staticRules?.map((r) => `### ${r.slug} (${r.source})\nGlobs: ${r.globs.join(', ')}\n${r.content}`).join('\n---\n') || '';
+                const staticData = staticRules?.length
+                    ? `${staticRules.length} candidate rules from static analysis (hubs, conventions, circular deps). The LLM decides which are worth keeping as scoped rules vs folding into AGENTS.md.`
+                    : '';
+                const diagnosisEdits = await (0, evaluator_1.diagnose)({
+                    judgedResults,
+                    agentsContent: finalContent,
+                    provider: diagnosisProvider ?? provider,
+                    log: optLog,
+                    signal,
+                    scopedRulesContext: rulesCtx,
+                    staticAnalysisData: staticData,
+                });
+                if (isCancelled())
+                    break;
+                // Merge per-probe edits + diagnosis edits, deduplicate
+                const allEdits = [];
+                for (const jr of judgedResults) {
+                    allEdits.push(...jr.proposedEdits);
+                }
+                allEdits.push(...diagnosisEdits);
+                // Deduplicate by content similarity
+                const seen = new Set();
+                const dedupedEdits = [];
+                for (const edit of allEdits) {
+                    const key = `${edit.section}:${edit.action}:${edit.content.toLowerCase().trim()}`;
+                    if (!seen.has(key)) {
+                        seen.add(key);
+                        dedupedEdits.push(edit);
+                    }
+                }
+                // Separate AGENTS.md edits from scoped rule edits
+                const agentsMdEdits = dedupedEdits.filter((e) => !e.section.startsWith('scoped:'));
+                const scopedEdits = dedupedEdits.filter((e) => e.section.startsWith('scoped:'));
+                // Collect scoped rule operations for later
+                for (const edit of scopedEdits) {
+                    if (edit.section.startsWith('scoped:DELETE:')) {
+                        const slug = edit.section.replace('scoped:DELETE:', '');
+                        scopedRuleDeletes.push(slug);
+                    }
+                    else if (edit.section.startsWith('scoped:CREATE:')) {
+                        const slug = edit.section.replace('scoped:CREATE:', '');
+                        if (edit.content && edit.globs?.length) {
+                            scopedRuleCreates.push({
+                                slug,
+                                description: edit.description || `Rule for ${slug}`,
+                                globs: edit.globs,
+                                content: edit.content,
+                                source: 'probe',
+                            });
+                        }
+                    }
+                    else {
+                        // scoped:slug — update existing rule
+                        const slug = edit.section.replace('scoped:', '');
+                        if (edit.content) {
+                            scopedRuleCreates.push({
+                                slug,
+                                description: edit.description || `Updated rule for ${slug}`,
+                                globs: edit.globs || [`**`],
+                                content: edit.content,
+                                source: 'probe',
+                            });
+                        }
+                    }
+                }
+                const cappedEdits = agentsMdEdits.slice(0, loopConfig.maxEditsPerIteration);
+                const totalEditCount = cappedEdits.length + scopedEdits.length;
+                log.info(`Applying ${cappedEdits.length} AGENTS.md edits, ${scopedEdits.length} scoped rule edits (${allEdits.length} total)`);
+                // ── Step 5: Apply AGENTS.md edits deterministically ────────
+                const pendingEditSummaries = [
+                    ...cappedEdits.map((e) => `${e.action} ${e.section}: "${e.content.length > 60 ? e.content.slice(0, 57) + '...' : e.content}"`),
+                    ...scopedEdits.map((e) => `${e.section}`),
+                ];
+                setEval({
+                    phase: 'applying',
+                    iteration,
+                    maxIterations: loopConfig.maxIterations,
+                    proposedEditCount: totalEditCount,
+                    editSummaries: pendingEditSummaries,
+                });
+                store_1.store.setPhase('evaluating');
+                const guidanceBefore = finalContent;
+                const applyResult = await (0, evaluator_1.applyEditsWithLlm)(finalContent, cappedEdits, loopConfig.charBudget, provider, signal);
+                finalContent = applyResult.content;
+                totalEditsApplied += applyResult.applied + scopedEdits.length;
+                allAppliedEdits.push(...cappedEdits.slice(0, applyResult.applied));
+                allAppliedEdits.push(...scopedEdits);
+                if (applyResult.trimmed > 0) {
+                    log.info(`Trimmed ${applyResult.trimmed} bullets to fit ${loopConfig.charBudget}-char budget`);
+                }
+                // ── Step 6: Convergence check ────────────────────
+                const guidanceChanged = finalContent !== guidanceBefore;
+                if (guidanceChanged) {
+                    noChangeStreak = 0;
+                    log.info(`Guidance updated (${guidanceBefore.length} → ${finalContent.length} chars)`);
                 }
                 else {
-                    // 'done' — accumulate pass count from results so far
-                    store_1.store.setPhase('evaluating', `probe ${info.probeIndex + 1}/${info.total} ${info.passed ? '✔' : '✖'}`);
+                    noChangeStreak++;
+                    log.info(`No guidance change (streak: ${noChangeStreak})`);
                 }
-            };
-            const probeResults = await (0, evaluator_1.runProbes)(finalContent, probes, provider, undefined, // fileContents
-            optLog, undefined, // signal
-            onProbeProgress);
-            const failures = probeResults.filter((r) => !r.passed);
-            const passCount = probeResults.length - failures.length;
+                // Build iteration summary
+                const roundParts = [];
+                roundParts.push(`${probes.length} scenarios`);
+                if (weakCount > 0)
+                    roundParts.push(`${weakCount} gap${weakCount === 1 ? '' : 's'}`);
+                else
+                    roundParts.push('all passed');
+                if (applyResult.applied > 0)
+                    roundParts.push(`${applyResult.applied} improvement${applyResult.applied === 1 ? '' : 's'}`);
+                iterationSummaries.push(`Round ${iteration}: ${roundParts.join(', ')}`);
+                if (noChangeStreak >= 2) {
+                    convergedReason = 'guidance converged (no changes)';
+                    log.info(`Converged: ${convergedReason}`);
+                    break;
+                }
+            }
+            const editSummaries = allAppliedEdits.map((e) => {
+                const verb = { add: 'Added', remove: 'Removed', strengthen: 'Strengthened', modify: 'Updated' }[e.action];
+                const brief = e.content.length > 60 ? e.content.slice(0, 57) + '...' : e.content;
+                return `${verb}: ${brief} (${e.section})`;
+            });
+            const wasCancelled = isCancelled();
             store_1.store.setEvalStatus({
-                phase: 'probing',
-                probesPassed: passCount,
-                probesTotal: probeResults.length,
+                phase: 'done',
+                iteration: loopConfig.maxIterations,
+                maxIterations: loopConfig.maxIterations,
+                diagnosisEdits: totalEditsApplied,
+                convergedReason: wasCancelled ? undefined : convergedReason,
+                editSummaries,
+                iterationSummaries: iterationSummaries.length > 0 ? iterationSummaries : undefined,
+                cancelled: wasCancelled,
             });
-            log.info(`Probes: ${passCount}/${probeResults.length} passed` +
-                (failures.length > 0 ? `, ${failures.length} failed` : ''));
-            // Diagnose and apply edits if there are failures
-            if (failures.length > 0) {
-                store_1.store.setEvalStatus({ phase: 'diagnosing' });
-                store_1.store.setPhase('evaluating', 'diagnosing failures');
-                const diagnosis = await (0, evaluator_1.diagnose)(failures, finalContent, provider, optLog);
-                if (diagnosis && diagnosis.edits.length > 0) {
-                    store_1.store.setPhase('evaluating', 'applying fixes');
-                    log.info(`Applying ${diagnosis.edits.length} diagnosis-driven edits…`);
-                    const fixed = await (0, evaluator_1.applyDiagnosisEdits)(finalContent, diagnosis, provider, optLog);
-                    finalContent = fixed.content;
-                    log.info(`Diagnosis edits applied (${fixed.appliedEdits.length} changes)`);
-                }
-                store_1.store.setEvalStatus({
-                    phase: 'done',
-                    probesPassed: passCount,
-                    probesTotal: probeResults.length,
-                    diagnosisEdits: diagnosis?.edits.length ?? 0,
-                });
+            store_1.store.removeListener('change', onStoreChange);
+            if (wasCancelled) {
+                log.info(`Probe-and-refine cancelled by user (${totalEditsApplied} edits applied)`);
+            }
+            else if (convergedReason) {
+                log.info(`Probe-and-refine complete: ${convergedReason}`);
             }
             else {
+                log.info(`Probe-and-refine complete: max iterations reached`);
+            }
+        }
+        catch (err) {
+            // Clean up abort listener if we exit via exception
+            store_1.store.removeListener('change', onStoreChange);
+            // Tier exhaustion — re-throw so pipeline can show upgrade prompt
+            if (err?.tierExhausted)
+                throw err;
+            // AbortError from cancel — not a real error
+            if (err instanceof DOMException && err.name === 'AbortError') {
+                const editSummaries = allAppliedEdits.map((e) => {
+                    const verb = { add: 'Added', remove: 'Removed', strengthen: 'Strengthened', modify: 'Updated' }[e.action];
+                    const brief = e.content.length > 60 ? e.content.slice(0, 57) + '...' : e.content;
+                    return `${verb}: ${brief} (${e.section})`;
+                });
                 store_1.store.setEvalStatus({
                     phase: 'done',
-                    probesPassed: passCount,
-                    probesTotal: probeResults.length,
-                    diagnosisEdits: 0,
+                    diagnosisEdits: totalEditsApplied,
+                    editSummaries,
+                    iterationSummaries: iterationSummaries.length > 0 ? iterationSummaries : undefined,
+                    cancelled: true,
                 });
+                log.info(`Probe-and-refine cancelled by user (${totalEditsApplied} edits applied)`);
+            }
+            else {
+                const msg = err instanceof Error ? err.message : String(err);
+                log.warn(`Probe and refine failed (non-fatal): ${msg}`);
             }
         }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            log.warn(`Evaluation failed (non-fatal): ${msg}`);
+    }
+    store_1.store.setReasoning([]);
+    // ── Build final scoped rules from evaluator decisions ──────
+    // The diagnosis step decided what scoped rules to create/delete.
+    // Start with static rules, apply evaluator modifications.
+    let finalRules = staticRules ?? [];
+    if (evaluatorEnabled) {
+        // Remove rules the evaluator marked for deletion
+        if (scopedRuleDeletes.length > 0) {
+            const deleteSet = new Set(scopedRuleDeletes);
+            finalRules = finalRules.filter((r) => !deleteSet.has(r.slug));
+            log.info(`Evaluator pruned ${scopedRuleDeletes.length} scoped rule${scopedRuleDeletes.length === 1 ? '' : 's'}`);
+        }
+        // Add/update rules the evaluator created
+        if (scopedRuleCreates.length > 0) {
+            const createBySlug = new Map(scopedRuleCreates.map((r) => [r.slug, r]));
+            // Update existing rules or add new ones
+            finalRules = finalRules.map((r) => createBySlug.get(r.slug) ?? r);
+            // Add truly new rules (not updates)
+            const existingSlugs = new Set(finalRules.map((r) => r.slug));
+            for (const r of scopedRuleCreates) {
+                if (!existingSlugs.has(r.slug))
+                    finalRules.push(r);
+            }
+            log.info(`Evaluator created/updated ${scopedRuleCreates.length} scoped rule${scopedRuleCreates.length === 1 ? '' : 's'}`);
         }
     }
-    store_1.store.setReasoning(result.reasoning);
-    return {
-        content: finalContent,
-        reasoning: result.reasoning,
-        tokenUsage: result.usage,
-    };
+    // ── Save probe-refine edits as preferences ───────────────
+    if (evaluatorEnabled && allAppliedEdits.length > 0 && preferences) {
+        try {
+            let prefs = { ...preferences };
+            for (const edit of allAppliedEdits) {
+                const isSpecific = edit.section.startsWith('scoped:') ||
+                    /(?:^|\s)(?:\.\/|src\/|lib\/|app\/|packages\/|test\/|tests\/)\S+\.\w{1,4}/m.test(edit.content);
+                prefs = (0, preferences_1.addPreference)(prefs, {
+                    rule: `probe-refine:${edit.section}`,
+                    pattern: edit.content.slice(0, 200),
+                    disposition: 'deny',
+                    directory: edit.globs?.[0],
+                    details: `action: ${edit.action}, section: ${edit.section}`,
+                    suggestion: edit.content,
+                    source: isSpecific ? 'probe-refine-specific' : 'probe-refine',
+                });
+            }
+            (0, preferences_1.savePreferences)(root, prefs);
+        }
+        catch { /* best-effort — don't break the pipeline */ }
+    }
+    return { content: finalContent, reasoning: [], scopedRules: finalRules, deleteSlugs: scopedRuleDeletes };
 }
 //# sourceMappingURL=optimize.js.map