summer-engine 3.2.1 → 3.3.0

package/dist/mcp/hosted-mount.d.ts

@@ -0,0 +1,96 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type Tool } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * One Summer Engine MCP. The cloud tools a creator's agent needs to publish
+ * (projects, store page, build upload, submit for the owner's approval, the
+ * board, Grow) live on the hosted Summer Engine MCP at mcp.summerengine.com,
+ * the same server ChatGPT and Claude connect to. This module mounts them into
+ * the local MCP so a local agent sees one server: each hosted tool, prompt
+ * and resource is registered here under its own name and forwarded with the
+ * person's store sign-in ("summer login --store"; the token's audience is
+ * that server). A name the local MCP already has stays local (the engine and
+ * generation tools keep their CLI-token path).
+ *
+ * Mounting is lazy: the server answers with the engine tools at once, and the
+ * hosted tools appear when the mount finishes (tools/list_changed). Without a
+ * store sign-in one tool, summer_store_tools, says how to sign in and mounts
+ * on the next call.
+ */
+export declare const STORE_TOOLS_STATUS = "summer_store_tools";
+/** The part of an MCP client the mount uses (a fake in tests). */
+export interface HostedClient {
+    listTools(params?: {
+        cursor?: string;
+    }): Promise<{
+        tools: Tool[];
+        nextCursor?: string;
+    }>;
+    callTool(params: {
+        name: string;
+        arguments?: Record<string, unknown>;
+    }): Promise<Record<string, unknown>>;
+    listPrompts(params?: {
+        cursor?: string;
+    }): Promise<{
+        prompts: Array<{
+            name: string;
+            title?: string;
+            description?: string;
+            arguments?: Array<{
+                name: string;
+                description?: string;
+                required?: boolean;
+            }>;
+        }>;
+        nextCursor?: string;
+    }>;
+    getPrompt(params: {
+        name: string;
+        arguments?: Record<string, string>;
+    }): Promise<Record<string, unknown>>;
+    listResources(params?: {
+        cursor?: string;
+    }): Promise<{
+        resources: Array<{
+            uri: string;
+            name: string;
+            title?: string;
+            description?: string;
+            mimeType?: string;
+        }>;
+        nextCursor?: string;
+    }>;
+    readResource(params: {
+        uri: string;
+    }): Promise<Record<string, unknown>>;
+}
+export interface HostedMountDependencies {
+    /** The hosted Summer Engine MCP URL (the store sign-in's resource). */
+    url: () => string;
+    token: () => Promise<string>;
+    connect: (url: string, token: () => Promise<string>) => Promise<HostedClient>;
+}
+export declare const defaultHostedMountDependencies: HostedMountDependencies;
+export interface HostedMountState {
+    status: "idle" | "mounting" | "mounted" | "unavailable";
+    tools: string[];
+    prompts: string[];
+    resources: string[];
+    /** Hosted names the local MCP already defines (kept local). */
+    collisions: string[];
+    error?: {
+        code: string;
+        message: string;
+        recovery: string;
+    };
+}
+/**
+ * Get the server ready for hosted tools before the transport connects (the
+ * SDK fixes capabilities at connect): resource handlers exist, and tools/list
+ * reports each mounted tool's own JSON Schema rather than the passthrough one.
+ * Returns mount(), which callers run after connect without awaiting it.
+ */
+export declare function prepareHostedMount(server: McpServer, deps?: HostedMountDependencies): {
+    mount: () => Promise<HostedMountState>;
+    state: HostedMountState;
+};

package/dist/mcp/hosted-mount.js

@@ -0,0 +1,206 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { getStoreAccessToken, OAuthError, resolveMcpResourceUrl } from "../core/oauth.js";
+import { appendMcpLogEvent } from "../core/mcp-log.js";
+import { TOOLKIT_VERSION } from "../core/version.js";
+/**
+ * One Summer Engine MCP. The cloud tools a creator's agent needs to publish
+ * (projects, store page, build upload, submit for the owner's approval, the
+ * board, Grow) live on the hosted Summer Engine MCP at mcp.summerengine.com,
+ * the same server ChatGPT and Claude connect to. This module mounts them into
+ * the local MCP so a local agent sees one server: each hosted tool, prompt
+ * and resource is registered here under its own name and forwarded with the
+ * person's store sign-in ("summer login --store"; the token's audience is
+ * that server). A name the local MCP already has stays local (the engine and
+ * generation tools keep their CLI-token path).
+ *
+ * Mounting is lazy: the server answers with the engine tools at once, and the
+ * hosted tools appear when the mount finishes (tools/list_changed). Without a
+ * store sign-in one tool, summer_store_tools, says how to sign in and mounts
+ * on the next call.
+ */
+export const STORE_TOOLS_STATUS = "summer_store_tools";
+const CALL_TIMEOUT_MS = 120_000;
+const passthroughArgs = z.object({}).passthrough();
+export const defaultHostedMountDependencies = {
+    url: () => resolveMcpResourceUrl(),
+    token: () => getStoreAccessToken(),
+    connect: async (url, token) => {
+        const transport = new StreamableHTTPClientTransport(new URL(url), {
+            // A fresh (refreshed when near expiry) token on every request.
+            fetch: async (input, init) => {
+                const headers = new Headers(init?.headers);
+                headers.set("authorization", `Bearer ${await token()}`);
+                return fetch(input, { ...init, headers });
+            },
+        });
+        const client = new Client({ name: "summer-engine-local", version: TOOLKIT_VERSION });
+        await client.connect(transport);
+        const timeout = { timeout: CALL_TIMEOUT_MS };
+        return {
+            listTools: (params) => client.listTools(params),
+            callTool: (params) => client.callTool(params, undefined, timeout),
+            listPrompts: (params) => client.listPrompts(params),
+            getPrompt: (params) => client.getPrompt(params),
+            listResources: (params) => client.listResources(params),
+            readResource: (params) => client.readResource(params),
+        };
+    },
+};
+async function listAll(page, key) {
+    const out = [];
+    let cursor;
+    for (let pages = 0; pages < 20; pages++) {
+        const result = await page(cursor);
+        out.push(...(result[key] ?? []));
+        if (!result.nextCursor)
+            break;
+        cursor = result.nextCursor;
+    }
+    return out;
+}
+function errorText(error) {
+    return { content: [{ type: "text", text: JSON.stringify({ ok: false, ...error }) }], isError: true };
+}
+/**
+ * Get the server ready for hosted tools before the transport connects (the
+ * SDK fixes capabilities at connect): resource handlers exist, and tools/list
+ * reports each mounted tool's own JSON Schema rather than the passthrough one.
+ * Returns mount(), which callers run after connect without awaiting it.
+ */
+export function prepareHostedMount(server, deps = defaultHostedMountDependencies) {
+    const state = { status: "idle", tools: [], prompts: [], resources: [], collisions: [] };
+    const schemas = new Map();
+    const registries = server;
+    // Declare the resources capability now: registering one and removing it
+    // keeps the handlers (and capability) without listing anything yet.
+    server.registerResource("summer-hosted-placeholder", "summer://hosted/placeholder", {}, async () => ({ contents: [] })).remove();
+    // tools/list as the SDK builds it, with mounted tools carrying their hosted schema.
+    const handlers = server.server._requestHandlers;
+    const listTools = handlers.get("tools/list");
+    if (listTools) {
+        server.server.setRequestHandler(ListToolsRequestSchema, async (request, extra) => {
+            const result = await listTools(request, extra);
+            return {
+                ...result,
+                tools: result.tools.map((tool) => {
+                    const hosted = schemas.get(tool.name);
+                    return hosted ? { ...tool, inputSchema: hosted.inputSchema, ...(hosted.annotations ? { annotations: hosted.annotations } : {}), ...(hosted.title ? { title: hosted.title } : {}) } : tool;
+                }),
+            };
+        });
+    }
+    let statusTool = null;
+    let running = null;
+    const showStatusTool = () => {
+        if (statusTool || STORE_TOOLS_STATUS in registries._registeredTools)
+            return;
+        statusTool = server.registerTool(STORE_TOOLS_STATUS, {
+            description: "The Summer store, publishing, board and Grow tools come from the hosted Summer Engine MCP and are not loaded. Call this to see why and how to fix it (usually: run \"summer login --store\" in a terminal); it loads them when the sign-in works.",
+            inputSchema: passthroughArgs,
+        }, async () => {
+            const after = await mount();
+            if (after.status === "mounted") {
+                return { content: [{ type: "text", text: JSON.stringify({ ok: true, loaded: after.tools.length, tools: after.tools }) }] };
+            }
+            return errorText(after.error ?? { code: "store_tools_unavailable", message: "The hosted tools are not loaded.", recovery: 'Recovery: run "summer login --store", then call this again.' });
+        });
+    };
+    async function attempt() {
+        let client;
+        try {
+            const url = deps.url();
+            await deps.token();
+            client = await deps.connect(url, deps.token);
+        }
+        catch (error) {
+            state.status = "unavailable";
+            state.error =
+                error instanceof OAuthError
+                    ? { code: error.code, message: error.message.replace(` ${error.recovery}`, ""), recovery: error.recovery }
+                    : {
+                        code: "store_tools_unreachable",
+                        message: `The hosted Summer Engine MCP did not answer: ${error instanceof Error ? error.message : String(error)}.`,
+                        recovery: 'Recovery: check the network; if it says unauthorized, run "summer login --store --force". Then call summer_store_tools.',
+                    };
+            appendMcpLogEvent("mcp:hosted_mount_failed", { code: state.error.code });
+            showStatusTool();
+            return state;
+        }
+        const [tools, prompts, resources] = await Promise.all([
+            listAll((cursor) => client.listTools(cursor ? { cursor } : undefined), "tools"),
+            listAll((cursor) => client.listPrompts(cursor ? { cursor } : undefined), "prompts").catch(() => []),
+            listAll((cursor) => client.listResources(cursor ? { cursor } : undefined), "resources").catch(() => []),
+        ]);
+        for (const tool of tools) {
+            if (tool.name in registries._registeredTools && !schemas.has(tool.name)) {
+                if (tool.name !== STORE_TOOLS_STATUS)
+                    state.collisions.push(tool.name);
+                continue;
+            }
+            if (schemas.has(tool.name))
+                continue;
+            schemas.set(tool.name, tool);
+            server.registerTool(tool.name, { description: tool.description ?? "", inputSchema: passthroughArgs, ...(tool.annotations ? { annotations: tool.annotations } : {}) }, async (args) => {
+                try {
+                    return (await client.callTool({ name: tool.name, arguments: args }));
+                }
+                catch (error) {
+                    return errorText({
+                        code: "store_tool_failed",
+                        message: `The hosted Summer Engine MCP did not complete ${tool.name}: ${error instanceof Error ? error.message : String(error)}.`,
+                        recovery: 'Recovery: retry; if it says unauthorized, run "summer login --store --force".',
+                    });
+                }
+            });
+            state.tools.push(tool.name);
+        }
+        for (const prompt of prompts) {
+            if (prompt.name in registries._registeredPrompts) {
+                if (!state.prompts.includes(prompt.name))
+                    state.collisions.push(`prompt:${prompt.name}`);
+                continue;
+            }
+            const shape = Object.fromEntries((prompt.arguments ?? []).map((arg) => [arg.name, arg.required ? z.string().describe(arg.description ?? "") : z.string().optional().describe(arg.description ?? "")]));
+            server.registerPrompt(prompt.name, { ...(prompt.title ? { title: prompt.title } : {}), ...(prompt.description ? { description: prompt.description } : {}), ...(prompt.arguments?.length ? { argsSchema: shape } : {}) }, (async (args = {}) => client.getPrompt({ name: prompt.name, arguments: Object.fromEntries(Object.entries(args).filter((entry) => typeof entry[1] === "string")) })));
+            state.prompts.push(prompt.name);
+        }
+        for (const resource of resources) {
+            if (resource.uri in registries._registeredResources) {
+                if (!state.resources.includes(resource.uri))
+                    state.collisions.push(`resource:${resource.uri}`);
+                continue;
+            }
+            server.registerResource(resource.name, resource.uri, { ...(resource.title ? { title: resource.title } : {}), ...(resource.description ? { description: resource.description } : {}), ...(resource.mimeType ? { mimeType: resource.mimeType } : {}) }, async (uri) => (await client.readResource({ uri: uri.href })));
+            state.resources.push(resource.uri);
+        }
+        statusTool?.remove();
+        statusTool = null;
+        state.status = "mounted";
+        delete state.error;
+        appendMcpLogEvent("mcp:hosted_mounted", { tools: state.tools.length, prompts: state.prompts.length, resources: state.resources.length, collisions: state.collisions.length });
+        return state;
+    }
+    /** Mount once; a failed mount runs again on the next call. */
+    function mount() {
+        if (state.status === "mounted")
+            return Promise.resolve(state);
+        if (!running) {
+            state.status = "mounting";
+            running = attempt()
+                .catch((error) => {
+                state.status = "unavailable";
+                state.error = { code: "store_tools_unreachable", message: error instanceof Error ? error.message : String(error), recovery: "Recovery: call summer_store_tools to retry." };
+                showStatusTool();
+                return state;
+            })
+                .finally(() => {
+                running = null;
+            });
+        }
+        return running;
+    }
+    return { mount, state };
+}

package/dist/mcp/server.d.ts

@@ -10,7 +10,8 @@ export declare const getCachedBootDriftNotice: typeof getCachedNotice;
  * (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.
+ * summer_agent_playbook prompt / summer_get_agent_playbook tool. The last
+ * sentence names the publishing path and the owner-approval rule.
  */
 export declare const SUMMER_MCP_INSTRUCTIONS: string;
 export declare function configureMcpEngineSelection(selection?: EngineSelection): void;

package/dist/mcp/server.js

@@ -26,6 +26,7 @@ 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 { prepareHostedMount } from "./hosted-mount.js";
 import { buildBootDriftNotice, fetchLatestRegistryVersion, } from "../installer/version-check.js";
 import { TOOLKIT_VERSION as version } from "../core/version.js";
 let processDiagnosticsInstalled = false;
@@ -37,13 +38,15 @@ export const getCachedBootDriftNotice = getCachedNotice;
  * (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.
+ * summer_agent_playbook prompt / summer_get_agent_playbook tool. The last
+ * sentence names the publishing path and the owner-approval rule.
  */
-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, compactly. " +
-    "Before building or fixing, summer_search_library then summer_read_library the hit: skills, examples, templates live there. " +
-    "After a playthrough read summer_get_diagnostics, not summer_get_console alone (runtime errors live in the debugger). " +
-    "An all-black screenshot means the viewport had not redrawn — recapture before concluding. " +
-    "Report entries you verified in-engine via summer_library_feedback.";
+export const SUMMER_MCP_INSTRUCTIONS = "Summer Engine MCP. Call summer_get_project_context first: it binds the open project and returns mainScene, projectMemory and any capabilitySkewWarning. " +
+    "Before building or fixing, summer_search_library then summer_read_library the hit. " +
+    "After a playthrough read summer_get_diagnostics, not summer_get_console alone. " +
+    "An all-black screenshot means the viewport had not redrawn: recapture. " +
+    "Report verified entries via summer_library_feedback. " +
+    "Publishing: summer_export_game, summer_publish_build, summer_store_*; an agent never publishes alone: summer_store_submit returns the owner's approval link.";
 /**
  * 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
@@ -352,8 +355,12 @@ export async function startMcpServer(options = {}) {
         setCachedBootDriftNotice(null);
         appendMcpLogEvent("mcp:boot_drift_probe_failed", errorDetails(error));
     });
+    // Hosted Summer Engine MCP tools (store, publishing, board, Grow): ready
+    // before connect, mounted after it without blocking the engine tools.
+    const hosted = prepareHostedMount(server);
     const transport = new StdioServerTransport();
     await server.connect(transport);
+    void hosted.mount();
     appendMcpLogEvent("mcp:ready", {
         version,
         pid: process.pid,

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

@@ -1,5 +1,10 @@
 import { z } from "zod";
 import { CreatorOperationError, listCreatorReleases, publishCreator, } from "../../core/capabilities/creator.js";
+import { exportGame } from "../../core/capabilities/export-game.js";
+import { STORE_TARGETS } from "../../core/capabilities/export-presets.js";
+import { exportTemplates, TEMPLATE_PLATFORMS } from "../../core/capabilities/export-templates.js";
+import { publishBuild } from "../../core/capabilities/publish-build.js";
+import { BuildToolError } from "../../core/capabilities/summer-bundle.js";
 import { CONFIG_KEYS, getConfigValue, isConfigKey, readSummerConfig, setConfigValue, unsetConfigValue, } from "../../core/config.js";
 import { textJson } from "./text-json.js";
 async function creatorResult(operation) {
@@ -16,6 +21,16 @@ async function creatorResult(operation) {
                 recovery: error.recovery,
             }, true);
         }
+        if (error instanceof BuildToolError) {
+            return textJson({
+                ok: false,
+                code: error.code,
+                message: error.message.replace(` ${error.recovery}`, ""),
+                recovery: error.recovery,
+                ...(error.status ? { status: error.status } : {}),
+                ...error.detail,
+            }, true);
+        }
         return textJson({
             ok: false,
             code: "creator_request_invalid",
@@ -24,7 +39,45 @@ async function creatorResult(operation) {
     }
 }
 export function registerCreatorTools(server) {
-    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.", {
+    server.tool("summer_export_game", "Export the game in the exact file the Summer Games store takes, with the installed Summer Engine headless (no window). format \"bundle\" (default): the summer.games .zip the Summer apps run on iPhone, Android, macOS and Windows; targets picks the platforms (a game without a server: ios and android only); upload it with summer_publish_build. format \"download\" with one target: web (an HTML5 .zip on Summer's WebGPU Forward+ web template, played on summer.games), macos (.app zip, macos-universal) or windows (.exe zip, windows-x64); these need the export template from summer_export_templates and are uploaded as store versions. Works without the editor running. Returns path, sha256, size, the manifest or store platform, and warnings.", {
+        project: z.string().optional().describe("Project folder with project.godot. Defaults to the MCP's bound project, then the working directory."),
+        out: z.string().optional().describe("Output .zip path. Defaults to <project>/.summer/exports/."),
+        targets: z
+            .array(z.enum(STORE_TARGETS))
+            .optional()
+            .describe("Store platforms. Bundle: any of macos, windows, ios, android (omit to use every platform the project declares). Download: exactly one of web, macos, windows."),
+        format: z
+            .enum(["bundle", "download"])
+            .optional()
+            .describe("bundle (default): the summer.games store build. download: a web build or native download; the default when targets is [\"web\"]."),
+        debug: z.boolean().default(false).describe("Export a debug build (--export-debug)."),
+        timeoutSeconds: z.number().int().min(10).max(7200).optional().describe("Stop the engine after this many seconds (default 900; a first export imports every asset)."),
+    }, async ({ project, out, targets, format, debug, timeoutSeconds }) => creatorResult(() => exportGame({ project, out, targets, format, debug, ...(timeoutSeconds ? { timeoutMs: timeoutSeconds * 1000 } : {}) })));
+    server.tool("summer_export_templates", "List, download and install Summer Engine export templates from Summer's CDN into the folder the installed engine reads, checking each file's sha256. Needed only for summer_export_game format \"download\": web (Summer's WebGPU Forward+ template), macos, windows. Store bundles (format \"bundle\") need no template. action list shows what is installed and published; action install fetches the platforms asked (default web).", {
+        action: z.enum(["list", "install"]).describe("list: installed and published templates. install: download and install."),
+        platforms: z
+            .array(z.enum(TEMPLATE_PLATFORMS))
+            .optional()
+            .describe("Template platforms to install (default [\"web\"])."),
+        includeDebug: z.boolean().default(false).describe("Also install the debug templates (for exports with debug true)."),
+        summerVersion: z
+            .string()
+            .optional()
+            .describe("The installed Summer Engine version (Help > About, e.g. 0.7.1). Read automatically on macOS; needed on Windows and Linux."),
+    }, async ({ action, platforms, includeDebug, summerVersion }) => creatorResult(() => exportTemplates({ action, platforms, includeDebug, summerVersion })));
+    server.tool("summer_publish_build", "Upload an export from summer_export_game to the creator's game on summer.games, through the same store upload Studio uses, straight from disk. A store bundle (format bundle): declare, upload parts, seal, wait until Summer makes the Build, name its client pack, and with publish=true approve it. A web build or native download (format download): upload it as the game's store version for its platform (web, macos-universal, windows-x64, linux-x64; read from the last export) and wait until Summer has checked it. First call with confirm=false and show the user the returned target; set confirm only after they approve. Needs \"summer login --store\". A retry with the same file and clientVersion continues the same upload. Nothing here makes a game live: the owner approves publishing (summer_store_submit).", {
+        gameId: z.string().optional().describe("The store game id (Studio store page URL). Omit to get the list of your games."),
+        file: z.string().optional().describe("Exported .zip. Defaults to the last summer_export_game result."),
+        clientVersion: z.string().describe("Build version, vMAJOR.MINOR.PATCH (e.g. v1.0.0); a new upload needs a new version."),
+        publish: z.boolean().default(false).describe("Bundles only: also approve the Build for players. A game that has not passed review keeps it as a preview; an agent needs the owner's approval."),
+        platform: z
+            .enum(["web", "macos-universal", "windows-x64", "linux-x64"])
+            .optional()
+            .describe("Web builds and native downloads: the store platform. Defaults to the last export's platform; omit for a store bundle."),
+        confirm: z.boolean().default(false).describe("Set true only after the user approves the exact upload."),
+        waitSeconds: z.number().int().min(0).max(1800).optional().describe("How long to wait for Summer to make the Build (default 600). On timeout, call again to keep waiting."),
+    }, async (args) => creatorResult(() => publishBuild({ ...args, face: "mcp" })));
+    server.tool("summer_creator_publish", "Deprecated: use summer_export_game, then summer_publish_build, which upload the summer.games .zip to the game's store listing. This old path publishes a .pck to the legacy Summercraft creator API with a separate sc_ token and will be removed. 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."),

package/gemini-extension.json

@@ -1,7 +1,7 @@
 {
   "_generated": "GENERATED from integrations/gemini — do not edit; npm run generate:registry",
   "name": "summer",
-  "version": "3.2.1",
+  "version": "3.3.0",
   "description": "Agent tooling for Summer Engine: MCP bridge, context primer, and game-dev skills. Use with the npm CLI for skill files on disk.",
   "contextFileName": "GEMINI.md",
   "mcpServers": {

package/library/references/mcp-tools-reference/mcp-tools-reference.md

@@ -17,7 +17,7 @@
 
 **Rule of thumb:** project reads/writes go through Summer; live hierarchy/inspector changes use scene tools; process-level work remains with the host.
 
-## Tool surface (101 tools)
+## Tool surface (104 tools)
 
 ### Project files (4)
 
@@ -237,11 +237,14 @@ Preview. One fast, read-only call that walks every node of a 3D scene and lists
 | `summer_get_project_context` | Project, scene, and `.summer` memory summary — call at start of session. Binds the session to the open project and surfaces a `capabilitySkewWarning` when the engine build and CLI have drifted; tools whose op the engine provably lacks return a structured `engine_lacks_op` result instead of running. Compact by default (a few KB: `sceneSummary`, scalar `health` with capability counts); `include:['scene_tree','capabilities','settings']` adds the heavy blocks, `omitted` says how. |
 | `summer_get_agent_playbook` | Daily operating contract (observe-first loop, content routing, invariants, verification ritual) — call at start of session. Also served natively as the `summer_agent_playbook` MCP prompt. |
 
-### Creator platform (3)
+### Creator platform (5)
 
 | Tool | Use |
 |---|---|
-| `summer_creator_publish` | Compute the exact `.pck` digest and size, require user confirmation, then run versioned prepare → write-once upload → finalize. The server independently verifies `publish` scope, ownership, bytes, and review state. |
+| `summer_export_game` | Export the game in the file the Summer Games store takes, headless (no window), no running editor needed. `format:"bundle"` (default): the `summer.games` `.zip` the Summer apps run; `targets` picks `ios`, `android`, `macos`, `windows` (a game without a server: phones only) through a named `summer.games <targets>` preset in `export_presets.cfg`. `format:"download"` with one target: `web` (HTML5 `.zip` on Summer's WebGPU Forward+ template; refuses Compatibility projects), `macos` (ad hoc signed `.app` zip, `macos-universal`) or `windows` (`.exe` with embedded pack, zipped, `windows-x64`). Returns path, sha256, size, bundle manifest or store platform, warnings. |
+| `summer_export_templates` | `list` or `install` export templates from Summer's CDN (`downloads.summer.games/engine-templates/<summerVersion>/manifest.json`) into the engine's user template folder (`<data>/Godot/export_templates/<FULL_CONFIG>/`), sha256-checked. Only download exports need them; store bundles need none. `summerVersion` is read on macOS, passed elsewhere. |
+| `summer_publish_build` | Upload that `.zip` to the creator's game through Studio's store upload: confirm-gated preview first, then declare, part upload from disk, seal, wait for the Build, name its client pack; `publish:true` also approves it. Needs `summer login --store`; a retry with the same file and version continues the same upload. |
+| `summer_creator_publish` | **Deprecated** (use the two tools above). Compute the exact `.pck` digest and size, require user confirmation, then run versioned prepare → write-once upload → finalize. The server independently verifies `publish` scope, ownership, bytes, and review state. |
 | `summer_creator_releases` | List real creator-owned releases from `summer.creator.v1`, with opaque cursor pagination. |
 | `summer_creator_config` | Read or confirm updates to the shared non-secret `~/.summer/config.json`. It never accepts or returns tokens. |
 

package/library/skills/export-and-ship/SKILL.md

@@ -291,6 +291,8 @@ For each build:
 
 Per platform, point the user at the correct upload path:
 
+- **summer.games:** `summer_export_game` writes the summer.games `.zip`; `summer_publish_build` uploads it to the game's store listing after the user confirms the exact game, file and version (needs `summer login --store`). If it answers `store_auth_refused`, the user uploads the `.zip` in Studio instead.
+  - Per platform, the store takes: iPhone, Android, macOS and Windows in the Summer apps = one summer.games bundle (`summer_export_game` `targets`, format `bundle`; no template, no signing; a game without a server targets `ios`/`android` only). Web = an HTML5 `.zip` on Summer's WebGPU Forward+ template (`targets:["web"]`; the project must render with Forward+ or Mobile). A macOS or Windows download for the store page = `targets:["macos"]` or `["windows"]` with format `download`. Download exports need the template: `summer_export_templates` `install` fetches it from Summer's CDN.
 - **Steam:** `steamcmd` + Steam Pipe (`builder_app_xxx.vdf`). Set up depots first in Steamworks.
 - **itch.io:** `butler push <path> <user>/<game>:<channel>` (e.g. `butler push build/win <user>/mygame:windows`).
 - **Web (itch hosted):** zip + drop into itch upload UI as "playable in browser".

package/library/skills/multiplayer-publish/SKILL.md

@@ -197,7 +197,11 @@ writes `rejection.json`; its codes are in [export-errors.md](export-errors.md).
    `gameId` and section `builds`, or summerengine.com → Studio → your game →
    Builds.
 3. Upload the `.zip` as a new Build. Summer checks it again: unknown fields,
-   queue rules, both packs, and the composition match.
+   queue rules, both packs, and the composition match. From an agent:
+   `summer_export_game`, then `summer_publish_build` with `gameId` and
+   `clientVersion`; it asks for confirmation first and needs
+   `summer login --store`. If it answers `store_auth_refused`, upload in
+   Studio.
 4. Release the Build to an environment. Its queues go live there, and
    clients join them with `Summer.client.join(SummerJoinTarget.queue(...))`.
    The code is the same as in Local Play.

package/library/skills/navigate-summer/SKILL.md

@@ -22,7 +22,7 @@ Rigid skill: follow the rules below exactly.
 | The user wants to… | Do |
 |---|---|
 | **see / check / decide** — plan and billing (money), their published games and releases, usage, pricing, the MCP setup guide for their agent, docs, the scene or node you just built ("show me") | **Open the surface** with `summer_open` |
-| **get a result** — add a node, set a property, import an asset, run the game, publish | **Act through Summer tools** (mutation tools, `summer_play`, `summer_creator_publish`); do not open the editor to do by hand what a tool does |
+| **get a result** — add a node, set a property, import an asset, run the game, publish | **Act through Summer tools** (mutation tools, `summer_play`, `summer_publish_build`); do not open the editor to do by hand what a tool does |
 | **both** ("add a camera and show me") | act first, then open the scene / select the node so the user sees the result |
 
 Never open a browser or switch the editor's tab as a side effect of building. Opening is a user-visible action — do it because the user asked to look, and say what will open before it opens.

package/library/tools/creator-publish/resource.yaml

@@ -1,12 +1,13 @@
 id: tool/creator-publish
 kind: tool
-version: 1.0.2
-summary: Publish an exported Summer .pck through the versioned Summercraft creator API, with an explicit confirm step before upload.
+version: 1.1.0
+summary: "Deprecated: publishes a .pck to the legacy Summercraft API. Use summer_export_game, then summer_publish_build, to upload to summer.games."
 use_when:
   - releasing a user-approved build to a Summercraft channel
   - '"ship this exported build to the live channel"'
   - '"release version 1.2.0 of my game"'
 do_not_use_when:
+  - uploading to summer.games — summer_export_game, then summer_publish_build
   - the user has not approved the exact version, digest, and channel
   - the game is not exported yet — export the .pck first (skill/export-and-ship)
 facets:
@@ -19,7 +20,7 @@ compatibility:
   engine: ">=4.6"
 source: official
 license: MIT
-status: stable
+status: deprecated
 aliases:
   - summer_creator_publish
 implementation:

package/library/tools/creator-releases/resource.yaml

@@ -7,7 +7,7 @@ use_when:
   - '"what version is live right now?"'
   - '"did the publish go through?" — confirming a release landed'
 do_not_use_when:
-  - publishing a new release — summer_creator_publish
+  - publishing a new release — summer_publish_build
 facets:
   lifecycle:
     - launch

package/library/tools/export-game/resource.yaml

@@ -0,0 +1,72 @@
+id: tool/export-game
+kind: tool
+version: 1.0.0
+summary: Export the game in the exact file the Summer Games store takes per platform (iPhone, Android, macOS, Windows bundle; web build; desktop download), headless.
+use_when:
+  - '"export my game for summer.games"'
+  - '"make a build I can upload to my store page"'
+  - '"export my game for iPhone and Android on Summer Games"'
+  - '"make a web build of my game for summer.games"'
+  - '"export a Mac or Windows download for my store page"'
+  - preparing the bundle that summer_publish_build uploads
+do_not_use_when:
+  - exporting for Steam, itch.io, the App Store, Google Play or other stores — skill/export-and-ship
+  - the game is still being built; export when the user wants a Build
+facets:
+  lifecycle:
+    - launch
+  domains:
+    - creator
+    - deployment
+    - headless
+compatibility:
+  engine: ">=4.6"
+source: official
+license: MIT
+status: preview
+aliases:
+  - summer_export_game
+implementation:
+  module: src/core/capabilities/export-game.ts
+  export: exportGame
+surfaces:
+  mcp:
+    tool_name: summer_export_game
+    remote: true
+input_schema:
+  type: object
+  properties:
+    project:
+      type: string
+      description: Project folder with project.godot. Defaults to the MCP's bound project, then the working directory.
+    out:
+      type: string
+      description: Output .zip path. Defaults to <project>/.summer/exports/.
+    targets:
+      type: array
+      items:
+        type: string
+        enum: [macos, windows, ios, android, web]
+      description: "Store platforms. Bundle: any of macos, windows, ios, android (omit to use every platform the project declares). Download: exactly one of web, macos, windows."
+    format:
+      type: string
+      enum: [bundle, download]
+      description: 'bundle (default): the summer.games store build. download: a web build or native download; the default when targets is ["web"].'
+    debug:
+      type: boolean
+      default: false
+      description: Export a debug build (--export-debug).
+    timeoutSeconds:
+      type: integer
+      minimum: 10
+      maximum: 7200
+      description: Stop the engine after this many seconds (default 900; a first export imports every asset).
+  additionalProperties: false
+authority:
+  filesystem: true
+  editor_mutation: false
+  network: false
+  credentials: false
+  publish: false
+evidence_checks:
+  - none