summer-engine 3.5.1 → 3.5.2

package/.claude-plugin/marketplace.json

@@ -11,7 +11,7 @@
     {
       "name": "summer",
       "source": "./",
-      "version": "3.5.1",
+      "version": "3.5.2",
       "description": "Agent tooling for Summer Engine: game-dev skills, lifecycle hooks, and a 105-tool MCP bridge to the local desktop app.",
       "author": {
         "name": "Summer Engine",

package/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "_generated": "GENERATED from integrations/claude — do not edit; npm run generate:registry",
   "name": "summer",
-  "version": "3.5.1",
+  "version": "3.5.2",
   "description": "Agent tooling for Summer Engine: game-dev skills, lifecycle hooks, and a 105-tool MCP bridge to the local desktop app.",
   "author": {
     "name": "Summer Engine",
@@ -96,6 +96,7 @@
     "./library/skills/psx-retro-rendering/",
     "./library/skills/publish-your-game/",
     "./library/skills/realtime-wet-surfaces/",
+    "./library/skills/release-readiness/",
     "./library/skills/remote-deploy/",
     "./library/skills/retarget/",
     "./library/skills/running-in-the-cloud/",

package/.codex-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "_generated": "GENERATED from integrations/codex — do not edit; npm run generate:registry",
   "name": "summer",
-  "version": "3.5.1",
+  "version": "3.5.2",
   "description": "Agent tooling for Summer Engine: game-dev skills, lifecycle hooks, and a 105-tool MCP bridge. Build games by talking.",
   "author": {
     "name": "Summer Engine",
@@ -91,6 +91,7 @@
     "./library/skills/psx-retro-rendering/",
     "./library/skills/publish-your-game/",
     "./library/skills/realtime-wet-surfaces/",
+    "./library/skills/release-readiness/",
     "./library/skills/remote-deploy/",
     "./library/skills/retarget/",
     "./library/skills/running-in-the-cloud/",

package/.cursor-plugin/plugin.json

@@ -3,7 +3,7 @@
   "_generated": "GENERATED from integrations/cursor — do not edit; npm run generate:registry",
   "name": "summer",
   "displayName": "Summer",
-  "version": "3.5.1",
+  "version": "3.5.2",
   "description": "Agent tooling for Summer Engine: game-dev skills, lifecycle hooks, and a 105-tool MCP bridge to the local desktop app.",
   "author": {
     "name": "Summer Engine",
@@ -103,6 +103,7 @@
     "./library/skills/psx-retro-rendering/",
     "./library/skills/publish-your-game/",
     "./library/skills/realtime-wet-surfaces/",
+    "./library/skills/release-readiness/",
     "./library/skills/remote-deploy/",
     "./library/skills/retarget/",
     "./library/skills/running-in-the-cloud/",

package/.factory-plugin/plugin.json

@@ -2,7 +2,7 @@
   "_generated": "GENERATED from integrations/factory — do not edit; npm run generate:registry",
   "name": "summer",
   "description": "Agent tooling for Summer Engine: game-dev skills, lifecycle hooks, and a 105-tool MCP bridge to the local desktop app.",
-  "version": "3.5.1",
+  "version": "3.5.2",
   "author": {
     "name": "Summer Engine",
     "email": "founders@summerengine.com",
@@ -88,6 +88,7 @@
     "./library/skills/psx-retro-rendering/",
     "./library/skills/publish-your-game/",
     "./library/skills/realtime-wet-surfaces/",
+    "./library/skills/release-readiness/",
     "./library/skills/remote-deploy/",
     "./library/skills/retarget/",
     "./library/skills/running-in-the-cloud/",

package/CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to summer-engine will be documented here. Following [Keep a
 
 ## [Unreleased]
 
+Hosted games: agents check that players can actually join before a release.
+
+- **`release-readiness` check 7: export with a released Summer, and prove the scripts compile on the runtime players get.** Players' apps run a bundle on the released Summer of the version its export stamp names. A development build that still stamps an older released version can use APIs that release lacks; its scripts then fail to compile on every player's device (`Parse Error: Static function "…" not found`, `Failed to load script`) and the game opens to an empty window, while every upload check passes. The check reads the stamp from `summer-bundle.json`, compares `engineSha` with the release's, and runs `client.pck` on that released Summer with `--headless --verbose --main-pack`, failing on `SCRIPT ERROR`, `Parse Error` or `Failed to load script`. `multiplayer-publish` adds the run as step 4e, and `export-and-ship` says to export summer.games bundles with the released editor only.
+
+- **New `release-readiness` skill.** Before a version reaches players, it runs six checks on the summer.games `.zip` you upload: the bundle's `server.pck`, started with no scene, loads the authority scene; a real online join with the released version reaches the game; online play is reachable by default; the server saves online progress through player data; players can get back to the title; and `Summer.initialize` passes no hard-coded Game ID. It reports pass, fail, not applicable or not run for each, and grows by one check after every release that fails in a way none of them caught. The same checklist is in the docs at `/publishing/release-readiness`.
+- **The multiplayer skills call `Summer.initialize()` with no Game ID.** The summer.games bundle leaves `gameId` out, so an ID in code (or a fallback when it is missing) fails on the hosted server with `game_identity_mismatch` and every online join ends in `world_start_timeout`.
+- `multiplayer-publish` explains why the server preset needs the `summer_authority` custom feature, adds a pre-upload step that runs the bundle's `server.pck` with no scene, a real online join after release, and what an empty server log does and doesn't mean. `multiplayer-testing` lists what Local Play can't catch; `make-game` plans online play reachable by default, server-saved progress and a way back to the title, and runs `release-readiness` before shipping.
+
+## [3.5.2] - 2026-10-10
+
+Summer works with Kimi Code and other agents whose model checks tool schemas strictly.
+
+- Kimi Code no longer fails every prompt with `400 tools.function.parameters is not a valid moonshot flavored json schema ... items must be an object` when Summer is connected. Ten tools (`summer_align_distribute_3d`, `summer_raycast`, `summer_instantiate_scene`, `summer_capture_gameplay`, `summer_test_placement`, `summer_snap_to_surface`, `summer_navigation_probe`, `summer_attach_to_surface`, `summer_repeat_along`, `summer_game_input`) described their `[x, y, z]` and `[x, y]` vectors in a form Moonshot rejects. Every tool now lists its parameters in the JSON Schema subset strict providers accept: a vector is an array of numbers with an exact length, and no schema points into another with `$ref`. The hosted store tools get the same treatment. The tools still reject a vector of the wrong length.
+- If you added Summer tools to Kimi's `disabledTools` to work around this, remove them after updating, then restart Kimi Code.
+
 ## [3.5.1] - 2026-10-10
 
 Summer Games now connects from almost every agent setup supports, and large store uploads finish.

package/commands/summer.md

@@ -47,6 +47,7 @@ Skills are invoked by their bare slug, such as `brainstorm-game`. There is no `s
 | add an animation to [character] | `generate-motion` |
 | wire up a state machine for [character] | `animation-tree` |
 | the game feels mushy / add juice | `game-feel` |
+| is it ready to release / check before publishing / online joins fail with `world_start_timeout` | `release-readiness` |
 | ship a trailer | `trailer-shot` |
 | cutscene for [X] | `cinematic-cutscene` |
 | let me play it | `play` |

package/dist/mcp/hosted-mount.js

@@ -3,6 +3,7 @@ import { z } from "zod";
 import { connectHostedMcp } from "../core/hosted-mcp.js";
 import { getStoreAccessToken, OAuthError, resolveMcpResourceUrl } from "../core/oauth.js";
 import { appendMcpLogEvent } from "../core/mcp-log.js";
+import { providerSafeSchema } from "./provider-safe-schema.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
@@ -73,7 +74,7 @@ export function prepareHostedMount(server, deps = defaultHostedMountDependencies
                 ...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;
+                    return hosted ? { ...tool, inputSchema: providerSafeSchema(hosted.inputSchema), ...(hosted.annotations ? { annotations: hosted.annotations } : {}), ...(hosted.title ? { title: hosted.title } : {}) } : tool;
                 }),
             };
         });

package/dist/mcp/provider-safe-schema.d.ts

@@ -0,0 +1,10 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/** String formats OpenAI strict mode accepts; other providers accept no more. */
+export declare const STRICT_PROVIDER_FORMATS: Set<string>;
+export declare function providerSafeSchema<T>(schema: T): T;
+/**
+ * Wrap the SDK's tools/list so every tool's inputSchema leaves the server in
+ * the provider-safe form. Call after the first registerTool (the SDK installs
+ * its tools/list handler then).
+ */
+export declare function serveProviderSafeToolSchemas(server: McpServer): void;

package/dist/mcp/provider-safe-schema.js

@@ -0,0 +1,96 @@
+import { ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+/** String formats OpenAI strict mode accepts; other providers accept no more. */
+export const STRICT_PROVIDER_FORMATS = new Set(["date-time", "time", "date", "duration", "email", "hostname", "ipv4", "ipv6", "uuid"]);
+// Where a schema holds subschemas: one, a list, or a name -> schema map.
+const SCHEMA_KEYS = new Set(["items", "additionalItems", "additionalProperties", "contains", "not", "if", "then", "else", "propertyNames", "unevaluatedItems", "unevaluatedProperties"]);
+const SCHEMA_LIST_KEYS = new Set(["anyOf", "oneOf", "allOf", "prefixItems"]);
+const SCHEMA_MAP_KEYS = new Set(["properties", "patternProperties", "dependentSchemas", "$defs", "definitions"]);
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function resolvePointer(root, ref) {
+    let node = root;
+    for (const raw of ref.slice(2).split("/")) {
+        if (raw === "")
+            continue;
+        const key = raw.replace(/~1/g, "/").replace(/~0/g, "~");
+        if (Array.isArray(node))
+            node = node[Number(key)];
+        else if (isObject(node))
+            node = node[key];
+        else
+            return undefined;
+    }
+    return node;
+}
+function uniqueSchemas(schemas) {
+    const seen = new Map();
+    for (const schema of schemas)
+        seen.set(JSON.stringify(schema), schema);
+    return [...seen.values()];
+}
+function rewrite(schema, root, expanding) {
+    if (!isObject(schema))
+        return schema;
+    const child = (value) => rewrite(value, root, expanding);
+    const { $ref, ...rest } = schema;
+    if (typeof $ref === "string" && ($ref === "#" || $ref.startsWith("#/"))) {
+        // A recursive shape cannot be inlined; accept any value there and let zod validate it.
+        const target = expanding.includes($ref) ? {} : rewrite(resolvePointer(root, $ref), root, [...expanding, $ref]);
+        return { ...(isObject(target) ? target : {}), ...child(rest) };
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === "additionalItems" || key === "prefixItems")
+            continue;
+        if (SCHEMA_KEYS.has(key))
+            out[key] = Array.isArray(value) ? value.map(child) : child(value);
+        else if (SCHEMA_LIST_KEYS.has(key) && Array.isArray(value))
+            out[key] = value.map(child);
+        else if (SCHEMA_MAP_KEYS.has(key) && isObject(value))
+            out[key] = Object.fromEntries(Object.entries(value).map(([name, sub]) => [name, child(sub)]));
+        else
+            out[key] = value;
+    }
+    if (Array.isArray(schema.type) && !("anyOf" in out)) {
+        delete out.type;
+        out.anyOf = schema.type.map((type) => ({ type }));
+    }
+    if (typeof out.format === "string" && !STRICT_PROVIDER_FORMATS.has(out.format))
+        delete out.format;
+    if (isObject(out.propertyNames) && Object.keys(out.propertyNames).length === 1 && out.propertyNames.type === "string")
+        delete out.propertyNames;
+    const tuple = Array.isArray(schema.prefixItems) ? schema.prefixItems : Array.isArray(schema.items) ? schema.items : null;
+    if (tuple) {
+        const extra = Array.isArray(schema.prefixItems) ? schema.items : schema.additionalItems;
+        const open = extra !== undefined && extra !== false;
+        const members = uniqueSchemas([...tuple, ...(isObject(extra) ? [extra] : [])].map(child));
+        out.items = members.length === 1 ? members[0] : members.length === 0 ? {} : { anyOf: members };
+        out.minItems ??= tuple.length;
+        if (!open)
+            out.maxItems ??= tuple.length;
+    }
+    return out;
+}
+export function providerSafeSchema(schema) {
+    const out = rewrite(schema, schema, []);
+    if (isObject(out)) {
+        // Every local $ref is inlined, so the definition tables are dead weight.
+        delete out.definitions;
+        delete out.$defs;
+    }
+    return out;
+}
+/**
+ * Wrap the SDK's tools/list so every tool's inputSchema leaves the server in
+ * the provider-safe form. Call after the first registerTool (the SDK installs
+ * its tools/list handler then).
+ */
+export function serveProviderSafeToolSchemas(server) {
+    const handlers = server.server._requestHandlers;
+    const listTools = handlers.get("tools/list");
+    if (!listTools)
+        return;
+    server.server.setRequestHandler(ListToolsRequestSchema, async (request, extra) => {
+        const result = await listTools(request, extra);
+        return { ...result, tools: result.tools.map((tool) => ({ ...tool, inputSchema: providerSafeSchema(tool.inputSchema) })) };
+    });
+}

package/dist/mcp/server.js

@@ -27,6 +27,7 @@ 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 { serveProviderSafeToolSchemas } from "./provider-safe-schema.js";
 import { buildBootDriftNotice, fetchLatestRegistryVersion, } from "../installer/version-check.js";
 import { TOOLKIT_VERSION as version } from "../core/version.js";
 let processDiagnosticsInstalled = false;
@@ -329,6 +330,8 @@ export function createMcpServer() {
     // 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);
+    // Strict providers (Kimi, OpenAI strict) reject tuple and $ref schemas.
+    serveProviderSafeToolSchemas(server);
     return { server, getRegisteredToolCount };
 }
 export async function startMcpServer(options = {}) {

package/gemini-extension.json

@@ -1,7 +1,7 @@
 {
   "_generated": "GENERATED from integrations/gemini — do not edit; npm run generate:registry",
   "name": "summer",
-  "version": "3.5.1",
+  "version": "3.5.2",
   "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": {
@@ -93,6 +93,7 @@
     "./library/skills/psx-retro-rendering/",
     "./library/skills/publish-your-game/",
     "./library/skills/realtime-wet-surfaces/",
+    "./library/skills/release-readiness/",
     "./library/skills/remote-deploy/",
     "./library/skills/retarget/",
     "./library/skills/running-in-the-cloud/",

package/library/skills/README.md

@@ -1,6 +1,6 @@
 # Summer skills
 
-> 122 skills, grouped by their primary domain. **Generated** by `npm run generate:registry` from each skill's `resource.yaml`; `--check` fails when this file and the library disagree. Do not edit by hand.
+> 123 skills, grouped by their primary domain. **Generated** by `npm run generate:registry` from each skill's `resource.yaml`; `--check` fails when this file and the library disagree. Do not edit by hand.
 
 The folder is flat on purpose (`docs/design/DECISIONS.md`, D3): a skill usually belongs to several domains, so categories live in each skill's `facets.domains` and this index is rendered from them. The first domain listed is the primary one. `summer skills list --by-domain` prints the same grouping; `summer skills info <slug>` shows one skill.
 
@@ -18,7 +18,7 @@ Status: **stable** unless marked; *preview* = not yet exercised in-engine by the
 - [character-controller](#character-controller) (2)
 - [creator](#creator) (4)
 - [debug](#debug) (1)
-- [deployment](#deployment) (2)
+- [deployment](#deployment) (3)
 - [editor](#editor) (1)
 - [gameplay](#gameplay) (6)
 - [level-design](#level-design) (2)
@@ -147,6 +147,7 @@ Status: **stable** unless marked; *preview* = not yet exercised in-engine by the
 | skill | when to use | also |
 |---|---|---|
 | [export-and-ship](./export-and-ship/SKILL.md) ★ | Assess and prepare a game export: inventory installed templates and targets, validate release assets and config, produce supported builds after approval. | project |
+| [*release-readiness*](./release-readiness/SKILL.md) (preview) | Before releasing a Summer game version, prove players can play it: server scene, online join, saved progress, no fixed Game ID, a released Summer compiles it. | multiplayer, playtest |
 | [remote-deploy](./remote-deploy/SKILL.md) ★ | Run or test the game on a real device — phone, tablet, another computer — via the Remote Deploy button, runnable export presets, and on-device debugging. | project |
 
 ## editor

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

@@ -298,6 +298,8 @@ 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.
   - Hosted games: if `summer_export_game` fails with "… is in the source graph's authority_engine domain, which the client pack leaves out", an authority root in `source-domains.json` holds a file the client loads (often the composition `.tres`). Narrow that root to the server-only files, or move the shared file under a `shared` path, then export again. Every exporter message is in the `multiplayer-publish` skill's export-errors.md; the folder rules are in `multiplayer-project`.
+  - Every summer.games bundle: export with the released Summer editor from the download page, never a development build, and export again after updating Summer. Otherwise its scripts can fail to compile on players' devices and the game opens to an empty window, though every upload check passes. `release-readiness` check 7 proves it.
+  - Hosted games, before the upload: a clean export does not prove players can join. Run `release-readiness` on the `.zip`: the bundle's `server.pck`, started with no scene, must load the authority scene (the server preset needs the `summer_authority` custom feature), and `Summer.initialize` must pass no hard-coded Game ID. Otherwise every online join fails with `world_start_timeout`.
   - Store page art: key art, covers and icons carry no text, logos or UI (the store page shows the title). Screenshots are real gameplay and may show the game's own HUD; add no captions, logos or overlays. Capture them with `summer_capture_gameplay` (offscreen, no editor needed; `resolution` `1920x1080`, or `1080x1920` for portrait; get past a title menu with the game's own flags in `args`, e.g. `["--autostart"]`, or `steps` such as `[{"press":"Play"},{"wait":3000},{"shot":true}]`), or `summer_screenshot` target `game` while the editor runs the game.
 - **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`).

package/library/skills/make-game/SKILL.md

@@ -47,6 +47,7 @@ These rules from the playbooks apply to every genre:
 - **2D scales to the viewport.** Set `display/window/stretch/mode = canvas_items` and `stretch/aspect = expand`; UI uses Control anchors; code-positioned nodes compute from `get_viewport_rect().size`. Never hardcode 1920x1080.
 - **Playable slice, not tech demo.** Name the core loop in one sentence; every input gets feedback (tween, sound, particle, flash, shake); progression is visible; a restart exists. The bar is "feels good for 30 seconds".
 - **Fast first draft when someone is waiting.** The first playable version uses shapes, the palette and any template art, plus at most one or two generated assets the person specifically asked for; generation takes minutes, so it never blocks the first play. Say plainly that it is a first draft to get a feel for the game, that the art is not final, and ask if this is the direction they want. Generate the rest of the art in later passes.
+- **A way back to the title.** From inside play, a pause menu or a **Leave** button returns to the title screen without quitting the app.
 - **Text the default font can show.** No emoji or symbols (▲ ◀ ★ ♥ ✓) in UI text: they render as boxes with hex codes. Use words or icons; see `ui-basics`.
 
 ## The Pipeline
@@ -95,6 +96,12 @@ This phase doesn't have a dedicated skill yet — do it inline. Read `.summer/Ga
 2. **Core mechanics** — ranked, max 3 (the brief enforces this; respect it)
 3. **Cut list** — what's explicitly NOT in scope
 
+If the game has online play, the plan also fixes three product defaults; each one was missed by a real release:
+
+- **Online play is reachable by default.** A new player gets to it from the title without changing a setting. Hiding it behind a setting or a grown-ups gate is the owner's explicit decision, recorded in the plan, and it means someone joins online before every release.
+- **Progress is saved by the server.** Online progress goes through authority player data (`summer-player-data`), not only the player's local files.
+- **A way back to the title** from inside an online and an offline session.
+
 Save the plan to `.summer/build-plan.md`. Format:
 
 ```markdown
@@ -236,8 +243,10 @@ Only if `summer_get_diagnostics` flags rendering or physics hotspots. Don't opti
 1. `play` from main scene.
 2. Walk every mechanic from the plan.
 3. Hit the win condition (or lose condition).
-4. `summer_get_diagnostics` clean.
-5. `debug` until clean if not.
+4. Return to the title from inside play, then start again.
+5. Online games: run Local Play (`multiplayer-testing`) and reach online play from the title as a new player, with default settings.
+6. `summer_get_diagnostics` clean.
+7. `debug` until clean if not.
 
 **Don't skip this even if every mechanic worked individually.** Integration bugs hide between mechanics.
 
@@ -249,6 +258,14 @@ Skill: export-and-ship
 
 Pre-flight checklist (icon, store banners, build config) before producing release builds for the targets in the brief.
 
+Before any version reaches players, run:
+
+```
+Skill: release-readiness
+```
+
+It checks the file you upload, not the editor: a hosted game's `server.pck` starts its authority scene, `Summer.initialize` passes no hard-coded Game ID, online play is reachable, progress is saved by the server, and players can get back to the title. Then, after publishing, the user joins online with the released version. Report each check as pass, fail, not applicable or not run. Hosted games publish through `multiplayer-publish`; store pages through `publish-your-game`.
+
 If the brief said "jam" or "prototype", skip this phase. If the brief said "game I want to release", run it.
 
 ## Anti-Patterns
@@ -260,6 +277,8 @@ If the brief said "jam" or "prototype", skip this phase. If the brief said "game
 | Stack art direction on top of unfinished mechanics | Art changes are reversible only if the underlying scene structure is stable. Get mechanics done first. |
 | Treat "polish" as required | If the brief says "jam in 2 days", polish is a cut item. Respect the brief. |
 | Run all phases without confirming | The user owns scope. Stop at every checkpoint. |
+| Ship online play behind a setting nobody changes | Hosted join is never exercised, so it breaks without anyone noticing. Reachable by default, or the owner joins online before every release. |
+| Hard-code a Game ID in `Summer.initialize` | The summer.games bundle has no `gameId`; a different ID fails on the hosted server and every online join times out. Pass no ID. |
 | Build a fully featured menu before there's a playable mechanic | Menu work is endless polish; player-loop work is the actual game. Mechanics first. |
 | Fall back to "let me try a few things" mid-pipeline | If you don't know what to do, name the phase and ask the user, don't improvise around the structure. |
 

package/library/skills/make-game/resource.yaml

@@ -21,6 +21,7 @@ related:
   skills:
     - skill/audio-direction
     - skill/export-and-ship
+    - skill/release-readiness
     - skill/design-mechanic
     - skill/tune-performance
     - skill/art-direction

package/library/skills/multiplayer/SKILL.md

@@ -84,7 +84,7 @@ the sender's verified Session. Events are fire-and-forget.
 
 | Word | Meaning |
 |---|---|
-| Game | Your game on Summer; its id is `gameId` in `summer.build.json` and the argument to `Summer.initialize` |
+| Game | Your game on Summer; its id is `gameId` in `summer.build.json`. `Summer.initialize()` takes no ID: Summer knows which game is running |
 | World | One running match or shared place, simulated by one authority |
 | WorldDefinition | `world.json`: which scenes run the client and the authority, lifetime, persistence |
 | Queue | How players find a World; declared in `summer.build.json` |
@@ -109,6 +109,8 @@ Each skill continues the same small game, so their code fits together:
    what a passing run must show.
 5. **`multiplayer-publish`**: export the summer.games bundle and upload it as
    a Build.
+6. **`release-readiness`**: before players get a version, prove the server
+   starts its authority scene and a real online join works.
 
 ## Add Summer services
 

package/library/skills/multiplayer/resource.yaml

@@ -25,6 +25,7 @@ related:
     - skill/multiplayer-state
     - skill/multiplayer-testing
     - skill/multiplayer-publish
+    - skill/release-readiness
     - skill/summer-matchmaking
     - skill/summer-player-data
 source: official

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

@@ -176,7 +176,7 @@ func _ready() -> void:
 	spawner.entity_spawned.connect(_on_player_spawned)
 	spawner.command_received.connect(_on_command)
 	world.session_left.connect(_on_session_left)
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return

package/library/skills/multiplayer-movement/files.md

@@ -26,7 +26,7 @@ func _ready() -> void:
 	spawner.entity_spawned.connect(_on_player_spawned)
 	spawner.command_received.connect(_on_command)
 	world.session_left.connect(_on_session_left)
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return
@@ -141,7 +141,7 @@ func _ready() -> void:
 	# Connect before joining, or the first values arrive unseen.
 	spawner.state_group_created.connect(_on_group_created)
 	spawner.entity_spawned.connect(_on_entity_spawned)
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return
@@ -440,7 +440,6 @@ occurrence_streams = Array[SummerNetworkOccurrenceStream]([SubResource("Commands
 extends RefCounted
 ## Shared by the client and the authority: ids, streams and shared rules.
 
-const GAME_ID := "game_courtyard"
 const QUEUE := &"courtyard"
 const MOTION := &"courtyard.motion"
 const CMD := &"courtyard.cmd"

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

@@ -74,7 +74,14 @@ textures/vram_compression/import_etc2_astc=true
 ```
 
 The `.summer_client` and `.summer_authority` overrides tell each exported pack
-which scene to start. Leave the `[summer] version` line the editor writes.
+which scene to start. Summer starts the hosted server with no scene
+argument, so `run/main_scene.summer_authority` is the only thing that makes
+`server.pck` start the authority. It applies only when the server export
+preset carries the custom feature `summer_authority` (`multiplayer-publish`).
+Without it the server starts the client scene, never reports ready, and every
+online join fails with `world_start_timeout`. Local Play names the scene
+itself, so it works either way. Leave the `[summer] version` line the editor
+writes.
 
 ## 4. The declarations
 
@@ -116,6 +123,9 @@ starts. Summer rejects unknown fields, so copy the shape exactly.
 }
 ```
 
+- `gameId` is the game's id in Summer Studio, for your publishing tools. The
+  summer.games export leaves it out of the bundle, so game code never reads
+  it: both sides call `Summer.initialize()` with no ID (sections 7 and 8).
 - `queues[].minPlayers` / `maxPlayers` bound a match. `worldDefinition` names
   the `definition_id` in `world.json`.
 - `server.exportPreset` names the server export preset (`multiplayer-publish`).
@@ -250,7 +260,6 @@ on both sides:
 extends RefCounted
 ## Shared by the client and the authority: ids, streams and shared rules.
 
-const GAME_ID := "game_courtyard"
 const QUEUE := &"courtyard"
 const CMD := &"courtyard.cmd"
 const MAX_PLAYERS := 8
@@ -321,7 +330,7 @@ func _ready() -> void:
 	spawner.entity_spawned.connect(_on_player_spawned)
 	spawner.command_received.connect(_on_command)
 	world.session_left.connect(_on_session_left)
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return
@@ -379,6 +388,11 @@ func _on_session_left(session: SummerSession, reason: String) -> void:
 
 `authority/main.tscn` is a plain `Node` with that script ([files.md](files.md)).
 
+- `Summer.initialize()` takes no Game ID. Summer takes the game's identity
+  from where it runs: Local Play, the hosted server or the Summer Games app.
+  Never pass a literal, a placeholder or a fallback ID: any ID that differs
+  from the hosted one fails with `game_identity_mismatch`, and the authority
+  stops before it reports ready.
 - **Never** read who sent a Command from its payload: `request.get_session()`
   is verified. Don't name your own classes `SummerSession`, `SummerWorld` or
   other engine class names.
@@ -426,7 +440,7 @@ func _ready() -> void:
 	spawner = Game.build_network(self, PlayerArchetype)
 	# Connect signals like state_group_created here, before joining, or values
 	# that arrive during the join go unseen (multiplayer-movement adds them).
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return
@@ -510,6 +524,8 @@ warning yourself.
 | `@rpc`, `MultiplayerSynchronizer`, `ENetMultiplayerPeer` | The Spawner, State groups and Commands | Unverified peers, no late join, no Summer hosting |
 | `if multiplayer.is_server()` in one shared scene | Separate `client/` and `authority/` scenes | The engine starts the right scene on each side |
 | Load an `authority/` file from client or shared code | Move what both sides need into `network/` | The export leaves `authority/` out of the players' pack |
+| `Summer.initialize("game_…")`, or a fallback ID when `gameId` is missing | `Summer.initialize()` | The bundle has no `gameId`; a different ID fails hosted with `game_identity_mismatch` |
+| Set `run/main_scene.summer_authority` and stop there | Also give the server preset the `summer_authority` feature | Without the feature the hosted server starts the client scene |
 | Build the composition differently on each side | One `network/composition.tres`, loaded by both | Different compositions refuse each other |
 | Send a Command right after `join` succeeds | Await `spawner.network_ready` first | The authority does not know the client's network until then |
 | Free a player's things on `session_disconnected` | Free them on `session_left` | A disconnected player keeps their seat and may reconnect |

package/library/skills/multiplayer-project/files.md

@@ -22,7 +22,7 @@ func _ready() -> void:
 	spawner.entity_spawned.connect(_on_player_spawned)
 	spawner.command_received.connect(_on_command)
 	world.session_left.connect(_on_session_left)
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return
@@ -127,7 +127,7 @@ func _ready() -> void:
 	spawner = Game.build_network(self, PlayerArchetype)
 	# Connect signals like state_group_created here, before joining, or values
 	# that arrive during the join go unseen (multiplayer-movement adds them).
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return
@@ -283,7 +283,6 @@ occurrence_streams = Array[SummerNetworkOccurrenceStream]([SubResource("Commands
 extends RefCounted
 ## Shared by the client and the authority: ids, streams and shared rules.
 
-const GAME_ID := "game_courtyard"
 const QUEUE := &"courtyard"
 const CMD := &"courtyard.cmd"
 const MAX_PLAYERS := 8