flowseeker 0.1.7 → 0.1.8

package/dist/index/workspaceIndex.js

@@ -36,15 +36,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadOrBuildWorkspaceIndex = loadOrBuildWorkspaceIndex;
 exports.selectIndexCandidates = selectIndexCandidates;
 exports.clearNodeWorkspaceIndex = clearNodeWorkspaceIndex;
+const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const dependencyExtractor_1 = require("./dependencyExtractor");
 const fileDiscovery_1 = require("./fileDiscovery");
+const embeddingIndex_1 = require("./embeddingIndex");
+const graphIndex_1 = require("./graphIndex");
 const structuredExtractor_1 = require("./structuredExtractor");
+const treeSitterExtractor_1 = require("./treeSitterExtractor");
+const retrievalFusion_1 = require("../pipeline/retrievalFusion");
 const text_1 = require("../utils/text");
 const fileScanner_1 = require("../pipeline/fileScanner");
 const subsystem_1 = require("../pipeline/subsystem");
-const indexVersion = 6;
+const indexVersion = 7;
+const regexExtractorVersion = "structured-regex-mvp-1";
+const treeSitterExtractorVersion = "tree-sitter-mvp-1";
+const chunkerVersion = "symbol-range-mvp-1";
+const graphVersion = "indexed-edges-mvp-1";
 const tokenLimitPerFile = 2500;
 async function loadOrBuildWorkspaceIndex(rootPath, config, options = {}) {
     const startedAt = options.startedAt ?? Date.now();
@@ -54,6 +63,8 @@ async function loadOrBuildWorkspaceIndex(rootPath, config, options = {}) {
     const currentFingerprint = fingerprintConfig(config);
     const reusablePriorIndex = priorIndex?.configFingerprint === currentFingerprint ? priorIndex : undefined;
     const priorByPath = new Map((reusablePriorIndex?.files ?? []).map((file) => [file.relativePath, file]));
+    const discoveredPathSet = new Set(discovery.files.map((file) => file.relativePath));
+    const deletedFiles = (reusablePriorIndex?.files ?? []).filter((file) => !discoveredPathSet.has(file.relativePath)).length;
     const files = [];
     let reusedFiles = 0;
     let updatedFiles = 0;
@@ -104,29 +115,58 @@ async function loadOrBuildWorkspaceIndex(rootPath, config, options = {}) {
         configFingerprint: currentFingerprint,
         files
     };
-    await writeIndex(resolvedRoot, index);
+    if (!options.readOnly) {
+        await writeIndex(resolvedRoot, index);
+    }
     return {
         index,
         discoveredFiles: discovery.files.length,
         reusedFiles,
         updatedFiles,
+        deletedFiles,
         indexedBytes: files.reduce((sum, file) => sum + file.size, 0),
         indexedTokens: files.reduce((sum, file) => sum + (file.tokenCount ?? Math.ceil(file.size / 4)), 0),
         stopReason
     };
 }
-function selectIndexCandidates(index, profile, config) {
+async function selectIndexCandidates(index, profile, config) {
     const terms = (0, fileScanner_1.getWeightedTerms)(profile);
     if (terms.length === 0) {
-        return [];
+        return { files: [], semanticStatus: "disabled", deepCandidateDiscoveryCandidates: 0, deepCandidateDiscoveryAdded: 0, deepCandidateDiscoveryAvoidBlocked: 0, semanticEmbeddedFiles: 0, semanticCacheHits: 0, semanticCacheMisses: 0, semanticHitCount: 0, semanticAddedFileCount: 0, semanticSupportedFileCount: 0 };
     }
-    const scored = index.files
-        .map((file) => ({
-        file,
-        score: scoreIndexedFile(file, terms, profile)
+    const baseHits = buildIndexChannelHits(index.files, terms, profile);
+    const semanticResult = await (0, embeddingIndex_1.searchSemanticFiles)(index.rootPath, index, profile.normalizedTask || profile.rawTask, config);
+    // Only add semantic hits for files NOT already discovered by other channels.
+    // This prevents semantic from modifying the ranking of lexically-discovered files.
+    const discoveredFiles = new Set(baseHits.map((h) => h.relativePath));
+    // Track semantic contributions + evidence for supported lexical files
+    let semanticAddedFileCount = 0;
+    let semanticSupportedFileCount = 0;
+    const semanticSupportByPath = new Map();
+    const semanticDiscoveryByPath = new Map();
+    semanticResult.hits.forEach((hit, rank) => {
+        if (discoveredFiles.has(hit.relativePath)) {
+            semanticSupportedFileCount++;
+            semanticSupportByPath.set(hit.relativePath, { score: hit.score, rank: rank + 1 });
+            return; // supported existing file but don't modify ranking
+        }
+        semanticAddedFileCount++;
+        semanticDiscoveryByPath.set(hit.relativePath, { score: hit.score, rank: rank + 1 });
+        baseHits.push({
+            channel: "semantic_vector",
+            relativePath: hit.relativePath,
+            score: hit.score,
+            rank: rank + 1,
+            reason: `semantic vector similarity ${hit.score.toFixed(3)} rank=${rank + 1} discovered by semantic`
+        });
+    });
+    const fused = (0, retrievalFusion_1.fuseRetrievalChannelHits)(baseHits);
+    const scored = fused
+        .map((candidate) => ({
+        candidate,
+        file: index.files.find((file) => file.relativePath === candidate.relativePath)
     }))
-        .filter((item) => item.score > 0)
-        .sort((left, right) => right.score - left.score);
+        .filter((item) => Boolean(item.file));
     const selected = new Map();
     const maxCandidates = config.index.maxIndexedCandidateFiles;
     const maxSeeds = Math.min(config.index.maxSeedCandidateFiles, maxCandidates);
@@ -134,6 +174,8 @@ function selectIndexCandidates(index, profile, config) {
     for (const seed of seeds) {
         selected.set(seed.relativePath, seed);
     }
+    const candidateTrace = new Map(scored.map((item) => [item.file.relativePath, item.candidate]));
+    const graphReasons = new Map();
     if (config.index.enableDependencyExpansion && selected.size < maxCandidates) {
         const maxExpansion = Math.min(config.index.maxDependencyExpansionFiles, maxCandidates - selected.size);
         let expanded = 0;
@@ -147,16 +189,164 @@ function selectIndexCandidates(index, profile, config) {
             }
         }
     }
+    if (config.index.enableDependencyExpansion && selected.size < maxCandidates) {
+        const graphBudget = Math.min(25, maxCandidates - selected.size);
+        for (const related of (0, graphIndex_1.expandIndexedGraph)(index, seeds.map((seed) => seed.relativePath), { maxAddedFiles: graphBudget })) {
+            if (selected.size >= maxCandidates) {
+                break;
+            }
+            selected.set(related.file.relativePath, related.file);
+            graphReasons.set(related.file.relativePath, [...(graphReasons.get(related.file.relativePath) ?? []), related.reason]);
+        }
+    }
+    // Attach semantic support evidence to lexically-discovered files (evidence-only, no ranking change)
+    for (const [relPath, semInfo] of semanticSupportByPath) {
+        if (selected.has(relPath)) {
+            const reasons = graphReasons.get(relPath) ?? [];
+            reasons.push("semantic_vector: similarity " + semInfo.score.toFixed(3) + " rank=" + semInfo.rank + " supported existing candidate");
+            graphReasons.set(relPath, reasons);
+        }
+    }
+    // Attach semantic discovered evidence to selected files
+    for (const [relPath, semInfo] of semanticDiscoveryByPath) {
+        if (selected.has(relPath)) {
+            const reasons = graphReasons.get(relPath) ?? [];
+            reasons.push("semantic_vector: similarity " + semInfo.score.toFixed(3) + " rank=" + semInfo.rank + " discovered by semantic");
+            graphReasons.set(relPath, reasons);
+        }
+    }
+    // Semantic candidate expansion: adds new files from semantic search that
+    // lexical channels missed. Used with fusion isolation (semantic hits only
+    // for undiscovered files) to avoid modifying lexical ranking of known files.
+    if (semanticResult.hits.length > 0 && selected.size < maxCandidates &&
+        semanticResult.providerName !== "deterministicTest") {
+        const semanticBudget = Math.min(40, maxCandidates - selected.size);
+        let added = 0;
+        for (const hit of semanticResult.hits) {
+            if (added >= semanticBudget || selected.size >= maxCandidates)
+                break;
+            const file = index.files.find((f) => f.relativePath === hit.relativePath);
+            if (!file || selected.has(file.relativePath))
+                continue;
+            if (isExpansionAvoidPath(file.relativePath))
+                continue;
+            selected.set(file.relativePath, file);
+            added++;
+            graphReasons.set(file.relativePath, [...(graphReasons.get(file.relativePath) ?? []), `semantic vector similarity ${hit.score.toFixed(3)} rank=${added} discovered by semantic`]);
+        }
+    }
+    // Deep candidate discovery: scan indexed files NOT already selected
+    // for files with 3+ independent deterministic evidence signals.
+    // Always evaluates for telemetry. Adds at most 3 (or replaces if pool full).
+    let deepCandidateDiscoveryCandidates = 0;
+    let deepCandidateDiscoveryAdded = 0;
+    let deepCandidateDiscoveryAvoidBlocked = 0;
+    // Always evaluate for telemetry, regardless of pool capacity
+    const allCandidates = discoverDeepCandidates(index.files, selected, profile, terms, 999);
+    deepCandidateDiscoveryCandidates = allCandidates.length;
+    if (allCandidates.length > 0) {
+        if (selected.size < maxCandidates) {
+            // Pool has space: add directly
+            const deepBudget = Math.min(3, maxCandidates - selected.size);
+            const addedCandidates = allCandidates.slice(0, deepBudget);
+            deepCandidateDiscoveryAdded = addedCandidates.length;
+            for (const dc of addedCandidates) {
+                selected.set(dc.file.relativePath, dc.file);
+                graphReasons.set(dc.file.relativePath, [...(graphReasons.get(dc.file.relativePath) ?? []), dc.reason]);
+            }
+        }
+        else {
+            // Pool is full: replace up to 3 lowest-priority non-required below top7
+            const requiredSlots = new Set(profile.blueprint.requiredSlots);
+            const selectedArr = Array.from(selected.entries()); // [path, file][]
+            const maxReplace = Math.min(3, allCandidates.length);
+            // Build replacement targets: indices >= 7 where the file is not a sole required-slot occupant
+            const slotOccupants = new Map();
+            for (const [, file] of selectedArr) {
+                const role = classifyDeepPathRole(file.relativePath);
+                if (role)
+                    slotOccupants.set(role, (slotOccupants.get(role) ?? 0) + 1);
+            }
+            // Find replaceable indices (7+, non-sole-required, lowest priority = highest index)
+            const replaceTargets = [];
+            for (let i = selectedArr.length - 1; i >= 7 && replaceTargets.length < maxReplace; i--) {
+                const [, file] = selectedArr[i];
+                const role = classifyDeepPathRole(file.relativePath);
+                const isSoleRequired = role && requiredSlots.has(role) && (slotOccupants.get(role) ?? 0) <= 1;
+                if (!isSoleRequired) {
+                    replaceTargets.push(i);
+                }
+            }
+            let added = 0;
+            for (const dc of allCandidates) {
+                if (added >= maxReplace || added >= replaceTargets.length)
+                    break;
+                const targetIdx = replaceTargets[added];
+                const [oldPath] = selectedArr[targetIdx];
+                selected.delete(oldPath);
+                selected.set(dc.file.relativePath, dc.file);
+                graphReasons.set(dc.file.relativePath, [...(graphReasons.get(dc.file.relativePath) ?? []), dc.reason + " (replaced pool-full slot)"]);
+                added++;
+            }
+            deepCandidateDiscoveryAdded = added;
+        }
+    }
     for (const item of scored) {
         if (selected.size >= maxCandidates) {
             break;
         }
         selected.set(item.file.relativePath, item.file);
     }
-    return Array.from(selected.values()).map((item) => ({
-        absolutePath: path.join(index.rootPath, item.relativePath),
-        relativePath: item.relativePath
-    }));
+    return {
+        files: Array.from(selected.values()).map((item) => {
+            const trace = candidateTrace.get(item.relativePath);
+            const graphTrace = graphReasons.get(item.relativePath) ?? [];
+            return {
+                absolutePath: path.join(index.rootPath, item.relativePath),
+                relativePath: item.relativePath,
+                channelHits: trace?.channelHits,
+                retrievalTrace: trace?.reasons,
+                graphReasons: graphTrace
+            };
+        }),
+        semanticStatus: semanticResult.status,
+        semanticErrorType: semanticResult.errorType,
+        semanticErrorMessage: semanticResult.errorMessage,
+        semanticEmbeddedFiles: semanticResult.embeddedFiles,
+        semanticCacheHits: semanticResult.cacheHits,
+        semanticCacheMisses: semanticResult.cacheMisses,
+        semanticHitCount: semanticResult.hits.length,
+        semanticAddedFileCount,
+        semanticSupportedFileCount,
+        deepCandidateDiscoveryCandidates,
+        deepCandidateDiscoveryAdded,
+        deepCandidateDiscoveryAvoidBlocked
+    };
+}
+function isExpansionAvoidPath(normalizedPath) {
+    const p = normalizedPath.replace(/\\/g, "/").toLowerCase();
+    // Helper/util/console/command files
+    if (/(^|\/)(helpers?|utils?|console|commands?|scripts?|tasks?)(\/|$)/.test(p))
+        return true;
+    // Admin/dashboard surfaces
+    if (/(^|\/)(admin|dashboard)(\/|$)/.test(p))
+        return true;
+    // Lock files
+    if (/(package-lock|yarn\.lock|pnpm-lock|composer\.lock|Gemfile\.lock|poetry\.lock|cargo\.lock)$/.test(p))
+        return true;
+    // Templates/views
+    if (/(^|\/)(views?|templates?|resources\/views)(\/|$)|\.(blade\.php|twig|erb|hbs|ejs)$/.test(p))
+        return true;
+    // Generated/snapshot
+    if (/(^|\/)(generated|__generated__|gen|codegen|snapshots?)(\/|$)|\.snap$|\.generated\./.test(p))
+        return true;
+    // Static assets
+    if (/(^|\/)(public|assets?|static|images?|fonts?)(\/|$)|\.(css|scss|less|svg|png|jpe?g|gif|ico|woff2?)$/.test(p))
+        return true;
+    // Notification/mail files unless specific pattern match
+    if (/(^|\/)(notifications?|mail|email)(\/|$)/.test(p))
+        return true;
+    return false;
 }
 function findDependencyRelatedFiles(files, seeds, maxResults) {
     const lookup = buildDependencyLookup(files);
@@ -291,8 +481,11 @@ async function indexFile(discovered, prior, config) {
     if (stat.size > config.project.maxFileSizeKb * 1024) {
         return undefined;
     }
-    if (prior && prior.size === stat.size && prior.mtimeMs === stat.mtimeMs) {
-        return { file: prior, reused: true };
+    const language = (0, structuredExtractor_1.detectLanguage)(discovered.relativePath);
+    const useTreeSitter = config.index.enableTreeSitter && language != null && (0, treeSitterExtractor_1.supportsTreeSitterLanguage)(language);
+    const effectiveExtractorVersion = useTreeSitter ? treeSitterExtractorVersion : regexExtractorVersion;
+    if (prior && prior.size === stat.size && prior.mtimeMs === stat.mtimeMs && prior.extractorVersion === effectiveExtractorVersion && prior.chunkerVersion === chunkerVersion && prior.graphVersion === graphVersion) {
+        return { file: { ...prior, parserKind: prior.parserKind || (useTreeSitter ? "tree-sitter" : "structured-regex"), parserVersion: prior.parserVersion || effectiveExtractorVersion, symbolCount: prior.symbolCount ?? prior.symbols.length, graphEdgeCount: prior.graphEdgeCount ?? prior.edges.length, indexedAt: prior.indexedAt || new Date().toISOString() }, reused: true };
     }
     let content;
     try {
@@ -304,10 +497,24 @@ async function indexFile(discovered, prior, config) {
     if (content.includes("\u0000")) {
         return undefined;
     }
-    const structuredNodes = extractStructuredNodesForIndex(discovered.relativePath, content);
-    const symbols = extractSymbols(structuredNodes);
+    const contentHash = hashText(content);
+    if (prior && prior.contentHash === contentHash && prior.extractorVersion === effectiveExtractorVersion && prior.chunkerVersion === chunkerVersion && prior.graphVersion === graphVersion) {
+        return {
+            file: {
+                ...prior,
+                size: stat.size,
+                mtimeMs: stat.mtimeMs
+            },
+            reused: true
+        };
+    }
+    const structuredNodes = config.index.enableTreeSitter ? extractStructuredNodesForIndex(discovered.relativePath, content) : [];
+    const symbols = extractSymbols(structuredNodes, discovered.relativePath);
     const calls = extractCalls(structuredNodes);
     const subsystemTerms = (0, subsystem_1.inferSubsystemTerms)(discovered.relativePath, symbols.map((symbol) => symbol.name));
+    const imports = (0, dependencyExtractor_1.extractImports)(content).map((item) => item.source).slice(0, 50);
+    const chunks = buildIndexedChunks(discovered.relativePath, contentHash, structuredNodes);
+    const edges = buildIndexedEdges(discovered.relativePath, imports, symbols, calls);
     return {
         reused: false,
         file: {
@@ -317,14 +524,116 @@ async function indexFile(discovered, prior, config) {
             language: (0, text_1.languageFromPath)(discovered.relativePath),
             tokenCount: (0, text_1.fastTokenEstimate)(`${discovered.relativePath}\n${content}`),
             tokens: tokenizeForIndex(`${discovered.relativePath}\n${content}\n${symbolText(symbols)}`),
-            imports: (0, dependencyExtractor_1.extractImports)(content).map((item) => item.source).slice(0, 50),
+            imports,
             symbols,
             calls,
+            contentHash,
+            extractorVersion: effectiveExtractorVersion,
+            chunkerVersion,
+            graphVersion,
+            chunks,
+            edges,
             subsystem: subsystemTerms[0],
-            subsystemTerms
+            subsystemTerms,
+            parserKind: useTreeSitter ? "tree-sitter" : "structured-regex",
+            parserVersion: effectiveExtractorVersion,
+            symbolCount: symbols.length,
+            graphEdgeCount: edges.length,
+            indexedAt: new Date().toISOString()
         }
     };
 }
+function buildIndexChannelHits(files, terms, profile) {
+    const hits = [];
+    const channelBuckets = {
+        exact_literal: [],
+        path: [],
+        lexical_content: [],
+        symbol: [],
+        semantic_vector: [],
+        dependency: [],
+        graph: [],
+        editor_context: []
+    };
+    for (const file of files) {
+        const scores = scoreIndexedFileChannels(file, terms, profile);
+        for (const [channel, score] of Object.entries(scores)) {
+            if (score <= 0) {
+                continue;
+            }
+            channelBuckets[channel].push({
+                channel,
+                relativePath: file.relativePath,
+                score,
+                rank: 0,
+                reason: `${channel} score ${score.toFixed(1)}`
+            });
+        }
+    }
+    for (const bucket of Object.values(channelBuckets)) {
+        bucket.sort((left, right) => right.score - left.score);
+        bucket.forEach((hit, index) => {
+            hits.push({ ...hit, rank: index + 1 });
+        });
+    }
+    return hits;
+}
+function scoreIndexedFileChannels(file, terms, profile) {
+    const normalizedPath = (0, text_1.normalizeText)(file.relativePath);
+    const compactPath = normalizedPath.replace(/[^a-z0-9]+/g, "");
+    const normalizedBaseName = (0, text_1.normalizeText)(fileBaseName(file.relativePath));
+    const compactBaseName = normalizedBaseName.replace(/[^a-z0-9]+/g, "");
+    const tokenSet = new Set(file.tokens);
+    const imports = file.imports.map(text_1.normalizeText).join("\n");
+    const symbolNames = file.symbols.map((symbol) => (0, text_1.normalizeText)(symbol.name));
+    const callNames = (file.calls ?? []).map(text_1.normalizeText);
+    const subsystemTerms = file.subsystemTerms ?? [];
+    const taskSubsystems = (0, subsystem_1.inferTaskSubsystemTerms)(profile);
+    const scores = {};
+    const add = (channel, value) => {
+        scores[channel] = (scores[channel] ?? 0) + value;
+    };
+    for (const term of terms) {
+        const normalizedTerm = (0, text_1.normalizeText)(term.term);
+        const compactTerm = normalizedTerm.replace(/[^a-z0-9]+/g, "");
+        if (normalizedPath.includes(normalizedTerm)) {
+            add("path", 6 * term.weight);
+        }
+        if (compactTerm.length >= 5 && compactBaseName.includes(compactTerm)) {
+            add("exact_literal", 18 * term.weight);
+        }
+        if (compactTerm.length >= 5 && compactPath.includes(compactTerm)) {
+            add("path", 8 * term.weight);
+        }
+        if (tokenSet.has(normalizedTerm)) {
+            add("lexical_content", 5 * term.weight);
+        }
+        if (imports.includes(normalizedTerm)) {
+            add("dependency", 2 * term.weight);
+        }
+        if (symbolNames.some((symbol) => symbol === normalizedTerm || symbol.includes(normalizedTerm))) {
+            add("symbol", 5 * term.weight);
+        }
+        if (callNames.some((call) => call === normalizedTerm || call.includes(normalizedTerm))) {
+            add("dependency", 3 * term.weight);
+        }
+        if (subsystemTerms.some((subsystem) => subsystem === normalizedTerm || subsystem.includes(normalizedTerm))) {
+            add("path", 4 * term.weight);
+        }
+    }
+    const subsystemMatches = subsystemTerms.filter((subsystem) => taskSubsystems.some((taskSubsystem) => subsystem === taskSubsystem || subsystem.includes(taskSubsystem) || taskSubsystem.includes(subsystem)));
+    if (subsystemMatches.length > 0) {
+        add("path", 4 + Math.min(10, subsystemMatches.length * 4));
+    }
+    if (wantsSourceCode(profile) && /(^|\/)src\//.test(file.relativePath.replace(/\\/g, "/"))) {
+        add("path", 14);
+    }
+    const pathModifier = pathQualityModifier(file.relativePath);
+    if (pathModifier !== 0) {
+        add("path", pathModifier);
+    }
+    return scores;
+}
 function scoreIndexedFile(file, terms, profile) {
     const normalizedPath = (0, text_1.normalizeText)(file.relativePath);
     const compactPath = normalizedPath.replace(/[^a-z0-9]+/g, "");
@@ -410,6 +719,9 @@ function pathQualityModifier(relativePath) {
     if (/(package-lock\.json|pnpm-lock\.yaml|yarn\.lock|composer\.lock|poetry\.lock|cargo\.lock)$/.test(normalizedPath)) {
         modifier -= 40;
     }
+    if (/(^|\/)(helpers?|utils?|console|commands?|scripts?|tasks?)(\/|$)/.test(normalizedPath) && !/(controller|handler|service|repository|model|route|router|worker|job|listener|command|resolver|middleware|policy|request|resource)/.test(normalizedPath)) {
+        modifier -= 28;
+    }
     return modifier;
 }
 function tokenizeForIndex(text) {
@@ -439,15 +751,83 @@ function extractStructuredNodesForIndex(relativePath, content) {
     }
     return (0, structuredExtractor_1.extractStructuredNodes)(content.slice(0, 200000), language);
 }
-function extractSymbols(nodes) {
+function buildIndexedChunks(relativePath, contentHash, nodes) {
+    const symbolChunks = nodes
+        .filter((node) => node.kind === "declaration" && node.name)
+        .slice(0, 120)
+        .map((node) => ({
+        id: `${relativePath}:${node.range.startLine}-${node.range.endLine}:${node.name}`,
+        relativePath,
+        range: node.range,
+        kind: "symbol",
+        symbolFqn: node.fqn ?? node.name,
+        textHash: contentHash
+    }));
+    if (symbolChunks.length > 0) {
+        return symbolChunks;
+    }
+    return [{
+            id: `${relativePath}:file`,
+            relativePath,
+            range: { startLine: 1, endLine: 1 },
+            kind: inferChunkKind(relativePath),
+            textHash: contentHash
+        }];
+}
+function inferChunkKind(relativePath) {
+    const normalized = relativePath.replace(/\\/g, "/").toLowerCase();
+    if (/\.(md|mdx|txt|rst)$/.test(normalized)) {
+        return "doc";
+    }
+    if (/(^|\/)(config|configs?|settings?)(\/|$)|\.(json|ya?ml|toml|ini|env)$/.test(normalized)) {
+        return "config";
+    }
+    return "file_region";
+}
+function buildIndexedEdges(relativePath, imports, symbols, calls) {
+    const edges = [];
+    for (const importSource of imports.slice(0, 80)) {
+        edges.push({
+            id: `${relativePath}:import:${importSource}`,
+            type: "import",
+            from: relativePath,
+            to: importSource,
+            fromPath: relativePath,
+            toPath: importSource,
+            weight: 0.75,
+            reason: `imports ${importSource}`
+        });
+    }
+    for (const call of calls.slice(0, 120)) {
+        edges.push({
+            id: `${relativePath}:call:${call}`,
+            type: "callee",
+            from: symbols[0]?.fqn ?? relativePath,
+            to: call,
+            fromPath: relativePath,
+            toPath: "",
+            weight: 0.65,
+            reason: `calls ${call}`
+        });
+    }
+    return edges;
+}
+function hashText(text) {
+    return crypto.createHash("sha256").update(text).digest("hex");
+}
+function extractSymbols(nodes, relativePath = "") {
     return nodes
         .filter((node) => node.kind === "declaration" && node.name)
         .slice(0, 80)
         .map((node) => ({
+        id: `${relativePath}:${node.fqn ?? node.name}:${node.range.startLine}`,
         name: node.name ?? "",
-        kind: "declaration",
+        fqn: node.fqn ?? node.name ?? "",
+        kind: node.symbolKind ?? "declaration",
         line: node.range.startLine,
-        exported: node.parent === "exported"
+        endLine: node.range.endLine,
+        exported: node.parent === "exported",
+        parentFqn: node.parentFqn
     }));
 }
 function extractCalls(nodes) {
@@ -486,22 +866,38 @@ function yieldToHost() {
     return new Promise((resolve) => setTimeout(resolve, 0));
 }
 async function readIndex(rootPath) {
+    const filePath = cachePath(rootPath);
     try {
-        const text = await fs.readFile(cachePath(rootPath), "utf8");
+        const text = await fs.readFile(filePath, "utf8");
         const parsed = JSON.parse(text);
         if (parsed.version !== indexVersion || parsed.rootPath !== path.resolve(rootPath)) {
             return undefined;
         }
         return parsed;
     }
-    catch {
+    catch (error) {
+        await moveCorruptIndexAside(filePath, error);
         return undefined;
     }
 }
 async function writeIndex(rootPath, index) {
     const filePath = cachePath(rootPath);
     await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.writeFile(filePath, JSON.stringify(index), "utf8");
+    const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    await fs.writeFile(tempPath, JSON.stringify(index), "utf8");
+    await fs.rename(tempPath, filePath);
+}
+async function moveCorruptIndexAside(filePath, error) {
+    const code = typeof error === "object" && error && "code" in error ? String(error.code) : "";
+    if (code === "ENOENT") {
+        return;
+    }
+    try {
+        await fs.rename(filePath, `${filePath}.corrupt-${Date.now()}`);
+    }
+    catch {
+        // Cache can be rebuilt if corrupt/missing.
+    }
 }
 function cachePath(rootPath) {
     return path.join(path.resolve(rootPath), ".flowseeker", "cache", "workspace-index.json");
@@ -515,4 +911,173 @@ function fingerprintConfig(config) {
         indexVersion
     });
 }
+function discoverDeepCandidates(files, selected, profile, terms, budget) {
+    if (budget <= 0)
+        return [];
+    const results = [];
+    const taskTokens = extractDeepTaskTokens(profile);
+    const taskSubsystems = (0, subsystem_1.inferTaskSubsystemTerms)(profile);
+    const seeds = [...selected.values()].slice(0, 3);
+    const seedDirs = new Set(seeds.map(s => deepDirname(s.relativePath)));
+    for (const file of files) {
+        if (results.length >= budget)
+            break;
+        if (selected.has(file.relativePath))
+            continue;
+        if (isDeepAvoidPath(file.relativePath))
+            continue;
+        const signals = computeDeepSignals(file, taskTokens, taskSubsystems, seedDirs, profile);
+        if (signals.length < 3)
+            continue;
+        const basename = deepBasename(file.relativePath);
+        const reason = `deep_discovery: ${basename} (${signals.length} signals: ${signals.join(", ")})`;
+        results.push({ file, reason, signals });
+    }
+    return results;
+}
+function extractDeepTaskTokens(profile) {
+    const tokens = new Set();
+    const allTerms = [...profile.keywords, ...profile.literalTerms, ...profile.concepts, ...profile.actions, ...profile.entities];
+    for (const term of allTerms) {
+        const n = (0, text_1.normalizeText)(term);
+        if (n.length >= 3)
+            tokens.add(n);
+        // Also split camelCase and snake_case
+        for (const part of splitCamelSnake(n)) {
+            if (part.length >= 3)
+                tokens.add(part);
+        }
+    }
+    return tokens;
+}
+function computeDeepSignals(file, taskTokens, taskSubsystems, seedDirs, profile) {
+    const signals = [];
+    const normalizedPath = (0, text_1.normalizeText)(file.relativePath);
+    const compactPath = normalizedPath.replace(/[^a-z0-9]+/g, "");
+    const normalizedBase = (0, text_1.normalizeText)(deepBasename(file.relativePath));
+    const compactBase = normalizedBase.replace(/[^a-z0-9]+/g, "");
+    const requiredSlots = new Set(profile.blueprint.requiredSlots);
+    // Signal 1: Path token overlap (task term of length >= 4 appears in file path)
+    let pathOverlapCount = 0;
+    for (const token of taskTokens) {
+        if (token.length >= 4 && compactPath.includes(token)) {
+            pathOverlapCount++;
+        }
+    }
+    if (pathOverlapCount >= 1)
+        signals.push("path_token");
+    // Signal 2: Basename overlap (task term in basename, camelCase/snake_split)
+    let baseOverlapCount = 0;
+    for (const token of taskTokens) {
+        if (token.length >= 4 && compactBase.includes(token)) {
+            baseOverlapCount++;
+        }
+    }
+    if (baseOverlapCount >= 1)
+        signals.push("basename_token");
+    // Signal 3: Symbol overlap (file symbols match task terms)
+    const symbolNames = file.symbols.map(s => (0, text_1.normalizeText)(s.name));
+    const symbolOverlap = symbolNames.filter(sym => [...taskTokens].some(t => t.length >= 3 && (sym === t || sym.includes(t))));
+    if (symbolOverlap.length >= 1)
+        signals.push("symbol_match");
+    // Signal 4: Import overlap (file imports match task terms/entities)
+    const importNorms = file.imports.map(text_1.normalizeText);
+    const importOverlap = importNorms.filter(imp => [...taskTokens].some(t => t.length >= 3 && imp.includes(t)));
+    if (importOverlap.length >= 1)
+        signals.push("import_match");
+    // Signal 5: Subsystem match (file subsystem matches task-inferred subsystem)
+    const fileSubsysTerms = file.subsystemTerms ?? [];
+    const subsystemOverlap = fileSubsysTerms.filter(st => taskSubsystems.some(ts => st === ts || st.includes(ts) || ts.includes(st)));
+    if (subsystemOverlap.length >= 1 || (file.subsystem && taskSubsystems.includes((0, text_1.normalizeText)(file.subsystem)))) {
+        signals.push("subsystem_match");
+    }
+    // Signal 6: Slot/role match (path role classification matches required slot)
+    const pathRole = classifyDeepPathRole(file.relativePath);
+    if (pathRole && requiredSlots.has(pathRole)) {
+        signals.push("slot_match");
+    }
+    // Signal 7: Same directory as a seed file
+    const fileDir = deepDirname(file.relativePath);
+    if (seedDirs.has(fileDir)) {
+        signals.push("same_directory");
+    }
+    // Signal 8: Token content overlap (file tokens match task terms)
+    const tokenSet = new Set(file.tokens.map(text_1.normalizeText));
+    const tokenOverlap = [...taskTokens].filter(t => t.length >= 3 && tokenSet.has(t));
+    if (tokenOverlap.length >= 2)
+        signals.push("token_content");
+    return signals;
+}
+function classifyDeepPathRole(relativePath) {
+    const p = relativePath.replace(/\\/g, "/").toLowerCase();
+    if (/(^|\/)(routes?|router)(\/|$)|urlpatterns|urls\.py$|web\.php$|api\.php$|\+page\.|\+server\.|page\.(tsx|jsx|svelte)$/.test(p))
+        return "entry";
+    if (/(^|\/)(controllers?|handlers?)(\/|$)/.test(p))
+        return "handler";
+    if (/(^|\/)(services?|usecases?|domain)(\/|$)/.test(p))
+        return "core_logic";
+    if (/(^|\/)(models?|entities?)(\/|$)|schema\.(ts|js|prisma)$/.test(p))
+        return "data";
+    if (/(^|\/)(migrations?|schema)(\/|$)|\.sql$|\.prisma$/.test(p))
+        return "data";
+    if (/(^|\/)(config|configs?|settings?)(\/|$)|\.(env|toml|ya?ml|ini|json|properties)$/.test(p))
+        return "infrastructure";
+    if (/(^|\/)(jobs?|workers?)(\/|$)/.test(p))
+        return "side_effect";
+    if (/(^|\/)(listeners?|events?)(\/|$)/.test(p))
+        return "side_effect";
+    if (/(^|\/)(notifications?|mail|email)(\/|$)/.test(p))
+        return "side_effect";
+    if (/(^|\/)(components?|views?|templates?|pages?)(\/|$)|\.(svelte|vue|tsx|jsx|blade\.php|twig)$/.test(p))
+        return "ui";
+    if (/(^|\/)(policies?|permissions?|guards?|middleware|auth)(\/|$)/.test(p))
+        return "permission";
+    if (/(^|\/)(tests?|specs?|__tests__)(\/|$)|\.(test|spec)\./.test(p))
+        return "tests";
+    if (/(^|\/)(validators?|validation)(\/|$)/.test(p))
+        return "validation";
+    return null;
+}
+function isDeepAvoidPath(normalizedPath) {
+    const p = normalizedPath.replace(/\\/g, "/").toLowerCase();
+    // Helpers/utils (unless they also match a strong signal)
+    if (/(^|\/)(helpers?|utils?)(\/|$)/.test(p) && !/(controller|handler|service|repository|model|route|router)\b/.test(p))
+        return true;
+    // Lock files
+    if (/(package-lock|yarn\.lock|pnpm-lock|composer\.lock|Gemfile\.lock|poetry\.lock|cargo\.lock)$/.test(p))
+        return true;
+    // Generated/snapshot
+    if (/(^|\/)(generated|__generated__|gen|codegen|snapshots?)(\/|$)|\.snap$|\.generated\./.test(p))
+        return true;
+    // Static assets
+    if (/(^|\/)(public|assets?|static|images?|fonts?)(\/|$)|\.(css|scss|less|svg|png|jpe?g|gif|ico|woff2?)$/.test(p))
+        return true;
+    // Admin/dashboard (unless task targets it)
+    if (/(^|\/)(admin|dashboard)(\/|$)/.test(p))
+        return true;
+    // Templates/views
+    if (/(^|\/)(views?|templates?|resources\/views)(\/|$)|\.(blade\.php|twig|erb|hbs|ejs)$/.test(p))
+        return true;
+    // Console/commands
+    if (/(^|\/)(console|commands?|scheduler|schedulers?|cli)(\/|$)/.test(p))
+        return true;
+    return false;
+}
+function deepDirname(filePath) {
+    return filePath.replace(/\\/g, "/").toLowerCase().split("/").slice(0, -1).join("/");
+}
+function deepBasename(filePath) {
+    return filePath.replace(/\\/g, "/").split("/").pop()?.replace(/\.[^.]+$/, "") || filePath;
+}
+function splitCamelSnake(s) {
+    const parts = [];
+    for (const seg of s.toLowerCase().split(/[_\-]/)) {
+        const camelParts = seg.replace(/([a-z])([A-Z])/g, "$1 $2").split(/[\s.]+/);
+        for (const p of camelParts) {
+            if (p.length >= 3)
+                parts.push(p);
+        }
+    }
+    return [...new Set(parts)];
+}
 //# sourceMappingURL=workspaceIndex.js.map