flowseeker 0.1.7 → 0.1.8

package/dist/mcp/mcpTools.js

@@ -59,6 +59,24 @@ exports.TOOL_DEFINITIONS = [
             required: ["task"]
         }
     },
+    {
+        name: "flowseeker_auto",
+        description: "Create an implementation-plan prompt from relevant code context. The agent should produce a reviewable plan or patch only after validating the retrieved evidence.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                task: {
+                    type: "string",
+                    description: "Natural-language codebase task to prepare an implementation plan for."
+                },
+                workspace: {
+                    type: "string",
+                    description: "Workspace root path. Use an absolute path if the IDE does not resolve cwd correctly."
+                }
+            },
+            required: ["task"]
+        }
+    },
     {
         name: "flowseeker_files",
         description: "List top ranked files for a task. Lightweight result for quickly finding where to inspect or edit.",
@@ -103,6 +121,16 @@ exports.MCP_PROMPT_DEFINITIONS = [
             { name: "workspace", description: "Optional workspace root path." }
         ]
     },
+    {
+        name: "auto",
+        description: "Create a reviewable implementation-plan prompt from relevant code context.",
+        toolName: "flowseeker_auto",
+        toolPurpose: "return an implementation-plan prompt with relevant files, edit guardrails, and verification steps",
+        arguments: [
+            { name: "task", description: "Task, bug, or feature to prepare a plan for.", required: true },
+            { name: "workspace", description: "Optional workspace root path." }
+        ]
+    },
     {
         name: "files",
         description: "List top ranked files for a task.",
@@ -127,6 +155,8 @@ async function handleToolCall(toolName, input, defaultWorkspace) {
                 return await handleRetrieve(task, workspace, input.maxFiles);
             case "flowseeker_guide":
                 return await handleGuide(task, workspace);
+            case "flowseeker_auto":
+                return await handleAuto(task, workspace);
             case "flowseeker_files":
                 return await handleFiles(task, workspace, input.limit);
             default:
@@ -153,6 +183,27 @@ async function handleGuide(task, workspace) {
     const summary = formatResultSummary(result);
     return textResult(`${summary}\n\n${prompt}`);
 }
+async function handleAuto(task, workspace) {
+    const result = await runPipeline(task, workspace);
+    const prompt = (0, agentPromptHeadless_1.createAgentSolvePromptHeadless)(result);
+    const summary = formatResultSummary(result);
+    const autoInstructions = [
+        "# FlowSeeker Auto Plan Prompt",
+        "",
+        "You are using FlowSeeker evidence to prepare a code change.",
+        "First validate whether the retrieved files actually match the task.",
+        "Then produce a reviewable implementation plan before editing.",
+        "",
+        "Rules:",
+        "- Do not edit files outside Allowed Edit Files unless you explain why the retrieved scope is insufficient.",
+        "- If retrieval contains unrelated repositories or stale paths, stop and ask for the correct workspace/cache reset.",
+        "- Prefer the smallest coherent patch that satisfies the task.",
+        "- Include focused verification commands or manual checks.",
+        "- If you produce a patch, summarize changed files and residual risk.",
+        ""
+    ].join("\n");
+    return textResult(`${summary}\n\n${autoInstructions}\n${prompt}`);
+}
 async function handleFiles(task, workspace, limit) {
     const result = await runPipeline(task, workspace);
     const groups = (0, fileGroups_1.aggregateEvidenceFiles)(result.units).slice(0, limit ?? 15);

package/dist/pipeline/contextPack.js

@@ -13,10 +13,10 @@ const sections = [
 function createContextPack(task, units, config) {
     const header = [`# FlowSeeker Context`, "", `## Task`, task, ""].join("\n");
     const output = [header];
-    let usedTokens = (0, text_1.tokenEstimate)(header);
+    let usedTokens = (0, text_1.fastTokenEstimate)(header);
     const fileScope = renderFileScope(units);
     output.push(fileScope);
-    usedTokens += (0, text_1.tokenEstimate)(fileScope);
+    usedTokens += (0, text_1.fastTokenEstimate)(fileScope);
     const contextUnits = (0, fileGroups_1.selectDiverseEvidenceUnits)(units, 2);
     for (const section of sections) {
         const sectionUnits = contextUnits.filter((unit) => section.roles.includes(unit.role));
@@ -26,7 +26,7 @@ function createContextPack(task, units, config) {
         const sectionLines = [`## ${section.title}`, ""];
         for (const unit of sectionUnits) {
             const block = renderUnit(unit);
-            const nextTokens = (0, text_1.tokenEstimate)(block);
+            const nextTokens = (0, text_1.fastTokenEstimate)(block);
             if (usedTokens + nextTokens > config.pipeline.maxContextTokens) {
                 sectionLines.push(`- Context budget reached. ${sectionUnits.length} candidates were ranked, but lower-ranked snippets were omitted.`, "");
                 break;

package/dist/pipeline/deterministicReranker.js

@@ -0,0 +1,358 @@
+"use strict";
+// Phase 05 Sprint 5B-R — Disabled Deterministic Reranker Model
+// Execution mode: report_only_disabled
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SELECTOR_CONFIG = exports.DEFAULT_RERANKER_CONFIG = void 0;
+exports.validateConfig = validateConfig;
+exports.computeScoreBreakdown = computeScoreBreakdown;
+exports.rerankCandidates = rerankCandidates;
+exports.validateSelectorConfig = validateSelectorConfig;
+exports.validateSelectorMetadata = validateSelectorMetadata;
+exports.validateSelectorMetadataMap = validateSelectorMetadataMap;
+exports.deriveCountMaps = deriveCountMaps;
+exports.selectCoverageTop10 = selectCoverageTop10;
+exports.DEFAULT_RERANKER_CONFIG = Object.freeze({
+    baseScoreScale: 0.2,
+    baseScoreCap: 100,
+    weights: Object.freeze({
+        exactBoost: 4, slotBoost: 3, graphBoost: 2, symbolBoost: 2, subsystemBoost: 1, parserBoost: 1, noisePenalty: 5, duplicationPenalty: 3
+    }),
+    caps: Object.freeze({
+        exactBoost: 12, slotBoost: 6, graphBoost: 6, symbolBoost: 6, subsystemBoost: 4, parserBoost: 3, noisePenalty: 20, duplicationPenalty: 9
+    })
+});
+function validateConfig(c) {
+    const checkNumber = (label, v) => {
+        if (!Number.isFinite(v) || v < 0)
+            throw new Error(`Invalid config ${label}: ${v}`);
+    };
+    checkNumber("baseScoreScale", c.baseScoreScale);
+    checkNumber("baseScoreCap", c.baseScoreCap);
+    const w = c.weights;
+    const p = c.caps;
+    checkNumber("exactBoost weight", w.exactBoost);
+    checkNumber("exactBoost cap", p.exactBoost);
+    checkNumber("slotBoost weight", w.slotBoost);
+    checkNumber("slotBoost cap", p.slotBoost);
+    checkNumber("graphBoost weight", w.graphBoost);
+    checkNumber("graphBoost cap", p.graphBoost);
+    checkNumber("symbolBoost weight", w.symbolBoost);
+    checkNumber("symbolBoost cap", p.symbolBoost);
+    checkNumber("subsystemBoost weight", w.subsystemBoost);
+    checkNumber("subsystemBoost cap", p.subsystemBoost);
+    checkNumber("parserBoost weight", w.parserBoost);
+    checkNumber("parserBoost cap", p.parserBoost);
+    checkNumber("noisePenalty weight", w.noisePenalty);
+    checkNumber("noisePenalty cap", p.noisePenalty);
+    checkNumber("duplicationPenalty weight", w.duplicationPenalty);
+    checkNumber("duplicationPenalty cap", p.duplicationPenalty);
+}
+function norm(s) { return (s || "").replace(/\\/g, "/").toLowerCase(); }
+function max(a, b) { return a > b ? a : b; }
+// Locale-independent string comparison (no localeCompare)
+function cmpStr(a, b) {
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+function deepClone(c) {
+    return {
+        ...c,
+        symbols: c.symbols ? [...c.symbols] : undefined,
+        symbolMatches: c.symbolMatches ? [...c.symbolMatches] : undefined,
+        matchedTerms: [...c.matchedTerms],
+        imports: [...c.imports],
+        channelHits: c.channelHits ? c.channelHits.map(h => ({ ...h })) : undefined,
+        retrievalPasses: [...c.retrievalPasses],
+        reasons: [...c.reasons]
+    };
+}
+function computeScoreBreakdown(candidate, config = exports.DEFAULT_RERANKER_CONFIG, context) {
+    validateConfig(config);
+    const w = config.weights;
+    const c = config.caps;
+    const baseScore = max(0, Math.min(config.baseScoreCap, candidate.score * config.baseScoreScale));
+    // Exact boost: non-empty matched terms that appear literally in path
+    const effectiveTerms = candidate.matchedTerms.filter(t => t && t.trim().length > 0);
+    const cPath = norm(candidate.relativePath);
+    const exactCount = effectiveTerms.filter(t => cPath.includes(norm(t))).length;
+    const exactBoost = max(0, Math.min(c.exactBoost, exactCount * w.exactBoost));
+    const knownSlots = new Set(["entry", "handler", "domain", "data", "config", "side_effect", "tests", "validation", "permission"]);
+    const slotBoost = (candidate.slot && knownSlots.has(candidate.slot)) ? max(0, Math.min(c.slotBoost, w.slotBoost)) : 0;
+    const hasGraphEvidence = (candidate.channelHits || []).some(h => h.channel === "graph" || h.channel === "dependency");
+    const graphBoost = hasGraphEvidence ? max(0, Math.min(c.graphBoost, w.graphBoost)) : 0;
+    const symbolBoost = (candidate.symbolMatches && candidate.symbolMatches.length > 0)
+        ? max(0, Math.min(c.symbolBoost, candidate.symbolMatches.length * w.symbolBoost)) : 0;
+    const subsystemBoost = candidate.subsystem ? max(0, Math.min(c.subsystemBoost, w.subsystemBoost)) : 0;
+    const parserBoost = candidate.extractorKind && candidate.extractorKind !== "fallback-chunk"
+        ? max(0, Math.min(c.parserBoost, w.parserBoost)) : 0;
+    const noisePenalty = candidate.confidence < 0.4 && candidate.reasons.length < 2
+        ? max(0, Math.min(c.noisePenalty, w.noisePenalty)) : 0;
+    let duplicationPenalty = 0;
+    if (context) {
+        const np = norm(candidate.relativePath);
+        if (context.seenFiles?.has(np))
+            duplicationPenalty = max(0, Math.min(c.duplicationPenalty, w.duplicationPenalty));
+        if (candidate.subsystem && context.seenSubsystems?.has(norm(candidate.subsystem)))
+            duplicationPenalty = max(duplicationPenalty, Math.min(c.duplicationPenalty, w.duplicationPenalty * 0.5));
+    }
+    const finalScore = max(0, baseScore + exactBoost + slotBoost + graphBoost + symbolBoost + subsystemBoost + parserBoost - noisePenalty - duplicationPenalty);
+    return { baseScore, exactBoost, slotBoost, graphBoost, symbolBoost, subsystemBoost, parserBoost, noisePenalty, duplicationPenalty, finalScore };
+}
+function rerankCandidates(candidates, config = exports.DEFAULT_RERANKER_CONFIG) {
+    validateConfig(config);
+    // Deep clone — do not mutate input nested arrays/objects
+    const copy = candidates.map(c => deepClone(c));
+    const byOriginalRank = [...copy].sort((a, b) => {
+        if (a.originalRank !== b.originalRank)
+            return a.originalRank - b.originalRank;
+        return cmpStr(norm(a.relativePath), norm(b.relativePath));
+    });
+    const seenSubsystems = new Set();
+    const seenFiles = new Set();
+    const results = [];
+    for (const candidate of byOriginalRank) {
+        const breakdown = computeScoreBreakdown(candidate, config, { seenSubsystems, seenFiles });
+        const reasons = buildReasons(candidate, breakdown);
+        results.push({ relativePath: candidate.relativePath, originalRank: candidate.originalRank, scoreBreakdown: breakdown, finalScore: breakdown.finalScore, stableRank: 0, reasons });
+        seenFiles.add(norm(candidate.relativePath));
+        if (candidate.subsystem)
+            seenSubsystems.add(norm(candidate.subsystem));
+    }
+    results.sort((a, b) => {
+        if (b.finalScore !== a.finalScore)
+            return b.finalScore - a.finalScore;
+        if (a.originalRank !== b.originalRank)
+            return a.originalRank - b.originalRank;
+        return cmpStr(norm(a.relativePath), norm(b.relativePath));
+    });
+    for (let i = 0; i < results.length; i++)
+        results[i].stableRank = i + 1;
+    return results;
+}
+function buildReasons(candidate, b) {
+    const r = [];
+    if (b.exactBoost > 0)
+        r.push(`exact +${b.exactBoost.toFixed(1)}`);
+    if (b.slotBoost > 0)
+        r.push(`slot ${candidate.slot} +${b.slotBoost.toFixed(1)}`);
+    if (b.graphBoost > 0)
+        r.push(`graph +${b.graphBoost.toFixed(1)}`);
+    if (b.symbolBoost > 0)
+        r.push(`symbol +${b.symbolBoost.toFixed(1)}`);
+    if (b.subsystemBoost > 0)
+        r.push(`subsystem +${b.subsystemBoost.toFixed(1)}`);
+    if (b.parserBoost > 0)
+        r.push(`parser +${b.parserBoost.toFixed(1)}`);
+    if (b.noisePenalty > 0)
+        r.push(`noise -${b.noisePenalty.toFixed(1)}`);
+    if (b.duplicationPenalty > 0)
+        r.push(`duplicate -${b.duplicationPenalty.toFixed(1)}`);
+    if (b.baseScore > 0)
+        r.push(`base ${b.baseScore.toFixed(1)}`);
+    return r.length > 0 ? r : ["no signal"];
+}
+exports.DEFAULT_SELECTOR_CONFIG = {
+    topK: 10, maxProtected: 3, maxPerSlot: {}, maxPerSubsystem: 3, requiredSlots: [],
+    enableProtection: false, enableSlotCaps: false, enableSubsystemCaps: false
+};
+function validateSelectorConfig(c) {
+    if (!Number.isInteger(c.topK) || c.topK < 1)
+        throw new Error("topK must be integer >= 1");
+    if (!Number.isInteger(c.maxProtected) || c.maxProtected < 0 || c.maxProtected > c.topK)
+        throw new Error("maxProtected must be integer 0..topK");
+    if (typeof c.enableProtection !== "boolean")
+        throw new Error("enableProtection must be boolean");
+    if (typeof c.enableSlotCaps !== "boolean")
+        throw new Error("enableSlotCaps must be boolean");
+    if (typeof c.enableSubsystemCaps !== "boolean")
+        throw new Error("enableSubsystemCaps must be boolean");
+    if (!Array.isArray(c.requiredSlots))
+        throw new Error("requiredSlots must be array");
+    const seen = new Set();
+    for (const s of c.requiredSlots) {
+        if (typeof s !== "string" || s.trim().length === 0)
+            throw new Error("required slot must be non-empty string");
+        const ns = s.trim().toLowerCase();
+        if (seen.has(ns))
+            throw new Error("duplicate required slot");
+        seen.add(ns);
+    }
+    if (c.maxPerSlot === null || c.maxPerSlot === undefined || Array.isArray(c.maxPerSlot) || Object.getPrototypeOf(c.maxPerSlot) !== Object.prototype)
+        throw new Error("maxPerSlot must be plain object");
+    for (const [k, v] of Object.entries(c.maxPerSlot)) {
+        if (typeof k !== "string" || k.trim().length === 0)
+            throw new Error("slot cap key non-empty");
+        if (!Number.isInteger(v) || v < 1)
+            throw new Error(`slot cap must be integer >= 1`);
+    }
+    if (!Number.isInteger(c.maxPerSubsystem) || c.maxPerSubsystem < 1)
+        throw new Error("maxPerSubsystem must be integer >= 1");
+}
+function validateSelectorMetadata(m) {
+    if (!m || typeof m !== "object" || m === null)
+        throw new Error("metadata must be non-null object");
+    if (typeof m.protected !== "boolean")
+        throw new Error("metadata.protected must be boolean");
+    if (typeof m.slot !== "string" || m.slot.trim().length === 0)
+        throw new Error("metadata.slot must be non-empty string");
+    if (typeof m.subsystem !== "string" || m.subsystem.trim().length === 0)
+        throw new Error("metadata.subsystem must be non-empty string");
+}
+function validateSelectorMetadataMap(metaMap) {
+    if (metaMap === undefined)
+        return;
+    if (!(metaMap instanceof Map))
+        throw new Error("metaMap must be a Map or undefined");
+    for (const [k, v] of metaMap) {
+        if (typeof k !== "string" || k.trim().length === 0)
+            throw new Error("metadata key must be non-empty string");
+        if (k !== norm(k))
+            throw new Error("metadata key must be normalized (lowercase, slash)");
+        validateSelectorMetadata(v);
+    }
+}
+function deriveCountMaps(selected, metaMap) {
+    const sc = {}, sub = {};
+    for (const s of selected) {
+        const m = metaMap?.get(norm(s.relativePath)) || { protected: false, slot: "unknown", subsystem: "none" };
+        sc[m.slot] = (sc[m.slot] || 0) + 1;
+        sub[m.subsystem] = (sub[m.subsystem] || 0) + 1;
+    }
+    return { slotCounts: sc, subsystemCounts: sub };
+}
+function selectCoverageTop10(scored, config = exports.DEFAULT_SELECTOR_CONFIG, metaMap) {
+    validateSelectorConfig(config);
+    if (metaMap)
+        validateSelectorMetadataMap(metaMap);
+    const seen = new Set();
+    for (const c of scored) {
+        const rp = norm(c.relativePath);
+        if (seen.has(rp))
+            throw new Error(`Duplicate path: ${c.relativePath}`);
+        seen.add(rp);
+    }
+    const sorted = [...scored].sort((a, b) => { if (b.finalScore !== a.finalScore)
+        return b.finalScore - a.finalScore; if (a.originalRank !== b.originalRank)
+        return a.originalRank - b.originalRank; return cmpStr(norm(a.relativePath), norm(b.relativePath)); });
+    const sel = [], selP = new Set();
+    const relax = [];
+    let pass = 0;
+    const slotC = {}, subC = {};
+    const effSlot = { ...config.maxPerSlot };
+    const effSub = {};
+    for (const k of Object.keys(subC))
+        effSub[k] = config.maxPerSubsystem;
+    const sTrace = [], rTrace = [];
+    function m(rp) { return metaMap?.get(rp) || { protected: false, slot: "unknown", subsystem: "none" }; }
+    function capCheck(rp) {
+        const mt = m(rp);
+        if (config.enableSlotCaps && (slotC[mt.slot] || 0) >= (effSlot[mt.slot] ?? config.maxPerSlot[mt.slot] ?? 999))
+            return false;
+        if (config.enableSubsystemCaps && (subC[mt.subsystem] || 0) >= (effSub[mt.subsystem] ?? config.maxPerSubsystem))
+            return false;
+        return true;
+    }
+    function trackCounts(rp) { const mt = m(rp); slotC[mt.slot] = (slotC[mt.slot] || 0) + 1; subC[mt.subsystem] = (subC[mt.subsystem] || 0) + 1; }
+    function addSel(c, prot, reason) {
+        const rp = norm(c.relativePath);
+        if (sel.length >= config.topK || selP.has(rp))
+            return false;
+        if (!capCheck(rp)) {
+            rTrace.push({ decision: "rejected", phase: "cap_blocked", candidate: c.relativePath, reason: `blocked: ${reason}`, pass: 0 });
+            return false;
+        }
+        pass++;
+        const sc = { relativePath: c.relativePath, finalScore: c.finalScore, stableRank: 0, protected: prot, selectionPass: pass, reason };
+        sel.push(sc);
+        selP.add(rp);
+        sTrace.push({ decision: "selected", phase: prot ? "protected" : reason.includes("slot:") ? "slot_fill" : "score_fill", candidate: c.relativePath, reason, pass });
+        trackCounts(rp);
+        return true;
+    }
+    if (config.enableProtection) {
+        let n = 0;
+        for (const c of sorted) {
+            if (sel.length >= config.topK || n >= config.maxProtected)
+                break;
+            if (!m(norm(c.relativePath)).protected)
+                continue;
+            if (addSel(c, true, `protected`))
+                n++;
+        }
+    }
+    if (config.requiredSlots.length > 0) {
+        const filled = new Set();
+        for (const s of sel) {
+            filled.add(m(norm(s.relativePath)).slot);
+        }
+        for (const slot of config.requiredSlots) {
+            if (filled.has(slot))
+                continue;
+            for (const c of sorted) {
+                if (sel.length >= config.topK)
+                    break;
+                if (m(norm(c.relativePath)).slot !== slot)
+                    continue;
+                if (addSel(c, false, `required slot:${slot}`)) {
+                    filled.add(slot);
+                    break;
+                }
+            }
+        }
+    }
+    for (const c of sorted) {
+        if (sel.length >= config.topK)
+            break;
+        addSel(c, false, `score=${c.finalScore.toFixed(1)}`);
+    }
+    // Relaxation: per-candidate, separate slot/subsystem checks, relax all caps for same candidate
+    if (sel.length < config.topK) {
+        for (const c of sorted) {
+            if (sel.length >= config.topK)
+                break;
+            const rp = norm(c.relativePath);
+            if (selP.has(rp))
+                continue;
+            const mt = m(rp);
+            let slotBlocked = false, subBlocked = false;
+            if (config.enableSlotCaps && (slotC[mt.slot] || 0) >= (effSlot[mt.slot] ?? config.maxPerSlot[mt.slot] ?? 999))
+                slotBlocked = true;
+            if (config.enableSubsystemCaps && (subC[mt.subsystem] || 0) >= (effSub[mt.subsystem] ?? config.maxPerSubsystem))
+                subBlocked = true;
+            if (!slotBlocked && !subBlocked)
+                continue;
+            // Relax slot first, then subsystem, for the same candidate
+            if (slotBlocked) {
+                const old = effSlot[mt.slot] ?? config.maxPerSlot[mt.slot] ?? 999;
+                effSlot[mt.slot] = old + 1;
+                relax.push({ pass: sel.length + 1, capType: "slot", key: mt.slot, oldLimit: old, newLimit: old + 1, candidate: c.relativePath, reason: `topK_fill` });
+            }
+            // Re-check subsystem after slot relaxation
+            if (config.enableSubsystemCaps && (subC[mt.subsystem] || 0) >= (effSub[mt.subsystem] ?? config.maxPerSubsystem)) {
+                const old = effSub[mt.subsystem] ?? config.maxPerSubsystem;
+                effSub[mt.subsystem] = old + 1;
+                relax.push({ pass: sel.length + 1, capType: "subsystem", key: mt.subsystem, oldLimit: old, newLimit: old + 1, candidate: c.relativePath, reason: `topK_fill` });
+            }
+            pass++;
+            const sc = { relativePath: c.relativePath, finalScore: c.finalScore, stableRank: 0, protected: false, selectionPass: pass, reason: "topK_fill" };
+            sel.push(sc);
+            selP.add(rp);
+            sTrace.push({ decision: "selected", phase: "cap_relaxed", candidate: c.relativePath, reason: "topK_fill", pass });
+            trackCounts(rp);
+        }
+    }
+    // Rebuild rejectedTrace from final rejected
+    rTrace.length = 0;
+    const finRej = sorted.filter(c => !selP.has(norm(c.relativePath))).map(c => ({ relativePath: c.relativePath, finalScore: c.finalScore, originalRank: c.originalRank, reason: "not selected" }));
+    for (const r of finRej) {
+        rTrace.push({ decision: "rejected", phase: "score_fill", candidate: r.relativePath, reason: "not selected", pass: 0 });
+    }
+    for (let i = 0; i < sel.length; i++)
+        sel[i].stableRank = i + 1;
+    const finalCounts = deriveCountMaps(sel, metaMap);
+    return { selected: sel, rejected: finRej, selectedTrace: sTrace, rejectedTrace: rTrace, relaxations: relax, capRelaxations: relax.length, slotCounts: finalCounts.slotCounts, subsystemCounts: finalCounts.subsystemCounts };
+}
+//# sourceMappingURL=deterministicReranker.js.map

package/dist/pipeline/evaluationMetrics.js

@@ -51,7 +51,11 @@ function computeExpectedPathMetrics(units, expectedPaths, passAtK, mode = "any")
     const firstUnitHitIndex = units.findIndex((unit) => expectedPaths.some((expectedPath) => pathMatches(unit.relativePath, expectedPath)));
     const firstFileHitIndex = fileGroups.findIndex((group) => expectedPaths.some((expectedPath) => pathMatches(group.relativePath, expectedPath)));
     const coverageAtPassK = coverageAt(fileGroups.map((group) => group.relativePath), expectedPaths, passAtK);
-    const pass = mode === "all" ? coverageAtPassK === expectedPaths.length : firstFileHitIndex >= 0 && firstFileHitIndex + 1 <= passAtK;
+    const pass = mode === "any"
+        ? firstFileHitIndex >= 0 && firstFileHitIndex + 1 <= passAtK
+        : mode === "subset"
+            ? coverageAtPassK >= Math.max(2, Math.ceil(expectedPaths.length * 0.5))
+            : coverageAtPassK === expectedPaths.length;
     return {
         expectedCount: expectedPaths.length,
         firstUnitHitRank: firstUnitHitIndex >= 0 ? firstUnitHitIndex + 1 : undefined,
@@ -127,6 +131,10 @@ function computeRankingQualityMetrics(result, topK = 10) {
     const subsystemPurityTop10 = primarySubsystemTop10 && subsystemFiles.length > 0
         ? subsystemFiles.filter((group) => group.subsystem === primarySubsystemTop10).length / subsystemFiles.length
         : 0;
+    const treeSitterEvidenceTop10 = topUnits.filter((unit) => unit.extractorKind === "tree-sitter").length;
+    const structuredRegexEvidenceTop10 = topUnits.filter((unit) => unit.extractorKind === "structured-regex").length;
+    const fallbackEvidenceTop10 = topUnits.filter((unit) => !unit.extractorKind || unit.extractorKind === "fallback-chunk").length;
+    const parserFallbackCases = topUnits.filter((unit) => unit.extractorKind === "fallback-chunk").length > 0 ? 1 : 0;
     return {
         uniqueTop10Files: uniqueTopFiles,
         duplicateEvidenceTop10,
@@ -137,7 +145,11 @@ function computeRankingQualityMetrics(result, topK = 10) {
         contrastContextTop10: topUnits.filter((unit) => unit.contrastContext).length,
         primarySubsystemTop10,
         subsystemPurityTop10,
-        symbolEvidenceTop10: topUnits.filter((unit) => (unit.symbolMatches?.length ?? 0) > 0 || unit.kind === "symbol").length
+        symbolEvidenceTop10: topUnits.filter((unit) => (unit.symbolMatches?.length ?? 0) > 0 || unit.kind === "symbol").length,
+        treeSitterEvidenceTop10,
+        structuredRegexEvidenceTop10,
+        fallbackEvidenceTop10,
+        parserFallbackCases
     };
 }
 function coverageAt(actualPaths, expectedPaths, k) {

package/dist/pipeline/fileGroups.js

@@ -13,7 +13,13 @@ const rolePriority = {
 function aggregateEvidenceFiles(units) {
     const byPath = new Map();
     for (const unit of units) {
-        byPath.set(unit.relativePath, [...(byPath.get(unit.relativePath) ?? []), unit]);
+        const existing = byPath.get(unit.relativePath);
+        if (existing) {
+            existing.push(unit);
+        }
+        else {
+            byPath.set(unit.relativePath, [unit]);
+        }
     }
     return Array.from(byPath.entries())
         .map(([relativePath, fileUnits]) => toGroup(relativePath, fileUnits))