flowseeker 0.1.8 → 0.1.9

package/dist/mcp/mcpTools.js

@@ -8,6 +8,39 @@
  *
  * Tools run the headless pipeline (no VS Code dependency) and return structured results.
  */
+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.MCP_PROMPT_DEFINITIONS = exports.TOOL_DEFINITIONS = void 0;
 exports.handleToolCall = handleToolCall;
@@ -18,6 +51,11 @@ const solvePacket_1 = require("../pipeline/solvePacket");
 const agentPromptHeadless_1 = require("../pipeline/agentPromptHeadless");
 const fileGroups_1 = require("../pipeline/fileGroups");
 const tokenSavings_1 = require("../pipeline/tokenSavings");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const evaluationMetrics_1 = require("../pipeline/evaluationMetrics");
+const embeddingProviders_1 = require("../gateway/embeddingProviders");
+const workspaceIndex_1 = require("../index/workspaceIndex");
 exports.TOOL_DEFINITIONS = [
     {
         name: "flowseeker_retrieve",
@@ -98,6 +136,142 @@ exports.TOOL_DEFINITIONS = [
             },
             required: ["task"]
         }
+    },
+    {
+        name: "flowseeker_validate_plan",
+        description: "Validate a proposed edit plan against FlowSeeker retrieval evidence. Checks whether proposed edit files match primary edit candidates, warns if files should be read-only, and flags missing required slots. Returns a verdict (safe/caution/risky/insufficient_evidence) with suggested corrections.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                task: {
+                    type: "string",
+                    description: "Natural-language coding task to validate the plan against."
+                },
+                workspaceRoot: {
+                    type: "string",
+                    description: "Workspace root path. Defaults to current working directory."
+                },
+                proposedEditFiles: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Files the agent plans to edit (workspace-relative paths)."
+                },
+                proposedReadFiles: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Files the agent plans to read (workspace-relative paths)."
+                },
+                proposedTestFiles: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Files the agent plans to use for testing/verification."
+                },
+                riskMode: {
+                    type: "string",
+                    enum: ["strict", "balanced", "broad"],
+                    description: "Risk tolerance. strict: unsupported edits are risky. balanced: caution unless clearly dangerous. broad: permissive but warns on noise. Default: balanced."
+                }
+            },
+            required: ["task", "proposedEditFiles"]
+        }
+    },
+    {
+        name: "flowseeker_context",
+        description: "Canonical FlowSeeker context tool. Returns task-relevant files, roles, slots, and evidence in the requested output profile (json/agent/human/compact). Replaces the need to choose between retrieve/guide/auto/files.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                task: { type: "string", description: "Natural-language coding task to find context for." },
+                workspaceRoot: { type: "string", description: "Workspace root path. Defaults to current working directory." },
+                workspace: { type: "string", description: "Alias for workspaceRoot." },
+                outputProfile: { type: "string", enum: ["json", "agent", "human", "compact"], description: "Output format. json: structured JSON. agent: guidance prompt. human: readable Solve Packet. compact: top files only. Default: json." },
+                mode: { type: "string", enum: ["auto", "deterministic", "hybrid-safe", "hybrid-aggressive", "semantic-only"], description: "Retrieval mode. Currently only deterministic is fully supported. Default: auto -> deterministic." },
+                depth: { type: "string", enum: ["quick", "standard", "deep"], description: "Scan depth. Currently only standard is fully supported. Default: standard." },
+                tokenBudget: { type: "number", description: "Approximate token budget for context. Acceptable, currently report-only." },
+                maxFiles: { type: "number", description: "Maximum files to scan. Default: 5000." },
+                includeSnippets: { type: "boolean", description: "Include code snippets in output. Default: true." }
+            },
+            required: ["task"]
+        }
+    },
+    {
+        name: "flowseeker_inspect",
+        description: "Inspect specific files against FlowSeeker retrieval evidence. Returns roles, scores, evidence chunks, snippets, retrieval trace, and honest edit guidance per file.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                task: { type: "string", description: "Natural-language coding task to retrieve context for." },
+                workspaceRoot: { type: "string", description: "Workspace root path. Defaults to current working directory." },
+                workspace: { type: "string", description: "Alias for workspaceRoot." },
+                files: { type: "array", items: { type: "string" }, description: "Workspace-relative file paths to inspect." },
+                maxSnippetsPerFile: { type: "number", description: "Max snippets to include per file. Default: 3." },
+                includeGraphNeighbors: { type: "boolean", description: "Include graph neighbor hints when available. Currently report-only." },
+                outputProfile: { type: "string", enum: ["json", "human"], description: "Output format. json: structured JSON. human: readable inspection report. Default: json." }
+            },
+            required: ["task", "files"]
+        }
+    },
+    {
+        name: "flowseeker_expand",
+        description: "Expand context for a specific slot. Given a task and a target slot (e.g. side_effect, domain, permission), returns files that can fill that missing context. Use anchor files to guide expansion.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                task: { type: "string", description: "Natural-language coding task to find context for." },
+                slot: { type: "string", description: "Target context slot to expand (e.g. side_effect, domain, permission, validation, handler, data, config, tests)." },
+                workspaceRoot: { type: "string", description: "Workspace root path. Defaults to current working directory." },
+                workspace: { type: "string", description: "Alias for workspaceRoot." },
+                anchorFiles: { type: "array", items: { type: "string" }, description: "Files the agent already has context for. Used to prefer connected candidates." },
+                maxFiles: { type: "number", description: "Max expansion candidates to return. Default: 15." },
+                outputProfile: { type: "string", enum: ["json", "human"], description: "Output format. json: structured JSON. human: readable expansion report. Default: json." }
+            },
+            required: ["task", "slot"]
+        }
+    },
+    {
+        name: "flowseeker_status",
+        description: "Check FlowSeeker readiness: version, workspace config, deterministic/semantic/local model status, index/cache state, and next actions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                workspaceRoot: { type: "string", description: "Workspace root path. Defaults to current working directory." },
+                workspace: { type: "string", description: "Alias for workspaceRoot." },
+                outputProfile: { type: "string", enum: ["json", "human"], description: "Output format. json: structured JSON. human: readable report. Default: json." }
+            },
+            required: []
+        }
+    },
+    {
+        name: "flowseeker_index",
+        description: "Check or build the FlowSeeker workspace index. action=status reports index state. action=build runs safe indexing. Destructive actions (clean, rebuild, delete, reset, remove, purge) are rejected.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: { type: "string", enum: ["status", "build"], description: "Action: status (read-only) or build (safe indexing)." },
+                workspaceRoot: { type: "string", description: "Workspace root path. Defaults to current working directory." },
+                workspace: { type: "string", description: "Alias for workspaceRoot." },
+                outputProfile: { type: "string", enum: ["json", "human"], description: "Output format. json: structured JSON. human: readable report. Default: json." },
+                maxFiles: { type: "number", description: "Max files to index (for build). Default: 5000." }
+            },
+            required: ["action"]
+        }
+    },
+    {
+        name: "flowseeker_feedback",
+        description: "Append lightweight labels to FlowSeeker feedback for future golden replay and accuracy improvement. Labels: useful, wrong, missing, edited, test_used, should_not_edit.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                task: { type: "string", description: "The coding task this feedback applies to." },
+                label: { type: "string", enum: ["useful", "wrong", "missing", "edited", "test_used", "should_not_edit"], description: "Feedback label." },
+                files: { type: "array", items: { type: "string" }, description: "Workspace-relative file paths related to this feedback." },
+                notes: { type: "string", description: "Optional human-readable notes about this feedback." },
+                workspaceRoot: { type: "string", description: "Workspace root path. Defaults to current working directory." },
+                workspace: { type: "string", description: "Alias for workspaceRoot." },
+                outputProfile: { type: "string", enum: ["json", "human"], description: "Output format. Default: json." }
+            },
+            required: ["task", "label"]
+        }
     }
 ];
 exports.MCP_PROMPT_DEFINITIONS = [
@@ -141,10 +315,164 @@ exports.MCP_PROMPT_DEFINITIONS = [
             { name: "workspace", description: "Optional workspace root path." },
             { name: "limit", description: "Optional maximum number of files to return." }
         ]
+    },
+    {
+        name: "validate-plan",
+        description: "Validate a proposed edit plan against FlowSeeker retrieval evidence.",
+        toolName: "flowseeker_validate_plan",
+        toolPurpose: "return a safety verdict with issues, suggested edit/read/test files, and missing slots",
+        arguments: [
+            { name: "task", description: "Natural-language coding task.", required: true },
+            { name: "proposedEditFiles", description: "Files the agent plans to edit.", required: true },
+            { name: "workspaceRoot", description: "Optional workspace root path." },
+            { name: "proposedReadFiles", description: "Optional files the agent plans to read." },
+            { name: "proposedTestFiles", description: "Optional files for testing/verification." },
+            { name: "riskMode", description: "Risk tolerance: strict, balanced, or broad. Default: balanced." }
+        ]
+    },
+    {
+        name: "context",
+        description: "Canonical FlowSeeker context tool -- structured JSON, agent guidance, human report, or compact top-files list.",
+        toolName: "flowseeker_context",
+        toolPurpose: "return task context in the requested output profile (json/agent/human/compact)",
+        arguments: [
+            { name: "task", description: "Natural-language coding task.", required: true },
+            { name: "outputProfile", description: "Output format: json, agent, human, or compact. Default: json." },
+            { name: "workspaceRoot", description: "Optional workspace root path." },
+            { name: "mode", description: "Retrieval mode. Default: auto -> deterministic." },
+            { name: "depth", description: "Scan depth. Default: standard." },
+            { name: "tokenBudget", description: "Optional token budget." },
+            { name: "maxFiles", description: "Optional max files." },
+            { name: "includeSnippets", description: "Include snippets. Default: true." }
+        ]
+    },
+    {
+        name: "inspect",
+        description: "Inspect specific files against FlowSeeker evidence -- roles, scores, chunks, snippets, and edit guidance.",
+        toolName: "flowseeker_inspect",
+        toolPurpose: "return per-file inspection with roles, evidence, and edit guidance (json/human)",
+        arguments: [
+            { name: "task", description: "Natural-language coding task.", required: true },
+            { name: "files", description: "Workspace-relative file paths to inspect.", required: true },
+            { name: "workspaceRoot", description: "Optional workspace root path." },
+            { name: "maxSnippetsPerFile", description: "Max snippets per file. Default: 3." },
+            { name: "includeGraphNeighbors", description: "Include graph neighbor hints. Report-only in this sprint." },
+            { name: "outputProfile", description: "Output format: json or human. Default: json." }
+        ]
+    },
+    {
+        name: "expand",
+        description: "Expand context for a specific slot -- returns files to read next to close missing context.",
+        toolName: "flowseeker_expand",
+        toolPurpose: "return slot-specific expansion candidates with reasons and edit guidance (json/human)",
+        arguments: [
+            { name: "task", description: "Natural-language coding task.", required: true },
+            { name: "slot", description: "Target context slot to expand.", required: true },
+            { name: "workspaceRoot", description: "Optional workspace root path." },
+            { name: "anchorFiles", description: "Files the agent already has context for." },
+            { name: "maxFiles", description: "Max expansion candidates. Default: 15." },
+            { name: "outputProfile", description: "Output format: json or human. Default: json." }
+        ]
+    },
+    {
+        name: "status",
+        description: "Check FlowSeeker readiness: version, config, deterministic/semantic/local model status, index state, next actions.",
+        toolName: "flowseeker_status",
+        toolPurpose: "return workspace-level FlowSeeker readiness report (json/human)",
+        arguments: [
+            { name: "workspaceRoot", description: "Optional workspace root path." },
+            { name: "outputProfile", description: "Output format: json or human. Default: json." }
+        ]
+    },
+    {
+        name: "index",
+        description: "Check or build the FlowSeeker workspace index safely.",
+        toolName: "flowseeker_index",
+        toolPurpose: "return index status or trigger safe build (json/human)",
+        arguments: [
+            { name: "action", description: "Action: status (read-only) or build (safe indexing).", required: true },
+            { name: "workspaceRoot", description: "Optional workspace root path." },
+            { name: "maxFiles", description: "Max files to index (for build). Default: 5000." },
+            { name: "outputProfile", description: "Output format: json or human. Default: json." }
+        ]
+    },
+    {
+        name: "feedback",
+        description: "Append labels to FlowSeeker feedback for future accuracy improvement.",
+        toolName: "flowseeker_feedback",
+        toolPurpose: "append a lightweight labeled record to .flowseeker/feedback/ (json/human)",
+        arguments: [
+            { name: "task", description: "The coding task this feedback applies to.", required: true },
+            { name: "label", description: "Feedback label.", required: true },
+            { name: "files", description: "Related workspace-relative file paths." },
+            { name: "notes", description: "Optional notes." },
+            { name: "workspaceRoot", description: "Optional workspace root path." },
+            { name: "outputProfile", description: "Output format: json or human. Default: json." }
+        ]
     }
 ];
 async function handleToolCall(toolName, input, defaultWorkspace) {
     const workspace = input.workspace ?? defaultWorkspace;
+    // Route validate_plan before generic task validation -- it has its own
+    // input validation that returns structured JSON for bad task input.
+    if (toolName === "flowseeker_validate_plan") {
+        try {
+            return await handleValidatePlan(input, workspace);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return errorResult(`FlowSeeker failed: ${message}`);
+        }
+    }
+    // Route inspect before generic task validation -- it validates files separately.
+    if (toolName === "flowseeker_inspect") {
+        try {
+            return await handleInspect(input, workspace);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return errorResult(`FlowSeeker failed: ${message}`);
+        }
+    }
+    // Route expand before generic task validation -- it validates slot separately.
+    if (toolName === "flowseeker_expand") {
+        try {
+            return await handleExpand(input, workspace);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return errorResult(`FlowSeeker failed: ${message}`);
+        }
+    }
+    // Route status/index before generic task validation -- they don't need task.
+    if (toolName === "flowseeker_status") {
+        try {
+            return await handleStatus(input, workspace);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return errorResult(`FlowSeeker failed: ${message}`);
+        }
+    }
+    if (toolName === "flowseeker_index") {
+        try {
+            return await handleIndex(input, workspace);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return errorResult(`FlowSeeker failed: ${message}`);
+        }
+    }
+    // Route feedback before generic task validation -- it validates label separately.
+    if (toolName === "flowseeker_feedback") {
+        try {
+            return await handleFeedback(input, workspace);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return errorResult(`FlowSeeker failed: ${message}`);
+        }
+    }
     const task = input.task?.trim();
     if (!task) {
         return errorResult("A task description is required.");
@@ -159,6 +487,8 @@ async function handleToolCall(toolName, input, defaultWorkspace) {
                 return await handleAuto(task, workspace);
             case "flowseeker_files":
                 return await handleFiles(task, workspace, input.limit);
+            case "flowseeker_context":
+                return await handleContext(input, workspace);
             default:
                 return errorResult(`Unknown tool: ${toolName}`);
         }
@@ -168,7 +498,7 @@ async function handleToolCall(toolName, input, defaultWorkspace) {
         return errorResult(`FlowSeeker failed: ${message}`);
     }
 }
-// ── Individual Handlers ───────────────────────────────────────────────
+// -- Individual Handlers -----------------------------------------------
 async function handleRetrieve(task, workspace, maxFiles) {
     const result = await runPipeline(task, workspace, maxFiles);
     const packet = result.solvePacket
@@ -228,7 +558,7 @@ async function handleFiles(task, workspace, limit) {
     }
     return textResult(lines.join("\n"));
 }
-// ── Helpers ───────────────────────────────────────────────────────────
+// -- Helpers -----------------------------------------------------------
 async function runPipeline(task, workspace, maxFiles) {
     const baseConfig = await (0, loadConfigFromPath_1.loadConfigFromPath)(workspace);
     const config = maxFiles && maxFiles > 0
@@ -257,10 +587,1305 @@ function formatResultSummary(result) {
     }
     return parts.join("\n");
 }
+async function handleContext(input, defaultWorkspace) {
+    var task = (input.task || "").trim();
+    var workspace = input.workspaceRoot || input.workspace || defaultWorkspace;
+    var profile = input.outputProfile || "json";
+    var mode = input.mode || "auto";
+    var depth = input.depth || "standard";
+    var includeSnippets = input.includeSnippets !== false;
+    if (!task) {
+        return errorResult("task must be a non-empty string");
+    }
+    // Validate inputs
+    var validProfiles = ["json", "agent", "human", "compact"];
+    var validModes = ["auto", "deterministic", "hybrid-safe", "hybrid-aggressive", "semantic-only"];
+    var validDepths = ["quick", "standard", "deep"];
+    if (validProfiles.indexOf(profile) < 0) {
+        return errorResult("invalid outputProfile: " + profile + ". Must be one of: " + validProfiles.join(", "));
+    }
+    if (validModes.indexOf(mode) < 0) {
+        return errorResult("invalid mode: " + mode + ". Must be one of: " + validModes.join(", "));
+    }
+    if (validDepths.indexOf(depth) < 0) {
+        return errorResult("invalid depth: " + depth + ". Must be one of: " + validDepths.join(", "));
+    }
+    // Resolve effective mode/depth
+    var effectiveMode = mode === "auto" ? "deterministic" : mode;
+    var effectiveDepth = depth;
+    var warnings = [];
+    if (effectiveMode !== "deterministic") {
+        warnings.push("mode=" + effectiveMode + " is accepted but report-only; only deterministic retrieval is active");
+    }
+    if (effectiveDepth !== "standard") {
+        warnings.push("depth=" + effectiveDepth + " is accepted but report-only; only standard depth is active");
+    }
+    if (input.tokenBudget !== undefined) {
+        warnings.push("tokenBudget is accepted but report-only");
+    }
+    if (!includeSnippets) {
+        warnings.push("includeSnippets=false: snippets omitted");
+    }
+    // Run retrieval
+    var result = await runPipeline(task, workspace, input.maxFiles);
+    var packet = result.solvePacket;
+    var groups = (0, fileGroups_1.aggregateEvidenceFiles)(result.units);
+    if (profile === "json") {
+        var modeDiagWarnings = [];
+        if (effectiveMode === "semantic-only") {
+            modeDiagWarnings.push("semantic-only is diagnostic/evaluation only; deterministic retrieval remains the active production path");
+        }
+        var modeDiagnostic = {
+            requestedMode: mode,
+            effectiveMode: effectiveMode,
+            status: effectiveMode === "semantic-only" ? "diagnostic_only" : effectiveMode === "deterministic" ? "active" : "report_only",
+            reportOnly: effectiveMode !== "deterministic",
+            rankingChanged: false,
+            primaryCandidatesChanged: false,
+            reason: effectiveMode === "semantic-only"
+                ? "semantic-only is diagnostic/evaluation only; firstFiles and primaryEditCandidates remain deterministic"
+                : effectiveMode === "deterministic"
+                    ? "deterministic mode active; no semantic retrieval configured by default"
+                    : "non-deterministic mode requested; output remains deterministic until hybrid-safe is implemented",
+            warnings: modeDiagWarnings,
+        };
+        var output = {
+            schemaVersion: "2.0.0",
+            tool: "flowseeker_context",
+            task: task,
+            workspaceRoot: workspace,
+            outputProfile: profile,
+            requestedMode: mode,
+            effectiveMode: effectiveMode,
+            requestedDepth: depth,
+            effectiveDepth: effectiveDepth,
+            modeDiagnostic: modeDiagnostic,
+            summary: formatResultSummary(result),
+            confidence: result.profile.intentConfidence,
+            firstFiles: packet?.firstThreeFiles || [],
+            primaryEditCandidates: (packet?.primaryEditCandidates || []).slice(0, 7).map(function (f) { return { path: f.relativePath, role: f.role, kind: f.kind, slot: f.slot, score: f.score, tier: f.tier, reasons: f.reasons }; }),
+            readOnlyContext: (packet?.readOnlyContext || []).slice(0, 7).map(function (f) { return { path: f.relativePath, role: f.role, slot: f.slot, score: f.score }; }),
+            verificationTargets: (packet?.verificationTargets || []).slice(0, 5).map(function (f) { return { path: f.relativePath, role: f.role, slot: f.slot, score: f.score }; }),
+            doNotEditYet: packet?.doNotEditYet || [],
+            missingSlots: result.contextCoverage?.missingRequiredSlots || [],
+            semanticDiagnostic: result.stats.semanticRetrievalStatus || "disabled",
+            semanticChunkDiagnostic: result.stats.semanticChunkDiagnostic || null,
+            roleRefinement: result.stats.roleRefinementMode || "off",
+            warnings: warnings,
+        };
+        return textResult(JSON.stringify(output, null, 2));
+    }
+    if (profile === "agent") {
+        var agentPrompt = require("../pipeline/agentPromptHeadless").createAgentSolvePromptHeadless(result);
+        var agentLines = [
+            "# FlowSeeker Agent Context",
+            "",
+            "Task: " + task,
+            "Intent: " + result.profile.intent + " | Confidence: " + result.profile.intentConfidence,
+            "",
+            agentPrompt,
+        ];
+        if (warnings.length > 0) {
+            agentLines.push("", "## Warnings", "");
+            for (var w = 0; w < warnings.length; w++)
+                agentLines.push("- " + warnings[w]);
+        }
+        return textResult(agentLines.join("\n"));
+    }
+    if (profile === "human") {
+        var packetMd = packet ? (0, solvePacket_1.renderSolvePacketMarkdown)(packet) : result.contextPack;
+        var summary = formatResultSummary(result);
+        var humanLines = [summary, "", packetMd];
+        if (effectiveMode === "semantic-only") {
+            humanLines.push("", "> semantic-only is diagnostic/evaluation only -- deterministic retrieval remains the active production path.");
+        }
+        else if (warnings.length > 0) {
+            humanLines.push("", "## Warnings", "");
+            for (var hw = 0; hw < warnings.length; hw++)
+                humanLines.push("- " + warnings[hw]);
+        }
+        return textResult(humanLines.join("\n"));
+    }
+    // compact
+    var compactLines = ["# FlowSeeker Context (compact)", "", "Task: " + task];
+    var topFiles = groups.slice(0, 15);
+    for (var tf = 0; tf < topFiles.length; tf++) {
+        var g = topFiles[tf];
+        compactLines.push((tf + 1) + ". " + g.relativePath + " role=" + g.role + " slot=" + (g.slot || "unknown") + " score=" + g.score.toFixed(1) + " reasons=" + g.reasons.join(","));
+    }
+    if (warnings.length > 0) {
+        compactLines.push("", "Warnings:");
+        for (var w2 = 0; w2 < warnings.length; w2++)
+            compactLines.push("- " + warnings[w2]);
+    }
+    return textResult(compactLines.join("\n"));
+}
+// -- Inspect Tool -----------------------------------------------------
+function editGuidanceForRole(role) {
+    switch (role) {
+        case "edit_candidate": return ["candidate_edit"];
+        case "read_context": return ["read_first", "do_not_edit_without_reason"];
+        case "impact": return ["read_first"];
+        case "test":
+        case "verify": return ["verification_target"];
+        default: return ["inspect_manually"];
+    }
+}
+async function handleInspect(input, defaultWorkspace) {
+    var task = (input.task || "").trim();
+    var workspace = input.workspaceRoot || input.workspace || defaultWorkspace;
+    var files = input.files || [];
+    var maxSnippets = input.maxSnippetsPerFile || 3;
+    var includeGraphNeighbors = !!input.includeGraphNeighbors;
+    var profile = input.outputProfile || "json";
+    // Validate task
+    if (!task) {
+        return errorResult("task must be a non-empty string");
+    }
+    // Validate files
+    if (!Array.isArray(files) || files.length === 0) {
+        return errorResult("files must be a non-empty array of non-empty strings");
+    }
+    for (var fi = 0; fi < files.length; fi++) {
+        if (typeof files[fi] !== "string" || !files[fi].trim()) {
+            return errorResult("files[" + fi + "] must be a non-empty string");
+        }
+    }
+    // Validate outputProfile
+    if (profile !== "json" && profile !== "human") {
+        return errorResult("invalid outputProfile: " + profile + ". Must be json or human");
+    }
+    // Validate maxSnippetsPerFile
+    if (input.maxSnippetsPerFile !== undefined && (typeof input.maxSnippetsPerFile !== "number" || input.maxSnippetsPerFile <= 0)) {
+        return errorResult("maxSnippetsPerFile must be a positive number");
+    }
+    // Path safety: classify each requested file
+    var rejectedPaths = [];
+    var validFiles = [];
+    for (var fi2 = 0; fi2 < files.length; fi2++) {
+        var raw = files[fi2].trim();
+        if (isOutsideWorkspace(raw, workspace)) {
+            rejectedPaths.push({ path: raw, reason: "outside workspace or sibling escape" });
+        }
+        else {
+            validFiles.push(raw);
+        }
+    }
+    // Run retrieval
+    var result = await runPipeline(task, workspace, input.maxFiles);
+    var groups = (0, fileGroups_1.aggregateEvidenceFiles)(result.units);
+    // Index groups by relativePath
+    var groupByPath = {};
+    for (var gi = 0; gi < groups.length; gi++) {
+        groupByPath[groups[gi].relativePath] = groups[gi];
+    }
+    var warnings = [];
+    if (includeGraphNeighbors) {
+        warnings.push("includeGraphNeighbors is accepted but report-only; graph neighbor extraction is not yet implemented");
+    }
+    // Index noiseRisk and doNotEditYet for guidance truth
+    var noiseRiskPaths = [];
+    var noiseRiskByPath = {}; // reasons from noiseRisk entry
+    if (result.solvePacket && result.solvePacket.noiseRisk) {
+        for (var nr = 0; nr < result.solvePacket.noiseRisk.length; nr++) {
+            var nf = result.solvePacket.noiseRisk[nr];
+            noiseRiskPaths.push(nf.relativePath);
+            noiseRiskByPath[nf.relativePath] = nf.reasons || [];
+        }
+    }
+    var doNotEditPaths = result.solvePacket?.doNotEditYet || [];
+    function isDoNotEdit(filePath) {
+        var reasons = [];
+        // Check noiseRisk
+        if (noiseRiskByPath[filePath]) {
+            reasons = reasons.concat(noiseRiskByPath[filePath]);
+        }
+        // Check doNotEditYet entries that reference this file
+        for (var di = 0; di < doNotEditPaths.length; di++) {
+            if (doNotEditPaths[di].indexOf(filePath) === 0) {
+                reasons.push(doNotEditPaths[di]);
+            }
+        }
+        return { isNoise: noiseRiskPaths.indexOf(filePath) >= 0 || reasons.length > 0, reasons: reasons };
+    }
+    var inspectedFiles = [];
+    var missingRequestedFiles = [];
+    for (var vf = 0; vf < validFiles.length; vf++) {
+        var requestedPath = validFiles[vf];
+        var group = groupByPath[requestedPath];
+        if (!group) {
+            missingRequestedFiles.push(requestedPath);
+            continue;
+        }
+        // Collect top chunks from units
+        var sortedUnits = group.units.slice().sort(function (a, b) { return b.score - a.score; });
+        var topChunks = [];
+        var snippets = [];
+        var retrievalTrace = [];
+        for (var ui = 0; ui < sortedUnits.length && ui < maxSnippets; ui++) {
+            var unit = sortedUnits[ui];
+            var chunk = {
+                kind: unit.kind,
+                role: unit.role,
+                slot: unit.slot,
+                score: unit.score,
+                confidence: unit.confidence,
+                tier: unit.tier,
+                reasons: unit.reasons,
+                range: unit.range || null,
+            };
+            topChunks.push(chunk);
+            if (unit.snippet) {
+                snippets.push(unit.snippet);
+            }
+            if (unit.retrievalTrace && unit.retrievalTrace.length > 0) {
+                for (var rt = 0; rt < unit.retrievalTrace.length; rt++) {
+                    if (retrievalTrace.indexOf(unit.retrievalTrace[rt]) < 0) {
+                        retrievalTrace.push(unit.retrievalTrace[rt]);
+                    }
+                }
+            }
+        }
+        // Determine edit guidance: check noiseRisk/doNotEditYet first
+        var doNotEditCheck = isDoNotEdit(group.relativePath);
+        var guidance;
+        var doNotEditReason;
+        if (doNotEditCheck.isNoise || doNotEditCheck.reasons.length > 0) {
+            guidance = ["avoid_edit"];
+            doNotEditReason = doNotEditCheck.reasons.length > 0
+                ? doNotEditCheck.reasons.join("; ")
+                : "listed in noiseRisk or doNotEditYet";
+        }
+        else {
+            guidance = editGuidanceForRole(group.role);
+        }
+        inspectedFiles.push({
+            path: group.relativePath,
+            found: true,
+            role: group.role,
+            slot: group.slot,
+            score: group.score,
+            confidence: group.confidence,
+            tier: group.tier,
+            reasons: group.reasons,
+            topChunks: topChunks,
+            snippets: snippets,
+            retrievalTrace: retrievalTrace.length > 0 ? retrievalTrace : undefined,
+            editGuidance: guidance,
+            doNotEditReason: doNotEditReason,
+        });
+    }
+    if (profile === "human") {
+        var humanLines = [
+            "# FlowSeeker Inspect Report",
+            "",
+            "Task: " + task,
+            "Workspace: " + workspace,
+            "",
+        ];
+        if (inspectedFiles.length > 0) {
+            humanLines.push("## Inspected Files");
+            humanLines.push("");
+            for (var hf = 0; hf < inspectedFiles.length; hf++) {
+                var f = inspectedFiles[hf];
+                humanLines.push("### " + f.path);
+                humanLines.push("- Role: " + f.role + " | Slot: " + (f.slot || "unknown") + " | Score: " + f.score.toFixed(1) + " | Tier: " + f.tier);
+                humanLines.push("- Edit Guidance: " + f.editGuidance.join(", "));
+                if (f.doNotEditReason) {
+                    humanLines.push("- Do Not Edit Reason: " + f.doNotEditReason);
+                }
+                humanLines.push("- Reasons: " + f.reasons.join("; "));
+                if (f.snippets.length > 0) {
+                    humanLines.push("- Snippets (" + f.snippets.length + "):");
+                    for (var sn = 0; sn < f.snippets.length; sn++) {
+                        humanLines.push("  ```");
+                        humanLines.push("  " + f.snippets[sn].split("\n").join("\n  "));
+                        humanLines.push("  ```");
+                    }
+                }
+                humanLines.push("");
+            }
+        }
+        if (missingRequestedFiles.length > 0) {
+            humanLines.push("## Missing Files");
+            humanLines.push("");
+            for (var mf = 0; mf < missingRequestedFiles.length; mf++) {
+                humanLines.push("- " + missingRequestedFiles[mf]);
+            }
+            humanLines.push("");
+        }
+        if (rejectedPaths.length > 0) {
+            humanLines.push("## Rejected Paths");
+            humanLines.push("");
+            for (var rp = 0; rp < rejectedPaths.length; rp++) {
+                humanLines.push("- " + rejectedPaths[rp].path + ": " + rejectedPaths[rp].reason);
+            }
+            humanLines.push("");
+        }
+        if (warnings.length > 0) {
+            humanLines.push("## Warnings");
+            humanLines.push("");
+            for (var hw = 0; hw < warnings.length; hw++) {
+                humanLines.push("- " + warnings[hw]);
+            }
+            humanLines.push("");
+        }
+        return textResult(humanLines.join("\n"));
+    }
+    // json profile
+    var jsonOutput = {
+        schemaVersion: "2.0.0",
+        tool: "flowseeker_inspect",
+        task: task,
+        workspaceRoot: workspace,
+        inspectedFiles: inspectedFiles,
+        missingRequestedFiles: missingRequestedFiles,
+        rejectedPaths: rejectedPaths,
+        warnings: warnings,
+    };
+    return textResult(JSON.stringify(jsonOutput, null, 2));
+}
+// -- Expand Tool ------------------------------------------------------
+async function handleExpand(input, defaultWorkspace) {
+    var task = (input.task || "").trim();
+    var slot = (input.slot || "").trim();
+    var workspace = input.workspaceRoot || input.workspace || defaultWorkspace;
+    var anchorFiles = input.anchorFiles || [];
+    var maxCandidates = input.maxFiles || 15;
+    var profile = input.outputProfile || "json";
+    // Validate task
+    if (!task) {
+        return errorResult("task must be a non-empty string");
+    }
+    // Validate slot
+    if (!slot) {
+        return errorResult("slot must be a non-empty string");
+    }
+    // Validate outputProfile
+    if (profile !== "json" && profile !== "human") {
+        return errorResult("invalid outputProfile: " + profile + ". Must be json or human");
+    }
+    // Validate maxFiles
+    if (input.maxFiles !== undefined && (typeof input.maxFiles !== "number" || input.maxFiles <= 0)) {
+        return errorResult("maxFiles must be a positive number");
+    }
+    // Validate anchorFiles if provided
+    if (!Array.isArray(anchorFiles)) {
+        return errorResult("anchorFiles must be an array of non-empty strings when provided");
+    }
+    for (var ai = 0; ai < anchorFiles.length; ai++) {
+        if (typeof anchorFiles[ai] !== "string" || !anchorFiles[ai].trim()) {
+            return errorResult("anchorFiles[" + ai + "] must be a non-empty string");
+        }
+    }
+    // Path safety for anchorFiles
+    var rejectedPaths = [];
+    var safeAnchors = [];
+    for (var ai2 = 0; ai2 < anchorFiles.length; ai2++) {
+        var raw = anchorFiles[ai2].trim();
+        if (isOutsideWorkspace(raw, workspace)) {
+            rejectedPaths.push({ path: raw, reason: "outside workspace or sibling escape" });
+        }
+        else {
+            safeAnchors.push(raw);
+        }
+    }
+    // Run retrieval
+    var result = await runPipeline(task, workspace, input.maxFiles);
+    var groups = (0, fileGroups_1.aggregateEvidenceFiles)(result.units);
+    // Index groups by relativePath before anchor extraction
+    var groupByPath = {};
+    for (var gi2 = 0; gi2 < groups.length; gi2++) {
+        groupByPath[groups[gi2].relativePath] = groups[gi2];
+    }
+    // -- Token classification --
+    // Strong: domain-specific domain/entity tokens that signal real connection
+    var strongTokenSet = {};
+    ["payment", "invoice", "user", "order", "course", "enrollment", "notification",
+        "email", "auth", "gateway", "transaction", "billing", "subscription", "receipt",
+        "checkout", "cart", "product", "pricing", "tax", "shipping", "coupon", "wallet",
+        "credit", "debit", "balance", "transfer", "refund", "charge", "fee", "payout",
+        "customer", "merchant", "account", "ledger", "report", "dashboard", "analytics",
+        "booking", "reservation", "appointment", "schedule", "calendar", "reminder",
+        "alert", "message", "sms", "push", "webhook", "callback", "listener", "observer",
+        "repository", "factory", "builder", "handle", "exec", "queue", "worker",
+        "cron", "batch", "process", "pipeline", "mutator", "accessor", "trait",
+        "interface", "abstract", "contract", "binding", "facade", "middleware",
+        "guard", "policy", "role", "permission", "profile", "token", "session",
+        "login", "register", "logout", "reset", "verify", "confirm", "upload",
+        "download", "export", "import", "filter", "search", "sort", "paginate",
+        "validate", "sanitize", "encrypt", "decrypt", "hash", "sign", "verify",
+        "approve", "reject", "cancel", "complete", "process", "dispatch", "fire",
+        "notify"].forEach(function (t) { strongTokenSet[t] = true; });
+    // Weak: generic framework/structural tokens that appear everywhere
+    var weakTokenSet = {};
+    ["service", "services", "model", "models", "controller", "controllers",
+        "config", "http", "jobs", "mail", "listeners", "events", "console", "commands",
+        "routes", "providers", "exceptions", "helpers", "support", "resources",
+        "views", "lang", "storage", "database", "bootstrap", "public", "tests",
+        "seeders", "migrations", "factories", "middleware", "requests", "responses",
+        "app", "src", "lib", "vendor", "php"].forEach(function (t) { weakTokenSet[t] = true; });
+    // Pure noise: tokens that should never appear in anchor connections
+    var noiseTokenSet = {};
+    ["path", "paths", "match", "matches", "fix", "line", "file", "files",
+        "service", "services", "model", "models", "config",
+        "code", "use", "get", "set", "new", "int", "str", "bool", "array", "null",
+        "true", "false", "return", "function", "class", "public", "private",
+        "protected", "static", "final", "abstract", "extends", "implements",
+        "interface", "namespace", "require", "include", "echo", "print", "var",
+        "let", "const", "this", "self", "parent", "php", "app", "src", "lib",
+        "vendor"].forEach(function (t) { noiseTokenSet[t] = true; });
+    function extractTokens(str) {
+        var lower = str.toLowerCase();
+        var parts = lower.replace(/[\\/]/g, " ").replace(/[^a-z0-9_]/g, " ").split(/\s+/);
+        var tokens = [];
+        for (var pt = 0; pt < parts.length; pt++) {
+            var t = parts[pt].trim();
+            if (t.length >= 3 && !noiseTokenSet[t]) {
+                tokens.push(t);
+            }
+        }
+        return tokens;
+    }
+    // -- Extract anchor signals --
+    var anchorStrongTokens = {};
+    var anchorWeakTokens = {};
+    for (var sa2 = 0; sa2 < safeAnchors.length; sa2++) {
+        var anchorPath = safeAnchors[sa2];
+        var pathTokens = extractTokens(anchorPath);
+        for (var pt2 = 0; pt2 < pathTokens.length; pt2++) {
+            var at = pathTokens[pt2];
+            if (strongTokenSet[at]) {
+                anchorStrongTokens[at] = true;
+            }
+            else if (weakTokenSet[at]) {
+                anchorWeakTokens[at] = true;
+            }
+        }
+        var anchorGroup = groupByPath[anchorPath];
+        if (anchorGroup) {
+            for (var ar = 0; ar < anchorGroup.reasons.length; ar++) {
+                var reasonTokens = extractTokens(anchorGroup.reasons[ar]);
+                for (var rt2 = 0; rt2 < reasonTokens.length; rt2++) {
+                    var rt2t = reasonTokens[rt2];
+                    if (strongTokenSet[rt2t]) {
+                        anchorStrongTokens[rt2t] = true;
+                    }
+                    else if (weakTokenSet[rt2t]) {
+                        anchorWeakTokens[rt2t] = true;
+                    }
+                }
+            }
+        }
+    }
+    // Build expansion candidates prioritizing the target slot
+    var noisePaths = (result.solvePacket?.noiseRisk || []).map(function (f) { return f.relativePath; });
+    var doNotEditSet = {};
+    var doNotEditList = result.solvePacket?.doNotEditYet || [];
+    for (var di = 0; di < doNotEditList.length; di++) {
+        doNotEditSet[doNotEditList[di]] = true;
+    }
+    var anchorSet = {};
+    for (var sa = 0; sa < safeAnchors.length; sa++) {
+        anchorSet[safeAnchors[sa]] = true;
+    }
+    // -- Compute anchor connection scores with strong/weak split --
+    // Config/* files: only path: and symbol: prefixes count as strong.
+    // reason: and unit: matches on config files are always weak (aggregate reason leakage).
+    function computeAnchorScore(g) {
+        var strongMatches = {};
+        var weakMatches = {};
+        var isConfig = g.relativePath.indexOf("config/") === 0;
+        // Check path tokens
+        var pathTokens = extractTokens(g.relativePath);
+        for (var t1 = 0; t1 < pathTokens.length; t1++) {
+            var ptt = pathTokens[t1];
+            if (anchorStrongTokens[ptt] && !strongMatches[ptt]) {
+                strongMatches["path:" + ptt] = true;
+            }
+            else if (anchorWeakTokens[ptt] && !weakMatches[ptt]) {
+                weakMatches["path:" + ptt] = true;
+            }
+        }
+        // Check reasons -- for config files, these are always weak
+        for (var r1 = 0; r1 < g.reasons.length; r1++) {
+            var reasonTokens = extractTokens(g.reasons[r1]);
+            for (var t2 = 0; t2 < reasonTokens.length; t2++) {
+                var rtt = reasonTokens[t2];
+                if (!isConfig && anchorStrongTokens[rtt] && !strongMatches["reason:" + rtt]) {
+                    strongMatches["reason:" + rtt] = true;
+                }
+                else if ((isConfig || anchorWeakTokens[rtt] || !anchorStrongTokens[rtt]) && !weakMatches["reason:" + rtt]) {
+                    weakMatches["reason:" + rtt] = true;
+                }
+            }
+        }
+        // Check unit-level symbols/reasons
+        for (var u1 = 0; u1 < g.units.length && u1 < 5; u1++) {
+            var unit = g.units[u1];
+            if (unit.symbols) {
+                for (var s1 = 0; s1 < unit.symbols.length; s1++) {
+                    var st = unit.symbols[s1].toLowerCase();
+                    if (anchorStrongTokens[st] && !strongMatches["symbol:" + st]) {
+                        strongMatches["symbol:" + st] = true;
+                    }
+                    else if (anchorWeakTokens[st] && !weakMatches["symbol:" + st]) {
+                        weakMatches["symbol:" + st] = true;
+                    }
+                }
+            }
+            if (unit.reasons) {
+                for (var r2 = 0; r2 < unit.reasons.length; r2++) {
+                    var urt = extractTokens(unit.reasons[r2]);
+                    for (var t3 = 0; t3 < urt.length; t3++) {
+                        var utt = urt[t3];
+                        // For config files, unit: matches are always weak
+                        if (!isConfig && anchorStrongTokens[utt] && !strongMatches["unit:" + utt]) {
+                            strongMatches["unit:" + utt] = true;
+                        }
+                        else if ((isConfig || anchorWeakTokens[utt] || !anchorStrongTokens[utt]) && !weakMatches["unit:" + utt]) {
+                            weakMatches["unit:" + utt] = true;
+                        }
+                    }
+                }
+            }
+        }
+        var strongList = Object.keys(strongMatches);
+        var weakList = Object.keys(weakMatches);
+        var totalScore = Math.min(strongList.length * 4 + weakList.length, 20);
+        return { score: totalScore, strongConnections: strongList, weakConnections: weakList };
+    }
+    function isGenericConfig(g) {
+        return g.relativePath.indexOf("config/") === 0;
+    }
+    var tier1 = [];
+    var tier2 = [];
+    var tier3 = [];
+    for (var gi = 0; gi < groups.length; gi++) {
+        var g = groups[gi];
+        var isNoise = noisePaths.indexOf(g.relativePath) >= 0 || doNotEditSet[g.relativePath];
+        if (isNoise)
+            continue;
+        if (anchorSet[g.relativePath])
+            continue;
+        if (g.slot === slot) {
+            tier1.push(g);
+        }
+        else if (g.role === "read_context" || g.role === "impact" || g.role === "verify") {
+            tier2.push(g);
+        }
+        else {
+            tier3.push(g);
+        }
+    }
+    // -- Rank: strong connections first, generic configs demoted --
+    function effectiveRank(g) {
+        var conn = computeAnchorScore(g);
+        var strongCount = conn.strongConnections.length;
+        var weakCount = conn.weakConnections.length;
+        var isConfig = isGenericConfig(g);
+        // Config files without strong path-level connections get heavy penalty
+        var configPenalty = (isConfig && strongCount === 0) ? 5000 : (isConfig ? 1000 : 0);
+        var base = strongCount * 200 + weakCount * 3 + g.score - configPenalty;
+        return base;
+    }
+    var hasSafeAnchors = safeAnchors.length > 0;
+    var allGroups = [];
+    for (var t1 = 0; t1 < tier1.length; t1++) {
+        allGroups.push(tier1[t1]);
+    }
+    for (var t2 = 0; t2 < tier2.length; t2++) {
+        allGroups.push(tier2[t2]);
+    }
+    for (var t3 = 0; t3 < tier3.length; t3++) {
+        allGroups.push(tier3[t3]);
+    }
+    if (hasSafeAnchors) {
+        allGroups.sort(function (a, b) {
+            var ra = effectiveRank(a);
+            var rb = effectiveRank(b);
+            if (ra !== rb)
+                return rb - ra;
+            return b.score - a.score;
+        });
+    }
+    else {
+        allGroups.sort(function (a, b) { return b.score - a.score; });
+    }
+    // -- Split into expansion (strong) and fallback (weak/generic) --
+    var expansionCandidates = [];
+    var fallbackCandidates = [];
+    var configCount = 0;
+    function buildCandidate(g) {
+        var conn = computeAnchorScore(g);
+        var cGuidance = editGuidanceForRole(g.role);
+        var topChunks = [];
+        for (var ui = 0; ui < g.units.length && ui < 3; ui++) {
+            var u = g.units[ui];
+            topChunks.push({
+                kind: u.kind, role: u.role, slot: u.slot, score: u.score,
+                reasons: u.reasons, range: u.range || null,
+            });
+        }
+        return {
+            path: g.relativePath, role: g.role, slot: g.slot, score: g.score, tier: g.tier,
+            reasons: g.reasons, topChunks: topChunks, editGuidance: cGuidance,
+            anchorConnectionScore: conn.score,
+            strongAnchorConnections: conn.strongConnections,
+            weakAnchorConnections: conn.weakConnections,
+        };
+    }
+    for (var ci = 0; ci < allGroups.length; ci++) {
+        var g = allGroups[ci];
+        var conn = computeAnchorScore(g);
+        // Expansion: non-config OR config with strong connections, limit to 8
+        if ((!isGenericConfig(g) || conn.strongConnections.length > 0) && expansionCandidates.length < 8) {
+            expansionCandidates.push(buildCandidate(g));
+        }
+        else {
+            fallbackCandidates.push(buildCandidate(g));
+        }
+    }
+    // NO fallback promotion -- weak evidence stays in fallbackCandidates.
+    // -- Compute anchorInfluence truth --
+    var anyStrong = false;
+    var anyWeak = false;
+    for (var cc = 0; cc < expansionCandidates.length; cc++) {
+        if (expansionCandidates[cc].strongAnchorConnections.length > 0)
+            anyStrong = true;
+        if (expansionCandidates[cc].weakAnchorConnections.length > 0)
+            anyWeak = true;
+    }
+    var influenceStatus = "no_safe_anchors";
+    if (hasSafeAnchors) {
+        if (anyStrong)
+            influenceStatus = "active_strong";
+        else if (anyWeak)
+            influenceStatus = "active_weak";
+        else
+            influenceStatus = "no_connected_evidence";
+    }
+    // If no connected evidence, zero all fallback anchor scores/connections
+    if (influenceStatus === "no_connected_evidence") {
+        for (var fb = 0; fb < expansionCandidates.length; fb++) {
+            expansionCandidates[fb].anchorConnectionScore = 0;
+            expansionCandidates[fb].strongAnchorConnections = [];
+            expansionCandidates[fb].weakAnchorConnections = [];
+        }
+        for (var fb2 = 0; fb2 < fallbackCandidates.length; fb2++) {
+            fallbackCandidates[fb2].anchorConnectionScore = 0;
+            fallbackCandidates[fb2].strongAnchorConnections = [];
+            fallbackCandidates[fb2].weakAnchorConnections = [];
+        }
+    }
+    var anchorInfluence = {
+        status: influenceStatus,
+        safeAnchorCount: safeAnchors.length,
+        rejectedAnchorCount: rejectedPaths.length,
+        strategy: "deterministic_strong_weak_with_config_guard",
+    };
+    var warnings = [];
+    warnings.push("deterministic-only: expansion uses deterministic retrieval only; semantic and graph expansion are not active");
+    if (influenceStatus === "active_weak") {
+        warnings.push("anchor influence is weak: primary expansion is unavailable; fallbackCandidates carries weak/potential context only");
+    }
+    if (hasSafeAnchors && influenceStatus === "no_connected_evidence") {
+        warnings.push("anchor influence: " + safeAnchors.length + " safe anchor(s) provided but no candidate had anchor-connected evidence; fallbackCandidates are generic context only, not anchored");
+    }
+    var missingSlotStatus = "ok";
+    if (expansionCandidates.length === 0) {
+        missingSlotStatus = "no_candidates";
+    }
+    else if (expansionCandidates.length < 3) {
+        missingSlotStatus = "low_coverage";
+    }
+    if (profile === "human") {
+        var humanLines = [
+            "# FlowSeeker Expand Report",
+            "",
+            "Task: " + task,
+            "Target Slot: " + slot,
+            "Workspace: " + workspace,
+            "",
+        ];
+        if (safeAnchors.length > 0) {
+            humanLines.push("## Anchor Files");
+            humanLines.push("");
+            for (var ah = 0; ah < safeAnchors.length; ah++) {
+                humanLines.push("- " + safeAnchors[ah]);
+            }
+            humanLines.push("");
+        }
+        if (rejectedPaths.length > 0) {
+            humanLines.push("## Rejected Paths");
+            humanLines.push("");
+            for (var rh = 0; rh < rejectedPaths.length; rh++) {
+                humanLines.push("- " + rejectedPaths[rh].path + ": " + rejectedPaths[rh].reason);
+            }
+            humanLines.push("");
+        }
+        humanLines.push("## Expansion Candidates (" + expansionCandidates.length + ")");
+        humanLines.push("");
+        humanLines.push("Slot Coverage: " + missingSlotStatus);
+        humanLines.push("Anchor Influence: " + anchorInfluence.status);
+        humanLines.push("");
+        for (var ch = 0; ch < expansionCandidates.length; ch++) {
+            var ec = expansionCandidates[ch];
+            humanLines.push((ch + 1) + ". **" + ec.path + "**");
+            humanLines.push("   Role: " + ec.role + " | Slot: " + (ec.slot || "unknown") + " | Score: " + ec.score.toFixed(1) + " | Tier: " + ec.tier);
+            humanLines.push("   Guidance: " + ec.editGuidance.join(", "));
+            if (ec.anchorConnectionScore > 0) {
+                humanLines.push("   Anchor: score=" + ec.anchorConnectionScore);
+                if (ec.strongAnchorConnections && ec.strongAnchorConnections.length > 0) {
+                    humanLines.push("   Strong: " + ec.strongAnchorConnections.join(", "));
+                }
+                if (ec.weakAnchorConnections && ec.weakAnchorConnections.length > 0) {
+                    humanLines.push("   Weak: " + ec.weakAnchorConnections.join(", "));
+                }
+            }
+            humanLines.push("   Reasons: " + ec.reasons.join("; "));
+            humanLines.push("");
+        }
+        if (fallbackCandidates.length > 0) {
+            humanLines.push("## Fallback Candidates (" + fallbackCandidates.length + ")");
+            humanLines.push("");
+            humanLines.push("These are weak/generic/context files surfaced when strong expansion is limited.");
+            humanLines.push("");
+            for (var fh = 0; fh < fallbackCandidates.length; fh++) {
+                var fc = fallbackCandidates[fh];
+                humanLines.push((fh + 1) + ". **" + fc.path + "**");
+                humanLines.push("   Role: " + fc.role + " | Slot: " + (fc.slot || "unknown") + " | Score: " + fc.score.toFixed(1));
+                humanLines.push("");
+            }
+        }
+        if (warnings.length > 0) {
+            humanLines.push("## Warnings");
+            humanLines.push("");
+            for (var wh = 0; wh < warnings.length; wh++) {
+                humanLines.push("- " + warnings[wh]);
+            }
+            humanLines.push("");
+        }
+        return textResult(humanLines.join("\n"));
+    }
+    // json profile
+    var jsonOutput = {
+        schemaVersion: "2.0.0",
+        tool: "flowseeker_expand",
+        task: task,
+        workspaceRoot: workspace,
+        targetSlot: slot,
+        anchorFiles: safeAnchors,
+        rejectedPaths: rejectedPaths,
+        anchorInfluence: anchorInfluence,
+        expansionCandidates: expansionCandidates,
+        fallbackCandidates: fallbackCandidates,
+        missingSlotStatus: missingSlotStatus,
+        warnings: warnings,
+    };
+    return textResult(JSON.stringify(jsonOutput, null, 2));
+}
+// -- Status Tool -------------------------------------------------------
+async function handleStatus(input, defaultWorkspace) {
+    var workspace = input.workspaceRoot || input.workspace || defaultWorkspace;
+    var profile = input.outputProfile || "json";
+    if (profile !== "json" && profile !== "human") {
+        return errorResult("invalid outputProfile: " + profile + ". Must be json or human");
+    }
+    var config = {};
+    try {
+        config = await (0, loadConfigFromPath_1.loadConfigFromPath)(workspace);
+    }
+    catch (e) { }
+    // Deterministic always ok
+    var deterministic = { status: "ok", retrieval: "available", note: "No embedding required. Code-structure analysis is first-class." };
+    // Semantic
+    var semanticEnabled = config?.index?.semanticEnabled === true;
+    var semanticProvider = config?.index?.semanticProvider || "none";
+    var semanticModel = config?.index?.semanticModel || "";
+    var semanticResult = semanticEnabled ? "configured" : "disabled";
+    // Local model readiness
+    var localReadiness = null;
+    try {
+        localReadiness = (0, embeddingProviders_1.getLocalProviderReadiness)(workspace, {
+            semanticModel: config?.index?.semanticModel || "",
+            semanticLocalModelPath: config?.index?.semanticLocalModelPath,
+            semanticLocalModelId: config?.index?.semanticLocalModelId,
+            semanticDimensions: config?.index?.semanticDimensions,
+        });
+    }
+    catch (e) { }
+    // Index state
+    var indexStatus = "unknown";
+    var cachePath = path.join(workspace, ".flowseeker", "cache");
+    var workspaceIndexPath = path.join(cachePath, "workspace-index.json");
+    try {
+        if (fs.existsSync(workspaceIndexPath)) {
+            var indexStat = fs.statSync(workspaceIndexPath);
+            var indexAgeS = Math.floor((Date.now() - indexStat.mtimeMs) / 1000);
+            indexStatus = "exists";
+        }
+        else {
+            indexStatus = "not_built";
+        }
+    }
+    catch (e) { }
+    // Config
+    var configPath = path.join(workspace, ".flowseeker", "config.json");
+    var configExists = fs.existsSync(configPath);
+    // Warnings
+    var warnings = [];
+    var nextActions = [];
+    if (semanticResult === "disabled") {
+        warnings.push("semantic retrieval is disabled");
+        nextActions.push("enable semantic retrieval in .flowseeker/config.json");
+    }
+    if (indexStatus === "not_built") {
+        warnings.push("workspace index not built yet");
+        nextActions.push("run flowseeker_index with action=build");
+    }
+    if (!configExists) {
+        warnings.push("no .flowseeker/config.json found; using defaults");
+        nextActions.push("run FlowSeeker at least once to generate config");
+    }
+    if (localReadiness && localReadiness.status !== "local_ready" && localReadiness.status !== "bundled_package_ready") {
+        warnings.push("local model not ready");
+        nextActions.push("run flowseeker semantic local setup && flowseeker semantic local download --yes");
+    }
+    if (profile === "human") {
+        var lines = [
+            "# FlowSeeker Status",
+            "",
+            "Version: 0.1.8",
+            "Workspace: " + workspace,
+            "",
+            "Deterministic: " + deterministic.status + " (" + deterministic.note + ")",
+            "Semantic: " + semanticResult,
+            "Local Model: " + (localReadiness ? localReadiness.status : "unknown"),
+            "Index: " + indexStatus,
+            "Config: " + (configExists ? "present" : "not found"),
+            "MCP Tools: " + exports.TOOL_DEFINITIONS.length + " (" + exports.TOOL_DEFINITIONS.map(function (t) { return t.name; }).join(", ") + ")",
+            "",
+        ];
+        if (warnings.length > 0) {
+            lines.push("## Warnings");
+            for (var w = 0; w < warnings.length; w++) {
+                lines.push("- " + warnings[w]);
+            }
+            lines.push("");
+        }
+        if (nextActions.length > 0) {
+            lines.push("## Next Actions");
+            for (var n = 0; n < nextActions.length; n++) {
+                lines.push("- " + nextActions[n]);
+            }
+            lines.push("");
+        }
+        return textResult(lines.join("\n"));
+    }
+    var output = {
+        schemaVersion: "2.0.0",
+        tool: "flowseeker_status",
+        version: "0.1.8",
+        workspaceRoot: workspace,
+        deterministic: deterministic,
+        semantic: {
+            enabled: semanticEnabled,
+            provider: semanticProvider,
+            model: semanticModel,
+            result: semanticResult,
+        },
+        localModel: localReadiness ? {
+            status: localReadiness.status,
+            runtimeAvailable: localReadiness.runtimeAvailable === true,
+            modelStatus: localReadiness.modelStatus || "unknown",
+            nextAction: localReadiness.nextAction || "",
+        } : undefined,
+        index: {
+            status: indexStatus,
+            path: cachePath,
+        },
+        mcp: {
+            toolsAvailable: exports.TOOL_DEFINITIONS.length,
+            toolNames: exports.TOOL_DEFINITIONS.map(function (t) { return t.name; }),
+        },
+        warnings: warnings,
+        nextActions: nextActions,
+    };
+    return textResult(JSON.stringify(output, null, 2));
+}
+// -- Index Tool --------------------------------------------------------
+var DESTRUCTIVE_ACTIONS = ["clean", "rebuild", "delete", "reset", "remove", "purge"];
+async function handleIndex(input, defaultWorkspace) {
+    var action = (input.action || "").trim().toLowerCase();
+    var workspace = input.workspaceRoot || input.workspace || defaultWorkspace;
+    var profile = input.outputProfile || "json";
+    var maxFiles = input.maxFiles || 5000;
+    if (DESTRUCTIVE_ACTIONS.indexOf(action) >= 0) {
+        return errorResult("unsupported action: " + action + ". Allowed: status, build. Destructive actions are rejected.");
+    }
+    if (profile !== "json" && profile !== "human") {
+        return errorResult("invalid outputProfile: " + profile + ". Must be json or human");
+    }
+    if (maxFiles <= 0) {
+        return errorResult("maxFiles must be a positive number");
+    }
+    if (action === "status") {
+        var cachePath = path.join(workspace, ".flowseeker", "cache");
+        var indexPath = path.join(cachePath, "workspace-index.json");
+        var exists = false;
+        var entryCount = 0;
+        try {
+            if (fs.existsSync(indexPath)) {
+                exists = true;
+                var raw = fs.readFileSync(indexPath, "utf8");
+                entryCount = Object.keys(JSON.parse(raw)).length;
+            }
+        }
+        catch (e) { }
+        if (profile === "human") {
+            var slines = [
+                "# FlowSeeker Index Status",
+                "",
+                "Workspace: " + workspace,
+                "Index exists: " + exists,
+                "Entries: " + entryCount,
+                "Path: " + indexPath,
+            ];
+            return textResult(slines.join("\n"));
+        }
+        return textResult(JSON.stringify({
+            schemaVersion: "2.0.0",
+            tool: "flowseeker_index",
+            action: "status",
+            workspaceRoot: workspace,
+            indexExists: exists,
+            entries: entryCount,
+            path: indexPath,
+        }, null, 2));
+    }
+    if (action === "build") {
+        // Run safe indexing
+        var config = {};
+        try {
+            config = await (0, loadConfigFromPath_1.loadConfigFromPath)(workspace);
+        }
+        catch (e) { }
+        var buildResult = null;
+        try {
+            var mergedCfg = maxFiles && maxFiles > 0
+                ? (0, defaultConfig_1.mergeConfig)(config, { pipeline: { ...config?.pipeline, maxFiles } })
+                : (config || await (0, loadConfigFromPath_1.loadConfigFromPath)(workspace));
+            buildResult = await (0, workspaceIndex_1.loadOrBuildWorkspaceIndex)(workspace, mergedCfg, { readOnly: false });
+        }
+        catch (e) {
+            return errorResult("Index build failed: " + (e?.message || String(e)));
+        }
+        // Verify source files still exist (safety check)
+        var fixtureFiles = ["app/Services/PaymentService.php", "app/Models/Payment.php"];
+        var missingFiles = [];
+        for (var ff = 0; ff < fixtureFiles.length; ff++) {
+            if (!fs.existsSync(path.join(workspace, fixtureFiles[ff]))) {
+                missingFiles.push(fixtureFiles[ff]);
+            }
+        }
+        if (missingFiles.length > 0) {
+            return errorResult("Build may have deleted source files: " + missingFiles.join(", "));
+        }
+        if (profile === "human") {
+            var blines = [
+                "# FlowSeeker Index Build",
+                "",
+                "Workspace: " + workspace,
+                "Status: complete",
+                "Discovered: " + (buildResult?.discoveredFiles ?? "?"),
+                "Reused: " + (buildResult?.reusedFiles ?? "?"),
+                "Updated: " + (buildResult?.updatedFiles ?? "?"),
+                "Deleted: " + (buildResult?.deletedFiles ?? "0"),
+                "Source files intact: yes",
+            ];
+            return textResult(blines.join("\n"));
+        }
+        return textResult(JSON.stringify({
+            schemaVersion: "2.0.0",
+            tool: "flowseeker_index",
+            action: "build",
+            workspaceRoot: workspace,
+            status: "complete",
+            discoveredFiles: buildResult?.discoveredFiles,
+            reusedFiles: buildResult?.reusedFiles,
+            updatedFiles: buildResult?.updatedFiles,
+            deletedFiles: buildResult?.deletedFiles || 0,
+            sourceFilesIntact: true,
+        }, null, 2));
+    }
+    return errorResult("unknown action: " + action);
+}
+// -- Feedback Tool ----------------------------------------------------
+var VALID_LABELS = ["useful", "wrong", "missing", "edited", "test_used", "should_not_edit"];
+var MAX_NOTES_LENGTH = 500;
+function redactNotes(notes) {
+    var redacted = notes.replace(/(sk-[a-z0-9\-]+)/gi, "***REDACTED_KEY***");
+    redacted = redacted.replace(/AIza[a-zA-Z0-9\-_]{15,}/g, "***REDACTED_KEY***");
+    return redacted.substring(0, MAX_NOTES_LENGTH);
+}
+async function handleFeedback(input, defaultWorkspace) {
+    var task = (input.task || "").trim();
+    var label = (input.label || "").trim();
+    var workspace = input.workspaceRoot || input.workspace || defaultWorkspace;
+    var profile = input.outputProfile || "json";
+    // Validate task
+    if (!task) {
+        return errorResult("task must be a non-empty string");
+    }
+    // Validate label
+    if (VALID_LABELS.indexOf(label) < 0) {
+        return errorResult("invalid label: " + label + ". Must be one of: " + VALID_LABELS.join(", "));
+    }
+    // Validate outputProfile
+    if (profile !== "json" && profile !== "human") {
+        return errorResult("invalid outputProfile: " + profile + ". Must be json or human");
+    }
+    // Validate files -- must be an array if provided
+    if (input.files !== undefined && !Array.isArray(input.files)) {
+        return errorResult("files must be an array of non-empty workspace-relative paths");
+    }
+    var files = input.files !== undefined ? input.files : [];
+    var workspaceRoot = path.resolve(workspace);
+    for (var fi = 0; fi < files.length; fi++) {
+        if (typeof files[fi] !== "string" || !files[fi].trim()) {
+            return errorResult("files[" + fi + "] must be a non-empty string");
+        }
+        // Reject absolute paths -- files must be workspace-relative
+        if (path.isAbsolute(files[fi])) {
+            return errorResult("files[" + fi + "] must be a workspace-relative path, got absolute: " + files[fi]);
+        }
+        // Reject sibling escapes using robust path.relative
+        var resolved = path.resolve(workspaceRoot, files[fi]);
+        var relative = path.relative(workspaceRoot, resolved);
+        if (relative.startsWith("..") || path.isAbsolute(relative)) {
+            return errorResult("files[" + fi + "] is outside workspace: " + files[fi]);
+        }
+    }
+    // Validate notes -- must be a string if provided
+    if (input.notes !== undefined && typeof input.notes !== "string") {
+        return errorResult("notes must be a string when provided");
+    }
+    var rawNotes = input.notes !== undefined ? input.notes : "";
+    var safeNotes = rawNotes ? redactNotes(rawNotes) : "";
+    // Append to JSONL
+    var feedbackDir = path.join(workspace, ".flowseeker", "feedback");
+    fs.mkdirSync(feedbackDir, { recursive: true });
+    var record = {
+        schemaVersion: "2.0.0",
+        tool: "flowseeker_feedback",
+        timestamp: new Date().toISOString(),
+        task: task,
+        label: label,
+        files: files,
+        notes: safeNotes,
+        workspaceRoot: workspace,
+    };
+    var line = JSON.stringify(record) + "\n";
+    var filePath = path.join(feedbackDir, "feedback.jsonl");
+    fs.appendFileSync(filePath, line, "utf8");
+    if (profile === "human") {
+        return textResult("# Feedback Recorded\n\nLabel: " + label + "\nTask: " + task + "\nFiles: " + (files.length ? files.join(", ") : "none") + "\nStored: " + filePath);
+    }
+    return textResult(JSON.stringify(record, null, 2));
+}
 function textResult(text) {
     return { content: [{ type: "text", text }] };
 }
 function errorResult(message) {
     return { content: [{ type: "text", text: message }], isError: true };
 }
+function emptyValidatePlanOutput(riskMode, confidence) {
+    return {
+        verdict: "insufficient_evidence",
+        issues: [],
+        suggestedEditFiles: [],
+        suggestedReadFiles: [],
+        suggestedTestFiles: [],
+        missingSlots: [],
+        doNotEditYet: [],
+        rejectedPaths: [],
+        evidenceSummary: "",
+        riskMode,
+        confidence,
+        matchedProposedEditFiles: [],
+        unsupportedProposedEditFiles: [],
+        proposedEditFilesOnlySeenAsReadContext: [],
+        topFlowSeekerEditCandidates: [],
+    };
+}
+function normalizeRelPath(p) {
+    return (p || "").replace(/\\/g, "/").replace(/^\/+/, "");
+}
+function isOutsideWorkspace(relPath, workspace) {
+    const resolved = path.resolve(workspace, relPath);
+    const relative = path.relative(workspace, resolved);
+    return relative.startsWith("..") || path.isAbsolute(relative);
+}
+function anyPathMatches(target, candidates) {
+    return candidates.some((c) => (0, evaluationMetrics_1.pathMatches)(target, c));
+}
+function validatePlanInput(input) {
+    const issues = [];
+    if (typeof input.task !== "string" || !input.task.trim()) {
+        issues.push("task must be a non-empty string");
+    }
+    if (!Array.isArray(input.proposedEditFiles)) {
+        issues.push("proposedEditFiles must be an array of non-empty strings");
+    }
+    else {
+        for (let i = 0; i < input.proposedEditFiles.length; i++) {
+            if (typeof input.proposedEditFiles[i] !== "string" || !input.proposedEditFiles[i].trim()) {
+                issues.push(`proposedEditFiles[${i}] must be a non-empty string`);
+            }
+        }
+    }
+    if (input.proposedReadFiles !== undefined && !Array.isArray(input.proposedReadFiles)) {
+        issues.push("proposedReadFiles must be an array of non-empty strings");
+    }
+    else if (Array.isArray(input.proposedReadFiles)) {
+        for (let i = 0; i < input.proposedReadFiles.length; i++) {
+            if (typeof input.proposedReadFiles[i] !== "string" || !input.proposedReadFiles[i].trim()) {
+                issues.push(`proposedReadFiles[${i}] must be a non-empty string`);
+            }
+        }
+    }
+    if (input.proposedTestFiles !== undefined && !Array.isArray(input.proposedTestFiles)) {
+        issues.push("proposedTestFiles must be an array of non-empty strings");
+    }
+    else if (Array.isArray(input.proposedTestFiles)) {
+        for (let i = 0; i < input.proposedTestFiles.length; i++) {
+            if (typeof input.proposedTestFiles[i] !== "string" || !input.proposedTestFiles[i].trim()) {
+                issues.push(`proposedTestFiles[${i}] must be a non-empty string`);
+            }
+        }
+    }
+    if (input.riskMode !== undefined && input.riskMode !== "strict" && input.riskMode !== "balanced" && input.riskMode !== "broad") {
+        issues.push(`riskMode must be "strict", "balanced", or "broad" (got: "${input.riskMode}")`);
+    }
+    return issues;
+}
+async function handleValidatePlan(input, defaultWorkspace) {
+    const workspace = path.resolve(input.workspaceRoot ?? defaultWorkspace);
+    // Validate input before any string method calls that could throw
+    const validationIssues = validatePlanInput(input);
+    const task = typeof input.task === "string" ? input.task.trim() : "";
+    const riskMode = (input.riskMode === "strict" || input.riskMode === "balanced" || input.riskMode === "broad") ? input.riskMode : "balanced";
+    if (validationIssues.length > 0 || !task) {
+        const errors = !task ? ["task must be a non-empty string", ...validationIssues] : validationIssues;
+        const out = emptyValidatePlanOutput(riskMode, "low");
+        out.verdict = "insufficient_evidence";
+        out.issues = errors;
+        out.evidenceSummary = "Invalid input: " + errors.join("; ");
+        return textResult(JSON.stringify(out, null, 2));
+    }
+    // Safe to normalize now -- validation confirmed arrays of strings
+    const proposedEditFiles = (input.proposedEditFiles ?? []).map(normalizeRelPath);
+    const proposedReadFiles = (input.proposedReadFiles ?? []).map(normalizeRelPath);
+    const proposedTestFiles = (input.proposedTestFiles ?? []).map(normalizeRelPath);
+    // Check for paths outside workspace
+    const outsidePaths = [];
+    for (const f of [...proposedEditFiles, ...proposedReadFiles, ...proposedTestFiles]) {
+        if (isOutsideWorkspace(f, workspace)) {
+            outsidePaths.push(f);
+        }
+    }
+    // Run FlowSeeker retrieval
+    const result = await runPipeline(task, workspace);
+    const groups = (0, fileGroups_1.aggregateEvidenceFiles)(result.units);
+    const topFiles = groups.map((g) => g.relativePath);
+    // FlowSeeker's view of the world
+    const fsEditCandidates = groups.filter((g) => g.role === "edit_candidate").map((g) => g.relativePath);
+    const fsReadContext = groups.filter((g) => g.role === "read_context").map((g) => g.relativePath);
+    const fsTests = groups.filter((g) => g.role === "test" || g.role === "verify").map((g) => g.relativePath);
+    const fsNoise = result.solvePacket?.noiseRisk.map((f) => f.relativePath) ?? [];
+    const fsDoNotEdit = result.solvePacket?.doNotEditYet ?? [];
+    const fsCoverage = result.contextCoverage;
+    const fsMissingSlots = fsCoverage?.missingRequiredSlots.map(String) ?? [];
+    const issues = [];
+    const matchedEdit = [];
+    const unsupportedEdit = [];
+    const readContextOnly = [];
+    // Compare proposed edits against FlowSeeker results
+    for (const pf of proposedEditFiles) {
+        if (anyPathMatches(pf, fsEditCandidates)) {
+            matchedEdit.push(pf);
+        }
+        else {
+            unsupportedEdit.push(pf);
+            if (anyPathMatches(pf, fsReadContext)) {
+                readContextOnly.push(pf);
+                issues.push(`"${pf}" is only in read-only context -- consider moving to proposedReadFiles`);
+            }
+            else if (anyPathMatches(pf, fsNoise) || anyPathMatches(pf, fsDoNotEdit)) {
+                issues.push(`"${pf}" is flagged as noise/do-not-edit by FlowSeeker`);
+            }
+            else {
+                issues.push(`"${pf}" is not a FlowSeeker primary edit candidate`);
+            }
+        }
+    }
+    // Check if strong edit candidates are only in proposedReadFiles
+    for (const ec of fsEditCandidates.slice(0, 5)) {
+        if (!anyPathMatches(ec, proposedEditFiles) && anyPathMatches(ec, proposedReadFiles)) {
+            issues.push(`"${ec}" is a strong edit candidate but is only listed as proposedReadFiles`);
+        }
+    }
+    // Missing slots
+    const combinedMissingSlots = [
+        ...fsMissingSlots.filter((s) => !fsCoverage?.foundRequiredSlots.some((f) => f === s)),
+    ];
+    // Outside workspace paths
+    for (const op of outsidePaths) {
+        issues.push(`"${op}" is outside workspace -- rejected`);
+    }
+    // Determine verdict
+    let verdict = "safe";
+    const hasUnsupported = unsupportedEdit.filter((f) => !outsidePaths.includes(f)).length > 0;
+    if (outsidePaths.length > 0 || unsupportedEdit.some((f) => anyPathMatches(f, fsNoise) || anyPathMatches(f, fsDoNotEdit))) {
+        verdict = "risky";
+    }
+    else if (riskMode === "strict" && hasUnsupported) {
+        verdict = "risky";
+    }
+    else if (hasUnsupported) {
+        verdict = "caution";
+    }
+    else if (riskMode === "strict" && combinedMissingSlots.length > 0) {
+        verdict = "caution";
+    }
+    if (fsEditCandidates.length === 0 && groups.length < 3) {
+        verdict = "insufficient_evidence";
+        issues.push("FlowSeeker retrieval produced too few candidates for confident validation");
+    }
+    // Evidence summary
+    const evidenceSummary = [
+        `FlowSeeker found ${fsEditCandidates.length} edit candidate(s), ${fsReadContext.length} read context file(s), ${fsTests.length} test/verify file(s).`,
+        `Matched ${matchedEdit.length}/${proposedEditFiles.length} proposed edit file(s).`,
+        fsMissingSlots.length > 0 ? `Missing slots: ${fsMissingSlots.join(", ")}.` : "All required slots covered.",
+    ].join(" ");
+    const output = {
+        verdict,
+        issues,
+        suggestedEditFiles: [...new Set([...matchedEdit, ...fsEditCandidates.slice(0, 5)])].filter((f) => !outsidePaths.includes(f)),
+        suggestedReadFiles: fsReadContext.slice(0, 5),
+        suggestedTestFiles: fsTests.slice(0, 5),
+        missingSlots: combinedMissingSlots,
+        doNotEditYet: [...fsDoNotEdit, ...fsNoise.slice(0, 5)].filter((f) => !outsidePaths.includes(f)),
+        rejectedPaths: outsidePaths,
+        evidenceSummary,
+        riskMode,
+        confidence: verdict === "safe" ? "high" : verdict === "caution" ? "medium" : "low",
+        matchedProposedEditFiles: matchedEdit,
+        unsupportedProposedEditFiles: unsupportedEdit.filter((f) => !outsidePaths.includes(f)),
+        proposedEditFilesOnlySeenAsReadContext: readContextOnly,
+        topFlowSeekerEditCandidates: fsEditCandidates.slice(0, 5),
+    };
+    return textResult(JSON.stringify(output, null, 2));
+}
 //# sourceMappingURL=mcpTools.js.map