scai 0.1.166 → 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 },

package/dist/agents/fileCheckStep.js

@@ -10,7 +10,9 @@ export async function fileCheckStep(context) {
     const intent = context.analysis.intent;
     const planSuggestion = context.analysis.planSuggestion?.text ?? "";
     // Step 1: gather known files from initContext only
-    const knownFiles = new Set(context.initContext?.relatedFiles ?? []);
+    const knownFiles = new Set([
+        ...(context.initContext?.relatedFiles ?? []),
+    ]);
     // Step 2: extract file names from normalizedQuery or planSuggestion
     const extractedFiles = extractFilesFromAnalysis(context.analysis);
     // Step 3: populate focus with safe defaults
@@ -31,9 +33,30 @@ export async function fileCheckStep(context) {
     context.analysis.focus.candidateFiles = candidateFiles;
     context.analysis.focus.rationale =
         `Pre-check: ${selectedFiles.length} files already available, ${candidateFiles.length} unresolved candidate(s).`;
-    // Optional: LLM call for semantic understanding (assumptions, constraints, risks)
+    // ----------------- Deterministic Evidence Extraction -----------------
+    const evidenceByFile = Object.entries(context.analysis.fileAnalysis ?? {}).reduce((acc, [filePath, analysis]) => {
+        if (!analysis?.evidence?.length)
+            return acc;
+        const evidenceItems = analysis.evidence.map(ev => ({
+            type: ev.type,
+            claim: ev.claim,
+            excerpt: ev.excerpt,
+            span: ev.span,
+            confidence: ev.confidence
+        }));
+        // Deterministic file-level confidence aggregation
+        const fileConfidence = evidenceItems.reduce((sum, e) => sum + (e.confidence ?? 0), 0) /
+            evidenceItems.length;
+        acc[filePath] = {
+            fileConfidence: Number(fileConfidence.toFixed(3)),
+            evidenceCount: evidenceItems.length,
+            evidence: evidenceItems
+        };
+        return acc;
+    }, {});
+    // ----------------- Prompt -----------------
     const prompt = `
-You are an AI meta-agent assisting with context verification. The user intent and plan suggestion are below.
+You are an AI meta-agent assisting with context verification.
 
 User intent:
 ${JSON.stringify(intent ?? {}, null, 2)}
@@ -44,11 +67,23 @@ ${planSuggestion}
 Known files in context:
 ${JSON.stringify([...knownFiles], null, 2)}
 
+Deterministic evidence per file:
+${JSON.stringify(evidenceByFile, null, 2)}
+
+Evidence rules:
+- Evidence includes a type ("filename", "symbol", "sentence", "keyword-cluster").
+- Each evidence item includes a confidence score between 0 and 1.
+- Each file includes an aggregated fileConfidence (average of its evidence confidence).
+- Higher confidence and stronger evidence types (e.g. filename, symbol definition) indicate stronger relevance.
+- Evidence alone is NOT sufficient — it must align with user intent.
+
 Task:
-1. Confirm which files are already available to satisfy the intent.
-2. List unresolved candidate files if any.
-3. Suggest any assumptions, constraints, or risks that may affect execution.
-4. Return STRICT JSON with shape:
+1. Evaluate file relevance using BOTH fileConfidence and semantic alignment with intent.
+2. Prefer files with higher fileConfidence when multiple candidates exist.
+3. Only promote files to selectedFiles if they clearly satisfy the user intent.
+4. List unresolved candidate files if any.
+5. Suggest assumptions, constraints, or risks that may affect execution.
+6. Return STRICT JSON with shape:
 
 {
   "selectedFiles": string[],

package/dist/agents/reasonNextTaskStep.js

@@ -70,11 +70,46 @@ export const reasonNextTaskStep = {
         // ---------------------------
         // 5️⃣ Task-level reasoning (cross-file)
         // ---------------------------
+        // Instead of deriving remainingFiles from artifacts, use TaskStep.status
+        const pendingFiles = intendedFiles.filter(path => {
+            const step = taskSteps.find(s => s.filePath === path);
+            return !step || step.status !== "completed";
+        });
+        // ---------------------------
+        // 🛑 Deterministic Completion Gate
+        // ---------------------------
+        const isDeterministicallyComplete = redoFiles.length === 0 &&
+            pendingFiles.length === 0;
+        if (isDeterministicallyComplete) {
+            // ✅ mark task as completed
+            context.task.status = "completed";
+            context.task.currentStep = undefined;
+            context.analysis.iterationReasoning = {
+                ...iteration,
+                nextAction: "complete",
+                rationale: "All selected files have completed TaskSteps and passed validation.",
+                confidence: 1.0,
+                redoFiles: [],
+                nextTargets: { files: [] },
+                summary: "Task step decision: complete",
+            };
+            logInputOutput("reasonNextTaskStep", "output", {
+                intendedFiles,
+                pendingFiles,
+                redoFiles,
+                currentStep: context.task.currentStep,
+                iterationReasoning: context.analysis.iterationReasoning,
+            });
+            return; // 🔴 HARD EXIT — skip Step 6 and risk reasoning entirely
+        }
+        // ---------------------------
+        //  Task-level reasoning (cross-file)
+        // ---------------------------
         const remainingFiles = intendedFiles.filter(path => !transformedFiles.includes(path) &&
             !analyzedFiles.includes(path) &&
             !redoFiles.includes(path));
         // ---------------------------
-        // 6️⃣ Decide next step
+        //  Decide next step
         // ---------------------------
         let nextAction = "continue";
         let rationale = "";

package/dist/agents/selectRelevantSourcesStep.js

@@ -3,38 +3,29 @@ import fs from "fs";
 import { logInputOutput } from "../utils/promptLogHelper.js";
 /**
  * Purpose:
- * Selects relevant files based on evidence strength.
- * - Files with concrete evidence (shouldModify = true) are selected.
- * - Relevant files without evidence are treated as candidates.
- * - Rewrites focus rationale based on observed evidence.
+ * Mirrors previously selected files into workingFiles.
+ * - Does NOT promote files based on evidence.
+ * - Candidate files are left untouched.
+ * - Rationale is preserved from preFileSearchCheckStep.
  */
 export const selectRelevantSourcesStep = {
     name: "selectRelevantSources",
-    description: "Selects relevant files from analysis.fileAnalysis using evidence and modification readiness.",
+    description: "Mirrors focus.selectedFiles into workingFiles without reasoning over evidence.",
     groups: ["analysis"],
     run: async (input) => {
         const query = input.query ?? "";
         const context = input.context;
-        if (!context?.analysis) {
-            throw new Error("[selectRelevantSources] context.analysis is required.");
+        if (!context?.analysis?.focus) {
+            throw new Error("[selectRelevantSources] context.analysis.focus is required.");
         }
-        const fileAnalysis = context.analysis.fileAnalysis ?? {};
-        const selected = [];
-        const candidates = [];
-        const discarded = [];
-        const rationaleParts = [];
+        const selectedFiles = context.analysis.focus.selectedFiles ?? [];
+        const candidateFiles = context.analysis.focus.candidateFiles ?? [];
+        const discardedFiles = []; // no reasoning done here
         // ---------------------------
-        // 1️⃣ Classify files by relevance, evidence, and mode
+        // 1️⃣ Populate workingFiles from selectedFiles only
         // ---------------------------
-        const mode = context.executionControl?.mode ?? "transform";
-        for (const [path, analysis] of Object.entries(fileAnalysis)) {
-            const isRelevant = analysis.action?.isRelevant === true;
-            if (!isRelevant) {
-                discarded.push(path);
-                continue;
-            }
-            const hasEvidence = (analysis.evidence?.length ?? 0) > 0;
-            const canModify = analysis.action?.shouldModify === true;
+        const workingFiles = [];
+        for (const path of selectedFiles) {
             let code;
             try {
                 code = fs.readFileSync(path, "utf-8");
@@ -42,72 +33,40 @@ export const selectRelevantSourcesStep = {
             catch {
                 code = undefined;
             }
-            // 🔑 Mode-aware selection rule
-            const isSelected = mode === "transform"
-                ? hasEvidence && canModify
-                : true; // analyze: relevance is sufficient
-            if (isSelected) {
-                selected.push({
-                    path,
-                    code,
-                    selectionReason: mode === "transform"
-                        ? "Selected: concrete evidence found and modification permitted."
-                        : "Selected: relevant focus file for semantic analysis.",
-                });
-            }
-            else {
-                candidates.push({
-                    path,
-                    code,
-                    selectionReason: hasEvidence
-                        ? "Candidate: evidence found but modification not permitted."
-                        : "Candidate: relevant but no concrete evidence found.",
-                });
-            }
-        }
-        // ---------------------------
-        // 2️⃣ Rewrite selection rationale
-        // ---------------------------
-        if (selected.length > 0) {
-            rationaleParts.push(`Selected ${selected.length} file(s) with concrete evidence permitting modification.`);
-        }
-        if (candidates.length > 0) {
-            rationaleParts.push(`Identified ${candidates.length} additional relevant file(s) lacking sufficient evidence for modification.`);
-        }
-        if (selected.length === 0 && candidates.length > 0) {
-            rationaleParts.push("No files selected for modification; evidence insufficient or ambiguous.");
+            workingFiles.push({
+                path,
+                code,
+                selectionReason: "Selected by preFileSearchCheckStep",
+            });
         }
-        const rationale = rationaleParts.join(" ");
-        // 3️⃣ Persist workingFiles (selected only)
+        // Deduplicate if anything preexists
+        const seen = new Set();
         context.workingFiles = [
             ...(context.workingFiles ?? []),
-            ...selected,
+            ...workingFiles.filter(f => {
+                if (!f.path || seen.has(f.path))
+                    return false;
+                seen.add(f.path);
+                return true;
+            }),
         ];
-        const seen = new Set();
-        context.workingFiles = context.workingFiles.filter(f => {
-            if (!f.path)
-                return false;
-            if (seen.has(f.path))
-                return false;
-            seen.add(f.path);
-            return true;
-        });
         // ---------------------------
-        // 4️⃣ Update canonical focus
+        // 2️⃣ Preserve focus but update rationale
         // ---------------------------
         context.analysis.focus = {
-            selectedFiles: selected.map((f) => f.path),
-            candidateFiles: candidates.map((f) => f.path),
-            discardedFiles: discarded,
-            rationale,
+            selectedFiles,
+            candidateFiles,
+            discardedFiles,
+            rationale: (context.analysis.focus.rationale ?? "") +
+                "\n[selectRelevantSources] Working files mirrored mechanically from previous selections.",
         };
         const output = {
             query,
             data: {
-                workingFiles: context.workingFiles.map((f) => ({ path: f.path })),
-                selectedFiles: context.analysis.focus.selectedFiles,
-                candidateFiles: context.analysis.focus.candidateFiles,
-                rationale,
+                workingFiles: context.workingFiles.map(f => ({ path: f.path })),
+                selectedFiles,
+                candidateFiles,
+                rationale: context.analysis.focus.rationale,
             },
         };
         logInputOutput("selectRelevantSources", "output", output.data);

package/dist/agents/writeFileStep.js

@@ -75,7 +75,7 @@ export const writeFileStep = {
                 }
                 await fs.mkdir(path.dirname(filePath), { recursive: true });
                 await fs.writeFile(filePath, artifact.content, "utf-8");
-                console.log(chalk.green(`${MODULE_STEP_INDENTATION} Wrote file: ${filePath}`));
+                console.log(chalk.blue(`${MODULE_STEP_INDENTATION} Wrote file: ${filePath}`));
                 writtenFiles.push(filePath);
                 artifact.written = true;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scai",
-  "version": "0.1.166",
+  "version": "0.1.167",
   "type": "module",
   "bin": {
     "scai": "./dist/index.js"