flowseeker 0.1.7

package/dist/pipeline/evidenceGraph.js

@@ -0,0 +1,389 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boostWithGraph = boostWithGraph;
+exports.buildEvidenceGraph = buildEvidenceGraph;
+exports.extractFrameworkEdges = extractFrameworkEdges;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const dependencyExtractor_1 = require("../index/dependencyExtractor");
+const frameworkEdges_1 = require("../adapters/frameworkEdges");
+const contextBlueprint_1 = require("./contextBlueprint");
+const subsystem_1 = require("./subsystem");
+function boostWithGraph(units, graph) {
+    return units.map((unit) => {
+        const edges = graph.edges.filter((edge) => edge.from === unit.id || edge.to === unit.id);
+        const edgeCount = edges.length;
+        if (edgeCount === 0) {
+            return unit;
+        }
+        const dependencyEdges = edges.filter((edge) => edge.type === "dependency_relation").length;
+        const frameworkEdges = edges.filter((edge) => edge.type.startsWith("framework_")).length;
+        const testEdges = edges.filter((edge) => edge.type === "test_relation").length;
+        const boost = Math.min(5, edgeCount) + Math.min(6, dependencyEdges * 2) + Math.min(6, frameworkEdges * 2) + Math.min(8, testEdges * 3);
+        return {
+            ...unit,
+            score: unit.score + boost,
+            reasons: [...unit.reasons, `${edgeCount} evidence graph edge(s)`, dependencyEdges > 0 ? `${dependencyEdges} dependency edge(s)` : "", frameworkEdges > 0 ? `${frameworkEdges} framework edge(s)` : "", testEdges > 0 ? `${testEdges} test relation(s)` : ""].filter(Boolean)
+        };
+    });
+}
+function buildEvidenceGraph(units) {
+    const edges = [];
+    for (let leftIndex = 0; leftIndex < units.length; leftIndex += 1) {
+        for (let rightIndex = leftIndex + 1; rightIndex < units.length; rightIndex += 1) {
+            const left = units[leftIndex];
+            const right = units[rightIndex];
+            if (left.relativePath === right.relativePath) {
+                edges.push({ from: left.id, to: right.id, type: "same_file", weight: 2 });
+            }
+            if (importsFile(left, right) || importsFile(right, left)) {
+                edges.push({ from: left.id, to: right.id, type: "dependency_relation", weight: 4 });
+            }
+            const sharedTerms = left.matchedTerms.filter((term) => right.matchedTerms.includes(term));
+            if (sharedTerms.length > 0) {
+                edges.push({ from: left.id, to: right.id, type: "same_concept", weight: Math.min(5, sharedTerms.length) });
+            }
+            if ((left.kind === "test" && right.kind !== "test") || (right.kind === "test" && left.kind !== "test")) {
+                const sharedPathStem = stem(left.relativePath) === stem(right.relativePath);
+                if (sharedPathStem || sharedTerms.length > 0) {
+                    edges.push({ from: left.id, to: right.id, type: "test_relation", weight: 5 });
+                }
+            }
+            if ((left.kind === "config" && right.kind !== "config") || (right.kind === "config" && left.kind !== "config")) {
+                if (sharedTerms.length > 0) {
+                    edges.push({ from: left.id, to: right.id, type: "config_relation", weight: 3 });
+                }
+            }
+        }
+    }
+    return { nodes: units, edges };
+}
+function stem(filePath) {
+    const parts = filePath.toLowerCase().split(/[\\/]/);
+    const name = parts.at(-1) ?? filePath;
+    return name.replace(/\.(test|spec)\./, ".").replace(/\.[^.]+$/, "");
+}
+function deduplicateNewUnits(units) {
+    const byId = new Map();
+    for (const unit of units) {
+        const existing = byId.get(unit.id);
+        if (!existing || unit.score > existing.score) {
+            byId.set(unit.id, unit);
+        }
+    }
+    return Array.from(byId.values());
+}
+function importsFile(source, target) {
+    return source.imports.some((importSource) => (0, dependencyExtractor_1.fileMatchesImport)(target.relativePath, importSource));
+}
+async function extractFrameworkEdges(units, onProgress) {
+    const startedAt = Date.now();
+    const maxFrameworkMs = 8000;
+    const timedOut = () => Date.now() - startedAt > maxFrameworkMs;
+    const fileMap = new Map();
+    for (const unit of units) {
+        if (timedOut()) {
+            return { edges: [], newUnits: [] };
+        }
+        const list = fileMap.get(unit.file) ?? [];
+        list.push(unit);
+        fileMap.set(unit.file, list);
+    }
+    const frameworkFiles = [];
+    const frameworkExtensions = new Set([".php", ".py", ".ts", ".tsx", ".js", ".jsx"]);
+    const hasFrameworkFiles = Array.from(fileMap.values()).some((fileUnits) => {
+        const ext = fileUnits[0].relativePath.slice(fileUnits[0].relativePath.lastIndexOf(".")).toLowerCase();
+        return frameworkExtensions.has(ext);
+    });
+    if (!hasFrameworkFiles) {
+        return { edges: [], newUnits: [] };
+    }
+    for (const [absolutePath, fileUnits] of fileMap) {
+        if (timedOut()) {
+            return { edges: [], newUnits: [] };
+        }
+        const relativePath = fileUnits[0].relativePath;
+        let content;
+        try {
+            const stat = await fs.stat(absolutePath);
+            if (stat.size > 500 * 1024) {
+                continue;
+            }
+            content = await fs.readFile(absolutePath, "utf8");
+        }
+        catch {
+            continue;
+        }
+        if (content.includes("\0")) {
+            continue;
+        }
+        const head = content.slice(0, 80000);
+        const framework = (0, frameworkEdges_1.detectFramework)(relativePath, head);
+        if (!framework) {
+            continue;
+        }
+        const extractor = (0, frameworkEdges_1.getFrameworkExtractor)(framework);
+        if (!extractor) {
+            continue;
+        }
+        frameworkFiles.push({
+            absolutePath,
+            relativePath,
+            content: head,
+            unitIds: fileUnits.map((unit) => unit.id)
+        });
+        if (frameworkFiles.length % 10 === 0) {
+            onProgress?.(`Analyzing ${framework} patterns: ${frameworkFiles.length} files...`);
+        }
+    }
+    const workspaceFiles = new Set(frameworkFiles.map((file) => file.relativePath));
+    // Also read files referenced by framework patterns that have no evidence yet.
+    const referencedPaths = [];
+    for (const file of frameworkFiles) {
+        if (timedOut()) {
+            return { edges: [], newUnits: [] };
+        }
+        const framework = (0, frameworkEdges_1.detectFramework)(file.relativePath, file.content);
+        if (framework !== "laravel") {
+            continue;
+        }
+        const refs = resolveReferencedLaravelFiles(file.content, file.relativePath);
+        for (const ref of refs) {
+            if (!workspaceFiles.has(ref) && !referencedPaths.includes(ref)) {
+                referencedPaths.push(ref);
+            }
+        }
+    }
+    if (frameworkFiles.length === 0) {
+        return { edges: [], newUnits: [] };
+    }
+    const firstAbsPath = frameworkFiles[0].absolutePath.replace(/\\/g, "/");
+    const firstRelPath = frameworkFiles[0].relativePath;
+    const rootPath = firstAbsPath.slice(0, firstAbsPath.lastIndexOf(firstRelPath));
+    for (const relativePath of referencedPaths.slice(0, 10)) {
+        if (timedOut()) {
+            break;
+        }
+        const absolutePath = path.resolve(rootPath, relativePath);
+        try {
+            const stat = await fs.stat(absolutePath);
+            if (stat.size > 500 * 1024) {
+                continue;
+            }
+            const content = await fs.readFile(absolutePath, "utf8");
+            frameworkFiles.push({
+                absolutePath,
+                relativePath,
+                content: content.slice(0, 80000),
+                unitIds: []
+            });
+        }
+        catch {
+            // Referenced file does not exist.
+        }
+    }
+    if (frameworkFiles.length === 0) {
+        return { edges: [], newUnits: [] };
+    }
+    const extractor = (0, frameworkEdges_1.getFrameworkExtractor)("laravel");
+    if (!extractor) {
+        return { edges: [], newUnits: [] };
+    }
+    const allUnitIds = new Set(units.map((unit) => unit.id));
+    const frameworkEdges = extractor.extractEdges(frameworkFiles);
+    if (timedOut()) {
+        return { edges: [], newUnits: [] };
+    }
+    const newUnits = [];
+    for (const edge of frameworkEdges) {
+        if (timedOut()) {
+            break;
+        }
+        if (!allUnitIds.has(edge.to)) {
+            const targetFile = units.find((unit) => unit.id.startsWith(edge.to.split(":")[0] + ":"));
+            const sourceUnit = units.find((unit) => unit.id === edge.from);
+            if (!targetFile && sourceUnit) {
+                const targetRelativePath = edge.to.split(":").slice(0, -2).join(":");
+                newUnits.push(createFrameworkDiscoveredUnit(targetRelativePath, edge, sourceUnit));
+            }
+        }
+        if (!allUnitIds.has(edge.from)) {
+            const sourceUnit = units.find((unit) => unit.id === edge.to);
+            if (sourceUnit) {
+                const sourceRelativePath = edge.from.split(":").slice(0, -2).join(":");
+                newUnits.push(createFrameworkDiscoveredUnit(sourceRelativePath, edge, sourceUnit));
+            }
+        }
+    }
+    return { edges: frameworkEdges, newUnits: deduplicateNewUnits(newUnits) };
+}
+function createFrameworkDiscoveredUnit(relativePath, edge, source) {
+    const role = findConnectedRole(edge.type);
+    const kind = "code_region";
+    const subsystemTerms = (0, subsystem_1.inferSubsystemTerms)(relativePath);
+    return {
+        id: `${relativePath}:1:1:code_region:fw`,
+        kind,
+        role,
+        file: source.file.replace(source.relativePath, relativePath),
+        relativePath,
+        range: { startLine: 1, endLine: 1 },
+        slot: (0, contextBlueprint_1.detectContextSlot)(relativePath, kind, role),
+        score: edge.weight * 12 + 6,
+        confidence: 0.40,
+        tier: "low",
+        frameworkEdgeReason: `framework ${edge.type} from ${source.relativePath}`,
+        subsystem: subsystemTerms[0],
+        subsystemTerms,
+        reasons: [`framework ${edge.type} from ${source.relativePath}`],
+        snippet: undefined,
+        matchedTerms: source.matchedTerms.slice(0, 3),
+        retrievalPasses: source.retrievalPasses,
+        imports: [source.relativePath]
+    };
+}
+function resolveReferencedLaravelFiles(content, relativePath) {
+    const paths = [];
+    const imports = parsePhpUseStatements(content);
+    // Extract class references from route definitions, event dispatches, DI, etc.
+    const classRefs = new Set();
+    const routePattern = /\[(\w+)::class\s*,\s*'(\w+)'\]/g;
+    let match = routePattern.exec(content);
+    while (match) {
+        classRefs.add(match[1]);
+        match = routePattern.exec(content);
+    }
+    const eventPattern = /event\s*\(\s*new\s+(\w+)\s*\(/g;
+    match = eventPattern.exec(content);
+    while (match) {
+        classRefs.add(match[1]);
+        match = eventPattern.exec(content);
+    }
+    const dispatchPattern = /(\w+)::dispatch\s*\(/g;
+    match = dispatchPattern.exec(content);
+    while (match) {
+        classRefs.add(match[1]);
+        match = dispatchPattern.exec(content);
+    }
+    const diPattern = /(?:private|protected|public)\s+(?:readonly\s+)?(\w+)\s+\$\w+/g;
+    match = diPattern.exec(content);
+    while (match) {
+        classRefs.add(match[1]);
+        match = diPattern.exec(content);
+    }
+    for (const className of classRefs) {
+        const fqcn = imports.get(className) ?? className;
+        const resolved = resolveLaravelPsr4Path(fqcn, className);
+        if (resolved) {
+            paths.push(resolved);
+        }
+    }
+    return [...new Set(paths)];
+}
+function parsePhpUseStatements(content) {
+    const imports = new Map();
+    const pattern = /^use\s+([A-Za-z0-9_\\]+?)(?:\s+as\s+(\w+))?\s*;/gm;
+    let match = pattern.exec(content);
+    while (match) {
+        const fqcn = match[1];
+        const alias = match[2] ?? fqcn.split("\\").pop() ?? fqcn;
+        imports.set(alias, fqcn);
+        match = pattern.exec(content);
+    }
+    return imports;
+}
+function resolveLaravelPsr4Path(fqcnOrClass, shortName) {
+    const knownMappings = [
+        { pattern: /\\Controllers\\/, path: "app/Http/Controllers" },
+        { pattern: /\\Services\\/, path: "app/Services" },
+        { pattern: /\\Repositories\\/, path: "app/Repositories" },
+        { pattern: /\\Events\\/, path: "app/Events" },
+        { pattern: /\\Listeners\\/, path: "app/Listeners" },
+        { pattern: /\\Jobs\\/, path: "app/Jobs" },
+        { pattern: /\\Mail\\/, path: "app/Mail" },
+        { pattern: /\\Models\\/, path: "app/Models" },
+        { pattern: /\\Middleware\\/, path: "app/Http/Middleware" },
+        { pattern: /\\Policies\\/, path: "app/Policies" },
+        { pattern: /\\Commands\\/, path: "app/Console/Commands" },
+        { pattern: /\\Providers\\/, path: "app/Providers" },
+        { pattern: /\\Exceptions\\/, path: "app/Exceptions" },
+        { pattern: /\\Rules\\/, path: "app/Rules" },
+        { pattern: /\\Requests\\/, path: "app/Http/Requests" },
+        { pattern: /\\Resources\\/, path: "app/Http/Resources" },
+        { pattern: /\\Notifications\\/, path: "app/Notifications" },
+        { pattern: /\\Enums\\/, path: "app/Enums" },
+        { pattern: /Controller$/, path: "app/Http/Controllers" },
+        { pattern: /Service$/, path: "app/Services" },
+        { pattern: /Event$/, path: "app/Events" },
+        { pattern: /Listener$/, path: "app/Listeners" },
+        { pattern: /Job$/, path: "app/Jobs" },
+        { pattern: /Mail$/, path: "app/Mail" },
+        { pattern: /Model$/, path: "app/Models" },
+    ];
+    // Try FQCN-based resolution first
+    for (const { pattern, path: folder } of knownMappings) {
+        if (pattern.test(fqcnOrClass)) {
+            return `${folder}/${shortName}.php`;
+        }
+    }
+    // Fallback: guess from namespace segments
+    const segments = fqcnOrClass.split("\\").filter(Boolean);
+    if (segments.length >= 3 && segments[0] === "App") {
+        const category = segments[segments.length - 2];
+        const guess = `app/${category}/${shortName}.php`;
+        return guess;
+    }
+    return `app/${shortName}.php`;
+}
+function findConnectedRole(edgeType) {
+    switch (edgeType) {
+        case "framework_route_handler":
+            return "impact";
+        case "framework_event_dispatch":
+            return "read_context";
+        case "framework_service_dependency":
+            return "read_context";
+        case "framework_job_dispatch":
+            return "read_context";
+        case "framework_config_usage":
+            return "read_context";
+        case "framework_view_render":
+            return "impact";
+        default:
+            return "unknown";
+    }
+}
+//# sourceMappingURL=evidenceGraph.js.map

package/dist/pipeline/feedback.js

@@ -0,0 +1,215 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFeedbackSnapshot = createFeedbackSnapshot;
+exports.createFeedbackRecord = createFeedbackRecord;
+exports.writeFeedbackRecord = writeFeedbackRecord;
+exports.readFeedbackRecords = readFeedbackRecords;
+exports.feedbackDirectory = feedbackDirectory;
+exports.normalizeFeedbackKind = normalizeFeedbackKind;
+exports.feedbackKindLabel = feedbackKindLabel;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const fileGroups_1 = require("./fileGroups");
+const canonicalFeedbackKinds = [
+    "relevant",
+    "missing_file",
+    "not_relevant",
+    "agent_needed_more_context"
+];
+function createFeedbackSnapshot(result, workspacePath, workspaceName) {
+    const topFiles = (0, fileGroups_1.aggregateEvidenceFiles)(result.units)
+        .slice(0, 20)
+        .map((group) => ({
+        relativePath: group.relativePath,
+        role: group.role,
+        slot: group.slot,
+        score: Number(group.score.toFixed(2)),
+        evidence: group.unitCount
+    }));
+    return {
+        schemaVersion: 1,
+        id: crypto.randomUUID(),
+        createdAt: new Date().toISOString(),
+        workspacePath,
+        workspaceName,
+        task: result.task,
+        intent: result.profile.intent,
+        keywords: result.profile.keywords.slice(0, 40),
+        strategies: result.profile.strategies,
+        requiredSlots: result.contextCoverage?.requiredSlots ?? result.profile.blueprint.requiredSlots,
+        missingRequiredSlots: result.contextCoverage?.missingRequiredSlots ?? [],
+        topFiles,
+        tokenSavings: result.tokenSavings ? summarizeTokenSavings(result.tokenSavings) : undefined,
+        stats: {
+            discoveredFiles: result.stats.discoveredFiles,
+            scannedFiles: result.stats.scannedFiles,
+            skippedFiles: result.stats.skippedFiles,
+            rawEvidenceCount: result.stats.rawEvidenceCount,
+            rankedEvidenceCount: result.stats.rankedEvidenceCount,
+            stoppedEarly: result.stats.stoppedEarly,
+            stopReason: result.stats.stopReason
+        }
+    };
+}
+function createFeedbackRecord(run, kind, options = { source: "manual" }) {
+    return {
+        schemaVersion: 1,
+        id: crypto.randomUUID(),
+        createdAt: new Date().toISOString(),
+        source: options.source,
+        kind,
+        note: options.note?.trim() || undefined,
+        run,
+        outcome: {
+            aiNeededMoreContext: kind === "missing_file" || kind === "agent_needed_more_context"
+        }
+    };
+}
+async function writeFeedbackRecord(workspacePath, record) {
+    const directoryPath = feedbackDirectory(workspacePath);
+    await fs.mkdir(directoryPath, { recursive: true });
+    const filePath = path.join(directoryPath, `${safeFilePart(record.createdAt)}-${safeFilePart(record.id)}.json`);
+    await fs.writeFile(filePath, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+    return filePath;
+}
+async function readFeedbackRecords(workspacePath, directoryPath = feedbackDirectory(workspacePath)) {
+    const files = await collectJsonFiles(path.resolve(directoryPath)).catch(() => []);
+    const records = [];
+    for (const filePath of files) {
+        try {
+            const text = await fs.readFile(filePath, "utf8");
+            const parsed = JSON.parse(text);
+            if (isFeedbackRecord(parsed)) {
+                const kind = normalizeFeedbackKind(parsed.kind);
+                if (!kind) {
+                    continue;
+                }
+                records.push({
+                    filePath,
+                    record: {
+                        ...parsed,
+                        kind,
+                        outcome: {
+                            ...parsed.outcome,
+                            aiNeededMoreContext: parsed.outcome?.aiNeededMoreContext === true ||
+                                kind === "missing_file" ||
+                                kind === "agent_needed_more_context"
+                        }
+                    }
+                });
+            }
+        }
+        catch {
+            // Ignore malformed local feedback files so one bad note does not block replay.
+        }
+    }
+    return records.sort((left, right) => left.record.createdAt.localeCompare(right.record.createdAt));
+}
+function feedbackDirectory(workspacePath) {
+    return path.join(workspacePath, ".flowseeker", "feedback");
+}
+function normalizeFeedbackKind(value) {
+    if (canonicalFeedbackKinds.includes(value)) {
+        return value;
+    }
+    switch (value) {
+        case "missing_files":
+            return "missing_file";
+        case "irrelevant":
+            return "not_relevant";
+        case "ai_needs_more":
+            return "agent_needed_more_context";
+        default:
+            return undefined;
+    }
+}
+function feedbackKindLabel(kind) {
+    switch (kind) {
+        case "relevant":
+            return "Relevant";
+        case "missing_file":
+            return "Missing file/context";
+        case "not_relevant":
+            return "Not relevant";
+        case "agent_needed_more_context":
+            return "AI needed more context";
+    }
+}
+function summarizeTokenSavings(metrics) {
+    return {
+        status: metrics.status,
+        basis: metrics.basis,
+        method: metrics.method,
+        tokenizer: metrics.tokenizer,
+        workspaceTokensEstimate: metrics.workspaceTokensEstimate,
+        candidateTokensEstimate: metrics.candidateTokensEstimate,
+        solvePacketTokensEstimate: metrics.solvePacketTokensEstimate,
+        reductionPercent: metrics.reductionPercent,
+        proofStatus: metrics.proofStatus,
+        proofWarnings: metrics.proofWarnings
+    };
+}
+async function collectJsonFiles(directoryPath) {
+    const entries = await fs.readdir(directoryPath, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const absolutePath = path.join(directoryPath, entry.name);
+        if (entry.isDirectory()) {
+            const childFiles = await collectJsonFiles(absolutePath);
+            files.push(...childFiles);
+        }
+        else if (entry.isFile() && entry.name.endsWith(".json")) {
+            files.push(absolutePath);
+        }
+    }
+    return files;
+}
+function isFeedbackRecord(value) {
+    const candidate = value;
+    return Boolean(candidate &&
+        candidate.schemaVersion === 1 &&
+        typeof candidate.id === "string" &&
+        typeof candidate.createdAt === "string" &&
+        normalizeFeedbackKind(candidate.kind) &&
+        candidate.run &&
+        typeof candidate.run.task === "string" &&
+        typeof candidate.run.workspacePath === "string");
+}
+function safeFilePart(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "feedback";
+}
+//# sourceMappingURL=feedback.js.map

package/dist/pipeline/fileGroups.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateEvidenceFiles = aggregateEvidenceFiles;
+exports.selectDiverseEvidenceUnits = selectDiverseEvidenceUnits;
+const rolePriority = {
+    edit_candidate: 6,
+    test: 5,
+    read_context: 4,
+    impact: 3,
+    verify: 2,
+    unknown: 1
+};
+function aggregateEvidenceFiles(units) {
+    const byPath = new Map();
+    for (const unit of units) {
+        byPath.set(unit.relativePath, [...(byPath.get(unit.relativePath) ?? []), unit]);
+    }
+    return Array.from(byPath.entries())
+        .map(([relativePath, fileUnits]) => toGroup(relativePath, fileUnits))
+        .sort((left, right) => {
+        const roleDelta = rolePriority[right.role] - rolePriority[left.role];
+        if (roleDelta !== 0) {
+            return roleDelta;
+        }
+        return right.score - left.score;
+    });
+}
+function selectDiverseEvidenceUnits(units, maxPerFile = 2) {
+    const counts = new Map();
+    const selected = [];
+    for (const unit of units) {
+        const count = counts.get(unit.relativePath) ?? 0;
+        if (count >= maxPerFile) {
+            continue;
+        }
+        counts.set(unit.relativePath, count + 1);
+        selected.push(unit);
+    }
+    return selected;
+}
+function toGroup(relativePath, units) {
+    const sortedUnits = [...units].sort((left, right) => right.score - left.score);
+    const best = sortedUnits[0];
+    const duplicateUnitCount = units.filter((unit) => unit.isDuplicate).length;
+    const uniqueEvidenceCount = Math.max(1, units.length - duplicateUnitCount);
+    const score = best.score + Math.min(10, uniqueEvidenceCount * 1.5);
+    const confidence = Math.max(...units.map((unit) => unit.confidence));
+    const role = bestRole(units);
+    return {
+        file: best.file,
+        relativePath,
+        role,
+        slot: bestSlot(units),
+        kinds: unique(units.map((unit) => unit.kind)),
+        score,
+        confidence,
+        tier: confidence >= 0.75 ? "high" : confidence >= 0.45 ? "medium" : "low",
+        unitCount: units.length,
+        duplicateUnitCount,
+        contrastContext: units.length > 0 && units.every((unit) => unit.contrastContext),
+        subsystem: best.subsystem,
+        subsystemTerms: unique(units.flatMap((unit) => unit.subsystemTerms ?? [])).slice(0, 8),
+        symbols: unique(units.flatMap((unit) => unit.symbols ?? [])).slice(0, 12),
+        ranges: units.flatMap((unit) => (unit.range ? [unit.range] : [])),
+        reasons: unique(units.flatMap((unit) => unit.reasons)).slice(0, 8),
+        retrievalPasses: unique(units.flatMap((unit) => unit.retrievalPasses)),
+        imports: unique(units.flatMap((unit) => unit.imports)).slice(0, 12),
+        units: sortedUnits
+    };
+}
+function bestRole(units) {
+    return [...units].sort((left, right) => rolePriority[right.role] - rolePriority[left.role])[0].role;
+}
+function bestSlot(units) {
+    const counts = new Map();
+    for (const unit of units) {
+        counts.set(unit.slot ?? "unknown", (counts.get(unit.slot ?? "unknown") ?? 0) + 1);
+    }
+    return Array.from(counts.entries()).sort((left, right) => right[1] - left[1])[0]?.[0] ?? "unknown";
+}
+function unique(values) {
+    return Array.from(new Set(values));
+}
+//# sourceMappingURL=fileGroups.js.map