summer-engine 4.3.0 → 4.6.0

package/library/skills/painted-25d-world/_building-blocks/tools/detail4k.py

@@ -0,0 +1,81 @@
+"""A 2K paint-over -> an aligned 4K painting. Upscale 2x, cut nine overlapping 2048x1152 tiles (1024x576 stride),
+run a strict "redraw sharper, pixel-aligned" image-to-image pass on each tile with seedream-5-pro (the Summer image
+model that returns 2048x1152), then blend the tiles back with tent weights. Nine image generations.
+Uses the Summer CLI (`summer`, or set SUMMER_BIN); every call carries an idempotencyKey and numImages 1, and a
+timed-out call is retried with the same key (a timeout can still charge). Needs Python with Pillow and numpy.
+usage: python3 detail4k.py <painting_2k.png> <out_dir> "<style words>" [run_id]"""
+import json, os, shlex, subprocess, sys, time, concurrent.futures as cf
+import numpy as np
+from PIL import Image
+S = shlex.split(os.environ.get("SUMMER_BIN", "summer"))
+src, outdir, style = sys.argv[1], sys.argv[2], sys.argv[3]
+run_id = sys.argv[4] if len(sys.argv) > 4 else os.path.splitext(os.path.basename(src))[0]
+os.makedirs(outdir, exist_ok=True)
+PROMPT = ("This is a crop of a hand-painted game background, shown at low resolution. "
+          f"Redraw it at full sharpness in its own style ({style}): crisp painterly brush strokes and fine texture detail. "
+          "This is a texture paint-over: keep the image pixel-aligned. Every edge, silhouette, object, colour and light stays "
+          "exactly where it is. Same framing, no zoom, no crop. Do not add, remove, move or resize anything. "
+          "No characters, no text, no border.")
+
+def run(args, inp=None):
+    r = subprocess.run(S + args + ["--json"] + (["--input", json.dumps(inp)] if inp else []), capture_output=True, text=True)
+    txt = r.stdout.strip() or r.stderr.strip()
+    if "{" in txt:
+        try:
+            return json.JSONDecoder().raw_decode(txt[txt.find("{"):])[0]
+        except Exception:
+            pass
+    sys.stderr.write("unparsed: " + txt[-300:] + r.stderr[-300:] + "\n")
+    return {"ok": False, "error": {"code": "outcome_unknown"}}
+
+def upload(path):
+    b = run(["assets", "upload-begin"])["result"]
+    f = b["fields"]
+    cmd = ["curl", "-sS", b["uploadUrl"]] + sum([["-F", f"{k}={v}"] for k, v in f.items()], []) + ["-F", f"file=@{path}"]
+    up = json.loads(subprocess.run(cmd, capture_output=True, text=True).stdout)
+    c = run(["assets", "upload-complete"], {"publicId": up["public_id"], "version": up["version"], "uploadSignature": up["signature"], "format": "png", "title": os.path.basename(path)})
+    return c["result"]["fileUrl"]
+
+def tile(job):
+    i, path = job
+    out = os.path.join(outdir, f"tile_{i}_paint.png")
+    if os.path.exists(out):
+        return out
+    cache = path + ".url"
+    if not os.path.exists(cache):
+        open(cache, "w").write(upload(path))
+    url = open(cache).read().strip()
+    for attempt in range(30):
+        r = run(["assets", "generate-image"], {"prompt": PROMPT, "referenceImageUrl": url, "model": "seedream-5-pro", "aspectRatio": "16:9",
+                                           "width": 2048, "height": 1152, "numImages": 1, "title": f"{run_id} 4k tile {i}",
+                                           "idempotencyKey": f"{run_id}-4k-tile-{i}", "out": out})
+        code = r.get("error", {}).get("code")
+        if r.get("ok") or code not in ("outcome_unknown", "in_progress"):
+            break
+        time.sleep(15)
+    if not r.get("ok"):
+        raise RuntimeError(json.dumps(r)[:600])
+    print("tile", i, r["result"].get("creditsCharged"), flush=True)
+    return out
+
+base = Image.open(src).convert("RGB").resize((4096, 2304), Image.LANCZOS)
+base.save(os.path.join(outdir, "base4k.png"))
+jobs = []
+for ty in range(3):
+    for tx in range(3):
+        x, y = tx * 1024, ty * 576
+        p = os.path.join(outdir, f"tile_{ty * 3 + tx}.png")
+        base.crop((x, y, x + 2048, y + 1152)).save(p)
+        jobs.append((ty * 3 + tx, p))
+with cf.ThreadPoolExecutor(3) as ex:
+    outs = list(ex.map(tile, jobs))
+acc = np.zeros((2304, 4096, 3)); wsum = np.zeros((2304, 4096, 1))
+wx = 1 - np.abs(np.linspace(-1, 1, 2048)); wy = 1 - np.abs(np.linspace(-1, 1, 1152))
+w = (np.outer(wy, wx) + 1e-3)[..., None]
+for (i, _), o in zip(jobs, outs):
+    t = np.asarray(Image.open(o).convert("RGB").resize((2048, 1152), Image.LANCZOS)).astype(float)
+    x, y = (i % 3) * 1024, (i // 3) * 576
+    tw = w.copy()
+    acc[y:y + 1152, x:x + 2048] += t * tw; wsum[y:y + 1152, x:x + 2048] += tw
+Image.fromarray(np.clip(acc / wsum, 0, 255).astype(np.uint8)).save(os.path.join(outdir, "paint4k.png"))
+print("done", os.path.join(outdir, "paint4k.png"))

package/library/skills/painted-25d-world/_building-blocks/tools/overlay.py

@@ -0,0 +1,17 @@
+"""Alignment check: red edges of the blockout render over the paint-over. Roof lines, wall corners and props must
+sit on the red lines; reject a painting that moved, added or zoomed anything. Needs Python with Pillow and numpy.
+usage: python3 overlay.py <blockout.png> <painting.png> <out.png>"""
+import sys
+
+import numpy as np
+from PIL import Image, ImageFilter
+
+block, paint, out = sys.argv[1:4]
+p = Image.open(paint).convert("RGB")
+b = Image.open(block).convert("RGB").resize(p.size, Image.NEAREST)
+a = np.asarray(b).astype(int)
+e = (np.abs(np.diff(a, axis=0, prepend=a[:1])).sum(2) > 40) | (np.abs(np.diff(a, axis=1, prepend=a[:, :1])).sum(2) > 40)
+e = np.asarray(Image.fromarray((e * 255).astype(np.uint8)).filter(ImageFilter.MaxFilter(3))) > 0
+o = np.asarray(p).copy()
+o[e] = [255, 0, 0]
+Image.fromarray(o).save(out)

package/library/skills/painted-25d-world/_building-blocks/tools/preview.py

@@ -0,0 +1,60 @@
+"""Draw the blockout spec's wireframe (red) over the concept through the paint camera, no engine needed.
+Fix block positions until the red lines sit on the concept's silhouettes, then build in the engine
+(blockout_builder.gd reads the same spec). Camera settings: see cam.py. Needs Python with Pillow.
+usage: python3 preview.py <concept.png> <blockout.json> <out.png>"""
+import json, math, sys, os
+sys.path.insert(0, os.path.dirname(__file__))
+from cam import to_px, IMG
+from PIL import Image, ImageDraw
+
+def ry(v, deg):
+    a = math.radians(deg); x, y, z = v
+    return (x * math.cos(a) + z * math.sin(a), y, -x * math.sin(a) + z * math.cos(a))
+def rx(v, deg):
+    a = math.radians(deg); x, y, z = v
+    return (x, y * math.cos(a) - z * math.sin(a), y * math.sin(a) + z * math.cos(a))
+
+def rz(v, deg):
+    a = math.radians(deg); x, y, z = v
+    return (x * math.cos(a) - y * math.sin(a), x * math.sin(a) + y * math.cos(a), z)
+
+def edges(o):
+    k = o["kind"]; P = o.get("pos", [0, 0, 0]); yaw = o.get("yaw", 0); rxd = o.get("rot_x", 0); rzd = o.get("rot_z", 0)
+    S = o.get("scale", [1, 1, 1])
+    def w(v):
+        v = (v[0] * S[0], v[1] * S[1], v[2] * S[2])
+        v = ry(rx(rz(v, rzd), rxd), yaw)
+        return (P[0] + v[0], P[1] + v[1], P[2] + v[2])
+    if k == "box":
+        sx, sy, sz = [s / 2 for s in o["size"]]
+        c = [(x, y, z) for x in (-sx, sx) for y in (-sy, sy) for z in (-sz, sz)]
+        E = [(a, b) for a in range(8) for b in range(a + 1, 8) if bin(a ^ b).count("1") == 1]
+        return [(w(c[a]), w(c[b])) for a, b in E]
+    if k == "prism":
+        sx, sy, sz = [s / 2 for s in o["size"]]
+        v = {"l0": (-sx, -sy, -sz), "r0": (sx, -sy, -sz), "a0": (0, sy, -sz), "l1": (-sx, -sy, sz), "r1": (sx, -sy, sz), "a1": (0, sy, sz)}
+        E = [("l0", "r0"), ("r0", "a0"), ("a0", "l0"), ("l1", "r1"), ("r1", "a1"), ("a1", "l1"), ("l0", "l1"), ("r0", "r1"), ("a0", "a1")]
+        return [(w(v[a]), w(v[b])) for a, b in E]
+    if k in ("cyl", "sphere"):
+        out = []
+        if k == "cyl":
+            rings = [(0, o["r_bot"]), (o["height"], o["r_top"])]
+        else:
+            r = o["radius"]; sy = o.get("sy", 1)
+            rings = [(r * sy * math.sin(t), r * math.cos(t)) for t in (-0.9, -0.45, 0, 0.45, 0.9)]
+        for (hy, r) in rings:
+            pts = [(P[0] + r * math.cos(a * math.pi / 12), P[1] + hy, P[2] + r * math.sin(a * math.pi / 12)) for a in range(25)]
+            out += list(zip(pts, pts[1:]))
+        return out
+    if k == "poly":
+        pts = [(x, o["top"], z) for x, z in o["points"]]
+        return list(zip(pts, pts[1:] + pts[:1]))
+    return []
+
+src, js, dst = sys.argv[1:4]
+im = Image.open(src).convert("RGB").resize(IMG)
+d = ImageDraw.Draw(im)
+for o in json.load(open(js))["objects"]:
+    for a, b in edges(o):
+        d.line([to_px(a), to_px(b)], fill=(255, 30, 30), width=2)
+im.save(dst)

package/library/skills/painted-25d-world/resource.yaml

@@ -0,0 +1,39 @@
+id: skill/painted-25d-world
+kind: skill
+version: 1.0.0
+summary: "Build a 2D or 2.5D game as a painted world: a 3D blockout under one fixed camera, an AI paint-over projected onto it, sprite characters."
+use_when:
+  - the user asks for a 2D game, a 2.5D game, a top-down RPG, a cozy village or farming game, a dungeon crawler look, or a side-scroller — build the world as a painted 2.5D world, not from a 2D template
+  - the user wants a game that looks like a hand-painted illustration but can be walked around in, with buildings to enter
+  - making a level from a concept image — rebuild the concept as blocks, paint over the blockout render, project the painting onto the blocks
+  - adding sprite characters, interiors or weapons to a painted 2.5D world
+do_not_use_when:
+  - the user explicitly wants pixel-art tiles or a classic 2D tile map — use pixel-art and the 2D genre playbooks in make-game
+  - the game is full 3D with a free camera (third-person, FPS) — the painting only holds from one camera direction
+facets:
+  lifecycle:
+    - build
+  domains:
+    - 2d
+    - level-design
+    - rendering
+    - assets
+  modalities:
+    - images
+    - scenes
+    - scripts
+    - shaders
+compatibility:
+  engine: ">=4.6"
+related:
+  skills:
+    - skill/make-game
+    - skill/new-project
+    - skill/concept-art
+    - skill/sprite-sheet
+    - skill/scene-composition
+source: official
+license: MIT
+status: preview
+recommended: false
+bundled: false

package/library/skills/publish-your-game/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: publish-your-game
-description: "Publish a game on Summer Games through MCP: store page, art, build upload, submit, owner approval link."
+description: "Publish a game on Summer Games over MCP: store page, art, build upload, go live."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: deployment
@@ -10,7 +10,7 @@ allowed-tools: summer_docs_read
 
 # /publish-your-game — publish your game
 
-This skill covers the whole publishing journey: find the game, make its store page, write the text, set the art, export and upload the build, submit, and hand the owner the approval link.
+This skill covers the whole publishing journey: find the game, make its store page, write the text, set the art, export and upload the build, and take it live.
 
 Its current text lives on the hosted Summer Engine MCP, the same text the Studio agent reads, so it changes with the store and is never stale here. Load it before you act:
 
@@ -25,14 +25,16 @@ A call written `area.action({...})` is the tool `summer_area_action` when your c
 1. `games.list()` finds the game; `games.create({ title, targets })` makes a new one with its first store page draft. Include `web` in `targets` so it plays in the browser. Keep the `gameId`.
 2. `store.get_listing({ gameId })` reads the page: text per store, art per slot, the publish checklist and the tags a page can pick.
 3. `store.update_listing`, `store.set_art`, `store.set_trailer` and `store.set_sound` fill it until `readyToPublish` is true. Editing never publishes.
-4. Export with `summer_export_game`, run `release-readiness` on the exact `.zip`, and report each check to the owner; a hosted game's upload checks can pass while every online join fails. Then upload it: `store.upload_file({ gameId, clientVersion, confirm: true })` from this machine once the owner approved the exact file and version, or `store.upload_begin` (`kind` bundle, web or download), `store.upload_sign_parts` and `store.upload_complete` with the bytes. Finishing answers a job: `jobs.wait({ jobId })` until Summer's checks are done.
-5. `store.publish({ gameId, price, note, idempotencyKey })` asks the owner; `price` is `{ currency: "USD", amountMinor }` in cents (0 is free), omitted it keeps the current price. It answers `needs_approval` with the owner's link and a job. Give the owner the link; `jobs.wait({ jobId })` returns once they answer.
-6. `store.status({ gameId })` shows Summer's review decision and feedback, every upload, what players get now, and one next step.
-7. A store bundle goes to players with `store.release({ gameId, idempotencyKey })` once Summer approved the game: it releases only the build the owner approved, and answers a job. Web builds and downloads need no release.
+4. Export with `summer_export_game`, run `release-readiness` on the exact `.zip`, and report each check to the owner; a hosted game's upload checks can pass while every online join fails. Then upload it with `summer_publish_build({ gameId, clientVersion, confirm: true })` once the owner approved the exact file and version. It waits for Summer's automated checks and answers each platform's result (`checks`), with the fix for a failed one.
+5. Run the `release-checklist` skill: the export, the upload's checks, the store art and every listing detail. `summer_store_set_details` fills the sections `store.update_listing` does not edit: the content questionnaire, the AI disclosure, genres, features, credits, languages and system requirements.
+6. `summer_go_live({ gameId, publicationId })` shows the plan; after the owner approves going live, call it again with `confirm: true`. It releases the Build to the platforms that passed, publishes the store page and watches until players get it, or names the failing check and its fix. Web builds and downloads go live with the page. It needs no owner approval link while the person's Agent permissions allow Publish (the default); with Publish off it answers `needs_permission`, and `store.publish` returns a link for the owner instead.
+7. `store.status({ gameId })` shows every upload, what players get now on each platform, and Summer's decision when there is one.
 
-The one rule to keep even before you load it: Asking does not publish. `store.publish` returns an approval link; only the owner's click sends the game to review, and review comes before live.
+To have the agent gather everything from the project and do these steps itself (export and upload, real screenshots, store art, listing text and details), with one confirmation before going live, use the `launch-ready` skill (`summer_docs_read` with id `skill/launch-ready`).
 
-After the review: when `store.status` says `review.needsChanges`, fix every point in `review.feedback`, then call `store.publish` again with a new `idempotencyKey`; the owner approves the resubmission. If there is no written feedback, say so and ask the owner instead of guessing. The game is not live until Summer approves it.
+The one rule to keep even before you load it: a game goes live as soon as Summer's automated checks pass. Summer's staff review it after it is live, so never tell the creator to wait for a review. When `summer_go_live` answers `waiting` with `waitingOn: "summer"`, every check passed and the platform is still holding the launch on Summer's side: nothing to fix, and it goes live by itself; call again to keep watching.
+
+When Summer sends the page back (`needs_changes`, or `store.status` `review.needsChanges`), fix every point in the feedback with `store.update_listing`, then call `summer_go_live` again. If there is no written feedback, say so and ask the owner instead of guessing.
 
 <!-- shell-commands: generated from the operation catalog by npm run generate:registry; do not edit by hand -->
 ## From a shell
@@ -45,18 +47,15 @@ No Summer MCP tools in this session? Run each one as a command; when `summer --v
 | `summer_export_game` | `summer engine export-game` |
 | `games.create` | `summer games create` |
 | `games.list` | `summer games list` |
-| `jobs.wait` | `summer jobs wait` |
 | `summer_search` | `summer ops search "<what you want>"` |
 | `store.get_listing` | `summer store get-listing` |
+| `summer_go_live` | `summer store go-live` |
 | `store.publish` | `summer store publish` |
-| `store.release` | `summer store release` |
 | `store.set_art` | `summer store set-art` |
+| `summer_store_set_details` | `summer store set-details` |
 | `store.set_sound` | `summer store set-sound` |
 | `store.set_trailer` | `summer store set-trailer` |
 | `store.status` | `summer store status` |
 | `store.update_listing` | `summer store update-listing` |
-| `store.upload_begin` | `summer store upload-begin` |
-| `store.upload_complete` | `summer store upload-complete` |
-| `store.upload_file` | `summer store upload-file` |
-| `store.upload_sign_parts` | `summer store upload-sign-parts` |
+| `summer_publish_build` | `summer store upload-file` |
 <!-- /shell-commands -->

package/library/skills/publish-your-game/resource.yaml

@@ -1,10 +1,10 @@
 id: skill/publish-your-game
 kind: skill
 version: 1.0.0
-summary: "Publish a game on Summer Games through MCP: store page, art, build upload, submit, owner approval link."
+summary: "Publish a game on Summer Games over MCP: store page, art, build upload, go live."
 use_when:
-  - "the user says 'publish my game', 'put it on summer.games', 'launch it on the store' or 'submit it for review'"
-  - "taking a built Summer game to a submitted store page: listing text, art, build upload, store.publish and the owner's approval link"
+  - "the user says 'publish my game', 'put it on summer.games', 'launch it on the store' or 'make it live'"
+  - "taking a built Summer game to live: listing text, art, build upload, the release checklist and summer_go_live"
   - "an agent publishes for the owner end to end and needs the order of the store.* operations"
 do_not_use_when:
   - "only producing a local export build — skill/export-and-ship"
@@ -22,6 +22,7 @@ related:
     - skill/store-art
     - skill/grow-analytics
     - skill/export-and-ship
+    - skill/release-checklist
 hosted_resource: "summer://skills/publish-your-game"
 source: official
 license: MIT

package/library/skills/release-checklist/SKILL.md

@@ -0,0 +1,188 @@
+---
+name: release-checklist
+description: "Pre-launch check for Summer Games: export, upload checks, store art, listing fields."
+license: MIT
+compatibility: [Cursor, Claude Code, Windsurf, Codex]
+category: deployment
+user-invocable: true
+allowed-tools: Read Grep Glob summer_export_game summer_publish_build summer_go_live summer_store_set_details
+---
+
+# /release-checklist: everything Summer Games needs before it goes live
+
+Run this before you take a game live with `summer_go_live`, and again when
+`summer_go_live` answers `blocked`. It has four parts, in the order of the
+release:
+
+1. the build exported properly;
+2. the build uploaded and passed Summer's automated checks;
+3. the store art is there and has the right shapes;
+4. every required listing detail is filled in.
+
+Each rule says how to check it with an MCP tool, what passes, how to fix a
+failure, and where the rule comes from. "Platform" rules are enforced by
+Summer's management API: a page or build that breaks one is refused. "Store"
+rules are the publish checklist Studio and `store.publish` apply to every
+page (`store.get_listing` returns it as `checklist` and `readyToPublish`); the
+platform accepts a page without them, but it is a poor page. Follow both.
+
+This checklist checks files and fields. Whether a player can actually play
+the release (online join, saves, phones) is the `release-readiness` skill:
+run it on the same `.zip` before you upload.
+
+To have the agent make every failing rule pass (export and upload, capture
+screenshots, make the art, write the listing, then go live with one
+confirmation), use the `launch-ready` skill (`summer_docs_read` with id
+`skill/launch-ready`).
+
+## Going live has no staff wait
+
+A game goes live as soon as Summer's automated checks pass: the malware scan,
+the secrets scan, the per-platform checks and the publish pipeline. Summer's
+staff review the game after it is live. So:
+
+- Never tell the creator to wait for a review, and never say a game is "in
+  review" as a step they must sit through.
+- When `summer_go_live` answers `waiting` with `waitingOn: "summer"`, every
+  check passed and the platform is still holding the launch on Summer's
+  side. Say exactly that: nothing to fix, nothing to ask for, and the request
+  goes live by itself. Call `summer_go_live` again to keep watching.
+- When Summer sent the page back (`needs_changes`), report the decision and
+  every line of its feedback, fix them, and go live again.
+
+## How to report
+
+Report one line per rule:
+
+- **pass**, with the evidence (the tool and the field you read);
+- **fail**, with what you saw and the fix;
+- **not applicable**, with the reason (for example, no server);
+- **not run**, with what is still needed.
+
+A rule that was not run is not a pass. Show the list to the user before you
+change anything; they decide what to fix. Ask before every upload and before
+going live: `summer_publish_build` and `summer_go_live` both preview first
+and need `confirm: true`.
+
+## 1. The build exported properly
+
+Export with `summer_export_game` (format `bundle`, the default) and read its
+answer.
+
+| Rule | Check | Pass | Fix | Source |
+| --- | --- | --- | --- | --- |
+| 1.1 The summer.games preset made it | `preset`, `format`, `debug` | `format` is `bundle`, `preset` is `summer.games` (or the `summer.games` preset the targets made), `debug` is false | Export again with `summer_export_game` and no `debug` | Engine `modules/1summer_engine/editor` (the summer.games export platform); platform `docs/build-publications.md` |
+| 1.2 A released Summer version | `bundle.summerVersion` | A Summer release (`X.Y.Z`); for `ios` or `android`, the same MAJOR.MINOR as the current Summer release | Update Summer Engine to the current release, export again | Platform `internal/clientartifacts/template.go` (same MAJOR.MINOR, a template patch at least the pack's); refusal `engine_build_unreleased`; `release-readiness` check 9 |
+| 1.3 The fixed export layout | `bundle.schema`, `bundle.paths` | `summer.bundle.v2` holds only these 6 paths: `summer-bundle.json`, `client.pck`, `config/summer.build.json` (always), `server.pck` (a game with a server only), `config/world-definitions.json` (only when the build declares queues), `config/world-support.json` (only when a World definition names a file). An older engine writes `summer.bundle.v1`, which the store still takes | Never add or rename a file in the `.zip`: upload it as Summer Engine wrote it. An extra path means the export is not from the summer.games preset; export again | Platform `docs/build-publications.md` "summer.games bundle layout", enforced by `internal/clientartifacts/bundle_layout.go` |
+| 1.4 A server pack when the game has a server | `bundle.hosted`, `bundle.paths` | A game with a server (multiplayer on Summer's servers) has `hosted: true` and `server.pck`; a game without one has neither | Set up the server export (the `multiplayer-publish` skill), export again | Platform `internal/clientartifacts/exported_game.go` (manifest `server` and `compositionPath` together) |
+| 1.5 The right platforms | `bundle.targetPlatforms`, `warnings` | No warning; a game without a server lists only `ios` and `android` (desktop and web ship as downloads, format `download`); a game with a server declares the same platforms in `summer.build.json` | `summer_export_game` with `targets` and, for a server game, `alignDeclaration: true` | Platform refusals `declaration_mismatch`, `template_execution_unsupported` (`api/management/openapi.yaml`, build-publications) |
+
+For web and desktop downloads (`format: "download"`), check instead that the
+`.zip` is under 500 MiB with `index.html` at its top (web), or the `.app` or
+`.exe` for macOS or Windows; `summer_publish_build` refuses the rest before
+it sends anything.
+
+## 2. The build uploaded and passed the automated checks
+
+Upload with `summer_publish_build` (preview first, then `confirm: true`). It
+waits for Summer's checks and answers with each one.
+
+| Rule | Check | Pass | Fix | Source |
+| --- | --- | --- | --- | --- |
+| 2.1 Summer made the Build | `status`, `state` | `status` is `uploaded` (or `published`); a refusal comes back as an error with `code` and `recovery` | Do what `recovery` says. A refused upload usually leaves the `clientVersion` free (`bundle_invalid`, `declaration_mismatch`); a new export needs a new one | Platform build-publication intake codes (`api/management/openapi.yaml`, `:source-complete`) |
+| 2.2 The malware scan passed | intake error code | No `malware_detected` or `malware_scan_unsupported`. A scan still running is a wait, never a failure: the tool keeps waiting | Clean the project's files and plugins, export again on a clean machine | Platform `docs/build-publications.md` (GuardDuty tags) |
+| 2.3 The secrets scan passed (game with a server) | intake error code | No `verifying_failed` | Remove the key or password from the project, revoke it, export again | Platform `docs/build-publications.md` (Trivy secrets in the server image) |
+| 2.4 Every platform check passed | `checksState`, `checks[]` | `checksState` is `passed`: every platform `passed`. `checking` means call `summer_publish_build` again with the same file and version | Each failed check has `code`, `owner` and `fix`. `owner: "creator"`: apply the fix, export again, upload with a new `clientVersion`. `owner: "summer"`: nothing to change | Platform `docs/client-pack-publication.md`, `internal/management/client_verification.go` |
+| 2.5 Web builds and downloads are checked | `summer_publish_build` answer for a download, or `store.status` uploads | Each is `ready` | `rejected` names its reason: fix it, export the download again, upload it | Platform store versions (`awaiting_upload`, `processing`, `ready`, `rejected`) |
+
+A hosted game's `web` check fails with `client_platform_unavailable` while
+its phone and desktop checks pass: that is expected, and `summer_go_live`
+releases the platforms that passed. Ship web for such a game as a download.
+
+## 3. The store art is there
+
+Read the art with `store.get_listing`: `art` per slot, and the `checklist`
+items for each slot.
+
+| Rule | Slot | Pass | Kind | Source |
+| --- | --- | --- | --- | --- |
+| 3.1 Every image is verified | all | No checklist item names a refused or unchecked image | Platform: `store_page_incomplete` with `media` | Platform `internal/creatorcatalog/submission.go` |
+| 3.2 Every filled slot fits its shape | all | No checklist item names a shape problem | Platform: `store_page_incomplete` with `mediaSlots`, sizes below | Platform `internal/storefront/slot_shapes.go` (within 2%) |
+| 3.3 Desktop key art | `desktop.keyArt` | Present, 16:9, at least 1920x1080, no text | Store, desktop targets | PSE `src/lib/creator-store/store-slots.ts` |
+| 3.4 Desktop screenshots | `desktop.screenshots` | 4 to 8, 16:9, at least 1920x1080, real play | Store, desktop targets | PSE `store-slots.ts`, `listing-spec.ts` |
+| 3.5 Icons | `desktop.icon`, `mobile.icon` | Square, at least 512 (1024 is best), no words | Store; platform checks the shape | PSE `store-slots.ts`; platform `slot_shapes.go` |
+| 3.6 Mobile key art | `mobile.keyArt` | 16:9, at least 1920x1080, no text | Store, phone targets; platform checks the shape | Same |
+| 3.7 Mobile screenshots | `mobile.screenshots` | 3 to 8, 16:9 to 19.5:9 either way, short side at least 1080 | Store, phone targets; platform checks the shape | Same |
+| 3.8 Tall cover | `mobile.tallCover` | 9:16 to 9:19.5, at least 1080x1920, no text | Store warning only (cropped from the key art when missing) | Same |
+| 3.9 Capsules | `desktop.capsuleTall` 3:4 at least 600x800, `desktop.capsuleWide` 460:215 at least 920x430 | Optional (cropped from the key art at its focal point); the logo is allowed | Store, optional | Same |
+| 3.10 At most 20 images and videos | all | 20 or fewer on the page | Store and platform (`mediaAssetIds` at most 20) | PSE `MEDIA_BUDGET`; platform `api/management/openapi.yaml` |
+
+Fix: make or capture the image (the `store-art` skill; `summer_capture_gameplay`
+for real screenshots) and put it in its slot with `store.set_art`. A trailer
+is optional (`store.set_trailer`).
+
+## 4. Every required listing detail is filled in
+
+Read `store.get_listing` (text, `checklist`, `readyToPublish`) and, for price,
+`pricing.get`.
+
+| Rule | Field | Pass | Kind | Fix | Source |
+| --- | --- | --- | --- | --- | --- |
+| 4.1 Title | `title` | 1 to 60 characters | Platform requires one (max 120); store max 60 | `store.update_listing` title | Platform `internal/creatorcatalog/types.go`; PSE `listing-spec.ts` |
+| 4.2 Tagline | desktop and mobile tagline | 1 to 80 characters | Store | `store.update_listing` desktop.tagline, mobile.tagline | PSE `listing-spec.ts`, `store-slots.ts` |
+| 4.3 Short description | desktop and mobile description | Desktop 120 to 300 characters; mobile 120 to 170 | Platform requires one; store sets the lengths | `store.update_listing` desktop.description, mobile.description | Same |
+| 4.4 Long description | `longDescription` | Optional; up to 12000 characters | Optional | `store.update_listing` longDescription | Platform `internal/storefront/listing_fields.go` |
+| 4.5 Tags | `tags` | 3 to 8 from the store's tag list | Store | `store.update_listing` desktop.tags | PSE `listing-spec.ts` |
+| 4.6 Genres and features | `genres`, `features` | Optional; 1 to 5 genre tags, features from the closed list | Optional (shown on the page) | `summer_store_set_details` | Platform `listing_fields.go`; openapi `GameGenres`, `GameFeatures` |
+| 4.7 Supported platforms | `targets` | At least one, and every platform the build was exported for | Platform | `store.update_listing` targets | Platform `internal/gameplatforms/platforms.go` |
+| 4.8 Age rating | `contentRating`, `contentDescriptors` | A rating (`everyone`, `everyone10Plus`, `teen`) and descriptors answered (an empty list when none apply) | Platform: `store_page_incomplete` | `store.update_listing` contentRating, contentDescriptors | Platform `internal/creatorcatalog/types.go`, `internal/contentrating/contentrating.go` |
+| 4.9 Content questionnaire | `contentSurvey` | Answered in full when the game has any mature content, user content, online interaction or purchases | Optional on the platform; every answer is required once given | `summer_store_set_details` contentSurvey | Platform `internal/storefront/page_fields.go` |
+| 4.10 AI disclosure | `aiDisclosure` | Says how AI made the game (`assets`, `code`, `generatedGameplay`, or `[]` for none); `generatedGameplay` has a description | Optional on the platform; always fill it, honestly | `summer_store_set_details` aiDisclosure | Platform `page_fields.go` |
+| 4.11 Support contact | support link | An https or `mailto:` support link | Optional | `store.update_listing` support | Platform `listing_fields.go` (`externalLinks` kind support) |
+| 4.12 Release stage | `release` | Chosen on purpose: `released` needs a playable build on a listed platform; `in_development` lists the game only on the In development page | Platform for released pages (`playable_release_required`) | `store.update_listing` release | Platform `internal/storefront/release.go`, `playable_page.go` |
+| 4.13 Price | `pricing.get` | Free, or the price the owner chose | Not checked at publish. A price can be set only once the creator's Stripe seller account takes payments (`seller_setup_required` otherwise; the game stays free), and only the owner sets that up, in Studio | `pricing.set_base` | Platform `PUT /games/{gameId}/price` (`api/management/openapi.yaml`) |
+| 4.14 Legal text | none | Nothing to fill: the store page has no EULA, terms or privacy field; players accept Summer's terms | Not applicable | None | Platform `api/management/openapi.yaml` (no such field) |
+
+Never invent features, modes, player counts, awards or prices: the
+`store-listing` skill has the writing rules.
+
+## Then go live
+
+When every rule passes (or the user accepted an open one), call
+`summer_go_live` with the `gameId` and the `publicationId` from
+`summer_publish_build`. Its first answer is the plan: show it to the user,
+then call again with `confirm: true`. It releases the Build to the platforms
+that passed, publishes the store page and watches until players get it:
+
+- `live`: report it, and ask the user to check it as a player on summer.games
+  and in the Summer Games apps;
+- `blocked`: each failure has a fix; apply them and run the failed part of
+  this checklist again;
+- `waiting`: say what it waits on (above), call again to keep watching;
+- `needs_permission`: the person's Agent permissions have Publish off: ask
+  them to turn it on (Studio > Agent permissions), or use `store.publish`,
+  which returns a link for the owner to approve;
+- `needs_changes`: Summer sent the page back; fix every line of feedback.
+
+<!-- shell-commands: generated from the operation catalog by npm run generate:registry; do not edit by hand -->
+## From a shell
+
+No Summer MCP tools in this session? Run each one as a command; when `summer --version` is missing or below 4.0, use `npx -y summer-engine@latest` in place of `summer`. Fields are flags in kebab-case (`--scene-path res://main.tscn`) or one `--input '<json>'`, and `summer ops describe <op>` prints the exact input. The `summer-cli` skill has the rest.
+
+| In this skill | Command |
+|---|---|
+| `summer_docs_read` | `summer docs read` |
+| `summer_capture_gameplay` | `summer engine capture-gameplay` |
+| `summer_export_game` | `summer engine export-game` |
+| `pricing.get` | `summer pricing get` |
+| `pricing.set_base` | `summer pricing set-base` |
+| `store.get_listing` | `summer store get-listing` |
+| `summer_go_live` | `summer store go-live` |
+| `store.publish` | `summer store publish` |
+| `store.set_art` | `summer store set-art` |
+| `summer_store_set_details` | `summer store set-details` |
+| `store.set_trailer` | `summer store set-trailer` |
+| `store.status` | `summer store status` |
+| `store.update_listing` | `summer store update-listing` |
+| `summer_publish_build` | `summer store upload-file` |
+<!-- /shell-commands -->

package/library/skills/release-checklist/resource.yaml

@@ -0,0 +1,40 @@
+id: skill/release-checklist
+kind: skill
+version: 1.0.0
+summary: "Pre-launch check for Summer Games: export, upload checks, store art, listing fields."
+use_when:
+  - "the user says 'is it ready to go live', 'check everything before launch' or 'what is missing from my store page'"
+  - "before summer_go_live, or when it answers blocked: checking the export, the upload's automated checks, the store art and the listing fields"
+  - "summer_publish_build reports a failed platform check, or store.get_listing says readyToPublish is false"
+  - "checking the export holds the fixed bundle layout, the right Summer version and a server pack for a hosted build"
+  - "filling the age rating, content questionnaire, AI disclosure, genres or support link before launch"
+do_not_use_when:
+  - "proving players can join, save and play the release on phones — skill/release-readiness"
+  - "exporting for Steam, itch.io or app stores — skill/export-and-ship"
+facets:
+  lifecycle:
+    - launch
+  domains:
+    - creator
+    - deployment
+  modalities:
+    - docs
+compatibility:
+  engine: ">=4.6"
+related:
+  skills:
+    - skill/launch-ready
+    - skill/release-readiness
+    - skill/publish-your-game
+    - skill/store-art
+    - skill/store-listing
+    - skill/multiplayer-publish
+  tools:
+    - tool/export-game
+    - tool/publish-build
+    - tool/go-live
+    - tool/store-set-details
+source: official
+license: MIT
+status: preview
+recommended: false

package/library/skills/release-readiness/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: release-readiness
-description: "Before releasing a Summer game version, prove players can play it: server, online join, progress, files."
+description: "Prove players can play a Summer release: server, online join, progress, files."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: deployment

package/library/skills/release-readiness/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/release-readiness
 kind: skill
 version: 1.0.0
-summary: "Before releasing a Summer game version, prove players can play it: server, online join, progress, files."
+summary: "Prove players can play a Summer release: server, online join, progress, files."
 use_when:
   - "before uploading, promoting or releasing a new version to players: is it ready to release"
   - "every online join fails with world_start_timeout, or the hosted server's log is empty, while Local Play works"

package/library/skills/store-art/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: store-art
-description: "Make Summer Games store art per slot: key art, covers, icons, screenshots, trailer, size and text rules."
+description: "Make Summer Games store art per slot: key art, icons, screenshots, trailer, sizes."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: deployment

package/library/skills/store-art/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/store-art
 kind: skill
 version: 1.0.0
-summary: "Make Summer Games store art per slot: key art, covers, icons, screenshots, trailer, size and text rules."
+summary: "Make Summer Games store art per slot: key art, icons, screenshots, trailer, sizes."
 use_when:
   - "making or choosing store art for Summer Games: key art, cover, icon, screenshots, trailer"
   - "store.set_art rejects an image for its shape or size, or store.get_listing says an art slot is missing"

package/library/skills/store-listing/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: store-listing
-description: "Write a Summer Games store page: title, tagline, descriptions, tags, per platform, and what never to write."
+description: "Write a Summer Games store page: title, tagline, descriptions, tags, what never to write."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: deployment

package/library/skills/store-listing/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/store-listing
 kind: skill
 version: 1.0.0
-summary: "Write a Summer Games store page: title, tagline, descriptions, tags, per platform, and what never to write."
+summary: "Write a Summer Games store page: title, tagline, descriptions, tags, what never to write."
 use_when:
   - "writing or fixing a game's store page text on Summer Games: title, tagline, description, tags"
   - "store.update_listing or store.get_listing says a text field is missing or wrong"

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

@@ -92,12 +92,14 @@ summer run ./my-game                                       # opens the project;
 summer engine get-project-context                          # first call: project, main scene, engine version
 summer engine get-scene-tree --scene-path res://main.tscn --depth 2
 summer engine screenshot                                   # the answer's localPath is an image: open it to look
+summer preview                                             # the game, live, in your own browser: http://127.0.0.1:5199
 ```
 
 - Values are engine value strings, not JSON: `"Vector3(0, 10, 0)"`, `"Color(1, 0.5, 0, 1)"`. A resource is its class name: `"BoxMesh"`.
 - Name the scene in every change: `--scene-path res://<scene>.tscn`.
 - 3 or more scene edits are one script, not a chain of commands. Write a `func run(ctx):` that ends with `ctx.save_scene()` to a file, then run `summer engine run-script --scene-path res://main.tscn --source "$(cat build.gd)"`. The `scene-scripting` skill has the script API.
 - With more than one editor open, set `SUMMER_ENGINE_PROJECT` to the project folder so the command picks the right one.
+- To watch the game in your own browser (Claude Code Desktop's Browser pane, the Codex app's in-app browser), run `summer preview` in the background, from the folder the session started in. It serves http://127.0.0.1:5199 (the next free port if that one is taken; it prints the URL): the running game, or the editor view when no game runs, with a status line that says what to do next. It also adds a `summer-preview` entry to `.claude/launch.json` there, so Desktop starts it and checks the game after each edit. A game frame comes about every 20 s, because reading one stalls the game; the page's Refresh button takes one now. Keys and clicks on the frame go to the running game. `--no-launch-json` leaves the file alone.
 - `summer tool <slug> --args '<json>'` runs an engine tool by its 3.x name too. `summer tool --list` lists them.
 
 ## Without Summer Engine