scai 0.1.175 → 0.1.177

package/dist/agents/MainAgent.js

@@ -28,6 +28,8 @@ import { structuralPreloadStep } from "./structuralPreloadStep.js";
 import { extractFileReferences } from "../utils/extractFileReferences.js";
 import { PREFILTER_STOP_WORDS } from "../fileRules/stopWords.js";
 import { MAX_WELL_KNOWN_REPO_FILES, WELL_KNOWN_REPO_FILE_BASENAMES } from "../fileRules/wellKnownRepoFiles.js";
+import { isPathIgnoredByFolderGlobs } from "../fileRules/ignoredPaths.js";
+import { canExecutePhase, canExecuteRoute, canExecuteScope } from "./guardPolicy.js";
 import chalk from "chalk";
 import path from "path";
 import fs from "fs";
@@ -172,12 +174,12 @@ export class MainAgent {
                 break;
             }
             // ---------------- INFORMATION ACQUISITION ----------------
-            const canRouteSearchExpansion = this.canExecuteRoute("search-expand");
+            const canRouteSearchExpansion = canExecuteRoute(this.context, "search-expand");
             if (!canRouteSearchExpansion) {
                 this.logLine("PLAN", "infoPlanGen", undefined, "skipped (routing disallows search expansion)", { highlight: false });
             }
-            else if (this.canExecutePhase("planning") &&
-                this.canExecuteScope("planning")) {
+            else if (canExecutePhase(this.context, "planning") &&
+                canExecuteScope(this.context, "planning")) {
                 const t = this.startTimer();
                 await infoPlanGenStep.run(this.context);
                 const infoPlan = this.context.analysis?.planSuggestion?.plan ?? { steps: [] };
@@ -208,7 +210,7 @@ export class MainAgent {
      */
     async runResearch() {
         var _a, _b;
-        if (!this.canExecuteRoute("research")) {
+        if (!canExecuteRoute(this.context, "research")) {
             this.logLine("RESEARCH", "taskStepSeed", undefined, "skipped (route disallows research)");
             return;
         }
@@ -298,7 +300,7 @@ export class MainAgent {
         var _a, _b;
         if (!this.context.task)
             return;
-        if (!this.canExecutePhase("planning") || !this.canExecuteScope("planning"))
+        if (!canExecutePhase(this.context, "planning") || !canExecuteScope(this.context, "planning"))
             return;
         (_a = this.context).analysis || (_a.analysis = {});
         (_b = this.context.task).taskSteps || (_b.taskSteps = []);
@@ -478,6 +480,9 @@ export class MainAgent {
             // Step-level iterations
             // ---------------------------
             const stepAction = await this.runStepIterations(taskStep);
+            if (stepAction === "expand-scope") {
+                this.applyScopeExpansionRouteHint();
+            }
             this.finishTaskStep(taskStep, stepCount, stepAction);
         }
         this.logLine("TASK", "Max task step limit reached — stopping work loop", undefined, undefined, { highlight: false });
@@ -517,6 +522,8 @@ export class MainAgent {
                 return "request-feedback";
             if (nextAction === "redo-step")
                 continue;
+            if (nextAction === "expand-scope")
+                return "expand-scope";
         }
         return "continue";
     }
@@ -532,7 +539,7 @@ export class MainAgent {
             await this.executeResearchTaskStep(taskStep);
             return;
         }
-        if (this.canExecutePhase("analysis") && this.canExecuteScope("analysis")) {
+        if (canExecutePhase(this.context, "analysis") && canExecuteScope(this.context, "analysis")) {
             const tAnalysis = this.startTimer();
             await analysisPlanGenStep.run(this.context);
             this.logLine("PLAN", "analysisPlanGen", tAnalysis(), undefined, { highlight: false });
@@ -545,7 +552,9 @@ export class MainAgent {
             if (this.context.analysis)
                 this.context.analysis.planSuggestion = undefined;
         }
-        if (this.canExecutePhase("transform") && this.canExecuteScope("transform")) {
+        if (canExecutePhase(this.context, "transform") &&
+            canExecuteScope(this.context, "transform") &&
+            canExecuteRoute(this.context, "transform")) {
             const tTransform = this.startTimer();
             await transformPlanGenStep.run(this.context);
             this.logLine("PLAN", "transformPlanGen", tTransform(), undefined, { highlight: false });
@@ -558,7 +567,7 @@ export class MainAgent {
             }
             if (this.context.analysis)
                 this.context.analysis.planSuggestion = undefined;
-            if (this.canExecutePhase("write") && this.canExecuteScope("write")) {
+            if (canExecutePhase(this.context, "write") && canExecuteScope(this.context, "write")) {
                 const tWrite = this.startTimer();
                 await writeFileStep.run({ query: this.query, context: this.context });
                 this.logLine("WRITE", "writeFileStep", tWrite());
@@ -1165,6 +1174,8 @@ export class MainAgent {
         const existsOrResearch = (filePath) => {
             if (filePath.startsWith("__research__/"))
                 return true;
+            if (isPathIgnoredByFolderGlobs(filePath))
+                return false;
             return fs.existsSync(filePath);
         };
         let removedRelated = 0;
@@ -1218,7 +1229,7 @@ export class MainAgent {
      */
     getTaskStepBudget() {
         const scope = this.context.analysis?.scopeType ?? "repo-wide";
-        if (this.canExecuteRoute("research"))
+        if (canExecuteRoute(this.context, "research"))
             return 10;
         if (scope === "multi-file")
             return 7;
@@ -1231,7 +1242,7 @@ export class MainAgent {
      * Example: require at least two analyzed files plus one understanding signal.
      */
     isResearchGateSatisfied() {
-        if (!this.canExecuteRoute("research"))
+        if (!canExecuteRoute(this.context, "research"))
             return true;
         const scope = this.context.analysis?.scopeType ?? "repo-wide";
         const researchPlanCount = this.context.task?.taskSteps?.filter(s => typeof s.action === "string" && s.action.startsWith("research-")).length ?? 0;
@@ -1302,29 +1313,45 @@ export class MainAgent {
         this.context.task.status = status;
         this.persistTaskDataForRun();
     }
+    applyScopeExpansionRouteHint() {
+        var _a;
+        (_a = this.context).analysis || (_a.analysis = {});
+        const route = this.context.analysis.routingDecision;
+        if (!route)
+            return;
+        route.decision = "needs-info";
+        route.allowSearch = true;
+        route.scopeLocked = false;
+        route.rationale = `${route.rationale}; stepReasoning=expand-scope`;
+        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 db = getDbForRepo();
+        this.ensureTaskIdentityForPersistence(db);
         this.context.task.currentStep = taskStep;
         taskStep.taskId = this.taskId;
         taskStep.stepIndex = stepCount;
         taskStep.status = "pending";
-        persistTaskStepInsert(taskStep, getDbForRepo());
+        persistTaskStepInsert(taskStep, db);
         const displayPath = this.formatTaskStepDisplayPath(taskStep.filePath);
         this.logLine("NEW STEP", `Processing taskStep ${stepCount}`, undefined, displayPath, { highlight: true });
         taskStep.startTime = Date.now();
-        persistTaskStepStart(taskStep, getDbForRepo());
+        persistTaskStepStart(taskStep, db);
     }
     finishTaskStep(taskStep, stepCount, stepAction) {
+        const db = getDbForRepo();
+        this.ensureTaskIdentityForPersistence(db);
         const displayPath = this.formatTaskStepDisplayPath(taskStep.filePath);
         taskStep.endTime = Date.now();
         if (stepAction === "complete") {
             taskStep.status = "completed";
-            persistTaskStepCompletion(taskStep, getDbForRepo());
+            persistTaskStepCompletion(taskStep, db);
             this.logLine("STEP-DONE", `Completed taskStep ${stepCount}`, undefined, displayPath, { highlight: false });
             return;
         }
         taskStep.status = "pending";
-        persistTaskStepCompletion(taskStep, getDbForRepo());
+        persistTaskStepCompletion(taskStep, db);
         this.logLine("STEP", `Pending taskStep ${stepCount}`, undefined, displayPath);
     }
     /**
@@ -1336,69 +1363,6 @@ export class MainAgent {
             ? filePath.replace("__research__/", "research/")
             : filePath;
     }
-    /* ───────────── execution gates ───────────── */
-    /**
-     * Gate model:
-     * 1) Phase + scope gates decide coarse permissions (what broad work is allowed).
-     * 2) Route gate decides finer sub-decisions within those allowed areas (what to do next).
-     */
-    /**
-     * Gate 1: Is this kind of work allowed at all?
-     * Plain meaning: checks capability rules (e.g. read-only vs file-writing).
-     * Example: for docs-only mode, analysis/planning are blocked, and writes are limited.
-     */
-    canExecutePhase(phase) {
-        const constraints = this.context.executionControl?.constraints;
-        const docsOnly = constraints?.docsOnly ?? false;
-        let allowed = false;
-        switch (phase) {
-            case "analysis":
-            case "planning":
-                allowed = !docsOnly;
-                break;
-            case "transform":
-            case "write":
-                allowed = constraints?.allowFileWrites ?? false;
-                break;
-        }
-        return allowed;
-    }
-    /* ───────────── scope gates ───────────── */
-    /**
-     * Gate 2: Is this work allowed for the current scope size?
-     * Plain meaning: checks scope rules (none/single/multi/repo-wide).
-     * Example: if scope is "analysis", only analysis/planning run and transform/write are blocked.
-     */
-    canExecuteScope(phase) {
-        const scope = this.context.analysis?.scopeType ?? "repo-wide";
-        let allowed = false;
-        switch (scope) {
-            case "none":
-                allowed = phase === "analysis" || phase === "planning";
-                break;
-            default:
-                allowed = true;
-        }
-        return allowed;
-    }
-    /**
-     * Gate 3: Does this request path want this action right now?
-     * Plain meaning: checks route-specific intent from routingDecision.
-     * Example: search expansion is skipped when routing says allowSearch=false.
-     */
-    canExecuteRoute(action) {
-        const routing = this.context.analysis?.routingDecision;
-        switch (action) {
-            case "search-expand":
-                return routing?.allowSearch ?? true;
-            case "transform":
-                return routing?.allowTransform ?? true;
-            case "research":
-                return routing?.allowResearch ?? false;
-            default:
-                return true;
-        }
-    }
     /* ----------------------------------- */
     /* ------------- helpers ------------- */
     /* ----------------------------------- */
@@ -1479,6 +1443,33 @@ export class MainAgent {
             }
         }
     }
+    /**
+     * Ensures the current task id exists in the active DB before step persistence.
+     * Example: if repo/db context switched, re-create task row and rebind step taskIds.
+     */
+    ensureTaskIdentityForPersistence(db) {
+        var _a;
+        const activeTaskId = this.taskId ?? this.context.task?.id;
+        if (!activeTaskId) {
+            this.taskId = bootTaskForRepo(this.context, db, this.logLine.bind(this));
+            this.context.task.id = this.taskId;
+            return;
+        }
+        const row = db.prepare("SELECT id FROM tasks WHERE id = ?").get(activeTaskId);
+        if (row?.id) {
+            this.taskId = activeTaskId;
+            this.context.task.id = activeTaskId;
+            return;
+        }
+        const reboundTaskId = bootTaskForRepo(this.context, db, this.logLine.bind(this));
+        this.taskId = reboundTaskId;
+        this.context.task.id = reboundTaskId;
+        (_a = this.context.task).taskSteps || (_a.taskSteps = []);
+        for (const step of this.context.task.taskSteps) {
+            step.taskId = reboundTaskId;
+        }
+        this.logLine("TASK", "taskId rebound", undefined, `previous=${activeTaskId}, rebound=${reboundTaskId}`);
+    }
 }
 function scoreCandidateFiles(filePaths, relatedFileScores, retrievalQuery) {
     const explicitRefs = extractFileReferences(retrievalQuery, { lowercase: true });

package/dist/agents/fileCheckStep.js

@@ -3,6 +3,7 @@ import { generate } from "../lib/generate.js";
 import { logInputOutput } from "../utils/promptLogHelper.js";
 import { cleanupModule } from "../pipeline/modules/cleanupModule.js";
 import path from "path";
+import { isPathIgnoredByFolderGlobs } from "../fileRules/ignoredPaths.js";
 export async function fileCheckStep(context) {
     var _a;
     context.analysis ?? (context.analysis = {});
@@ -10,9 +11,7 @@ export async function fileCheckStep(context) {
     const intent = context.analysis.intent;
     const planSuggestion = context.analysis.planSuggestion?.text ?? "";
     // Step 1: gather known files from initContext only
-    const knownFiles = new Set([
-        ...(context.initContext?.relatedFiles ?? []),
-    ]);
+    const knownFiles = new Set((context.initContext?.relatedFiles ?? []).filter(filePath => !isPathIgnoredByFolderGlobs(filePath)));
     // Step 2: extract file names from normalizedQuery or planSuggestion
     const extractedFiles = extractFilesFromAnalysis(context.analysis);
     // Step 3: populate focus with safe defaults
@@ -138,16 +137,25 @@ Task:
         // Merge parsed output safely
         if (Array.isArray(parsed.selectedFiles)) {
             const existing = new Set(context.analysis.focus.selectedFiles);
+            const safeSelected = parsed.selectedFiles
+                .filter((f) => typeof f === "string" && knownFiles.has(f) && !isPathIgnoredByFolderGlobs(f));
             context.analysis.focus.selectedFiles = [
                 ...context.analysis.focus.selectedFiles,
-                ...parsed.selectedFiles.filter((f) => !existing.has(f))
+                ...safeSelected.filter((f) => !existing.has(f))
             ];
         }
         if (Array.isArray(parsed.candidateFiles)) {
             const existing = new Set(context.analysis.focus.candidateFiles);
+            const safeCandidates = parsed.candidateFiles
+                .filter((f) => typeof f === "string")
+                .filter((f) => {
+                if (knownFiles.has(f))
+                    return !isPathIgnoredByFolderGlobs(f);
+                return /^[\w\-./]+\.(js|ts|jsx|tsx|py|java|go|rs|cpp|c|cs|md)$/i.test(f);
+            });
             context.analysis.focus.candidateFiles = [
                 ...context.analysis.focus.candidateFiles,
-                ...parsed.candidateFiles.filter((f) => !existing.has(f))
+                ...safeCandidates.filter((f) => !existing.has(f))
             ];
         }
         if (typeof parsed.rationale === "string") {

package/dist/agents/guardPolicy.js

@@ -0,0 +1,43 @@
+/**
+ * Gate 1: capability constraints (execution control).
+ */
+export function canExecutePhase(context, phase) {
+    const constraints = context.executionControl?.constraints;
+    const docsOnly = constraints?.docsOnly ?? false;
+    switch (phase) {
+        case "analysis":
+        case "planning":
+            return !docsOnly;
+        case "transform":
+        case "write":
+            return constraints?.allowFileWrites ?? false;
+        default:
+            return false;
+    }
+}
+/**
+ * Gate 2: scope constraints (none/single/multi/repo-wide).
+ */
+export function canExecuteScope(context, phase) {
+    const scope = context.analysis?.scopeType ?? "repo-wide";
+    if (scope === "none") {
+        return phase === "analysis" || phase === "planning";
+    }
+    return true;
+}
+/**
+ * Gate 3: route constraints (dynamic routing decisions).
+ */
+export function canExecuteRoute(context, action) {
+    const routing = context.analysis?.routingDecision;
+    switch (action) {
+        case "search-expand":
+            return routing?.allowSearch ?? true;
+        case "transform":
+            return routing?.allowTransform ?? true;
+        case "research":
+            return routing?.allowResearch ?? false;
+        default:
+            return true;
+    }
+}

package/dist/commands/FindCmd.js

@@ -1,5 +1,5 @@
 import { queryFiles } from '../db/fileIndex.js';
-import { sanitizeQueryForFts } from '../utils/sanitizeQuery.js';
+import { compileSearchQuery } from '../utils/compileSearchQuery.js';
 import path from 'path';
 import os from 'os';
 export async function runFindCommand(query) {
@@ -8,8 +8,8 @@ export async function runFindCommand(query) {
         return;
     }
     console.log(`\n🔍 Searching for: "${query}"\n`);
-    const sanitizedQuery = sanitizeQueryForFts(query);
-    const results = queryFiles(sanitizedQuery);
+    const compiled = compileSearchQuery({ query, mode: "fts" });
+    const results = compiled.fts.expression ? queryFiles(compiled.fts.expression) : [];
     if (results.length === 0) {
         console.log('⚠️ No matching files found.');
         return;

package/dist/commands/SummaryCmd.js

@@ -4,7 +4,7 @@ import readline from 'readline';
 import { queryFiles } from '../db/fileIndex.js';
 import { summaryModule } from '../pipeline/modules/summaryModule.js';
 import { detectFileType } from '../fileRules/detectFileType.js';
-import { sanitizeQueryForFts } from '../utils/sanitizeQuery.js';
+import { compileSearchQuery } from '../utils/compileSearchQuery.js';
 import { styleText } from '../utils/outputFormatter.js';
 import { indexFile } from '../daemon/runIndexingBatch.js';
 export async function summarizeFile(filepath) {
@@ -12,8 +12,8 @@ export async function summarizeFile(filepath) {
     let filePathResolved;
     // 📁 Resolve file path from index or local disk
     if (filepath) {
-        const sanitizedQuery = sanitizeQueryForFts(filepath);
-        const matches = queryFiles(sanitizedQuery);
+        const compiled = compileSearchQuery({ query: filepath, mode: "fts" });
+        const matches = compiled.fts.expression ? queryFiles(compiled.fts.expression) : [];
         if (matches.length > 0) {
             const topMatch = matches[0];
             filePathResolved = path.resolve(process.cwd(), topMatch.path);
@@ -34,7 +34,8 @@ export async function summarizeFile(filepath) {
     }
     // 📄 Load file content (from path or stdin)
     if (filePathResolved) {
-        const matches = queryFiles(`"${filePathResolved}"`);
+        const compiled = compileSearchQuery({ query: filePathResolved, mode: "fts" });
+        const matches = compiled.fts.expression ? queryFiles(compiled.fts.expression) : [];
         const match = matches.find(row => path.resolve(row.path) === filePathResolved);
         if (match?.summary) {
             console.log(`🧠 Cached summary for ${filepath}:\n`);

package/dist/db/fileIndex.js

@@ -15,9 +15,8 @@ import * as sqlTemplates from '../db/sqlTemplates.js';
 import { RELATED_FILES_LIMIT } from '../constants.js';
 import { generate } from '../lib/generate.js';
 import { logInputOutput } from '../utils/promptLogHelper.js';
-import { sanitizeQueryForFts } from '../utils/sanitizeQuery.js';
+import { compileSearchQuery } from '../utils/compileSearchQuery.js';
 import { extractTaggedContent } from '../utils/parseTaggedContent.js';
-import { extractFileReferences } from '../utils/extractFileReferences.js';
 const QUERY_OPERATOR_TOKENS = new Set(["or", "and", "not", "near"]);
 const GENERIC_FTS_TERMS = new Set([
     "file",
@@ -659,12 +658,14 @@ export async function plannerSearchFiles(originalQuery, query, topK = 5) {
     const db = getDbForRepo();
     const seen = new Map();
     const usedQueries = [];
-    const safeQuery = sanitizeQueryForFts(query);
+    const compiledPrimary = compileSearchQuery({ query, mode: "fts" });
+    const safeQuery = compiledPrimary.fts.expression;
     if (safeQuery)
         usedQueries.push(safeQuery);
-    const primaryResults = db
-        .prepare(sqlTemplates.searchFilesTemplate)
-        .all(safeQuery, RELATED_FILES_LIMIT);
+    const primaryResults = safeQuery
+        ? db.prepare(sqlTemplates.searchFilesTemplate)
+            .all(safeQuery, RELATED_FILES_LIMIT)
+        : [];
     primaryResults.forEach(r => seen.set(r.id, r));
     logInputOutput("plannerSearchFiles primary FTS", "input", {
         safeQuery,
@@ -673,12 +674,12 @@ export async function plannerSearchFiles(originalQuery, query, topK = 5) {
     if (primaryResults.length === 0) {
         const stmt = db.prepare(sqlTemplates.searchFilesTemplate);
         const llmPrimaryQuery = await generatePrimaryFtsQuery(originalQuery);
-        const llmFallbackQueries = await generateFallbackFtsQueries(originalQuery, llmPrimaryQuery || safeQuery);
+        const llmFallbackQueries = await generateFallbackFtsQueries(originalQuery, llmPrimaryQuery || safeQuery || originalQuery);
         const candidateQueries = [];
         const pushCandidate = (q) => {
             if (!q)
                 return;
-            const sanitized = sanitizeQueryForFts(q);
+            const sanitized = compileSearchQuery({ query: q, mode: "fts" }).fts.expression;
             if (!sanitized)
                 return;
             if (sanitized === safeQuery)
@@ -764,8 +765,12 @@ function buildQueryExpansionTerms(originalQuery, queries) {
  * - output: "\"fileIndex.ts\" OR semanticsearchfiles* OR output*"
  */
 function enforceFtsQueryPolicy(userQuery, candidateQuery, maxTerms, intent = {}) {
-    const safe = sanitizeQueryForFts(candidateQuery);
-    const candidateTerms = splitOrTerms(safe);
+    const candidateTerms = compileSearchQuery({
+        query: candidateQuery,
+        intent,
+        mode: "fts",
+        maxTerms,
+    }).fts.terms;
     const prioritizedAnchors = buildAnchorTerms(userQuery, intent);
     const hasAnchors = prioritizedAnchors.length > 0;
     const filtered = candidateTerms.filter(term => {
@@ -777,25 +782,17 @@ function enforceFtsQueryPolicy(userQuery, candidateQuery, maxTerms, intent = {})
         return true;
     });
     const merged = dedupeTerms([...prioritizedAnchors, ...filtered]);
-    return merged.slice(0, maxTerms).join(" OR ");
-}
-/**
- * Splits an OR query into raw terms.
- * Example: "\"fileIndex.ts\" OR semanticsearchfiles* OR output*" ->
- * ["\"fileIndex.ts\"", "semanticsearchfiles*", "output*"]
- */
-function splitOrTerms(query) {
-    return query
-        .split(/\s+OR\s+/i)
-        .map(part => part.trim())
-        .filter(Boolean);
+    return merged
+        .slice(0, maxTerms)
+        .map(term => `${normalizeFtsTerm(term)}*`)
+        .join(" OR ");
 }
 /**
  * Normalizes an FTS term for stable comparisons by removing quotes/wildcards.
  * Example: "\"fileIndex.ts\"" -> "fileindex.ts", "Module*" -> "module"
  */
 function normalizeFtsTerm(term) {
-    return term.replace(/["*]/g, "").toLowerCase().trim();
+    return term.toLowerCase().replace(/[^a-z0-9_]/g, "").trim();
 }
 /**
  * Dedupes terms using normalized keys while preserving first-seen order.
@@ -820,54 +817,10 @@ function dedupeTerms(terms) {
  * - output includes: ["\"fileIndex.ts\"", "semanticsearchfiles*"]
  */
 function buildAnchorTerms(userQuery, intent = {}) {
-    const anchorTerms = [];
-    const explicitFiles = extractFileReferences(userQuery);
-    const targetFiles = Array.isArray(intent.targetFiles)
-        ? dedupeNormalizedStrings(intent.targetFiles)
-        : [];
-    const targetSymbols = Array.isArray(intent.targetSymbols)
-        ? dedupeNormalizedStrings(intent.targetSymbols)
-        : [];
-    for (const fileRef of targetFiles) {
-        for (const matchedFile of extractFileReferences(fileRef)) {
-            const filename = path.basename(matchedFile);
-            if (filename)
-                anchorTerms.push(`"${filename}"`);
-        }
-    }
-    for (const fileRef of explicitFiles) {
-        const filename = path.basename(fileRef);
-        if (filename)
-            anchorTerms.push(`"${filename}"`);
-    }
-    for (const symbol of targetSymbols) {
-        for (const form of buildSymbolSearchForms(symbol)) {
-            const normalized = normalizeFtsTerm(form);
-            if (!normalized)
-                continue;
-            if (QUERY_OPERATOR_TOKENS.has(normalized))
-                continue;
-            if (GENERIC_FTS_TERMS.has(normalized))
-                continue;
-            anchorTerms.push(`${normalized}*`);
-        }
-    }
-    const symbolMatches = userQuery.match(/[A-Za-z_][A-Za-z0-9_]*/g) ?? [];
-    for (const token of symbolMatches) {
-        const isLikelySymbol = /[A-Z]/.test(token) ||
-            token.includes("_") ||
-            token.endsWith("Step") ||
-            token.endsWith("Module");
-        if (!isLikelySymbol)
-            continue;
-        const normalized = token.toLowerCase();
-        if (QUERY_OPERATOR_TOKENS.has(normalized))
-            continue;
-        if (GENERIC_FTS_TERMS.has(normalized))
-            continue;
-        anchorTerms.push(`${normalized}*`);
-    }
-    return dedupeTerms(anchorTerms);
+    const compiled = compileSearchQuery({ query: userQuery, intent, mode: "fts" });
+    const fileTerms = compiled.anchors.files.flatMap(fileRef => compileSearchQuery({ query: path.basename(fileRef), mode: "fts", maxTerms: 8 }).fts.terms);
+    const symbolTerms = compiled.anchors.symbols.flatMap(symbol => compileSearchQuery({ query: symbol, mode: "fts", maxTerms: 8 }).fts.terms);
+    return dedupeTerms([...fileTerms, ...symbolTerms]);
 }
 function dedupeNormalizedStrings(tokens) {
     // Lightweight normalization only (trim + slash normalization + case-insensitive dedupe).
@@ -909,7 +862,7 @@ Question:
         const response = await generate({ content: prompt, query: "" });
         const rawText = String(response.data ?? "");
         const { content } = extractTaggedContent(rawText, "FILE_CONTENT");
-        return sanitizeQueryForFts(content);
+        return compileSearchQuery({ query: content, mode: "fts" }).fts.expression;
     }
     catch {
         return null;

package/dist/fileRules/ignoredPaths.js

@@ -43,3 +43,20 @@ export const IGNORED_FOLDER_GLOBS = [
     '**/debug.log',
     '**/Dockerfile',
 ];
+export const IGNORED_DIR_NAMES = Array.from(new Set(IGNORED_FOLDER_GLOBS
+    .map((pattern) => {
+    const match = pattern.match(/^\*\*\/([^*\/]+)\/\*\*$/);
+    return match?.[1];
+})
+    .filter((name) => !!name)));
+/**
+ * Coarse path guard used by runtime search/selection fallback paths.
+ * Matches the same ignore-glob intent used during indexing.
+ */
+export function isPathIgnoredByFolderGlobs(filePath) {
+    const normalizedPath = String(filePath ?? "").replace(/\\/g, "/");
+    return IGNORED_FOLDER_GLOBS.some((pattern) => {
+        const cleanPattern = pattern.replace(/^\*\*\/?/, "").replace(/\/\*\*$/, "");
+        return cleanPattern.length > 0 && normalizedPath.includes(cleanPattern);
+    });
+}

package/dist/pipeline/modules/fileSearchModule.js

@@ -1,12 +1,14 @@
 // File: src/modules/fileSearchModule.ts
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import path from "path";
 import fs from "fs";
 import { plannerSearchFiles } from "../../db/fileIndex.js";
 import { Config } from "../../config.js";
 import { getDbForRepo } from "../../db/client.js";
 import { IGNORED_EXTENSIONS } from "../../fileRules/ignoredExtensions.js";
+import { IGNORED_DIR_NAMES, isPathIgnoredByFolderGlobs } from "../../fileRules/ignoredPaths.js";
 import { logInputOutput } from "../../utils/promptLogHelper.js";
+import { compileSearchQuery } from "../../utils/compileSearchQuery.js";
 async function fetchSummariesForPaths(paths) {
     if (paths.length === 0)
         return {};
@@ -63,14 +65,32 @@ export const fileSearchModule = {
         // -------------------------------------------------
         if (results.length === 0) {
             try {
-                const exclude = IGNORED_EXTENSIONS
-                    .map(ext => `--exclude=*${ext}`)
-                    .join(" ");
-                const stdout = execSync(`grep -ril ${exclude} "${subQuery}" "${repoRoot}"`, { encoding: "utf8" });
+                const excludeExtArgs = IGNORED_EXTENSIONS.map(ext => `--exclude=*${ext}`);
+                const excludeDirArgs = IGNORED_DIR_NAMES.map(dir => `--exclude-dir=${dir}`);
+                const compiledFallback = compileSearchQuery({ query: subQuery, mode: "auto" });
+                const rgExcludeExtArgs = excludeExtArgs.map(arg => {
+                    const value = arg.replace("--exclude=", "");
+                    return `!${value}`;
+                });
+                const rgExcludeDirArgs = excludeDirArgs.map(arg => {
+                    const value = arg.replace("--exclude-dir=", "");
+                    return `!${value}/**`;
+                });
+                const rgArgs = [
+                    "--files-with-matches",
+                    "--no-messages",
+                    ...rgExcludeDirArgs.flatMap(pattern => ["-g", pattern]),
+                    ...rgExcludeExtArgs.flatMap(pattern => ["-g", pattern]),
+                    ...(compiledFallback.regex.enabled ? [] : ["-F"]),
+                    subQuery,
+                    repoRoot,
+                ];
+                const stdout = execFileSync("rg", rgArgs, { encoding: "utf8" });
                 results = stdout
                     .split("\n")
                     .filter(Boolean)
-                    .map(f => ({ path: f }));
+                    .map(f => ({ path: f }))
+                    .filter(record => !isPathIgnoredByFolderGlobs(record.path));
             }
             catch (err) {
                 if (err?.status !== 1) {

package/dist/pipeline/modules/gatherInfoModule.js

@@ -1,7 +1,7 @@
 // src/pipeline/modules/gatherInfoModule.ts
 import { getDbForRepo } from "../../db/client.js";
 import chalk from "chalk";
-import { sanitizeQueryForFts } from "../../utils/sanitizeQuery.js";
+import { compileSearchQuery } from "../../utils/compileSearchQuery.js";
 import { logInputOutput } from "../../utils/promptLogHelper.js"; // ✅ import logger
 /** Escape % and _ for LIKE queries */
 function sanitizeForLike(input) {
@@ -32,13 +32,15 @@ export const gatherInfoModule = {
             logInputOutput("gatherInfo", "output", stripEmbeddings(emptyOutput)); // ✅
             return emptyOutput;
         }
-        const sanitizedFts = sanitizeQueryForFts(query);
+        const compiled = compileSearchQuery({ query, mode: "fts" });
+        const sanitizedFts = compiled.fts.expression;
         const likeQuery = `%${sanitizeForLike(query)}%`;
         // 🩹 Handle legacy DBs that might not have `functions_extracted`
         let files = [];
         try {
-            files = db
-                .prepare(`
+            if (sanitizedFts) {
+                files = db
+                    .prepare(`
           SELECT f.id, f.path, f.type, f.summary, f.embedding,
                  f.last_modified, f.indexed_at,
                  COALESCE(f.functions_extracted, 0) AS functions_extracted,
@@ -49,12 +51,14 @@ export const gatherInfoModule = {
           ORDER BY f.path ASC
           LIMIT ?;
         `)
-                .all(maxFiles);
+                    .all(maxFiles);
+            }
         }
         catch (err) {
             console.warn(chalk.yellow("⚠️ 'functions_extracted' column missing in files table, running fallback query..."));
-            files = db
-                .prepare(`
+            if (sanitizedFts) {
+                files = db
+                    .prepare(`
           SELECT f.id, f.path, f.type, f.summary, f.embedding,
                  f.last_modified, f.indexed_at, f.processing_status
           FROM files f
@@ -63,7 +67,8 @@ export const gatherInfoModule = {
           ORDER BY f.path ASC
           LIMIT ?;
         `)
-                .all(maxFiles);
+                    .all(maxFiles);
+            }
         }
         const functions = db
             .prepare(`

package/dist/utils/compileSearchQuery.js

@@ -0,0 +1,138 @@
+import path from "path";
+import { STOP_WORDS } from "../fileRules/stopWords.js";
+import { extractFileReferences } from "./extractFileReferences.js";
+const QUERY_OPERATOR_TOKENS = new Set(["or", "and", "not", "near"]);
+const GENERIC_FTS_TERMS = new Set([
+    "file",
+    "files",
+    "code",
+    "source",
+    "repository",
+    "result",
+    "results",
+    "output",
+    "entry",
+    "database",
+    "configuration",
+]);
+const SYMBOL_HINT_SUFFIXES = ["step", "module", "service", "controller", "handler", "manager"];
+export function compileSearchQuery(args) {
+    const rawQuery = String(args.query ?? "").trim();
+    const intent = args.intent ?? {};
+    const mode = args.mode ?? "auto";
+    const maxTerms = Math.max(1, args.maxTerms ?? 12);
+    const fileRefs = dedupeNormalizedStrings([
+        ...extractFileReferences(rawQuery),
+        ...collectIntentFileRefs(intent),
+    ]);
+    const symbolRefs = dedupeNormalizedStrings([
+        ...collectIntentSymbols(intent),
+        ...extractLikelySymbols(rawQuery),
+    ]);
+    const anchorFileTerms = fileRefs.flatMap(ref => toSearchTerms(path.basename(ref)));
+    const anchorSymbolTerms = symbolRefs.flatMap(ref => toSearchTerms(ref));
+    const baseTerms = dedupeNormalizedStrings([
+        ...toSearchTerms(rawQuery),
+        ...anchorFileTerms,
+        ...anchorSymbolTerms,
+    ]);
+    const droppedTerms = [];
+    const filteredTerms = baseTerms.filter(term => {
+        if (term.length < 2) {
+            droppedTerms.push(term);
+            return false;
+        }
+        if (STOP_WORDS.has(term) || QUERY_OPERATOR_TOKENS.has(term)) {
+            droppedTerms.push(term);
+            return false;
+        }
+        return true;
+    });
+    const hasAnchors = anchorFileTerms.length > 0 || anchorSymbolTerms.length > 0;
+    const ftsTerms = dedupeNormalizedStrings(filteredTerms.filter(term => !(hasAnchors && GENERIC_FTS_TERMS.has(term)))).slice(0, maxTerms);
+    const literalTerms = dedupeNormalizedStrings([
+        rawQuery,
+        ...fileRefs,
+        ...symbolRefs,
+        ...filteredTerms,
+    ]).filter(Boolean);
+    const regexEnabled = mode === "regex" || (mode === "auto" && looksLikeRegex(rawQuery));
+    return {
+        rawQuery,
+        mode,
+        anchors: {
+            files: fileRefs,
+            symbols: symbolRefs,
+        },
+        fts: {
+            terms: ftsTerms,
+            expression: ftsTerms.length > 0 ? ftsTerms.map(term => `${term}*`).join(" OR ") : null,
+        },
+        literal: {
+            terms: literalTerms,
+        },
+        regex: {
+            terms: regexEnabled ? [rawQuery].filter(Boolean) : [],
+            enabled: regexEnabled,
+        },
+        diagnostics: {
+            droppedTerms,
+        },
+    };
+}
+function collectIntentFileRefs(intent) {
+    if (!Array.isArray(intent.targetFiles))
+        return [];
+    return intent.targetFiles
+        .map(entry => String(entry ?? "").trim())
+        .filter(Boolean);
+}
+function collectIntentSymbols(intent) {
+    if (!Array.isArray(intent.targetSymbols))
+        return [];
+    return intent.targetSymbols
+        .map(entry => String(entry ?? "").trim())
+        .filter(Boolean);
+}
+function dedupeNormalizedStrings(tokens) {
+    const out = [];
+    const seen = new Set();
+    for (const token of tokens) {
+        if (typeof token !== "string")
+            continue;
+        const normalized = token.trim().replace(/\\/g, "/");
+        if (!normalized)
+            continue;
+        const key = normalized.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(normalized);
+    }
+    return out;
+}
+function extractLikelySymbols(input) {
+    const matches = String(input ?? "").match(/[A-Za-z_][A-Za-z0-9_]{2,}/g) ?? [];
+    const out = new Set();
+    for (const token of matches) {
+        const lowered = token.toLowerCase();
+        const looksLikeSymbol = /[A-Z]/.test(token) ||
+            token.includes("_") ||
+            SYMBOL_HINT_SUFFIXES.some(suffix => lowered.endsWith(suffix));
+        if (!looksLikeSymbol)
+            continue;
+        out.add(token);
+    }
+    return Array.from(out);
+}
+function toSearchTerms(input) {
+    const matches = String(input ?? "")
+        .toLowerCase()
+        .match(/[a-z0-9_]{2,}/g) ?? [];
+    return Array.from(new Set(matches));
+}
+function looksLikeRegex(input) {
+    if (!input)
+        return false;
+    return /[\[\]{}()+?|\\.^$]/.test(input);
+}

package/dist/utils/resolveTargetsToFiles.js

@@ -1,8 +1,11 @@
 import fs from "fs/promises";
 import path from "path";
+import { isPathIgnoredByFolderGlobs } from "../fileRules/ignoredPaths.js";
 export async function resolveTargetsToFiles(targets, exts) {
     const files = [];
     for (const target of targets) {
+        if (isPathIgnoredByFolderGlobs(target))
+            continue;
         const stat = await fs.stat(target);
         if (stat.isDirectory()) {
             files.push(...await collectFilesRecursive(target, exts));
@@ -18,6 +21,8 @@ async function collectFilesRecursive(dir, exts) {
     const files = [];
     for (const entry of entries) {
         const fullPath = path.join(dir, entry.name);
+        if (isPathIgnoredByFolderGlobs(fullPath))
+            continue;
         if (entry.isDirectory()) {
             files.push(...await collectFilesRecursive(fullPath, exts));
         }

package/package.json

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