summer-engine 2.8.2 → 3.0.0

package/dist/mcp/server.d.ts

@@ -1,10 +1,30 @@
-import { EngineApiClient } from "../lib/api-client.js";
-import type { EngineSelection } from "../lib/engine.js";
-import { getCachedBootDriftNotice as getCachedNotice } from "../lib/mcp-boot-notice.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { EngineApiClient } from "../core/api-client.js";
+import type { EngineSelection } from "../core/engine.js";
+import { getCachedBootDriftNotice as getCachedNotice } from "./boot-notice.js";
 export declare const getCachedBootDriftNotice: typeof getCachedNotice;
+/**
+ * Server `instructions` in the MCP initialize response (SDK ServerOptions,
+ * @modelcontextprotocol/sdk >= 1.x). Hosts hand this to the model once per
+ * session, before any tool call — the place for the five habits the E2E run
+ * (docs/design/archive/E2E-2026-09-03.md, F-17) showed an agent needs on the first
+ * turn and would otherwise learn the hard way. Kept under 600 characters so
+ * it costs a few hundred tokens once; the full operating guide stays in the
+ * summer_agent_playbook prompt / summer_get_agent_playbook tool.
+ */
+export declare const SUMMER_MCP_INSTRUCTIONS: string;
 export declare function configureMcpEngineSelection(selection?: EngineSelection): void;
 export declare function getClient(): Promise<EngineApiClient>;
 export declare function resetClient(): void;
+/**
+ * Build the MCP server with every Summer tool registered, without connecting
+ * a transport. startMcpServer() uses this; tests use it to count the live
+ * tool surface against registry/generated/counts.json.
+ */
+export declare function createMcpServer(): {
+    server: McpServer;
+    getRegisteredToolCount: () => number;
+};
 export interface StartMcpServerOptions {
     projectPath?: string;
     instanceId?: string;

package/dist/mcp/server.js

@@ -1,24 +1,46 @@
-import { createRequire } from "node:module";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { EngineApiClient } from "../lib/api-client.js";
+import { EngineApiClient } from "../core/api-client.js";
 import { registerSceneTools } from "./tools/scene-tools.js";
 import { registerDebugTools } from "./tools/debug-tools.js";
 import { registerVisualTools } from "./tools/visual-tools.js";
 import { WITH_ENGINE_META } from "./tools/with-engine.js";
-import { registerProjectTools } from "./tools/project-tools.js";
+import { registerPlaybookPrompt, registerProjectTools, } from "./tools/project-tools.js";
+import { registerPerceptionTools } from "./tools/perception-tools.js";
+import { registerSpatialTools } from "./tools/spatial-tools.js";
+import { registerScriptTools } from "./tools/script-tools.js";
+import { registerEventTools } from "./tools/event-tools.js";
+import { registerFabricateTools } from "./tools/fabricate-tools.js";
+import { registerUiTools } from "./tools/ui-tools.js";
+import { registerRuntimeTools } from "./tools/runtime-tools.js";
+import { recordToolCall, registrationHasInputSchema, trajectoryArgsFor, } from "../core/trajectory.js";
 import { registerFileTools } from "./tools/file-tools.js";
 import { registerAssetTools } from "./tools/asset-tools.js";
 import { registerGenerateTools } from "./tools/generate-tools.js";
-import { registerCloudTools } from "./tools/cloud-tools.js";
 import { registerCreatorTools } from "./tools/creator-tools.js";
-import { getCachedBootDriftNotice as getCachedNotice, setCachedBootDriftNotice, } from "../lib/mcp-boot-notice.js";
-import { appendMcpLogEvent } from "../lib/mcp-log.js";
-import { buildBootDriftNotice, fetchLatestRegistryVersion, } from "../lib/version-check.js";
-const require = createRequire(import.meta.url);
-const { version } = require("../../package.json");
+import { registerFeedbackTools } from "./tools/feedback-tools.js";
+import { registerNavigationTools } from "./tools/navigation-tools.js";
+import { registerLibraryTools } from "./tools/library-tools.js";
+import { getCachedBootDriftNotice as getCachedNotice, setCachedBootDriftNotice, } from "./boot-notice.js";
+import { appendMcpLogEvent } from "../core/mcp-log.js";
+import { buildBootDriftNotice, fetchLatestRegistryVersion, } from "../installer/version-check.js";
+import { TOOLKIT_VERSION as version } from "../core/version.js";
 let processDiagnosticsInstalled = false;
 export const getCachedBootDriftNotice = getCachedNotice;
+/**
+ * Server `instructions` in the MCP initialize response (SDK ServerOptions,
+ * @modelcontextprotocol/sdk >= 1.x). Hosts hand this to the model once per
+ * session, before any tool call — the place for the five habits the E2E run
+ * (docs/design/archive/E2E-2026-09-03.md, F-17) showed an agent needs on the first
+ * turn and would otherwise learn the hard way. Kept under 600 characters so
+ * it costs a few hundred tokens once; the full operating guide stays in the
+ * summer_agent_playbook prompt / summer_get_agent_playbook tool.
+ */
+export const SUMMER_MCP_INSTRUCTIONS = "Summer Engine MCP. Call summer_get_project_context first: it binds this session to the open project and returns mainScene, projectMemory (GameSoul, template pin) and any capabilitySkewWarning. " +
+    "Before building or fixing, summer_search_library then summer_read_library the hit — skills, examples and templates live there. " +
+    "After a playthrough read summer_get_diagnostics, not summer_get_console alone (runtime errors live in the debugger). " +
+    "A uniformly black screenshot means the viewport had not redrawn — recapture before concluding. " +
+    "Report entries you verified in-engine via summer_library_feedback.";
 /**
  * Fire-and-forget probe of the npm registry on MCP boot. Caches the result for
  * the session. We never await this in startup so a slow / offline registry
@@ -38,6 +60,18 @@ export function configureMcpEngineSelection(selection) {
     cachedClient = null;
 }
 export async function getClient() {
+    // Opt-in per-project routing (editor -> live worker -> spawned worker).
+    // OFF by default: with the flag unset this block is skipped entirely and
+    // src/core/headless/ is never even loaded (dynamic import). With the flag
+    // set, the router returns null whenever the existing path should serve the
+    // call (no project context, or a live editor has the project open), so
+    // editor behavior stays identical. See docs/HEADLESS_ROUTING.md.
+    if (process.env.SUMMER_HEADLESS_ROUTING === "1") {
+        const { getHeadlessRoutedClient } = await import("../core/headless/mcp-routing.js");
+        const routed = await getHeadlessRoutedClient(engineSelection);
+        if (routed)
+            return routed;
+    }
     if (cachedClient) {
         // The engine rotates its api-token (and can change ports) on every launch, so
         // a cached client can outlive the engine instance it was built for. If the
@@ -61,10 +95,10 @@ export async function getClient() {
             ? error.message
             : "Summer Engine is not running.";
         throw new Error(reason + "\n" +
-            "Open the intended project in Summer Engine, or run: npx summer-engine run\n" +
+            "Open the intended project in Summer Engine, or run: npx -y summer-engine@latest run\n" +
             "Note: only tools that touch the local project need the engine. Cloud tools " +
             "(summer_generate_*, summer_search_assets, summer_list_my_assets, summer_get_asset, " +
-            "summer_check_job) work right now without it — they only need 'npx summer-engine login'.");
+            "summer_check_job) work right now without it — they only need 'npx -y summer-engine@latest login'.");
     }
 }
 export function resetClient() {
@@ -141,11 +175,50 @@ function installResultSizeLogger(server) {
         if (typeof handler !== "function")
             return original(...args);
         registeredToolCount += 1;
+        // Schema-less tools receive only the SDK's `extra` — never record that as
+        // the tool's arguments (see registrationHasInputSchema).
+        const hasInputSchema = registrationHasInputSchema(args);
         const wrapped = async (...handlerArgs) => {
             const startedAt = Date.now();
-            const result = await handler(...handlerArgs);
+            let result;
+            try {
+                result = await handler(...handlerArgs);
+            }
+            catch (error) {
+                // A handler THROW never produced a result to classify; record it as
+                // ok:false / exception so the stream does not silently skip failures,
+                // then let the SDK turn it into the protocol error it always did.
+                recordToolCall({
+                    tool: name,
+                    args: trajectoryArgsFor(hasInputSchema, handlerArgs),
+                    exception: error instanceof Error ? error.message : String(error),
+                    durationMs: Date.now() - startedAt,
+                });
+                throw error;
+            }
             const durationMs = Date.now() - startedAt;
             try {
+                // Opt-in local trajectory capture: one JSONL line per tool call when
+                // SUMMER_TRAJECTORY_DIR is set. recordToolCall never throws and is a
+                // no-op when the env var is unset.
+                {
+                    const record = result;
+                    const callMeta = record && typeof record === "object"
+                        ? record[WITH_ENGINE_META]
+                        : undefined;
+                    recordToolCall({
+                        tool: name,
+                        args: trajectoryArgsFor(hasInputSchema, handlerArgs),
+                        isError: record?.isError === true,
+                        terminalState: callMeta?.terminalState,
+                        errorClass: callMeta?.errorClass,
+                        failureReason: callMeta?.failureReason,
+                        durationMs,
+                        // Read only under SUMMER_TRAJECTORY_EVAL=1 (bounded summary); the
+                        // default redacted stream ignores it.
+                        result,
+                    });
+                }
                 if (result &&
                     typeof result === "object" &&
                     "content" in result &&
@@ -213,6 +286,42 @@ function installResultSizeLogger(server) {
     };
     return () => registeredToolCount;
 }
+/**
+ * Build the MCP server with every Summer tool registered, without connecting
+ * a transport. startMcpServer() uses this; tests use it to count the live
+ * tool surface against registry/generated/counts.json.
+ */
+export function createMcpServer() {
+    const server = new McpServer({
+        name: "summer-engine",
+        version,
+    }, { instructions: SUMMER_MCP_INSTRUCTIONS });
+    // Passive observability: log result-size to stderr but do not modify
+    // results. See installResultSizeLogger above.
+    const getRegisteredToolCount = installResultSizeLogger(server);
+    registerSceneTools(server);
+    registerDebugTools(server);
+    registerVisualTools(server);
+    registerProjectTools(server);
+    registerFileTools(server);
+    registerAssetTools(server);
+    registerGenerateTools(server);
+    registerCreatorTools(server);
+    registerFeedbackTools(server);
+    registerScriptTools(server);
+    registerPerceptionTools(server);
+    registerSpatialTools(server);
+    registerNavigationTools(server);
+    registerLibraryTools(server);
+    registerEventTools(server);
+    registerFabricateTools(server);
+    registerUiTools(server);
+    registerRuntimeTools(server);
+    // The playbook is also an MCP prompt so prompt-surfacing hosts get it
+    // natively (same content as the summer_get_agent_playbook tool).
+    registerPlaybookPrompt(server);
+    return { server, getRegisteredToolCount };
+}
 export async function startMcpServer(options = {}) {
     configureMcpEngineSelection({
         instanceId: options.instanceId ?? process.env.SUMMER_ENGINE_INSTANCE_ID,
@@ -231,22 +340,7 @@ export async function startMcpServer(options = {}) {
             cwd: options.cwd ?? process.cwd(),
         },
     });
-    const server = new McpServer({
-        name: "summer-engine",
-        version,
-    });
-    // Passive observability: log result-size to stderr but do not modify
-    // results. See installResultSizeLogger above.
-    const getRegisteredToolCount = installResultSizeLogger(server);
-    registerSceneTools(server);
-    registerDebugTools(server);
-    registerVisualTools(server);
-    registerProjectTools(server);
-    registerFileTools(server);
-    registerAssetTools(server);
-    registerGenerateTools(server);
-    registerCloudTools(server);
-    registerCreatorTools(server);
+    const { server, getRegisteredToolCount } = createMcpServer();
     // Fire-and-forget — never block tool registration on the npm registry.
     void probeBootDrift().catch((error) => {
         setCachedBootDriftNotice(null);

package/dist/mcp/tools/asset-tools.js

@@ -1,51 +1,15 @@
 import { z } from "zod";
-import { getAuthToken } from "../../lib/auth.js";
+import { getAuthToken } from "../../core/auth.js";
+import { resolveGatewayUrl } from "../../core/config.js";
 import { getClient } from "../server.js";
-const GATEWAY_URL = process.env.SUMMER_GATEWAY_URL || "https://www.summerengine.com";
-/** Kenney Cloudinary URL pattern: .../summer_art/kenney/3d/{pack-slug}/{filename}.glb */
-const KENNEY_URL_PATTERN = /\/kenney\/3d\/([^/]+)\//;
-function getPackSlugFromUrl(fileUrl) {
-    return fileUrl.match(KENNEY_URL_PATTERN)?.[1] ?? null;
-}
-function buildKenneyTextureUrl(fileUrl) {
-    const lastSlash = fileUrl.lastIndexOf("/");
-    const base = lastSlash >= 0 ? fileUrl.slice(0, lastSlash) : fileUrl;
-    return `${base}/Textures/colormap.png`;
-}
-async function textureExists(url) {
-    try {
-        const res = await fetch(url, { method: "HEAD", signal: AbortSignal.timeout(5000) });
-        return res.ok;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Build import entries for Kenney 3D assets: texture first, then GLB.
- * Pack-scoped paths prevent texture collision (each pack has its own Textures/colormap.png).
- * See: publicsummerengine/Docs/ASSET_IMPORT_END_TO_END.md
- */
-async function buildKenneyImportEntries(fileUrl, packSlug, fileName) {
-    const textureUrl = buildKenneyTextureUrl(fileUrl);
-    const hasTexture = await textureExists(textureUrl);
-    if (!hasTexture) {
-        return [{ url: fileUrl, path: `res://assets/models/kenney/${packSlug}/${fileName}` }];
-    }
-    const glbPath = `res://assets/models/kenney/${packSlug}/${fileName}`;
-    const glbDir = glbPath.replace(/\/[^/]+$/, "");
-    const texturePath = `${glbDir}/Textures/colormap.png`;
-    return [
-        { url: textureUrl, path: texturePath },
-        { url: fileUrl, path: glbPath },
-    ];
-}
+import { ImportHdriError, importPolyHavenHdri, } from "../../core/capabilities/hdri-import.js";
+import { importResolvedAsset } from "../../core/capabilities/asset-import.js";
 async function searchAssetsApi(params) {
     const token = await getAuthToken();
     if (!token) {
         return {
             error: "Not logged in",
-            message: "Not signed in. The user needs to run this in their terminal:\n  npx summer-engine login\nOr open: https://www.summerengine.com/login\nAsset search requires a Summer Engine account (free to create).",
+            message: "Not signed in. The user needs to run this in their terminal:\n  npx -y summer-engine@latest login\nOr open: https://www.summerengine.com/login\nAsset search requires a Summer Engine account (free to create).",
         };
     }
     const searchParams = new URLSearchParams();
@@ -59,7 +23,8 @@ async function searchAssetsApi(params) {
     if (params.source) {
         searchParams.set("source", params.source);
     }
-    const res = await fetch(`${GATEWAY_URL}/api/mcp/assets?${searchParams}`, {
+    const gatewayUrl = await resolveGatewayUrl();
+    const res = await fetch(`${gatewayUrl}/api/mcp/assets?${searchParams}`, {
         headers: { Authorization: `Bearer ${token}` },
         signal: AbortSignal.timeout(15000),
     });
@@ -69,7 +34,7 @@ async function searchAssetsApi(params) {
             return {
                 error: "unauthorized",
                 message: (data.message || "Auth token expired.") +
-                    " The user needs to re-authenticate:\n  npx summer-engine login --force",
+                    " The user needs to re-authenticate:\n  npx -y summer-engine@latest login --force",
             };
         }
         if (res.status === 429) {
@@ -92,10 +57,11 @@ async function authedGetJson(endpoint, timeoutMs = 15_000) {
         return {
             status: 401,
             error: "not_logged_in",
-            message: "Not signed in. Run in your terminal:\n  npx summer-engine login",
+            message: "Not signed in. Run in your terminal:\n  npx -y summer-engine@latest login",
         };
     }
-    const res = await fetch(`${GATEWAY_URL}${endpoint}`, {
+    const gatewayUrl = await resolveGatewayUrl();
+    const res = await fetch(`${gatewayUrl}${endpoint}`, {
         headers: { Authorization: `Bearer ${token}` },
         signal: AbortSignal.timeout(timeoutMs),
     });
@@ -124,99 +90,6 @@ async function getAssetDownloadUrlApi(assetId, role) {
     }
     return { data: result.data };
 }
-function fileNameFromUrl(fileUrl) {
-    return fileUrl.split("/").pop()?.split("?")[0] || "asset";
-}
-function sanitizeNodeName(name) {
-    return ((name || "Asset")
-        .replace(/[^\p{L}\p{N}_]+/gu, "_")
-        .replace(/^_+|_+$/g, "") || "Asset");
-}
-async function buildImportEntriesForAsset(asset, targetPath) {
-    const fileUrl = asset.importUrl || asset.fileUrl;
-    if (!fileUrl)
-        throw new Error("Asset has no import URL.");
-    const fileName = targetPath?.split("/").pop() || asset.fileName || fileNameFromUrl(fileUrl);
-    const packSlug = asset.packSlug ?? getPackSlugFromUrl(fileUrl) ?? "misc";
-    if (targetPath) {
-        if (asset.type === "3d_model" && fileUrl.includes("kenney/3d/")) {
-            const textureUrl = buildKenneyTextureUrl(fileUrl);
-            const hasTexture = await textureExists(textureUrl);
-            if (hasTexture) {
-                const glbDir = targetPath.replace(/\/[^/]+$/, "");
-                return {
-                    importPath: targetPath,
-                    imports: [
-                        { url: textureUrl, path: `${glbDir}/Textures/colormap.png` },
-                        { url: fileUrl, path: targetPath },
-                    ],
-                };
-            }
-        }
-        return {
-            importPath: targetPath,
-            imports: [{ url: fileUrl, path: targetPath }],
-        };
-    }
-    if (asset.type === "3d_model" && fileUrl.includes("kenney/3d/")) {
-        const imports = await buildKenneyImportEntries(fileUrl, packSlug, fileName);
-        return { imports, importPath: imports[imports.length - 1].path };
-    }
-    const path = asset.type === "3d_model"
-        ? `res://assets/models/${fileName}`
-        : `res://assets/${fileName}`;
-    return { imports: [{ url: fileUrl, path }], importPath: path };
-}
-async function importResolvedAsset(args) {
-    const { asset, parent, scenePath, path, name } = args;
-    if (parent && !scenePath) {
-        throw new Error("scenePath is required when importing an asset into a scene");
-    }
-    const { imports, importPath } = await buildImportEntriesForAsset(asset, path);
-    const client = await getClient();
-    const importResult = imports.length === 1
-        ? await client.executeOps([
-            { op: "ImportFromUrl", url: imports[0].url, path: imports[0].path },
-        ])
-        : await client.executeOps([{ op: "ImportFromUrlBatch", imports }]);
-    const importReceipts = importResult?.results ?? [];
-    const importFailure = importReceipts.find((receipt) => receipt?.ok === false);
-    if (importResult?.status === "error" || importFailure) {
-        throw new Error(importFailure?.error || "Could not import asset. Check engine logs.");
-    }
-    let addedToScene = false;
-    let sceneReceipt = null;
-    if (parent && asset.type === "3d_model") {
-        sceneReceipt = await client.executeIdentityBoundOps([
-            {
-                op: "InstantiateScene",
-                parent,
-                scene: importPath,
-                name: sanitizeNodeName(name || asset.title),
-            },
-            { op: "SaveScene" },
-        ], { scenePath });
-        const placementReceipts = sceneReceipt?.results ?? [];
-        const placementFailure = placementReceipts.find((receipt) => receipt?.ok !== true);
-        if (sceneReceipt?.status === "error" ||
-            placementReceipts.length !== 2 ||
-            placementFailure) {
-            throw new Error(placementFailure?.error || `Could not add asset to ${scenePath}`);
-        }
-        addedToScene = true;
-    }
-    return {
-        success: true,
-        assetId: asset.id,
-        asset: asset.title,
-        type: asset.type,
-        importedTo: importPath,
-        addedToScene,
-        parent: parent || null,
-        scenePath: scenePath || null,
-        sceneReceipt,
-    };
-}
 function jsonSuccess(data) {
     return {
         content: [
@@ -250,7 +123,7 @@ Uses hybrid search: keywords + semantic similarity. Finds assets by name AND by
 Returns asset names, types, preview URLs, and import-ready file URLs.
 
 Cloud tool — works WITHOUT the Summer Engine app open.
-Requires authentication (so we can attribute usage and apply per-user rate limits): run 'npx summer-engine login' first.`, {
+Requires authentication (so we can attribute usage and apply per-user rate limits): run 'npx -y summer-engine@latest login' first.`, {
         query: z.string().describe("Natural language search, e.g. 'low-poly tree', 'sci-fi weapon'. For my_assets, can be empty to list recent."),
         assetType: z.enum(["2d_image", "animation", "3d_model", "audio", "music", "all"]).default("all").describe("Filter by asset type"),
         limit: z.number().default(10).describe("Max results (1-20)"),
@@ -391,7 +264,7 @@ itself does not — only this import step does).`, {
             });
         }
         try {
-            const imported = await importResolvedAsset({
+            const imported = await importResolvedAsset(await getClient(), {
                 asset: fetched.asset,
                 parent,
                 scenePath,
@@ -419,7 +292,7 @@ itself does not — only this import step does).`, {
 Use when the user wants a specific type of asset added: "Add a tree to the scene", "Import a wooden barrel".
 Searches, picks the top result, downloads and imports it, then optionally adds it to the scene.
 
-Requires authentication. If the user gets an auth error, they need to run 'npx summer-engine login' in their terminal first. Summer Engine must be running.`, {
+Requires authentication. If the user gets an auth error, they need to run 'npx -y summer-engine@latest login' in their terminal first. Summer Engine must be running.`, {
         query: z.string().describe("What to find, e.g. 'low-poly tree', 'wooden crate'"),
         parent: z.string().optional().describe("Parent node path to add the asset under, e.g. './World'. If omitted, only imports (no scene placement)"),
         scenePath: z.string().optional().describe("Required with parent. Exact res:// target scene path."),
@@ -464,7 +337,7 @@ Requires authentication. If the user gets an auth error, they need to run 'npx s
             };
         }
         try {
-            const imported = await importResolvedAsset({ asset: best, parent, scenePath });
+            const imported = await importResolvedAsset(await getClient(), { asset: best, parent, scenePath });
             // 2D sprites and audio: import only; user adds to scene manually
             return {
                 content: [
@@ -503,4 +376,51 @@ Requires authentication. If the user gets an auth error, they need to run 'npx s
             };
         }
     });
+    server.tool("summer_import_hdri", `Search Poly Haven's CC0 HDRI library and import one as environment lighting.
+
+The single cheapest visual-quality upgrade for a 3D scene: a real HDRI sky lights
+and reflects the whole world. Searches ~1,000 CC0 HDRIs on Poly Haven's public API
+(no account, no key), downloads the .hdr/.exr through the engine's import pipeline
+into res://sky/, and returns a ready-to-run summer_run_script snippet that wires it
+into the WorldEnvironment (PanoramaSkyMaterial + sky ambient/reflections).
+
+Pass query ("sunset beach", "night city", "studio") to search, or assetId for an
+exact Poly Haven id. resolution 2k is right for most games; 4k for hero skies.
+All results are CC0 — no attribution required.
+
+Requires the Summer Engine app to be open with the project loaded (the download
+runs through the engine). No Summer login needed.`, {
+        query: z
+            .string()
+            .optional()
+            .describe("What kind of sky/environment, e.g. 'sunset beach', 'overcast field', 'studio'. Omit when assetId is given."),
+        assetId: z
+            .string()
+            .optional()
+            .describe("Exact Poly Haven asset id (lowercase slug, e.g. 'kloppenheim_02'). Skips the search."),
+        resolution: z
+            .enum(["1k", "2k", "4k"])
+            .default("2k")
+            .describe("HDRI resolution. 2k (default) is right for most games; 4k for hero skies; 1k for quick blockouts."),
+    }, async ({ query, assetId, resolution }) => {
+        try {
+            const result = await importPolyHavenHdri({ query, assetId, resolution: resolution }, () => getClient());
+            return jsonSuccess(result);
+        }
+        catch (err) {
+            if (err instanceof ImportHdriError) {
+                return jsonError({
+                    error: err.code,
+                    message: err.message,
+                    ...(err.hint ? { hint: err.hint } : {}),
+                });
+            }
+            const msg = err instanceof Error ? err.message : String(err);
+            return jsonError({
+                error: "hdri_import_failed",
+                message: msg,
+                hint: "Poly Haven may be unreachable, or Summer Engine is not running.",
+            });
+        }
+    });
 }

package/dist/mcp/tools/creator-tools.js

@@ -1,17 +1,7 @@
 import { z } from "zod";
-import { CreatorOperationError, listCreatorReleases, publishCreator, readCreatorLogs, } from "../../lib/creator.js";
-import { CONFIG_KEYS, getConfigValue, isConfigKey, readSummerConfig, setConfigValue, unsetConfigValue, } from "../../lib/config.js";
-function textJson(value, isError = false) {
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify(value, null, 2),
-            },
-        ],
-        ...(isError ? { isError: true } : {}),
-    };
-}
+import { CreatorOperationError, listCreatorReleases, publishCreator, } from "../../core/capabilities/creator.js";
+import { CONFIG_KEYS, getConfigValue, isConfigKey, readSummerConfig, setConfigValue, unsetConfigValue, } from "../../core/config.js";
+import { textJson } from "./text-json.js";
 async function creatorResult(operation) {
     try {
         return textJson(await operation());
@@ -34,7 +24,7 @@ async function creatorResult(operation) {
     }
 }
 export function registerCreatorTools(server) {
-    server.tool("summer_creator_publish", "Publish an exact exported Summer .pck through the versioned Summercraft creator API. First call with confirm=false and present the returned project, version, digest, size, artifact path, channel, and notes; set confirm only after the user approves that exact target. The server independently verifies token scope, ownership, bytes, and review state.", {
+    server.tool("summer_creator_publish", "Publish an exact exported Summer .pck through the versioned Summer Platform creator API. First call with confirm=false and present the returned project, version, digest, size, artifact path, channel, and notes; set confirm only after the user approves that exact target. The server independently verifies token scope, ownership, bytes, and review state.", {
         project: z.string().optional().describe("Project root. Defaults to the current working directory."),
         artifact: z.string().describe("Exact path to the exported Summer .pck artifact."),
         version: z.string().describe("Immutable release version."),
@@ -47,7 +37,7 @@ export function registerCreatorTools(server) {
         ...args,
         face: "mcp",
     })));
-    server.tool("summer_creator_releases", "List real creator-owned releases from the versioned Summercraft creator API. The server independently verifies the exact publish scope and project ownership.", {
+    server.tool("summer_creator_releases", "List real creator-owned releases from the versioned Summer Platform creator API. The server independently verifies the exact publish scope and project ownership.", {
         projectId: z.string().optional().describe("Creator project ID. Defaults to ~/.summer/config.json."),
         limit: z.number().int().min(1).max(100).default(20),
         cursor: z.string().optional().describe("Opaque nextCursor from the previous page."),
@@ -55,14 +45,6 @@ export function registerCreatorTools(server) {
         ...args,
         face: "mcp",
     })));
-    server.tool("summer_creator_logs", "Read creator runtime logs for a project or release. If the required platform route or token scope is unavailable, returns the exact recovery action instead of placeholder logs.", {
-        projectId: z.string().optional().describe("Creator project ID. Defaults to ~/.summer/config.json."),
-        releaseId: z.string().optional().describe("Optional release ID."),
-        limit: z.number().int().min(1).max(1000).default(100),
-    }, async (args) => creatorResult(() => readCreatorLogs({
-        ...args,
-        face: "mcp",
-    })));
     server.tool("summer_creator_config", "Read or update the shared non-secret ~/.summer configuration used by the CLI and this MCP. Mutations require confirm=true. Tokens are never returned or accepted by this tool.", {
         action: z.enum(["list", "get", "set", "unset"]),
         key: z.enum(CONFIG_KEYS).optional(),