@mosvera/mcp 0.1.1

package/dist/server.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: Apache-2.0
+//
+// Mosvera MCP stdio bootstrap. The server exposes a small, user-facing
+// aesthetic tool surface over the TypeScript runtime and a local project
+// registry.
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { buildContext, parseCliOptions, SERVER_VERSION } from "./context.js";
+import { documentKinds, runCompileDesignTokens, runCompileProviderPayload, runDeleteRegistryDocument, runDraftAesthetic, runGetRegistryDocument, runListAesthetics, runResolveAesthetic, runSaveAesthetic, runSaveRegistryDocument, runServerStatus, runValidateDocument, runValidateRegistry, runWriteMergeStrategies, } from "./tools/aesthetic.js";
+const docArg = z.union([z.string(), z.record(z.any())]);
+const strategiesArg = z.record(z.object({
+    strategy: z.enum(["replace", "append", "merge_by"]),
+    key: z.string().optional(),
+}));
+const criticalityArg = z.record(z.enum(["required", "optional"]));
+const documentKindArg = z.enum(documentKinds);
+const registryDocumentKindArg = z.enum(documentKinds);
+const outputSchema = z.object({ ok: z.boolean(), message: z.string() }).passthrough();
+const readAnnotations = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: false,
+};
+const writeAnnotations = {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+};
+const destructiveAnnotations = {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: false,
+};
+export { buildContext };
+export function createServer(ctx) {
+    const server = new McpServer({
+        name: "mosvera-mcp",
+        title: "Mosvera MCP",
+        version: SERVER_VERSION,
+    });
+    server.registerTool("server_status", {
+        title: "Server Status",
+        description: "Show the active Mosvera registry path, write mode, versions, document counts, and diagnostics.",
+        inputSchema: {},
+        outputSchema,
+        annotations: readAnnotations,
+    }, async () => runServerStatus(ctx));
+    server.registerTool("list_aesthetics", {
+        title: "List Aesthetics",
+        description: "List named aesthetics available in the active local Mosvera registry.",
+        inputSchema: {},
+        outputSchema,
+        annotations: readAnnotations,
+    }, async () => runListAesthetics(ctx));
+    server.registerTool("get_registry_document", {
+        title: "Get Registry Document",
+        description: "Fetch a template, modifier, palette, composition, or capability manifest from the active registry.",
+        inputSchema: { kind: registryDocumentKindArg, id: z.string() },
+        outputSchema,
+        annotations: readAnnotations,
+    }, async (args) => runGetRegistryDocument(ctx, args));
+    server.registerTool("validate_document", {
+        title: "Validate Document",
+        description: "Validate one Mosvera document against a schema kind. Invalid documents return valid=false, not a thrown protocol error.",
+        inputSchema: { document: docArg, kind: documentKindArg },
+        outputSchema,
+        annotations: readAnnotations,
+    }, async (args) => runValidateDocument(ctx, args));
+    server.registerTool("validate_registry", {
+        title: "Validate Registry",
+        description: "Validate the active local registry and return Mosvera diagnostics.",
+        inputSchema: {},
+        outputSchema,
+        annotations: readAnnotations,
+    }, async () => runValidateRegistry(ctx));
+    server.registerTool("resolve_aesthetic", {
+        title: "Resolve Aesthetic",
+        description: "Resolve a named or inline aesthetic composition into the canonical Mosvera model.",
+        inputSchema: { aesthetic: z.union([z.string(), z.record(z.any())]), merge_strategies: strategiesArg.optional() },
+        outputSchema,
+        annotations: readAnnotations,
+    }, async (args) => runResolveAesthetic(ctx, args));
+    server.registerTool("compile_design_tokens", {
+        title: "Compile Design Tokens",
+        description: "Compile a named/inline aesthetic or canonical model into portable design tokens and CSS variables.",
+        inputSchema: {
+            aesthetic: z.union([z.string(), z.record(z.any())]).optional(),
+            canonical: docArg.optional(),
+            merge_strategies: strategiesArg.optional(),
+            css_prefix: z.string().optional(),
+            preserve_unknown: z.boolean().optional(),
+        },
+        outputSchema,
+        annotations: readAnnotations,
+    }, async (args) => runCompileDesignTokens(ctx, args));
+    server.registerTool("compile_provider_payload", {
+        title: "Compile Provider Payload",
+        description: "Advanced: deterministically compile a named/inline aesthetic into a provider payload. No provider HTTP call is made.",
+        inputSchema: {
+            aesthetic: z.union([z.string(), z.record(z.any())]),
+            provider: z.string(),
+            criticality: criticalityArg.optional(),
+            merge_strategies: strategiesArg.optional(),
+        },
+        outputSchema,
+        annotations: readAnnotations,
+    }, async (args) => runCompileProviderPayload(ctx, args));
+    server.registerTool("draft_aesthetic", {
+        title: "Draft Aesthetic",
+        description: "Draft a valid composition document without saving it to disk.",
+        inputSchema: {
+            id: z.string(),
+            base: z.string(),
+            modifiers: z.array(z.string()).optional(),
+            overrides: docArg.optional(),
+        },
+        outputSchema,
+        annotations: readAnnotations,
+    }, async (args) => runDraftAesthetic(ctx, args));
+    if (ctx.registryWritable && !ctx.readOnlyMode) {
+        server.registerTool("save_aesthetic", {
+            title: "Save Aesthetic",
+            description: "Create or update a named aesthetic composition in the active local registry.",
+            inputSchema: {
+                id: z.string(),
+                base: z.string(),
+                modifiers: z.array(z.string()).optional(),
+                overrides: docArg.optional(),
+            },
+            outputSchema,
+            annotations: writeAnnotations,
+        }, async (args) => runSaveAesthetic(ctx, args));
+        server.registerTool("save_registry_document", {
+            title: "Save Registry Document",
+            description: "Advanced: create or update a template, modifier, palette, composition, or capability manifest in the active local registry.",
+            inputSchema: { kind: registryDocumentKindArg, document: docArg },
+            outputSchema,
+            annotations: writeAnnotations,
+        }, async (args) => runSaveRegistryDocument(ctx, args));
+        server.registerTool("delete_registry_document", {
+            title: "Delete Registry Document",
+            description: "Delete a registry document from the active local registry.",
+            inputSchema: { kind: registryDocumentKindArg, id: z.string() },
+            outputSchema,
+            annotations: destructiveAnnotations,
+        }, async (args) => runDeleteRegistryDocument(ctx, args));
+        server.registerTool("write_merge_strategies", {
+            title: "Write Merge Strategies",
+            description: "Advanced: replace the active registry's merge-strategies.json with deterministic JSON.",
+            inputSchema: { merge_strategies: strategiesArg },
+            outputSchema,
+            annotations: writeAnnotations,
+        }, async (args) => runWriteMergeStrategies(ctx, args));
+    }
+    return server;
+}
+async function main() {
+    const options = parseCliOptions(process.argv.slice(2));
+    const ctx = buildContext(options);
+    const server = createServer(ctx);
+    await server.connect(new StdioServerTransport());
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch((e) => {
+        process.stderr.write(`mosvera-mcp failed to start: ${e instanceof Error ? e.stack : String(e)}\n`);
+        process.exit(1);
+    });
+}

package/dist/tools/aesthetic.d.ts

@@ -0,0 +1,57 @@
+import { type Criticality, type DocumentKind, type MergeStrategies, type RegistryKind } from "@mosvera/runtime";
+import type { ToolContext, ToolErrorCode } from "../types.ts";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export declare const registryKinds: readonly ["template", "modifier", "palette", "composition"];
+export declare const documentKinds: readonly ["template", "modifier", "palette", "composition", "capability-manifest"];
+export declare function runServerStatus(ctx: ToolContext): CallToolResult;
+export declare function runListAesthetics(ctx: ToolContext): CallToolResult;
+export declare function runGetRegistryDocument(ctx: ToolContext, args: {
+    kind: RegistryKind | "capability-manifest";
+    id: string;
+}): CallToolResult;
+export declare function runValidateDocument(ctx: ToolContext, args: {
+    document: object | string;
+    kind: DocumentKind;
+}): CallToolResult;
+export declare function runValidateRegistry(ctx: ToolContext): CallToolResult;
+export declare function runResolveAesthetic(ctx: ToolContext, args: {
+    aesthetic: string | object;
+    merge_strategies?: MergeStrategies;
+}): CallToolResult;
+export declare function runCompileDesignTokens(ctx: ToolContext, args: {
+    aesthetic?: string | object;
+    canonical?: object | string;
+    merge_strategies?: MergeStrategies;
+    css_prefix?: string;
+    preserve_unknown?: boolean;
+}): CallToolResult;
+export declare function runCompileProviderPayload(ctx: ToolContext, args: {
+    aesthetic: string | object;
+    provider: string;
+    criticality?: Record<string, Criticality>;
+    merge_strategies?: MergeStrategies;
+}): CallToolResult;
+export declare function runDraftAesthetic(_ctx: ToolContext, args: {
+    id: string;
+    base: string;
+    modifiers?: string[];
+    overrides?: object | string;
+}): CallToolResult;
+export declare function runSaveAesthetic(ctx: ToolContext, args: {
+    id: string;
+    base: string;
+    modifiers?: string[];
+    overrides?: object | string;
+}): CallToolResult;
+export declare function runSaveRegistryDocument(ctx: ToolContext, args: {
+    kind: RegistryKind | "capability-manifest";
+    document: object | string;
+}): CallToolResult;
+export declare function runDeleteRegistryDocument(ctx: ToolContext, args: {
+    kind: RegistryKind | "capability-manifest";
+    id: string;
+}): CallToolResult;
+export declare function runWriteMergeStrategies(ctx: ToolContext, args: {
+    merge_strategies: MergeStrategies;
+}): CallToolResult;
+export declare function errorCodeFromResult(result: CallToolResult): ToolErrorCode | undefined;

package/dist/tools/aesthetic.js

@@ -0,0 +1,331 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// User-facing Mosvera MCP tools. These handlers keep the MCP layer thin:
+// parse/validate inputs, call @mosvera/runtime, persist through the Node
+// boundary where needed, and return MCP-native structured results.
+import { compile, compileDesignTokens, composeStrategies, createComposition, getRegistryDocument, listRegistryEntries, parse, resolveAesthetic, toCssVariables, } from "@mosvera/runtime";
+import { deleteProjectDocument, RegistryProjectError, saveProjectDocument, writeMergeStrategies } from "@mosvera/runtime/node";
+import { EmissionError } from "@mosvera/provider-base";
+import { registryDiagnostics, reloadContext, SERVER_VERSION } from "../context.js";
+import { fail, ok } from "../mcp-result.js";
+import { deleteCapabilityManifest, ProjectWriteError, saveCapabilityManifest } from "../project-writes.js";
+import { isResolutionError, mapResolutionError } from "../errors.js";
+export const registryKinds = ["template", "modifier", "palette", "composition"];
+export const documentKinds = ["template", "modifier", "palette", "composition", "capability-manifest"];
+function parseDocument(source) {
+    try {
+        return parse(source);
+    }
+    catch (e) {
+        return {
+            error: "invalid_document",
+            message: `Could not parse Mosvera document: ${e instanceof Error ? e.message : String(e)}`,
+        };
+    }
+}
+function runtimeError(e) {
+    if (isResolutionError(e)) {
+        const mapped = mapResolutionError(e);
+        return { error: mapped.error, message: `Could not resolve aesthetic: ${mapped.error}`, detail: mapped.detail };
+    }
+    if (e instanceof ProjectWriteError) {
+        return { error: e.code, message: e.message, detail: e.detail };
+    }
+    if (e instanceof RegistryProjectError) {
+        const first = e.diagnostics[0];
+        return {
+            error: first?.code ?? "invalid_document",
+            message: first?.message ?? e.message,
+            detail: { diagnostics: e.diagnostics },
+        };
+    }
+    if (e instanceof EmissionError) {
+        return { error: "invalid_document", message: e.message, detail: { construct: e.construct } };
+    }
+    if (e instanceof Error && e.message.includes("invalid Mosvera reference id")) {
+        return { error: "unsafe_filename", message: e.message };
+    }
+    return {
+        error: "invalid_document",
+        message: e instanceof Error ? e.message : String(e),
+    };
+}
+function maybeFail(value) {
+    return typeof value === "object" && value !== null && "error" in value && "message" in value;
+}
+function strategies(ctx, inline) {
+    return composeStrategies(ctx.baseStrategies, inline);
+}
+function resolveInput(ctx, args) {
+    if (args.canonical !== undefined) {
+        const canonical = parseDocument(args.canonical);
+        if (maybeFail(canonical))
+            return canonical;
+        return { canonical, source: "canonical" };
+    }
+    const aesthetic = args.aesthetic ?? "quiet-editorial";
+    const docOrId = typeof aesthetic === "string" ? aesthetic : parseDocument(aesthetic);
+    if (maybeFail(docOrId))
+        return docOrId;
+    try {
+        return {
+            canonical: resolveAesthetic(docOrId, ctx.project.registry, strategies(ctx, args.merge_strategies)),
+            source: "aesthetic",
+        };
+    }
+    catch (e) {
+        return runtimeError(e);
+    }
+}
+function validateForSave(ctx, document, kind) {
+    const result = ctx.validator.validate(document, kind);
+    if (result.valid)
+        return undefined;
+    return {
+        error: "schema_failure",
+        message: `${kind} document failed schema validation`,
+        detail: { errors: result.errors },
+    };
+}
+function writeDisabled(ctx) {
+    if (ctx.readOnlyMode)
+        return { error: "write_disabled", message: "This Mosvera MCP server is running in read-only mode." };
+    if (!ctx.registryWritable)
+        return { error: "registry_unwritable", message: "The active Mosvera registry is not writable." };
+    return undefined;
+}
+function toolFail(failure) {
+    return fail(failure.error, failure.message, failure.detail);
+}
+export function runServerStatus(ctx) {
+    const diagnostics = [...ctx.loadDiagnostics, ...registryDiagnostics(ctx.project, ctx.validator)];
+    const registry = ctx.project.registry;
+    const counts = {
+        templates: Object.keys(registry.templates ?? {}).length,
+        modifiers: Object.keys(registry.modifiers ?? {}).length,
+        palettes: Object.keys(registry.palettes ?? {}).length,
+        compositions: Object.keys(registry.compositions ?? {}).length,
+        manifests: Object.keys(ctx.project.manifests).length,
+    };
+    return ok("Mosvera MCP server is ready.", {
+        registry_path: ctx.registryDir,
+        registry_writable: ctx.registryWritable,
+        read_only_mode: ctx.readOnlyMode,
+        write_tools_enabled: ctx.registryWritable && !ctx.readOnlyMode,
+        fallback_registry: ctx.fallbackRegistry,
+        fallback_reason: ctx.fallbackReason,
+        versions: {
+            mcp: SERVER_VERSION,
+            runtime: "0.1.1",
+        },
+        counts,
+        diagnostics,
+    });
+}
+export function runListAesthetics(ctx) {
+    const aesthetics = listRegistryEntries(ctx.project.registry, "composition");
+    return ok(`Found ${aesthetics.length} aesthetic${aesthetics.length === 1 ? "" : "s"}.`, { aesthetics });
+}
+export function runGetRegistryDocument(ctx, args) {
+    if (args.kind === "capability-manifest") {
+        const document = ctx.project.manifests[args.id];
+        if (document === undefined) {
+            return fail("unknown_reference", `No capability manifest named "${args.id}" was found.`, { kind: args.kind, id: args.id });
+        }
+        return ok(`Loaded capability manifest "${args.id}".`, { kind: args.kind, id: args.id, document });
+    }
+    const document = getRegistryDocument(ctx.project.registry, args.kind, args.id);
+    if (document === undefined) {
+        return fail("unknown_reference", `No ${args.kind} named "${args.id}" was found.`, { kind: args.kind, id: args.id });
+    }
+    return ok(`Loaded ${args.kind} "${args.id}".`, { kind: args.kind, id: args.id, document });
+}
+export function runValidateDocument(ctx, args) {
+    const document = parseDocument(args.document);
+    if (maybeFail(document))
+        return toolFail(document);
+    const result = ctx.validator.validate(document, args.kind);
+    return ok(result.valid ? "Document is valid." : "Document is invalid.", { valid: result.valid, errors: result.errors });
+}
+export function runValidateRegistry(ctx) {
+    const diagnostics = [...ctx.loadDiagnostics, ...registryDiagnostics(ctx.project, ctx.validator)];
+    return ok(diagnostics.length === 0 ? "Registry is valid." : `Registry has ${diagnostics.length} diagnostic(s).`, {
+        valid: diagnostics.length === 0,
+        diagnostics,
+    });
+}
+export function runResolveAesthetic(ctx, args) {
+    const input = { aesthetic: args.aesthetic };
+    if (args.merge_strategies !== undefined)
+        input.merge_strategies = args.merge_strategies;
+    const resolved = resolveInput(ctx, input);
+    if (maybeFail(resolved))
+        return toolFail(resolved);
+    const id = typeof args.aesthetic === "string" ? args.aesthetic : "inline";
+    return ok(`Resolved aesthetic "${id}".`, { canonical: resolved.canonical });
+}
+export function runCompileDesignTokens(ctx, args) {
+    const resolved = resolveInput(ctx, args);
+    if (maybeFail(resolved))
+        return toolFail(resolved);
+    const tokenOptions = {};
+    if (args.preserve_unknown !== undefined)
+        tokenOptions.preserveUnknown = args.preserve_unknown;
+    const cssOptions = {};
+    if (args.css_prefix !== undefined)
+        cssOptions.prefix = args.css_prefix;
+    const tokens = compileDesignTokens(resolved.canonical, tokenOptions);
+    const css_variables = toCssVariables(tokens, cssOptions);
+    return ok("Compiled portable design tokens.", { source: resolved.source, canonical: resolved.canonical, tokens, css_variables });
+}
+export function runCompileProviderPayload(ctx, args) {
+    const input = { aesthetic: args.aesthetic };
+    if (args.merge_strategies !== undefined)
+        input.merge_strategies = args.merge_strategies;
+    const resolved = resolveInput(ctx, input);
+    if (maybeFail(resolved))
+        return toolFail(resolved);
+    const adapter = ctx.adapters?.[args.provider];
+    const manifest = ctx.project.manifests[args.provider] ?? adapter?.manifest();
+    if (manifest === undefined)
+        return fail("unknown_provider", `No provider manifest or adapter named "${args.provider}" was found.`, { provider: args.provider });
+    const manifestValidation = ctx.validator.validate(manifest, "capability-manifest");
+    if (!manifestValidation.valid) {
+        return fail("schema_failure", `Provider manifest "${args.provider}" failed schema validation.`, { errors: manifestValidation.errors });
+    }
+    const compiled = compile(resolved.canonical, manifest, args.criticality ?? {});
+    if (compiled.status === "error") {
+        return ok(`Provider "${args.provider}" cannot satisfy required construct "${compiled.construct}".`, {
+            status: "error",
+            error: compiled.error,
+            construct: compiled.construct,
+            canonical: resolved.canonical,
+        });
+    }
+    if (adapter === undefined) {
+        return ok(`Compiled provider contract for "${args.provider}".`, {
+            status: "compiled",
+            provider: args.provider,
+            warnings: compiled.warnings,
+            canonical: resolved.canonical,
+        });
+    }
+    try {
+        const emission = adapter.emit(resolved.canonical, { criticality: args.criticality ?? {} });
+        return ok(`Compiled deterministic provider payload for "${args.provider}".`, {
+            status: "compiled",
+            provider: args.provider,
+            warnings: emission.warnings,
+            canonical: resolved.canonical,
+            emission,
+        });
+    }
+    catch (e) {
+        const failure = runtimeError(e);
+        return toolFail(failure);
+    }
+}
+export function runDraftAesthetic(_ctx, args) {
+    const overrides = args.overrides === undefined ? undefined : parseDocument(args.overrides);
+    if (overrides !== undefined && maybeFail(overrides))
+        return toolFail(overrides);
+    try {
+        const options = {};
+        if (args.modifiers !== undefined)
+            options.modifiers = args.modifiers;
+        if (overrides !== undefined)
+            options.overrides = overrides;
+        const document = createComposition(args.id, args.base, options);
+        return ok(`Drafted aesthetic "${args.id}".`, { kind: "composition", id: args.id, document });
+    }
+    catch (e) {
+        const failure = runtimeError(e);
+        return toolFail(failure);
+    }
+}
+export function runSaveAesthetic(ctx, args) {
+    const disabled = writeDisabled(ctx);
+    if (disabled !== undefined)
+        return toolFail(disabled);
+    const draft = runDraftAesthetic(ctx, args);
+    if (draft.isError === true)
+        return draft;
+    const document = draft.structuredContent?.document;
+    if (document === undefined)
+        return fail("invalid_document", "Drafted aesthetic did not produce a document.");
+    const validation = validateForSave(ctx, document, "composition");
+    if (validation !== undefined)
+        return toolFail(validation);
+    try {
+        saveProjectDocument(ctx.registryDir, "composition", document);
+        reloadContext(ctx);
+        return ok(`Saved aesthetic "${args.id}".`, { kind: "composition", id: args.id, document });
+    }
+    catch (e) {
+        return toolFail(runtimeError(e));
+    }
+}
+export function runSaveRegistryDocument(ctx, args) {
+    const disabled = writeDisabled(ctx);
+    if (disabled !== undefined)
+        return toolFail(disabled);
+    const document = parseDocument(args.document);
+    if (maybeFail(document))
+        return toolFail(document);
+    const validation = validateForSave(ctx, document, args.kind);
+    if (validation !== undefined)
+        return toolFail(validation);
+    try {
+        if (args.kind === "capability-manifest") {
+            const manifest = document;
+            saveCapabilityManifest(ctx.registryDir, manifest);
+            reloadContext(ctx);
+            return ok(`Saved capability manifest "${manifest.provider}".`, { kind: args.kind, id: manifest.provider, document });
+        }
+        saveProjectDocument(ctx.registryDir, args.kind, document);
+        reloadContext(ctx);
+        return ok(`Saved ${args.kind} "${String(document.id)}".`, { kind: args.kind, id: document.id, document });
+    }
+    catch (e) {
+        return toolFail(runtimeError(e));
+    }
+}
+export function runDeleteRegistryDocument(ctx, args) {
+    const disabled = writeDisabled(ctx);
+    if (disabled !== undefined)
+        return toolFail(disabled);
+    try {
+        if (args.kind === "capability-manifest") {
+            const deleted = deleteCapabilityManifest(ctx.registryDir, args.id);
+            reloadContext(ctx);
+            return ok(deleted ? `Deleted capability manifest "${args.id}".` : `Capability manifest "${args.id}" did not exist.`, {
+                kind: args.kind,
+                id: args.id,
+                deleted,
+            });
+        }
+        deleteProjectDocument(ctx.registryDir, args.kind, args.id);
+        reloadContext(ctx);
+        return ok(`Deleted ${args.kind} "${args.id}" if it existed.`, { kind: args.kind, id: args.id, deleted: true });
+    }
+    catch (e) {
+        return toolFail(runtimeError(e));
+    }
+}
+export function runWriteMergeStrategies(ctx, args) {
+    const disabled = writeDisabled(ctx);
+    if (disabled !== undefined)
+        return toolFail(disabled);
+    try {
+        writeMergeStrategies(ctx.registryDir, args.merge_strategies);
+        reloadContext(ctx);
+        return ok("Saved merge strategies.", { merge_strategies: args.merge_strategies });
+    }
+    catch (e) {
+        return toolFail(runtimeError(e));
+    }
+}
+export function errorCodeFromResult(result) {
+    const code = result.structuredContent?.error;
+    return typeof code === "string" ? code : undefined;
+}

package/dist/tools/compile-generation.d.ts

@@ -0,0 +1,12 @@
+import { type CapabilityManifest, type Criticality, type MergeStrategies, type Registry } from "@mosvera/runtime";
+import type { CompileResultMcp, ToolContext } from "../types.ts";
+export interface CompileArgs {
+    composition: object | string;
+    provider: string;
+    registry?: Registry;
+    manifest?: CapabilityManifest;
+    criticality?: Record<string, Criticality>;
+    merge_strategies?: MergeStrategies;
+    emit?: boolean;
+}
+export declare function runCompileGeneration(ctx: ToolContext, args: CompileArgs): CompileResultMcp;

package/dist/tools/compile-generation.js

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// compile_generation tool handler. Resolves a composition, then runs the
+// MEP-0003 compilation contract (compile) against a provider capability
+// manifest sourced inline, from the loaded registry, or from an injected Phase
+// 4 adapter. When emit=true and an adapter is available, returns the
+// deterministic provider payload emission. No provider HTTP call is made.
+import { compile, parse, resolveComposition, } from "@mosvera/runtime";
+import { EmissionError } from "@mosvera/provider-base";
+import { invalidDocument, isResolutionError, mapResolutionError, toolError } from "../errors.js";
+import { collectMissingReferences } from "../registry/preflight.js";
+import { composeStrategies, mergeRegistry } from "../registry/strategies.js";
+export function runCompileGeneration(ctx, args) {
+    let composition;
+    try {
+        composition = parse(args.composition);
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        return invalidDocument([{ path: "", message: `parse error: ${message}` }]);
+    }
+    const cv = ctx.validator.validate(composition, "composition");
+    if (!cv.valid)
+        return invalidDocument(cv.errors);
+    const registry = mergeRegistry(ctx.project.registry, args.registry);
+    const missing = collectMissingReferences(composition, registry);
+    if (missing.length > 0) {
+        return toolError("unknown_reference", { missing });
+    }
+    const adapter = ctx.adapters?.[args.provider];
+    const manifest = args.manifest ?? ctx.project.manifests[args.provider] ?? adapter?.manifest();
+    if (manifest === undefined) {
+        return toolError("unknown_provider", { provider: args.provider });
+    }
+    const mv = ctx.validator.validate(manifest, "capability-manifest");
+    if (!mv.valid)
+        return invalidDocument(mv.errors);
+    const strategies = composeStrategies(ctx.baseStrategies, args.merge_strategies);
+    let canonical;
+    try {
+        canonical = resolveComposition(composition, registry, strategies);
+    }
+    catch (e) {
+        if (isResolutionError(e))
+            return mapResolutionError(e);
+        throw e;
+    }
+    const result = compile(canonical, manifest, args.criticality ?? {});
+    if (result.status === "error") {
+        return { status: "error", error: result.error, construct: result.construct, canonical };
+    }
+    if (args.emit === true) {
+        if (adapter === undefined) {
+            return toolError("unknown_provider", { provider: args.provider, adapter: "missing" });
+        }
+        try {
+            return { status: "compiled", canonical, emission: adapter.emit(canonical, { criticality: args.criticality ?? {} }) };
+        }
+        catch (e) {
+            if (e instanceof EmissionError) {
+                return { status: "error", error: e.error, construct: e.construct, canonical };
+            }
+            throw e;
+        }
+    }
+    return { status: "compiled", warnings: result.warnings, canonical };
+}

package/dist/tools/get-palette.d.ts

@@ -0,0 +1,11 @@
+import type { JsonObject, Registry } from "@mosvera/runtime";
+import type { ToolContext, ToolError } from "../types.ts";
+export interface GetPaletteArgs {
+    name: string;
+    registry?: Registry;
+}
+export type GetPaletteResult = {
+    palette: JsonObject;
+    inheritance_unresolved?: true;
+} | ToolError;
+export declare function runGetPalette(ctx: ToolContext, args: GetPaletteArgs): GetPaletteResult;

package/dist/tools/get-palette.js

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// get_palette tool handler. Returns the named palette as stored (schema-
+// validated). Palette $extends resolution is deferred at v0.1 (design spec
+// D4): if the palette declares $extends, the response carries
+// inheritance_unresolved:true so a consumer is never silently misled.
+import { invalidDocument, toolError } from "../errors.js";
+import { mergeRegistry } from "../registry/strategies.js";
+export function runGetPalette(ctx, args) {
+    const reg = mergeRegistry(ctx.project.registry, args.registry);
+    const palettes = reg.palettes ?? {};
+    if (!(args.name in palettes)) {
+        return toolError("unknown_reference", { name: args.name });
+    }
+    const palette = palettes[args.name];
+    const res = ctx.validator.validate(palette, "palette");
+    if (!res.valid)
+        return invalidDocument(res.errors);
+    if (typeof palette["$extends"] === "string") {
+        return { palette, inheritance_unresolved: true };
+    }
+    return { palette };
+}