scai 0.1.173 → 0.1.175

package/dist/agents/MainAgent.js

@@ -198,6 +198,7 @@ export class MainAgent {
         if (!this.isWorkLoopReady())
             return;
         this.ensureTaskForWorkLoop();
+        this.recalibrateRoutingAfterVerify();
         // Research gate is evaluated after runResearch() in run().
     }
     /* ───────────── research ───────────── */
@@ -207,8 +208,10 @@ export class MainAgent {
      */
     async runResearch() {
         var _a, _b;
-        if (!this.canExecuteRoute("research"))
+        if (!this.canExecuteRoute("research")) {
+            this.logLine("RESEARCH", "taskStepSeed", undefined, "skipped (route disallows research)");
             return;
+        }
         if (!this.context.task)
             return;
         (_a = this.context.task).taskSteps || (_a.taskSteps = []);
@@ -305,9 +308,20 @@ export class MainAgent {
             .map(step => step.filePath));
         const selectedFiles = this.context.analysis.focus?.selectedFiles ?? [];
         const touchedFromResearch = this.context.analysis.researchArtifacts?.touchedFiles ?? [];
-        const verifyRelevantFiles = Object.entries(this.context.analysis.verify?.byFile ?? {})
-            .filter(([_, verify]) => verify?.isRelevant)
+        const route = this.context.analysis.routingDecision;
+        const useFocusedSelectedPlanOnly = this.context.analysis.readiness?.decision === "ready" &&
+            (route?.decision === "has-info") &&
+            (route?.scopeLocked ?? false) &&
+            (route?.allowSearch === false) &&
+            selectedFiles.length > 0;
+        const verifyMinConfidence = this.getVerifyConfidenceThresholdForPlan();
+        const verifyEntries = Object.entries(this.context.analysis.verify?.byFile ?? {});
+        const verifyRelevantFiles = verifyEntries
+            .filter(([_, verify]) => verify?.isRelevant &&
+            (verify.fileConfidence ?? 0) >= verifyMinConfidence)
             .map(([filePath]) => filePath);
+        const verifySkippedLowConfidenceCount = verifyEntries.filter(([_, verify]) => !!verify?.isRelevant &&
+            (verify.fileConfidence ?? 0) < verifyMinConfidence).length;
         const rankPath = (filePath) => {
             const inSelected = selectedFiles.includes(filePath);
             const inResearchTouched = touchedFromResearch.includes(filePath);
@@ -322,14 +336,18 @@ export class MainAgent {
                 return 3;
             return 4;
         };
-        const plannedPaths = Array.from(new Set([
-            ...selectedFiles,
-            ...touchedFromResearch,
-            ...verifyRelevantFiles,
-        ]))
+        const plannedPathsSource = useFocusedSelectedPlanOnly
+            ? Array.from(new Set(selectedFiles))
+            : Array.from(new Set([
+                ...selectedFiles,
+                ...touchedFromResearch,
+                ...verifyRelevantFiles,
+            ]));
+        const plannedPaths = plannedPathsSource
             .filter(filePath => !!filePath && !filePath.startsWith("__research__/") && fs.existsSync(filePath))
             .sort((a, b) => rankPath(a) - rankPath(b))
             .slice(0, 16);
+        this.ensureWorkingFilesLoaded(plannedPaths, "Planned for execution");
         let seededCount = 0;
         const seeded = [];
         for (const filePath of plannedPaths) {
@@ -363,10 +381,71 @@ export class MainAgent {
             selectedFileCount: selectedFiles.length,
             researchTouchedCount: touchedFromResearch.length,
             verifyRelevantCount: verifyRelevantFiles.length,
+            focusedSelectedOnly: useFocusedSelectedPlanOnly,
+            verifyMinConfidence,
+            verifySkippedLowConfidenceCount,
             seeded,
         });
         this.logLine("PLAN", "taskStepSeed", undefined, `${seededCount} execution step(s) planned`);
     }
+    /**
+     * Sets minimum verify confidence before a file can be plan-seeded from verify-only signal.
+     * Example: single-file lanes require higher confidence than repo-wide lanes.
+     */
+    getVerifyConfidenceThresholdForPlan() {
+        const scope = this.context.analysis?.scopeType ?? "repo-wide";
+        if (scope === "single-file")
+            return 0.45;
+        if (scope === "multi-file")
+            return 0.35;
+        return 0.3;
+    }
+    /**
+     * Re-routes after verify when evidence converges on selected files with high confidence.
+     * Example: selected files strongly verified => disable expansion/research and lock focused execution.
+     */
+    recalibrateRoutingAfterVerify() {
+        var _a;
+        (_a = this.context).analysis || (_a.analysis = {});
+        const routing = this.context.analysis.routingDecision;
+        if (!routing)
+            return;
+        const intentCategory = (this.context.analysis.intent?.intentCategory ?? "").toLowerCase();
+        const isEditLikeIntent = intentCategory === "codingtask" ||
+            intentCategory === "refactortask" ||
+            intentCategory === "request" ||
+            intentCategory === "docsandcomments";
+        const canWrite = this.context.executionControl?.constraints?.allowFileWrites ?? false;
+        if (!isEditLikeIntent || !canWrite) {
+            return;
+        }
+        const selectedFiles = this.context.analysis.focus?.selectedFiles ?? [];
+        if (selectedFiles.length === 0)
+            return;
+        const readinessConfidence = this.context.analysis.readiness?.confidence ?? 0;
+        const intentConfidence = this.context.analysis.intent?.confidence ?? 0;
+        const minFileConfidence = 0.28;
+        const strongSelected = selectedFiles.filter(filePath => {
+            const verify = this.context.analysis?.verify?.byFile?.[filePath];
+            return verify?.isRelevant === true && (verify.fileConfidence ?? 0) >= minFileConfidence;
+        });
+        const convergedSingle = selectedFiles.length === 1 &&
+            strongSelected.length === 1 &&
+            readinessConfidence >= 0.9 &&
+            intentConfidence >= 0.8;
+        const convergedMulti = selectedFiles.length >= 2 &&
+            strongSelected.length >= 2 &&
+            readinessConfidence >= 0.9 &&
+            intentConfidence >= 0.75;
+        if (!convergedSingle && !convergedMulti)
+            return;
+        routing.decision = "has-info";
+        routing.allowSearch = false;
+        routing.allowResearch = false;
+        routing.scopeLocked = true;
+        routing.rationale = `${routing.rationale}; postVerify=focused-selection(${strongSelected.length})`;
+        this.logLine("TASK", "Routing recalibrated", undefined, `focused=${selectedFiles.length} selected, strong=${strongSelected.length}`);
+    }
     /* ───────────── work loop ───────────── */
     async runWorkLoop() {
         if (this.context.task.status !== "active")
@@ -1224,6 +1303,7 @@ export class MainAgent {
         this.persistTaskDataForRun();
     }
     startTaskStep(taskStep, stepCount) {
+        this.ensureWorkingFilesLoaded([taskStep.filePath], "Current task step");
         this.context.task.currentStep = taskStep;
         taskStep.taskId = this.taskId;
         taskStep.stepIndex = stepCount;
@@ -1364,6 +1444,41 @@ export class MainAgent {
             console.log(`[USER OUTPUT] ${message}`);
         });
     }
+    /**
+     * Ensures workingFiles has file capsules with code for the given paths.
+     * Example: planned verify-relevant files are hydrated before transform starts.
+     */
+    ensureWorkingFilesLoaded(paths, reason) {
+        var _a;
+        (_a = this.context).workingFiles || (_a.workingFiles = []);
+        const indexByPath = new Map(this.context.workingFiles.map(file => [file.path, file]));
+        for (const filePath of paths) {
+            if (!filePath || filePath.startsWith("__research__/"))
+                continue;
+            if (!fs.existsSync(filePath))
+                continue;
+            const existing = indexByPath.get(filePath);
+            if (existing && typeof existing.code === "string" && existing.code.length > 0) {
+                continue;
+            }
+            let code;
+            try {
+                code = fs.readFileSync(filePath, "utf-8");
+            }
+            catch {
+                code = undefined;
+            }
+            if (existing) {
+                existing.code = code;
+                existing.selectionReason || (existing.selectionReason = reason);
+            }
+            else {
+                const capsule = { path: filePath, code, selectionReason: reason };
+                this.context.workingFiles.push(capsule);
+                indexByPath.set(filePath, capsule);
+            }
+        }
+    }
 }
 function scoreCandidateFiles(filePaths, relatedFileScores, retrievalQuery) {
     const explicitRefs = extractFileReferences(retrievalQuery, { lowercase: true });

package/dist/agents/reasonNextTaskStep.js

@@ -39,9 +39,12 @@ export const reasonNextTaskStep = {
             ...(context.analysis.focus?.selectedFiles ?? []),
             ...(context.workingFiles?.map(f => f.path).filter(Boolean) ?? []),
         ]));
-        const intendedFiles = plannedExecutionFiles.length > 0
-            ? plannedExecutionFiles
-            : fallbackIntendedFiles;
+        // Use union (not fallback switch) so docs-only or planning-skipped lanes
+        // still process all selected files instead of only ad-hoc seeded taskSteps.
+        const intendedFiles = Array.from(new Set([
+            ...plannedExecutionFiles,
+            ...fallbackIntendedFiles,
+        ]));
         // ---------------------------
         // 2️⃣ Transformed and analyzed files
         // ---------------------------

package/dist/agents/resolveExecutionModeStep.js

@@ -48,6 +48,19 @@ export const resolveExecutionModeStep = {
                     docsOnly: true
                 };
                 break;
+            // ───── Generic requests: promote to transform when edit intent is explicit ─────
+            case "request":
+                if (hasExplicitWriteIntent(normalizedQuery)) {
+                    mode = "transform";
+                    rationale = "Request contains explicit edit intent.";
+                    constraints = {
+                        allowAnalysis: true,
+                        allowPlanning: true,
+                        allowFileWrites: true,
+                        docsOnly: false
+                    };
+                }
+                break;
             // ───── Everything else is analysis ─────
             case "debugging":
             case "planning":
@@ -88,5 +101,5 @@ function isQuestionLikeQuery(query) {
 }
 function hasExplicitWriteIntent(query) {
     const q = query.toLowerCase();
-    return /\b(add|update|edit|modify|refactor|rewrite|implement|fix|create|remove|delete|replace|rename|write|patch|change)\b/.test(q);
+    return /\b(add|update|edit|modify|refactor|rewrite|implement|fix|create|remove|delete|replace|rename|write|patch|change|increment|bump|set)\b/.test(q);
 }

package/dist/agents/routingDecisionStep.js

@@ -23,6 +23,9 @@ export const routingDecisionStep = {
         const hasExplicitTargets = (context.analysis.intent?.targetFiles?.length ?? 0) > 0;
         const ambiguousIntent = intentConfidence < 0.45;
         const isRefactorLike = intentCategory === "refactorTask" || intentCategory === "codingTask";
+        const isAnalysisLike = intentCategory === "question" ||
+            intentCategory === "analysis" ||
+            intentCategory === "explanation";
         let decision = "has-info";
         let allowSearch = true;
         let scopeLocked = false;
@@ -50,8 +53,8 @@ export const routingDecisionStep = {
                     ? "single-file-focused"
                     : "bounded-analysis";
         const allowResearch = scope !== "none" &&
-            (isRefactorLike ||
-                (isResearchScope && (decision === "needs-info" || complexitySignals >= 2)));
+            ((isAnalysisLike && isResearchScope && (decision === "needs-info" || complexitySignals >= 2)) ||
+                (isRefactorLike && complexitySignals >= 1));
         const confidence = Math.max(0, Math.min(1, 0.55 + intentConfidence * 0.35 - (ambiguousIntent ? 0.2 : 0)));
         const routingDecision = {
             decision,

package/dist/testing/testCommands.js

@@ -3,7 +3,7 @@ import chalk from "chalk";
 import { RUN_LOG_PATH } from "../constants.js";
 // ---------------- Test Queries ----------------
 export const testQueries = [
-    "Add concise comments to semanticAnalysisModule.ts and MainAgent.ts describing phase boundaries.",
+    "Add concise comments to semanticAnalysisModule.ts and finalAnswerModule.ts describing phase boundaries.",
     "Refactor MainAgent runVerify flow to reduce nesting while preserving behavior.",
     "Explain how resolveExecutionModeStep, routingDecisionStep, and canExecuteRoute interact.",
     "Add stronger validation and safer fallback behavior in contextReviewStep.ts.",

package/package.json

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