@quantakrypto/mcp 0.2.2 → 0.4.0

package/dist/tools.js

@@ -1,19 +1,17 @@
 /**
  * quantakrypto MCP tools, backed by {@link @quantakrypto/core}.
  *
- * Every tool returns an MCP {@link ToolResult} ({ content, isError? }). Because
- * `@quantakrypto/core` is still partly stubbed (several functions throw "not
- * implemented"), each handler runs core calls through {@link safe} so a missing
- * implementation surfaces as a readable `isError` tool result instead of a
- * protocol-level crash. When core lands, the tools work unchanged.
+ * Every tool returns an MCP {@link ToolResult} ({ content, isError? }). Each
+ * handler runs core calls through {@link safe} so any runtime failure (a bad
+ * path, a work-budget overflow, an unexpected error) surfaces as a readable
+ * `isError` tool result with host details stripped, rather than a protocol-level
+ * crash.
  */
 import process from "node:process";
-import { VERSION, AbortError, BudgetExceededError, buildInventory, detectors, remediationFor, scan, toCbom, } from "@quantakrypto/core";
+import { VERSION, AbortError, BudgetExceededError, buildInventory, buildRemediateRequest, buildTriageRequest, compareFindings, detectors, fingerprintFinding, languageToExtension, remediationFor, scan, SEVERITY_ORDER, toCbom, verifyFix, vulnerableDependencies, } from "@quantakrypto/core";
 import { errorResult, textResult } from "./protocol.js";
 import { resolveRule } from "./rules.js";
 import { resolveFsConfig, resolveScanPath } from "./fsconfig.js";
-/** Severity order for stable, human-friendly summaries. */
-const SEVERITY_ORDER = ["critical", "high", "medium", "low", "info"];
 /** All classical algorithm families we can advise on, used for validation/help. */
 const ALGORITHM_FAMILIES = [
     "RSA",
@@ -23,6 +21,7 @@ const ALGORITHM_FAMILIES = [
     "DH",
     "DSA",
     "X25519",
+    "X448",
     "ECIES",
     "unknown",
 ];
@@ -100,6 +99,8 @@ function normalizeAlgorithm(input) {
         return "ECDSA";
     if (cleaned.includes("ED25519") || cleaned.includes("EDDSA"))
         return "EdDSA";
+    if (cleaned.includes("X448") || cleaned.includes("CURVE448"))
+        return "X448";
     if (cleaned.includes("X25519") || cleaned.includes("CURVE25519"))
         return "X25519";
     if (cleaned.includes("ECDH"))
@@ -284,13 +285,22 @@ const explainFindingTool = {
         if (ruleId) {
             const resolved = resolveRule(ruleId);
             resolvedAlgorithm = resolved.algorithm;
-            lines.push(`Rule: ${ruleId}`);
+            const meta = resolved.meta;
+            lines.push(`Rule: ${meta ? `${ruleId} — ${meta.title}` : ruleId}`);
             if (resolved.detector) {
                 lines.push(`Detector: ${resolved.detector.id} — ${resolved.detector.description}`);
             }
             else if (resolved.via === "unresolved") {
                 lines.push("No matching detector found in the catalog (rule may be unknown to this core version).");
             }
+            // Rule catalog metadata (severity / category / HNDL / remediation) so the
+            // explanation is actionable on its own, not just a detector pointer.
+            if (meta) {
+                lines.push(`Severity: ${meta.severity} · Category: ${meta.category} · HNDL-exposed: ${meta.hndl ? "yes" : "no"}`);
+                lines.push(`What it detects: ${meta.description ?? meta.message}`);
+                if (meta.remediation)
+                    lines.push(`Rule remediation: ${meta.remediation}`);
+            }
         }
         // Prefer an explicit algorithm; otherwise use the one the rule resolved to.
         const algorithm = algoInput
@@ -352,7 +362,8 @@ const suggestHybridTool = {
             lines.push(`Rationale: ${rem.value.detail}`);
         }
         else {
-            // Static fallback table so the tool stays useful even with a stubbed core.
+            // Defensive fallback: core has a remediation for every known family, so
+            // this only triggers if the lookup throws or the algorithm is unrecognised.
             lines.push(...staticHybridAdvice(algorithm));
         }
         lines.push("");
@@ -453,13 +464,581 @@ const generateCbomTool = {
         return textResult(JSON.stringify(cbom.value, null, 2));
     },
 };
+// ---------------------------------------------------------------------------
+// Copilot tools — let an AI coding agent migrate *through* the deterministic
+// engine ("the model proposes, the engine disposes"). plan_migration scans and
+// orders the work; get_fix_examples shows the code change; verify_fix re-runs
+// the detectors on the agent's edited code to confirm the classical crypto is
+// actually gone; check_dependency and score_delta quantify the work.
+// ---------------------------------------------------------------------------
+// `languageToExtension` + `verifyFix` now live in @quantakrypto/core so this tool and
+// the remediation pipeline share one definition of "the fix is verified".
+/** Before/after migration snippets per classical family. Static + deterministic. */
+const FIX_EXAMPLES = {
+    RSA: {
+        note: "RSA key establishment → ML-KEM-768 (hybrid X25519MLKEM768). RSA signatures → ML-DSA-65.",
+        before: "// key establishment\nconst { publicKey } = crypto.generateKeyPairSync('rsa', { modulusLength: 3072 });\nconst enc = crypto.publicEncrypt(publicKey, data);",
+        after: "// hybrid KEM (e.g. @noble/post-quantum or a TLS 1.3 hybrid group)\nimport { MlKem768 } from 'mlkem';\nconst kem = new MlKem768();\nconst [encapsulated, sharedSecret] = await kem.encap(peerPublicKey); // pair with X25519 for hybrid",
+    },
+    ECDH: {
+        note: "ECDH / DH key agreement → hybrid X25519MLKEM768 (ML-KEM-768 + X25519).",
+        before: "const ecdh = crypto.createECDH('prime256v1');\nconst shared = ecdh.computeSecret(peerKey);",
+        after: "// TLS: negotiate the X25519MLKEM768 named group. In app code, combine ML-KEM-768\n// with X25519 and KDF the concatenated secrets so security holds if either survives.",
+    },
+    DH: {
+        note: "Finite-field DH → hybrid X25519MLKEM768.",
+        before: "const dh = crypto.createDiffieHellman(2048);",
+        after: "// Replace with ML-KEM-768 encapsulation, deployed as a hybrid with X25519.",
+    },
+    X25519: {
+        note: "X25519 is modern but classical; wrap it in a hybrid X25519MLKEM768 rather than dropping it.",
+        before: "const alice = crypto.generateKeyPairSync('x25519');",
+        after: "// Keep X25519 AND add ML-KEM-768; derive the session key from both (hybrid).",
+    },
+    ECDSA: {
+        note: "ECDSA signatures → ML-DSA-65 (Dilithium), or SLH-DSA where statelessness matters.",
+        before: "const sig = crypto.sign('sha256', msg, ecPrivateKey);",
+        after: "import { ml_dsa65 } from '@noble/post-quantum/ml-dsa';\nconst sig = ml_dsa65.sign(mlDsaSecretKey, msg);",
+    },
+    EdDSA: {
+        note: "Ed25519/Ed448 signatures → ML-DSA-65 (or a hybrid Ed25519+ML-DSA during transition).",
+        before: "const sig = crypto.sign(null, msg, ed25519PrivateKey);",
+        after: "import { ml_dsa65 } from '@noble/post-quantum/ml-dsa';\nconst sig = ml_dsa65.sign(mlDsaSecretKey, msg);",
+    },
+    DSA: {
+        note: "DSA is deprecated; rotate keys and migrate to ML-DSA-65.",
+        before: "crypto.generateKeyPairSync('dsa', { modulusLength: 2048 });",
+        after: "import { ml_dsa65 } from '@noble/post-quantum/ml-dsa';\nconst keys = ml_dsa65.keygen();",
+    },
+};
+const planMigrationTool = {
+    name: "plan_migration",
+    description: "Scan a path and return a deterministic, prioritized post-quantum migration " +
+        "plan: findings grouped by algorithm, ordered harvest-now-decrypt-later first, " +
+        "each with its PQC target and the readiness-score impact. Reads the filesystem, " +
+        "so it is gated like scan_path over HTTP.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            path: {
+                type: "string",
+                description: "Absolute or relative path to a file or directory to plan a migration for.",
+            },
+        },
+        required: ["path"],
+        additionalProperties: false,
+    },
+    async handler(args, context) {
+        const path = args.path;
+        if (typeof path !== "string" || path.length === 0) {
+            return errorResult("plan_migration requires a non-empty 'path' string.");
+        }
+        const opts = buildScanOptions(path, context);
+        if (!opts.ok)
+            return opts.result;
+        const scanned = await safe("scan", () => scan(opts.options));
+        if (!scanned.ok)
+            return scanned.result;
+        const plan = await buildMigrationPlan(scanned.value);
+        return {
+            content: [
+                { type: "text", text: plan.human },
+                { type: "text", text: JSON.stringify(plan.structured, null, 2) },
+            ],
+        };
+    },
+};
+/** Build a deterministic, prioritized migration plan from a scan result. */
+async function buildMigrationPlan(result) {
+    const findings = result.findings;
+    const byPhase = { 1: [], 2: [], 3: [] };
+    for (const f of findings) {
+        // Phase 1: HNDL-exposed confidentiality (harvest now, decrypt later) — most urgent.
+        // Phase 2: forgeable signatures. Phase 3: transport / certificate config.
+        if (f.hndl)
+            byPhase[1].push(f);
+        else if (f.category === "tls" || f.category === "certificate")
+            byPhase[3].push(f);
+        else
+            byPhase[2].push(f);
+    }
+    const phaseMeta = {
+        1: {
+            title: "Harvest-now-decrypt-later (do first)",
+            rationale: "Key exchange / public-key encryption. Traffic captured today is decryptable once a quantum computer exists — migrate these first.",
+        },
+        2: {
+            title: "Quantum-forgeable signatures",
+            rationale: "Signatures are not retroactively broken, but become forgeable post-Q-day. Migrate before Q-day, prioritising long-lived keys.",
+        },
+        3: {
+            title: "Transport & certificate configuration",
+            rationale: "TLS versions, cipher suites, and certificate signature algorithms. Adopt hybrid PQC named groups and plan PQC-capable CA re-issuance.",
+        },
+    };
+    async function groupsFor(list) {
+        const byAlgo = new Map();
+        for (const f of list) {
+            const a = (f.algorithm ?? "unknown");
+            const arr = byAlgo.get(a) ?? [];
+            arr.push(f);
+            byAlgo.set(a, arr);
+        }
+        const groups = [];
+        for (const [algorithm, fs] of byAlgo) {
+            const rem = await safe("remediationFor", () => remediationFor(algorithm));
+            groups.push({
+                algorithm,
+                count: fs.length,
+                hndlCount: fs.filter((f) => f.hndl).length,
+                remediation: rem.ok && rem.value ? rem.value.recommendation : "Adopt NIST PQC (ML-KEM / ML-DSA).",
+                locations: fs.slice(0, 8).map((f) => `${f.location.file}:${f.location.line}`),
+            });
+        }
+        // Largest groups first within a phase.
+        groups.sort((a, b) => b.count - a.count);
+        return groups;
+    }
+    const phases = [];
+    for (const p of [1, 2, 3]) {
+        if (byPhase[p].length === 0)
+            continue;
+        phases.push({
+            phase: p,
+            title: phaseMeta[p].title,
+            rationale: phaseMeta[p].rationale,
+            groups: await groupsFor(byPhase[p]),
+        });
+    }
+    const lines = [];
+    lines.push(`Post-quantum migration plan for ${result.root}`);
+    lines.push(`Readiness score: ${result.inventory.readinessScore}/100 · ${findings.length} finding(s) · ${result.inventory.hndlCount} HNDL-exposed`);
+    if (findings.length === 0) {
+        lines.push("");
+        lines.push(result.analyzedFiles === 0
+            ? "No analyzable source was scanned — this plan does NOT cover unsupported languages."
+            : "No classical asymmetric cryptography found. Keep scanning in CI to hold the line.");
+        return { human: lines.join("\n"), structured: { root: result.root, phases: [] } };
+    }
+    for (const ph of phases) {
+        lines.push("");
+        lines.push(`Phase ${ph.phase}: ${ph.title}`);
+        lines.push(`  ${ph.rationale}`);
+        for (const g of ph.groups) {
+            lines.push(`  - ${g.algorithm} × ${g.count}${g.hndlCount ? ` (${g.hndlCount} HNDL)` : ""} → ${g.remediation}`);
+            lines.push(`      e.g. ${g.locations.join(", ")}${g.count > g.locations.length ? ", …" : ""}`);
+        }
+    }
+    lines.push("");
+    lines.push("Use get_fix_examples for per-algorithm code changes, then verify_fix to confirm each edit.");
+    return {
+        human: lines.join("\n"),
+        structured: {
+            root: result.root,
+            readinessScore: result.inventory.readinessScore,
+            totalFindings: findings.length,
+            hndlExposed: result.inventory.hndlCount,
+            phases,
+        },
+    };
+}
+const getFixExamplesTool = {
+    name: "get_fix_examples",
+    description: "Return before/after code examples for migrating a classical algorithm to a " +
+        "post-quantum / hybrid replacement. Provide an 'algorithm' (RSA, ECDH, ECDSA, …) " +
+        "or a 'ruleId' from a finding.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            algorithm: {
+                type: "string",
+                description: "Classical algorithm family to migrate away from.",
+            },
+            ruleId: { type: "string", description: "A finding's ruleId (resolved to its algorithm)." },
+        },
+        additionalProperties: false,
+    },
+    async handler(args) {
+        const algoInput = typeof args.algorithm === "string" ? args.algorithm.trim() : "";
+        const ruleId = typeof args.ruleId === "string" ? args.ruleId.trim() : "";
+        if (!algoInput && !ruleId) {
+            return errorResult("get_fix_examples requires 'algorithm' or 'ruleId'.");
+        }
+        let family;
+        if (algoInput) {
+            family = normalizeAlgorithm(algoInput);
+        }
+        else {
+            const resolved = resolveRule(ruleId);
+            family = resolved.meta?.algorithm ?? resolved.algorithm ?? "unknown";
+        }
+        // Fold families that share a fix onto the example we have.
+        const key = family === "ECIES" ? "RSA" : family;
+        const ex = FIX_EXAMPLES[key];
+        if (!ex) {
+            const rem = await safe("remediationFor", () => remediationFor(family));
+            return textResult(`No canned example for ${family}. ${rem.ok && rem.value
+                ? rem.value.recommendation
+                : "Adopt NIST PQC (ML-KEM / ML-DSA), deployed as hybrids."}`);
+        }
+        const text = [
+            `Migration example — ${family}`,
+            ex.note,
+            "",
+            "BEFORE (classical):",
+            ex.before,
+            "",
+            "AFTER (post-quantum / hybrid):",
+            ex.after,
+            "",
+            "Deploy as a hybrid (classical + PQC) first; drop the classical half once the PQC side is proven.",
+        ].join("\n");
+        return {
+            content: [
+                { type: "text", text },
+                { type: "text", text: JSON.stringify({ algorithm: family, ...ex }, null, 2) },
+            ],
+        };
+    },
+};
+const verifyFixTool = {
+    name: "verify_fix",
+    description: "Run the quantakrypto detectors over a code snippet (NOT the filesystem) and " +
+        "report any classical crypto that remains. Use this to confirm an edit actually " +
+        "removed the quantum-vulnerable usage. Provide 'code' plus a 'language' or 'filename'.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            code: { type: "string", description: "The source code to check." },
+            language: {
+                type: "string",
+                description: "Language of the code (js, ts, python, go, java, csharp, rust, ruby, c, …).",
+            },
+            filename: {
+                type: "string",
+                description: "Optional filename; its extension selects the detectors (overrides 'language').",
+            },
+        },
+        required: ["code"],
+        additionalProperties: false,
+    },
+    async handler(args) {
+        const code = typeof args.code === "string" ? args.code : "";
+        if (!code)
+            return errorResult("verify_fix requires a non-empty 'code' string.");
+        const filename = typeof args.filename === "string" ? args.filename.trim() : "";
+        const language = typeof args.language === "string" ? args.language.trim() : "";
+        if (!filename && !language) {
+            return errorResult("verify_fix requires a 'language' or a 'filename' to know which detectors to run.");
+        }
+        if (!filename && languageToExtension(language) === null) {
+            return errorResult(`verify_fix: unknown language "${language}". Supported: js/ts, python, go, java, kotlin, csharp, rust, ruby, c/c++ — or pass a 'filename'.`);
+        }
+        const res = await safe("verifyFix", () => verifyFix(code, { filename, language }));
+        if (!res.ok)
+            return res.result;
+        const { supported, findings } = res.value;
+        if (findings.length === 0) {
+            const caveat = supported
+                ? "Fix verified: no classical asymmetric cryptography detected in this snippet."
+                : "No classical crypto detected — but this language is NOT one the scanner analyzes, so this is not a verification. Use a supported language.";
+            return textResult(caveat);
+        }
+        const lines = [`Still ${findings.length} classical finding(s) — fix NOT complete:`];
+        for (const f of findings) {
+            lines.push(`- [${f.severity}] ${f.ruleId} (line ${f.location.line})${f.hndl ? " (HNDL)" : ""} — ${f.message}`);
+        }
+        return {
+            content: [
+                { type: "text", text: lines.join("\n") },
+                { type: "text", text: JSON.stringify(findings, null, 2) },
+            ],
+        };
+    },
+};
+const checkDependencyTool = {
+    name: "check_dependency",
+    description: "Check whether a package is in quantakrypto's known quantum-vulnerable dependency " +
+        "database (the classical crypto it exposes). Provide 'name' and optional 'ecosystem' (default npm).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Package name to look up (e.g. 'node-forge', 'jsonwebtoken').",
+            },
+            ecosystem: { type: "string", description: "Package ecosystem. Default: npm." },
+        },
+        required: ["name"],
+        additionalProperties: false,
+    },
+    async handler(args) {
+        const name = typeof args.name === "string" ? args.name.trim().toLowerCase() : "";
+        if (!name)
+            return errorResult("check_dependency requires a non-empty 'name'.");
+        const ecosystem = typeof args.ecosystem === "string" ? args.ecosystem.trim().toLowerCase() : "npm";
+        const db = await safe("vulnerableDependencies", () => vulnerableDependencies);
+        if (!db.ok)
+            return db.result;
+        const hit = db.value.find((d) => d.name.toLowerCase() === name && d.ecosystem.toLowerCase() === ecosystem);
+        if (!hit) {
+            return textResult(`"${name}" (${ecosystem}) is NOT in the known quantum-vulnerable dependency database. ` +
+                "That is not proof it's safe — it may simply not be catalogued, or its crypto may be in your own code. Scan the source too.");
+        }
+        const rem = await safe("remediationFor", () => remediationFor(hit.algorithms[0] ?? "unknown"));
+        const text = [
+            `${hit.name} (${hit.ecosystem}) — quantum-vulnerable [${hit.severity}]`,
+            `Exposes: ${hit.algorithms.join(", ")}`,
+            `Why: ${hit.reason}`,
+            rem.ok && rem.value
+                ? `Migrate toward: ${rem.value.recommendation}`
+                : "Migrate toward NIST PQC (ML-KEM / ML-DSA).",
+        ].join("\n");
+        return {
+            content: [
+                { type: "text", text },
+                { type: "text", text: JSON.stringify(hit, null, 2) },
+            ],
+        };
+    },
+};
+const scoreDeltaTool = {
+    name: "score_delta",
+    description: "Compute the readiness-score and HNDL change between two finding sets (e.g. before " +
+        "and after a migration). Pass 'before' and 'after' as arrays of findings from " +
+        "scan_path --format json.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            before: {
+                type: "array",
+                description: "Findings before the change (from a scan's JSON findings).",
+            },
+            after: { type: "array", description: "Findings after the change." },
+        },
+        required: ["before", "after"],
+        additionalProperties: false,
+    },
+    async handler(args) {
+        if (!Array.isArray(args.before) || !Array.isArray(args.after)) {
+            return errorResult("score_delta requires 'before' and 'after' arrays of findings.");
+        }
+        const before = args.before;
+        const after = args.after;
+        const invBefore = await safe("buildInventory", () => buildInventory(before));
+        if (!invBefore.ok)
+            return invBefore.result;
+        const invAfter = await safe("buildInventory", () => buildInventory(after));
+        if (!invAfter.ok)
+            return invAfter.result;
+        const dScore = invAfter.value.readinessScore - invBefore.value.readinessScore;
+        const dHndl = invAfter.value.hndlCount - invBefore.value.hndlCount;
+        const dCount = after.length - before.length;
+        const sign = (n) => (n > 0 ? `+${n}` : `${n}`);
+        const text = [
+            "Readiness delta",
+            `Score:   ${invBefore.value.readinessScore} → ${invAfter.value.readinessScore}  (${sign(dScore)})`,
+            `Findings: ${before.length} → ${after.length}  (${sign(dCount)})`,
+            `HNDL:    ${invBefore.value.hndlCount} → ${invAfter.value.hndlCount}  (${sign(dHndl)})`,
+            dScore > 0
+                ? "Progress: readiness improved."
+                : dScore < 0
+                    ? "Regression: readiness dropped — new classical crypto was introduced."
+                    : "No net change in readiness.",
+        ].join("\n");
+        return {
+            content: [
+                { type: "text", text },
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        before: {
+                            score: invBefore.value.readinessScore,
+                            findings: before.length,
+                            hndl: invBefore.value.hndlCount,
+                        },
+                        after: {
+                            score: invAfter.value.readinessScore,
+                            findings: after.length,
+                            hndl: invAfter.value.hndlCount,
+                        },
+                        delta: { score: dScore, findings: dCount, hndl: dHndl },
+                    }, null, 2),
+                },
+            ],
+        };
+    },
+};
+const triageFindingsTool = {
+    name: "triage_findings",
+    description: "Produce a deterministic triage REQUEST bundle (rubric + verdict schema + " +
+        "per-finding metadata) for YOU (the host agent) to reason over. This tool does " +
+        "NOT call any model and needs no API key. Assess each finding's real-world " +
+        "exposure, then call apply_triage with your verdicts. Pass 'findings' as an " +
+        "array from scan_path --format json.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            findings: { type: "array", description: "Findings from a scan's JSON output." },
+        },
+        required: ["findings"],
+        additionalProperties: false,
+    },
+    async handler(args) {
+        if (!Array.isArray(args.findings)) {
+            return errorResult("triage_findings requires a 'findings' array.");
+        }
+        const findings = args.findings;
+        const request = buildTriageRequest(findings, "metadata");
+        // Pair each context with the finding fingerprint the verdict must echo back.
+        const items = findings.map((f, i) => ({
+            fingerprint: fingerprintFinding(f),
+            context: request.contexts[i],
+        }));
+        const bundle = { rubric: request.rubric, schema: request.schema, items };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Triage request. For each item, decide {exposureScore 0-100, priority, rationale} " +
+                        "per the rubric, then call apply_triage with the same 'findings' and a 'verdicts' " +
+                        "array (each carrying the item's 'fingerprint'). You never suppress a finding.",
+                },
+                { type: "text", text: JSON.stringify(bundle, null, 2) },
+            ],
+        };
+    },
+};
+/** Validate one caller-supplied triage verdict. Returns null when malformed. */
+function parseVerdict(v) {
+    if (typeof v !== "object" || v === null)
+        return null;
+    const o = v;
+    const fingerprint = o.fingerprint;
+    const exposureScore = o.exposureScore;
+    const priority = o.priority;
+    const rationale = o.rationale;
+    if (typeof fingerprint !== "string")
+        return null;
+    if (typeof exposureScore !== "number" || exposureScore < 0 || exposureScore > 100)
+        return null;
+    if (priority !== "now" && priority !== "soon" && priority !== "later")
+        return null;
+    if (typeof rationale !== "string")
+        return null;
+    return { fingerprint, exposureScore, priority, rationale };
+}
+const applyTriageTool = {
+    name: "apply_triage",
+    description: "Deterministically attach your triage verdicts to their findings and re-sort by " +
+        "exposure (highest first). Never suppresses. Pass the same 'findings' array you " +
+        "triaged plus a 'verdicts' array of { fingerprint, exposureScore, priority, rationale }.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            findings: { type: "array", description: "The findings that were triaged." },
+            verdicts: { type: "array", description: "One verdict per finding, keyed by fingerprint." },
+        },
+        required: ["findings", "verdicts"],
+        additionalProperties: false,
+    },
+    async handler(args) {
+        if (!Array.isArray(args.findings) || !Array.isArray(args.verdicts)) {
+            return errorResult("apply_triage requires 'findings' and 'verdicts' arrays.");
+        }
+        const findings = args.findings;
+        const byFingerprint = new Map();
+        let skipped = 0;
+        for (const raw of args.verdicts) {
+            const v = parseVerdict(raw);
+            if (v)
+                byFingerprint.set(v.fingerprint, v);
+            else
+                skipped++;
+        }
+        const annotated = findings.map((f) => {
+            const v = byFingerprint.get(fingerprintFinding(f));
+            return v
+                ? {
+                    ...f,
+                    triage: {
+                        exposureScore: v.exposureScore,
+                        priority: v.priority,
+                        rationale: v.rationale,
+                    },
+                }
+                : f;
+        });
+        annotated.sort((a, b) => {
+            const ea = a.triage?.exposureScore ?? -1;
+            const eb = b.triage?.exposureScore ?? -1;
+            if (eb !== ea)
+                return eb - ea;
+            return compareFindings(a, b);
+        });
+        const applied = annotated.filter((f) => f.triage).length;
+        const head = `Triaged ${applied}/${findings.length} finding(s), re-sorted by exposure.` +
+            (skipped ? ` ${skipped} malformed verdict(s) ignored.` : "");
+        return {
+            content: [
+                { type: "text", text: head },
+                { type: "text", text: JSON.stringify(annotated, null, 2) },
+            ],
+        };
+    },
+};
+const remediateFindingsTool = {
+    name: "remediate_findings",
+    description: "Produce a deterministic remediation REQUEST bundle (rubric + fix schema + " +
+        "per-finding metadata + fingerprints) for YOU (the host agent) to fix. This " +
+        "tool calls no model and needs no key. For each finding, propose the corrected " +
+        "FULL file content, then VERIFY with verify_fix and keep only fixes that clear " +
+        "the finding. Never touch files with secrets; never auto-merge. Pass 'findings' " +
+        "from scan_path --format json.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            findings: { type: "array", description: "Findings from a scan's JSON output." },
+        },
+        required: ["findings"],
+        additionalProperties: false,
+    },
+    async handler(args) {
+        if (!Array.isArray(args.findings)) {
+            return errorResult("remediate_findings requires a 'findings' array.");
+        }
+        const findings = args.findings;
+        const request = buildRemediateRequest(findings, "metadata");
+        const items = findings.map((f, i) => ({
+            fingerprint: fingerprintFinding(f),
+            context: request.contexts[i],
+        }));
+        const bundle = { instructions: request.instructions, schema: request.schema, items };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Remediation request. For each item, propose {path, newContent, explanation} " +
+                        "(the FULL corrected file), call verify_fix on your newContent, and keep only " +
+                        "verified fixes. Skip any file containing secrets. This never merges anything.",
+                },
+                { type: "text", text: JSON.stringify(bundle, null, 2) },
+            ],
+        };
+    },
+};
 /**
  * Tools that read arbitrary filesystem paths. Disabled by default on the HTTP
  * transport (see {@link ./http.ts}) because a hosted endpoint must not be an
  * arbitrary-file-read oracle (security audit Q-01). The stdio transport, which
  * trusts the local user, always exposes them.
  */
-export const FS_TOOL_NAMES = ["scan_path", "inventory_crypto", "generate_cbom"];
+export const FS_TOOL_NAMES = [
+    "scan_path",
+    "inventory_crypto",
+    "generate_cbom",
+    "plan_migration",
+];
 /** All quantakrypto MCP tools, in a stable order. */
 export const quantakryptoTools = [
     scanPathTool,
@@ -468,6 +1047,16 @@ export const quantakryptoTools = [
     suggestHybridTool,
     listRulesTool,
     generateCbomTool,
+    // Copilot tools — migrate through the engine.
+    planMigrationTool,
+    getFixExamplesTool,
+    verifyFixTool,
+    checkDependencyTool,
+    scoreDeltaTool,
+    // BYOK triage + remediation — deterministic request/apply (host agent reasons; offline).
+    triageFindingsTool,
+    applyTriageTool,
+    remediateFindingsTool,
 ];
 /** The core version these tools are built against (re-exported for diagnostics). */
 export const CORE_VERSION = VERSION;