scai 0.1.165 → 0.1.167

package/dist/agents/MainAgent.js

@@ -19,18 +19,9 @@ import { selectRelevantSourcesStep } from "./selectRelevantSourcesStep.js";
 import { iterationFileSelector } from "./iterationFileSelector.js";
 import { finalAnswerModule } from "../pipeline/modules/finalAnswerModule.js";
 import { reasonNextStep } from "./reasonNextStep.js";
+import chalk from "chalk";
 /* ───────────────────────── registry ───────────────────────── */
-/**
- * Registry mapping action names to their corresponding Module implementations.
- * This registry is populated with built-in modules from the module registry.
- */
 const MODULE_REGISTRY = Object.fromEntries(Object.entries(builtInModules).map(([name, mod]) => [name, mod]));
-/**
- * Resolves a module by its action name.
- *
- * @param action - The action name to resolve.
- * @returns The Module implementation if found, otherwise undefined.
- */
 function resolveModuleForAction(action) {
     return MODULE_REGISTRY[action];
 }
@@ -66,7 +57,6 @@ export class MainAgent {
     async run() {
         this.runCount = 0;
         await this.runBoot();
-        await this.runPrecheck();
         await this.runScope();
         await this.runGrounding();
         await this.runWorkLoop();
@@ -78,27 +68,23 @@ export class MainAgent {
         await understandIntentStep.run({ context: this.context });
         await resolveExecutionModeStep.run(this.context);
         // Boot the task and get the real DB taskId
-        this.taskId = bootTaskForRepo(this.context, getDbForRepo(), this.logLine.bind(this));
-        // Ensure context.task exists and has all required fields
+        this.taskId = bootTaskForRepo(this.context, getDbForRepo(), (phase, step, ms, desc) => this.logLine(phase, step, ms, desc, { highlight: true }));
         (_a = this.context).task || (_a.task = {
             id: this.taskId,
-            projectId: 0, // optionally set to a real projectId if available
+            projectId: 0,
             status: "active",
             initialQuery: this.context.initContext?.userQuery ?? "",
             createdAt: new Date().toISOString(),
             updatedAt: new Date().toISOString(),
             taskSteps: [],
         });
-        // If task existed but id wasn’t set, set it now
         this.context.task.id = this.taskId;
-    }
-    /* ───────────── precheck ───────────── */
-    async runPrecheck() {
-        await fileCheckStep(this.context);
+        this.logLine("TASK", "Boot complete", undefined, `taskId=${this.taskId}`, { highlight: true });
     }
     /* ───────────── scope ───────────── */
     async runScope() {
         await scopeClassificationStep.run(this.context);
+        this.logLine("TASK", "Scope classification complete");
     }
     /* ───────────── grounding / info acquisition loop ───────────── */
     async runGrounding() {
@@ -108,48 +94,44 @@ export class MainAgent {
             if (this.canExecutePhase("planning") &&
                 this.canExecuteScope("planning")) {
                 const t = this.startTimer();
-                // Generate info plan step(s) in context
                 await infoPlanGenStep.run(this.context);
                 const infoPlan = this.context.analysis?.planSuggestion?.plan ?? { steps: [] };
                 for (const step of infoPlan.steps) {
                     const stepIO = { query: this.query };
                     await this.executeStep(step, stepIO);
-                    // Re-check any new files discovered
-                    const t2 = this.startTimer();
-                    await fileCheckStep(this.context);
-                    this.logLine("PRECHECK", "postFileSearch", t2());
                 }
-                this.logLine("PLAN", "infoPlanGen", t());
+                this.logLine("PLAN", "infoPlanGen", t(), undefined, { highlight: false });
             }
             // ---------------- DETERMINISTIC EVIDENCE VERIFICATION ----------------
             const t1 = this.startTimer();
             await evidenceVerifierStep.run({ query: this.query, context: this.context });
-            this.logLine("ANALYSIS", "collectAnalysisEvidence", t1(), undefined);
-            // Select grounded candidate files
+            this.logLine("ANALYSIS", "collectAnalysisEvidence", t1());
+            /* ───────────── precheck ───────────── */
             const t2 = this.startTimer();
+            await fileCheckStep(this.context);
+            this.logLine("ANALYSIS", "fileCheckStep", t2());
+            // Select grounded candidate files
+            const t3 = this.startTimer();
             await selectRelevantSourcesStep.run({ query: this.query, context: this.context });
-            this.logLine("ANALYSIS", "selectRelevantSources", t2(), undefined);
+            this.logLine("ANALYSIS", "selectRelevantSources", t3());
             // ---------------- READINESS GATE ----------------
-            const t3 = this.startTimer();
+            const t4 = this.startTimer();
             await readinessGateStep.run(this.context);
-            this.logLine("HASINFO", "readinessGate", t3(), undefined);
+            this.logLine("HASINFO", "readinessGate", t4());
             ready = this.context.analysis?.readiness?.decision === "ready";
             if (!ready) {
                 this.runCount++;
-                // Previously resetInitContextForLoop removed; optionally clear temporary data
-                if (this.context.analysis) {
+                if (this.context.analysis)
                     this.context.analysis.planSuggestion = undefined;
-                }
-                this.logLine("HASINFO", "readinessGate", undefined, "Not ready, looping back to information acquisition");
+                this.logLine("HASINFO", "Not ready — looping back to information acquisition", undefined, undefined, { highlight: false });
             }
         }
     }
     /* ───────────── finalize ───────────── */
     async runFinalize() {
-        // generate final answer
         await finalAnswerModule.run({ query: this.query, context: this.context });
-        // persist task and steps
         persistTaskData(this.context, this.taskId, getDbForRepo(), this.logLine.bind(this));
+        this.logLine("TASK", "Finalize complete", undefined, undefined, { highlight: false });
     }
     /* ───────────── work loop ───────────── */
     async runWorkLoop() {
@@ -159,29 +141,21 @@ export class MainAgent {
             await reasonNextTaskStep.run(this.context);
             const nextAction = this.context.analysis?.iterationReasoning?.nextAction;
             if (nextAction === "complete") {
-                this.logLine("TASK", "All selected files processed — task complete");
+                this.logLine("TASK", "All selected files processed — task complete", undefined, undefined, { highlight: false });
                 return;
             }
             const taskStep = await iterationFileSelector.run(this.context);
             if (!taskStep) {
-                this.logLine("TASK", "No eligible taskStep found — task complete");
+                this.logLine("TASK", "No eligible taskStep found — task complete", undefined, undefined, { highlight: false });
                 return;
             }
-            // Set current step in context
-            if (this.context.task) {
-                this.context.task.currentStep = taskStep;
-            }
+            this.context.task.currentStep = taskStep;
             stepCount++;
             taskStep.taskId = this.taskId;
             taskStep.stepIndex = stepCount;
             taskStep.status = "pending";
-            // ⬇️ Persist newly created step
             persistTaskStepInsert(taskStep, getDbForRepo());
-            logInputOutput("Step to process", "input", taskStep);
-            this.logLine("TASK", `Processing taskStep ${stepCount}/${MAX_TASK_STEPS}`, undefined, taskStep.filePath);
-            // ---------------------------
-            //  Start the step
-            // ---------------------------
+            this.logLine("NEW STEP", `Processing taskStep ${stepCount}/${MAX_TASK_STEPS}`, undefined, taskStep.filePath, { highlight: true });
             taskStep.startTime = Date.now();
             persistTaskStepStart(taskStep, getDbForRepo());
             // ---------------------------
@@ -192,14 +166,15 @@ export class MainAgent {
                 taskStep.status = "completed";
                 taskStep.endTime = Date.now();
                 persistTaskStepCompletion(taskStep, getDbForRepo());
+                this.logLine("STEP-DONE", `Completed taskStep ${stepCount}`, undefined, taskStep.filePath, { highlight: false });
             }
             else {
-                // optionally mark as pending or redo-step
                 taskStep.status = "pending";
                 persistTaskStepCompletion(taskStep, getDbForRepo());
+                this.logLine("STEP", `Pending taskStep ${stepCount}`, undefined, taskStep.filePath);
             }
         }
-        this.logLine("TASK", "Max task step limit reached — stopping work loop");
+        this.logLine("TASK", "Max task step limit reached — stopping work loop", undefined, undefined, { highlight: false });
     }
     /* ───────────── step iterations ───────────── */
     async runStepIterations(taskStep) {
@@ -207,31 +182,22 @@ export class MainAgent {
         let loopCount = 0;
         const getNextIterationAction = () => {
             const nextAction = this.context.analysis?.iterationReasoning?.nextAction;
-            if (nextAction !== "continue" &&
-                nextAction !== "redo-step" &&
-                nextAction !== "expand-scope" &&
-                nextAction !== "request-feedback" &&
-                nextAction !== "complete") {
-                return "complete"; // fallback
-            }
+            if (!["continue", "redo-step", "expand-scope", "request-feedback", "complete"].includes(nextAction ?? ""))
+                return "complete";
             return nextAction;
         };
-        // Loop through iterations for a single task step (file)
         while (loopCount < MAX_ITERATIONS) {
             this.runCount++;
             loopCount++;
-            // 🔴 HARD RESET — no carryover allowed
-            if (this.context.analysis?.iterationReasoning) {
+            if (this.context.analysis?.iterationReasoning)
                 this.context.analysis.iterationReasoning.nextAction = undefined;
-            }
             await this.runWorkIteration(taskStep);
             const nextAction = getNextIterationAction();
-            this.logLine("STEP-LOOP", "nextAction", undefined, nextAction);
+            this.logLine("STEP-LOOP", `nextAction = ${nextAction}`);
             if (nextAction === "complete")
                 return "complete";
             if (nextAction === "request-feedback")
                 return "request-feedback";
-            // else: continue
         }
         return "continue";
     }
@@ -239,56 +205,47 @@ export class MainAgent {
     async runWorkIteration(taskStep) {
         if (!this.context.analysis)
             this.context.analysis = {};
-        // ---------------- ANALYSIS ----------------
         if (this.canExecutePhase("analysis") && this.canExecuteScope("analysis")) {
             const tAnalysis = this.startTimer();
             await analysisPlanGenStep.run(this.context);
-            this.logLine("PLAN", "analysisPlanGen", tAnalysis());
+            this.logLine("PLAN", "analysisPlanGen", tAnalysis(), undefined, { highlight: false });
             const analysisPlan = this.context.analysis?.planSuggestion?.plan ?? { steps: [] };
             for (const step of analysisPlan.steps) {
                 const tStep = this.startTimer();
                 await this.executeStep(step, { query: this.query });
-                this.logLine("STEP", step.action || "unnamedStep", tStep());
+                this.logLine("PLANNING-STEP", step.action || "unnamedStep", tStep());
             }
-            if (this.context.analysis) {
+            if (this.context.analysis)
                 this.context.analysis.planSuggestion = undefined;
-            }
         }
-        // ---------------- TRANSFORM ----------------
         if (this.canExecutePhase("transform") && this.canExecuteScope("transform")) {
             const tTransform = this.startTimer();
             await transformPlanGenStep.run(this.context);
-            this.logLine("PLAN", "transformPlanGen", tTransform());
+            this.logLine("PLAN", "transformPlanGen", tTransform(), undefined, { highlight: false });
             const transformPlan = this.context.analysis?.planSuggestion?.plan ?? { steps: [] };
             const firstStep = transformPlan.steps[0];
             if (firstStep) {
                 const tStep = this.startTimer();
                 await this.executeStep(firstStep, { query: this.query });
-                this.logLine("STEP", `#1 (only) - ${firstStep.action || "unnamedStep"}`, tStep());
+                this.logLine("PLANNING-STEP", `#1 (only) - ${firstStep.action || "unnamedStep"}`, tStep());
             }
-            if (this.context.analysis) {
+            if (this.context.analysis)
                 this.context.analysis.planSuggestion = undefined;
-            }
-            // ---------------- WRITE ----------------
             if (this.canExecutePhase("write") && this.canExecuteScope("write")) {
                 const tWrite = this.startTimer();
                 await writeFileStep.run({ query: this.query, context: this.context });
                 this.logLine("WRITE", "writeFileStep", tWrite());
             }
-            // ---------------- VALIDATION ----------------
             const tValidate = this.startTimer();
             await validateChangesStep.run(this.context);
             this.logLine("VALIDATION", "validateChangesStep", tValidate());
         }
-        // ---------------- REASONING ----------------
         const tReason = this.startTimer();
         await reasonNextStep.run(this.context, taskStep);
         this.logLine("REASONING", "reasonNextStep", tReason());
-        // ---------------- COLLABORATOR FEEDBACK ----------------
         const tCollab = this.startTimer();
         await collaboratorStep.run(this.context);
         this.logLine("FEEDBACK", "collaboratorStep", tCollab());
-        // ---------------- INTEGRATE FEEDBACK ----------------
         const tIntegrate = this.startTimer();
         await integrateFeedbackStep.run(this.context);
         this.logLine("FEEDBACK", "integrateFeedbackStep", tIntegrate());
@@ -304,9 +261,7 @@ export class MainAgent {
      */
     async executeStep(step, input) {
         const stop = this.startTimer();
-        // Set current step in context
         this.context.currentStep = step;
-        // Resolve module for this action
         const mod = resolveModuleForAction(step.action);
         if (!mod) {
             this.logLine("EXECUTE", step.action, stop(), "skipped (missing module)");
@@ -314,13 +269,7 @@ export class MainAgent {
         }
         try {
             this.ui.update(`Running step: ${step.action}`);
-            // Execute the module
-            await mod.run({
-                query: step.description ?? input.query,
-                content: input.data ?? input.content,
-                context: this.context
-            });
-            // Return ModuleIO (can remain minimal since output is untyped)
+            await mod.run({ query: step.description ?? input.query, content: input.data ?? input.content, context: this.context });
             return { query: step.description ?? input.query, data: {} };
         }
         catch (err) {
@@ -342,12 +291,10 @@ export class MainAgent {
         switch (phase) {
             case "analysis":
             case "planning":
-                // Read-only phases are always allowed
                 allowed = !docsOnly;
                 break;
             case "transform":
             case "write":
-                // Side-effect phases require explicit permission
                 allowed = constraints?.allowFileWrites ?? false;
                 break;
         }
@@ -365,14 +312,10 @@ export class MainAgent {
         let allowed = false;
         switch (scope) {
             case "none":
-                // Non-repo questions: analysis/planning only
                 allowed = phase === "analysis" || phase === "planning";
                 break;
-            case "single-file":
-            case "multi-file":
-            case "repo-wide":
+            default:
                 allowed = true;
-                break;
         }
         return allowed;
     }
@@ -396,38 +339,33 @@ export class MainAgent {
      * @param fn - The function to execute while spinner is paused.
      */
     withSpinnerPaused(fn) {
-        this.ui.pause(() => {
-            // Ensure spinner line is fully gone
-            process.stdout.write('\r\x1b[K');
-            fn();
-        });
+        this.ui.pause(() => { process.stdout.write('\r\x1b[K'); fn(); });
     }
-    /**
-     * Logs a line with timing information.
-     *
-     * @param phase - The phase of execution.
-     * @param step - The step being executed.
-     * @param ms - The execution time in milliseconds.
-     * @param desc - Optional description of the step.
-     */
-    logLine(phase, step, ms, desc) {
+    logLine(phase, step, ms, desc, options) {
         this.withSpinnerPaused(() => {
             const suffix = desc ? ` — ${desc}` : "";
             const timing = typeof ms === "number" ? ` (${ms}ms)` : "";
-            console.log(`[AGENT] ${phase} :: ${step}${suffix}${timing}`);
+            let line = `[AGENT] ${phase} :: ${step}${suffix}${timing}`;
+            // Coloring rules
+            if (phase === "NEW STEP" || phase === "STEP") {
+                line = chalk.green(line);
+            }
+            else if (options?.highlight) {
+                line = chalk.green(line);
+            }
+            // Print a blank line **before** NEW STEP only
+            if (phase === "NEW STEP")
+                console.log();
+            console.log(line);
         });
     }
-    /**
-     * Logs a message to the user output.
-     *
-     * @param message - The message to log.
-     */
     userOutput(message) {
         this.withSpinnerPaused(() => {
             console.log(`[USER OUTPUT] ${message}`);
         });
     }
 }
+// All helper functions (persistTaskData, bootTaskForRepo, persistTaskStep*) remain unchanged
 /* ───────────── FOLDER CAPSULES SUMMARY HELPER ───────────── */
 /**
  * Generates a human-readable summary of folder capsules and logs it.

package/dist/agents/evidenceVerifierStep.js

@@ -3,15 +3,17 @@ import fs from "fs";
 import { logInputOutput } from "../utils/promptLogHelper.js";
 /**
  * Deterministic evidence verification:
- * - Scans candidate files line-by-line for exact or heuristic matches to the query.
- * - Marks relevance passively; only enables modification when evidence is found.
+ * - Scans candidate files line-by-line for meaningful matches to the query.
+ * - Filters stopwords and short tokens.
+ * - Deduplicates symbol evidence per file.
+ * - Removes low-signal keyword clustering.
  */
 export const evidenceVerifierStep = {
     name: "evidenceVerifier",
     description: "Deterministic evidence-first scan over candidate files to populate fileAnalysis, with filename dominance.",
     groups: ["analysis"],
     run: async (input) => {
-        var _a, _b, _c;
+        var _a, _b;
         const query = input.query ?? "";
         const context = input.context;
         if (!context?.analysis) {
@@ -19,24 +21,32 @@ export const evidenceVerifierStep = {
         }
         (_a = context.analysis).fileAnalysis ?? (_a.fileAnalysis = {});
         const candidatePaths = [
-            ...(context.analysis.focus?.selectedFiles ?? []),
-            ...(context.analysis.focus?.candidateFiles ?? []),
+            ...(context.initContext?.relatedFiles ?? []),
         ];
         const uniquePaths = Array.from(new Set(candidatePaths));
         if (!uniquePaths.length) {
             console.warn("[evidenceVerifier] No candidate files to scan.");
             return { query, data: {} };
         }
-        const filesWithEvidence = [];
+        // ----------------- Stopwords -----------------
+        const STOPWORDS = new Set([
+            "the", "and", "for", "with", "from", "that",
+            "this", "are", "was", "were", "has", "have",
+            "had", "not", "but", "can", "could", "should",
+            "would", "into", "onto", "about", "above",
+            "below", "under", "over", "then", "else",
+            "when", "where", "what", "which", "while",
+            "return", "const", "let", "var", "true", "false",
+            "null", "undefined", "new", "set", "get",
+            "in", "to", "of", "on", "at", "by"
+        ]);
         // ----------------- Parse query for targets -----------------
         const sentenceTargets = [];
-        // 1️⃣ Capture text inside quotes (existing behavior)
         const quoteRegex = /['"`](.+?)['"`]/g;
         let match;
         while ((match = quoteRegex.exec(query)) !== null) {
             sentenceTargets.push(match[1]);
         }
-        // 2️⃣ Capture heuristic unquoted sentences if none found inside quotes
         if (!sentenceTargets.length) {
             const heuristicSentences = query
                 .split(/[\.\n]/)
@@ -51,15 +61,43 @@ export const evidenceVerifierStep = {
         const filenameTargets = query
             .split(/\s+/)
             .map(word => word.replace(/['",]/g, ''))
-            .filter(w => w.match(/\.(ts|js|tsx|md)$/) || w.length > 5);
+            .filter(w => w.match(/\.(ts|js|tsx|md)$/));
         const baseNameTargets = filenameTargets.map(t => t.replace(/\.(ts|js|tsx|md)$/, ''));
+        // ---- Symbol extraction (filtered + deduplicated) ----
         const symbolTargets = [];
-        const symbolRegex = /\b([a-zA-Z_]\w+)(?:\(\))?\b/g;
+        const symbolRegex = /\b([a-zA-Z_]\w{2,})(?:\(\))?\b/g;
         let symMatch;
         while ((symMatch = symbolRegex.exec(query)) !== null) {
-            symbolTargets.push(symMatch[1]);
+            const token = symMatch[1];
+            if (token.length >= 3 &&
+                !STOPWORDS.has(token.toLowerCase()) &&
+                !sentenceTargets.includes(token)) {
+                symbolTargets.push(token);
+            }
+        }
+        const uniqueSymbolTargets = Array.from(new Set(symbolTargets));
+        // ----------------- Token strength tiering -----------------
+        const WEAK_TOKENS = new Set([
+            "file",
+            "line",
+            "move",
+            "update",
+            "change",
+            "modify",
+            "readme"
+        ]);
+        function computeSymbolConfidence(sym) {
+            const lower = sym.toLowerCase();
+            // If symbol appears inside quoted sentence → very strong
+            const fromQuoted = sentenceTargets.some(s => s.toLowerCase().includes(lower));
+            if (fromQuoted)
+                return 0.95;
+            // Weak structural tokens → low weight
+            if (WEAK_TOKENS.has(lower))
+                return 0.5;
+            // Default meaningful symbol
+            return 0.85;
         }
-        const mode = context.executionControl?.mode ?? "transform";
         // ----------------- Process each file -----------------
         for (const path of uniquePaths) {
             let code = null;
@@ -72,60 +110,98 @@ export const evidenceVerifierStep = {
             const lines = code?.split("\n") ?? [];
             const evidenceItems = [];
             const matchedLines = [];
-            // Sentence & Symbol evidence
+            const addedSymbols = new Set();
+            // Sentence matches
             lines.forEach((line, idx) => {
                 sentenceTargets.forEach(target => {
                     if (line.includes(target)) {
+                        const snippet = lines
+                            .slice(Math.max(0, idx - 1), Math.min(lines.length, idx + 2))
+                            .join("\n");
                         evidenceItems.push({
-                            claim: `Line contains the target sentence: "${target}"`,
-                            excerpt: line,
+                            claim: `Sentence match: "${target}"`,
+                            type: "sentence",
+                            excerpt: snippet,
                             span: { startLine: idx + 1, endLine: idx + 1 },
                             confidence: 1,
                         });
                         matchedLines.push(line);
                     }
                 });
-                symbolTargets.forEach(sym => {
-                    if (line.includes(`function ${sym}`) || line.includes(`class ${sym}`)) {
-                        evidenceItems.push({
-                            claim: `Line contains target symbol: "${sym}"`,
-                            excerpt: line,
-                            span: { startLine: idx + 1, endLine: idx + 1 },
-                            confidence: 0.9,
-                        });
-                        matchedLines.push(line);
+            });
+            // Symbol matches (deduplicated per symbol)
+            uniqueSymbolTargets.forEach(sym => {
+                for (let idx = 0; idx < lines.length; idx++) {
+                    const line = lines[idx];
+                    if (line.includes(`function ${sym}`) ||
+                        line.includes(`class ${sym}`) ||
+                        line.includes(sym)) {
+                        if (!addedSymbols.has(sym)) {
+                            addedSymbols.add(sym);
+                            const snippet = lines
+                                .slice(Math.max(0, idx - 1), Math.min(lines.length, idx + 2))
+                                .join("\n");
+                            evidenceItems.push({
+                                claim: `Symbol reference found: "${sym}"`,
+                                type: "symbol",
+                                excerpt: snippet,
+                                span: { startLine: idx + 1, endLine: idx + 1 },
+                                confidence: computeSymbolConfidence(sym),
+                            });
+                            matchedLines.push(line);
+                        }
+                        break; // stop after first meaningful match
                     }
-                });
+                }
             });
             // Filename-level evidence
             const fullFileName = path.split("/").pop() ?? "";
             const baseFileName = fullFileName.replace(/\.(ts|js|tsx|md)$/, "");
-            if (filenameTargets.includes(fullFileName) || baseNameTargets.includes(baseFileName)) {
+            if (filenameTargets.includes(fullFileName) ||
+                baseNameTargets.includes(baseFileName)) {
                 evidenceItems.push({
                     claim: `Filename matches query target: "${fullFileName}"`,
+                    type: "filename",
                     excerpt: `Path: ${path}`,
                     span: { startLine: 0, endLine: 0 },
                     confidence: 1,
                 });
             }
+            // ----------------- Compute file-level confidence -----------------
+            let fileScore = 0;
+            for (const ev of evidenceItems) {
+                if (ev.type === "sentence")
+                    fileScore += 1.0;
+                else if (ev.type === "filename")
+                    fileScore += 1.0;
+                else if (ev.type === "symbol")
+                    fileScore += ev.confidence ?? 0.8;
+            }
+            // Normalize to 0–1 range (soft cap)
+            const fileConfidence = fileScore === 0
+                ? 0
+                : Math.min(1, fileScore / 3); // 3 strong signals = max confidence
             const isFocusFile = context.analysis.focus?.selectedFiles?.includes(path) ?? false;
             const hasEvidence = evidenceItems.length > 0;
             // ----------------- Merge into fileAnalysis -----------------
             if (isFocusFile || hasEvidence) {
+                const confidenceLabel = fileConfidence.toFixed(2);
                 context.analysis.fileAnalysis[path] = {
                     ...context.analysis.fileAnalysis[path],
                     intent: "relevant",
-                    relevanceExplanation: `${evidenceItems.length} evidence item(s) match the query${isFocusFile ? " (focus file already selected)" : ""}`,
+                    relevanceExplanation: `[confidence:${confidenceLabel}] ${evidenceItems.length} evidence item(s) match the query${isFocusFile ? " (focus file already selected)" : ""}`,
                     role: "primary",
                     action: {
                         isRelevant: true,
-                        shouldModify: hasEvidence
+                        shouldModify: hasEvidence,
                     },
                     proposedChanges: hasEvidence
                         ? {
                             summary: "Evidence found in file",
                             scope: "minor",
-                            targets: matchedLines.length ? matchedLines : undefined,
+                            targets: matchedLines.length
+                                ? Array.from(new Set(matchedLines))
+                                : undefined,
                         }
                         : {
                             summary: "No evidence found",
@@ -137,9 +213,6 @@ export const evidenceVerifierStep = {
                         : ["No concrete evidence found; modification not permitted"],
                     evidence: evidenceItems,
                 };
-                if (hasEvidence) {
-                    filesWithEvidence.push(path);
-                }
             }
             else {
                 (_b = context.analysis.fileAnalysis)[path] || (_b[path] = {
@@ -152,12 +225,6 @@ export const evidenceVerifierStep = {
                 });
             }
         }
-        // ----------------- Update focus after processing -----------------
-        (_c = context.analysis).focus ?? (_c.focus = { selectedFiles: [] });
-        context.analysis.focus.selectedFiles = Array.from(new Set([
-            ...(context.analysis.focus.selectedFiles ?? []),
-            ...filesWithEvidence,
-        ]));
         const output = {
             query,
             data: { fileAnalysis: context.analysis.fileAnalysis },