scai 0.1.177 → 0.1.178

package/dist/agents/MainAgent.js

@@ -61,6 +61,13 @@ export class MainAgent {
      */
     constructor(context, ui) {
         this.runCount = 0;
+        this.verboseAgentLogs = process.env.SCAI_VERBOSE_AGENT_LOGS === "1";
+        this.hasPrintedHeader = false;
+        this.activity = {
+            searches: [],
+            lists: [],
+            reads: [],
+        };
         this.context = context;
         this.query = context.initContext?.userQuery ?? "";
         this.ui = ui;
@@ -69,16 +76,23 @@ export class MainAgent {
     async run() {
         try {
             this.runCount = 0;
+            this.printHeader("Boot & Scope");
             await this.runBoot();
             await this.runScope();
+            this.printHeader("Search");
             await this.runSearch();
+            this.printHeader("Verify");
             await this.runVerify();
+            this.printHeader("Research");
             await this.runResearch();
             const canProceedToExecution = this.isResearchGateSatisfied();
             if (canProceedToExecution) {
+                this.printHeader("Plan");
                 await this.runPlan();
+                this.printHeader("Execute");
                 await this.runWorkLoop();
             }
+            this.printHeader("Finalize");
             await this.runFinalize();
         }
         finally {
@@ -101,7 +115,7 @@ export class MainAgent {
             taskSteps: [],
         });
         this.context.task.id = this.taskId;
-        this.logLine("TASK", "Boot complete", undefined, `taskId=${this.taskId}`, { highlight: true });
+        this.userOutput(`Boot complete (taskId=${this.taskId}).`);
     }
     /* ───────────── scope ───────────── */
     async runScope() {
@@ -109,10 +123,11 @@ export class MainAgent {
         await resolveExecutionModeStep.run(this.context);
         await routingDecisionStep.run(this.context);
         const routing = this.context.analysis?.routingDecision;
+        const scope = this.context.analysis?.scopeType ?? "unknown";
         if (routing) {
-            this.logLine("TASK", "Routing decision", undefined, `${routing.decision} | search=${routing.allowSearch} | research=${routing.allowResearch} | transform=${routing.allowTransform} | scopeLocked=${routing.scopeLocked}`);
+            this.userOutput(`Routing: ${routing.decision} (scope=${scope}, search=${routing.allowSearch}, research=${routing.allowResearch}, transform=${routing.allowTransform}, scopeLocked=${routing.scopeLocked}).`);
         }
-        this.logLine("TASK", "Scope classification complete");
+        this.userOutput("Scope classification complete.");
     }
     /* ───────────── search ───────────── */
     /**
@@ -121,6 +136,7 @@ export class MainAgent {
      */
     async runSearch() {
         const { rawUserQuery, retrievalQuery } = this.resolveInitialRetrievalQueries();
+        this.userOutput("I’ll start by identifying likely files from semantic search before analyzing content.");
         const t = this.startTimer();
         try {
             const results = await this.fetchInitialRetrievalResults(retrievalQuery);
@@ -129,7 +145,12 @@ export class MainAgent {
             const mergedRelatedCount = this.mergeSeededInitialContext(rawUserQuery, seededContext);
             const prefilter = this.applyDeterministicPreGroundingPrefilter(retrievalQuery);
             const repoDefaults = this.injectWellKnownRepoFiles(prefilter.after);
+            this.recordSearch(retrievalQuery, path.basename(process.cwd()));
+            this.recordListEntries(Array.from(new Set(results.map(result => path.dirname(this.formatPathForLog(result.path)))))
+                .slice(0, 2)
+                .map(dir => dir === "." ? process.cwd() : dir));
             this.logLine("ANALYSIS", "initialRetrieval", t(), `${results.length} result(s), ${mergedRelatedCount} candidate file(s), prefilter ${prefilter.before} -> ${prefilter.after}, defaults +${repoDefaults.added} (${repoDefaults.reason})`);
+            this.flushActivity();
         }
         catch (err) {
             this.logLine("ANALYSIS", "initialRetrieval", t(), `failed: ${String(err)}`);
@@ -151,24 +172,52 @@ export class MainAgent {
             this.pruneMissingVerifyPaths();
             this.logLine("ANALYSIS", "groundingWave", undefined, `wave ${groundingWave}/${maxGroundingWaves}`);
             const beforeFocus = this.captureVerifyFocusSnapshot();
+            const beforeWorking = new Set((this.context.workingFiles ?? []).map(file => file.path));
+            const beforeSelected = new Set(this.context.analysis?.focus?.selectedFiles ?? []);
+            const beforeCandidate = new Set(this.context.analysis?.focus?.candidateFiles ?? []);
+            const structuralBefore = new Set(Object.entries(this.context.analysis?.fileAnalysis ?? {})
+                .filter(([_, analysis]) => !!analysis?.structural)
+                .map(([filePath]) => filePath));
             // ---------------- EVIDENCE PIPELINE ----------------
             // -------- STRUCTURAL PRELOAD --------
             const t0 = this.startTimer();
             await structuralPreloadStep.run({ query: this.query, context: this.context });
+            const structuralAfter = Object.entries(this.context.analysis?.fileAnalysis ?? {})
+                .filter(([_, analysis]) => !!analysis?.structural)
+                .map(([filePath]) => filePath);
+            const newStructural = structuralAfter.filter(filePath => !structuralBefore.has(filePath));
             this.logLine("ANALYSIS", "structuralPreload", t0());
             const t1 = this.startTimer();
             await evidenceVerifierStep.run({ query: this.query, context: this.context });
+            const verifyEntries = Object.entries(this.context.analysis?.verify?.byFile ?? {});
             this.logLine("ANALYSIS", "collectAnalysisEvidence", t1());
             const t2 = this.startTimer();
             await fileCheckStep(this.context);
+            const selectedAfterCheck = this.context.analysis?.focus?.selectedFiles ?? [];
+            const candidateAfterCheck = this.context.analysis?.focus?.candidateFiles ?? [];
+            const addedSelected = selectedAfterCheck.filter(filePath => !beforeSelected.has(filePath));
+            const addedCandidate = candidateAfterCheck.filter(filePath => !beforeCandidate.has(filePath));
             this.logLine("ANALYSIS", "fileCheckStep", t2());
             const t3 = this.startTimer();
             await selectRelevantSourcesStep.run({ query: this.query, context: this.context });
+            const workingAfter = this.context.workingFiles ?? [];
+            const newWorking = workingAfter
+                .map(file => file.path)
+                .filter(filePath => !beforeWorking.has(filePath));
             this.logLine("ANALYSIS", "selectRelevantSources", t3());
             // ---------------- READINESS GATE ----------------
             const t4 = this.startTimer();
             await readinessGateStep.run(this.context);
-            this.logLine("ANALYSIS", "readinessGate", t4());
+            const readiness = this.context.analysis?.readiness;
+            const selectedCount = this.context.analysis?.focus?.selectedFiles?.length ?? 0;
+            this.logLine("ANALYSIS", "readinessGate", t4(), `decision=${readiness?.decision ?? "unknown"}, confidence=${(readiness?.confidence ?? 0).toFixed(2)}, selected=${selectedCount}`);
+            this.userOutput("I mapped the verify wave. Next I’ll analyze selected files and refine scope if needed.");
+            this.recordReadEntries(newStructural);
+            this.recordReadEntries(verifyEntries.map(([filePath]) => filePath));
+            this.recordReadEntries(addedSelected);
+            this.recordListEntries(addedCandidate);
+            this.recordReadEntries(newWorking);
+            this.flushActivity();
             ready = this.context.analysis?.readiness?.decision === "ready";
             if (ready) {
                 break;
@@ -389,6 +438,8 @@ export class MainAgent {
             seeded,
         });
         this.logLine("PLAN", "taskStepSeed", undefined, `${seededCount} execution step(s) planned`);
+        this.recordReadEntries(seeded.map(step => step.filePath));
+        this.flushActivity();
     }
     /**
      * Sets minimum verify confidence before a file can be plan-seeded from verify-only signal.
@@ -973,7 +1024,8 @@ export class MainAgent {
             return { query: input.query, content: input.content, data: { skipped: true } };
         }
         try {
-            this.ui.update(`Running step: ${step.action}`);
+            const stepTarget = step.targetFile ? this.formatPathForLog(step.targetFile) : undefined;
+            this.ui.update(stepTarget ? `Running ${step.action} on ${stepTarget}` : `Running ${step.action}`);
             const output = await mod.run({ query: step.description ?? input.query, content: input.data ?? input.content, context: this.context });
             const errors = Array.isArray(output.data?.errors)
                 ? output.data.errors.filter((e) => typeof e === "string" && e.trim().length > 0)
@@ -1182,22 +1234,31 @@ export class MainAgent {
         let removedSelected = 0;
         let removedCandidate = 0;
         if (init?.relatedFiles?.length) {
-            const before = init.relatedFiles.length;
-            init.relatedFiles = init.relatedFiles.filter(existsOrResearch);
-            removedRelated = before - init.relatedFiles.length;
+            const existing = init.relatedFiles;
+            init.relatedFiles = existing.filter(filePath => {
+                const keep = existsOrResearch(filePath);
+                return keep;
+            });
+            removedRelated = existing.length - init.relatedFiles.length;
             if (removedRelated > 0 && init.relatedFileScores) {
                 init.relatedFileScores = Object.fromEntries(Object.entries(init.relatedFileScores).filter(([filePath]) => init.relatedFiles?.includes(filePath)));
             }
         }
         if (focus?.selectedFiles?.length) {
-            const before = focus.selectedFiles.length;
-            focus.selectedFiles = focus.selectedFiles.filter(existsOrResearch);
-            removedSelected = before - focus.selectedFiles.length;
+            const existing = focus.selectedFiles;
+            focus.selectedFiles = existing.filter(filePath => {
+                const keep = existsOrResearch(filePath);
+                return keep;
+            });
+            removedSelected = existing.length - focus.selectedFiles.length;
         }
         if (focus?.candidateFiles?.length) {
-            const before = focus.candidateFiles.length;
-            focus.candidateFiles = focus.candidateFiles.filter(existsOrResearch);
-            removedCandidate = before - focus.candidateFiles.length;
+            const existing = focus.candidateFiles;
+            focus.candidateFiles = existing.filter(filePath => {
+                const keep = existsOrResearch(filePath);
+                return keep;
+            });
+            removedCandidate = existing.length - focus.candidateFiles.length;
         }
         if (removedRelated + removedSelected + removedCandidate > 0) {
             this.logLine("ANALYSIS", "verifyPruneMissing", undefined, `removed related=${removedRelated}, selected=${removedSelected}, candidate=${removedCandidate}`);
@@ -1326,7 +1387,7 @@ export class MainAgent {
         this.logLine("TASK", "Route updated from step reasoning", undefined, "expand-scope requested; re-enabled search expansion");
     }
     startTaskStep(taskStep, stepCount) {
-        this.ensureWorkingFilesLoaded([taskStep.filePath], "Current task step");
+        const hydration = this.ensureWorkingFilesLoaded([taskStep.filePath], "Current task step");
         const db = getDbForRepo();
         this.ensureTaskIdentityForPersistence(db);
         this.context.task.currentStep = taskStep;
@@ -1335,7 +1396,10 @@ export class MainAgent {
         taskStep.status = "pending";
         persistTaskStepInsert(taskStep, db);
         const displayPath = this.formatTaskStepDisplayPath(taskStep.filePath);
-        this.logLine("NEW STEP", `Processing taskStep ${stepCount}`, undefined, displayPath, { highlight: true });
+        this.printHeader(`Step ${stepCount}`);
+        this.userOutput(`Now processing ${this.formatPathForLog(displayPath)}.`);
+        this.recordReadEntries(hydration.loadedFromDisk);
+        this.flushActivity();
         taskStep.startTime = Date.now();
         persistTaskStepStart(taskStep, db);
     }
@@ -1386,6 +1450,31 @@ export class MainAgent {
         this.ui.pause(() => { process.stdout.write('\r\x1b[K'); fn(); });
     }
     logLine(phase, step, ms, desc, options) {
+        if (!this.verboseAgentLogs) {
+            // Keep only key transitions when verbose logging is disabled.
+            if (phase === "STEP-DONE" && desc) {
+                this.userOutput(`Completed ${this.formatPathForLog(desc)}.`);
+            }
+            else if (phase === "TASK" && step.includes("Execution paused")) {
+                this.userOutput("Execution paused; waiting for user clarification.");
+            }
+            else if (phase === "TASK" && step.includes("All selected files processed")) {
+                this.userOutput("All selected files processed.");
+            }
+            else if (phase === "TASK" && step.includes("No eligible taskStep found")) {
+                this.userOutput("No eligible task step found.");
+            }
+            else if (phase === "TASK" && step.includes("Finalize complete")) {
+                this.userOutput("Finalize complete.");
+            }
+            else if (phase === "RESEARCH" && step === "taskStepSeed" && desc?.includes("skipped")) {
+                this.userOutput("Research skipped for this route.");
+            }
+            else if (phase === "RESEARCH" && step === "taskStepSeed" && desc) {
+                this.userOutput(desc);
+            }
+            return;
+        }
         this.withSpinnerPaused(() => {
             const suffix = desc ? ` — ${desc}` : "";
             const timing = typeof ms === "number" ? ` (${ms}ms)` : "";
@@ -1400,12 +1489,21 @@ export class MainAgent {
             // Print a blank line **before** NEW STEP only
             if (phase === "NEW STEP")
                 console.log();
+            process.stdout.write("\r\x1b[K");
             console.log(line);
         });
     }
     userOutput(message) {
         this.withSpinnerPaused(() => {
-            console.log(`[USER OUTPUT] ${message}`);
+            console.log(message);
+        });
+    }
+    printHeader(title) {
+        this.withSpinnerPaused(() => {
+            if (this.hasPrintedHeader)
+                console.log("");
+            console.log(chalk.bold(`== ${title} ==`));
+            this.hasPrintedHeader = true;
         });
     }
     /**
@@ -1416,18 +1514,25 @@ export class MainAgent {
         var _a;
         (_a = this.context).workingFiles || (_a.workingFiles = []);
         const indexByPath = new Map(this.context.workingFiles.map(file => [file.path, file]));
+        const loadedFromDisk = [];
+        const alreadyLoaded = [];
+        const skippedMissing = [];
         for (const filePath of paths) {
             if (!filePath || filePath.startsWith("__research__/"))
                 continue;
-            if (!fs.existsSync(filePath))
+            if (!fs.existsSync(filePath)) {
+                skippedMissing.push(filePath);
                 continue;
+            }
             const existing = indexByPath.get(filePath);
             if (existing && typeof existing.code === "string" && existing.code.length > 0) {
+                alreadyLoaded.push(filePath);
                 continue;
             }
             let code;
             try {
                 code = fs.readFileSync(filePath, "utf-8");
+                loadedFromDisk.push(filePath);
             }
             catch {
                 code = undefined;
@@ -1442,6 +1547,77 @@ export class MainAgent {
                 indexByPath.set(filePath, capsule);
             }
         }
+        return { loadedFromDisk, alreadyLoaded, skippedMissing };
+    }
+    formatPathForLog(filePath) {
+        if (!filePath)
+            return "(none)";
+        if (filePath.startsWith("__research__/")) {
+            return filePath.replace("__research__/", "research/");
+        }
+        const normalized = path.normalize(filePath);
+        const relative = path.relative(process.cwd(), normalized);
+        if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) {
+            return relative || path.basename(normalized);
+        }
+        return normalized;
+    }
+    describeFileList(paths, maxItems = 4) {
+        const unique = Array.from(new Set(paths.filter(Boolean)));
+        if (unique.length === 0)
+            return "none";
+        const shown = unique.slice(0, maxItems).map(filePath => this.formatPathForLog(filePath));
+        const extra = unique.length - shown.length;
+        if (extra > 0)
+            shown.push(`+${extra} more`);
+        return shown.join(", ");
+    }
+    recordSearch(query, scope) {
+        const normalizedScope = scope || "repo";
+        this.activity.searches.push(`Searched for ${query} in ${normalizedScope}`);
+    }
+    recordListEntries(entries) {
+        for (const entry of entries) {
+            const normalized = entry.replace(/\\/g, "/");
+            const asDir = normalized.endsWith("/") || path.extname(normalized) === ""
+                ? normalized
+                : path.dirname(normalized);
+            const display = asDir === "." ? "repo root" : this.formatPathForLog(asDir);
+            this.activity.lists.push(`Listed files in ${display}`);
+        }
+    }
+    recordReadEntries(paths) {
+        for (const filePath of paths) {
+            if (!filePath || filePath.startsWith("__research__/"))
+                continue;
+            this.activity.reads.push(`Read ${this.formatPathForLog(filePath)}`);
+        }
+    }
+    flushActivity() {
+        const searches = Array.from(new Set(this.activity.searches));
+        const lists = Array.from(new Set(this.activity.lists));
+        const reads = Array.from(new Set(this.activity.reads));
+        if (searches.length === 0 && lists.length === 0 && reads.length === 0) {
+            return;
+        }
+        const parts = [];
+        if (searches.length > 0) {
+            parts.push(`${searches.length} search${searches.length === 1 ? "" : "es"}`);
+        }
+        if (lists.length > 0) {
+            parts.push(`${lists.length} director${lists.length === 1 ? "y" : "ies"}`);
+        }
+        if (reads.length > 0) {
+            parts.push(`${reads.length} file${reads.length === 1 ? "" : "s"}`);
+        }
+        this.userOutput(`Explored ${parts.join(", ")}`);
+        for (const line of searches.slice(0, 2))
+            this.userOutput(line);
+        for (const line of lists.slice(0, 3))
+            this.userOutput(line);
+        for (const line of reads.slice(0, 6))
+            this.userOutput(line);
+        this.activity = { searches: [], lists: [], reads: [] };
     }
     /**
      * Ensures the current task id exists in the active DB before step persistence.

package/dist/agents/analysisPlanGenStep.js

@@ -103,10 +103,14 @@ Return a valid JSON object in this format:
             });
             context.analysis.planSuggestion = { plan: { steps: finalSteps } };
             logInputOutput("analysisPlanGen", "output", finalSteps);
-            console.log("🧠 [analysisPlanGenStep] EXIT (success)");
+            if (process.env.SCAI_VERBOSE_AGENT_LOGS === "1") {
+                console.log("🧠 [analysisPlanGenStep] EXIT (success)");
+            }
         }
         catch (err) {
-            console.warn("⚠️ [analysisPlanGenStep] FAILED to generate analysis plan:", err);
+            if (process.env.SCAI_VERBOSE_AGENT_LOGS === "1") {
+                console.warn("⚠️ [analysisPlanGenStep] FAILED to generate analysis plan:", err);
+            }
             context.analysis.planSuggestion = { plan: { steps: [] } };
             logInputOutput("analysisPlanGen", "output", { steps: [] });
         }

package/dist/testing/testCommands.js

@@ -176,8 +176,8 @@ function pickRandom(items) {
     return items[Math.floor(Math.random() * items.length)];
 }
 function logHighContrastQuery(prefix, query) {
-    // Bright white + bold for dark terminal readability.
-    console.log(chalk.bold.white(`${prefix} ${query}`));
+    // Neutral bold so it is readable on both light and dark terminal themes.
+    console.log(chalk.bold(`${prefix} ${query}`));
 }
 function countOccurrences(haystack, needle) {
     if (!needle)

package/package.json

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