modwright 0.1.0

package/dist/server.js

@@ -0,0 +1,1914 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { pathExists, tail } from "./core/fsutil.js";
+import { describeProject, findProjectFile, loadProject } from "./core/project/index.js";
+import { userDataDir } from "./core/home.js";
+import { applyDataFetch, applyManagedInstall, checkToolchain, featureReadiness, locateTool, planDataFetch, planDataMemory, planManagedInstall, planToolMemory, readinessSummary, TOOL_SPECS, toolsToLocate } from "./core/toolchain/index.js";
+import { loadUserConfig } from "./core/userconfig.js";
+import { runCompat } from "./core/compat/check.js";
+import { SignatureRegistry, triageLogs } from "./core/logs/index.js";
+import { buildContext, createValidatorRegistry, runValidators } from "./core/validate/index.js";
+import { runBuild } from "./core/build/index.js";
+import { classifyReload, detectRedHotTools, runDeploy } from "./core/deploy/index.js";
+import { armBridge, bridgeCandidateDirs, bridgeStatus, cetLogCandidates, listPendingArms, PROTOCOL_VERSION as BRIDGE_PROTOCOL_VERSION, pollCyberpunk, pollForResult, probeSchema as bridgeProbeSchema, readPendingArm, stageBridge } from "./core/bridge/index.js";
+import { runTestPlan } from "./core/testplan/index.js";
+import { applyBuildLedgerHook, applyClaimTransition, applyDecisionRecord, applyValidateLedgerHook, checkLedger, claimsFilePath, listClaims, loadClaims, loadDecisions, saveClaims, saveDecisions, showClaim, } from "./core/ledger/index.js";
+import { IndexStore, defaultCacheDir, findLegacyIndex, indexFile, legacyIndexHint, loadKnowledge, resolveIndexFile, searchFacts, } from "./core/knowledge/index.js";
+import { pathExists as fileExists } from "./core/fsutil.js";
+import { executePlan, listBackups, restoreBackup } from "./core/safety/index.js";
+import { readTextIfExists } from "./core/fsutil.js";
+import * as path from "node:path";
+import { promises as fs } from "node:fs";
+import { crossCheckIdentities, findConflicts, listMods, sharedIdentities } from "./core/mods.js";
+import { resolveLogs, resolveRoots } from "./core/surfaceutil.js";
+import { SURFACES, getSurface, installGameVersion, resolveInstall, surfaceIds } from "./surfaces/index.js";
+import { CONVERTERS, convert as runConvert, defaultLocateTool as defaultTextLocateTool, extractTemplate, fieldDiff, getTemplate, invalidateTemplate, listTemplates, } from "./core/text/index.js";
+import { bootstrapProject, describe as describeScaffold, findScaffold, findSequence, generateClaudeAssets, loadAllScaffolds, loadAllSequences, planSequence, runScaffold, summarize, summarizeSequences } from "./core/scaffold/index.js";
+import { loadSkillPromptCatalog, renderSkillPrompt } from "./core/prompts.js";
+const server = new McpServer({ name: "modwright", version: "0.1.0" });
+const registry = new SignatureRegistry();
+for (const surface of SURFACES) {
+    if (surface.logSignatures?.length)
+        registry.register(surface.logSignatures);
+}
+function json(value) {
+    return { content: [{ type: "text", text: JSON.stringify(value, binaryAsSize, 2) }] };
+}
+function binaryAsSize(key, value) {
+    const raw = this?.[key];
+    if (raw instanceof Uint8Array)
+        return { bytes: raw.byteLength };
+    return value;
+}
+function fail(message) {
+    return { content: [{ type: "text", text: message }], isError: true };
+}
+class NoProjectError extends Error {
+}
+async function projectOrFail(start) {
+    try {
+        return await resolveProject(start);
+    }
+    catch (error) {
+        return fail(error instanceof NoProjectError ? error.message : `Could not load project: ${error.message}`);
+    }
+}
+const gameArg = z
+    .string()
+    .describe(`Game id or alias. Known ids: ${surfaceIds().join(", ")}`);
+const installPathArg = z
+    .string()
+    .optional()
+    .describe("Override the game root path. Omit to use auto-detection.");
+server.registerTool("list_games", {
+    title: "List supported games",
+    description: "List every game ModWright has a surface for, whether an install was detected, " +
+        "and the modding model each game uses. Start here.",
+    inputSchema: {},
+}, async () => {
+    const games = await Promise.all(SURFACES.map(async (surface) => ({
+        id: surface.id,
+        name: surface.name,
+        aliases: surface.aliases ?? [],
+        summary: surface.summary,
+        installs: await surface.detect(),
+    })));
+    return json({ games });
+});
+server.registerTool("detect_install", {
+    title: "Detect a game install",
+    description: "Locate installs of one game and report its mod roots and log sources, marking " +
+        "which exist on disk, plus surface-specific guidance.",
+    inputSchema: { game: gameArg, installPath: installPathArg },
+}, async ({ game, installPath }) => {
+    const surface = getSurface(game);
+    if (!surface)
+        return fail(`Unknown game "${game}". Known: ${surfaceIds().join(", ")}`);
+    const install = await resolveInstall(surface, installPath);
+    if (!install) {
+        return json({
+            game: surface.id,
+            detected: false,
+            hint: "No install found. Pass installPath explicitly, or set " +
+                `MODWRIGHT_${surface.id.toUpperCase()}_ROOT.`,
+        });
+    }
+    return json({
+        game: surface.id,
+        detected: true,
+        install,
+        modRoots: await resolveRoots(surface, install),
+        logs: await resolveLogs(surface, install),
+        guidance: surface.guidance,
+    });
+});
+server.registerTool("list_mods", {
+    title: "List installed mods",
+    description: "Enumerate installed mods across a game's mod roots, with size, modification " +
+        "time and parsed manifest data where the game provides one.",
+    inputSchema: {
+        game: gameArg,
+        installPath: installPathArg,
+        rootIds: z
+            .array(z.string())
+            .optional()
+            .describe("Restrict to these mod root ids. Omit for all roots."),
+        includeFiles: z
+            .boolean()
+            .default(false)
+            .describe("Include each mod's full file listing. Verbose; off by default."),
+    },
+}, async ({ game, installPath, rootIds, includeFiles }) => {
+    const surface = getSurface(game);
+    if (!surface)
+        return fail(`Unknown game "${game}". Known: ${surfaceIds().join(", ")}`);
+    const install = await resolveInstall(surface, installPath);
+    if (!install)
+        return fail(`No install detected for ${surface.name}.`);
+    const { mods, roots } = await listMods(surface, install, { rootIds });
+    return json({
+        game: surface.id,
+        install: install.root,
+        roots: roots.map(({ id, label, path, exists, notes }) => ({
+            id,
+            label,
+            path,
+            exists,
+            notes,
+        })),
+        modCount: mods.length,
+        mods: mods.map((mod) => includeFiles ? mod : { ...mod, files: undefined, fileCount: mod.files.length }),
+    });
+});
+server.registerTool("inspect_mod", {
+    title: "Inspect one mod",
+    description: "Full detail for a single mod: every file it owns, its manifest, and any " +
+        "warnings found while reading it.",
+    inputSchema: {
+        game: gameArg,
+        installPath: installPathArg,
+        modId: z.string().describe("Mod id from list_mods, e.g. archive:MyMod.archive"),
+    },
+}, async ({ game, installPath, modId }) => {
+    const surface = getSurface(game);
+    if (!surface)
+        return fail(`Unknown game "${game}". Known: ${surfaceIds().join(", ")}`);
+    const install = await resolveInstall(surface, installPath);
+    if (!install)
+        return fail(`No install detected for ${surface.name}.`);
+    const { mods } = await listMods(surface, install);
+    const mod = mods.find((candidate) => candidate.id === modId);
+    if (!mod)
+        return fail(`Mod "${modId}" not found. Run list_mods for valid ids.`);
+    return json(mod);
+});
+const IDENTITY_UNREADABLE_LIMIT = 25;
+server.registerTool("find_conflicts", {
+    title: "Find file conflicts",
+    description: "Report paths claimed by more than one mod within the same mod root. Only " +
+        "roots where mods merge into a shared tree are analyzed; roots where each mod " +
+        "is isolated, or is a packed archive, are listed in skippedRoots instead. " +
+        "Kind 'overwrite' means the game has a defined last-wins rule; 'ambiguous' " +
+        "means the outcome is not predictable and needs a human decision. " +
+        "sharedIdentities is a separate, surface-level pass (BG3-only for now): the same " +
+        "module UUID installed under more than one path (e.g. a .pak and a mod.io " +
+        "re-download of it). Which copy the game loads is not predictable from outside; " +
+        "load_order's crossCheck reports the Folder the mod manager last bound. It reports a total plus a capped " +
+        "identities list (most-duplicated first, each with its own capped copies list); " +
+        "both carry truncated: true when capped. total is 0 for surfaces without the pass.",
+    inputSchema: {
+        game: gameArg,
+        installPath: installPathArg,
+        rootIds: z.array(z.string()).optional().describe("Restrict to these mod root ids."),
+        limit: z.number().int().positive().default(100).describe("Max conflicts to return."),
+    },
+}, async ({ game, installPath, rootIds, limit }) => {
+    const surface = getSurface(game);
+    if (!surface)
+        return fail(`Unknown game "${game}". Known: ${surfaceIds().join(", ")}`);
+    const install = await resolveInstall(surface, installPath);
+    if (!install)
+        return fail(`No install detected for ${surface.name}.`);
+    const { mods, roots } = await listMods(surface, install, { rootIds });
+    const { conflicts, skippedRoots, suppressedNoiseFiles } = findConflicts(mods, roots);
+    let identities = { total: 0, identities: [] };
+    let identityUnreadable = [];
+    let identityUnreadableCount = 0;
+    if (surface.scanModIdentities) {
+        const scanned = await surface.scanModIdentities(install);
+        identities = sharedIdentities(scanned.copies);
+        identityUnreadableCount = scanned.unreadable.length;
+        identityUnreadable = scanned.unreadable.slice(0, IDENTITY_UNREADABLE_LIMIT);
+    }
+    return json({
+        game: surface.id,
+        modsAnalyzed: mods.length,
+        conflictCount: conflicts.length,
+        skippedRoots,
+        suppressedNoiseFiles,
+        truncated: conflicts.length > limit,
+        conflicts: conflicts.slice(0, limit),
+        sharedIdentities: identities,
+        identityUnreadableCount,
+        identityUnreadable,
+        identityUnreadableTruncated: identityUnreadableCount > IDENTITY_UNREADABLE_LIMIT ? true : undefined,
+        note: "File-level analysis, and only for roots where mods share one deploy tree. " +
+            "See skippedRoots for what was excluded and why.",
+        guidance: surface.guidance,
+    });
+});
+server.registerTool("load_order", {
+    title: "Read load order",
+    description: "Read the game's explicit load order and cross-check it against what is " +
+        "installed, reporting entries with no matching mod and mods absent from the order. " +
+        "For BG3, crossCheck resolves each entry by the UUID read from every installed " +
+        "pak/loose meta.lsx rather than by filename: each entry carries every installed " +
+        "copy sharing its UUID (matches), whether more than one exists (duplicated) or " +
+        "none does (missing), and per match whether its module folder is the one " +
+        "modsettings.lsx's own Folder attribute names (folderMatchesEntry) — the folder the " +
+        "mod manager last bound, a hint rather than proof of what the running game loads " +
+        "(Ext.Mod.GetMod(uuid).Info.Directory at the SE console is the live answer). " +
+        "inertCopies summarises installed paks/modules matching no " +
+        "entry — a total, a capped copies list, and truncated: true when capped, because a " +
+        "real profile holds hundreds of installed paks against a handful of ordered entries.",
+    inputSchema: { game: gameArg, installPath: installPathArg },
+}, async ({ game, installPath }) => {
+    const surface = getSurface(game);
+    if (!surface)
+        return fail(`Unknown game "${game}". Known: ${surfaceIds().join(", ")}`);
+    if (!surface.loadOrder) {
+        return json({
+            game: surface.id,
+            supported: false,
+            note: `${surface.name} has no explicit load order file; ` +
+                "order is derived from the filesystem.",
+        });
+    }
+    const install = await resolveInstall(surface, installPath);
+    if (!install)
+        return fail(`No install detected for ${surface.name}.`);
+    const order = await surface.loadOrder(install);
+    const { mods } = await listMods(surface, install);
+    let crossCheck;
+    if (surface.scanModIdentities) {
+        const scanned = await surface.scanModIdentities(install);
+        crossCheck = {
+            ...crossCheckIdentities(order, scanned.copies, scanned.unreadable.slice(0, IDENTITY_UNREADABLE_LIMIT)),
+            unreadableCount: scanned.unreadable.length,
+            unreadableTruncated: scanned.unreadable.length > IDENTITY_UNREADABLE_LIMIT ? true : undefined,
+        };
+    }
+    else {
+        const resolvable = order.some((entry) => entry.modId);
+        const installedIds = new Set(mods.map((mod) => mod.id));
+        const orderedIds = new Set(order.map((entry) => entry.modId).filter(Boolean));
+        crossCheck = resolvable
+            ? {
+                available: true,
+                inOrderButNotInstalled: order
+                    .filter((entry) => entry.modId && !installedIds.has(entry.modId))
+                    .map((entry) => entry.name),
+                installedButNotInOrder: mods
+                    .filter((mod) => !orderedIds.has(mod.id))
+                    .map((mod) => mod.id),
+            }
+            : {
+                available: false,
+                reason: `${surface.name} identifies mods in its load order by something the ` +
+                    "filesystem does not expose, so entries cannot be matched to installed " +
+                    "files by name alone.",
+            };
+    }
+    return json({
+        game: surface.id,
+        supported: true,
+        entryCount: order.length,
+        installedModCount: mods.length,
+        order,
+        crossCheck,
+        guidance: surface.guidance,
+    });
+});
+server.registerTool("read_log", {
+    title: "Read a mod log",
+    description: "Tail one of the game's mod-related logs. Call detect_install first to see " +
+        "which log ids exist for this install.",
+    inputSchema: {
+        game: gameArg,
+        installPath: installPathArg,
+        logId: z.string().describe("Log id from detect_install."),
+        lines: z.number().int().positive().max(2000).default(200),
+    },
+}, async ({ game, installPath, logId, lines }) => {
+    const surface = getSurface(game);
+    if (!surface)
+        return fail(`Unknown game "${game}". Known: ${surfaceIds().join(", ")}`);
+    const install = await resolveInstall(surface, installPath);
+    if (!install)
+        return fail(`No install detected for ${surface.name}.`);
+    const sources = await resolveLogs(surface, install);
+    const source = sources.find((candidate) => candidate.id === logId);
+    if (!source) {
+        const available = sources.map((entry) => entry.id).join(", ") || "none";
+        return fail(`Unknown log "${logId}". Available: ${available}`);
+    }
+    if (!source.exists || !(await pathExists(source.path))) {
+        return json({ logId, path: source.path, exists: false, content: null });
+    }
+    return json({
+        logId,
+        path: source.path,
+        exists: true,
+        lines,
+        content: await tail(source.path, lines),
+    });
+});
+server.registerTool("project_info", {
+    title: "Describe a mod project",
+    description: "Load a modwright.json (from a file path, a directory containing one, or by walking " +
+        "up from a directory) and report its sources, build and deploy configuration, " +
+        "dependencies and publish targets with paths resolved and existence checked, plus " +
+        "structural warnings such as staging the repo root or a deploy target no root knows.",
+    inputSchema: {
+        path: z
+            .string()
+            .optional()
+            .describe("modwright.json path or a directory to search from. Default: current directory."),
+    },
+}, async ({ path: start }) => {
+    const from = start ?? process.cwd();
+    try {
+        const file = (await pathExists(from)) && from.toLowerCase().endsWith(".json")
+            ? from
+            : await findProjectFile(from);
+        if (!file) {
+            return json({
+                found: false,
+                searchedFrom: from,
+                hint: "No modwright.json found here or in any parent directory.",
+            });
+        }
+        const resolved = await loadProject(file);
+        return json({ found: true, ...describeProject(resolved) });
+    }
+    catch (error) {
+        return fail(`Could not load project: ${error.message}`);
+    }
+});
+server.registerTool("check_toolchain", {
+    title: "Locate external tools",
+    description: "Find the external tools ModWright drives (LSLib divine, WolvenKit CLI, Cpp2IL, Blender, " +
+        "...) in this order: environment override, a project's toolchain override, the per-user " +
+        "config, ModWright's managed tools folder, PATH, common install locations. Reports path, " +
+        "where it was found, version where the tool can print one ('unknown' otherwise, never " +
+        "guessed) and a hint when missing. action 'install' fetches a pinned release of a tool " +
+        "ModWright can install (Cpp2IL, the UnityPy Python) into its own tools folder, dry-run first, and " +
+        "with data=<id> fetches a data folder ModWright can fetch (Stardew Valley's wiki pages) and remembers it; " +
+        "action 'remember' records a tool's path in the " +
+        "per-user config so every session finds it (no environment variable, no restart); " +
+        "'forget' drops it. Both are dry-run unless mode is 'apply'.",
+    inputSchema: {
+        action: z.enum(["check", "remember", "forget", "install"]).default("check").describe("check (default) reports; remember/forget change the per-user config; install fetches a pinned tool into ModWright's tools folder (dry-run shows the file, source, size and sha256 first), or with data a fetchable data folder (dry-run lists every URL first)."),
+        game: gameArg.optional().describe("Restrict to tools used by this game (check only)."),
+        projectPath: z
+            .string()
+            .optional()
+            .describe("modwright.json (or a directory) whose toolchain overrides should apply."),
+        tool: z.string().optional().describe("remember/forget/install: the tool id, e.g. 'cpp2il', 'divine'."),
+        toolPath: z.string().optional().describe("remember: absolute path to the executable, or the folder that directly holds it."),
+        data: z.string().optional().describe("remember/forget/install: a data folder id instead of a tool, e.g. 'valheim.jotunn' (a Jotunn checkout) or 'stardewvalley.wiki' (saved wiki pages); check_toolchain game=<id> lists the ones a game reads."),
+        dataPath: z.string().optional().describe("remember with data: absolute path to that folder. install with data: where to save it (default: ModWright's per-user data folder)."),
+        mode: z.enum(["dry-run", "apply"]).default("dry-run").describe("remember/forget: dry-run shows the config change; apply writes it (backing up the old file)."),
+    },
+}, async ({ action, game, projectPath, tool, toolPath, data, dataPath, mode }) => {
+    if ((action === "remember" || action === "forget") && data) {
+        if (tool)
+            return fail("Give either tool or data, not both.");
+        const known = SURFACES.flatMap((s) => (s.toolNeeds ?? []).flatMap((n) => n.data ?? []));
+        const planned = await planDataMemory(action, data, dataPath, known);
+        if (!planned.ok)
+            return fail(planned.error);
+        const report = await executePlan(planned.plan, {
+            mode,
+            confidence: { level: "high", assumptions: ["The per-user config is ModWright's own file; nothing in a game or a project is touched."] },
+        });
+        const envVar = known.find((k) => k.id === planned.data)?.envVar;
+        return json({
+            action,
+            data: planned.data,
+            mode,
+            applied: report.applied,
+            file: planned.file,
+            ...(planned.entry ? { entry: planned.entry } : {}),
+            ...(planned.previous ? { previous: planned.previous } : {}),
+            operations: report.operations,
+            ...(report.backupDir ? { backupDir: report.backupDir } : {}),
+            note: report.applied
+                ? `Saved. Every session now reads ${planned.data} from the per-user config${envVar ? `, unless ${envVar} is set` : ""}.`
+                : "Dry run: nothing written. Repeat with mode 'apply' to save it.",
+        });
+    }
+    if (dataPath && !data)
+        return fail("dataPath goes with data (a data folder id).");
+    if (action === "install" && data) {
+        if (tool)
+            return fail("Give either tool or data, not both.");
+        const known = SURFACES.flatMap((s) => (s.toolNeeds ?? []).flatMap((n) => n.data ?? []));
+        const planned = planDataFetch(data, known, dataPath);
+        if (!planned.ok)
+            return fail(planned.error);
+        const plan = planned.plan;
+        if (mode !== "apply") {
+            return json({
+                action,
+                data: plan.data,
+                mode,
+                applied: false,
+                plan: { ...plan, files: plan.files.length, urls: plan.files.map((f) => f.url) },
+                note: `Dry run: nothing was requested or written. Repeat with mode 'apply' to fetch these ${plan.files.length} pages (about ${plan.estimatedSeconds} s, one request every ${plan.delayMs / 1000} s after robots.txt), save them under ${plan.destination}, and remember that folder.`,
+            });
+        }
+        const result = await applyDataFetch(plan, { known });
+        if (!result.ok)
+            return fail(result.error);
+        return json({
+            action,
+            data: plan.data,
+            mode,
+            applied: result.saved.length > 0,
+            destination: result.destination,
+            saved: result.saved.length,
+            ...(result.failed.length > 0 ? { failed: result.failed } : {}),
+            ...(result.refused.length > 0 ? { refused: result.refused } : {}),
+            remembered: result.remembered,
+            note: result.saved.length === 0
+                ? "Nothing was saved; see failed and refused."
+                : `Saved ${result.saved.length} of ${plan.files.length} pages${result.remembered ? " and remembered the folder" : ""}. Next: build_index for the game that reads ${plan.data}.`,
+        });
+    }
+    if (action === "install") {
+        if (!tool)
+            return fail("install needs tool (a tool id; check_toolchain game=<id> marks which are installable).");
+        const planned = await planManagedInstall(tool);
+        if (!planned.ok)
+            return fail(planned.error);
+        if (mode !== "apply") {
+            return json({ action, tool: planned.plan.tool, mode, applied: false, plan: planned.plan, note: "Dry run: nothing was downloaded, run or written. Repeat with mode 'apply' to install exactly this." });
+        }
+        const result = await applyManagedInstall(planned.plan);
+        if (!result.ok)
+            return fail(result.error);
+        const after = await checkToolchain({ probe: "trusted" }).then((all) => all.find((t) => t.id === planned.plan.tool));
+        return json({ action, tool: planned.plan.tool, mode, applied: true, executable: result.executable, verified: result.verified, ...(after ? { nowFound: after } : {}) });
+    }
+    if (action === "remember" || action === "forget") {
+        if (!tool)
+            return fail(`${action} needs tool (a tool id from check_toolchain's list).`);
+        const planned = await planToolMemory(action, tool, toolPath);
+        if (!planned.ok)
+            return fail(planned.error);
+        const report = await executePlan(planned.plan, {
+            mode,
+            confidence: { level: "high", assumptions: ["The per-user config is ModWright's own file; nothing in a game or a project is touched."] },
+        });
+        const after = report.applied ? await checkToolchain({ probe: "trusted" }).then((all) => all.find((t) => t.id === planned.tool)) : undefined;
+        return json({
+            action,
+            tool: planned.tool,
+            mode,
+            applied: report.applied,
+            file: planned.file,
+            ...(planned.entry ? { entry: planned.entry } : {}),
+            ...(planned.previous ? { previous: planned.previous } : {}),
+            operations: report.operations,
+            ...(report.backupDir ? { backupDir: report.backupDir } : {}),
+            ...(after ? { nowFound: after } : {}),
+            note: report.applied
+                ? `Saved. Every session now finds ${planned.tool} through the per-user config, unless ${TOOL_SPECS.find((s) => s.id === planned.tool)?.envVar} or a project override says otherwise.`
+                : "Dry run: nothing written. Repeat with mode 'apply' to save it.",
+        });
+    }
+    if (tool || toolPath)
+        return fail("tool and toolPath belong to action 'remember' or 'forget'; action 'check' takes game and projectPath.");
+    let surfaceId;
+    if (game) {
+        const surface = getSurface(game);
+        if (!surface)
+            return fail(`Unknown game "${game}". Known: ${surfaceIds().join(", ")}`);
+        surfaceId = surface.id;
+    }
+    let projectOverrides;
+    let project;
+    if (projectPath) {
+        try {
+            project = (await loadProject(projectPath)).project;
+            projectOverrides = project.toolchain;
+        }
+        catch (error) {
+            return fail(`Could not load project: ${error.message}`);
+        }
+    }
+    const userConfig = await loadUserConfig();
+    const tools = await checkToolchain({ surfaceId, projectOverrides, userTools: userConfig.config.tools });
+    let features;
+    if (surfaceId) {
+        const surface = getSurface(surfaceId);
+        const located = new Map(tools.map((t) => [t.id, t]));
+        for (const id of toolsToLocate(surface, project ? { project } : {})) {
+            const spec = TOOL_SPECS.find((s) => s.id === id);
+            if (spec && !located.has(id))
+                located.set(id, await locateTool(spec, { projectOverrides, probe: "trusted", userTools: userConfig.config.tools }));
+        }
+        const indexBuilt = surface.index ? await fileExists(resolveIndexFile(surface.id).file) : undefined;
+        features = featureReadiness(surface, [...located.values()], { ...(project ? { project } : {}), ...(indexBuilt !== undefined ? { indexBuilt } : {}), userData: userConfig.config.data });
+    }
+    return json({
+        game: surfaceId,
+        ...(features ? { summary: readinessSummary(features), features } : {}),
+        found: tools.filter((t) => t.found).length,
+        missing: tools.filter((t) => !t.found).map((t) => t.id),
+        userConfig: { file: userConfig.file, exists: userConfig.exists, remembered: Object.keys(userConfig.config.tools), rememberedData: Object.keys(userConfig.config.data), ...(userConfig.problems.length > 0 ? { problems: userConfig.problems } : {}) },
+        tools,
+    });
+});
+server.registerTool("check_compat", {
+    title: "Check the version matrix",
+    description: "Detect the installed game build, loaders, frameworks and tools for a game and " +
+        "check the combination against known compatibility floors (each rule cites its " +
+        "source). Reports 'block' for a combination known not to work, 'warn' when a " +
+        "version could not be read, and lists what is undetermined rather than guessing.",
+    inputSchema: { game: gameArg, installPath: installPathArg },
+}, async ({ game, installPath }) => {
+    const surface = getSurface(game);
+    if (!surface)
+        return fail(`Unknown game "${game}". Known: ${surfaceIds().join(", ")}`);
+    const install = await resolveInstall(surface, installPath);
+    if (!install)
+        return fail(`No install detected for ${surface.name}.`);
+    return json(await runCompat(surface, install));
+});
+server.registerTool("triage_logs", {
+    title: "Triage the game's logs",
+    description: "Read every mod-related log for a game, scoped to the current run, classify lines " +
+        "against known failure signatures, and return one verdict: which mod systems loaded, " +
+        "which failed and why, with the first error's explanation and usual fix. Pass the " +
+        "returned offsets and offsetKeys back as offsets/offsetKeys for incremental triage after " +
+        "the next launch (the keys let a re-created log of identical size be read again). " +
+        "Stale and zero-byte logs are reported as such rather than trusted.",
+    inputSchema: {
+        game: gameArg,
+        installPath: installPathArg,
+        since: z
+            .string()
+            .optional()
+            .describe("ISO timestamp; ignore log lines older than this where the log has timestamps."),
+        offsets: z
+            .record(z.number())
+            .optional()
+            .describe("Per log id byte offsets from a previous triage_logs result."),
+        offsetKeys: z
+            .record(z.string())
+            .optional()
+            .describe("Per log id file identities (offsetKeys) from the same previous result."),
+        maxLines: z.number().int().positive().max(20000).optional(),
+        includeFindings: z.boolean().default(true),
+    },
+}, async ({ game, installPath, since, offsets, offsetKeys, maxLines, includeFindings }) => {
+    const surface = getSurface(game);
+    if (!surface)
+        return fail(`Unknown game "${game}". Known: ${surfaceIds().join(", ")}`);
+    const install = await resolveInstall(surface, installPath);
+    if (!install)
+        return fail(`No install detected for ${surface.name}.`);
+    const verdict = await triageLogs(surface, install, registry, { since, offsets, offsetKeys, maxLines });
+    return json({
+        ...verdict,
+        signatureCount: registry.forGame(surface.id).length,
+        findings: includeFindings ? verdict.findings : undefined,
+        sources: verdict.sources.map(({ source, ...rest }) => ({
+            id: source.id,
+            label: source.label,
+            path: source.path,
+            exists: source.exists,
+            resolvedFrom: source.resolvedFrom,
+            ...rest,
+        })),
+    });
+});
+server.registerTool("load_order_diff", {
+    title: "Snapshot or diff the load order file",
+    description: "For games that rewrite their load order on launch (BG3's modsettings.lsx), compare a " +
+        "saved snapshot with the current file and report entries the game dropped, added or " +
+        "reordered. With no beforePath, saves a snapshot of the current file and returns its " +
+        "path for use after the next launch: under the project's .modwright/snapshots when " +
+        "`path` names a project, else under ModWright's per-user data directory.",
+    inputSchema: {
+        game: gameArg,
+        installPath: installPathArg,
+        beforePath: z.string().optional().describe("A snapshot saved earlier by this tool."),
+        afterPath: z
+            .string()
+            .optional()
+            .describe("File to compare against. Default: the game's live load order file."),
+        path: z.string().optional().describe("A mod project root or modwright.json; when given, the snapshot is kept in that project's .modwright/snapshots."),
+    },
+}, async ({ game, installPath, beforePath, afterPath, path: projectPath }) => {
+    const surface = getSurface(game);
+    if (!surface)
+        return fail(`Unknown game "${game}". Known: ${surfaceIds().join(", ")}`);
+    if (!surface.loadOrderFile || !surface.diffLoadOrder) {
+        return json({ game: surface.id, supported: false, note: `${surface.name} has no explicit load order file to diff.` });
+    }
+    const install = await resolveInstall(surface, installPath);
+    if (!install)
+        return fail(`No install detected for ${surface.name}.`);
+    const live = surface.loadOrderFile(install);
+    if (!beforePath) {
+        const content = await readTextIfExists(live);
+        if (content === undefined)
+            return fail(`Load order file not found at ${live}.`);
+        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+        let snapshotDir = path.join(userDataDir(), "snapshots");
+        if (projectPath) {
+            const projectFile = (await pathExists(projectPath)) && projectPath.toLowerCase().endsWith(".json") ? projectPath : await findProjectFile(projectPath);
+            if (!projectFile)
+                return fail(`No modwright.json found at or above ${projectPath}.`);
+            snapshotDir = path.join(path.dirname(path.resolve(projectFile)), ".modwright", "snapshots");
+        }
+        const snapshot = path.join(snapshotDir, `${surface.id}-${stamp}${path.extname(live)}`);
+        const report = await executePlan({
+            purpose: `snapshot ${surface.name} load order`,
+            operations: [{ kind: "mkdir", path: path.dirname(snapshot) }, { kind: "create", path: snapshot, content }],
+        }, { mode: "apply", confidence: { level: "high", assumptions: ["Snapshot is written under the project's .modwright or ModWright's per-user data directory, never the game."] } });
+        return json({ game: surface.id, snapshot, live, applied: report.applied, next: "Launch the game, then call load_order_diff with beforePath set to the snapshot." });
+    }
+    const before = await readTextIfExists(beforePath);
+    if (before === undefined)
+        return fail(`Snapshot not found at ${beforePath}.`);
+    const afterFile = afterPath ?? live;
+    const after = await readTextIfExists(afterFile);
+    if (after === undefined)
+        return fail(`Load order file not found at ${afterFile}.`);
+    return json({ game: surface.id, before: beforePath, after: afterFile, ...surface.diffLoadOrder(before, after) });
+});
+const validators = createValidatorRegistry();
+for (const surface of SURFACES) {
+    if (surface.validators?.length)
+        validators.register(surface.id, surface.validators);
+}
+let knowledge;
+function getKnowledge() {
+    knowledge ??= loadKnowledge().then(({ facts, problems }) => ({ facts, problems }));
+    return knowledge;
+}
+const stores = new Map();
+const STORE_RETIRE_GRACE_MS = 60_000;
+function retireStore(gameId) {
+    const old = stores.get(gameId);
+    stores.delete(gameId);
+    void old
+        ?.then((store) => {
+        if (store)
+            setTimeout(() => store.close(), STORE_RETIRE_GRACE_MS).unref();
+    })
+        .catch(() => { });
+}
+const legacyStores = new Map();
+function getStore(gameId, reopen = false) {
+    if (reopen)
+        retireStore(gameId);
+    let pending = stores.get(gameId);
+    if (!pending) {
+        const { file, legacy } = resolveIndexFile(gameId);
+        if (legacy)
+            legacyStores.set(gameId, legacy);
+        else
+            legacyStores.delete(gameId);
+        pending = fileExists(file).then((exists) => (exists ? IndexStore.open(file) : undefined));
+        stores.set(gameId, pending);
+    }
+    return pending;
+}
+const FACT_STATUSES = ["verified", "unverified", "contradicted", "community", "inferred"];
+server.registerTool("lookup", {
+    title: "Look up facts and vanilla data",
+    description: "Ground truth before authoring. kind 'facts' searches ModWright's knowledge base of " +
+        "game and toolchain behaviour, each fact tagged verified / unverified / contradicted / " +
+        "community / inferred with its source. Other kinds query the game's locally built " +
+        "vanilla index (records, GUIDs, handles, inheritance chains, the precedent census, archive resource paths); " +
+        "call kind 'kinds' to list what this game supports, and build_index first if the index " +
+        "is missing. Results are capped; refine the query rather than raising the limit. For " +
+        "facts' 'version' param: pass the game's marketing version, not a framework's or the " +
+        "PE file version — for Cyberpunk 2077 that's check_compat's game.marketingVersion " +
+        "('2.31'), not its 'version' (the PE FileVersion, e.g. '3.0.80.51928'); passing the " +
+        "wrong axis never reports false staleness, but does surface as staleUnknownAxis instead " +
+        "of a real answer.",
+    inputSchema: {
+        game: gameArg,
+        kind: z.string().describe("'facts', 'rule', 'kinds', 'info', or an index query kind from 'kinds'."),
+        query: z
+            .record(z.union([z.string(), z.number()]))
+            .default({})
+            .describe("For facts: text, topic, tags (comma separated), status (comma separated), version " +
+            "(installed game version, for staleness), limit, full (1 to include full detail). " +
+            "For rule (the validator catalogue): id (exact, or a prefix ending in '.'), text, group, modType, cheap (1 for the on-every-edit set), limit. " +
+            "For index kinds: the params listed by 'kinds'."),
+        installPath: installPathArg,
+    },
+}, async ({ game, kind, query, installPath }) => {
+    const surface = getSurface(game);
+    if (!surface)
+        return fail(`Unknown game "${game}". Known: ${surfaceIds().join(", ")}`);
+    const str = (key) => (query[key] === undefined ? undefined : String(query[key]));
+    const num = (key) => (query[key] === undefined ? undefined : Number(query[key]));
+    if (kind === "kinds") {
+        return json({
+            game: surface.id,
+            kinds: [
+                { kind: "facts", description: "Search the knowledge base.", params: ["text", "topic", "tags", "status", "version", "limit", "full"] },
+                { kind: "rule", description: "The validator catalogue: every rule id with its trigger, needs, severity and evidence.", params: ["id", "text", "group", "modType", "cheap", "limit"] },
+                { kind: "info", description: "Describe the vanilla index on disk.", params: [] },
+                ...(surface.index?.queryKinds() ?? []),
+            ],
+            indexAvailable: Boolean(surface.index),
+        });
+    }
+    if (kind === "rule") {
+        const id = str("id");
+        const text = str("text")?.toLowerCase();
+        const group = str("group");
+        const modType = str("modType");
+        const cheap = str("cheap") === "1";
+        const limit = num("limit") ?? 50;
+        const all = validators.forGame(surface.id);
+        const hits = all.filter((v) => (!id || v.id === id || (id.endsWith(".") && v.id.startsWith(id))) &&
+            (!text || v.id.toLowerCase().includes(text) || v.summary.toLowerCase().includes(text)) &&
+            (!group || v.groups.includes(group)) &&
+            (!modType || v.modTypes.includes(modType)) &&
+            (!cheap || v.cost === "edit"));
+        return json({
+            game: surface.id,
+            totalRules: all.length,
+            count: hits.length,
+            truncated: hits.length > limit ? true : undefined,
+            rules: hits.slice(0, limit).map((v) => ({
+                id: v.id,
+                groups: v.groups,
+                modTypes: v.modTypes,
+                summary: v.summary,
+                appliesTo: v.appliesToDescription,
+                needs: v.needs,
+                cost: v.cost,
+                severity: v.severity,
+                evidence: v.evidence,
+            })),
+        });
+    }
+    if (kind === "facts") {
+        const { facts, problems } = await getKnowledge();
+        const statuses = str("status")?.split(",").map((value) => value.trim());
+        const bad = statuses?.filter((value) => !FACT_STATUSES.includes(value));
+        if (bad?.length)
+            return fail(`Unknown status ${bad.join(", ")}. Known: ${FACT_STATUSES.join(", ")}`);
+        const version = str("version");
+        const hits = searchFacts(facts, {
+            game: surface.id,
+            text: str("text"),
+            topic: str("topic"),
+            tags: str("tags")?.split(",").map((value) => value.trim().toLowerCase()),
+            status: statuses,
+            installedVersion: version,
+            limit: num("limit") ?? 20,
+        });
+        const full = str("full") === "1";
+        const staleUnknownAxis = version === undefined ? undefined : hits.filter((hit) => hit.staleUnknownAxis).length;
+        return json({
+            game: surface.id,
+            totalFacts: facts.filter((fact) => fact.game === surface.id).length,
+            count: hits.length,
+            staleUnknownAxis,
+            knowledgeProblems: problems.length ? problems : undefined,
+            facts: hits.map((hit) => ({
+                id: hit.id,
+                status: hit.status,
+                stale: hit.stale,
+                staleUnknownAxis: hit.staleUnknownAxis,
+                claim: hit.claim,
+                detail: full || !hit.detail || hit.detail.length <= 400 ? hit.detail : `${hit.detail.slice(0, 400)}…`,
+                source: hit.source,
+                verified_on: hit.verified_on,
+                verified_by: hit.verified_by,
+                supersedes: hit.supersedes,
+                tags: hit.tags,
+                topic: hit.topic,
+                score: hit.score,
+            })),
+        });
+    }
+    if (!surface.index) {
+        return json({ game: surface.id, kind, available: false, note: `${surface.name} has no vanilla index implementation yet.` });
+    }
+    if (kind === "info") {
+        const install = await resolveInstall(surface, installPath);
+        if (!install)
+            return fail(`No install detected for ${surface.name}.`);
+        const indexInfo = await surface.index.info(install);
+        const legacy = indexInfo.exists ? undefined : findLegacyIndex(surface.id);
+        return json(legacy ? { ...indexInfo, legacyIndex: legacy.file, cacheNote: legacyIndexHint(surface.id, legacy) } : indexInfo);
+    }
+    const store = await getStore(surface.id);
+    if (!store) {
+        return json({
+            game: surface.id,
+            kind,
+            available: false,
+            file: indexFile(defaultCacheDir(), surface.id),
+            hint: "No index built yet. Run build_index for this game first.",
+        });
+    }
+    try {
+        const result = await surface.index.query(store, kind, query);
+        const legacy = legacyStores.get(surface.id);
+        return json(legacy ? { ...result, legacyIndex: legacy.file, cacheNote: legacyIndexHint(surface.id, legacy) } : result);
+    }
+    catch (error) {
+        return fail(`lookup ${kind} failed: ${error.message}`);
+    }
+});
+server.registerTool("build_index", {
+    title: "Build the vanilla data index",
+    description: "Extract and index the game's own data (BG3: stats, lists, progressions, templates, " +
+        "localization from the vanilla paks via LSLib; Cyberpunk: TweakDB records from the " +
+        "REDmod tweak sources) into a local SQLite file under the ModWright cache. Takes " +
+        "minutes on first run and drives external tools; nothing in the game directory is " +
+        "modified. Never redistribute the resulting index.",
+    inputSchema: {
+        game: gameArg,
+        installPath: installPathArg,
+        force: z.boolean().default(false).describe("Rebuild even if an index exists."),
+        only: z.array(z.string()).optional().describe("Restrict to these sources (surface-specific names)."),
+        path: z
+            .string()
+            .optional()
+            .describe("A mod project root or modwright.json. When given, the project's toolchain overrides " +
+            "(e.g. the divine path) are used to locate tools, as check_toolchain, build and deploy do."),
+    },
+}, async ({ game, installPath, force, only, path: projectPath }) => {
+    const surface = getSurface(game);
+    if (!surface)
+        return fail(`Unknown game "${game}". Known: ${surfaceIds().join(", ")}`);
+    if (!surface.index)
+        return json({ game: surface.id, supported: false, note: `${surface.name} has no index implementation yet.` });
+    const install = await resolveInstall(surface, installPath);
+    if (!install)
+        return fail(`No install detected for ${surface.name}.`);
+    let toolOverrides;
+    if (projectPath) {
+        try {
+            const file = (await pathExists(projectPath)) && projectPath.toLowerCase().endsWith(".json") ? projectPath : await findProjectFile(projectPath);
+            if (!file)
+                return fail(`No modwright.json found at or above ${projectPath}.`);
+            toolOverrides = (await loadProject(file)).project.toolchain;
+        }
+        catch (error) {
+            return fail(`Could not load project for tool overrides: ${error.message}`);
+        }
+    }
+    const file = indexFile(defaultCacheDir(), surface.id);
+    const legacy = force ? undefined : findLegacyIndex(surface.id);
+    if (legacy) {
+        return json({ game: surface.id, rebuilt: false, file: legacy.file, legacyIndex: legacy.file, note: `${legacyIndexHint(surface.id, legacy)} lookup already uses it. Pass force to build a fresh index in the new location instead.` });
+    }
+    if (!force && (await fileExists(file))) {
+        const existing = await surface.index.info(install);
+        if (!existing.stale)
+            return json({ ...existing, note: "Index already exists; pass force to rebuild." });
+    }
+    const progress = [];
+    const store = await IndexStore.open(force ? undefined : file);
+    try {
+        const info = await surface.index.build(install, store, {
+            force,
+            only,
+            toolOverrides,
+            progress: (event) => {
+                progress.push(`${event.step}${event.done !== undefined ? ` ${event.done}${event.total ? `/${event.total}` : ""}` : ""}${event.note ? `: ${event.note}` : ""}`);
+            },
+        });
+        await store.save(file);
+        retireStore(surface.id);
+        const freshInfo = await surface.index.info(install);
+        return json({ ...info, ...freshInfo, buildNotes: info.sources ?? [], rebuilt: true, file, progressTail: progress.slice(-20) });
+    }
+    catch (error) {
+        return fail(`build_index failed: ${error.message}
+Progress: ${progress.slice(-10).join(" | ")}`);
+    }
+    finally {
+        store.close();
+    }
+});
+server.registerTool("validate", {
+    title: "Validate a mod project before building",
+    description: "Run the static validators for a mod project (from its modwright.json): schema and " +
+        "syntax checks, reference integrity against the vanilla index, known crash causes and " +
+        "silent failures, packaging hygiene. Each finding names the file, what is wrong, the " +
+        "fix, and the knowledge facts behind the rule. Rules whose needs are unmet (no index " +
+        "built, tool not located, no install) are reported as skipped with the reason, never " +
+        "guessed. Findings can be suppressed with a reason in .modwright/suppressions.json.",
+    inputSchema: {
+        path: z.string().optional().describe("modwright.json path or a directory to search from. Default: current directory."),
+        groups: z.array(z.string()).optional().describe("Restrict to these rule groups (see the rules document)."),
+        cheapOnly: z.boolean().default(false).describe("Only the on-every-edit rules."),
+        rule: z
+            .string()
+            .optional()
+            .describe("Run only this rule id (comma-separated for several), e.g. after a fix. lookup kind 'rule' lists the ids; an unknown id is refused, not ignored."),
+        changedFiles: z.array(z.string()).optional().describe("Absolute paths; when given, file rules run only on these."),
+        installPath: installPathArg,
+        includeInfo: z.boolean().default(false).describe("Include info-severity findings in the output."),
+    },
+}, async ({ path: start, groups, cheapOnly, rule, changedFiles, installPath, includeInfo }) => {
+    const resolved = await projectOrFail(start);
+    if ("isError" in resolved)
+        return resolved;
+    const surface = getSurface(resolved.project.game);
+    if (!surface)
+        return fail(`Unknown game "${resolved.project.game}".`);
+    const ids = rule
+        ?.split(",")
+        .map((id) => id.trim())
+        .filter(Boolean);
+    if (ids?.length) {
+        const unknown = ids.filter((id) => !validators.get(id));
+        if (unknown.length)
+            return fail(`Unknown rule id(s): ${unknown.join(", ")}. Call lookup with kind "rule" and game "${surface.id}" to list them.`);
+        const foreign = ids.filter((id) => validators.get(id).game !== surface.id);
+        if (foreign.length)
+            return fail(`Rule(s) ${foreign.join(", ")} belong to another game, not ${surface.id}.`);
+    }
+    const install = await resolveInstall(surface, installPath).catch(() => undefined);
+    const store = await getStore(surface.id);
+    const ctx = buildContext({ project: resolved, surface, install, store, changedFiles });
+    const report = await runValidators(validators, ctx, {
+        groups: groups,
+        cheapOnly,
+        ids: ids?.length ? ids : undefined,
+        changedOnly: Boolean(changedFiles?.length),
+    });
+    const findings = includeInfo ? report.findings : report.findings.filter((finding) => finding.severity !== "info");
+    const blockingFiles = report.findings.filter((f) => f.severity === "block" && !f.suppressedBy).map((f) => f.file);
+    const ledger = await applyValidateLedgerHook(resolved.root, blockingFiles, changedFiles, "validate");
+    return json({
+        ...report,
+        findings: findings.slice(0, 200),
+        truncated: findings.length > 200 ? true : undefined,
+        infoHidden: includeInfo ? undefined : report.findings.length - findings.length,
+        indexAvailable: Boolean(store),
+        installFound: Boolean(install),
+        ledger,
+    });
+});
+server.registerTool("build", {
+    title: "Build a mod project",
+    description: "Run a mod project's build.steps (modwright.json): stage sources into a clean tree under " +
+        ".modwright/cache/build/, run the typed pack/convert/verify steps for the project's surface " +
+        "(WolvenKit CLI, Blender, LSLib divine, an in-house zip writer), and write a manifest of every " +
+        "step's inputs/outputs with content hashes. Dry-run by default: resolves and describes every " +
+        "step without running a tool or writing a byte. Before the first pack step, the cheap " +
+        "(on-every-edit) validators run against the staged tree and refuse the build on any block, " +
+        "unless noValidate. The stage tree is deleted on success and always kept on any failure, for " +
+        "inspection.",
+    inputSchema: {
+        path: z.string().optional().describe("modwright.json path or a directory to search from. Default: current directory."),
+        mode: z.enum(["dry-run", "apply"]).default("dry-run").describe("dry-run resolves and describes every step without touching disk or running a tool."),
+        variant: z.string().optional().describe("Name of a build.variants entry to layer onto the base build (addSources/addSteps/dropExclude). It also selects the steps, stage source entries and deploy targets that carry the same `variant` gate; without it, those gated steps are left out."),
+        only: z.array(z.string()).optional().describe("Run only the steps whose id is in this list (a full restriction, not an addition) — e.g. a mesh-export chain's id, to reproduce an --Export-only run."),
+        version: z.string().optional().describe("Overrides ${version} substitution. Default: the project file's own version, else \"0.0.0\"."),
+        keepStage: z.boolean().default(false).describe("Keep the stage tree even when the build succeeds."),
+        noValidate: z.boolean().default(false).describe("Skip the cheap-validate gate before the first pack step; the manifest records validated:false."),
+        installPath: installPathArg,
+    },
+}, async ({ path: start, mode, variant, only, version, keepStage, noValidate, installPath }) => {
+    const resolved = await projectOrFail(start);
+    if ("isError" in resolved)
+        return resolved;
+    const surface = getSurface(resolved.project.game);
+    if (!surface)
+        return fail(`Unknown game "${resolved.project.game}".`);
+    const install = await resolveInstall(surface, installPath).catch(() => undefined);
+    const store = await getStore(surface.id);
+    let result;
+    try {
+        result = await runBuild(resolved, surface, {
+            mode,
+            variant,
+            only,
+            version,
+            keepStage,
+            noValidate,
+            validatorRegistry: validators,
+            install,
+            store,
+        });
+    }
+    catch (error) {
+        return fail(`build failed: ${error.message}`);
+    }
+    const summary = result.failed
+        ? `FAILED: ${result.failureReason}`
+        : mode === "dry-run"
+            ? `dry-run: ${result.plan?.length ?? 0} step(s) would run${result.skippedOptional.length ? `; skipped optional [${result.skippedOptional.join(", ")}]` : ""}${result.skippedVariant?.length ? `; left out by their variant gate [${result.skippedVariant.join(", ")}]` : ""}.`
+            : `built ${result.manifest?.steps.length ?? 0} step(s), validated=${result.manifest?.validated}, manifest at ${result.manifestPath}.`;
+    const ledger = mode === "apply" && !result.failed && result.manifestPath
+        ? await applyBuildLedgerHook(resolved.root, result.manifestPath, "build")
+        : { skipped: true, applied: [], refused: [] };
+    return json({ ...result, summary, ledger });
+});
+const RELOAD_PATH_LIMIT = 200;
+function trimReload(reload) {
+    const total = reload.classifications.length;
+    return {
+        ...reload,
+        classifications: reload.classifications.slice(0, RELOAD_PATH_LIMIT),
+        groups: reload.groups.map((g) => ({ ...g, paths: g.paths.slice(0, RELOAD_PATH_LIMIT), pathCount: g.paths.length })),
+        classifiedPathCount: total,
+        truncated: total > RELOAD_PATH_LIMIT ? true : undefined,
+    };
+}
+server.registerTool("deploy", {
+    title: "Deploy a built mod into the game",
+    description: "Copy a mod project's built artifacts into the game's own mod roots as one write plan: " +
+        "resolve every deploy target through the surface's roots, refuse an artifact this build did not " +
+        "produce, refuse a packed artifact older than its own sources, refuse (or, with unlink, remove) a " +
+        "junction that would coexist with a pak, wait a bounded time for the game to release locked files, " +
+        "prune leftovers a previous build left behind, and copy locked artifacts last. A file matching the " +
+        "project's build.exclude or the target's own exclude never reaches the install. If the game still holds a " +
+        "locked file when the wait expires, the unlocked targets are deployed anyway and the locked ones come back " +
+        "as deferred, naming the process and what to re-run. Dry-run by default: nothing is touched and nothing is " +
+        "waited on. Every overwrite and delete is backed up first (restore one with rollback), and the result " +
+        "carries a reload recommendation for the paths actually written. With reload: apply (Cyberpunk only) it " +
+        "then fires Red Hot Tools' file triggers under a session grant, each with a read-back.",
+    inputSchema: {
+        path: z.string().optional().describe("modwright.json path or a directory to search from. Default: current directory."),
+        mode: z.enum(["dry-run", "apply"]).default("dry-run").describe("dry-run resolves, checks and plans without writing a byte or waiting on a process."),
+        variant: z.string().optional().describe("Build variant this deploy belongs to; targets naming a different variant are skipped (and their prune rules still remove the old copy)."),
+        deployMode: z.enum(["pak", "loose"]).default("pak").describe("pak: deploy the packed artifact, refusing while a junction exists. loose: junction the install at the project's own trees and report the modsettings.lsx entry to add."),
+        unlink: z.boolean().default(false).describe("Allow pak mode to remove existing junctions first. The link is removed, never what it points at."),
+        waitMinutes: z.number().int().min(0).max(30).optional().describe("How long to wait for the game to exit before a locked copy. Default: the project's deploy.waitMinutes, else 0 (fail fast, naming the process)."),
+        outDir: z.string().optional().describe("Override where built artifacts are read from. Default: the project's build.outDir."),
+        redHotTools: z.boolean().default(false).describe("Detect Red Hot Tools presence and classify the RHT-dependent Cyberpunk reload rows accordingly."),
+        reload: z
+            .enum(["classify", "apply"])
+            .default("classify")
+            .describe("classify (default): only recommend what a reload needs. apply (Cyberpunk only): after writing, fire Red Hot Tools' file triggers (.hot-scripts, .hot-tweaks, archive/pc/hot) so a running game picks the change up — gated on a session grant, with a read-back per trigger."),
+        grant: z
+            .array(z.enum(["read", "observe", "session", "persist", "process"]))
+            .optional()
+            .describe("Capability tiers for reload apply; the session tier is required to write the triggers into the running game."),
+        allowMutate: z.boolean().default(false).describe("DEPRECATED alias for grant:[\"session\"], for reload apply."),
+        meshArchives: z.array(z.string()).optional().describe("Deployed archive paths/basenames known to carry a mounted mesh: kept cold (the hot folder is banned for whole-mesh archives)."),
+        installPath: installPathArg,
+    },
+}, async ({ path: start, mode, variant, deployMode, unlink, waitMinutes, outDir, redHotTools, reload, grant, allowMutate, meshArchives, installPath }) => {
+    const resolved = await projectOrFail(start);
+    if ("isError" in resolved)
+        return resolved;
+    const surface = getSurface(resolved.project.game);
+    if (!surface)
+        return fail(`Unknown game "${resolved.project.game}".`);
+    const install = await resolveInstall(surface, installPath).catch(() => undefined);
+    const wantRht = redHotTools || reload === "apply";
+    const compat = wantRht && install ? await runCompat(surface, install).catch(() => undefined) : undefined;
+    const rht = wantRht ? await detectRedHotTools(install, compat).catch(() => undefined) : undefined;
+    try {
+        const result = await runDeploy({
+            project: resolved,
+            surface,
+            install,
+            mode,
+            variant,
+            deployMode,
+            unlink,
+            waitMinutes,
+            outDir: outDir ? path.resolve(outDir) : undefined,
+            compat,
+            redHotTools: rht,
+            reloadApply: reload === "apply"
+                ? { grant, allowMutate, meshArchives, devModule: resolved.project.identity?.devModule }
+                : undefined,
+        });
+        return json({ ...result, summary: { ...result.summary, reload: trimReload(result.summary.reload) } });
+    }
+    catch (error) {
+        return fail(`deploy failed: ${error.message}`);
+    }
+});
+server.registerTool("rollback", {
+    title: "List or restore a deploy backup",
+    description: "Every deploy backs up what it overwrites or deletes under the project's " +
+        ".modwright/backups/<stamp>/ before touching it. With no backupId this lists what is there — stamp, " +
+        "purpose, entry count, how many of those entries are junction pointers rather than content, and total " +
+        "size. With a backupId it restores that backup: dry-run by default, and every file's sha256 is re-checked " +
+        "against the manifest immediately before it is written back. A junction is recreated as a junction, never " +
+        "as a copy of what it pointed at.",
+    inputSchema: {
+        path: z.string().optional().describe("modwright.json path or a directory to search from. Default: current directory."),
+        backupId: z.string().optional().describe("The stamp naming one backup directory under .modwright/backups (from this tool's own listing). Omit to list."),
+        mode: z.enum(["dry-run", "apply"]).default("dry-run").describe("dry-run reports what would be restored without writing a byte."),
+    },
+}, async ({ path: start, backupId, mode }) => {
+    const resolved = await projectOrFail(start);
+    if ("isError" in resolved)
+        return resolved;
+    const backupRoot = path.join(resolved.root, ".modwright", "backups");
+    if (!backupId) {
+        const backups = await listBackups(backupRoot);
+        return json({
+            backupRoot,
+            backups,
+            next: backups.length === 0
+                ? `No backups under ${backupRoot} — nothing has been overwritten or deleted in this project yet.`
+                : `Re-run with { backupId: "${backups[0].id}" } to see what restoring it would do, then { mode: "apply" } to restore.`,
+        });
+    }
+    if (backupId.includes("/") || backupId.includes("\\") || backupId === "." || backupId === "..") {
+        return fail(`backupId must be one directory name under ${backupRoot}, not a path ("${backupId}").`);
+    }
+    const backupDir = path.join(backupRoot, backupId);
+    if (!(await pathExists(backupDir))) {
+        return fail(`No backup "${backupId}" under ${backupRoot}. Call rollback with no backupId to list what is there.`);
+    }
+    try {
+        const report = await restoreBackup(backupDir, { mode });
+        return json({ ...report, backupId, backupDir });
+    }
+    catch (error) {
+        return fail(`rollback failed: ${error.message}`);
+    }
+});
+server.registerTool("reload_plan", {
+    title: "Classify what a set of deployed paths needs to take effect",
+    description: "Map deployed paths to a reload recommendation — hot, hot-degraded, save-reload, restart or unknown — " +
+        "using the project's own reload.rules first and then the per-surface table, and reduce them to the single " +
+        "most conservative answer with its caveats. An unmatched path is reported as unknown ('restart to be sure'), " +
+        "never promoted. ModWright never launches the game and never sends a reload command; this is a " +
+        "recommendation for the user to confirm. `deploy` returns the same block for what it just wrote.",
+    inputSchema: {
+        path: z.string().optional().describe("modwright.json path or a directory to search from. Default: current directory."),
+        paths: z.array(z.string()).min(1).describe("Deployed paths to classify — normally the destination paths from a deploy summary."),
+        redHotTools: z.boolean().default(false).describe("Detect Red Hot Tools presence (DLL + this launch's ArchiveWatcher line) and classify the RHT-dependent Cyberpunk rows accordingly."),
+        installPath: installPathArg,
+    },
+}, async ({ path: start, paths, redHotTools, installPath }) => {
+    const resolved = await projectOrFail(start);
+    if ("isError" in resolved)
+        return resolved;
+    const surface = getSurface(resolved.project.game);
+    if (!surface)
+        return fail(`Unknown game "${resolved.project.game}".`);
+    const install = redHotTools ? await resolveInstall(surface, installPath).catch(() => undefined) : undefined;
+    const compat = install ? await runCompat(surface, install).catch(() => undefined) : undefined;
+    const rht = redHotTools ? await detectRedHotTools(install, compat).catch(() => undefined) : undefined;
+    return json(trimReload(classifyReload(surface.id, resolved.project, paths, { compat, redHotTools: rht })));
+});
+const BRIDGE_GAMES = ["baldursgate3", "cyberpunk2077"];
+function asBridgeGame(id) {
+    return BRIDGE_GAMES.includes(id) ? id : undefined;
+}
+server.registerTool("bridge", {
+    title: "In-game verification bridge",
+    description: "The in-game bridge: a small in-game mod that answers probes under a " +
+        "capability policy for BG3 (Script Extender) and Cyberpunk " +
+        "2077 (CET) only. The old 'ModWright never launches the game and never sends a reload command' rule is retired " +
+        "in favour of that policy: a request carries the tiers it was granted (read | observe | session | persist | " +
+        "process), and a mutating probe runs only under a session grant. The retired allowMutate: true is still " +
+        "accepted for one release as an alias for grant:[\"session\"]. This tool arms a request, polls for its result " +
+        "and reports the bridge's heartbeat. The two games use different transports: BG3 " +
+        "writes and reads files in the Script Extender folder, while Cyberpunk — whose CET console sandbox has no 'io' " +
+        "at all — is armed by pasting one console line and answers in the CET log. 'status': " +
+        "heartbeat freshness and protocolVersion match, from the heartbeat file (BG3) or the newest " +
+        "[MODWRIGHT-HEARTBEAT] line in cyber_engine_tweaks.log / gamelog.log (Cyberpunk). 'stage': copy this repo's " +
+        "bridges/<id>/ into <project>/.modwright/bridge/<id>/ so 'deploy --variant withBridge' can target it, and " +
+        "register that withBridge target in the project's own modwright.json unless a target already deploys to the " +
+        "same place under the same variant — reported as deployTarget 'added' | 'present' | 'no-project', with the " +
+        "modwright.json overwrite backed up like any other; dry-run " +
+        "by default. 'arm': for BG3, write a probe request through the two-file commit; for Cyberpunk, return the exact " +
+        "GetMod(\"ModWrightBridge\").arm('...') console line to paste and record the pending nonce under the project " +
+        "(dry-run by default for both; refuses on a protocolVersion mismatch rather than guessing). 'poll': wait for " +
+        "that request's result up to a budget of max(15s, 3s x probe count) + window, capped at 300s, " +
+        "reporting one of four named timeout outcomes rather than a bare 'timed out' — plus, on the CET log transport, " +
+        "'truncated' when the result line was cut mid-write. Test-plan execution is run_tests; claims are the " +
+        "ledger tool.",
+    inputSchema: {
+        action: z.enum(["status", "arm", "poll", "stage"]),
+        game: z
+            .enum(BRIDGE_GAMES)
+            .optional()
+            .describe("Required for status/arm/poll unless path is given (then defaulted from the project). Only baldursgate3 and cyberpunk2077 have a bridge."),
+        installPath: installPathArg,
+        path: z
+            .string()
+            .optional()
+            .describe("modwright.json path or a directory to search from. Required for 'stage', and for 'arm'/'poll' on cyberpunk2077 " +
+            "(whose pending arms are recorded under <project>/.modwright/bridge/pending/). For BG3 it is optional but symmetric: " +
+            "an 'arm' given it records the pending arm so a later 'poll' with the same path fills id/nonce/probeCount " +
+            "from it. For the other actions, only used to default 'game'."),
+        mode: z.enum(["dry-run", "apply"]).default("dry-run").describe("'stage'/'arm': dry-run describes without writing a byte."),
+        probes: z.array(bridgeProbeSchema).min(1).max(64).optional().describe("Required for 'arm'. Each probe names a kind from ModWright's probe catalogue."),
+        armForSeconds: z.number().int().positive().max(3600).default(60).describe("'arm': how long the request stays armed for, from issuedAt."),
+        grant: z
+            .array(z.enum(["read", "observe", "session", "persist", "process"]))
+            .optional()
+            .describe("'arm': the capability tiers to grant this request. A mutating probe needs \"session\". Overrides the allowMutate alias."),
+        allowMutate: z.boolean().default(false).describe("'arm': DEPRECATED alias for grant:[\"session\"]; allows effect:\"mutate\" probes to run."),
+        windowSeconds: z.number().nonnegative().optional().describe("'arm'/'poll': an observe window in seconds; 0 or absent means a read-only request."),
+        planId: z.string().optional().describe("'arm': ties this request to a test-plan run, once one exists."),
+        planPath: z.string().optional(),
+        runId: z.string().optional(),
+        id: z.string().optional().describe("'poll': the request id from 'arm'. On cyberpunk2077, defaults to the newest pending arm recorded under 'path'."),
+        nonce: z.string().optional().describe("'poll': the nonce from 'arm'. On cyberpunk2077, read from the pending record when 'path' is given."),
+        probeCount: z.number().int().positive().max(64).optional().describe("'poll': probes.length from the 'arm' call, for the timeout budget. On cyberpunk2077, read from the pending record when 'path' is given."),
+        timeoutSeconds: z.number().positive().max(300).optional().describe("'poll': override the computed budget; still capped at 300s."),
+    },
+}, async ({ action, game, installPath, path: start, mode, probes, armForSeconds, grant, allowMutate, windowSeconds, planId, planPath, runId, id, nonce, probeCount, timeoutSeconds }) => {
+    let projectGame;
+    let projectRoot;
+    if (start) {
+        try {
+            const from = start;
+            const file = (await pathExists(from)) && from.toLowerCase().endsWith(".json") ? from : await findProjectFile(from);
+            if (!file)
+                return fail(`No modwright.json found at or above ${from}.`);
+            const loaded = await loadProject(file);
+            projectGame = loaded.project.game;
+            projectRoot = loaded.root;
+        }
+        catch (error) {
+            return fail(`Could not load project: ${error.message}`);
+        }
+    }
+    if (action === "stage") {
+        if (!start)
+            return fail('bridge stage requires "path" (the project to stage the bridge into).');
+        const gameId = game ?? projectGame;
+        if (!gameId)
+            return fail("Could not determine which game's bridge to stage — pass game explicitly.");
+        const bridgeGame = asBridgeGame(gameId);
+        if (!bridgeGame)
+            return fail(`"${gameId}" has no bridge. Known: ${BRIDGE_GAMES.join(", ")}`);
+        const resolved = await loadProject(start);
+        try {
+            const report = await stageBridge(resolved.root, bridgeGame, { mode });
+            return json({ action, game: bridgeGame, project: resolved.project.name, ...report });
+        }
+        catch (error) {
+            return fail(`bridge stage failed: ${error.message}`);
+        }
+    }
+    const gameId = game ?? projectGame;
+    if (!gameId)
+        return fail('bridge status/arm/poll requires "game" (or a "path" to a project that names one).');
+    const bridgeGame = asBridgeGame(gameId);
+    if (!bridgeGame)
+        return fail(`"${gameId}" has no bridge. Known: ${BRIDGE_GAMES.join(", ")}`);
+    const surface = getSurface(bridgeGame);
+    if (!surface)
+        return fail(`Unknown game "${bridgeGame}".`);
+    if (action === "poll") {
+        const install = await resolveInstall(surface, installPath);
+        if (!install)
+            return fail(`No install detected for ${surface.name}.`);
+        if (bridgeGame === "cyberpunk2077") {
+            const pending = projectRoot ? (id ? await readPendingArm(projectRoot, id) : (await listPendingArms(projectRoot, "cyberpunk2077", { activeAt: new Date() }))[0]) : undefined;
+            const pollId = id ?? pending?.id;
+            const pollNonce = nonce ?? pending?.nonce;
+            const pollProbeCount = probeCount ?? pending?.probeCount;
+            if (!pollId || !pollNonce || !pollProbeCount) {
+                return fail('bridge poll for cyberpunk2077 needs either "path" (the project whose .modwright/bridge/pending/ holds the arm) ' +
+                    'or all of "id", "nonce" and "probeCount" from the prior "arm" call.');
+            }
+            const files = await cetLogCandidates(install, surface);
+            const dirs = bridgeCandidateDirs(bridgeGame, install, surface);
+            const outcome = await pollCyberpunk({
+                files,
+                dirs,
+                id: pollId,
+                nonce: pollNonce,
+                probeCount: pollProbeCount,
+                armedAt: pending ? new Date(pending.armedAt) : undefined,
+                windowSeconds: windowSeconds ?? pending?.windowSeconds,
+                timeoutMs: timeoutSeconds ? timeoutSeconds * 1000 : undefined,
+            });
+            return json({
+                action,
+                game: bridgeGame,
+                expectedProtocolVersion: BRIDGE_PROTOCOL_VERSION,
+                candidates: [...dirs, ...files],
+                armedAt: pending?.armedAt,
+                consoleLine: pending?.consoleLine,
+                ...outcome,
+            });
+        }
+        const pending = projectRoot ? (id ? await readPendingArm(projectRoot, id) : (await listPendingArms(projectRoot, "baldursgate3", { activeAt: new Date() }))[0]) : undefined;
+        const pollId = id ?? pending?.id;
+        const pollNonce = nonce ?? pending?.nonce;
+        const pollProbeCount = probeCount ?? pending?.probeCount;
+        if (!pollId || !pollNonce || !pollProbeCount) {
+            return fail('bridge poll needs either "path" (the project whose .modwright/bridge/pending/ holds the arm) or all of "id", "nonce" and "probeCount" from the prior "arm" call.');
+        }
+        const dirs = bridgeCandidateDirs(bridgeGame, install, surface);
+        const outcome = await pollForResult({
+            game: bridgeGame,
+            dirs,
+            id: pollId,
+            nonce: pollNonce,
+            probeCount: pollProbeCount,
+            windowSeconds: windowSeconds ?? pending?.windowSeconds,
+            timeoutMs: timeoutSeconds ? timeoutSeconds * 1000 : undefined,
+        });
+        return json({ action, game: bridgeGame, transport: "file", expectedProtocolVersion: BRIDGE_PROTOCOL_VERSION, armedAt: pending?.armedAt, ...outcome });
+    }
+    const install = await resolveInstall(surface, installPath);
+    if (!install)
+        return fail(`No install detected for ${surface.name}.`);
+    if (action === "status") {
+        return json({ action, ...(await bridgeStatus(bridgeGame, install, surface)) });
+    }
+    if (!probes || probes.length === 0)
+        return fail('bridge arm requires "probes" (1-64 entries).');
+    if (bridgeGame === "cyberpunk2077" && !projectRoot) {
+        return fail('bridge arm for cyberpunk2077 requires "path" (the mod project): its request may have to be armed by pasting a ' +
+            "console line, and the pending nonce is recorded under <project>/.modwright/bridge/pending/ so poll can match " +
+            "the CET log lines.");
+    }
+    const result = await armBridge({
+        game: bridgeGame,
+        install,
+        surface,
+        probes,
+        armForSeconds,
+        grant,
+        allowMutate,
+        window: windowSeconds !== undefined ? { seconds: windowSeconds } : undefined,
+        plan: planId && planPath && runId ? { planId, planPath, runId } : undefined,
+        mode,
+        projectRoot,
+        console: true,
+    });
+    return json({ action, expectedProtocolVersion: BRIDGE_PROTOCOL_VERSION, ...result });
+});
+server.registerTool("run_tests", {
+    title: "Run a mod's in-game test plan",
+    description: "Execute a test-plan YAML against the in-game bridge: rows carrying a " +
+        "probe are combined into one bridge request, armed and polled through the bridge protocol; rows without one " +
+        "(or explicitly manual) are checklist-only. A row naming an unknown or contradicted probe kind is refused; an " +
+        "unverified probe kind is still run, but a passing result is capped below 'verified' since a pass from an " +
+        "unattested read proves nothing about whether it read the right thing. Runs under the verify policy " +
+        "unless policyMode: workbench (or the retired allowMutate) grants the session tier; a row may declare " +
+        "setup steps that run before its reads, recorded on the claim as verifiedWithSetup. Dry-run by default: shows " +
+        "the combined request and the full checklist without arming the bridge. Writes observed/status/evidence back into the " +
+        "plan's own YAML on apply, and — when a row names a ledger 'claim' id and the project has a ledger — records " +
+        "verified/contradicted against that claim with inline evidence.",
+    inputSchema: {
+        path: z.string().optional().describe("modwright.json path or a directory to search from. Default: current directory."),
+        plan: z.string().describe("A planId (from the test plan's own header) or a path to its YAML file."),
+        rows: z.array(z.string()).optional().describe("Restrict to these row ids. Omit for every row in the plan."),
+        gates: z.array(z.string()).optional().describe("Restrict to rows carrying one of these gate ids."),
+        mode: z.enum(["dry-run", "apply"]).default("dry-run").describe("dry-run shows the combined request and the full checklist without arming the bridge or writing anything."),
+        policyMode: z
+            .enum(["verify", "workbench"])
+            .optional()
+            .describe("Capability policy: verify (default, regardless of the project's own policy) grants read+observe; workbench adds session, letting effect:\"mutate\" probes and row setup steps run. Overrides the project's bridge.policy.mode."),
+        windowSeconds: z.number().nonnegative().optional().describe("An observe window in seconds, on top of any a row's own probe declares."),
+        allowMutate: z.boolean().default(false).describe("DEPRECATED: retired alias for policyMode: workbench / grant:[\"session\"]. Prefer bridge.policy or policyMode."),
+        timeoutSeconds: z.number().positive().max(300).optional().describe("Override the computed poll budget; still capped at 300s."),
+        installPath: installPathArg,
+    },
+}, async ({ path: start, plan, rows, gates, mode, policyMode, windowSeconds, allowMutate, timeoutSeconds, installPath }) => {
+    const resolved = await projectOrFail(start);
+    if ("isError" in resolved)
+        return resolved;
+    const gameId = asBridgeGame(resolved.project.game);
+    if (!gameId)
+        return fail(`"${resolved.project.game}" has no bridge, so it has no test plan to run. Known: ${BRIDGE_GAMES.join(", ")}`);
+    const surface = getSurface(gameId);
+    if (!surface)
+        return fail(`Unknown game "${gameId}".`);
+    const install = await resolveInstall(surface, installPath).catch(() => undefined);
+    try {
+        const result = await runTestPlan({
+            project: resolved,
+            surface,
+            install,
+            plan,
+            rows,
+            gates,
+            mode,
+            policyMode,
+            window: windowSeconds !== undefined ? { seconds: windowSeconds } : undefined,
+            allowMutate,
+            timeoutSeconds,
+        });
+        return json(result);
+    }
+    catch (error) {
+        return fail(`run_tests failed: ${error.message}`);
+    }
+});
+function asLedgerTool(value) {
+    return value === "validate" || value === "build" || value === "run_tests" ? value : "ledger";
+}
+server.registerTool("ledger", {
+    title: "Track claims and blind decisions across a fix",
+    description: "`<mod repo>/ledger/claims.yaml` and `ledger/decisions.yaml`. Statuses " +
+        "authored -> checker-clean -> built -> verified | contradicted, each written by exactly one tool " +
+        "(validate/build/run_tests already wire the first three transitions automatically when a project has a " +
+        "ledger); 'ledger record' authors a new claim/decision or makes a manual correction, always dry-run by " +
+        "default. Nothing reaches verified/contradicted without an evidence block. 'list'/'show' read only; 'check' " +
+        "verifies every verified/contradicted claim has evidence, every evidence path exists on disk, every id is " +
+        "unique, and that a claim whose evidence names an unverified probe kind also carries a manual-row " +
+        "corroboration entry.",
+    inputSchema: {
+        action: z.enum(["list", "show", "record", "check"]),
+        path: z.string().optional().describe("modwright.json path or a directory to search from. Default: current directory."),
+        mode: z.enum(["dry-run", "apply"]).default("dry-run").describe("'record': dry-run previews the write without touching disk."),
+        status: z.enum(["authored", "checker-clean", "built", "verified", "contradicted"]).optional().describe("'list': restrict to this claim status."),
+        file: z.string().optional().describe("'list': restrict to claims whose scope.files names this path (exact or suffix match)."),
+        id: z.string().optional().describe("'show'/'record': the claim or decision id."),
+        kind: z.enum(["claim", "decision"]).default("claim").describe("'record': which ledger this write targets."),
+        claimText: z.string().optional().describe("'record' kind:\"claim\": the claim text — required when authoring a new claim id."),
+        scopeFiles: z.array(z.string()).optional().describe("'record' kind:\"claim\": files this claim is about, for a new claim."),
+        scopeEntries: z.array(z.string()).optional().describe("'record' kind:\"claim\": named entries (stat/tweak ids) this claim is about, for a new claim."),
+        toStatus: z.enum(["authored", "checker-clean", "built", "verified", "contradicted"]).optional().describe("'record' kind:\"claim\": the status to move this claim to."),
+        tool: z.enum(["validate", "build", "run_tests", "ledger"]).optional().describe("'record' kind:\"claim\": which tool this write claims to be — defaults to \"ledger\" (a manual record/correction). Passing another tool's name does not skip that tool's own gate; it only labels the write."),
+        by: z.string().optional().describe("'record': who or what made this write. Default \"ledger\"."),
+        note: z.string().optional().describe("'record': why, for the history entry."),
+        evidence: z
+            .array(z.object({
+            runId: z.string(),
+            planId: z.string(),
+            rowId: z.string(),
+            probeId: z.string(),
+            probeKind: z.string(),
+            resultPath: z.string(),
+            resultSha256: z.string(),
+            observedAt: z.string(),
+            observed: z.unknown(),
+            manual: z.boolean().optional(),
+        }))
+            .optional()
+            .describe("'record' kind:\"claim\": evidence entries to append — required to reach verified/contradicted unless the claim already carries some."),
+        supersedes: z.string().optional().describe("'record' kind:\"claim\": id of a contradicted claim this one replaces."),
+        question: z.string().optional().describe("'record' kind:\"decision\": required when authoring a new decision id."),
+        appliedDefault: z.string().optional().describe("'record' kind:\"decision\": required when authoring a new decision id."),
+        where: z.string().optional().describe("'record' kind:\"decision\": required when authoring a new decision id."),
+        madeBlind: z.boolean().optional().describe("'record' kind:\"decision\": required when authoring a new decision id."),
+        resolutionStatus: z.enum(["open", "resolved"]).optional().describe("'record' kind:\"decision\": sets resolution.status."),
+        outcome: z.string().optional().describe("'record' kind:\"decision\": sets resolution.outcome."),
+        source: z.string().optional().describe("'record' kind:\"decision\": sets resolution.source."),
+    },
+}, async ({ action, path: start, mode, status, file, id, kind, claimText, scopeFiles, scopeEntries, toStatus, tool, by, note, evidence, supersedes, question, appliedDefault, where, madeBlind, resolutionStatus, outcome, source, }) => {
+    const resolved = await projectOrFail(start);
+    if ("isError" in resolved)
+        return resolved;
+    if (action === "list") {
+        const loaded = await loadClaims(resolved.root);
+        return json({
+            action,
+            path: claimsFilePath(resolved.root),
+            exists: loaded.exists,
+            problems: loaded.problems,
+            count: loaded.claims.length,
+            claims: listClaims(loaded.claims, { status, claim: undefined, file }),
+        });
+    }
+    if (action === "show") {
+        if (!id)
+            return fail('ledger show requires "id".');
+        const loaded = await loadClaims(resolved.root);
+        const claim = showClaim(loaded.claims, id);
+        if (!claim)
+            return fail(`No claim "${id}" in ${claimsFilePath(resolved.root)}.`);
+        return json({ action, claim });
+    }
+    if (action === "check") {
+        const loaded = await loadClaims(resolved.root);
+        if (!loaded.exists)
+            return json({ action, exists: false, ok: true, issues: [], note: "No ledger/claims.yaml — nothing to check." });
+        const report = await checkLedger(resolved.root, loaded.claims);
+        return json({ action, path: claimsFilePath(resolved.root), ...report });
+    }
+    if (!id)
+        return fail('ledger record requires "id".');
+    const writeTool = asLedgerTool(tool);
+    if (kind === "decision") {
+        const loaded = await loadDecisions(resolved.root);
+        const resolution = resolutionStatus || outcome || source ? { status: resolutionStatus ?? "open", outcome, source, at: new Date().toISOString() } : undefined;
+        const result = applyDecisionRecord({ decisions: loaded.decisions, id, question, appliedDefault, where, madeBlind, resolution });
+        if (!result.ok)
+            return fail(`ledger record (decision) refused: ${result.refusal}`);
+        const write = await saveDecisions(resolved.root, result.decisions, { mode });
+        return json({ action, kind, decision: result.decision, write });
+    }
+    if (!toStatus)
+        return fail('ledger record kind:"claim" requires "toStatus".');
+    const loaded = await loadClaims(resolved.root);
+    const scope = scopeFiles || scopeEntries ? { files: scopeFiles, entries: scopeEntries } : undefined;
+    const result = applyClaimTransition({
+        claims: loaded.claims,
+        id,
+        to: toStatus,
+        tool: writeTool,
+        by: by ?? "ledger",
+        note,
+        evidence: evidence,
+        scope,
+        claimText,
+        supersedes,
+    });
+    if (!result.ok)
+        return fail(`ledger record refused: ${result.refusal}`);
+    const write = await saveClaims(resolved.root, result.claims, { mode });
+    return json({ action, kind, claim: result.claim, write });
+});
+const CONVERSION_IDS = CONVERTERS.map((c) => c.id);
+const DIFF_KINDS = ["cr2w-json", "lsx", "loca-xml"];
+const TEMPLATE_SURFACES = ["baldursgate3", "cyberpunk2077"];
+const TEMPLATE_PERMISSIONS = ["never-redistribute", "maintainer-own", "declared-dependency"];
+async function resolveProject(start) {
+    const from = start ?? process.cwd();
+    const file = (await pathExists(from)) && from.toLowerCase().endsWith(".json") ? from : await findProjectFile(from);
+    if (!file)
+        throw new NoProjectError(`No modwright.json found at or above ${from}.`);
+    return loadProject(file);
+}
+server.registerTool("convert", {
+    title: "Convert between an authoring text format and a game binary",
+    description: "One registered conversion from the `text/` converter registry: " +
+        "BG3's lsx<->lsf and xml<->loca through divine, Cyberpunk's cr2w<->json through WolvenKit CLI. Dry-run by " +
+        "default — resolves the tool and reports the argv without running it or writing a byte; apply runs the " +
+        "tool into a scratch file and writes the result through core/safety (an existing destination is backed up " +
+        "first). `cp2077.json-to-cr2w` renumbers every HandleId/BufferId into document-encounter order before " +
+        "deserializing, since WolvenKit's own deserialize fails otherwise, and reports what it renumbered. Unless " +
+        "verifyRoundTrip is set to false, every conversion also runs the round trip registered for " +
+        "it (a byte compare for a binary source, a field diff against the ignore list for a text source) and reports " +
+        "whether it came back clean.",
+    inputSchema: {
+        conversionId: z.enum(CONVERSION_IDS).describe(`The conversion to run. Known ids: ${CONVERSION_IDS.join(", ")}.`),
+        source: z.string().describe("Absolute path to the source file."),
+        dest: z.string().describe("Absolute path to write the converted result to."),
+        mode: z.enum(["dry-run", "apply"]).default("dry-run").describe("dry-run resolves the tool and reports the argv without running it or writing a byte."),
+        verifyRoundTrip: z.boolean().default(true).describe("Run the conversion's round-trip verification after an apply. Set false to skip it (e.g. when the inverse tool is not needed)."),
+        path: z.string().optional().describe("A modwright.json path or directory, to resolve toolchain overrides (its own \"toolchain\" map) from. Omit to use PATH/env-var/candidate detection only."),
+    },
+}, async ({ conversionId, source, dest, mode, verifyRoundTrip, path: projectPath }) => {
+    let overrides;
+    if (projectPath) {
+        try {
+            overrides = (await resolveProject(projectPath)).project.toolchain;
+        }
+        catch {
+        }
+    }
+    try {
+        const report = await runConvert(conversionId, source, dest, { mode, verifyRoundTrip, locateTool: defaultTextLocateTool(overrides, mode === "apply" ? "all" : "none") });
+        return json(report);
+    }
+    catch (error) {
+        return fail(`convert failed: ${error.message}`);
+    }
+});
+server.registerTool("diff", {
+    title: "Field-diff two authoring documents",
+    description: "The field diff behind convert's round-trip verification and scaffold's dry-run preview: " +
+        "compares two parsed documents of the given kind, not two byte " +
+        "strings, with type-aware equality (case/slash-insensitive resource paths, epsilon-compared floats, exact " +
+        "enums/ids) and an explicit ignore list (per-machine export metadata, render buffers, HandleId/BufferId " +
+        "renumbering, tool-fixed version fields, LSX serialization artefacts). Rows are `{ path, kind: " +
+        "\"added\"|\"removed\"|\"changed\", left?, right?, note? }`; `path` is a JSON-path for cr2w-json, a node path " +
+        "with the attribute id for lsx, or a contentuid for loca-xml.",
+    inputSchema: {
+        kind: z.enum(DIFF_KINDS).describe("Which document format both sides are."),
+        left: z.string().describe("Absolute path to the left/original file."),
+        right: z.string().optional().describe("Absolute path to the right/comparison file. Omit when using \"template\" instead."),
+        template: z
+            .object({
+            path: z.string().optional().describe("modwright.json path or a directory to search from. Default: current directory."),
+            surface: z.enum(TEMPLATE_SURFACES),
+            gameVersion: z.string(),
+            key: z.string(),
+        })
+            .optional()
+            .describe("Compare \"left\" against this cached template's content instead of a second file."),
+    },
+}, async ({ kind, left, right, template }) => {
+    let rightPath = right;
+    if (template) {
+        let resolved;
+        try {
+            resolved = await resolveProject(template.path);
+        }
+        catch (error) {
+            return fail(`Could not load project: ${error.message}`);
+        }
+        const got = await getTemplate(resolved.root, template.surface, template.gameVersion, template.key);
+        if (!got)
+            return fail(`No cached template at ${template.surface}/${template.gameVersion}/${template.key}.`);
+        rightPath = got.contentPath;
+    }
+    if (!rightPath)
+        return fail('diff requires either "right" or "template".');
+    try {
+        const [leftText, rightText] = await Promise.all([fs.readFile(left, "utf8"), fs.readFile(rightPath, "utf8")]);
+        const result = fieldDiff(kind, leftText, rightText);
+        return json({ action: "diff", kind, left, right: rightPath, ...result });
+    }
+    catch (error) {
+        return fail(`diff failed: ${error.message}`);
+    }
+});
+server.registerTool("template", {
+    title: "The vanilla-extract template library",
+    description: "Extract-on-demand, cache-per-game-version templates for a scaffold to build from. A template is never committed; every cached file carries a provenance " +
+        "(vanilla-extract/own-work/authored) and a permission, and the cache is keyed by surface, game version and a " +
+        "hash of the extraction inputs — a patch orphans the old subtree rather than silently reusing it. 'extract' " +
+        "runs the surface's toolchain adapter (divine extract-package for BG3, WolvenKit CLI extract for Cyberpunk, " +
+        "then an optional registered conversion) into the cache through a WritePlan, dry-run by default; a still-" +
+        "valid cache entry (checked against the install's game version, the tool's version, the source container's " +
+        "size/mtime, and the cached content's own sha256 — any miss re-extracts) is served without re-running the " +
+        "toolchain, unless refresh is set. 'list'/'get' read the cache; 'get' also reports whether the entry it " +
+        "found is still valid. 'invalidate' deletes one cached entry's whole key directory, dry-run by default. " +
+        "Nothing here ever writes the tracked .modwright/templates/manifest.json — that record is a scaffold's job.",
+    inputSchema: {
+        action: z.enum(["list", "get", "extract", "invalidate"]),
+        path: z.string().optional().describe("modwright.json path or a directory to search from. Default: current directory."),
+        installPath: installPathArg,
+        mode: z.enum(["dry-run", "apply"]).default("dry-run").describe("'extract'/'invalidate': dry-run describes without running a tool or touching disk."),
+        surface: z.enum(TEMPLATE_SURFACES).optional().describe("Required for get/extract/invalidate; an optional filter for list."),
+        gameVersion: z.string().optional().describe("Required for get/extract/invalidate (extract defaults to the resolved install's version when omitted); an optional filter for list."),
+        key: z.string().optional().describe("Required for get/invalidate. 'extract' computes and returns its own key; never pass one in."),
+        refresh: z.boolean().default(false).describe("'extract': force re-extraction even over an entry that would otherwise pass every invalidation check."),
+        ref: z.string().optional().describe("'extract': a human-readable reference for this template, e.g. \"cp2077/garment/t2_146_pwa_jacket__collar_fur.ent\"."),
+        kind: z.string().optional().describe("'extract': what this template is, e.g. \"garment-ent\", \"roottemplate\"."),
+        permission: z.enum(TEMPLATE_PERMISSIONS).optional().describe("'extract': the permission this template's content carries."),
+        sourceContainer: z.string().optional().describe("'extract': absolute path to the .pak/.archive the file lives inside."),
+        sourcePath: z.string().optional().describe("'extract': the archive-internal path to the one file this template is."),
+        conversion: z.enum(CONVERSION_IDS).optional().describe("'extract': a registered conversion to run on the extracted file before it is cached, e.g. \"cp2077.cr2w-to-json\"."),
+        notes: z.string().optional().describe("'extract': free-text notes recorded on the template record."),
+    },
+}, async ({ action, path: start, installPath, mode, surface, gameVersion, key, refresh, ref, kind, permission, sourceContainer, sourcePath, conversion, notes }) => {
+    let resolved;
+    try {
+        resolved = await resolveProject(start);
+    }
+    catch (error) {
+        return fail(`Could not load project: ${error.message}`);
+    }
+    const locateTool = defaultTextLocateTool(resolved.project.toolchain, action === "extract" && mode === "apply" ? "all" : action === "extract" ? "none" : "trusted");
+    const templateGameVersion = async (surfaceId) => {
+        const gameSurface = getSurface(surfaceId);
+        if (!gameSurface)
+            return undefined;
+        const install = await resolveInstall(gameSurface, installPath).catch(() => undefined);
+        return install ? installGameVersion(gameSurface, install) : undefined;
+    };
+    if (action === "list") {
+        const entries = await listTemplates(resolved.root, { surface: surface, gameVersion });
+        return json({ action, project: resolved.project.name, count: entries.length, templates: entries });
+    }
+    if (action === "get") {
+        if (!surface || !gameVersion || !key)
+            return fail('template get requires "surface", "gameVersion" and "key".');
+        const got = await getTemplate(resolved.root, surface, gameVersion, key, { currentGameVersion: await templateGameVersion(surface), locateTool });
+        if (!got)
+            return fail(`No cached template at ${surface}/${gameVersion}/${key}.`);
+        return json({ action, ...got });
+    }
+    if (action === "invalidate") {
+        if (!surface || !gameVersion || !key)
+            return fail('template invalidate requires "surface", "gameVersion" and "key".');
+        const report = await invalidateTemplate(resolved.root, surface, gameVersion, key, mode);
+        return json({ action, ...report });
+    }
+    if (!surface || !ref || !kind || !permission || !sourceContainer || !sourcePath) {
+        return fail('template extract requires "surface", "ref", "kind", "permission", "sourceContainer" and "sourcePath".');
+    }
+    const resolvedGameVersion = gameVersion ?? (await templateGameVersion(surface)) ?? "unknown";
+    try {
+        const report = await extractTemplate({
+            projectRoot: resolved.root,
+            surface,
+            ref,
+            kind,
+            permission: permission,
+            sourceContainer,
+            sourcePath,
+            gameVersion: resolvedGameVersion,
+            conversion: conversion,
+            mode,
+            locateTool,
+            refresh,
+            notes,
+        });
+        return json(report);
+    }
+    catch (error) {
+        return fail(`template extract failed: ${error.message}`);
+    }
+});
+let scaffoldCatalog;
+function getScaffoldCatalog() {
+    scaffoldCatalog ??= loadAllScaffolds(validators).then(({ loaded, problems }) => {
+        if (problems.length > 0) {
+            throw new Error(`scaffold catalogue failed to load:\n${problems.join("\n")}`);
+        }
+        return loaded;
+    });
+    return scaffoldCatalog;
+}
+let sequenceCatalog;
+function getSequenceCatalog(catalog) {
+    sequenceCatalog ??= loadAllSequences(catalog).then(({ loaded, problems }) => {
+        for (const problem of problems)
+            process.stderr.write(`[modwright] sequence not loaded: ${problem}\n`);
+        return loaded;
+    });
+    return sequenceCatalog;
+}
+server.registerTool("scaffold", {
+    title: "Author new mod content from a declarative scaffold",
+    description: "Declarative, reviewable scaffolds: list every shipped definition, " +
+        "describe one (its inputs, the vanilla index queries it runs, the rules it must pass, the files it writes), or " +
+        "run one against a project. Dry-run by default — resolves inputs, allocates deterministic ids (with project/" +
+        "index/load-order collision checks), and renders the emit ops into a WritePlan without writing a byte; apply " +
+        "writes through core/safety (existing files are backed up first), then re-runs the named `satisfies` rules plus " +
+        "the surface's cheap rule set, writes the scaffold manifest, an `authored` ledger claim, and proposed rows into " +
+        "tests/authored.yaml (for a game with a bridge; otherwise the rows stay in the report and the skip says why). `new-project` is the one scaffold that runs before a modwright.json exists at all — pass " +
+        "`path` as the target directory and it is bootstrapped from `inputs.name`/the scaffold's own game. " +
+        "`claude-assets` is not a scaffold and takes no scaffoldId: it writes ModWright's own Claude Code skills " +
+        "and agents into the project's `.claude/`, recording each file's sha256 so a locally " +
+        "edited one is reported with a diff and left alone rather than clobbered.",
+    inputSchema: {
+        action: z.enum(["list", "describe", "run", "plan", "claude-assets"]),
+        game: z.string().optional().describe("'list' only: restrict to this game id/alias."),
+        scaffoldId: z.string().optional().describe("Required for 'describe'/'run' — a listed scaffold's id, e.g. \"baldursgate3.new-spell\"."),
+        sequenceId: z
+            .string()
+            .optional()
+            .describe("'plan' only: an authoring sequence id from 'list' (its 'sequences'), e.g. \"cyberpunk2077.iconic-weapon\". A sequence is the ordered scaffolds one mod type needs; 'plan' reads the project's scaffold manifests to see which steps are done and reports the next step's exact run call, or the exact prompts (inputs and assets) still unanswered. Read-only."),
+        assets: z
+            .record(z.string())
+            .optional()
+            .describe("'plan' only: answers to the asset prompts a previous plan reported, keyed exactly by their 'answerAs' (\"<stepId>.<assetName>\"). Sequence inputs and per-step inputs (\"<stepId>.<inputName>\") go in 'inputs'."),
+        path: z.string().optional().describe("'run' only: modwright.json path or a directory to search from (or, for a *.new-project scaffold with no project there yet, the directory to create one in). Default: current directory."),
+        inputs: z.record(z.string()).optional().describe("'run' only: values for every input the scaffold's 'describe' lists, keyed by name."),
+        mode: z.enum(["dry-run", "apply"]).default("dry-run").describe("'run' only: dry-run resolves and describes every write without touching disk."),
+        installPath: installPathArg,
+        force: z.boolean().default(false).describe("'run': proceed past a collision refusal, reporting each hit as a warning instead of refusing. 'claude-assets': overwrite locally edited asset files (each is backed up first)."),
+        claudeSettings: z
+            .boolean()
+            .default(false)
+            .describe("'claude-assets' only: also write .claude/settings.json with the project model/effort baseline. Off by default \u2014 ModWright does not change a repo's Claude Code settings unless asked; the generated skills and agents pin their own model and effort in frontmatter."),
+    },
+}, async ({ action, game, scaffoldId, sequenceId, path: start, inputs, assets, mode, installPath, force, claudeSettings }) => {
+    const catalog = await getScaffoldCatalog();
+    if (action === "list") {
+        const gameId = game ? getSurface(game)?.id : undefined;
+        if (game && !gameId)
+            return fail(`Unknown game "${game}". Known: ${surfaceIds().join(", ")}`);
+        const filtered = gameId ? catalog.filter((l) => l.definition.game === gameId) : catalog;
+        const sequences = await getSequenceCatalog(catalog);
+        const filteredSequences = gameId ? sequences.filter((l) => l.definition.game === gameId) : sequences;
+        return json({ action, count: filtered.length, scaffolds: summarize(filtered), sequences: summarizeSequences(filteredSequences) });
+    }
+    if (action === "plan") {
+        if (!sequenceId)
+            return fail(`"plan" requires "sequenceId". Call action:"list" and read its "sequences".`);
+        const sequences = await getSequenceCatalog(catalog);
+        const found = findSequence(sequences, sequenceId);
+        if (!found)
+            return fail(`Unknown sequence "${sequenceId}". Known: ${sequences.map((l) => l.definition.id).join(", ") || "(none)"}`);
+        const dir = start ?? process.cwd();
+        let resolved;
+        try {
+            resolved = await resolveProject(dir);
+        }
+        catch {
+            resolved = undefined;
+        }
+        if (resolved && resolved.project.game !== found.definition.game) {
+            return fail(`"${sequenceId}" is a ${found.definition.game} sequence; ${resolved.project.name} is a ${resolved.project.game} project.`);
+        }
+        const plan = await planSequence({ definition: found.definition, catalog, project: resolved, inputs, assets });
+        return json({ action, ...plan, projectDir: resolved ? undefined : dir });
+    }
+    if (action === "claude-assets") {
+        const dir = start ?? process.cwd();
+        let resolved;
+        try {
+            resolved = await resolveProject(dir);
+        }
+        catch (error) {
+            return fail(`Could not load project: ${error.message}`);
+        }
+        try {
+            const { plan, writeReport, ...rest } = await generateClaudeAssets({
+                project: resolved,
+                mode,
+                force,
+                includeSettings: claudeSettings,
+            });
+            const opPath = (op) => ("path" in op ? op.path : undefined);
+            const opBytes = (op) => "content" in op ? (typeof op.content === "string" ? Buffer.byteLength(op.content, "utf8") : op.content.byteLength) : undefined;
+            return json({
+                action,
+                ...rest,
+                operations: plan.operations.map((op) => ({ kind: op.kind, path: opPath(op), bytes: opBytes(op) })),
+                write: writeReport
+                    ? {
+                        mode: writeReport.mode,
+                        applied: writeReport.applied,
+                        backupDir: writeReport.backupDir,
+                        next: writeReport.next,
+                        operations: writeReport.operations.map((result) => ({
+                            kind: result.op.kind,
+                            path: opPath(result.op),
+                            status: result.status,
+                            backedUpTo: result.backedUpTo,
+                            error: result.error,
+                        })),
+                    }
+                    : undefined,
+            });
+        }
+        catch (error) {
+            return fail(`claude-assets failed: ${error.message}`);
+        }
+    }
+    if (!scaffoldId)
+        return fail(`"${action}" requires "scaffoldId". Call action:"list" to see what is available.`);
+    const found = findScaffold(catalog, scaffoldId);
+    if (!found)
+        return fail(`Unknown scaffold "${scaffoldId}". Known: ${catalog.map((l) => l.definition.id).join(", ")}`);
+    if (action === "describe") {
+        return json({ action, ...describeScaffold(found) });
+    }
+    const surface = getSurface(found.definition.game);
+    if (!surface)
+        return fail(`Scaffold "${scaffoldId}" names game "${found.definition.game}", which has no surface registered.`);
+    const dir = start ?? process.cwd();
+    let resolved;
+    try {
+        resolved = await resolveProject(dir);
+    }
+    catch (error) {
+        if (!scaffoldId.endsWith(".new-project"))
+            return fail(`Could not load project: ${error.message}`);
+        const name = inputs?.name;
+        if (!name)
+            return fail(`No modwright.json found at or above ${dir}, and "${scaffoldId}" needs inputs.name to bootstrap one.`);
+        resolved = bootstrapProject(dir, found.definition.game, name);
+    }
+    if (resolved.project.game !== found.definition.game) {
+        return fail(`"${scaffoldId}" is a ${found.definition.game} scaffold; ${resolved.project.name} is a ${resolved.project.game} project.`);
+    }
+    const install = await resolveInstall(surface, installPath).catch(() => undefined);
+    const store = await getStore(surface.id);
+    try {
+        const report = await runScaffold({
+            project: resolved,
+            surface,
+            definition: found.definition,
+            inputs: inputs ?? {},
+            mode,
+            install,
+            store,
+            registry: validators,
+            force,
+        });
+        return json({ action, ...report });
+    }
+    catch (error) {
+        return fail(`scaffold "${scaffoldId}" failed: ${error.message}`);
+    }
+});
+for (const entry of loadSkillPromptCatalog()) {
+    server.registerPrompt(entry.name, {
+        title: entry.title,
+        description: entry.description,
+        argsSchema: {
+            path: z.string().optional().describe("modwright.json path or a directory to search up from. Default: the server's working directory."),
+        },
+    }, async ({ path: start }) => {
+        const rendered = await renderSkillPrompt(entry, start);
+        return {
+            description: rendered.project ? `${entry.name} for ${rendered.project.name} (${rendered.project.game})` : entry.description,
+            messages: [{ role: "user", content: { type: "text", text: rendered.text } }],
+        };
+    });
+}
+const transport = new StdioServerTransport();
+await server.connect(transport);