summer-engine 4.3.0 → 4.6.0

package/dist/mcp/server.js

@@ -9,6 +9,7 @@ import { registerAuditTools } from "./tools/audit-tools.js";
 import { WITH_ENGINE_META } from "./tools/with-engine.js";
 import { registerPlaybookPrompt, registerProjectTools, } from "./tools/project-tools.js";
 import { registerPerceptionTools } from "./tools/perception-tools.js";
+import { registerLocalProjectTools } from "./tools/local-project-tools.js";
 import { registerSpatialTools } from "./tools/spatial-tools.js";
 import { registerPlacementTools } from "./tools/placement-tools.js";
 import { registerScriptTools } from "./tools/script-tools.js";
@@ -39,10 +40,12 @@ import { refreshInstalledSkills, refreshNotice } from "../installer/skills-refre
 import { OUTPUT_CAPS, PROFILE_TOOL_LIMIT, PROFILES, TOOLSETS, annotationsFor, registryAuthorities, resolveToolSelection, selectionIncludes, withMaxCharactersArg, } from "./tool-surface.js";
 import { shapeToolResult, singleEditCounter } from "./tool-results.js";
 import { recordLocalToolCall, recordMcpSession, toolErrorCode } from "../core/telemetry.js";
+import { boundProject } from "../core/usage-fields.js";
 import { currentToolContext, registerMcpClientSource, runWithToolContext } from "../core/agent-host.js";
 import { buildBootDriftNotice, fetchLatestRegistryVersion, } from "../installer/version-check.js";
 import { TOOLKIT_VERSION as version } from "../core/version.js";
 import { ENGINE_FREE_NOTE, engineNotRunningFromConnectError } from "../core/error-codes.js";
+import { selfStartEngine } from "../core/engine-self-start.js";
 import { resolveSurface } from "../core/tool-profiles.js";
 import { OAuthError } from "../core/oauth.js";
 let processDiagnosticsInstalled = false;
@@ -54,10 +57,11 @@ export const getCachedBootDriftNotice = getCachedNotice;
  * session, before any tool call — the place for the habits end-to-end runs
  * showed an agent needs on the first turn and would otherwise learn the hard
  * way, including scripting a run of scene edits instead of hundreds of single
- * calls. Kept under 600 characters so it costs a few hundred tokens once; the
+ * calls. Kept under 800 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. The last sentence names the publishing path,
- * the owner-approval rule and where review feedback is read.
+ * summer_get_agent_playbook tool. The publish sentence names the publishing
+ * path, the user's confirmation and that going live has no staff wait; the last
+ * says an agent may open the editor and play the game in a window.
  */
 export const SUMMER_MCP_INSTRUCTIONS = "Summer Engine MCP. Call summer_get_project_context first: it binds the open project. " +
     "Before building or fixing: summer_search_library, then summer_read_library the hit. " +
@@ -65,7 +69,8 @@ export const SUMMER_MCP_INSTRUCTIONS = "Summer Engine MCP. Call summer_get_proje
     "After play: summer_get_diagnostics, not only summer_get_console. " +
     "All-black screenshot: no redraw yet, recapture. " +
     "Report verified entries via summer_library_feedback. " +
-    "Publish: summer_export_game, summer_publish_build, summer_store_*; never alone: summer_store_submit returns the owner's approval link, summer_store_review the feedback.";
+    "Publish: summer_export_game, summer_publish_build, skill/release-checklist, summer_go_live, each confirmed. Live once automated checks pass: never say wait for review. " +
+    "Opening the editor and playing the game in a window is allowed and expected: summer_play, then summer_screenshot or summer_frame_shot; close what you opened, one editor at a time.";
 /** The same first-turn habits for a profile without engine tools (`--profile assets`). */
 export const SUMMER_MCP_ASSETS_INSTRUCTIONS = "Summer MCP, assets profile: generation and the Summer asset library, no engine tools. " +
     "Read skill/summer-assets, then the asset's skill (sound-effect, prop-model, ...): stop at the file, skip its engine steps. " +
@@ -90,7 +95,22 @@ export function configureMcpEngineSelection(selection) {
     engineSelection = selection ? { ...selection } : undefined;
     cachedClient = null;
 }
-export async function getClient() {
+/** The session's editor selection (projects.open_local opens its project). */
+export function currentMcpEngineSelection() {
+    return engineSelection ? { ...engineSelection } : undefined;
+}
+/** Bind the session to the project projects.open_local opened, with the client it connected. */
+export function bindMcpProject(projectRoot, client) {
+    engineSelection = { cwd: projectRoot };
+    cachedClient = client;
+}
+/** The step's log lines go to the MCP log and stderr, never stdout (the protocol). */
+export function logEngineSelfStart(line) {
+    appendMcpLogEvent("mcp:engine_self_start", { line });
+    writeMcpStderr("mcp:engine_self_start", { line });
+}
+/** `launch: false`: connect only, never open the editor (summer_open lists and prints with no side effects). */
+export async function getClient(options = {}) {
     // 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
@@ -129,8 +149,14 @@ export async function getClient() {
         // (engine_not_running). Anything else (several editors open, …) already
         // says how to pick one.
         const notRunning = engineNotRunningFromConnectError(reason);
-        if (notRunning)
+        if (notRunning && options.launch === false)
             throw notRunning;
+        if (notRunning) {
+            // Open the session's project ourselves when we can, else a coded
+            // error with the one command that gets there (core/engine-self-start.ts).
+            cachedClient = await selfStartEngine(engineSelection, notRunning, { log: logEngineSelfStart });
+            return cachedClient;
+        }
         throw new Error(reason + "\n" +
             "Open the intended project in Summer Engine, or run: npx -y summer-engine@latest run <project-path>\n" +
             "Note: " + ENGINE_FREE_NOTE);
@@ -235,14 +261,21 @@ function installToolCallWrapper(server, surfaceMeta) {
             // A tool another tool runs (summer_call, a v4 operation over its 3.x
             // tool) is part of that call: only the outer call sends a usage line.
             const nested = currentToolContext() !== undefined;
+            // What the call notes for its line (core/usage-fields.ts), shared with any tool it runs.
+            let noted = {};
             const recordUsage = (ok, durationMs, error) => {
+                const bound = boundProject();
+                const usage = { ...(bound ? { projectIdHash: bound } : {}), ...noted };
                 if (!nested)
-                    recordLocalToolCall({ tool: name, op: knownOp(opForToolCall(name, handlerArgs[0])), ...surfaceMeta, ok, durationMs, mcpClient: hostApp(), error });
+                    recordLocalToolCall({ tool: name, op: knownOp(opForToolCall(name, handlerArgs[0])), ...surfaceMeta, ok, durationMs, mcpClient: hostApp(), error, usage });
             };
             let result;
             try {
                 // Every Summer request the tool makes names it (core/agent-host.ts).
-                result = await runWithToolContext(name, "mcp", () => handler(...handlerArgs));
+                result = await runWithToolContext(name, "mcp", () => {
+                    noted = currentToolContext()?.usage ?? {};
+                    return handler(...handlerArgs);
+                });
             }
             catch (error) {
                 // A handler THROW never produced a result to classify; record it as
@@ -379,6 +412,7 @@ export function createMcpServer(selection = FULL_SELECTION, options = {}) {
     registerSeeingTools(server);
     registerAuditTools(server);
     registerProjectTools(server, { engine });
+    registerLocalProjectTools(server);
     registerFileTools(server);
     registerAssetTools(server);
     registerGenerateTools(server);

package/dist/mcp/tool-surface.d.ts

@@ -32,6 +32,14 @@ export declare function resolveToolSelection(options?: {
     profile?: string;
     toolsets?: string;
 }, env?: NodeJS.ProcessEnv): ToolSelection;
+/**
+ * Hosted 3.x status tools a limited profile leaves out because summer_go_live
+ * answers the same question (what players get now on each platform, and
+ * where each upload and download stands), so the local go-live tools fit
+ * under PROFILE_TOOL_LIMIT without pushing hosted store tools over it. The
+ * full profile keeps them, and store.status answers it on the v4 surface.
+ */
+export declare const SUPERSEDED_HOSTED_TOOLS: ReadonlySet<string>;
 /** True when the selection keeps this tool. */
 export declare function selectionIncludes(selection: ToolSelection, name: string, local: boolean): boolean;
 /** Every name the refinement sets mention (a test checks each is a real tool). */

package/dist/mcp/tool-surface.js

@@ -36,8 +36,11 @@ const LOCAL_TOOLSETS = {
         "summer_get_asset",
         "summer_get_asset_download_url",
     ],
-    ship: ["summer_export_game", "summer_export_templates", "summer_publish_build", "summer_capture_gameplay"],
+    ship: ["summer_export_game", "summer_export_templates", "summer_publish_build", "summer_go_live", "summer_store_set_details", "summer_capture_gameplay"],
     ui: ["summer_ui_actions", "summer_ui_activate", "summer_ui_screenshot", "summer_ui_tree"],
+    // Create and open a project on this computer with no shell (the full profile;
+    // the engine profile's clients have a shell, `summer dev`, and a tool cap).
+    projects: ["summer_projects_create_local", "summer_projects_open_local"],
 };
 const localToolset = new Map(Object.entries(LOCAL_TOOLSETS).flatMap(([set, names]) => names.map((name) => [name, set])));
 /** Hosted tool names by pattern, first match wins. Unknown names land in `other` (full only). */
@@ -99,9 +102,21 @@ export function resolveToolSelection(options = {}, env = process.env) {
         return { profile: "custom", toolsets: new Set(["core", ...extra]), ignored };
     return { profile, toolsets: new Set([...PROFILES[profile], ...extra]), ignored };
 }
+/**
+ * Hosted 3.x status tools a limited profile leaves out because summer_go_live
+ * answers the same question (what players get now on each platform, and
+ * where each upload and download stands), so the local go-live tools fit
+ * under PROFILE_TOOL_LIMIT without pushing hosted store tools over it. The
+ * full profile keeps them, and store.status answers it on the v4 surface.
+ */
+export const SUPERSEDED_HOSTED_TOOLS = new Set(["summer_store_releases", "summer_store_version_status"]);
 /** True when the selection keeps this tool. */
 export function selectionIncludes(selection, name, local) {
-    return selection.toolsets === null || selection.toolsets.has(toolsetOf(name, local));
+    if (selection.toolsets === null)
+        return true;
+    if (!local && SUPERSEDED_HOSTED_TOOLS.has(name))
+        return false;
+    return selection.toolsets.has(toolsetOf(name, local));
 }
 // ── Annotations ──────────────────────────────────────────────────────────────
 /**
@@ -139,6 +154,7 @@ const NETWORK_WRITES = new Set([
     "summer_app_report_gap",
     "summer_app_update",
     "summer_slice_asset_sheet",
+    "summer_store_set_details",
 ]);
 /** Changes that only add something new, or only touch the editor view or the running game. */
 const ADDITIVE_OR_TRANSIENT = new Set([
@@ -181,6 +197,7 @@ const ADDITIVE_OR_TRANSIENT = new Set([
 ]);
 /** Changes where a second identical call has no further effect. */
 const IDEMPOTENT_WRITES = new Set([
+    "summer_store_set_details",
     "summer_set_prop",
     "summer_set_resource_property",
     "summer_project_setting",

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

@@ -3,24 +3,20 @@ import { captureGameplay } from "../../core/capabilities/capture-gameplay.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 { goLive } from "../../core/capabilities/go-live.js";
 import { publishBuild } from "../../core/capabilities/publish-build.js";
-import { BuildToolError } from "../../core/capabilities/summer-bundle.js";
+import { AI_USES, STORE_FEATURES, setStoreDetails, SURVEY_LEVELS } from "../../core/capabilities/store-details.js";
+import { BuildToolError, buildToolFailure } from "../../core/capabilities/summer-bundle.js";
+import { syncItems } from "../../core/capabilities/sync-items.js";
+import { contentMake, contentMakeInput } from "../../core/capabilities/content-make/index.js";
 import { textJson } from "./text-json.js";
 async function creatorResult(operation) {
     try {
         return textJson(await operation());
     }
     catch (error) {
-        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);
-        }
+        if (error instanceof BuildToolError)
+            return textJson(buildToolFailure(error), true);
         return textJson({
             ok: false,
             code: "creator_request_invalid",
@@ -93,11 +89,11 @@ export function registerCreatorTools(server) {
             .optional()
             .describe("What to do after waitSeconds, in order; exactly one of press, key, action, click, drag, wait, shot per step."),
     }, async (args) => creatorResult(() => captureGameplay(args)));
-    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: it checks that the game exists for this account and warns when its store page does not list the export's platforms, then returns the target (game name and id, file, digest, size, version) to show the user; 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 (from summer_store_list_games, or the Studio store page URL). Without it the call fails with game_required and lists your store games, or says why the store did not list them."),
+    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 wait for Summer's automated checks on each platform (checks: passed, or failed with the code and the fix). 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: it checks that the game exists for this account and warns when its store page does not list the export's platforms, then returns the target (game name and id, file, digest, size, version) to show the user; set confirm only after they approve. Needs \"summer login --store\". A retry with the same file and clientVersion continues the same upload. Going live is summer_go_live.", {
+        gameId: z.string().optional().describe("The store game id (from games.list, or the Studio store page URL). Without it the call fails with game_required and lists your store games, or says why the store did not list them."),
         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."),
+        publish: z.boolean().default(false).describe("Bundles only: also make the Build available to players once its checks pass. summer_go_live does this, the release and the store page in one step."),
         platform: z
             .enum(["web", "macos-universal", "windows-x64", "linux-x64"])
             .optional()
@@ -105,4 +101,86 @@ export function registerCreatorTools(server) {
         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_go_live", "Take a store game live for players: release its uploaded bundle Build (publicationId, or the newest upload) to every platform that passed Summer's automated checks, and publish its store page, through the same store routes Studio uses; then watch until players get it. It runs without an owner approval while the person's Agent permissions allow Publish (the default). First call with confirm=false: it reads the page, the Build and its per-platform checks and what players get now, and returns live, blocked (each failure with its fix), needs_changes (Summer's decision and feedback) or confirmation_required with the plan to show the user; set confirm only after they approve going live. With confirm=true it asks the platform and polls until live, or answers waiting with waitingOn (automated_checks, activation, or summer: a hold on Summer's side that needs nothing from the creator; never tell them to wait for a review). Call again with confirm=true to keep watching: nothing is asked twice. needs_permission: Publish is off in the person's Agent permissions. Web builds and downloads go live with the page. Needs \"summer login --store\".", {
+        gameId: z.string().optional().describe("The store game id (from games.list). Without it the call fails with game_required and lists your store games."),
+        publicationId: z.string().optional().describe("The bundle Build to release: publicationId from summer_publish_build. Default: the newest uploaded export."),
+        confirm: z.boolean().default(false).describe("Set true only after the user approves taking this exact page and Build live."),
+        waitSeconds: z.number().int().min(0).max(1800).optional().describe("How long to watch before answering (default 600). On waiting, call again to keep watching."),
+    }, async (args) => creatorResult(() => goLive({ ...args, face: "mcp" })));
+    server.tool("summer_store_set_details", "Fill the store page sections store.update_listing does not edit, on the store page draft: genres (1-5 genre tag ids from store.get_listing tags), features, credits, languageSupport, systemRequirements, contentSurvey (the age questionnaire: every answer, none included) and aiDisclosure (how AI was used; an empty uses list means no AI). Each section given replaces that section, null clears it, an omitted one keeps its value. A published page gets a new draft first. Saving never publishes: take it live with summer_go_live. Needs \"summer login --store\".", {
+        gameId: z.string().optional().describe("The store game id (from games.list)."),
+        genres: z.array(z.string()).min(1).max(5).nullable().optional().describe("Genre tag ids (category genre in store.get_listing tags), in the creator's order."),
+        features: z.array(z.enum(STORE_FEATURES)).min(1).nullable().optional().describe("What the game offers, from the store's closed list."),
+        credits: z
+            .object({ developer: z.string().min(1).max(120), publisher: z.string().min(1).max(120).optional(), franchise: z.string().min(1).max(120).optional() })
+            .nullable()
+            .optional()
+            .describe("Who made and published it; omit publisher or franchise when there is none."),
+        languageSupport: z
+            .array(z.object({ code: z.string(), interface: z.boolean(), fullAudio: z.boolean(), subtitles: z.boolean() }))
+            .min(1)
+            .max(30)
+            .nullable()
+            .optional()
+            .describe("One entry per language (BCP 47 code: en, pt-br, zh-hans), each with at least one kind of support."),
+        systemRequirements: z
+            .record(z.string(), z.unknown())
+            .nullable()
+            .optional()
+            .describe("Desktop hardware: { windows | macos | linux: { minimum: { os, processor, memory, graphics, storage, network, notes }, recommended? } }."),
+        contentSurvey: z
+            .object({
+            violence: z.enum(SURVEY_LEVELS.violence),
+            bloodGore: z.enum(SURVEY_LEVELS.bloodGore),
+            sexualContent: z.enum(SURVEY_LEVELS.sexualContent),
+            nudity: z.enum(SURVEY_LEVELS.nudity),
+            language: z.enum(SURVEY_LEVELS.language),
+            substances: z.enum(SURVEY_LEVELS.substances),
+            gambling: z.enum(SURVEY_LEVELS.gambling),
+            userGeneratedContent: z.boolean(),
+            onlineInteraction: z.boolean(),
+            inGamePurchases: z.boolean(),
+            notes: z.string().max(1000).optional(),
+        })
+            .nullable()
+            .optional()
+            .describe("The mature-content questionnaire; every answer is required, none is an answer."),
+        aiDisclosure: z
+            .object({ uses: z.array(z.enum(AI_USES)), description: z.string().max(2000).optional() })
+            .nullable()
+            .optional()
+            .describe("How AI was used to make the game; uses [] means no AI. generatedGameplay needs a description of what is generated and its guardrails."),
+    }, async (args) => creatorResult(() => setStoreDetails({ ...args, face: "mcp" })));
+    server.tool("summer_sync_items", "Bring the store game's items in line with summer.items.json in the project root, matched by each item's slug (the creator key the game's code uses, e.g. emote_ponder), so the same file gives the staging game and the production game the same items. First call with confirm=false: it checks the file, reads the game's items by slug and returns the plan (create, update with the changed fields, unchanged, blocked with the reason, and the game's items the file does not name, which are never changed) for the gateway this machine is set to; show it to the user. With confirm=true it uploads the changed images and sends the plan to the game's owner: the answer carries the approval link; nothing changes until the owner approves in Studio, then each item is created or revised, priced in Sparks and submitted for Summer's review. After Summer approves an item, the owner activates it in Studio (Review activation on the item's page); players can buy it only while the game is live. A change to a live item is a new revision, reviewed and activated again. An item with the same slug that is a Passport collectible is blocked: Passport items are not synced. One approval takes at most 50 changed items: a larger plan lists batches, confirm each with slugs. A new item needs at least one image. Never activates or releases an item. Needs \"summer login --store\". Staging or production is the gateway this machine is set to; switching takes SUMMER_GATEWAY_URL and SUMMER_MCP_RESOURCE_URL, then \"summer login --store --force\" (one store sign-in per machine; a sign-in for the other environment fails with store_login_other_environment).", {
+        gameId: z.string().optional().describe("The store game id on this gateway (from games.list). Staging and production games have different ids. Without it the call fails with game_required and lists your store games."),
+        project: z.string().optional().describe("Project folder with project.godot and summer.items.json. Defaults to the MCP's bound project, then the working directory."),
+        file: z.string().optional().describe("The items file, relative to the project. Default summer.items.json."),
+        slugs: z.array(z.string()).max(500).optional().describe("Only these items (their slugs); the rest of the file is left out of the plan. Confirm a plan of more than 50 changed items one batch (from batches) at a time."),
+        confirm: z.boolean().default(false).describe("Set true only after the user approves the plan."),
+    }, async (args) => creatorResult(() => syncItems({ ...args, face: "mcp" })));
+    server.tool("summer_content_make", "Make one finished, postable piece of content for a game and put it in the team's Review (Studio > Grow > Content), on this computer: it picks the reference from Summer's library that fits today (a format the game has not posted, what changed in the repo), studies its cuts and caption look, measures the footage, maps each reference shot to a clip window with motion, cuts to the reference's timings, draws the captions in its style, mixes at -14 LUFS, checks hook, motion per shot, safe zones, length and loudness, renders the reference side by side, uploads and saves the piece (failed checks: a draft). It never writes words itself: the first call answers needs_words with the beats and the kit's learnings; call again with workDir, lines (one per beat, in the reference's pattern, true to the game, never the reference's own words) and learningIds. A reference that speaks also needs voiceFile, the lines recorded in the team's voice (needs_voice). Same workDir continues where a run stopped. claim=true takes the oldest queued make request instead (nothing_queued when none; a revision answers needs_changes with what the team asked) and reports every stage to it, so Today shows it live. Needs ffmpeg and ImageMagick (and Whisper for a voice-over). Takes a few minutes.", {
+        contentGameId: z.string().optional().describe("The game's Content id, from content.list_games. Not needed with workDir."),
+        teamId: z.string().optional().describe("From team.list, when the person has more than one team."),
+        referenceId: z.string().optional().describe("The reference to copy, from content.list_references. Without it the best fit for today is picked."),
+        footage: z.array(z.string()).max(20).optional().describe("Folders (or files) of the game's footage on this computer: clips, stills, and the game's music. Default ./content/footage."),
+        lines: z.array(z.string()).max(80).optional().describe("Our words, one per reference beat (\"\" for a beat without words), from the needs_words answer."),
+        voiceFile: z.string().optional().describe("The lines recorded in the team's voice (wav, mp3, m4a), when the reference speaks."),
+        title: z.string().max(100).optional().describe("The piece's title in Review (also the YouTube title)."),
+        caption: z.string().max(2200).optional().describe("The post caption: one dry line and a question, no hashtags."),
+        hashtags: z.array(z.string()).max(10).optional().describe("3-5 tags, the game's tag first. Default: the kit's core tags."),
+        note: z.string().max(2000).optional().describe("What to make it about (\"the new boss\", or commit lines like \"3f2a1c9 Add waiting room\"): weighs the reference pick and becomes the why."),
+        claim: z.boolean().optional().describe("Make a queued make request (the daily scheduler's, or a Change pressed on Today) and report every stage to it: the one named by requestId, else the team's oldest."),
+        requestId: z.string().optional().describe("The make request to claim, from content.make."),
+        learningIds: z.array(z.string()).max(20).optional().describe("The kit learnings (content.get_kit learnings, listed in needs_words) the words and choices applied."),
+        workDir: z.string().optional().describe("The work folder an earlier call answered: continues that piece."),
+        out: z.string().optional().describe("Where the work goes (pieces, the reference videos and footage measurements). Default ~/.summer/content."),
+        music: z.string().optional().describe("The game's own music for a reference with a song (never the reference's audio). Default: the first song in the footage folders."),
+        font: z.string().optional().describe("The game's caption font file (.ttf/.otf)."),
+        referenceFile: z.string().optional().describe("The reference video, when it cannot be fetched (yt-dlp)."),
+        repo: z.string().optional().describe("The game's repo, for what changed today. Default the working directory."),
+        stage: z.enum(["plan", "all"]).optional().describe("plan: stop after the plan, to change shots in plan.json."),
+        upload: z.boolean().optional().describe("false: render and check only, upload nothing."),
+        replan: z.boolean().optional().describe("Throw away the plan and map the shots again."),
+        status: z.enum(["draft", "in_review"]).optional().describe("Override: in_review even with failed checks, or draft."),
+    }, async (args) => creatorResult(() => contentMake({ ...contentMakeInput(args), face: "mcp" })));
 }

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

@@ -194,6 +194,8 @@ Use this when summer_get_diagnostics shows a non-zero \`debugger.warnings\` coun
     }));
     server.tool("summer_play", `Start the game. With no parameters it runs QUIETLY inside Summer Engine's viewport (the 'main' instance); scene runs one level or UI screen instead of the main scene.
 
+Playing the game in the editor's real window is allowed and expected: then summer_screenshot target:'game' to see it, summer_stop when done. One editor at a time.
+
 QUIET BY DEFAULT (focus:false, PlayGame agent:true): the user usually works on the same machine, so the EDITOR stays put. It does not switch to the Game tab or take keyboard focus (nor follow the game's later focus report), and skips the render-health self-check that would misread the untouched Game view as a GPU failure and flip the user's embed setting. Quiet play does NOT hide the game: it runs embedded in the Game view (visible if that tab is open) and is the running game for summer_is_running / summer_screenshot target:'game' / summer_get_diagnostics. With "Embed Game on Play" off the game gets its own OS window; engines with --summer-background (0.5.66+) open it without taking focus. The result echoes agent_quiet:true when honoured; without agent_quiet the engine predates quiet play and most likely took focus (posture_note says so). focus:true launches like the toolbar Play button (Game tab + focus): ONLY when the user is watching and asked to see the game come up.
 
 After starting, confirm boot with summer_is_running (boot time varies; never sleep a guessed delay), then summer_get_diagnostics for runtime errors.

package/dist/mcp/tools/local-project-tools.d.ts

@@ -0,0 +1,6 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * projects.create_local and projects.open_local: what `summer dev` does, for
+ * agents with no shell (core/capabilities/projects-local.ts).
+ */
+export declare function registerLocalProjectTools(server: McpServer): void;

package/dist/mcp/tools/local-project-tools.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { createLocalProject, LocalProjectError, localProjectFailure, openLocalProject, } from "../../core/capabilities/projects-local.js";
+import { EngineNotRunningError } from "../../core/error-codes.js";
+import { bindMcpProject, currentMcpEngineSelection, logEngineSelfStart } from "../server.js";
+import { textJson } from "./text-json.js";
+import { engineNotRunningResult } from "./with-engine.js";
+async function localProjectResult(operation) {
+    try {
+        return textJson(await operation());
+    }
+    catch (error) {
+        if (error instanceof LocalProjectError)
+            return textJson(localProjectFailure(error), true);
+        if (error instanceof EngineNotRunningError)
+            return engineNotRunningResult(error);
+        throw error;
+    }
+}
+/**
+ * projects.create_local and projects.open_local: what `summer dev` does, for
+ * agents with no shell (core/capabilities/projects-local.ts).
+ */
+export function registerLocalProjectTools(server) {
+    server.tool("summer_projects_create_local", "Create a Summer project on this computer from a template, with no shell: the built-in 3d-basic (sky, sun, ground and a hero; no download) unless template names another. Writes it into dir, or into <name> next to the session's project, in the session's folder, or in ~/Documents/Summer; never inside another project. A folder that already holds project.godot is left as it is. Returns projectPath. Next: summer_projects_open_local with that path.", {
+        template: z.string().max(80).optional().describe("Template slug (docs.search finds them): 3d-basic (default), empty, 3d-third-person-controller, 2d-platformer, ..."),
+        name: z.string().max(80).optional().describe("The project's name and folder name. Default my-game (or the template's name)."),
+        dir: z.string().max(1000).optional().describe("The project folder: a new or empty folder, not inside another project; ~ is home. Default <name> next to the session's project, in the session's folder, or in ~/Documents/Summer."),
+    }, async (args) => localProjectResult(() => createLocalProject(args, currentMcpEngineSelection()?.cwd)));
+    server.tool("summer_projects_open_local", "Open a project on this computer in Summer Engine, in the background, and wait until it connects (an editor that has it open is used as it is); this session's engine tools then work on it. When Summer Engine is not installed it answers engine_not_running: ask the person, and only with their yes call again with install: true (about 660 MB, free). A first open can take a few minutes: the answer says to call again. It adds summer-preview to the session folder's .claude/launch.json (Claude Code Desktop's Browser pane), and preview.url is where the game shows. Next: summer_get_project_context.", {
+        path: z.string().max(1000).optional().describe("The project folder (holds project.godot), e.g. projectPath from summer_projects_create_local. Default this session's project."),
+        install: z.boolean().default(false).describe("Install Summer Engine first when it is missing. Set true only after the person said yes."),
+    }, async (args) => localProjectResult(() => openLocalProject(args, currentMcpEngineSelection(), { log: logEngineSelfStart }, (root, client) => bindMcpProject(root, client))));
+}

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

@@ -24,7 +24,8 @@ Result: { ok, action: opened | printed | listed | ambiguous | unsupported | engi
 - ambiguous: several destinations match; call again with one of matches[].id.
 Only summerengine.com (and subdomains) are ever opened — a gateway configured elsewhere is refused (blocked_origin); res:// paths with .. or other escapes are refused; a machine with no browser gets open_failed with the url to hand over.`, openArgsShape, async (args) => {
         const result = await runOpen(args, {
-            engine: () => getClient(),
+            // Lists and prints must not open the editor (no side effects).
+            engine: () => getClient({ launch: false }),
             openUrl: (url) => open(url),
             isLoggedIn: async () => (await getAuthToken()) !== null,
             gatewayUrl: resolveGatewayUrl,

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

@@ -5,6 +5,7 @@ import { buildProjectContext, projectContextInputShape, resolveMainScene, } from
 import { getCachedBootDriftNotice } from "../boot-notice.js";
 import { appendMcpLogEvent } from "../../core/mcp-log.js";
 import { withEngine } from "./with-engine.js";
+import { importUrls } from "../../core/capabilities/video-ogv.js";
 import { asRecord, stringFrom } from "../../core/util/json.js";
 // One skew log line per MCP process — the warning itself stays in every
 // summer_get_project_context payload.
@@ -245,20 +246,16 @@ Use this for:
 - 3D models (.glb, .gltf, .obj)
 - Textures (.png, .jpg, .webp)
 - Audio (.ogg, .wav, .mp3)
+- Video (.mp4, .mov, .webm, .ogv): Summer Engine plays only Ogg Theora, so any other video is converted to .ogv first and lands at the path with .ogv; the answer names it.
 
 The path is auto-inferred from the URL filename if not specified. After import, the asset is immediately usable in scenes.`, {
         url: z.string().describe("HTTP(S) URL to download from"),
         path: z.string().optional().describe("Target path in project, e.g. 'res://assets/player.glb'. Auto-inferred from URL if omitted."),
-    }, async ({ url, path }) => withEngine(async (client) => {
-        const op = { op: "ImportFromUrl", url };
-        if (path)
-            op.path = path;
-        return client.executeOps([op]);
-    }));
-    server.tool("summer_import_from_url_batch", "Download multiple files from URLs in one operation. Performs a single filesystem scan after all downloads, which is faster than importing one at a time.", {
+    }, async ({ url, path }) => withEngine(async (client) => importUrls(client, [{ url, ...(path ? { path } : {}) }], { batch: false })));
+    server.tool("summer_import_from_url_batch", "Download multiple files from URLs in one operation. Performs a single filesystem scan after all downloads, which is faster than importing one at a time. A video (.mp4, .mov, .webm) is converted to Ogg Theora first and lands at its path with .ogv.", {
         imports: z.array(z.object({
             url: z.string().describe("URL to download"),
             path: z.string().describe("Target path in project"),
         })).describe("Array of {url, path} objects"),
-    }, async ({ imports }) => withEngine(async (client) => client.executeOps([{ op: "ImportFromUrlBatch", imports }])));
+    }, async ({ imports }) => withEngine(async (client) => importUrls(client, imports, { batch: true })));
 }

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

@@ -54,7 +54,7 @@ Returns the grid + caption. ${COMMON}`, debugViewsShape, run(debugViews));
     server.tool("summer_zoom", `High-resolution close look at part of a frame: region [x, y, w, h] (fractions of the frame) or mark N from a marks render of the same pose. The camera renders the EXACT sub-frustum of that region at full output resolution, so you see real texture detail, seams, gaps and floating pieces, not upscaled pixels. A region is honoured exactly (no pad by default, never widened to an aspect ratio: the image takes the region's own aspect, with dark bars only for extreme shapes); a mark gets pad 0.15.
 
 Use after a sheet or debug view shows something suspicious. view picks beauty or a debug view. Returns the zoomed image + caption (the real zoom factor, the rendered region, widened_because when it is larger than asked, mark -> node path and a warning when that node is hidden). ${COMMON}`, zoomShape, run(zoom));
-    server.tool("summer_frame_shot", `Smart framing: find good camera poses for a shot type automatically, measured in-engine against the real geometry.
+    server.tool("summer_frame_shot", `Smart framing: find good camera poses for a shot type automatically, measured in-engine against the real geometry. It runs in the open editor; use it to look at the scene as a player would.
 
 shot: establishing (wide), eye_level (from a spawn node at player eye height), low_angle (hero, near the ground looking up: the camera moves closer and widens its FOV instead of sinking into the ground), detail (close-up), corridor (down a lane or corridor found inside the subject by a free-space scan, preferring the view in from its open end, walls on both sides).
 

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

@@ -103,7 +103,7 @@ function teachPreviewFailure(snap) {
 export function registerVisualTools(server) {
     server.tool("summer_screenshot", `Capture a frame from Summer Engine and return it as an image you can look at directly.
 
-Use this to visually verify your work: scene layout, asset placement, scale, framing, missing/untextured assets, or runtime gameplay state. You see the actual pixels — no description layer in between. Lighting and materials are only truthfully shown by the "viewport" and "game" targets — see the note on "scene" below.
+Use this to visually verify your work (it reads the real open editor or game window; that is allowed and expected): scene layout, asset placement, scale, framing, missing/untextured assets, or runtime gameplay state. You see the actual pixels — no description layer in between. Lighting and materials are only truthfully shown by the "viewport" and "game" targets — see the note on "scene" below.
 
 target:
   "viewport" (default) — the editor's CURRENT view (whatever scene/tab is open). No game boot. Use for edit-time checks of how the scene looks right now.

package/dist/mcp/tools/with-engine.js

@@ -162,7 +162,7 @@ export async function withEngine(fn, opts) {
 export function engineNotRunningResult(error) {
     return {
         isError: true,
-        content: [{ type: "text", text: JSON.stringify(codedFailure(error.code, error.message, { hint: ENGINE_FREE_NOTE }), null, 2) }],
+        content: [{ type: "text", text: JSON.stringify(codedFailure(error.code, error.message, { hint: ENGINE_FREE_NOTE }, error.recovery), null, 2) }],
     };
 }
 const PRE_APPLY_FAILURE_REASON = {

package/dist/project-memory/agent-instructions.js

@@ -36,10 +36,18 @@ export function renderAgentsBlock(commands = projectCommands()) {
         "",
         "This is a game made with Summer Engine, the game engine built for AI. Game code is GDScript (`.gd`), scenes are `.tscn`, resources are `.tres`, and `project.godot` is the project file.",
         "",
+        "## First game: make it look finished",
+        "",
+        "People judge Summer by the first frame of their first game, so make it look finished even when they ask for a quick prototype. Keep the features they asked for and raise the look:",
+        "- sky and sun with shadows, tonemapping, a little fog;",
+        "- a texture on every surface, and real models for the player, characters and main props (the starter project and the Summer asset library first), never capsules or boxes as final art;",
+        "- one colour palette and a styled UI font.",
+        "Before you say it is ready, play it and look at a screenshot of the running game, not the editor: the editor shows a preview sky and sun that the game does not have.",
+        "",
         "## How to work on it",
         "",
-        "- Change scenes through Summer while Summer Engine has the project open. The editor rewrites `.tscn` files when it saves, so hand edits get lost.",
-        "- With Summer's MCP server, call the `summer_*` tools and start with `summer_get_project_context`. Without it, run the same operations as `summer` commands in the shell (the `summer-cli` skill). If `summer` is missing or older than 4.0, use `npx -y summer-engine@latest` in its place.",
+        "- Write GDScript (`.gd`) files directly. Create and change scenes and import assets through Summer while Summer Engine has the project open: it imports new files, and the editor rewrites `.tscn` files when it saves, so hand edits to an open scene get lost.",
+        "- With Summer's MCP server, use the `summer_*` tools; `summer_get_project_context` tells you which project you are connected to. Without it, run the same operations as `summer` commands in the shell (the `summer-cli` skill). If `summer` is missing or older than 4.0, use `npx -y summer-engine@latest` in its place.",
         "- Summer's skills teach each part of a game. `npx -y summer-engine@latest setup <agent> --yes` installs them for your agent (add `--cli` for no MCP server). Start with `using-summer`, and find the right one with `summer docs search --query \"<the task>\"`.",
         "- `.summer/` is the project's memory: `GameSoul.md` says what the game is, `memory/` holds the decisions to keep. Read them before you change the game's look, sound or story.",
         "- Check your own work: script errors, a screenshot, a play run. Ask the person to play only for feel and fun.",
@@ -50,7 +58,7 @@ export function renderAgentsBlock(commands = projectCommands()) {
         "",
         "## Publishing",
         "",
-        "The `publish-your-game` skill has the steps; `summer ops search \"publish my game\"` finds each operation. `summer store publish` sends the game to Summer's store review, and the game's owner approves it: give them the link it prints. Nothing goes live until they approve.",
+        "The `publish-your-game` skill has the steps; `summer ops search \"publish my game\"` finds each operation. Going live needs the game owner's yes. A game goes live as soon as Summer's automated checks pass; Summer's staff review it after it is live, so never tell anyone to wait for a review.",
         SUMMER_BLOCK_END,
     ].join("\n");
 }

package/gemini-extension.json

@@ -1,7 +1,7 @@
 {
   "_generated": "GENERATED from integrations/gemini — do not edit; npm run generate:registry",
   "name": "summer",
-  "version": "4.3.0",
+  "version": "4.6.0",
   "description": "The game engine built for AI. Any agent makes a multiplayer game and publishes it. The Summer Engine MCP server, context primer and game-dev skills.",
   "contextFileName": "GEMINI.md",
   "mcpServers": {
@@ -72,6 +72,7 @@
     "./library/skills/in-game-purchases/",
     "./library/skills/instantiate-asset-pack/",
     "./library/skills/investigating-bugs/",
+    "./library/skills/make-content/",
     "./library/skills/make-game/",
     "./library/skills/multiplayer/",
     "./library/skills/multiplayer-movement/",
@@ -89,6 +90,7 @@
     "./library/skills/procedural-animation/",
     "./library/skills/prop-model/",
     "./library/skills/publish-your-game/",
+    "./library/skills/release-checklist/",
     "./library/skills/release-readiness/",
     "./library/skills/remote-deploy/",
     "./library/skills/retarget/",

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

@@ -19,7 +19,16 @@
 
 **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 (119 tools)
+## Tool surface (125 tools)
+
+### Local projects (2)
+
+No shell needed (Claude Desktop, chat apps); the `summer dev` command does both in one step from a shell.
+
+| Tool | Use |
+|---|---|
+| `summer_projects_create_local` | Write a new project from a template to this computer (`3d-basic` by default: sky, sun, ground and a hero). `dir`, or `name` next to the session's project, in the session's folder, or in `~/Documents/Summer`; never inside another project. A folder that already holds `project.godot` is left as it is. Returns `projectPath`. |
+| `summer_projects_open_local` | Open a project in Summer Engine in the background and wait until it connects; the session's engine tools then work on it. Engine missing: answers `engine_not_running`; ask the person, and only with their yes call again with `install: true` (about 660 MB, free). A slow first open answers "call again in 30 seconds". It registers `summer preview` in the session folder's `.claude/launch.json`; `preview.url` is where the game shows. |
 
 ### Project files (4)
 
@@ -253,13 +262,17 @@ Each spends the person's credits. `dryRun: true` returns `preview.estimate` (`cr
 | `summer_call` `{"op":"summer_get_agent_playbook"}` | Daily operating contract (observe-first loop, content routing, invariants, verification ritual) — read at start of session. Also served natively as the `summer_agent_playbook` MCP prompt. |
 | `plans.get` (3.x `summer_get_board`) | Read the person's game plan (look, characters, place, storyboard, picks): every item with its id, picture URL and revision, to compare screenshots against. `projects.get({ projectId })` gives the project's `planId` from the project id in the build brief; works without the engine. |
 
-### Creator platform (4)
+### Creator platform (8)
 
 | Tool | Use |
 |---|---|
 | `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. |
-| `store.upload_file` (3.x `summer_publish_build`; through `summer_call`) | 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; `publish:true` also approves it. Needs `summer login --store`; a retry with the same file and version continues the same upload. Without a shell, `store.upload_begin`, `store.upload_sign_parts` and `store.upload_complete` take the bytes in parts. |
+| `store.upload_file` (3.x `summer_publish_build`; through `summer_call`) | 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 and for Summer's automated checks on each platform (`checks`: passed, or failed with `code`, `owner` and `fix`); `publish:true` also makes the Build available to players. Needs `summer login --store`; a retry with the same file and version continues the same upload. Without a shell, `store.upload_begin`, `store.upload_sign_parts` and `store.upload_complete` take the bytes in parts. |
+| `store.go_live` (`summer_go_live`; through `summer_call`) | Take the store game live: release the uploaded bundle Build to the platforms that passed their checks and publish the store page, through the same store routes Studio uses, then watch until players get it. Confirm-gated: the plan first (or `live`, `blocked` with each failure's fix, `needs_changes` with Summer's feedback). It needs no owner approval link while the person's Agent permissions allow Publish (the default; otherwise `needs_permission`). `waiting` names what it waits on (`automated_checks`, `activation`, or `summer`: a hold on Summer's side that needs nothing from the creator). Call again to keep watching; nothing is asked twice. Run the `release-checklist` skill first. |
+| `store.set_details` (`summer_store_set_details`; through `summer_call`) | The store page sections `store.update_listing` does not edit, on the draft: `genres`, `features`, `credits`, `languageSupport`, `systemRequirements`, `contentSurvey` (the age questionnaire) and `aiDisclosure`. A section given replaces it, `null` clears it. Never publishes. |
+| `economy.sync_items` (`summer_sync_items`; through `summer_call`) | Bring the store game's items in line with `summer.items.json` in the project root, matched by slug, so staging and production carry the same items. Confirm-gated: the plan first (create, update with the changed fields, unchanged, blocked), then the changed images are uploaded and the plan goes to the owner, who approves it in Studio; the items are then created or revised, priced in Sparks and submitted for review. One approval takes at most 50 changed items (a larger plan lists `batches`; confirm each with `slugs`); a new item needs at least one image. Never activates or releases an item. Needs `summer login --store`. Staging or production is the gateway setting: switching takes `SUMMER_GATEWAY_URL` and `SUMMER_MCP_RESOURCE_URL`, then `summer login --store --force` (one store sign-in per machine). |
+| `content.make` (`summer_content_make`; through `summer_call`) | Make one finished piece of content for a game on this computer and put it in the team's Review: picks the reference that fits today (a format the game has not posted, what changed in the repo), studies its cuts and caption look, maps each reference shot to a footage window with motion, cuts to its timings, draws its captions, puts a song on the beat, mixes at -14 LUFS, checks hook, motion per shot, safe zones, length and loudness, renders the reference side by side and saves the piece (failed checks: a draft). It never writes words: `needs_words` lists the beats, call again with `workDir` and `lines`; a reference that speaks also needs `voiceFile` in the team's voice (`needs_voice`). Same `workDir` continues where it stopped. Needs ffmpeg and ImageMagick (Whisper for a voice-over). |
 | `summer_capture_gameplay` | Real gameplay frames without a running editor: starts the game (main scene or `scene`) in the engine's offscreen verify instance (`--summer-verify`, real renderer, window parked offscreen, no focus) (`--summer-offscreen`) at `resolution` (default `1920x1080`), waits `waitSeconds`, runs `steps` (`press` a button by text, `key`, `action`, `click`, `drag`, `wait`, `shot`), saves `frames` PNGs (HUD included; with a `shot` step, one per shot) to `<project>/.summer/captures/<time>/`. `args` are the game's own flags, passed after `--` (e.g. `["--autostart"]` to skip the title screen). Imports the project first when `.godot/` is missing. Returns each path with its real width and height; warns when the stretch settings render another size. For store screenshots. |
 
 ### Hosted store, publishing and Grow tools
@@ -267,9 +280,9 @@ Each spends the person's credits. `dryRun: true` returns `preview.estimate` (`cr
 These come from the hosted Summer server (the one ChatGPT and Claude connect to) and are mounted into the local MCP after `summer login`; `summer tool <name>` reaches them too.
 
 - **Store page:** `summer_store_list_games`, `summer_store_create_game`, `summer_store_get_listing` (the page, the checklist and `availableTags`), `summer_store_update_listing` (text, tags, long description, support contact, release date, content rating), `summer_store_set_art`, `summer_store_set_trailer`, `summer_store_set_sound`, `summer_store_preview_link`, `summer_store_jams` and `summer_store_enter_jam`.
-- **Builds and release:** `summer_build_begin_upload` / `_sign_parts` / `_complete_upload` / `_status` (the local `summer_publish_build` does these from disk), `summer_store_version_*` for web and native downloads, `summer_store_submit` (one approval link for the owner), `summer_store_cancel_submission`, `summer_store_review`, `summer_store_releases`, `summer_build_release`.
+- **Builds and release:** `summer_build_begin_upload` / `_sign_parts` / `_complete_upload` / `_status` (the local `summer_publish_build` does these from disk), `summer_store_version_*` for web and native downloads, `summer_store_submit` (one approval link for the owner, for a person whose Agent permissions have Publish off; otherwise the local `summer_go_live` takes the game live), `summer_store_cancel_submission`, `summer_store_review`, `summer_store_releases`, `summer_build_release`. The engine profile leaves out `summer_store_releases` and `summer_store_version_status`: `summer_go_live` reports what players get and each download's state.
 - **Grow:** `summer_grow_overview` and `summer_grow_analytics` (store page views, launches, play sessions, play time, custom events), `summer_grow_event_catalog`, `summer_grow_event_trend`, `summer_grow_event_funnel`, `summer_grow_members`, `summer_grow_ab_tests`, `summer_grow_prices`, `summer_grow_event_limit`, `summer_grow_apply` and `summer_grow_applications`.
-- **Guides:** the `publish-your-game`, `store-listing`, `store-art` and `grow-analytics` skills (`summer_docs_read`).
+- **Guides:** the `publish-your-game`, `release-checklist`, `store-listing`, `store-art` and `grow-analytics` skills (`summer_docs_read`).
 
 ### Library search (2)