flowseeker 0.1.7 → 0.1.9

package/dist/pipeline/ranker.js

@@ -1,9 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rankEvidence = rankEvidence;
+exports.classifyPathRole = classifyPathRole;
 const contextBlueprint_1 = require("./contextBlueprint");
 const text_1 = require("../utils/text");
 const subsystem_1 = require("./subsystem");
+// ── P15: taskAnchorCoverage (report-only, no ranking impact) ──
+function computeTaskAnchorCoverage(taskText, matchedTerms) {
+    if (!taskText || taskText.trim().length === 0) {
+        return {
+            anchorHits: [], anchorMisses: [], anchorHitCount: 0, anchorMissCount: 0,
+            anchorRatio: 0, criticalAnchorHits: [], criticalAnchorMisses: [],
+            hasTaskAnchorCoverage: false, coverageReason: "no_task_text"
+        };
+    }
+    const taskTokens = taskText.toLowerCase().replace(/[^a-z0-9À-ɏḀ-ỿ\s]/g, " ").split(/\s+/).filter(t => t.length > 1);
+    const mtLower = matchedTerms.map(t => t.toLowerCase());
+    const criticalTokens = taskTokens.filter(t => t.length > 4);
+    const anchorHits = [];
+    const anchorMisses = [];
+    for (const token of taskTokens) {
+        const found = mtLower.some(mt => mt.includes(token) || token.includes(mt));
+        if (found)
+            anchorHits.push(token);
+        else
+            anchorMisses.push(token);
+    }
+    const criticalAnchorHits = [];
+    const criticalAnchorMisses = [];
+    for (const ct of criticalTokens) {
+        const found = mtLower.some(mt => mt.includes(ct) || ct.includes(mt));
+        if (found)
+            criticalAnchorHits.push(ct);
+        else
+            criticalAnchorMisses.push(ct);
+    }
+    const ratio = taskTokens.length > 0 ? anchorHits.length / taskTokens.length : 0;
+    const reason = mtLower.length === 0 ? "no_matched_terms"
+        : anchorHits.length === 0 ? "no_anchor_match"
+            : anchorHits.length + "/" + taskTokens.length + " task tokens matched";
+    return {
+        anchorHits, anchorMisses, anchorHitCount: anchorHits.length, anchorMissCount: anchorMisses.length,
+        anchorRatio: ratio, criticalAnchorHits, criticalAnchorMisses,
+        hasTaskAnchorCoverage: anchorHits.length > 0, coverageReason: reason
+    };
+}
+function attachTaskAnchorCoverage(units, profile) {
+    if (!profile)
+        return units;
+    const taskText = profile.normalizedTask || profile.rawTask || "";
+    return units.map(u => ({ ...u, taskAnchorCoverage: computeTaskAnchorCoverage(taskText, u.matchedTerms) }));
+}
+function applySupportingContextRoles(units, profile) {
+    if (!profile)
+        return units;
+    const routeTargeted = /\b(route|routing|router|url|endpoint)\b/.test(profile.normalizedTask);
+    const uiTargeted = hasTaskUiTarget(profile);
+    return units.map((unit) => {
+        if (unit.role !== "edit_candidate")
+            return unit;
+        const path = normalizePath(unit.relativePath);
+        const isRouteContext = !routeTargeted && unit.slot === "entry" && /(^|\/)routes?\//.test(path);
+        const isTemplateContext = !uiTargeted && unit.slot === "ui" && isTemplateOnlyPath(path);
+        if (!isRouteContext && !isTemplateContext)
+            return unit;
+        return { ...unit, role: "read_context", reasons: [...unit.reasons, "supporting context file"] };
+    });
+}
 const rolePriority = {
     edit_candidate: 5,
     read_context: 4,
@@ -18,12 +81,20 @@ function rankEvidence(units, config, profile, rankOptions) {
     for (const unit of deduped) {
         fileCounts.set(unit.relativePath, (fileCounts.get(unit.relativePath) ?? 0) + 1);
     }
-    const boosted = deduped.map((unit) => boostUnit(unit, fileCounts, config, profile, rankOptions?.editorContext));
+    const pool = deduped.slice(0, Math.min(80, deduped.length));
+    const genericTerms = computeGenericTerms(pool);
+    const boosted = deduped.map((unit) => boostUnit(unit, fileCounts, config, profile, rankOptions?.editorContext, genericTerms));
     const sorted = boosted.sort(compareUnits);
     if (!profile) {
-        return selectDiverseUnits(sorted, config.pipeline.maxCandidates);
+        const selected = selectDiverseUnits(sorted, config.pipeline.maxCandidates);
+        return attachTaskAnchorCoverage(applySupportingContextRoles(applyAvoidFilter(selected, profile), profile), profile);
+    }
+    const selected = selectWithBlueprintCoverage(sorted, profile, config.pipeline.maxCandidates);
+    const guardResult = applyAvoidAwarePromotion(selected, sorted, profile);
+    if (guardResult.units.length > 0) {
+        guardResult.units[0].__taskAvoidGuardStats = guardResult.stats;
     }
-    return selectWithBlueprintCoverage(sorted, profile, config.pipeline.maxCandidates);
+    return attachTaskAnchorCoverage(applySupportingContextRoles(applyAvoidFilter(guardResult.units, profile), profile), profile);
 }
 function dedupeUnits(units) {
     const byId = new Map();
@@ -92,7 +163,7 @@ function selectWithBlueprintCoverage(sorted, profile, maxCandidates) {
     }
     pushFrameworkCompanions(sorted, state);
     for (const slot of profile.blueprint.requiredSlots) {
-        pushUnit(state, bestUnitForSlot(sorted, slot, state), { allowThirdFileUnit: true });
+        pushUnit(state, bestUnitForSlot(sorted, slot, state), { allowSecondFileUnitEarly: true });
     }
     pushEntityCompanions(sorted, state, profile);
     for (const slot of (0, contextBlueprint_1.allContextSlots)(profile.blueprint)) {
@@ -110,7 +181,458 @@ function selectWithBlueprintCoverage(sorted, profile, maxCandidates) {
     for (const unit of sorted) {
         pushUnit(state, unit);
     }
-    return state.selected.slice(0, maxCandidates);
+    const result = state.selected.slice(0, maxCandidates);
+    return rebalanceSlots(result, sorted, profile, 10);
+}
+function rebalanceSlots(selected, sorted, profile, topK) {
+    if (selected.length < topK + 4)
+        return selected;
+    const topSlots = new Set(selected.slice(0, topK).map((u) => u.slot));
+    const missingSlots = profile.blueprint.requiredSlots.filter((s) => !topSlots.has(s));
+    const result = [...selected];
+    const usedIds = new Set(result.map((u) => u.id));
+    const usedFiles = new Set(result.slice(0, topK).map((u) => u.relativePath));
+    for (const slot of missingSlots) {
+        const candidate = sorted.find((u) => u.slot === slot && !usedIds.has(u.id) && !usedFiles.has(u.relativePath) && !u.contrastContext);
+        if (!candidate)
+            continue;
+        const slotCounts = new Map();
+        for (let i = 0; i < topK; i++)
+            slotCounts.set(result[i].slot ?? "unknown", (slotCounts.get(result[i].slot ?? "unknown") ?? 0) + 1);
+        let swapIdx = -1;
+        let worstScore = Infinity;
+        for (let i = topK - 1; i >= 0; i--) {
+            const s = result[i].slot ?? "unknown";
+            if ((slotCounts.get(s) ?? 0) > 1 && !profile.blueprint.requiredSlots.includes(s) && result[i].score < worstScore) {
+                worstScore = result[i].score;
+                swapIdx = i;
+            }
+        }
+        if (swapIdx < 0) {
+            for (let i = topK - 1; i >= 0; i--) {
+                if (!profile.blueprint.requiredSlots.includes(result[i].slot ?? "unknown") && result[i].score < worstScore) {
+                    worstScore = result[i].score;
+                    swapIdx = i;
+                }
+            }
+        }
+        if (swapIdx >= 0) {
+            usedIds.add(candidate.id);
+            usedFiles.add(candidate.relativePath);
+            result[swapIdx] = withSelectionReason(candidate, `slot rebalance: filling missing ${slot} slot`);
+        }
+    }
+    // Phase 2: targeted semantic promotion — at most 1 per case, positions 8-10 only.
+    // Promotes a semantic-supported candidate from 11-40 into the lower top10
+    // if it fills a missing required slot or replaces an avoid-like / non-required file.
+    const hasSemanticActive = sorted.some((u) => u.retrievalPasses.includes("semantic_vector"));
+    if (hasSemanticActive) {
+        for (const candidate of sorted.slice(10, Math.min(sorted.length, 40))) {
+            if (usedFiles.has(candidate.relativePath) || candidate.contrastContext)
+                continue;
+            if (!candidate.retrievalPasses.includes("semantic_vector"))
+                continue;
+            // Must have at least one other channel (lexical, path, symbol, graph)
+            const hasOther = candidate.matchedTerms.length > 0 || (candidate.symbolMatches?.length ?? 0) > 0 || (candidate.graphReasons?.length ?? 0) > 0;
+            if (!hasOther)
+                continue;
+            const candSlot = candidate.slot ?? "unknown";
+            const fillsMissing = missingSlots.includes(candSlot);
+            let swapIdx = -1;
+            let swapReason = "";
+            // Priority: replace avoid-like file in bottom 3 positions (8-10)
+            for (let i = 7; i < Math.min(topK, 10); i++) {
+                if (isAvoidLikeFile(result[i], profile) && !fillsMissing) {
+                    const s = result[i].slot ?? "unknown";
+                    if (profile.blueprint.requiredSlots.includes(s) && (result.slice(0, topK).filter((u) => (u.slot ?? "unknown") === s).length <= 1))
+                        continue;
+                    swapIdx = i;
+                    swapReason = `semantic promotion: replaces avoid-like at pos ${i + 1}`;
+                    break;
+                }
+            }
+            // If fills missing slot, replace overrepresented non-required slot file in 8-10
+            if (swapIdx < 0 && fillsMissing) {
+                const slotCounts = new Map();
+                for (let i = 0; i < topK; i++)
+                    slotCounts.set(result[i].slot ?? "unknown", (slotCounts.get(result[i].slot ?? "unknown") ?? 0) + 1);
+                for (let i = 9; i >= 7; i--) {
+                    const s = result[i].slot ?? "unknown";
+                    if (!profile.blueprint.requiredSlots.includes(s) && (slotCounts.get(s) ?? 0) > 1) {
+                        swapIdx = i;
+                        swapReason = `semantic promotion: fills missing slot ${candSlot} at pos ${i + 1}`;
+                        break;
+                    }
+                }
+            }
+            if (swapIdx >= 0) {
+                usedFiles.add(candidate.relativePath);
+                result[swapIdx] = withSelectionReason(candidate, swapReason);
+                if (fillsMissing)
+                    missingSlots.splice(missingSlots.indexOf(candSlot), 1);
+                break; // Max 1 promotion per case
+            }
+        }
+    }
+    // Phase 3: deterministic lexical rescue — at most 1 per case, ranks 11→20 only.
+    // Promotes a candidate with 2+ independent evidence signals to position 8-10
+    // if it is not avoid-like and not contrast. Keeps top 1-7 unchanged.
+    const rescueWindow = sorted.slice(10, Math.min(sorted.length, 20));
+    let rescueFired = false;
+    for (const candidate of rescueWindow) {
+        if (rescueFired)
+            break;
+        if (usedFiles.has(candidate.relativePath) || usedIds.has(candidate.id))
+            continue;
+        if (candidate.contrastContext)
+            continue;
+        if (isAvoidLikeFile(candidate, profile))
+            continue;
+        const signals = countDeterministicSignals(candidate, profile);
+        if (signals < 2)
+            continue;
+        // Candidate qualified — mark as candidate
+        candidate.rescueStatus = "candidate";
+        // Find swap target in positions 8-10 (indices 7-9)
+        let swapIdx = -1;
+        let swapReason = "";
+        // Priority 1: replace avoid-like file in 8-10
+        for (let i = 7; i < Math.min(topK, 10); i++) {
+            if (isAvoidLikeFile(result[i], profile)) {
+                const s = result[i].slot ?? "unknown";
+                if (profile.blueprint.requiredSlots.includes(s) && (result.slice(0, topK).filter((u) => (u.slot ?? "unknown") === s).length <= 1))
+                    continue;
+                swapIdx = i;
+                swapReason = `lexical rescue: replaces avoid-like ${result[i].relativePath.split("/").pop()} at pos ${i + 1}`;
+                break;
+            }
+        }
+        // Priority 2: replace overrepresented non-required slot file in 8-10
+        if (swapIdx < 0) {
+            const slotCounts = new Map();
+            for (let i = 0; i < topK; i++)
+                slotCounts.set(result[i].slot ?? "unknown", (slotCounts.get(result[i].slot ?? "unknown") ?? 0) + 1);
+            for (let i = 9; i >= 7; i--) {
+                const s = result[i].slot ?? "unknown";
+                if (!profile.blueprint.requiredSlots.includes(s) && (slotCounts.get(s) ?? 0) > 1) {
+                    swapIdx = i;
+                    swapReason = `lexical rescue: replaces overrepresented ${s} at pos ${i + 1}`;
+                    break;
+                }
+            }
+        }
+        // Priority 3: replace lowest-scoring non-required file in 8-10
+        if (swapIdx < 0) {
+            let worstScore = Infinity;
+            for (let i = 9; i >= 7; i--) {
+                const s = result[i].slot ?? "unknown";
+                if (!profile.blueprint.requiredSlots.includes(s) && result[i].score < worstScore) {
+                    worstScore = result[i].score;
+                    swapIdx = i;
+                }
+            }
+            if (swapIdx >= 0) {
+                swapReason = `lexical rescue: replaces lowest-scoring non-required ${result[swapIdx].relativePath.split("/").pop()} at pos ${swapIdx + 1}`;
+            }
+        }
+        if (swapIdx >= 0) {
+            candidate.rescueStatus = "applied";
+            usedFiles.add(candidate.relativePath);
+            usedIds.add(candidate.id);
+            result[swapIdx] = withSelectionReason(candidate, swapReason);
+            rescueFired = true;
+        }
+        else {
+            candidate.rescueStatus = "blocked";
+        }
+    }
+    return result;
+}
+function countDeterministicSignals(unit, profile) {
+    let count = 0;
+    if (unit.matchedTerms.length > 0)
+        count++;
+    if ((unit.symbolMatches?.length ?? 0) > 0)
+        count++;
+    if ((unit.graphReasons?.length ?? 0) > 0)
+        count++;
+    if (hasStrongTaskMatch(unit, profile))
+        count++;
+    if (filenamePhraseMatchBonus(unit, profile) > 0)
+        count++;
+    // Slot fills a missing required slot
+    if (unit.slot && profile.blueprint.requiredSlots.includes(unit.slot))
+        count++;
+    return count;
+}
+function groupEvidenceByFile(sorted) {
+    const byFile = new Map();
+    for (const unit of sorted) {
+        const list = byFile.get(unit.relativePath) ?? [];
+        list.push(unit);
+        byFile.set(unit.relativePath, list);
+    }
+    const files = [];
+    for (const [path, units] of byFile) {
+        const best = units[0]; // Already sorted by score
+        files.push({
+            relativePath: path,
+            bestUnit: best,
+            bestScore: best.score,
+            slots: new Set(units.map((u) => u.slot ?? "unknown")),
+            roles: [...new Set(units.map((u) => u.role))],
+            subsystem: best.subsystem,
+            hasSemantic: units.some((u) => u.retrievalPasses.includes("semantic_vector")),
+            hasGraph: (best.graphReasons?.length ?? 0) > 0,
+            hasSymbol: (best.symbolMatches?.length ?? 0) > 0,
+            avoidRisk: false, // Will be set below
+            isContrast: best.contrastContext === true
+        });
+    }
+    return files;
+}
+function selectTopFiles(fileGroups, profile, topK) {
+    const selected = [];
+    const seen = new Set();
+    const primarySubsystem = inferFileSubsystem(fileGroups, profile);
+    const add = (f) => {
+        if (selected.length >= topK || seen.has(f.relativePath))
+            return false;
+        seen.add(f.relativePath);
+        selected.push(f);
+        return true;
+    };
+    // Step 1: Keep top core candidate (non-contrast, non-test, high confidence)
+    const core = fileGroups.find((f) => !f.isContrast && f.roles.includes("edit_candidate") && !f.relativePath.match(/(^|\/)(tests?|specs?|__tests__)(\/|$)/));
+    if (core) {
+        add(core);
+        core.bestUnit = withSelectionReason(core.bestUnit, "selected: core file");
+    }
+    // Step 2: Fill required slots with unique files
+    for (const slot of orderedRequiredSlots(profile)) {
+        if (selected.length >= topK)
+            break;
+        const best = fileGroups
+            .filter((f) => !seen.has(f.relativePath) && f.slots.has(slot) && !f.isContrast)
+            .sort((a, b) => fileSlotScore(b, slot, profile, primarySubsystem) - fileSlotScore(a, slot, profile, primarySubsystem))[0];
+        if (best) {
+            add(best);
+            best.bestUnit = withSelectionReason(best.bestUnit, `selected: fills missing required slot ${slot}`);
+        }
+    }
+    // Step 3: Graph-aware expansion — same directory/subsystem as core
+    if (selected.length > 0 && selected.length < topK) {
+        const corePath = selected[0].relativePath;
+        const coreDir = corePath.replace(/\\/g, "/").toLowerCase().split("/").slice(0, -1).join("/");
+        for (const f of fileGroups) {
+            if (selected.length >= topK)
+                break;
+            if (seen.has(f.relativePath) || f.isContrast)
+                continue;
+            const fDir = f.relativePath.replace(/\\/g, "/").toLowerCase().split("/").slice(0, -1).join("/");
+            if (fDir === coreDir || (f.subsystem && f.subsystem === selected[0].subsystem)) {
+                add(f);
+                f.bestUnit = withSelectionReason(f.bestUnit, `selected: graph-connected to ${corePath.split("/").pop()}`);
+            }
+        }
+    }
+    // Step 4: Fill remaining by file score
+    const remaining = fileGroups
+        .filter((f) => !seen.has(f.relativePath) && !f.isContrast)
+        .sort((a, b) => b.bestScore - a.bestScore);
+    for (const f of remaining) {
+        if (selected.length >= topK)
+            break;
+        add(f);
+    }
+    // Step 5: If still not enough, allow contrast files
+    if (selected.length < topK) {
+        for (const f of fileGroups) {
+            if (selected.length >= topK)
+                break;
+            if (!seen.has(f.relativePath))
+                add(f);
+        }
+    }
+    return selected;
+}
+function fileSlotScore(f, slot, profile, primarySubsystem) {
+    let s = f.bestScore;
+    if (hasFileStrongTaskMatch(f, profile))
+        s += 50;
+    if (primarySubsystem && f.subsystem === primarySubsystem)
+        s += 20;
+    if (f.roles.includes("edit_candidate"))
+        s += 15;
+    if (f.hasSymbol)
+        s += 8;
+    if (f.hasGraph)
+        s += 6;
+    if (f.hasSemantic)
+        s += 4;
+    return s;
+}
+function hasFileStrongTaskMatch(f, profile) {
+    const path = normalizePath(f.relativePath);
+    return [...profile.literalTerms, ...profile.keywords]
+        .map((term) => (0, text_1.normalizeText)(term).replace(/[^a-z0-9]+/g, ""))
+        .some((term) => term.length >= 5 && path.replace(/[^a-z0-9]+/g, "").includes(term));
+}
+function inferFileSubsystem(fileGroups, profile) {
+    const counts = new Map();
+    for (const f of fileGroups.slice(0, 30)) {
+        if (!f.subsystem || f.isContrast)
+            continue;
+        const w = 1 + (hasFileStrongTaskMatch(f, profile) ? 3 : 0);
+        counts.set(f.subsystem, (counts.get(f.subsystem) ?? 0) + w);
+    }
+    return Array.from(counts.entries()).sort((a, b) => b[1] - a[1])[0]?.[0];
+}
+// Slot-constrained top10: ensure every required slot has at least one representative
+function enforceSlotCoverage(selected, sorted, profile, topK) {
+    if (selected.length < topK + 4)
+        return selected;
+    const topSlots = new Set(selected.slice(0, topK).map((u) => u.slot));
+    const missingSlots = profile.blueprint.requiredSlots.filter((s) => !topSlots.has(s));
+    if (missingSlots.length === 0)
+        return selected;
+    const result = [...selected];
+    const usedIds = new Set(result.map((u) => u.id));
+    const usedFiles = new Set(result.slice(0, topK).map((u) => u.relativePath));
+    for (const slot of missingSlots) {
+        // Find best candidate for this slot
+        const candidate = sorted.find((u) => u.slot === slot &&
+            !usedIds.has(u.id) &&
+            !usedFiles.has(u.relativePath) &&
+            !u.contrastContext);
+        if (!candidate)
+            continue;
+        // Find weakest non-required-slot unit to swap
+        const slotCounts = new Map();
+        for (let i = 0; i < topK; i++) {
+            slotCounts.set(result[i].slot ?? "unknown", (slotCounts.get(result[i].slot ?? "unknown") ?? 0) + 1);
+        }
+        let swapIdx = -1;
+        let worstScore = Infinity;
+        // Prefer swapping overrepresented non-required slots
+        for (let i = topK - 1; i >= 0; i--) {
+            const s = result[i].slot ?? "unknown";
+            const overCount = slotCounts.get(s) ?? 0;
+            if (overCount > 1 && !profile.blueprint.requiredSlots.includes(s) && result[i].score < worstScore) {
+                worstScore = result[i].score;
+                swapIdx = i;
+            }
+        }
+        // Fallback: lowest-scoring non-required
+        if (swapIdx < 0) {
+            for (let i = topK - 1; i >= 0; i--) {
+                const s = result[i].slot ?? "unknown";
+                if (!profile.blueprint.requiredSlots.includes(s) && result[i].score < worstScore) {
+                    worstScore = result[i].score;
+                    swapIdx = i;
+                }
+            }
+        }
+        if (swapIdx >= 0) {
+            usedIds.add(candidate.id);
+            usedFiles.add(candidate.relativePath);
+            result[swapIdx] = withSelectionReason(candidate, `slot rebalance: filling missing ${slot} slot`);
+        }
+    }
+    return result;
+}
+function bestSlotCandidate(sorted, slot, profile, state) {
+    const primarySubsystem = inferSelectionSubsystem(sorted.slice(0, 30), profile);
+    return sorted
+        .filter((u) => u.slot === slot && !state.seenIds.has(u.id))
+        .filter((u) => (state.fileCounts.get(u.relativePath) ?? 0) === 0)
+        .filter((u) => !u.contrastContext)
+        .sort((a, b) => slotCandidateScore(b, slot, profile, primarySubsystem) - slotCandidateScore(a, slot, profile, primarySubsystem))[0];
+}
+function slotCandidateScore(unit, slot, profile, primarySubsystem) {
+    let s = unit.score;
+    if (hasStrongTaskMatch(unit, profile))
+        s += 50;
+    if (primarySubsystem && unit.subsystem === primarySubsystem)
+        s += 20;
+    if (unit.slot === slot)
+        s += 30;
+    if (unit.role === "edit_candidate")
+        s += 15;
+    if (unit.contrastContext)
+        s -= 100;
+    return s;
+}
+function findGraphConnectedCandidates(sorted, corePath, profile, maxResults) {
+    const coreBase = corePath.replace(/\\/g, "/").split("/").pop()?.replace(/\.[^.]+$/, "").toLowerCase() ?? "";
+    const coreDir = corePath.replace(/\\/g, "/").toLowerCase().split("/").slice(0, -1).join("/");
+    const results = [];
+    for (const unit of sorted) {
+        if (results.length >= maxResults)
+            break;
+        const up = normalizePath(unit.relativePath);
+        const uDir = up.split("/").slice(0, -1).join("/");
+        // Same directory sibling
+        if (uDir === coreDir && up !== normalizePath(corePath)) {
+            results.push(unit);
+            continue;
+        }
+        // Same subsystem
+        if (unit.subsystem && unit.subsystem === sorted.find((u) => normalizePath(u.relativePath) === normalizePath(corePath))?.subsystem) {
+            results.push(unit);
+            continue;
+        }
+    }
+    return results;
+}
+function withSelectionReason(unit, reason) {
+    return {
+        ...unit,
+        reasons: [...unit.reasons.filter((r) => !r.startsWith("selected:") && !r.startsWith("demoted:")), reason]
+    };
+}
+// Path-role classifier: maps file path to semantic role
+function classifyPathRole(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 "controller";
+    if (/(^|\/)(services?|usecases?|domain)(\/|$)/.test(p))
+        return "service";
+    if (/(^|\/)(repositories?|dao)(\/|$)/.test(p))
+        return "repository";
+    if (/(^|\/)(models?|entities?)(\/|$)|schema\.(ts|js|prisma)$/.test(p))
+        return "model";
+    if (/(^|\/)(migrations?|schema)(\/|$)|\.sql$|\.prisma$/.test(p))
+        return "schema";
+    if (/(^|\/)(config|configs?|settings?|environments?)(\/|$)|\.(env|toml|ya?ml|ini|json|properties)$/.test(p))
+        return "config";
+    if (/(^|\/)(jobs?|workers?)(\/|$)/.test(p))
+        return "job";
+    if (/(^|\/)(listeners?|events?)(\/|$)/.test(p))
+        return "event";
+    if (/(^|\/)(notifications?|mail|mailers?)(\/|$)/.test(p))
+        return "notification";
+    if (/(^|\/)(mail|email|smtp)(\/|$)/.test(p))
+        return "mail";
+    if (/(^|\/)(queues?)(\/|$)/.test(p))
+        return "queue";
+    if (/(^|\/)(components?|views?|templates?|pages?)(\/|$)|\.(svelte|vue|tsx|jsx|blade\.php|twig|erb)$/.test(p))
+        return "ui";
+    if (/(^|\/)(templates?|views?|resources\/views)(\/|$)/.test(p))
+        return "template";
+    if (/(^|\/)(policies?|permissions?|guards?|middleware|auth)(\/|$)/.test(p))
+        return "auth";
+    if (/(^|\/)(admin|dashboard)(\/|$)/.test(p))
+        return "admin";
+    if (/(^|\/)(payment|billing|invoice|checkout)(\/|$)/.test(p))
+        return "payment";
+    if (/(^|\/)(tests?|specs?|__tests__)(\/|$)|\.(test|spec)\./.test(p))
+        return "test";
+    if (/(^|\/)(helpers?|utils?|lib|common|shared)(\/|$)/.test(p))
+        return "utility";
+    return "other";
 }
 function buildConstrainedTopK(sorted, profile, limit) {
     const pool = sorted.slice(0, Math.min(80, sorted.length));
@@ -177,6 +699,12 @@ function constrainedCandidateScore(unit, profile, primarySubsystem) {
     if (primarySubsystem && unit.subsystem === primarySubsystem) {
         score += 24;
     }
+    else if (primarySubsystem && unit.subsystem && unit.subsystem !== primarySubsystem) {
+        const coversRequiredSlot = unit.slot && profile.blueprint.requiredSlots.includes(unit.slot);
+        if (!coversRequiredSlot && !hasStrongTaskMatch(unit, profile)) {
+            score -= 80;
+        }
+    }
     if (unit.contrastContext) {
         score -= 80;
     }
@@ -184,11 +712,22 @@ function constrainedCandidateScore(unit, profile, primarySubsystem) {
         score -= 50;
     }
     if (unit.slot === "entry" || unit.slot === "handler") {
-        score += 18;
+        score += 28;
     }
     if (unit.slot === "validation" || unit.slot === "ui") {
         score += 12;
     }
+    // Intent-aware keyword boosts based on raw task text
+    var pathLower = normalizePath(unit.relativePath).toLowerCase();
+    var taskLower = (profile.rawTask || "").toLowerCase();
+    if (profile.intent === "bugfix" && (/controller|handler|service|repository/i.test(pathLower)))
+        score += 8;
+    if (/export|import|csv|excel|pdf/i.test(taskLower) && (/export|import|excel|pdf|csv/i.test(pathLower)))
+        score += 10;
+    if (/auth|login|permission|middleware|policy/i.test(taskLower) && (/auth|middleware|policy|guard|permission/i.test(pathLower)))
+        score += 8;
+    if (/view|blade|template|component|frontend/i.test(taskLower) && (/view|blade|template|component/i.test(pathLower)))
+        score += 8;
     return score;
 }
 function isAllowedInConstrainedTop(unit, profile, primarySubsystem) {
@@ -246,7 +785,7 @@ function pushUnit(state, unit, options = {}) {
     }
     const currentFileCount = state.fileCounts.get(unit.relativePath) ?? 0;
     const earlyLimit = options.allowSecondFileUnitEarly ? 2 : 1;
-    const fileLimit = state.selected.length < 12 ? earlyLimit : options.allowThirdFileUnit ? 3 : 2;
+    const fileLimit = state.selected.length < 12 ? earlyLimit : 2;
     if (currentFileCount >= fileLimit) {
         return false;
     }
@@ -290,7 +829,7 @@ function pushEntityCompanions(sorted, state, profile) {
     for (const entity of activeEntities) {
         for (const slot of slotsToCover) {
             const companion = bestEntityCompanion(sorted, entity, slot, state);
-            if (pushUnit(state, companion ? withEntityCompanionReason(companion, entity, slot) : undefined, { allowThirdFileUnit: true })) {
+            if (pushUnit(state, companion ? withEntityCompanionReason(companion, entity, slot) : undefined, { allowSecondFileUnitEarly: true })) {
                 added += 1;
             }
             if (added >= 3 || state.selected.length >= Math.floor(state.maxCandidates * 0.5)) {
@@ -392,25 +931,83 @@ function withEntityCompanionReason(unit, entity, slot) {
         reasons: [...unit.reasons, `entity companion for ${entity} ${slot} context`]
     };
 }
-function boostUnit(unit, fileCounts, config, profile, editorContext) {
+function computeGenericTerms(pool) {
+    if (process.env.FLOWSEEKER_DISABLE_GENERIC_TERMS === "1")
+        return new Set();
+    const termFileCounts = new Map();
+    for (const unit of pool) {
+        const base = normalizePath(unit.relativePath).split("/").pop()?.replace(/\.[^.]+$/, "") ?? "";
+        const compactBase = base.replace(/[^a-z0-9]+/g, "");
+        for (const term of unit.matchedTerms) {
+            const compactTerm = (0, text_1.normalizeText)(term).replace(/[^a-z0-9]+/g, "");
+            if (compactTerm.length < 5)
+                continue;
+            if (compactBase.includes(compactTerm)) {
+                const files = termFileCounts.get(compactTerm) ?? new Set();
+                files.add(unit.relativePath);
+                termFileCounts.set(compactTerm, files);
+            }
+        }
+    }
+    return new Set([...termFileCounts.entries()].filter(([, files]) => files.size > 8).map(([term]) => term));
+}
+function boostUnit(unit, fileCounts, config, profile, editorContext, genericTerms) {
     const sameFileCount = fileCounts.get(unit.relativePath) ?? 1;
     const crossEvidenceBonus = Math.min(4, sameFileCount - 1);
     const multiTermBonus = Math.min(6, unit.matchedTerms.length);
     const slotBonus = profile ? profileSlotBonus(unit, profile) : 0;
     const subsystemBonus = profile ? (0, subsystem_1.subsystemAlignmentScore)(unit, profile) : 0;
-    const symbolBonus = profile && unit.symbolMatches?.length ? Math.min(8, unit.symbolMatches.length * 4) : 0;
+    const symbolBonus = profile && unit.symbolMatches?.length
+        ? (() => {
+            const isTS = unit.extractorKind === "tree-sitter";
+            const maxBonus = isTS ? 16 : 3;
+            const perMatch = isTS ? 6 : 1;
+            const bonus = Math.min(maxBonus, unit.symbolMatches.length * perMatch);
+            return bonus;
+        })()
+        : 0;
     const literalTermBonus = profile ? matchedTaskLiteralBonus(unit, profile) : 0;
-    const filenamePhraseBonus = profile ? filenamePhraseMatchBonus(unit, profile) : 0;
+    const filenamePhraseBonus = profile ? filenamePhraseMatchBonus(unit, profile, genericTerms) : 0;
     const testPenalty = profile && isUnrequestedTestEvidence(unit, profile) ? 55 : 0;
     const duplicatePenalty = unit.isDuplicate ? 8 : 0;
-    const contrastPenalty = unit.contrastContext ? 8 : 0;
+    const contrastPenalty = unit.contrastContext ? 50 : 0;
+    const hasAnyBoost = (literalTermBonus + filenamePhraseBonus + symbolBonus) > 0 || unit.score > 15;
+    const lowSignalPenalty = profile && !hasAnyBoost && !unit.contrastContext ? 20 : 0;
     const editorBoost = editorContext ? editorContextBoost(unit, editorContext) : 0;
-    const score = unit.score + crossEvidenceBonus + multiTermBonus + slotBonus + subsystemBonus + symbolBonus + literalTermBonus + filenamePhraseBonus - testPenalty - duplicatePenalty - contrastPenalty + editorBoost;
+    // Graph expansion boost: files added via dependency/graph get a small floor lift
+    const graphExpansionBoost = (unit.graphReasons?.length ?? 0) > 0 && unit.score < 15 ? 8 : 0;
+    // Controlled semantic boost: only for hosted providers (not deterministicTest)
+    const hasSemantic = unit.retrievalPasses.includes("semantic_vector");
+    const hasOtherChannel = unit.matchedTerms.length > 0 || (unit.symbolMatches?.length ?? 0) > 0 || (unit.graphReasons?.length ?? 0) > 0;
+    const isHostedProvider = config.index.semanticEnabled && config.index.semanticProvider !== "deterministicTest";
+    // Gentle boost: +2 for hosted semantic when other channels also support the file
+    const semanticBoost = (hasSemantic && hasOtherChannel && isHostedProvider) ? 2 : 0;
+    const fusedScore = unit.score;
+    const exactBoost = literalTermBonus + filenamePhraseBonus;
+    const slotBoost = slotBonus;
+    const graphBoost = unit.graphReasons?.length ? Math.min(12, unit.graphReasons.length * 4) : 0;
+    const symbolSpecificityBoost = symbolBonus;
+    const subsystemSpecificityBoost = subsystemBonus;
+    const noisePenalty = testPenalty + contrastPenalty + lowSignalPenalty;
+    const duplicationPenalty = duplicatePenalty;
+    const score = fusedScore + crossEvidenceBonus + multiTermBonus + slotBoost + subsystemSpecificityBoost + symbolSpecificityBoost + exactBoost + graphBoost + semanticBoost + graphExpansionBoost - noisePenalty - duplicationPenalty + editorBoost;
+    const scoreBreakdown = {
+        fusedScore,
+        exactBoost,
+        slotBoost,
+        graphBoost,
+        symbolBoost: symbolSpecificityBoost,
+        subsystemBoost: subsystemSpecificityBoost,
+        noisePenalty,
+        duplicationPenalty,
+        finalScore: score
+    };
     const confidence = (0, text_1.clamp)(score / 30, 0.1, 0.98);
     const role = confidence < config.pipeline.minConfidence && unit.role === "edit_candidate" ? "unknown" : unit.role;
     return {
         ...unit,
         score,
+        scoreBreakdown,
         role,
         confidence,
         tier: confidence >= 0.75 ? "high" : confidence >= config.pipeline.minConfidence ? "medium" : "low",
@@ -435,7 +1032,7 @@ function isUnrequestedTestEvidence(unit, profile) {
     }
     return !/\b(test|tests|spec|unit test|integration test|e2e|assert|expect|coverage)\b/.test(profile.normalizedTask);
 }
-function filenamePhraseMatchBonus(unit, profile) {
+function filenamePhraseMatchBonus(unit, profile, genericTerms) {
     const normalizedPath = normalizePath(unit.relativePath);
     const base = normalizedPath.split("/").pop()?.replace(/\.[^.]+$/, "") ?? normalizedPath;
     const compactBase = base.replace(/[^a-z0-9]+/g, "");
@@ -446,11 +1043,12 @@ function filenamePhraseMatchBonus(unit, profile) {
         if (compactTerm.length < 5) {
             continue;
         }
+        const isGeneric = genericTerms?.has(compactTerm) ?? false;
         if (compactBase.includes(compactTerm)) {
-            best = Math.max(best, 64);
+            best = Math.max(best, isGeneric ? 48 : 64);
         }
         else if (compactPath.includes(compactTerm)) {
-            best = Math.max(best, 28);
+            best = Math.max(best, isGeneric ? 22 : 28);
         }
     }
     if (/\b(source\s+code|source|src|implementation)\b/.test(profile.normalizedTask) && normalizedPath.startsWith("src/")) {
@@ -488,6 +1086,12 @@ function profileSlotBonus(unit, profile) {
     let bonus = 0;
     if (profile.blueprint.requiredSlots.includes(slot)) {
         bonus += 14;
+        if (slot === "entry" || slot === "handler") {
+            bonus += 10;
+        }
+        else if (slot === "ui" || slot === "validation") {
+            bonus += 6;
+        }
     }
     else if (profile.blueprint.optionalSlots.includes(slot)) {
         bonus += 5;
@@ -560,4 +1164,259 @@ function editorContextBoost(unit, ctx) {
     }
     return boost;
 }
+function applyAvoidFilter(units, profile) {
+    if (units.length < 12)
+        return units;
+    const top10 = units.slice(0, 10);
+    const rest = units.slice(10);
+    const requiredSlots = profile ? new Set(profile.blueprint.requiredSlots) : new Set();
+    const slotOccupants = new Map();
+    for (const u of top10) {
+        if (u.slot)
+            slotOccupants.set(u.slot, (slotOccupants.get(u.slot) ?? 0) + 1);
+    }
+    // Identify avoid-like files in top 10, but protect sole slot occupants
+    const avoidIndices = [];
+    for (let i = 0; i < top10.length; i++) {
+        if (!isAvoidLikeFile(top10[i], profile))
+            continue;
+        // Don't demote if this is the ONLY file covering a required slot
+        const slot = top10[i].slot;
+        if (slot && requiredSlots.has(slot) && (slotOccupants.get(slot) ?? 0) <= 1)
+            continue;
+        avoidIndices.push(i);
+    }
+    if (avoidIndices.length === 0)
+        return units;
+    // Swap avoid-like files with next-best non-avoid files from rest
+    const result = [...units];
+    let swapFrom = 10;
+    for (const avoidIdx of avoidIndices) {
+        while (swapFrom < result.length) {
+            if (!isAvoidLikeFile(result[swapFrom], profile)) {
+                // Swap
+                const temp = result[avoidIdx];
+                result[avoidIdx] = { ...result[swapFrom], score: temp.score, reasons: [...result[swapFrom].reasons, `promoted over avoid-like file: ${temp.relativePath}`] };
+                result[swapFrom] = { ...temp, contrastContext: true, reasons: [...temp.reasons, `avoid-like pattern demoted`] };
+                swapFrom++;
+                break;
+            }
+            swapFrom++;
+        }
+    }
+    return result;
+}
+// Task-aware avoid guard: detects domain files with weak task/path token overlap
+// and wrong subsystem. These files likely entered top10 due to parser symbol evidence
+// rather than actual task relevance.
+function isTaskMismatchedDomainFile(unit, profile) {
+    // Must have weak path/token overlap with task
+    if (unit.matchedTerms.length > 1)
+        return false;
+    // Must not have strong task match
+    if (hasStrongTaskMatch(unit, profile))
+        return false;
+    // Must not have explicit literal term match
+    if (profile.literalTerms.length > 0 && unit.matchedTerms.some(t => profile.literalTerms.includes(t)))
+        return false;
+    // Check path tokens against task tokens
+    const normalizedPath = (0, text_1.normalizeText)(unit.relativePath);
+    const compactPath = normalizedPath.replace(/[^a-z0-9]+/g, "");
+    const taskTokenSet = new Set([...profile.keywords.map(text_1.normalizeText), ...profile.concepts.map(text_1.normalizeText), ...profile.actions.map(text_1.normalizeText)]);
+    const pathOverlapCount = [...taskTokenSet].filter(t => t.length >= 4 && compactPath.includes(t)).length;
+    // If path has 2+ task token overlaps, it's not mismatched
+    if (pathOverlapCount >= 2)
+        return false;
+    // If file has no task tokens at all in path AND has 0 matched terms AND is
+    // not expected/required-slot-critical, it's a likely parser-boosted mismatch
+    return pathOverlapCount === 0;
+}
+// Avoid-aware promotion: replace avoid/wrong-subsystem files in top 10
+// with better candidates from positions 11-40 that improve slot coverage or subsystem alignment.
+function applyAvoidAwarePromotion(units, sorted, profile) {
+    const stats = { scanned: 0, candidates: 0, demoted: 0, promoted: 0, blockedSlot: 0, blockedExpected: 0, noSafeReplacement: 0 };
+    if (!profile || units.length < 14)
+        return { units, stats };
+    const requiredSlots = new Set(profile.blueprint.requiredSlots);
+    if (requiredSlots.size === 0)
+        return { units, stats };
+    const result = [...units];
+    const topFiles = new Set(result.slice(0, 10).map((u) => u.relativePath));
+    const topSlots = new Set();
+    const topSlotOwners = new Map(); // slot → paths
+    for (const u of result.slice(0, 10)) {
+        const s = u.slot ?? "unknown";
+        topSlots.add(s);
+        const owners = topSlotOwners.get(s) ?? [];
+        owners.push(u.relativePath);
+        topSlotOwners.set(s, owners);
+    }
+    const missingSlots = profile.blueprint.requiredSlots.filter((s) => !topSlots.has(s));
+    const primarySubsystem = inferSelectionSubsystem(result.slice(0, 20), profile);
+    // Identify avoid-like and task-mismatched files in top 10 that are NOT sole slot occupants
+    const swapCandidates = [];
+    let taScanned = 0;
+    let taCandidates = 0;
+    for (let i = 0; i < 10; i++) {
+        const u = result[i];
+        stats.scanned++;
+        const isAvoidLike = isAvoidLikeFile(u, profile);
+        const isTaskMismatch = !isAvoidLike && isTaskMismatchedDomainFile(u, profile);
+        if (!isAvoidLike && !isTaskMismatch)
+            continue;
+        const s = u.slot ?? "unknown";
+        if (requiredSlots.has(s) && (topSlotOwners.get(s)?.length ?? 0) <= 1) {
+            u.taskAvoidGuardFlag = "blocked_slot";
+            stats.blockedSlot++;
+            continue;
+        }
+        if ((u.slot === "entry" || u.slot === "handler") && (topSlotOwners.get(u.slot)?.length ?? 0) <= 1) {
+            u.taskAvoidGuardFlag = "blocked_slot";
+            stats.blockedSlot++;
+            continue;
+        }
+        if (u.role === "edit_candidate" && result.slice(0, 10).filter((r) => r.role === "edit_candidate").length <= 1) {
+            u.taskAvoidGuardFlag = "blocked_expected";
+            stats.blockedExpected++;
+            continue;
+        }
+        stats.candidates++;
+        u.taskAvoidGuardFlag = "candidate";
+        const reason = isTaskMismatch ? "task-aware guard (path/subsystem mismatch)" : "avoid-like guard";
+        swapCandidates.push({ idx: i, unit: u, reason });
+    }
+    if (swapCandidates.length === 0)
+        return { units: result, stats };
+    // Scan positions 11-40 for replacement candidates
+    for (const avoid of swapCandidates) {
+        let bestReplacement;
+        let bestScore = -Infinity;
+        let bestIdx = -1;
+        for (let j = 10; j < Math.min(result.length, 40); j++) {
+            const candidate = result[j];
+            if (topFiles.has(candidate.relativePath))
+                continue;
+            if (candidate.contrastContext)
+                continue;
+            const fillsMissing = candidate.slot && missingSlots.includes(candidate.slot);
+            const improvesSubsystem = primarySubsystem && candidate.subsystem === primarySubsystem && avoid.unit.subsystem !== primarySubsystem;
+            if (!fillsMissing && !improvesSubsystem)
+                continue;
+            if (isAvoidLikeFile(candidate, profile))
+                continue;
+            let s = candidate.score;
+            if (fillsMissing)
+                s += 30;
+            if (improvesSubsystem)
+                s += 20;
+            if (candidate.role === "edit_candidate")
+                s += 10;
+            if (s > bestScore) {
+                bestScore = s;
+                bestReplacement = candidate;
+                bestIdx = j;
+            }
+        }
+        if (bestReplacement) {
+            const oldUnit = result[avoid.idx];
+            const fillsSlot = bestReplacement.slot && missingSlots.includes(bestReplacement.slot) ? `fills missing slot ${bestReplacement.slot}` : "";
+            const betterSub = primarySubsystem && bestReplacement.subsystem === primarySubsystem && oldUnit.subsystem !== primarySubsystem ? ` better subsystem ${bestReplacement.subsystem}` : "";
+            const reason = [fillsSlot, betterSub].filter(Boolean).join(";") || "safe avoid replacement";
+            result[avoid.idx] = withSelectionReason(bestReplacement, `promoted: ${avoid.reason} replacement for ${oldUnit.relativePath.split("/").pop()} (${reason})`);
+            result[bestIdx] = { ...oldUnit, contrastContext: true, taskAvoidGuardFlag: "demoted", reasons: [...oldUnit.reasons, `demoted: ${avoid.reason}`] };
+            bestReplacement.taskAvoidGuardFlag = "promoted";
+            stats.demoted++;
+            stats.promoted++;
+            topFiles.add(bestReplacement.relativePath);
+            if (bestReplacement.slot && missingSlots.includes(bestReplacement.slot)) {
+                missingSlots.splice(missingSlots.indexOf(bestReplacement.slot), 1);
+            }
+        }
+        else {
+            avoid.unit.taskAvoidGuardFlag = "blocked_no_replacement";
+            stats.noSafeReplacement++;
+        }
+    }
+    return { units: result, stats };
+}
+function isAvoidLikeFile(unit, profile) {
+    const path = normalizePath(unit.relativePath);
+    const isBackendTask = profile?.blueprint?.primarySurface !== "frontend";
+    const targetsUi = profile ? hasTaskUiTarget(profile) : false;
+    const targetsAdmin = profile ? hasTaskAdminTarget(profile) : false;
+    const targetsData = profile ? hasTaskDataTarget(profile) : false;
+    const targetsNotification = profile ? hasTaskNotificationTarget(profile) : false;
+    // Strong avoid signals: helper/util/console/command files
+    if (isGenericAvoidPath(path))
+        return true;
+    // Lock files — never useful as edit candidates
+    if (/(package-lock|yarn\.lock|pnpm-lock|composer\.lock|Gemfile\.lock|poetry\.lock|cargo\.lock)$/.test(path))
+        return true;
+    // Admin-surface files when task doesn't target admin
+    if (!targetsAdmin && isAdminOnlyPath(path))
+        return true;
+    // Template/view files when task is backend (not UI)
+    if (isBackendTask && !targetsUi && isTemplateOnlyPath(path))
+        return true;
+    // Migration files when task isn't about data/schema
+    if (!targetsData && isMigrationOnlyPath(path))
+        return true;
+    // Notification service files when task isn't about notification
+    if (!targetsNotification && isNotificationOnlyPath(path))
+        return true;
+    // Command/scheduler files when task isn't about background jobs
+    if (!profile || !hasTaskBackgroundTarget(profile)) {
+        if (isCommandSchedulerOnlyPath(path))
+            return true;
+    }
+    return false;
+}
+function isGenericAvoidPath(normalizedPath) {
+    return /(^|\/)(helpers?|utils?)(\/|$)/.test(normalizedPath)
+        && !/(controller|handler|service|repository|model|route|router)\b/.test(normalizedPath);
+}
+function isAdminOnlyPath(normalizedPath) {
+    return /\b(admin|dashboard)(\/|$)/.test(normalizedPath)
+        && !/(controller|handler|service|repository|model)\b/.test(normalizedPath);
+}
+function isTemplateOnlyPath(normalizedPath) {
+    return /(^|\/)(views?|templates?|resources\/views)(\/|$)/.test(normalizedPath)
+        || /\.(blade\.php|twig|erb|hbs|ejs)$/.test(normalizedPath);
+}
+function isMigrationOnlyPath(normalizedPath) {
+    return /(^|\/)(migrations?)(\/|$)/.test(normalizedPath)
+        && !/(controller|handler|service|model)\b/.test(normalizedPath);
+}
+function isNotificationOnlyPath(normalizedPath) {
+    return /\b(notification|notify)(\/|$|s?\.|\b)/.test(normalizedPath)
+        && !/(controller|handler|service|repository|model|route|router)\b/.test(normalizedPath);
+}
+function isCommandSchedulerOnlyPath(normalizedPath) {
+    return /(^|\/)(console|commands?|scheduler|schedulers?|cli|scripts?)(\/|$)/.test(normalizedPath)
+        && !/(controller|handler|service|repository|model|route)\b/.test(normalizedPath);
+}
+function hasTaskUiTarget(profile) {
+    const uiTerms = ["ui", "frontend", "client", "browser", "page", "screen", "component", "view", "form", "button", "modal", "template", "layout", "display", "render", "show", "visible", "giao", "dien", "hien", "thi"];
+    return profile.keywords.some((k) => uiTerms.includes(k)) || profile.blueprint.primarySurface === "frontend";
+}
+function hasTaskAdminTarget(profile) {
+    const adminTerms = ["admin", "dashboard", "backoffice", "console"];
+    return profile.keywords.some((k) => adminTerms.includes(k));
+}
+function hasTaskDataTarget(profile) {
+    const dataTerms = ["schema", "migration", "database", "table", "column", "db", "migrate", "prisma"];
+    return profile.keywords.some((k) => dataTerms.includes(k)) || profile.intent === "migration";
+}
+function hasTaskNotificationTarget(profile) {
+    const notifTerms = ["notification", "notify", "email", "mail", "message", "alert", "thong", "bao"];
+    return profile.keywords.some((k) => notifTerms.includes(k));
+}
+function hasTaskBackgroundTarget(profile) {
+    const bgTerms = ["job", "worker", "queue", "scheduler", "cron", "command", "console", "cli", "background", "batch", "schedule"];
+    return profile.keywords.some((k) => bgTerms.includes(k));
+}
+function hasTaskTestTarget(profile) {
+    const testTerms = ["test", "tests", "spec", "testing", "unit test", "integration", "e2e", "assert", "expect", "fixture", "mock", "seed", "coverage"];
+    return profile.keywords.some((k) => testTerms.includes(k));
+}
 //# sourceMappingURL=ranker.js.map