scai 0.1.149 → 0.1.152

package/dist/agents/MainAgent.js

@@ -12,8 +12,8 @@ import { writeFileStep } from "./writeFileStep.js";
 import { resolveExecutionModeStep } from "./resolveExecutionModeStep.js";
 import { fileCheckStep } from "./fileCheckStep.js";
 import { analysisPlanGenStep } from "./analysisPlanGenStep.js";
-import chalk from "chalk";
 import { readinessGateStep } from "./readinessGateStep.js";
+import { collectAnalysisEvidenceStep } from "./collectAnalysisEvidenceStep.js";
 /* ───────────────────────── registry ───────────────────────── */
 const MODULE_REGISTRY = Object.fromEntries(Object.entries(builtInModules).map(([name, mod]) => [name, mod]));
 function resolveModuleForAction(action) {
@@ -114,122 +114,112 @@ export class MainAgent {
             const db = getDbForRepo();
             this.taskId = bootTaskForRepo(this.context, db, this.logLine.bind(this));
         }
-        // -------------------- INITIAL PRE-FILE CHECK --------------------
-        let t = this.startTimer();
-        await fileCheckStep(this.context);
-        this.logLine("PRECHECK", "preFileSearch", t());
-        // -------------------- EXPLAIN MODE HANDLING --------------------
-        if (this.canExecutePhase("explain")) {
-            const explainMod = resolveModuleForAction("explain");
-            if (!explainMod)
-                throw new Error("Explain module not found");
-            const explainOutput = await explainMod.run({
-                query: this.query,
-                context: this.context
-            });
-            this.logLine("MODE", "explain", undefined, "returning AI-generated explanation after preFileSearchCheck");
-            return explainOutput;
-        }
-        // -------------------- summarize folder capsules --------------------
-        logFolderCapsulesSummary(this.context);
-        this.logLine("BOOT", "folderCapsulesSummary", t(), `📂 ${this.context.initContext?.folderCapsules?.length} folders summarized`);
+        /* ================= PRECHECK (INITIAL) ================= */
         {
-            let t = this.startTimer();
-            await readinessGateStep.run(this.context);
-            this.logLine("HASINFO", "routing", t());
+            const t = this.startTimer();
+            await fileCheckStep(this.context);
+            this.logLine("PRECHECK", "preFileSearch", t());
         }
-        /* ================= INFORMATION ACQUISITION PHASE ================= */
+        /* ================= INFORMATION ACQUISITION ================= */
         if (this.canExecutePhase("planning")) {
-            t = this.startTimer();
-            await infoPlanGen.run(this.context);
-            this.logLine("PLAN", "infoPlanGen", t());
-            const infoPlan = this.context.analysis?.planSuggestion?.plan ?? { steps: [] };
+            {
+                const t = this.startTimer();
+                await infoPlanGen.run(this.context);
+                this.logLine("PLAN", "infoPlanGen", t());
+            }
             let stepIO = { query: this.query };
+            const infoPlan = this.context.analysis?.planSuggestion?.plan ?? { steps: [] };
             for (const step of infoPlan.steps.filter(s => s.groups?.includes("info"))) {
                 stepIO = await this.executeStep(step, stepIO);
             }
-            const newFilesFound = infoPlan.steps.length > 0;
-            if (newFilesFound) {
-                t = this.startTimer();
+            if (infoPlan.steps.length > 0) {
+                const t = this.startTimer();
                 await fileCheckStep(this.context);
                 this.logLine("PRECHECK", "postFileSearch", t());
             }
-            else {
-                this.logLine("PRECHECK", "postFileSearch", undefined, chalk.gray("skipped (no new info search steps)"));
-            }
         }
-        /* ================= ANALYSIS PHASE ================= */
+        /* ================= GROUNDING & READINESS GATE ================= */
         {
-            t = this.startTimer();
+            const t1 = this.startTimer();
+            await collectAnalysisEvidenceStep.run({ query: this.query, context: this.context });
+            this.logLine("ANALYSIS", "collectAnalysisEvidence", t1());
+            const t2 = this.startTimer();
             await selectRelevantSourcesStep.run({ query: this.query, context: this.context });
-            this.logLine("ANALYSIS", "selectRelevantSources", t());
+            this.logLine("ANALYSIS", "selectRelevantSources", t2());
+            const t3 = this.startTimer();
+            await readinessGateStep.run(this.context);
+            this.logLine("HASINFO", "readinessGate", t3());
+        }
+        /* ================= EXPLAIN (EVIDENCE EXIT) ================= */
+        if (this.canExecutePhase("explain") &&
+            this.context.analysis?.routingDecision?.decision === "has-info") {
+            const explainMod = resolveModuleForAction("explain");
+            if (!explainMod)
+                throw new Error("Explain module not found");
+            return await explainMod.run({
+                query: this.query,
+                context: this.context
+            });
         }
+        /* ================= ANALYSIS (DEEP) ================= */
         if (this.canExecutePhase("analysis")) {
-            t = this.startTimer();
-            await analysisPlanGenStep.run(this.context);
-            this.logLine("PLAN", "analysisPlanGen", t());
-            const analysisPlan = this.context.analysis?.planSuggestion?.plan?.steps ?? [];
+            {
+                const t = this.startTimer();
+                await analysisPlanGenStep.run(this.context);
+                this.logLine("PLAN", "analysisPlanGen", t());
+            }
             let stepIO = { query: this.query };
+            const analysisPlan = this.context.analysis?.planSuggestion?.plan?.steps ?? [];
             for (const step of analysisPlan.filter(s => s.groups?.includes("analysis"))) {
                 stepIO = await this.executeStep(step, stepIO);
             }
-        }
-        {
-            t = this.startTimer();
-            await planTargetFilesStep.run({ query: this.query, context: this.context });
-            this.logLine("ANALYSIS", "planTargetFiles", t());
-        }
-        const review = await contextReviewStep(this.context);
-        if (review.decision === "has") {
-            if (this.runCount >= this.maxRuns) {
-                this.logLine("ROUTING", "gatherData", undefined, chalk.yellow("max runs reached, proceeding anyway"));
+            {
+                const t = this.startTimer();
+                await planTargetFilesStep.run({ query: this.query, context: this.context });
+                this.logLine("ANALYSIS", "planTargetFiles", t());
             }
-            else {
-                this.logLine("ROUTING", "gatherData", undefined, chalk.yellow(review.reason));
+            const review = await contextReviewStep(this.context);
+            if (review.decision === "has" && this.runCount < this.maxRuns) {
                 this.runCount++;
                 this.resetInitContextForLoop();
                 return this.run();
             }
         }
-        /* ================= TRANSFORM PHASE ================= */
+        /* ================= TRANSFORM ================= */
         if (this.canExecutePhase("transform")) {
-            t = this.startTimer();
-            await transformPlanGenStep.run(this.context);
-            this.logLine("PLAN", "transformPlanGen", t());
-            const transformSteps = (this.context.analysis?.planSuggestion?.plan?.steps ?? [])
-                .filter(s => s.groups?.includes("transform"));
+            {
+                const t = this.startTimer();
+                await transformPlanGenStep.run(this.context);
+                this.logLine("PLAN", "transformPlanGen", t());
+            }
             let stepIO = { query: this.query };
+            const transformSteps = this.context.analysis?.planSuggestion?.plan?.steps
+                ?.filter(s => s.groups?.includes("transform")) ?? [];
             for (const step of transformSteps) {
                 stepIO = await this.executeStep(step, stepIO);
             }
             if (this.canExecutePhase("write")) {
-                const tWrite = this.startTimer();
-                stepIO = await writeFileStep.run({
-                    query: this.query,
-                    context: this.context,
-                    data: stepIO.data
-                });
-                this.logLine("EXECUTE", "writeFile", tWrite());
+                const t = this.startTimer();
+                await writeFileStep.run({ query: this.query, context: this.context });
+                this.logLine("EXECUTE", "writeFile", t());
             }
         }
-        /* ================= FINALIZE PHASE ================= */
+        /* ================= FINALIZE ================= */
         {
-            t = this.startTimer();
+            const t = this.startTimer();
             await finalPlanGenStep.run(this.context);
             this.logLine("PLAN", "finalPlanGen", t());
-            const finalPlan = this.context.analysis?.planSuggestion?.plan ?? { steps: [] };
             let stepIO = { query: this.query };
+            const finalPlan = this.context.analysis?.planSuggestion?.plan ?? { steps: [] };
             for (const step of finalPlan.steps.filter(s => s.groups?.includes("finalize"))) {
                 stepIO = await this.executeStep(step, stepIO);
             }
         }
-        this.userOutput("All input/output logs can be found at ~/.scai/input_output.log");
-        this.logLine("RUN", "complete", stopRun());
-        // -------------------- PERSIST TASK DATA --------------------
         const db = getDbForRepo();
         persistTaskData(this.context, this.taskId, db, this.logLine.bind(this));
+        this.logLine("RUN", "complete", stopRun());
         return { query: this.query, data: {} };
-    } // <-- close run() properly
+    }
     resetInitContextForLoop() {
         if (this.context.initContext)
             this.context.initContext.relatedFiles = [];

package/dist/agents/collectAnalysisEvidenceStep.js

@@ -0,0 +1,189 @@
+// File: src/modules/collectAnalysisEvidenceStep.ts
+import fs from "fs";
+import { generate } from "../lib/generate.js";
+import { cleanupModule } from "../pipeline/modules/cleanupModule.js";
+import { logInputOutput } from "../utils/promptLogHelper.js";
+export const collectAnalysisEvidenceStep = {
+    name: "collectAnalysisEvidence",
+    description: "Evidence-first, deterministic analysis over candidate source files. Builds fileAnalysis only.",
+    groups: ["analysis"],
+    run: async (input) => {
+        var _a;
+        const query = input.query ?? "";
+        const context = input.context;
+        if (!context?.analysis) {
+            throw new Error("[collectAnalysisEvidence] context.analysis is required.");
+        }
+        context.analysis.fileAnalysis = context.analysis.fileAnalysis ?? {};
+        const intentCategory = context.analysis.intent?.intentCategory ?? "other";
+        // ───────────── Guard ─────────────
+        if (!["refactorTask", "codingTask", "writing"].includes(intentCategory)) {
+            console.log(`[collectAnalysisEvidence] Skipping file scan because intentCategory=${intentCategory}`);
+            return {
+                query,
+                data: {
+                    fileAnalysis: context.analysis.fileAnalysis
+                }
+            };
+        }
+        // --------------------------------------------------
+        // Collect candidate paths (old selectRelevantSources behavior)
+        // --------------------------------------------------
+        const candidatePaths = [
+            ...(context.analysis.focus?.relevantFiles ?? []),
+            ...(context.initContext?.relatedFiles ?? []),
+            ...(context.workingFiles?.map(f => f.path) ?? []),
+        ];
+        const uniquePaths = Array.from(new Set(candidatePaths));
+        if (!uniquePaths.length) {
+            console.warn("⚠️ No candidate paths available for evidence collection.");
+            return { query, data: {} };
+        }
+        const filesWithEvidence = [];
+        // --------------------------------------------------
+        // Deterministic evidence collection
+        // --------------------------------------------------
+        for (const path of uniquePaths) {
+            let code;
+            try {
+                code = fs.readFileSync(path, "utf-8");
+            }
+            catch (err) {
+                console.warn(`⚠️ Failed to read file ${path}:`, err.message);
+                continue;
+            }
+            const lines = code.split("\n");
+            const evidenceItems = [];
+            const sentenceMatches = [];
+            // Heuristic: quoted strings in query
+            const sentenceRegex = /['"`](.+?)['"`]/g;
+            const targetSentences = [];
+            let match;
+            while ((match = sentenceRegex.exec(query)) !== null) {
+                targetSentences.push(match[1]);
+            }
+            // Line-by-line scan
+            lines.forEach((line, index) => {
+                for (const target of targetSentences) {
+                    if (line.includes(target)) {
+                        evidenceItems.push({
+                            claim: `Line contains the target sentence: "${target}"`,
+                            excerpt: line,
+                            span: { startLine: index + 1, endLine: index + 1 },
+                            confidence: 1,
+                        });
+                        sentenceMatches.push(line);
+                    }
+                }
+            });
+            const isRelevant = evidenceItems.length > 0;
+            const shouldModify = determineShouldModify(intentCategory, isRelevant);
+            const scope = determineScope(evidenceItems.length, intentCategory, isRelevant);
+            if (isRelevant) {
+                filesWithEvidence.push(path);
+            }
+            const fileAnalysis = {
+                intent: isRelevant ? "relevant" : "irrelevant",
+                relevance: isRelevant
+                    ? `${evidenceItems.length} candidate item(s) relevant to the query.`
+                    : "No matching lines found in the file.",
+                role: "primary",
+                action: {
+                    isRelevant,
+                    shouldModify
+                },
+                proposedChanges: {
+                    summary: isRelevant
+                        ? "File contains elements that should be modified according to the query."
+                        : "No changes required.",
+                    scope,
+                    targets: sentenceMatches,
+                    rationale: isRelevant
+                        ? "Detected sentence(s) in file matching the query."
+                        : undefined,
+                },
+                risks: [],
+                evidence: evidenceItems,
+            };
+            // Optional LLM rationale (non-authoritative)
+            if (isRelevant) {
+                try {
+                    const prompt = `
+Provide a concise rationale (1–2 sentences) explaining why the identified lines in this file are relevant to the user's query.
+
+Query:
+"${query}"
+
+File:
+${path}
+
+Lines:
+${sentenceMatches.join("\n")}
+          `.trim();
+                    const response = await generate({ content: prompt, query });
+                    const cleaned = await cleanupModule.run({ query, content: response.data });
+                    if (typeof cleaned.data === "string") {
+                        fileAnalysis.proposedChanges.rationale = cleaned.data;
+                    }
+                }
+                catch {
+                    console.warn(`[collectAnalysisEvidence] Rationale enrichment failed for ${path}`);
+                }
+            }
+            // Persist analysis only
+            context.analysis.fileAnalysis[path] = {
+                ...context.analysis.fileAnalysis[path],
+                ...fileAnalysis,
+            };
+        }
+        // ───────────── Conditional relevance update ─────────────
+        // Only update focus.relevantFiles if at least one file has evidence
+        if (filesWithEvidence.length > 0) {
+            (_a = context.analysis).focus ?? (_a.focus = { relevantFiles: [] });
+            context.analysis.focus.relevantFiles = filesWithEvidence;
+            // Mark others as irrelevant
+            for (const path of uniquePaths) {
+                if (!filesWithEvidence.includes(path)) {
+                    context.analysis.fileAnalysis[path] = {
+                        ...context.analysis.fileAnalysis[path],
+                        intent: "irrelevant",
+                        action: { ...context.analysis.fileAnalysis[path]?.action, isRelevant: false }
+                    };
+                }
+            }
+        }
+        const output = {
+            query,
+            data: {
+                fileAnalysis: context.analysis.fileAnalysis,
+            },
+        };
+        logInputOutput("collectAnalysisEvidence", "output", output.data);
+        return output;
+    },
+};
+// ───────────── helpers ─────────────
+function determineShouldModify(intentCategory, isRelevant) {
+    if (!isRelevant)
+        return false;
+    return ["codingTask", "refactorTask", "writing"].includes(intentCategory);
+}
+function determineScope(evidenceCount, intentCategory, isRelevant) {
+    if (!isRelevant)
+        return "none";
+    let scope = "minor";
+    if (evidenceCount <= 2)
+        scope = "minor";
+    else if (evidenceCount <= 5)
+        scope = "moderate";
+    else
+        scope = "major";
+    // Intent bump
+    if (["refactorTask", "codingTask"].includes(intentCategory)) {
+        if (scope === "minor" && evidenceCount > 1)
+            scope = "moderate";
+        if (scope === "moderate" && evidenceCount > 4)
+            scope = "major";
+    }
+    return scope;
+}

package/dist/agents/readinessGateStep.js

@@ -4,7 +4,7 @@ function logRoutingDecision(context) {
     logInputOutput('readinessGateStep', 'output', {
         routingDecision: context.analysis?.routingDecision,
         focus: context.analysis?.focus,
-        understanding: context.analysis?.understanding,
+        fileAnalysis: context.analysis?.fileAnalysis,
     });
 }
 export const readinessGateStep = {
@@ -15,51 +15,56 @@ export const readinessGateStep = {
         var _a, _b;
         context.analysis || (context.analysis = {});
         (_a = context.analysis).focus || (_a.focus = { relevantFiles: [], missingFiles: [], rationale: '' });
-        (_b = context.analysis).understanding || (_b.understanding = {});
+        (_b = context.analysis).fileAnalysis || (_b.fileAnalysis = {});
         const focus = context.analysis.focus;
+        const fileAnalysis = context.analysis.fileAnalysis;
+        // ================= CHECK EVIDENCE =================
+        const relevantFiles = Object.entries(fileAnalysis)
+            .filter(([_, fa]) => fa.intent === 'relevant')
+            .map(([path, _]) => path);
+        const irrelevantFiles = Object.entries(fileAnalysis)
+            .filter(([_, fa]) => fa.intent === 'irrelevant')
+            .map(([path, _]) => path);
         const missingFiles = focus.missingFiles ?? [];
-        const availableFiles = focus.relevantFiles ?? [];
-        // ================= FAST PATH =================
-        // If fileCheckStep says nothing is missing, we already have enough info
-        if (missingFiles.length === 0) {
+        // Fast path: no relevant files, evidence indicates info is missing
+        if (relevantFiles.length === 0 || missingFiles.length > 0) {
             context.analysis.routingDecision = {
-                decision: 'has-info',
-                rationale: focus.rationale || 'All required information is already available.',
-                confidence: 0.85,
+                decision: 'needs-info',
+                rationale: `No relevant evidence found or missing files: ${missingFiles.join(', ')}`,
+                confidence: 0.9,
             };
             logRoutingDecision(context);
             return;
         }
-        // ================= MODEL CLASSIFICATION =================
-        // Only classify readiness; do NOT infer files or plans
+        // Evidence-based classification
+        // Build simple summary for model
+        const evidenceSummary = relevantFiles
+            .map(path => {
+            const fa = fileAnalysis[path];
+            const claims = fa.evidence?.map(e => `- ${e.claim}`).join('\n') ?? '';
+            return `File: ${path}\nRole: ${fa.role}\nRelevance: ${fa.relevance}\nClaims:\n${claims}`;
+        })
+            .join('\n\n');
         const prompt = `
-You are a routing classifier, not a problem solver.
+You are a routing classifier. Your task is to determine if the agent has sufficient evidence to answer the user's query.
 
 User query:
 ${context.initContext?.userQuery}
 
-Available files:
-${JSON.stringify(availableFiles, null, 2)}
-
-Repo section:
-${context.initContext?.repoTree}
-
-${context.analysis?.folderCapsulesHuman}
-
-Missing files (as determined earlier):
-${JSON.stringify(missingFiles, null, 2)}
+Evidence from analyzed files:
+${evidenceSummary}
 
 Decide ONE of the following:
 
 HAS-INFO:
+- Sufficient evidence exists in the analyzed files.
 - All required information is present to answer the user's query.
-- No further information acquisition is required.
 
 NEEDS-INFO:
-- Some files or context are missing, or additional analysis is required.
-- Information acquisition must run before execution.
+- Insufficient evidence or missing critical files.
+- Additional information acquisition must run.
 
-Return ONLY the label, optionally with a short rationale.
+Return ONLY the label (HAS-INFO or NEEDS-INFO) and optionally a short rationale.
 `.trim();
         try {
             const genInput = {
@@ -72,15 +77,15 @@ Return ONLY the label, optionally with a short rationale.
             const extractedText = raw.replace(/^(HAS-INFO|NEEDS-INFO):?\s*/i, '').trim();
             const modelDecision = raw.toUpperCase().startsWith('HAS-INFO') ? 'has-info' : 'needs-info';
             const combinedRationale = [
-                focus.rationale?.trim(),
+                `Evidence-based routing: ${relevantFiles.length} relevant files, ${irrelevantFiles.length} irrelevant files.`,
                 extractedText ? `Model: ${extractedText}` : null,
             ]
                 .filter(Boolean)
-                .join('\n') || `Missing files detected: ${missingFiles.join(', ')}`;
+                .join('\n');
             context.analysis.routingDecision = {
                 decision: modelDecision,
                 rationale: combinedRationale,
-                confidence: modelDecision === 'has-info' ? 0.8 : 0.85,
+                confidence: modelDecision === 'has-info' ? 0.85 : 0.9,
             };
             logRoutingDecision(context);
         }

package/dist/agents/resolveExecutionModeStep.js

@@ -29,6 +29,15 @@ export const resolveExecutionModeStep = {
                 mode = "explain";
                 rationale = "User intent requests text explanation only.";
                 break;
+            case "docsAndComments":
+            case "docsandcomments":
+            case "docsAndComment":
+            case "docs":
+            case "comments":
+            case "comment":
+                mode = "transform";
+                rationale = "User intent requests adding documentation/comments to files.";
+                break;
             default:
                 mode = "explain";
                 rationale = "Defaulted to explanation due to unclear intent.";

package/dist/agents/selectRelevantSourcesStep.js

@@ -1,95 +1,121 @@
 // File: src/modules/selectRelevantSourcesStep.ts
 import fs from "fs";
+import chalk from "chalk";
 import { generate } from "../lib/generate.js";
 import { cleanupModule } from "../pipeline/modules/cleanupModule.js";
 import { logInputOutput } from "../utils/promptLogHelper.js";
 export const selectRelevantSourcesStep = {
     name: "selectRelevantSources",
-    description: "Selects the most relevant files for the query from relatedFiles + workingFiles, loads their code, and updates context.workingFiles.",
+    description: "Selects relevant files from analysis.fileAnalysis and populates focus.relevantFiles; also optionally adds to workingFiles with optional LLM fallback.",
     groups: ["analysis"],
     run: async (input) => {
         const query = input.query ?? "";
         const context = input.context;
-        if (!context) {
-            throw new Error("[selectRelevantSources] StructuredContext is required.");
+        if (!context?.analysis) {
+            throw new Error("[selectRelevantSources] context.analysis is required.");
         }
-        // Merge candidate paths (relatedFiles + existing workingFiles)
-        // At this point in-depth context build or searchfiles may have placed files in 
-        // working files. 
+        const fileAnalysis = context.analysis.fileAnalysis ?? {};
+        // --------------------------------------------------
+        // 1. Evidence-first promotion (authoritative)
+        // --------------------------------------------------
+        const evidenceSelected = [];
+        for (const [path, analysis] of Object.entries(fileAnalysis)) {
+            if (!analysis.action?.isRelevant)
+                continue;
+            let code;
+            try {
+                code = fs.readFileSync(path, "utf-8");
+            }
+            catch (err) {
+                console.warn(`⚠️ Failed to read file ${path}:`, err.message);
+            }
+            evidenceSelected.push({ path, code });
+        }
+        // --------------------------------------------------
+        // 2. LLM fallback (only for unanalyzed paths)
+        // --------------------------------------------------
         const candidatePaths = [
-            ...(context.analysis?.focus?.relevantFiles ?? []),
+            ...(context.analysis.focus?.relevantFiles ?? []),
             ...(context.initContext?.relatedFiles ?? []),
-            ...(context.workingFiles?.map(f => f.path) ?? [])
         ];
-        const uniquePaths = Array.from(new Set(candidatePaths));
-        // -----------------------------
-        // Prompt the LLM to rank files
-        // -----------------------------
-        const prompt = `
-You are given:
-
+        const analyzedPaths = new Set(Object.keys(fileAnalysis));
+        const llmCandidates = Array.from(new Set(candidatePaths)).filter(p => !analyzedPaths.has(p));
+        let llmSelected = [];
+        if (llmCandidates.length > 0) {
+            const prompt = `
 Query:
 "${query}"
 
 Candidate file paths:
-${JSON.stringify(uniquePaths, null, 2)}
+${JSON.stringify(llmCandidates, null, 2)}
 
 Task:
-- Identify ONLY the files you find to be directly relevant to the query. 
+- Select ONLY files that are directly relevant to answering the query.
 - Return ONLY a JSON array of objects.
-- Each object must have at least a "path" field.
+- Each object must include "path".
 - Optional fields: "summary".
-- Do NOT include explanations.
-    `.trim();
-        let topFiles = [];
-        try {
-            const response = await generate({ content: prompt, query: "" });
-            const cleaned = await cleanupModule.run({
-                query,
-                content: response.data,
-            });
-            const rawFiles = Array.isArray(cleaned.data) ? cleaned.data : [];
-            // Load code for selected files
-            topFiles = rawFiles
-                .map((f) => {
-                if (typeof f?.path !== "string")
-                    return null;
-                let code;
-                try {
-                    code = fs.readFileSync(f.path, "utf-8");
-                }
-                catch (err) {
-                    console.warn(`⚠️ Failed to read file ${f.path}:`, err.message);
-                }
-                return { path: f.path, code };
-            })
-                .filter(Boolean);
-        }
-        catch (err) {
-            console.error("❌ [selectRelevantSources] Model selection failed:", err);
-            topFiles = [];
+- No explanations.
+      `.trim();
+            try {
+                const response = await generate({ content: prompt, query: "" });
+                const cleaned = await cleanupModule.run({
+                    query,
+                    content: response.data,
+                });
+                const rawFiles = Array.isArray(cleaned.data) ? cleaned.data : [];
+                llmSelected = rawFiles
+                    .map((f) => {
+                    if (typeof f?.path !== "string")
+                        return null;
+                    let code;
+                    try {
+                        code = fs.readFileSync(f.path, "utf-8");
+                    }
+                    catch (err) {
+                        console.warn(`⚠️ Failed to read file ${f.path}:`, err.message);
+                    }
+                    return { path: f.path, code };
+                })
+                    .filter(Boolean);
+            }
+            catch (err) {
+                console.error(chalk.red("❌ [selectRelevantSources] LLM fallback failed:"), err);
+            }
         }
-        // -----------------------------
-        // Persist authoritative context (append, do not overwrite)
-        // -----------------------------
+        // --------------------------------------------------
+        // 3. Persist workingFiles (append + dedupe)
+        // --------------------------------------------------
         context.workingFiles = [
-            ...(context.workingFiles ?? []), // existing working files
-            ...topFiles, // new top files
+            ...(context.workingFiles ?? []),
+            ...evidenceSelected,
+            ...llmSelected,
         ];
-        // Deduplicate by path
-        const seenPaths = new Set();
+        const seen = new Set();
         context.workingFiles = context.workingFiles.filter(f => {
             if (!f.path)
-                return false; // safety check
-            if (seenPaths.has(f.path))
                 return false;
-            seenPaths.add(f.path);
+            if (seen.has(f.path))
+                return false;
+            seen.add(f.path);
             return true;
         });
+        // --------------------------------------------------
+        // 4. Update focus.relevantFiles (canonical source for planning)
+        // --------------------------------------------------
+        context.analysis.focus = {
+            relevantFiles: Array.from(new Set([
+                ...evidenceSelected.map(f => f.path),
+                ...llmSelected.map(f => f.path),
+            ])),
+            missingFiles: context.analysis.focus?.missingFiles ?? [],
+            discardedFiles: context.analysis.focus?.discardedFiles ?? [],
+            rationale: context.analysis.focus?.rationale ?? "",
+        };
         const output = {
             query,
             data: {
-                workingFiles: topFiles.map(f => ({ path: f.path })),
+                workingFiles: context.workingFiles.map(f => ({ path: f.path })),
+                relevantFiles: context.analysis.focus?.relevantFiles,
             },
         };
         logInputOutput("selectRelevantSources", "output", output.data);

package/dist/agents/understandIntentStep.js

@@ -18,7 +18,7 @@ ${context.initContext?.userQuery}
 Return a STRICT JSON object with the following fields:
 {
   "intent": "short sentence summarizing the user's intent",
-  "intentCategory": "one of: question, request, codingTask, refactorTask, explanation, debugging, planning, writing, other",
+  "intentCategory": "one of: question, request, codingTask, refactorTask, explanation, debugging, planning, writing, docsAndComments",
   "normalizedQuery": "a cleaned and direct restatement of the user query",
   "confidence": 0-1  // float
 }
@@ -42,17 +42,36 @@ Do not include commentary. Emit ONLY valid JSON.
             catch {
                 parsed = {
                     intent: "unknown",
-                    intentCategory: "other",
+                    intentCategory: "",
                     normalizedQuery: context.initContext?.userQuery,
                     confidence: 0.3
                 };
             }
+            // ---------------------
+            // Fallback for invalid / "other" categories
+            // ---------------------
+            let category = parsed.intentCategory?.trim();
+            if (!category || category.toLowerCase() === "other") {
+                const q = parsed.normalizedQuery?.toLowerCase() ?? "";
+                if (q.includes("move") || q.includes("append") || q.includes("remove") || q.includes("insert")) {
+                    category = "refactorTask";
+                }
+                else if (q.includes("comment") || q.includes("documentation") || q.includes("jsdoc") || q.includes("docstring")) {
+                    category = "docsAndComments";
+                }
+                else if (q.includes("sentence") || q.includes("file")) {
+                    category = "explanation";
+                }
+                else {
+                    category = "request"; // safe default
+                }
+            }
             // Ensure the analysis object exists
             context.analysis ?? (context.analysis = {});
             // Store intent inside a dedicated object
             context.analysis.intent = {
                 intent: parsed.intent,
-                intentCategory: parsed.intentCategory,
+                intentCategory: category,
                 normalizedQuery: parsed.normalizedQuery,
                 confidence: parsed.confidence
             };
@@ -63,7 +82,7 @@ Do not include commentary. Emit ONLY valid JSON.
             context.analysis ?? (context.analysis = {});
             context.analysis.intent = {
                 intent: "unknown",
-                intentCategory: "other",
+                intentCategory: "request",
                 normalizedQuery: context.initContext?.userQuery ?? '',
                 confidence: 0.0
             };

package/dist/commands/factory.js

@@ -9,8 +9,6 @@ import { reviewPullRequestCmd } from './ReviewCmd.js';
 import { checkGit } from './GitCmd.js';
 import { promptForToken } from '../github/token.js';
 import { validateGitHubTokenAgainstRepo } from '../github/githubAuthCheck.js';
-import { runWorkflowCommand } from './WorkflowCmd.js';
-import { handleStandaloneChangelogUpdate } from './ChangeLogUpdateCmd.js';
 import { runInteractiveSwitch, runSwitchCommand, statusIndex } from './SwitchCmd.js';
 import { runInteractiveDelete } from './DeleteIndex.js';
 import { startDaemon, stopDaemon, restartDaemon, statusDaemon, unlockConfig, showLogs } from './DaemonCmd.js';
@@ -112,31 +110,6 @@ export function createProgram() {
             console.log('🔑 GitHub token set.');
         });
     });
-    // ---------------- Workflow ----------------
-    const workflow = cmd.command('workflow').description('Run or manage module pipelines');
-    workflow
-        .command('run <goals...>')
-        .description('Run one or more modules as a pipeline')
-        .option('-f, --file <filepath>', 'File to process (omit to read from stdin)')
-        .action(async (goals, options) => {
-        await withContext(async () => {
-            await runWorkflowCommand(goals, options);
-        });
-    })
-        .on('--help', () => {
-        console.log('\nExamples:');
-        console.log('  $ scai workflow run comments tests -f path/to/myfile.ts');
-        console.log('  $ cat file.ts | scai workflow run comments tests > file.test.ts\n');
-        console.log('Available modules: summary, comments, tests');
-    });
-    // ---------------- Gen / Changelog ----------------
-    const gen = cmd.command('gen').description('Generate code-related output');
-    gen
-        .command('changelog')
-        .description('Update or create CHANGELOG.md')
-        .action(async () => {
-        await withContext(async () => { await handleStandaloneChangelogUpdate(); });
-    });
     // ---------------- Config ----------------
     const config = cmd.command('config').description('Manage SCAI configuration');
     config

package/dist/config.js

@@ -8,6 +8,7 @@ import { getHashedRepoKey } from './utils/repoKey.js';
 const defaultConfig = {
     model: 'qwen3-coder:30b',
     contextLength: 32768,
+    maxOutputTokens: 2048,
     language: 'ts',
     indexDir: '',
     githubToken: '',
@@ -26,7 +27,15 @@ function ensureConfigDir() {
 export function readConfig() {
     try {
         const content = fs.readFileSync(CONFIG_PATH, 'utf-8');
-        return { ...defaultConfig, ...JSON.parse(content) };
+        const parsed = JSON.parse(content);
+        // ⛔ Never allow static config.json to control token limits
+        const { contextLength: _ignoredContextLength, maxOutputTokens: _ignoredMaxOutputTokens, ...rest } = parsed;
+        return {
+            ...defaultConfig,
+            ...rest,
+            contextLength: defaultConfig.contextLength,
+            maxOutputTokens: defaultConfig.maxOutputTokens,
+        };
     }
     catch {
         return defaultConfig;
@@ -220,22 +229,23 @@ export const Config = {
         const cfg = readConfig();
         const active = cfg.activeRepo;
         console.log(`🔧 Current configuration:`);
-        console.log(`   Active index dir: ${active || 'Not Set'}`);
+        console.log(`   Active index dir  : ${active || 'Not Set'}`);
         const repoCfg = active ? cfg.repos[active] : {};
-        console.log(`   Model           : ${repoCfg?.model || cfg.model}`);
-        console.log(`   Language        : ${repoCfg?.language || cfg.language}`);
-        console.log(`   GitHub Token    : ${cfg.githubToken ? '*****' : 'Not Set'}`);
+        console.log(`   Model             : ${repoCfg?.model || cfg.model}`);
+        console.log(`   Language          : ${repoCfg?.language || cfg.language}`);
+        console.log(`   Context length    : ${cfg.contextLength} tokens`);
+        console.log(`   Max output tokens : ${cfg.maxOutputTokens} tokens`);
+        console.log(`   GitHub Token      : ${cfg.githubToken ? '*****' : 'Not Set'}`);
         const daemon = this.getDaemonConfig();
-        console.log(`   Daemon sleepMs  : ${daemon.sleepMs}ms`);
-        console.log(`   Daemon idleMs   : ${daemon.idleSleepMs}ms`);
+        console.log(`   Daemon sleepMs    : ${daemon.sleepMs}ms`);
+        console.log(`   Daemon idleMs     : ${daemon.idleSleepMs}ms`);
         // ✅ Show lock status
         let lockStatus = 'Unlocked';
-        let lockedRepo = null;
         if (fs.existsSync(CONFIG_LOCK_PATH)) {
-            lockedRepo = fs.readFileSync(CONFIG_LOCK_PATH, 'utf8');
+            const lockedRepo = fs.readFileSync(CONFIG_LOCK_PATH, 'utf8');
             lockStatus = `Locked to repo '${lockedRepo}'`;
         }
-        console.log(`   Daemon Lock     : ${lockStatus}`);
+        console.log(`   Daemon Lock       : ${lockStatus}`);
     },
     getRaw() {
         return readConfig();

package/dist/index.js

@@ -117,6 +117,8 @@ function editInEditorAsync(initialContent = '') {
 // run terminal commands with '!', or edit input in an external editor with '/edit'.
 // It uses withContext to ensure proper execution context for each command or query.
 async function startShell() {
+    // Clear screen first
+    process.stdout.write('\x1Bc');
     console.log(chalk.yellow("Welcome to SCAI shell!") + "\n" +
         chalk.blueBright(`- Type your query directly for short commands or questions.
 - Use !command to run terminal commands.
@@ -159,9 +161,7 @@ async function startShell() {
                     const content = await editInEditorAsync();
                     const trimmedContent = content.trim();
                     if (trimmedContent) {
-                        // Print the editor content in orange
                         console.log(chalk.hex('#FFA500')('\n[Editor input]:\n' + trimmedContent + '\n'));
-                        // Execute the query
                         await withContext(() => runAskCommand(trimmedContent));
                     }
                     continue;

package/dist/lib/generate.js

@@ -9,17 +9,17 @@ import { Config, readConfig } from '../config.js';
  */
 export async function generate(input) {
     const model = Config.getModel();
-    const { contextLength } = readConfig();
+    const { contextLength, maxOutputTokens } = readConfig();
     // Safely build prompt
     const queryPart = input.query ? `User query:\n${input.query}\n\n` : '';
     const contentPart = input.content && typeof input.content !== 'string'
         ? JSON.stringify(input.content, null, 2)
         : input.content || '';
     const prompt = `${queryPart}${contentPart}`.trim();
-    const data = await doGenerate(prompt, model, contextLength);
+    const data = await doGenerate(prompt, model, contextLength, maxOutputTokens);
     return { query: input.query, data };
 }
-async function doGenerate(prompt, model, contextLength) {
+async function doGenerate(prompt, model, contextLength, maxOutputTokens) {
     const res = await fetch('http://localhost:11434/api/generate', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
@@ -28,7 +28,10 @@ async function doGenerate(prompt, model, contextLength) {
             prompt,
             stream: false,
             options: {
+                // context window
                 num_ctx: contextLength,
+                // limit output to avoid exceeding context
+                max_output_tokens: maxOutputTokens,
             },
         }),
     });

package/dist/pipeline/modules/codeTransformModule.js

@@ -1,11 +1,7 @@
 import { generate } from "../../lib/generate.js";
 import { cleanupModule } from "./cleanupModule.js";
 import { logInputOutput } from "../../utils/promptLogHelper.js";
-import { splitCodeIntoChunks, countTokens } from "../../utils/splitCodeIntoChunk.js";
 import chalk from "chalk";
-// ───────────── Token limits ─────────────
-const SINGLE_SHOT_TOKEN_LIMIT = 2500; // keep large enough for small files
-const CHUNK_TOKEN_LIMIT = 2200; // chunked transformation limit
 function stripCodeFences(text) {
     const lines = text.split("\n");
     while (lines.length && /^```/.test(lines[0].trim()))
@@ -14,24 +10,12 @@ function stripCodeFences(text) {
         lines.pop();
     return lines.join("\n");
 }
-function isSuspiciousChunkOutput(text, originalChunk) {
-    const trimmed = text.trim();
-    if (!trimmed)
-        return true;
-    if (/here is|transformed|updated code|explanation/i.test(trimmed))
-        return true;
-    if (trimmed.startsWith("{") && trimmed.endsWith("}"))
-        return true;
-    if (trimmed.length < originalChunk.trim().length * 0.3)
-        return true;
-    return false;
-}
 export const codeTransformModule = {
     name: "codeTransform",
     description: "Transforms a single file specified in the current plan step based on user instruction.",
     groups: ["transform"],
     run: async (input) => {
-        var _a, _b, _c;
+        var _a, _b;
         const query = typeof input.query === "string" ? input.query : String(input.query ?? "");
         const context = input.context;
         if (!context) {
@@ -78,17 +62,13 @@ ${proposed.rationale ? `- Rationale: ${proposed.rationale}` : ""}
             : "";
         const outputs = [];
         const perFileErrors = [];
-        const tokenCount = countTokens(file.code);
         context.execution || (context.execution = {});
         (_a = context.execution).codeTransformArtifacts || (_a.codeTransformArtifacts = { files: [] });
-        // ───────────── SMALL FILE ─────────────
-        if (tokenCount <= SINGLE_SHOT_TOKEN_LIMIT) {
-            logInputOutput("codeTransform", "output", {
-                file: file.path,
-                tokenCount,
-                message: "Starting small file transformation",
-            });
-            const prompt = `
+        logInputOutput("codeTransform", "output", {
+            file: file.path,
+            message: "Starting single-shot file transformation",
+        });
+        const prompt = `
 You are a precise code transformation assistant.
 
 User instruction (normalized):
@@ -117,139 +97,52 @@ JSON schema:
   "errors": []
 }
 `.trim();
-            try {
-                logInputOutput("codeTransform", "output", { file: file.path, message: "Sending prompt to LLM" });
-                const llmResponse = await generate({ content: prompt, query });
-                logInputOutput("codeTransform", "output", {
-                    file: file.path,
-                    message: "Received LLM response",
-                    responseSnippet: String(llmResponse.data ?? "").slice(0, 200),
-                });
-                const cleaned = await cleanupModule.run({ query, content: llmResponse.data });
-                let finalContent;
-                let notes = undefined;
-                if (typeof cleaned.data === 'string') {
-                    // Raw code returned
-                    finalContent = cleaned.data;
-                    console.debug(chalk.yellow(` - [cleanupModule] Using raw code output for ${file.path}`));
-                }
-                else if (cleaned.data &&
-                    typeof cleaned.data === 'object' &&
-                    Array.isArray(cleaned.data.files)) {
-                    // Structured JSON returned
-                    const structured = cleaned.data;
-                    const out = structured.files.find(f => f.filePath === file.path);
-                    finalContent = out?.content ?? file.code;
-                    notes = out?.notes;
-                    perFileErrors.push(...(structured.errors ?? []));
-                }
-                else {
-                    // Fallback
-                    finalContent = file.code;
-                }
-                outputs.push({ filePath: file.path, content: finalContent, notes });
-                // ensure artifacts are updated
-                context.execution.codeTransformArtifacts.files =
-                    context.execution.codeTransformArtifacts.files.filter(f => f.filePath !== file.path);
-                context.execution.codeTransformArtifacts.files.push(outputs[0]);
-                context.plan || (context.plan = {});
-                (_b = context.plan).touchedFiles || (_b.touchedFiles = []);
-                if (!context.plan.touchedFiles.includes(file.path))
-                    context.plan.touchedFiles.push(file.path);
-                const output = { query, data: { files: outputs, errors: perFileErrors } };
-                logInputOutput("codeTransform", "output", context.execution.codeTransformArtifacts.files);
-                return output;
-            }
-            catch (err) {
-                const finalContent = file.code;
-                outputs.push({ filePath: file.path, content: finalContent });
-                perFileErrors.push(`LLM call or cleanup failed: ${err.message}`);
-                context.execution.codeTransformArtifacts.files.push(outputs[0]);
-                const output = { query, data: { files: outputs, errors: perFileErrors } };
-                return output;
-            }
-        }
-        // ───────────── LARGE FILE (chunked) ─────────────
-        const chunks = splitCodeIntoChunks(file.code, CHUNK_TOKEN_LIMIT);
-        console.warn(chalk.yellow([
-            "",
-            "⚠️  Large file detected — falling back to chunked transformation",
-            `   File: ${file.path}`,
-            `   Estimated tokens: ${tokenCount}`,
-            `   Chunks: ${chunks.length}`,
-            "   Note: Chunked refactors may be less accurate or inconsistent.",
-            "   If results look wrong, try reducing scope or refactoring manually.",
-            "",
-        ].join("\n")));
-        const transformedChunks = [];
-        logInputOutput("codeTransform", "output", { file: file.path, chunkCount: chunks.length, message: "Starting chunked transformation" });
-        for (let i = 0; i < chunks.length; i++) {
-            const chunk = chunks[i];
-            process.stdout.write("\r\x1b[K");
-            console.log(` - Processing chunk ${i + 1} of ${chunks.length} for ${file.path}...`);
+        try {
+            logInputOutput("codeTransform", "output", { file: file.path, message: "Sending prompt to LLM" });
+            const llmResponse = await generate({ content: prompt, query });
             logInputOutput("codeTransform", "output", {
                 file: file.path,
-                chunkIndex: i + 1,
-                chunkLength: chunk.length,
-                message: "Processing chunk",
+                message: "Received LLM response",
+                responseSnippet: String(llmResponse.data ?? "").slice(0, 200),
             });
-            const prompt = `
-You are a precise and conservative code transformation assistant.
-
-User instruction (normalized):
-${normalizedQuery}
-
-IMPORTANT SAFETY RULES:
-- If this chunk contains an UNFINISHED or UNCLOSED construct
-  (for example: an opening "{", "(", "[", "function", "class", or similar
-   that is not clearly closed within this chunk),
-  then you MUST return the chunk UNCHANGED.
-- Do NOT invent missing braces, code, or structure.
-- Do NOT attempt to "fix" incomplete syntax.
-- When in doubt, return the chunk EXACTLY as given.
-
-Transformation rules:
-- Apply the instruction ONLY if it is clearly relevant to this chunk.
-- If no change is needed, return the chunk UNCHANGED.
-- You MUST return the FULL chunk content.
-- Do NOT return diffs, explanations, or partial snippets.
-
-FILE: ${file.path}
-CHUNK ${i + 1} / ${chunks.length}
----
-${chunk}
-`.trim();
-            try {
-                const llmResponse = await generate({ content: prompt, query });
-                const raw = String(llmResponse.data ?? "");
-                const stripped = stripCodeFences(raw);
-                if (isSuspiciousChunkOutput(stripped, chunk)) {
-                    transformedChunks.push(chunk);
-                    perFileErrors.push(`Chunk ${i + 1} suspicious; original preserved.`);
-                    logInputOutput("codeTransform", "output", { file: file.path, chunkIndex: i + 1, message: "Suspicious output, original chunk preserved" });
-                }
-                else {
-                    transformedChunks.push(stripped);
-                    logInputOutput("codeTransform", "output", { file: file.path, chunkIndex: i + 1, message: "Chunk transformed successfully" });
-                }
+            const cleaned = await cleanupModule.run({ query, content: llmResponse.data });
+            let finalContent;
+            let notes = undefined;
+            if (typeof cleaned.data === 'string') {
+                finalContent = cleaned.data;
+                console.debug(chalk.yellow(` - [cleanupModule] Using raw code output for ${file.path}`));
+            }
+            else if (cleaned.data &&
+                typeof cleaned.data === 'object' &&
+                Array.isArray(cleaned.data.files)) {
+                const structured = cleaned.data;
+                const out = structured.files.find(f => f.filePath === file.path);
+                finalContent = out?.content ?? file.code;
+                notes = out?.notes;
+                perFileErrors.push(...(structured.errors ?? []));
             }
-            catch (err) {
-                transformedChunks.push(chunk);
-                perFileErrors.push(`Chunk ${i + 1} failed; original preserved. Error: ${err.message}`);
-                logInputOutput("codeTransform", "output", { file: file.path, chunkIndex: i + 1, error: err.message, message: "Chunk transformation failed, original preserved" });
+            else {
+                finalContent = file.code;
             }
+            outputs.push({ filePath: file.path, content: finalContent, notes });
+            context.execution.codeTransformArtifacts.files =
+                context.execution.codeTransformArtifacts.files.filter(f => f.filePath !== file.path);
+            context.execution.codeTransformArtifacts.files.push(outputs[0]);
+            context.plan || (context.plan = {});
+            (_b = context.plan).touchedFiles || (_b.touchedFiles = []);
+            if (!context.plan.touchedFiles.includes(file.path))
+                context.plan.touchedFiles.push(file.path);
+            const output = { query, data: { files: outputs, errors: perFileErrors } };
+            logInputOutput("codeTransform", "output", context.execution.codeTransformArtifacts.files);
+            return output;
         }
-        const finalContent = transformedChunks.join("\n");
-        outputs.push({ filePath: file.path, content: finalContent });
-        context.execution.codeTransformArtifacts.files =
-            context.execution.codeTransformArtifacts.files.filter(f => f.filePath !== file.path);
-        context.execution.codeTransformArtifacts.files.push(outputs[0]);
-        context.plan || (context.plan = {});
-        (_c = context.plan).touchedFiles || (_c.touchedFiles = []);
-        if (!context.plan.touchedFiles.includes(file.path))
-            context.plan.touchedFiles.push(file.path);
-        const output = { query, data: { files: outputs, errors: perFileErrors } };
-        logInputOutput("codeTransform", "output", context.execution.codeTransformArtifacts.files);
-        return output;
-    },
+        catch (err) {
+            const finalContent = file.code;
+            outputs.push({ filePath: file.path, content: finalContent });
+            perFileErrors.push(`LLM call or cleanup failed: ${err.message}`);
+            context.execution.codeTransformArtifacts.files.push(outputs[0]);
+            const output = { query, data: { files: outputs, errors: perFileErrors } };
+            return output;
+        }
+    }
 };

package/dist/pipeline/modules/semanticAnalysisModule.js

@@ -3,12 +3,6 @@ import { logInputOutput } from "../../utils/promptLogHelper.js";
 import { cleanupModule } from "./cleanupModule.js";
 import { generate } from "../../lib/generate.js";
 const MAX_CODE_CHARS = 6000; // conservative prompt-safe limit
-/**
- * Semantic analysis module:
- * - Performs file-level semantic analysis based on provided steps
- * - Stores results in context.analysis.fileAnalysis
- * - Optionally produces cross-file combined analysis
- */
 export const semanticAnalysisModule = {
     name: "semanticAnalysis",
     description: "Performs semantic analysis for each file provided by the plan steps, storing file-level and combined insights.",
@@ -27,7 +21,8 @@ export const semanticAnalysisModule = {
         context.analysis || (context.analysis = {});
         (_a = context.analysis).fileAnalysis || (_a.fileAnalysis = {});
         (_b = context.analysis).combinedAnalysis || (_b.combinedAnalysis = {});
-        // Use the planSuggestion.steps to determine which files to analyze
+        const intentCategory = context.analysis.intent?.intentCategory ?? "other";
+        // Determine which files to analyze based on plan steps
         const planSteps = context.analysis.planSuggestion?.plan?.steps ?? [];
         const filesToAnalyze = planSteps
             .filter(step => step.action === "semanticAnalysis" && step.targetFile)
@@ -39,28 +34,41 @@ export const semanticAnalysisModule = {
         // ----------------------------
         for (const file of filesToAnalyze) {
             const filePath = file.path;
-            // Skip if already analyzed
-            if (context.analysis.fileAnalysis[filePath])
-                continue;
-            const fileAnalysis = await analyzeFile(file, input.query, context);
-            context.analysis.fileAnalysis[filePath] = fileAnalysis;
+            const prevAnalysis = context.analysis.fileAnalysis[filePath];
+            // Use evidence relevance if available
+            const isRelevant = prevAnalysis?.action?.isRelevant ?? false;
+            if (!isRelevant)
+                continue; // skip irrelevant files
+            const shouldModify = prevAnalysis?.action?.shouldModify ?? determineShouldModify(intentCategory, isRelevant);
+            // Analyze the file (enriching previous evidence)
+            const semanticAnalysis = await analyzeFile(file, input.query, context, isRelevant, shouldModify);
+            context.analysis.fileAnalysis[filePath] = {
+                ...prevAnalysis, // keep evidence and prior info
+                ...semanticAnalysis, // add semantic insights
+                action: { isRelevant, shouldModify },
+            };
             logInputOutput("semanticAnalysisStep - per-file", "output", {
                 file: filePath,
-                analysis: fileAnalysis,
+                analysis: context.analysis.fileAnalysis[filePath],
             });
         }
         // ----------------------------
         // 2️⃣ Cross-file combined analysis (optional)
-        // Only combine if > 2 files analyzed
+        // Only consider relevant files
         // ----------------------------
-        const analyzedFiles = Object.keys(context.analysis.fileAnalysis);
+        const relevantFiles = Object.entries(context.analysis.fileAnalysis)
+            .filter(([_, analysis]) => analysis.action?.isRelevant)
+            .map(([path]) => path);
         let combinedAnalysis = {
             sharedPatterns: [],
             architectureSummary: "[skipped]",
             hotspots: [],
         };
-        if (analyzedFiles.length > 2) {
-            combinedAnalysis = await analyzeCombined(context.analysis.fileAnalysis, input.query);
+        if (relevantFiles.length > 2) {
+            const filteredAnalysis = {};
+            for (const path of relevantFiles)
+                filteredAnalysis[path] = context.analysis.fileAnalysis[path];
+            combinedAnalysis = await analyzeCombined(filteredAnalysis, input.query);
             logInputOutput("semanticAnalysisStep - combined", "output", combinedAnalysis);
         }
         context.analysis.combinedAnalysis = combinedAnalysis;
@@ -74,24 +82,16 @@ export const semanticAnalysisModule = {
 /* -------------------------
    Analyze single file
 ---------------------------- */
-async function analyzeFile(file, query, context) {
+async function analyzeFile(file, query, context, isRelevant = false, shouldModify = false) {
     const slicedCode = sliceCodeForAnalysis(file.code);
-    // Use rationale / understanding from previous steps
     const focus = context?.analysis?.focus;
     const understanding = context?.analysis?.understanding;
-    const rationaleSnippet = focus?.rationale ? `Rationale: ${focus.rationale}` : "";
-    const assumptionsSnippet = understanding?.assumptions
-        ? `Assumptions: ${understanding.assumptions.join("; ")}`
-        : "";
-    const constraintsSnippet = understanding?.constraints
-        ? `Constraints: ${understanding.constraints.join("; ")}`
-        : "";
-    const risksSnippet = understanding?.risks
-        ? `Known risks: ${understanding.risks.join("; ")}`
-        : "";
-    const contextSnippet = [rationaleSnippet, assumptionsSnippet, constraintsSnippet, risksSnippet]
-        .filter(Boolean)
-        .join("\n");
+    const contextSnippet = [
+        focus?.rationale ? `Rationale: ${focus.rationale}` : "",
+        understanding?.assumptions ? `Assumptions: ${understanding.assumptions.join("; ")}` : "",
+        understanding?.constraints ? `Constraints: ${understanding.constraints.join("; ")}` : "",
+        understanding?.risks ? `Known risks: ${understanding.risks.join("; ")}` : "",
+    ].filter(Boolean).join("\n");
     const prompt = `
 You are analyzing a single file in the context of a user query.
 
@@ -138,12 +138,10 @@ Return STRICT JSON:
                 data = JSON.parse(String(cleaned.content ?? "{}"));
             }
             catch {
-                console.warn(`[semanticAnalysisStep] Non-JSON output for ${file.path}, defaulting to irrelevant`);
                 data = {};
             }
         }
         const intent = data.intent === "relevant" || data.intent === "irrelevant" ? data.intent : "irrelevant";
-        const shouldModify = intent === "relevant" && data.action?.shouldModify === true;
         return {
             intent,
             relevance: typeof data.relevance === "string" && data.relevance.trim()
@@ -232,3 +230,11 @@ Return STRICT JSON:
         };
     }
 }
+/* -------------------------
+   Helpers
+---------------------------- */
+function determineShouldModify(intentCategory, isRelevant) {
+    if (!isRelevant)
+        return false;
+    return ["codingTask", "refactorTask", "writing"].includes(intentCategory);
+}

package/package.json

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